?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Btrfs-progs: Initialize stripesize to the value of sectorsize
[btrfs-progs-unstable/devel.git] / cmds-check.c
blobec0bbfd0744c51ec973e8c148a224f3a33d4456b
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 "ulist.h"
44
45 enum task_position {
46 TASK_EXTENTS,
47 TASK_FREE_SPACE,
48 TASK_FS_ROOTS,
49 TASK_NOTHING, /* have to be the last element */
50 };
51
52 struct task_ctx {
53 int progress_enabled;
54 enum task_position tp;
55
56 struct task_info *info;
57 };
58
59 static u64 bytes_used = 0;
60 static u64 total_csum_bytes = 0;
61 static u64 total_btree_bytes = 0;
62 static u64 total_fs_tree_bytes = 0;
63 static u64 total_extent_tree_bytes = 0;
64 static u64 btree_space_waste = 0;
65 static u64 data_bytes_allocated = 0;
66 static u64 data_bytes_referenced = 0;
67 static int found_old_backref = 0;
68 static LIST_HEAD(duplicate_extents);
69 static LIST_HEAD(delete_items);
70 static int repair = 0;
71 static int no_holes = 0;
72 static int init_extent_tree = 0;
73 static int check_data_csum = 0;
74 static struct btrfs_fs_info *global_info;
75 static struct task_ctx ctx = { 0 };
76 static struct cache_tree *roots_info_cache = NULL;
77
78 struct extent_backref {
79 struct list_head list;
80 unsigned int is_data:1;
81 unsigned int found_extent_tree:1;
82 unsigned int full_backref:1;
83 unsigned int found_ref:1;
84 unsigned int broken:1;
85 };
86
87 struct data_backref {
88 struct extent_backref node;
89 union {
90 u64 parent;
91 u64 root;
92 };
93 u64 owner;
94 u64 offset;
95 u64 disk_bytenr;
96 u64 bytes;
97 u64 ram_bytes;
98 u32 num_refs;
99 u32 found_ref;
100 };
101
102 /*
103 * Much like data_backref, just removed the undetermined members
104 * and change it to use list_head.
105 * During extent scan, it is stored in root->orphan_data_extent.
106 * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
107 */
108 struct orphan_data_extent {
109 struct list_head list;
110 u64 root;
111 u64 objectid;
112 u64 offset;
113 u64 disk_bytenr;
114 u64 disk_len;
115 };
116
117 struct tree_backref {
118 struct extent_backref node;
119 union {
120 u64 parent;
121 u64 root;
122 };
123 };
124
125 /* Explicit initialization for extent_record::flag_block_full_backref */
126 enum { FLAG_UNSET = 2 };
127
128 struct extent_record {
129 struct list_head backrefs;
130 struct list_head dups;
131 struct list_head list;
132 struct cache_extent cache;
133 struct btrfs_disk_key parent_key;
134 u64 start;
135 u64 max_size;
136 u64 nr;
137 u64 refs;
138 u64 extent_item_refs;
139 u64 generation;
140 u64 parent_generation;
141 u64 info_objectid;
142 u32 num_duplicates;
143 u8 info_level;
144 unsigned int flag_block_full_backref:2;
145 unsigned int found_rec:1;
146 unsigned int content_checked:1;
147 unsigned int owner_ref_checked:1;
148 unsigned int is_root:1;
149 unsigned int metadata:1;
150 unsigned int bad_full_backref:1;
151 unsigned int crossing_stripes:1;
152 unsigned int wrong_chunk_type:1;
153 };
154
155 struct inode_backref {
156 struct list_head list;
157 unsigned int found_dir_item:1;
158 unsigned int found_dir_index:1;
159 unsigned int found_inode_ref:1;
160 unsigned int filetype:8;
161 int errors;
162 unsigned int ref_type;
163 u64 dir;
164 u64 index;
165 u16 namelen;
166 char name[0];
167 };
168
169 struct root_item_record {
170 struct list_head list;
171 u64 objectid;
172 u64 bytenr;
173 u64 last_snapshot;
174 u8 level;
175 u8 drop_level;
176 int level_size;
177 struct btrfs_key drop_key;
178 };
179
180 #define REF_ERR_NO_DIR_ITEM (1 << 0)
181 #define REF_ERR_NO_DIR_INDEX (1 << 1)
182 #define REF_ERR_NO_INODE_REF (1 << 2)
183 #define REF_ERR_DUP_DIR_ITEM (1 << 3)
184 #define REF_ERR_DUP_DIR_INDEX (1 << 4)
185 #define REF_ERR_DUP_INODE_REF (1 << 5)
186 #define REF_ERR_INDEX_UNMATCH (1 << 6)
187 #define REF_ERR_FILETYPE_UNMATCH (1 << 7)
188 #define REF_ERR_NAME_TOO_LONG (1 << 8) // 100
189 #define REF_ERR_NO_ROOT_REF (1 << 9)
190 #define REF_ERR_NO_ROOT_BACKREF (1 << 10)
191 #define REF_ERR_DUP_ROOT_REF (1 << 11)
192 #define REF_ERR_DUP_ROOT_BACKREF (1 << 12)
193
194 struct file_extent_hole {
195 struct rb_node node;
196 u64 start;
197 u64 len;
198 };
199
200 struct inode_record {
201 struct list_head backrefs;
202 unsigned int checked:1;
203 unsigned int merging:1;
204 unsigned int found_inode_item:1;
205 unsigned int found_dir_item:1;
206 unsigned int found_file_extent:1;
207 unsigned int found_csum_item:1;
208 unsigned int some_csum_missing:1;
209 unsigned int nodatasum:1;
210 int errors;
211
212 u64 ino;
213 u32 nlink;
214 u32 imode;
215 u64 isize;
216 u64 nbytes;
217
218 u32 found_link;
219 u64 found_size;
220 u64 extent_start;
221 u64 extent_end;
222 struct rb_root holes;
223 struct list_head orphan_extents;
224
225 u32 refs;
226 };
227
228 #define I_ERR_NO_INODE_ITEM (1 << 0)
229 #define I_ERR_NO_ORPHAN_ITEM (1 << 1)
230 #define I_ERR_DUP_INODE_ITEM (1 << 2)
231 #define I_ERR_DUP_DIR_INDEX (1 << 3)
232 #define I_ERR_ODD_DIR_ITEM (1 << 4)
233 #define I_ERR_ODD_FILE_EXTENT (1 << 5)
234 #define I_ERR_BAD_FILE_EXTENT (1 << 6)
235 #define I_ERR_FILE_EXTENT_OVERLAP (1 << 7)
236 #define I_ERR_FILE_EXTENT_DISCOUNT (1 << 8) // 100
237 #define I_ERR_DIR_ISIZE_WRONG (1 << 9)
238 #define I_ERR_FILE_NBYTES_WRONG (1 << 10) // 400
239 #define I_ERR_ODD_CSUM_ITEM (1 << 11)
240 #define I_ERR_SOME_CSUM_MISSING (1 << 12)
241 #define I_ERR_LINK_COUNT_WRONG (1 << 13)
242 #define I_ERR_FILE_EXTENT_ORPHAN (1 << 14)
243
244 struct root_backref {
245 struct list_head list;
246 unsigned int found_dir_item:1;
247 unsigned int found_dir_index:1;
248 unsigned int found_back_ref:1;
249 unsigned int found_forward_ref:1;
250 unsigned int reachable:1;
251 int errors;
252 u64 ref_root;
253 u64 dir;
254 u64 index;
255 u16 namelen;
256 char name[0];
257 };
258
259 struct root_record {
260 struct list_head backrefs;
261 struct cache_extent cache;
262 unsigned int found_root_item:1;
263 u64 objectid;
264 u32 found_ref;
265 };
266
267 struct ptr_node {
268 struct cache_extent cache;
269 void *data;
270 };
271
272 struct shared_node {
273 struct cache_extent cache;
274 struct cache_tree root_cache;
275 struct cache_tree inode_cache;
276 struct inode_record *current;
277 u32 refs;
278 };
279
280 struct block_info {
281 u64 start;
282 u32 size;
283 };
284
285 struct walk_control {
286 struct cache_tree shared;
287 struct shared_node *nodes[BTRFS_MAX_LEVEL];
288 int active_node;
289 int root_level;
290 };
291
292 struct bad_item {
293 struct btrfs_key key;
294 u64 root_id;
295 struct list_head list;
296 };
297
298 struct extent_entry {
299 u64 bytenr;
300 u64 bytes;
301 int count;
302 int broken;
303 struct list_head list;
304 };
305
306 struct root_item_info {
307 /* level of the root */
308 u8 level;
309 /* number of nodes at this level, must be 1 for a root */
310 int node_count;
311 u64 bytenr;
312 u64 gen;
313 struct cache_extent cache_extent;
314 };
315
316 static void *print_status_check(void *p)
317 {
318 struct task_ctx *priv = p;
319 const char work_indicator[] = { '.', 'o', 'O', 'o' };
320 uint32_t count = 0;
321 static char *task_position_string[] = {
322 "checking extents",
323 "checking free space cache",
324 "checking fs roots",
325 };
326
327 task_period_start(priv->info, 1000 /* 1s */);
328
329 if (priv->tp == TASK_NOTHING)
330 return NULL;
331
332 while (1) {
333 printf("%s [%c]\r", task_position_string[priv->tp],
334 work_indicator[count % 4]);
335 count++;
336 fflush(stdout);
337 task_period_wait(priv->info);
338 }
339 return NULL;
340 }
341
342 static int print_status_return(void *p)
343 {
344 printf("\n");
345 fflush(stdout);
346
347 return 0;
348 }
349
350 /* Compatible function to allow reuse of old codes */
351 static u64 first_extent_gap(struct rb_root *holes)
352 {
353 struct file_extent_hole *hole;
354
355 if (RB_EMPTY_ROOT(holes))
356 return (u64)-1;
357
358 hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
359 return hole->start;
360 }
361
362 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
363 {
364 struct file_extent_hole *hole1;
365 struct file_extent_hole *hole2;
366
367 hole1 = rb_entry(node1, struct file_extent_hole, node);
368 hole2 = rb_entry(node2, struct file_extent_hole, node);
369
370 if (hole1->start > hole2->start)
371 return -1;
372 if (hole1->start < hole2->start)
373 return 1;
374 /* Now hole1->start == hole2->start */
375 if (hole1->len >= hole2->len)
376 /*
377 * Hole 1 will be merge center
378 * Same hole will be merged later
379 */
380 return -1;
381 /* Hole 2 will be merge center */
382 return 1;
383 }
384
385 /*
386 * Add a hole to the record
387 *
388 * This will do hole merge for copy_file_extent_holes(),
389 * which will ensure there won't be continuous holes.
390 */
391 static int add_file_extent_hole(struct rb_root *holes,
392 u64 start, u64 len)
393 {
394 struct file_extent_hole *hole;
395 struct file_extent_hole *prev = NULL;
396 struct file_extent_hole *next = NULL;
397
398 hole = malloc(sizeof(*hole));
399 if (!hole)
400 return -ENOMEM;
401 hole->start = start;
402 hole->len = len;
403 /* Since compare will not return 0, no -EEXIST will happen */
404 rb_insert(holes, &hole->node, compare_hole);
405
406 /* simple merge with previous hole */
407 if (rb_prev(&hole->node))
408 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
409 node);
410 if (prev && prev->start + prev->len >= hole->start) {
411 hole->len = hole->start + hole->len - prev->start;
412 hole->start = prev->start;
413 rb_erase(&prev->node, holes);
414 free(prev);
415 prev = NULL;
416 }
417
418 /* iterate merge with next holes */
419 while (1) {
420 if (!rb_next(&hole->node))
421 break;
422 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
423 node);
424 if (hole->start + hole->len >= next->start) {
425 if (hole->start + hole->len <= next->start + next->len)
426 hole->len = next->start + next->len -
427 hole->start;
428 rb_erase(&next->node, holes);
429 free(next);
430 next = NULL;
431 } else
432 break;
433 }
434 return 0;
435 }
436
437 static int compare_hole_range(struct rb_node *node, void *data)
438 {
439 struct file_extent_hole *hole;
440 u64 start;
441
442 hole = (struct file_extent_hole *)data;
443 start = hole->start;
444
445 hole = rb_entry(node, struct file_extent_hole, node);
446 if (start < hole->start)
447 return -1;
448 if (start >= hole->start && start < hole->start + hole->len)
449 return 0;
450 return 1;
451 }
452
453 /*
454 * Delete a hole in the record
455 *
456 * This will do the hole split and is much restrict than add.
457 */
458 static int del_file_extent_hole(struct rb_root *holes,
459 u64 start, u64 len)
460 {
461 struct file_extent_hole *hole;
462 struct file_extent_hole tmp;
463 u64 prev_start = 0;
464 u64 prev_len = 0;
465 u64 next_start = 0;
466 u64 next_len = 0;
467 struct rb_node *node;
468 int have_prev = 0;
469 int have_next = 0;
470 int ret = 0;
471
472 tmp.start = start;
473 tmp.len = len;
474 node = rb_search(holes, &tmp, compare_hole_range, NULL);
475 if (!node)
476 return -EEXIST;
477 hole = rb_entry(node, struct file_extent_hole, node);
478 if (start + len > hole->start + hole->len)
479 return -EEXIST;
480
481 /*
482 * Now there will be no overlap, delete the hole and re-add the
483 * split(s) if they exists.
484 */
485 if (start > hole->start) {
486 prev_start = hole->start;
487 prev_len = start - hole->start;
488 have_prev = 1;
489 }
490 if (hole->start + hole->len > start + len) {
491 next_start = start + len;
492 next_len = hole->start + hole->len - start - len;
493 have_next = 1;
494 }
495 rb_erase(node, holes);
496 free(hole);
497 if (have_prev) {
498 ret = add_file_extent_hole(holes, prev_start, prev_len);
499 if (ret < 0)
500 return ret;
501 }
502 if (have_next) {
503 ret = add_file_extent_hole(holes, next_start, next_len);
504 if (ret < 0)
505 return ret;
506 }
507 return 0;
508 }
509
510 static int copy_file_extent_holes(struct rb_root *dst,
511 struct rb_root *src)
512 {
513 struct file_extent_hole *hole;
514 struct rb_node *node;
515 int ret = 0;
516
517 node = rb_first(src);
518 while (node) {
519 hole = rb_entry(node, struct file_extent_hole, node);
520 ret = add_file_extent_hole(dst, hole->start, hole->len);
521 if (ret)
522 break;
523 node = rb_next(node);
524 }
525 return ret;
526 }
527
528 static void free_file_extent_holes(struct rb_root *holes)
529 {
530 struct rb_node *node;
531 struct file_extent_hole *hole;
532
533 node = rb_first(holes);
534 while (node) {
535 hole = rb_entry(node, struct file_extent_hole, node);
536 rb_erase(node, holes);
537 free(hole);
538 node = rb_first(holes);
539 }
540 }
541
542 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
543
544 static void record_root_in_trans(struct btrfs_trans_handle *trans,
545 struct btrfs_root *root)
546 {
547 if (root->last_trans != trans->transid) {
548 root->track_dirty = 1;
549 root->last_trans = trans->transid;
550 root->commit_root = root->node;
551 extent_buffer_get(root->node);
552 }
553 }
554
555 static u8 imode_to_type(u32 imode)
556 {
557 #define S_SHIFT 12
558 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
559 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
560 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
561 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
562 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
563 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
564 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
565 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
566 };
567
568 return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
569 #undef S_SHIFT
570 }
571
572 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
573 {
574 struct device_record *rec1;
575 struct device_record *rec2;
576
577 rec1 = rb_entry(node1, struct device_record, node);
578 rec2 = rb_entry(node2, struct device_record, node);
579 if (rec1->devid > rec2->devid)
580 return -1;
581 else if (rec1->devid < rec2->devid)
582 return 1;
583 else
584 return 0;
585 }
586
587 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
588 {
589 struct inode_record *rec;
590 struct inode_backref *backref;
591 struct inode_backref *orig;
592 struct inode_backref *tmp;
593 struct orphan_data_extent *src_orphan;
594 struct orphan_data_extent *dst_orphan;
595 size_t size;
596 int ret;
597
598 rec = malloc(sizeof(*rec));
599 if (!rec)
600 return ERR_PTR(-ENOMEM);
601 memcpy(rec, orig_rec, sizeof(*rec));
602 rec->refs = 1;
603 INIT_LIST_HEAD(&rec->backrefs);
604 INIT_LIST_HEAD(&rec->orphan_extents);
605 rec->holes = RB_ROOT;
606
607 list_for_each_entry(orig, &orig_rec->backrefs, list) {
608 size = sizeof(*orig) + orig->namelen + 1;
609 backref = malloc(size);
610 if (!backref) {
611 ret = -ENOMEM;
612 goto cleanup;
613 }
614 memcpy(backref, orig, size);
615 list_add_tail(&backref->list, &rec->backrefs);
616 }
617 list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
618 dst_orphan = malloc(sizeof(*dst_orphan));
619 if (!dst_orphan) {
620 ret = -ENOMEM;
621 goto cleanup;
622 }
623 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
624 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
625 }
626 ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
627 BUG_ON(ret < 0);
628
629 return rec;
630
631 cleanup:
632 if (!list_empty(&rec->backrefs))
633 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
634 list_del(&orig->list);
635 free(orig);
636 }
637
638 if (!list_empty(&rec->orphan_extents))
639 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
640 list_del(&orig->list);
641 free(orig);
642 }
643
644 free(rec);
645
646 return ERR_PTR(ret);
647 }
648
649 static void print_orphan_data_extents(struct list_head *orphan_extents,
650 u64 objectid)
651 {
652 struct orphan_data_extent *orphan;
653
654 if (list_empty(orphan_extents))
655 return;
656 printf("The following data extent is lost in tree %llu:\n",
657 objectid);
658 list_for_each_entry(orphan, orphan_extents, list) {
659 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
660 orphan->objectid, orphan->offset, orphan->disk_bytenr,
661 orphan->disk_len);
662 }
663 }
664
665 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
666 {
667 u64 root_objectid = root->root_key.objectid;
668 int errors = rec->errors;
669
670 if (!errors)
671 return;
672 /* reloc root errors, we print its corresponding fs root objectid*/
673 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
674 root_objectid = root->root_key.offset;
675 fprintf(stderr, "reloc");
676 }
677 fprintf(stderr, "root %llu inode %llu errors %x",
678 (unsigned long long) root_objectid,
679 (unsigned long long) rec->ino, rec->errors);
680
681 if (errors & I_ERR_NO_INODE_ITEM)
682 fprintf(stderr, ", no inode item");
683 if (errors & I_ERR_NO_ORPHAN_ITEM)
684 fprintf(stderr, ", no orphan item");
685 if (errors & I_ERR_DUP_INODE_ITEM)
686 fprintf(stderr, ", dup inode item");
687 if (errors & I_ERR_DUP_DIR_INDEX)
688 fprintf(stderr, ", dup dir index");
689 if (errors & I_ERR_ODD_DIR_ITEM)
690 fprintf(stderr, ", odd dir item");
691 if (errors & I_ERR_ODD_FILE_EXTENT)
692 fprintf(stderr, ", odd file extent");
693 if (errors & I_ERR_BAD_FILE_EXTENT)
694 fprintf(stderr, ", bad file extent");
695 if (errors & I_ERR_FILE_EXTENT_OVERLAP)
696 fprintf(stderr, ", file extent overlap");
697 if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
698 fprintf(stderr, ", file extent discount");
699 if (errors & I_ERR_DIR_ISIZE_WRONG)
700 fprintf(stderr, ", dir isize wrong");
701 if (errors & I_ERR_FILE_NBYTES_WRONG)
702 fprintf(stderr, ", nbytes wrong");
703 if (errors & I_ERR_ODD_CSUM_ITEM)
704 fprintf(stderr, ", odd csum item");
705 if (errors & I_ERR_SOME_CSUM_MISSING)
706 fprintf(stderr, ", some csum missing");
707 if (errors & I_ERR_LINK_COUNT_WRONG)
708 fprintf(stderr, ", link count wrong");
709 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
710 fprintf(stderr, ", orphan file extent");
711 fprintf(stderr, "\n");
712 /* Print the orphan extents if needed */
713 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
714 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
715
716 /* Print the holes if needed */
717 if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
718 struct file_extent_hole *hole;
719 struct rb_node *node;
720 int found = 0;
721
722 node = rb_first(&rec->holes);
723 fprintf(stderr, "Found file extent holes:\n");
724 while (node) {
725 found = 1;
726 hole = rb_entry(node, struct file_extent_hole, node);
727 fprintf(stderr, "\tstart: %llu, len: %llu\n",
728 hole->start, hole->len);
729 node = rb_next(node);
730 }
731 if (!found)
732 fprintf(stderr, "\tstart: 0, len: %llu\n",
733 round_up(rec->isize, root->sectorsize));
734 }
735 }
736
737 static void print_ref_error(int errors)
738 {
739 if (errors & REF_ERR_NO_DIR_ITEM)
740 fprintf(stderr, ", no dir item");
741 if (errors & REF_ERR_NO_DIR_INDEX)
742 fprintf(stderr, ", no dir index");
743 if (errors & REF_ERR_NO_INODE_REF)
744 fprintf(stderr, ", no inode ref");
745 if (errors & REF_ERR_DUP_DIR_ITEM)
746 fprintf(stderr, ", dup dir item");
747 if (errors & REF_ERR_DUP_DIR_INDEX)
748 fprintf(stderr, ", dup dir index");
749 if (errors & REF_ERR_DUP_INODE_REF)
750 fprintf(stderr, ", dup inode ref");
751 if (errors & REF_ERR_INDEX_UNMATCH)
752 fprintf(stderr, ", index mismatch");
753 if (errors & REF_ERR_FILETYPE_UNMATCH)
754 fprintf(stderr, ", filetype mismatch");
755 if (errors & REF_ERR_NAME_TOO_LONG)
756 fprintf(stderr, ", name too long");
757 if (errors & REF_ERR_NO_ROOT_REF)
758 fprintf(stderr, ", no root ref");
759 if (errors & REF_ERR_NO_ROOT_BACKREF)
760 fprintf(stderr, ", no root backref");
761 if (errors & REF_ERR_DUP_ROOT_REF)
762 fprintf(stderr, ", dup root ref");
763 if (errors & REF_ERR_DUP_ROOT_BACKREF)
764 fprintf(stderr, ", dup root backref");
765 fprintf(stderr, "\n");
766 }
767
768 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
769 u64 ino, int mod)
770 {
771 struct ptr_node *node;
772 struct cache_extent *cache;
773 struct inode_record *rec = NULL;
774 int ret;
775
776 cache = lookup_cache_extent(inode_cache, ino, 1);
777 if (cache) {
778 node = container_of(cache, struct ptr_node, cache);
779 rec = node->data;
780 if (mod && rec->refs > 1) {
781 node->data = clone_inode_rec(rec);
782 if (IS_ERR(node->data))
783 return node->data;
784 rec->refs--;
785 rec = node->data;
786 }
787 } else if (mod) {
788 rec = calloc(1, sizeof(*rec));
789 if (!rec)
790 return ERR_PTR(-ENOMEM);
791 rec->ino = ino;
792 rec->extent_start = (u64)-1;
793 rec->refs = 1;
794 INIT_LIST_HEAD(&rec->backrefs);
795 INIT_LIST_HEAD(&rec->orphan_extents);
796 rec->holes = RB_ROOT;
797
798 node = malloc(sizeof(*node));
799 if (!node) {
800 free(rec);
801 return ERR_PTR(-ENOMEM);
802 }
803 node->cache.start = ino;
804 node->cache.size = 1;
805 node->data = rec;
806
807 if (ino == BTRFS_FREE_INO_OBJECTID)
808 rec->found_link = 1;
809
810 ret = insert_cache_extent(inode_cache, &node->cache);
811 if (ret)
812 return ERR_PTR(-EEXIST);
813 }
814 return rec;
815 }
816
817 static void free_orphan_data_extents(struct list_head *orphan_extents)
818 {
819 struct orphan_data_extent *orphan;
820
821 while (!list_empty(orphan_extents)) {
822 orphan = list_entry(orphan_extents->next,
823 struct orphan_data_extent, list);
824 list_del(&orphan->list);
825 free(orphan);
826 }
827 }
828
829 static void free_inode_rec(struct inode_record *rec)
830 {
831 struct inode_backref *backref;
832
833 if (--rec->refs > 0)
834 return;
835
836 while (!list_empty(&rec->backrefs)) {
837 backref = list_entry(rec->backrefs.next,
838 struct inode_backref, list);
839 list_del(&backref->list);
840 free(backref);
841 }
842 free_orphan_data_extents(&rec->orphan_extents);
843 free_file_extent_holes(&rec->holes);
844 free(rec);
845 }
846
847 static int can_free_inode_rec(struct inode_record *rec)
848 {
849 if (!rec->errors && rec->checked && rec->found_inode_item &&
850 rec->nlink == rec->found_link && list_empty(&rec->backrefs))
851 return 1;
852 return 0;
853 }
854
855 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
856 struct inode_record *rec)
857 {
858 struct cache_extent *cache;
859 struct inode_backref *tmp, *backref;
860 struct ptr_node *node;
861 unsigned char filetype;
862
863 if (!rec->found_inode_item)
864 return;
865
866 filetype = imode_to_type(rec->imode);
867 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
868 if (backref->found_dir_item && backref->found_dir_index) {
869 if (backref->filetype != filetype)
870 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
871 if (!backref->errors && backref->found_inode_ref &&
872 rec->nlink == rec->found_link) {
873 list_del(&backref->list);
874 free(backref);
875 }
876 }
877 }
878
879 if (!rec->checked || rec->merging)
880 return;
881
882 if (S_ISDIR(rec->imode)) {
883 if (rec->found_size != rec->isize)
884 rec->errors |= I_ERR_DIR_ISIZE_WRONG;
885 if (rec->found_file_extent)
886 rec->errors |= I_ERR_ODD_FILE_EXTENT;
887 } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
888 if (rec->found_dir_item)
889 rec->errors |= I_ERR_ODD_DIR_ITEM;
890 if (rec->found_size != rec->nbytes)
891 rec->errors |= I_ERR_FILE_NBYTES_WRONG;
892 if (rec->nlink > 0 && !no_holes &&
893 (rec->extent_end < rec->isize ||
894 first_extent_gap(&rec->holes) < rec->isize))
895 rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
896 }
897
898 if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
899 if (rec->found_csum_item && rec->nodatasum)
900 rec->errors |= I_ERR_ODD_CSUM_ITEM;
901 if (rec->some_csum_missing && !rec->nodatasum)
902 rec->errors |= I_ERR_SOME_CSUM_MISSING;
903 }
904
905 BUG_ON(rec->refs != 1);
906 if (can_free_inode_rec(rec)) {
907 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
908 node = container_of(cache, struct ptr_node, cache);
909 BUG_ON(node->data != rec);
910 remove_cache_extent(inode_cache, &node->cache);
911 free(node);
912 free_inode_rec(rec);
913 }
914 }
915
916 static int check_orphan_item(struct btrfs_root *root, u64 ino)
917 {
918 struct btrfs_path path;
919 struct btrfs_key key;
920 int ret;
921
922 key.objectid = BTRFS_ORPHAN_OBJECTID;
923 key.type = BTRFS_ORPHAN_ITEM_KEY;
924 key.offset = ino;
925
926 btrfs_init_path(&path);
927 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
928 btrfs_release_path(&path);
929 if (ret > 0)
930 ret = -ENOENT;
931 return ret;
932 }
933
934 static int process_inode_item(struct extent_buffer *eb,
935 int slot, struct btrfs_key *key,
936 struct shared_node *active_node)
937 {
938 struct inode_record *rec;
939 struct btrfs_inode_item *item;
940
941 rec = active_node->current;
942 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
943 if (rec->found_inode_item) {
944 rec->errors |= I_ERR_DUP_INODE_ITEM;
945 return 1;
946 }
947 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
948 rec->nlink = btrfs_inode_nlink(eb, item);
949 rec->isize = btrfs_inode_size(eb, item);
950 rec->nbytes = btrfs_inode_nbytes(eb, item);
951 rec->imode = btrfs_inode_mode(eb, item);
952 if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
953 rec->nodatasum = 1;
954 rec->found_inode_item = 1;
955 if (rec->nlink == 0)
956 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
957 maybe_free_inode_rec(&active_node->inode_cache, rec);
958 return 0;
959 }
960
961 static struct inode_backref *get_inode_backref(struct inode_record *rec,
962 const char *name,
963 int namelen, u64 dir)
964 {
965 struct inode_backref *backref;
966
967 list_for_each_entry(backref, &rec->backrefs, list) {
968 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
969 break;
970 if (backref->dir != dir || backref->namelen != namelen)
971 continue;
972 if (memcmp(name, backref->name, namelen))
973 continue;
974 return backref;
975 }
976
977 backref = malloc(sizeof(*backref) + namelen + 1);
978 if (!backref)
979 return NULL;
980 memset(backref, 0, sizeof(*backref));
981 backref->dir = dir;
982 backref->namelen = namelen;
983 memcpy(backref->name, name, namelen);
984 backref->name[namelen] = '\0';
985 list_add_tail(&backref->list, &rec->backrefs);
986 return backref;
987 }
988
989 static int add_inode_backref(struct cache_tree *inode_cache,
990 u64 ino, u64 dir, u64 index,
991 const char *name, int namelen,
992 int filetype, int itemtype, int errors)
993 {
994 struct inode_record *rec;
995 struct inode_backref *backref;
996
997 rec = get_inode_rec(inode_cache, ino, 1);
998 BUG_ON(IS_ERR(rec));
999 backref = get_inode_backref(rec, name, namelen, dir);
1000 BUG_ON(!backref);
1001 if (errors)
1002 backref->errors |= errors;
1003 if (itemtype == BTRFS_DIR_INDEX_KEY) {
1004 if (backref->found_dir_index)
1005 backref->errors |= REF_ERR_DUP_DIR_INDEX;
1006 if (backref->found_inode_ref && backref->index != index)
1007 backref->errors |= REF_ERR_INDEX_UNMATCH;
1008 if (backref->found_dir_item && backref->filetype != filetype)
1009 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1010
1011 backref->index = index;
1012 backref->filetype = filetype;
1013 backref->found_dir_index = 1;
1014 } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1015 rec->found_link++;
1016 if (backref->found_dir_item)
1017 backref->errors |= REF_ERR_DUP_DIR_ITEM;
1018 if (backref->found_dir_index && backref->filetype != filetype)
1019 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1020
1021 backref->filetype = filetype;
1022 backref->found_dir_item = 1;
1023 } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1024 (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1025 if (backref->found_inode_ref)
1026 backref->errors |= REF_ERR_DUP_INODE_REF;
1027 if (backref->found_dir_index && backref->index != index)
1028 backref->errors |= REF_ERR_INDEX_UNMATCH;
1029 else
1030 backref->index = index;
1031
1032 backref->ref_type = itemtype;
1033 backref->found_inode_ref = 1;
1034 } else {
1035 BUG_ON(1);
1036 }
1037
1038 maybe_free_inode_rec(inode_cache, rec);
1039 return 0;
1040 }
1041
1042 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1043 struct cache_tree *dst_cache)
1044 {
1045 struct inode_backref *backref;
1046 u32 dir_count = 0;
1047 int ret = 0;
1048
1049 dst->merging = 1;
1050 list_for_each_entry(backref, &src->backrefs, list) {
1051 if (backref->found_dir_index) {
1052 add_inode_backref(dst_cache, dst->ino, backref->dir,
1053 backref->index, backref->name,
1054 backref->namelen, backref->filetype,
1055 BTRFS_DIR_INDEX_KEY, backref->errors);
1056 }
1057 if (backref->found_dir_item) {
1058 dir_count++;
1059 add_inode_backref(dst_cache, dst->ino,
1060 backref->dir, 0, backref->name,
1061 backref->namelen, backref->filetype,
1062 BTRFS_DIR_ITEM_KEY, backref->errors);
1063 }
1064 if (backref->found_inode_ref) {
1065 add_inode_backref(dst_cache, dst->ino,
1066 backref->dir, backref->index,
1067 backref->name, backref->namelen, 0,
1068 backref->ref_type, backref->errors);
1069 }
1070 }
1071
1072 if (src->found_dir_item)
1073 dst->found_dir_item = 1;
1074 if (src->found_file_extent)
1075 dst->found_file_extent = 1;
1076 if (src->found_csum_item)
1077 dst->found_csum_item = 1;
1078 if (src->some_csum_missing)
1079 dst->some_csum_missing = 1;
1080 if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1081 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1082 if (ret < 0)
1083 return ret;
1084 }
1085
1086 BUG_ON(src->found_link < dir_count);
1087 dst->found_link += src->found_link - dir_count;
1088 dst->found_size += src->found_size;
1089 if (src->extent_start != (u64)-1) {
1090 if (dst->extent_start == (u64)-1) {
1091 dst->extent_start = src->extent_start;
1092 dst->extent_end = src->extent_end;
1093 } else {
1094 if (dst->extent_end > src->extent_start)
1095 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1096 else if (dst->extent_end < src->extent_start) {
1097 ret = add_file_extent_hole(&dst->holes,
1098 dst->extent_end,
1099 src->extent_start - dst->extent_end);
1100 }
1101 if (dst->extent_end < src->extent_end)
1102 dst->extent_end = src->extent_end;
1103 }
1104 }
1105
1106 dst->errors |= src->errors;
1107 if (src->found_inode_item) {
1108 if (!dst->found_inode_item) {
1109 dst->nlink = src->nlink;
1110 dst->isize = src->isize;
1111 dst->nbytes = src->nbytes;
1112 dst->imode = src->imode;
1113 dst->nodatasum = src->nodatasum;
1114 dst->found_inode_item = 1;
1115 } else {
1116 dst->errors |= I_ERR_DUP_INODE_ITEM;
1117 }
1118 }
1119 dst->merging = 0;
1120
1121 return 0;
1122 }
1123
1124 static int splice_shared_node(struct shared_node *src_node,
1125 struct shared_node *dst_node)
1126 {
1127 struct cache_extent *cache;
1128 struct ptr_node *node, *ins;
1129 struct cache_tree *src, *dst;
1130 struct inode_record *rec, *conflict;
1131 u64 current_ino = 0;
1132 int splice = 0;
1133 int ret;
1134
1135 if (--src_node->refs == 0)
1136 splice = 1;
1137 if (src_node->current)
1138 current_ino = src_node->current->ino;
1139
1140 src = &src_node->root_cache;
1141 dst = &dst_node->root_cache;
1142 again:
1143 cache = search_cache_extent(src, 0);
1144 while (cache) {
1145 node = container_of(cache, struct ptr_node, cache);
1146 rec = node->data;
1147 cache = next_cache_extent(cache);
1148
1149 if (splice) {
1150 remove_cache_extent(src, &node->cache);
1151 ins = node;
1152 } else {
1153 ins = malloc(sizeof(*ins));
1154 BUG_ON(!ins);
1155 ins->cache.start = node->cache.start;
1156 ins->cache.size = node->cache.size;
1157 ins->data = rec;
1158 rec->refs++;
1159 }
1160 ret = insert_cache_extent(dst, &ins->cache);
1161 if (ret == -EEXIST) {
1162 conflict = get_inode_rec(dst, rec->ino, 1);
1163 BUG_ON(IS_ERR(conflict));
1164 merge_inode_recs(rec, conflict, dst);
1165 if (rec->checked) {
1166 conflict->checked = 1;
1167 if (dst_node->current == conflict)
1168 dst_node->current = NULL;
1169 }
1170 maybe_free_inode_rec(dst, conflict);
1171 free_inode_rec(rec);
1172 free(ins);
1173 } else {
1174 BUG_ON(ret);
1175 }
1176 }
1177
1178 if (src == &src_node->root_cache) {
1179 src = &src_node->inode_cache;
1180 dst = &dst_node->inode_cache;
1181 goto again;
1182 }
1183
1184 if (current_ino > 0 && (!dst_node->current ||
1185 current_ino > dst_node->current->ino)) {
1186 if (dst_node->current) {
1187 dst_node->current->checked = 1;
1188 maybe_free_inode_rec(dst, dst_node->current);
1189 }
1190 dst_node->current = get_inode_rec(dst, current_ino, 1);
1191 BUG_ON(IS_ERR(dst_node->current));
1192 }
1193 return 0;
1194 }
1195
1196 static void free_inode_ptr(struct cache_extent *cache)
1197 {
1198 struct ptr_node *node;
1199 struct inode_record *rec;
1200
1201 node = container_of(cache, struct ptr_node, cache);
1202 rec = node->data;
1203 free_inode_rec(rec);
1204 free(node);
1205 }
1206
1207 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1208
1209 static struct shared_node *find_shared_node(struct cache_tree *shared,
1210 u64 bytenr)
1211 {
1212 struct cache_extent *cache;
1213 struct shared_node *node;
1214
1215 cache = lookup_cache_extent(shared, bytenr, 1);
1216 if (cache) {
1217 node = container_of(cache, struct shared_node, cache);
1218 return node;
1219 }
1220 return NULL;
1221 }
1222
1223 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1224 {
1225 int ret;
1226 struct shared_node *node;
1227
1228 node = calloc(1, sizeof(*node));
1229 if (!node)
1230 return -ENOMEM;
1231 node->cache.start = bytenr;
1232 node->cache.size = 1;
1233 cache_tree_init(&node->root_cache);
1234 cache_tree_init(&node->inode_cache);
1235 node->refs = refs;
1236
1237 ret = insert_cache_extent(shared, &node->cache);
1238
1239 return ret;
1240 }
1241
1242 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1243 struct walk_control *wc, int level)
1244 {
1245 struct shared_node *node;
1246 struct shared_node *dest;
1247 int ret;
1248
1249 if (level == wc->active_node)
1250 return 0;
1251
1252 BUG_ON(wc->active_node <= level);
1253 node = find_shared_node(&wc->shared, bytenr);
1254 if (!node) {
1255 ret = add_shared_node(&wc->shared, bytenr, refs);
1256 BUG_ON(ret);
1257 node = find_shared_node(&wc->shared, bytenr);
1258 wc->nodes[level] = node;
1259 wc->active_node = level;
1260 return 0;
1261 }
1262
1263 if (wc->root_level == wc->active_node &&
1264 btrfs_root_refs(&root->root_item) == 0) {
1265 if (--node->refs == 0) {
1266 free_inode_recs_tree(&node->root_cache);
1267 free_inode_recs_tree(&node->inode_cache);
1268 remove_cache_extent(&wc->shared, &node->cache);
1269 free(node);
1270 }
1271 return 1;
1272 }
1273
1274 dest = wc->nodes[wc->active_node];
1275 splice_shared_node(node, dest);
1276 if (node->refs == 0) {
1277 remove_cache_extent(&wc->shared, &node->cache);
1278 free(node);
1279 }
1280 return 1;
1281 }
1282
1283 static int leave_shared_node(struct btrfs_root *root,
1284 struct walk_control *wc, int level)
1285 {
1286 struct shared_node *node;
1287 struct shared_node *dest;
1288 int i;
1289
1290 if (level == wc->root_level)
1291 return 0;
1292
1293 for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1294 if (wc->nodes[i])
1295 break;
1296 }
1297 BUG_ON(i >= BTRFS_MAX_LEVEL);
1298
1299 node = wc->nodes[wc->active_node];
1300 wc->nodes[wc->active_node] = NULL;
1301 wc->active_node = i;
1302
1303 dest = wc->nodes[wc->active_node];
1304 if (wc->active_node < wc->root_level ||
1305 btrfs_root_refs(&root->root_item) > 0) {
1306 BUG_ON(node->refs <= 1);
1307 splice_shared_node(node, dest);
1308 } else {
1309 BUG_ON(node->refs < 2);
1310 node->refs--;
1311 }
1312 return 0;
1313 }
1314
1315 /*
1316 * Returns:
1317 * < 0 - on error
1318 * 1 - if the root with id child_root_id is a child of root parent_root_id
1319 * 0 - if the root child_root_id isn't a child of the root parent_root_id but
1320 * has other root(s) as parent(s)
1321 * 2 - if the root child_root_id doesn't have any parent roots
1322 */
1323 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1324 u64 child_root_id)
1325 {
1326 struct btrfs_path path;
1327 struct btrfs_key key;
1328 struct extent_buffer *leaf;
1329 int has_parent = 0;
1330 int ret;
1331
1332 btrfs_init_path(&path);
1333
1334 key.objectid = parent_root_id;
1335 key.type = BTRFS_ROOT_REF_KEY;
1336 key.offset = child_root_id;
1337 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1338 0, 0);
1339 if (ret < 0)
1340 return ret;
1341 btrfs_release_path(&path);
1342 if (!ret)
1343 return 1;
1344
1345 key.objectid = child_root_id;
1346 key.type = BTRFS_ROOT_BACKREF_KEY;
1347 key.offset = 0;
1348 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1349 0, 0);
1350 if (ret < 0)
1351 goto out;
1352
1353 while (1) {
1354 leaf = path.nodes[0];
1355 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1356 ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1357 if (ret)
1358 break;
1359 leaf = path.nodes[0];
1360 }
1361
1362 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1363 if (key.objectid != child_root_id ||
1364 key.type != BTRFS_ROOT_BACKREF_KEY)
1365 break;
1366
1367 has_parent = 1;
1368
1369 if (key.offset == parent_root_id) {
1370 btrfs_release_path(&path);
1371 return 1;
1372 }
1373
1374 path.slots[0]++;
1375 }
1376 out:
1377 btrfs_release_path(&path);
1378 if (ret < 0)
1379 return ret;
1380 return has_parent ? 0 : 2;
1381 }
1382
1383 static int process_dir_item(struct btrfs_root *root,
1384 struct extent_buffer *eb,
1385 int slot, struct btrfs_key *key,
1386 struct shared_node *active_node)
1387 {
1388 u32 total;
1389 u32 cur = 0;
1390 u32 len;
1391 u32 name_len;
1392 u32 data_len;
1393 int error;
1394 int nritems = 0;
1395 int filetype;
1396 struct btrfs_dir_item *di;
1397 struct inode_record *rec;
1398 struct cache_tree *root_cache;
1399 struct cache_tree *inode_cache;
1400 struct btrfs_key location;
1401 char namebuf[BTRFS_NAME_LEN];
1402
1403 root_cache = &active_node->root_cache;
1404 inode_cache = &active_node->inode_cache;
1405 rec = active_node->current;
1406 rec->found_dir_item = 1;
1407
1408 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1409 total = btrfs_item_size_nr(eb, slot);
1410 while (cur < total) {
1411 nritems++;
1412 btrfs_dir_item_key_to_cpu(eb, di, &location);
1413 name_len = btrfs_dir_name_len(eb, di);
1414 data_len = btrfs_dir_data_len(eb, di);
1415 filetype = btrfs_dir_type(eb, di);
1416
1417 rec->found_size += name_len;
1418 if (name_len <= BTRFS_NAME_LEN) {
1419 len = name_len;
1420 error = 0;
1421 } else {
1422 len = BTRFS_NAME_LEN;
1423 error = REF_ERR_NAME_TOO_LONG;
1424 }
1425 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1426
1427 if (location.type == BTRFS_INODE_ITEM_KEY) {
1428 add_inode_backref(inode_cache, location.objectid,
1429 key->objectid, key->offset, namebuf,
1430 len, filetype, key->type, error);
1431 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1432 add_inode_backref(root_cache, location.objectid,
1433 key->objectid, key->offset,
1434 namebuf, len, filetype,
1435 key->type, error);
1436 } else {
1437 fprintf(stderr, "invalid location in dir item %u\n",
1438 location.type);
1439 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1440 key->objectid, key->offset, namebuf,
1441 len, filetype, key->type, error);
1442 }
1443
1444 len = sizeof(*di) + name_len + data_len;
1445 di = (struct btrfs_dir_item *)((char *)di + len);
1446 cur += len;
1447 }
1448 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1449 rec->errors |= I_ERR_DUP_DIR_INDEX;
1450
1451 return 0;
1452 }
1453
1454 static int process_inode_ref(struct extent_buffer *eb,
1455 int slot, struct btrfs_key *key,
1456 struct shared_node *active_node)
1457 {
1458 u32 total;
1459 u32 cur = 0;
1460 u32 len;
1461 u32 name_len;
1462 u64 index;
1463 int error;
1464 struct cache_tree *inode_cache;
1465 struct btrfs_inode_ref *ref;
1466 char namebuf[BTRFS_NAME_LEN];
1467
1468 inode_cache = &active_node->inode_cache;
1469
1470 ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1471 total = btrfs_item_size_nr(eb, slot);
1472 while (cur < total) {
1473 name_len = btrfs_inode_ref_name_len(eb, ref);
1474 index = btrfs_inode_ref_index(eb, ref);
1475 if (name_len <= BTRFS_NAME_LEN) {
1476 len = name_len;
1477 error = 0;
1478 } else {
1479 len = BTRFS_NAME_LEN;
1480 error = REF_ERR_NAME_TOO_LONG;
1481 }
1482 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1483 add_inode_backref(inode_cache, key->objectid, key->offset,
1484 index, namebuf, len, 0, key->type, error);
1485
1486 len = sizeof(*ref) + name_len;
1487 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1488 cur += len;
1489 }
1490 return 0;
1491 }
1492
1493 static int process_inode_extref(struct extent_buffer *eb,
1494 int slot, struct btrfs_key *key,
1495 struct shared_node *active_node)
1496 {
1497 u32 total;
1498 u32 cur = 0;
1499 u32 len;
1500 u32 name_len;
1501 u64 index;
1502 u64 parent;
1503 int error;
1504 struct cache_tree *inode_cache;
1505 struct btrfs_inode_extref *extref;
1506 char namebuf[BTRFS_NAME_LEN];
1507
1508 inode_cache = &active_node->inode_cache;
1509
1510 extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1511 total = btrfs_item_size_nr(eb, slot);
1512 while (cur < total) {
1513 name_len = btrfs_inode_extref_name_len(eb, extref);
1514 index = btrfs_inode_extref_index(eb, extref);
1515 parent = btrfs_inode_extref_parent(eb, extref);
1516 if (name_len <= BTRFS_NAME_LEN) {
1517 len = name_len;
1518 error = 0;
1519 } else {
1520 len = BTRFS_NAME_LEN;
1521 error = REF_ERR_NAME_TOO_LONG;
1522 }
1523 read_extent_buffer(eb, namebuf,
1524 (unsigned long)(extref + 1), len);
1525 add_inode_backref(inode_cache, key->objectid, parent,
1526 index, namebuf, len, 0, key->type, error);
1527
1528 len = sizeof(*extref) + name_len;
1529 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1530 cur += len;
1531 }
1532 return 0;
1533
1534 }
1535
1536 static int count_csum_range(struct btrfs_root *root, u64 start,
1537 u64 len, u64 *found)
1538 {
1539 struct btrfs_key key;
1540 struct btrfs_path path;
1541 struct extent_buffer *leaf;
1542 int ret;
1543 size_t size;
1544 *found = 0;
1545 u64 csum_end;
1546 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1547
1548 btrfs_init_path(&path);
1549
1550 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1551 key.offset = start;
1552 key.type = BTRFS_EXTENT_CSUM_KEY;
1553
1554 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1555 &key, &path, 0, 0);
1556 if (ret < 0)
1557 goto out;
1558 if (ret > 0 && path.slots[0] > 0) {
1559 leaf = path.nodes[0];
1560 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1561 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1562 key.type == BTRFS_EXTENT_CSUM_KEY)
1563 path.slots[0]--;
1564 }
1565
1566 while (len > 0) {
1567 leaf = path.nodes[0];
1568 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1569 ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1570 if (ret > 0)
1571 break;
1572 else if (ret < 0)
1573 goto out;
1574 leaf = path.nodes[0];
1575 }
1576
1577 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1578 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1579 key.type != BTRFS_EXTENT_CSUM_KEY)
1580 break;
1581
1582 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1583 if (key.offset >= start + len)
1584 break;
1585
1586 if (key.offset > start)
1587 start = key.offset;
1588
1589 size = btrfs_item_size_nr(leaf, path.slots[0]);
1590 csum_end = key.offset + (size / csum_size) * root->sectorsize;
1591 if (csum_end > start) {
1592 size = min(csum_end - start, len);
1593 len -= size;
1594 start += size;
1595 *found += size;
1596 }
1597
1598 path.slots[0]++;
1599 }
1600 out:
1601 btrfs_release_path(&path);
1602 if (ret < 0)
1603 return ret;
1604 return 0;
1605 }
1606
1607 static int process_file_extent(struct btrfs_root *root,
1608 struct extent_buffer *eb,
1609 int slot, struct btrfs_key *key,
1610 struct shared_node *active_node)
1611 {
1612 struct inode_record *rec;
1613 struct btrfs_file_extent_item *fi;
1614 u64 num_bytes = 0;
1615 u64 disk_bytenr = 0;
1616 u64 extent_offset = 0;
1617 u64 mask = root->sectorsize - 1;
1618 int extent_type;
1619 int ret;
1620
1621 rec = active_node->current;
1622 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1623 rec->found_file_extent = 1;
1624
1625 if (rec->extent_start == (u64)-1) {
1626 rec->extent_start = key->offset;
1627 rec->extent_end = key->offset;
1628 }
1629
1630 if (rec->extent_end > key->offset)
1631 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1632 else if (rec->extent_end < key->offset) {
1633 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1634 key->offset - rec->extent_end);
1635 if (ret < 0)
1636 return ret;
1637 }
1638
1639 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1640 extent_type = btrfs_file_extent_type(eb, fi);
1641
1642 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1643 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1644 if (num_bytes == 0)
1645 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1646 rec->found_size += num_bytes;
1647 num_bytes = (num_bytes + mask) & ~mask;
1648 } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1649 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1650 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1651 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1652 extent_offset = btrfs_file_extent_offset(eb, fi);
1653 if (num_bytes == 0 || (num_bytes & mask))
1654 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1655 if (num_bytes + extent_offset >
1656 btrfs_file_extent_ram_bytes(eb, fi))
1657 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1658 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1659 (btrfs_file_extent_compression(eb, fi) ||
1660 btrfs_file_extent_encryption(eb, fi) ||
1661 btrfs_file_extent_other_encoding(eb, fi)))
1662 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1663 if (disk_bytenr > 0)
1664 rec->found_size += num_bytes;
1665 } else {
1666 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1667 }
1668 rec->extent_end = key->offset + num_bytes;
1669
1670 /*
1671 * The data reloc tree will copy full extents into its inode and then
1672 * copy the corresponding csums. Because the extent it copied could be
1673 * a preallocated extent that hasn't been written to yet there may be no
1674 * csums to copy, ergo we won't have csums for our file extent. This is
1675 * ok so just don't bother checking csums if the inode belongs to the
1676 * data reloc tree.
1677 */
1678 if (disk_bytenr > 0 &&
1679 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1680 u64 found;
1681 if (btrfs_file_extent_compression(eb, fi))
1682 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1683 else
1684 disk_bytenr += extent_offset;
1685
1686 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1687 if (ret < 0)
1688 return ret;
1689 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1690 if (found > 0)
1691 rec->found_csum_item = 1;
1692 if (found < num_bytes)
1693 rec->some_csum_missing = 1;
1694 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1695 if (found > 0)
1696 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1697 }
1698 }
1699 return 0;
1700 }
1701
1702 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1703 struct walk_control *wc)
1704 {
1705 struct btrfs_key key;
1706 u32 nritems;
1707 int i;
1708 int ret = 0;
1709 struct cache_tree *inode_cache;
1710 struct shared_node *active_node;
1711
1712 if (wc->root_level == wc->active_node &&
1713 btrfs_root_refs(&root->root_item) == 0)
1714 return 0;
1715
1716 active_node = wc->nodes[wc->active_node];
1717 inode_cache = &active_node->inode_cache;
1718 nritems = btrfs_header_nritems(eb);
1719 for (i = 0; i < nritems; i++) {
1720 btrfs_item_key_to_cpu(eb, &key, i);
1721
1722 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1723 continue;
1724 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1725 continue;
1726
1727 if (active_node->current == NULL ||
1728 active_node->current->ino < key.objectid) {
1729 if (active_node->current) {
1730 active_node->current->checked = 1;
1731 maybe_free_inode_rec(inode_cache,
1732 active_node->current);
1733 }
1734 active_node->current = get_inode_rec(inode_cache,
1735 key.objectid, 1);
1736 BUG_ON(IS_ERR(active_node->current));
1737 }
1738 switch (key.type) {
1739 case BTRFS_DIR_ITEM_KEY:
1740 case BTRFS_DIR_INDEX_KEY:
1741 ret = process_dir_item(root, eb, i, &key, active_node);
1742 break;
1743 case BTRFS_INODE_REF_KEY:
1744 ret = process_inode_ref(eb, i, &key, active_node);
1745 break;
1746 case BTRFS_INODE_EXTREF_KEY:
1747 ret = process_inode_extref(eb, i, &key, active_node);
1748 break;
1749 case BTRFS_INODE_ITEM_KEY:
1750 ret = process_inode_item(eb, i, &key, active_node);
1751 break;
1752 case BTRFS_EXTENT_DATA_KEY:
1753 ret = process_file_extent(root, eb, i, &key,
1754 active_node);
1755 break;
1756 default:
1757 break;
1758 };
1759 }
1760 return ret;
1761 }
1762
1763 static void reada_walk_down(struct btrfs_root *root,
1764 struct extent_buffer *node, int slot)
1765 {
1766 u64 bytenr;
1767 u64 ptr_gen;
1768 u32 nritems;
1769 u32 blocksize;
1770 int i;
1771 int level;
1772
1773 level = btrfs_header_level(node);
1774 if (level != 1)
1775 return;
1776
1777 nritems = btrfs_header_nritems(node);
1778 blocksize = root->nodesize;
1779 for (i = slot; i < nritems; i++) {
1780 bytenr = btrfs_node_blockptr(node, i);
1781 ptr_gen = btrfs_node_ptr_generation(node, i);
1782 readahead_tree_block(root, bytenr, blocksize, ptr_gen);
1783 }
1784 }
1785
1786 /*
1787 * Check the child node/leaf by the following condition:
1788 * 1. the first item key of the node/leaf should be the same with the one
1789 * in parent.
1790 * 2. block in parent node should match the child node/leaf.
1791 * 3. generation of parent node and child's header should be consistent.
1792 *
1793 * Or the child node/leaf pointed by the key in parent is not valid.
1794 *
1795 * We hope to check leaf owner too, but since subvol may share leaves,
1796 * which makes leaf owner check not so strong, key check should be
1797 * sufficient enough for that case.
1798 */
1799 static int check_child_node(struct btrfs_root *root,
1800 struct extent_buffer *parent, int slot,
1801 struct extent_buffer *child)
1802 {
1803 struct btrfs_key parent_key;
1804 struct btrfs_key child_key;
1805 int ret = 0;
1806
1807 btrfs_node_key_to_cpu(parent, &parent_key, slot);
1808 if (btrfs_header_level(child) == 0)
1809 btrfs_item_key_to_cpu(child, &child_key, 0);
1810 else
1811 btrfs_node_key_to_cpu(child, &child_key, 0);
1812
1813 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
1814 ret = -EINVAL;
1815 fprintf(stderr,
1816 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
1817 parent_key.objectid, parent_key.type, parent_key.offset,
1818 child_key.objectid, child_key.type, child_key.offset);
1819 }
1820 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
1821 ret = -EINVAL;
1822 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
1823 btrfs_node_blockptr(parent, slot),
1824 btrfs_header_bytenr(child));
1825 }
1826 if (btrfs_node_ptr_generation(parent, slot) !=
1827 btrfs_header_generation(child)) {
1828 ret = -EINVAL;
1829 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
1830 btrfs_header_generation(child),
1831 btrfs_node_ptr_generation(parent, slot));
1832 }
1833 return ret;
1834 }
1835
1836 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
1837 struct walk_control *wc, int *level)
1838 {
1839 enum btrfs_tree_block_status status;
1840 u64 bytenr;
1841 u64 ptr_gen;
1842 struct extent_buffer *next;
1843 struct extent_buffer *cur;
1844 u32 blocksize;
1845 int ret, err = 0;
1846 u64 refs;
1847
1848 WARN_ON(*level < 0);
1849 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1850 ret = btrfs_lookup_extent_info(NULL, root,
1851 path->nodes[*level]->start,
1852 *level, 1, &refs, NULL);
1853 if (ret < 0) {
1854 err = ret;
1855 goto out;
1856 }
1857
1858 if (refs > 1) {
1859 ret = enter_shared_node(root, path->nodes[*level]->start,
1860 refs, wc, *level);
1861 if (ret > 0) {
1862 err = ret;
1863 goto out;
1864 }
1865 }
1866
1867 while (*level >= 0) {
1868 WARN_ON(*level < 0);
1869 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1870 cur = path->nodes[*level];
1871
1872 if (btrfs_header_level(cur) != *level)
1873 WARN_ON(1);
1874
1875 if (path->slots[*level] >= btrfs_header_nritems(cur))
1876 break;
1877 if (*level == 0) {
1878 ret = process_one_leaf(root, cur, wc);
1879 if (ret < 0)
1880 err = ret;
1881 break;
1882 }
1883 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
1884 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
1885 blocksize = root->nodesize;
1886 ret = btrfs_lookup_extent_info(NULL, root, bytenr, *level - 1,
1887 1, &refs, NULL);
1888 if (ret < 0)
1889 refs = 0;
1890
1891 if (refs > 1) {
1892 ret = enter_shared_node(root, bytenr, refs,
1893 wc, *level - 1);
1894 if (ret > 0) {
1895 path->slots[*level]++;
1896 continue;
1897 }
1898 }
1899
1900 next = btrfs_find_tree_block(root, bytenr, blocksize);
1901 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
1902 free_extent_buffer(next);
1903 reada_walk_down(root, cur, path->slots[*level]);
1904 next = read_tree_block(root, bytenr, blocksize,
1905 ptr_gen);
1906 if (!extent_buffer_uptodate(next)) {
1907 struct btrfs_key node_key;
1908
1909 btrfs_node_key_to_cpu(path->nodes[*level],
1910 &node_key,
1911 path->slots[*level]);
1912 btrfs_add_corrupt_extent_record(root->fs_info,
1913 &node_key,
1914 path->nodes[*level]->start,
1915 root->nodesize, *level);
1916 err = -EIO;
1917 goto out;
1918 }
1919 }
1920
1921 ret = check_child_node(root, cur, path->slots[*level], next);
1922 if (ret) {
1923 err = ret;
1924 goto out;
1925 }
1926
1927 if (btrfs_is_leaf(next))
1928 status = btrfs_check_leaf(root, NULL, next);
1929 else
1930 status = btrfs_check_node(root, NULL, next);
1931 if (status != BTRFS_TREE_BLOCK_CLEAN) {
1932 free_extent_buffer(next);
1933 err = -EIO;
1934 goto out;
1935 }
1936
1937 *level = *level - 1;
1938 free_extent_buffer(path->nodes[*level]);
1939 path->nodes[*level] = next;
1940 path->slots[*level] = 0;
1941 }
1942 out:
1943 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
1944 return err;
1945 }
1946
1947 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
1948 struct walk_control *wc, int *level)
1949 {
1950 int i;
1951 struct extent_buffer *leaf;
1952
1953 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
1954 leaf = path->nodes[i];
1955 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
1956 path->slots[i]++;
1957 *level = i;
1958 return 0;
1959 } else {
1960 free_extent_buffer(path->nodes[*level]);
1961 path->nodes[*level] = NULL;
1962 BUG_ON(*level > wc->active_node);
1963 if (*level == wc->active_node)
1964 leave_shared_node(root, wc, *level);
1965 *level = i + 1;
1966 }
1967 }
1968 return 1;
1969 }
1970
1971 static int check_root_dir(struct inode_record *rec)
1972 {
1973 struct inode_backref *backref;
1974 int ret = -1;
1975
1976 if (!rec->found_inode_item || rec->errors)
1977 goto out;
1978 if (rec->nlink != 1 || rec->found_link != 0)
1979 goto out;
1980 if (list_empty(&rec->backrefs))
1981 goto out;
1982 backref = list_entry(rec->backrefs.next, struct inode_backref, list);
1983 if (!backref->found_inode_ref)
1984 goto out;
1985 if (backref->index != 0 || backref->namelen != 2 ||
1986 memcmp(backref->name, "..", 2))
1987 goto out;
1988 if (backref->found_dir_index || backref->found_dir_item)
1989 goto out;
1990 ret = 0;
1991 out:
1992 return ret;
1993 }
1994
1995 static int repair_inode_isize(struct btrfs_trans_handle *trans,
1996 struct btrfs_root *root, struct btrfs_path *path,
1997 struct inode_record *rec)
1998 {
1999 struct btrfs_inode_item *ei;
2000 struct btrfs_key key;
2001 int ret;
2002
2003 key.objectid = rec->ino;
2004 key.type = BTRFS_INODE_ITEM_KEY;
2005 key.offset = (u64)-1;
2006
2007 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2008 if (ret < 0)
2009 goto out;
2010 if (ret) {
2011 if (!path->slots[0]) {
2012 ret = -ENOENT;
2013 goto out;
2014 }
2015 path->slots[0]--;
2016 ret = 0;
2017 }
2018 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2019 if (key.objectid != rec->ino) {
2020 ret = -ENOENT;
2021 goto out;
2022 }
2023
2024 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2025 struct btrfs_inode_item);
2026 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2027 btrfs_mark_buffer_dirty(path->nodes[0]);
2028 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2029 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2030 root->root_key.objectid);
2031 out:
2032 btrfs_release_path(path);
2033 return ret;
2034 }
2035
2036 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2037 struct btrfs_root *root,
2038 struct btrfs_path *path,
2039 struct inode_record *rec)
2040 {
2041 int ret;
2042
2043 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2044 btrfs_release_path(path);
2045 if (!ret)
2046 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2047 return ret;
2048 }
2049
2050 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2051 struct btrfs_root *root,
2052 struct btrfs_path *path,
2053 struct inode_record *rec)
2054 {
2055 struct btrfs_inode_item *ei;
2056 struct btrfs_key key;
2057 int ret = 0;
2058
2059 key.objectid = rec->ino;
2060 key.type = BTRFS_INODE_ITEM_KEY;
2061 key.offset = 0;
2062
2063 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2064 if (ret) {
2065 if (ret > 0)
2066 ret = -ENOENT;
2067 goto out;
2068 }
2069
2070 /* Since ret == 0, no need to check anything */
2071 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2072 struct btrfs_inode_item);
2073 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2074 btrfs_mark_buffer_dirty(path->nodes[0]);
2075 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2076 printf("reset nbytes for ino %llu root %llu\n",
2077 rec->ino, root->root_key.objectid);
2078 out:
2079 btrfs_release_path(path);
2080 return ret;
2081 }
2082
2083 static int add_missing_dir_index(struct btrfs_root *root,
2084 struct cache_tree *inode_cache,
2085 struct inode_record *rec,
2086 struct inode_backref *backref)
2087 {
2088 struct btrfs_path *path;
2089 struct btrfs_trans_handle *trans;
2090 struct btrfs_dir_item *dir_item;
2091 struct extent_buffer *leaf;
2092 struct btrfs_key key;
2093 struct btrfs_disk_key disk_key;
2094 struct inode_record *dir_rec;
2095 unsigned long name_ptr;
2096 u32 data_size = sizeof(*dir_item) + backref->namelen;
2097 int ret;
2098
2099 path = btrfs_alloc_path();
2100 if (!path)
2101 return -ENOMEM;
2102
2103 trans = btrfs_start_transaction(root, 1);
2104 if (IS_ERR(trans)) {
2105 btrfs_free_path(path);
2106 return PTR_ERR(trans);
2107 }
2108
2109 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2110 (unsigned long long)rec->ino);
2111 key.objectid = backref->dir;
2112 key.type = BTRFS_DIR_INDEX_KEY;
2113 key.offset = backref->index;
2114
2115 ret = btrfs_insert_empty_item(trans, root, path, &key, data_size);
2116 BUG_ON(ret);
2117
2118 leaf = path->nodes[0];
2119 dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
2120
2121 disk_key.objectid = cpu_to_le64(rec->ino);
2122 disk_key.type = BTRFS_INODE_ITEM_KEY;
2123 disk_key.offset = 0;
2124
2125 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2126 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2127 btrfs_set_dir_data_len(leaf, dir_item, 0);
2128 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2129 name_ptr = (unsigned long)(dir_item + 1);
2130 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2131 btrfs_mark_buffer_dirty(leaf);
2132 btrfs_free_path(path);
2133 btrfs_commit_transaction(trans, root);
2134
2135 backref->found_dir_index = 1;
2136 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2137 BUG_ON(IS_ERR(dir_rec));
2138 if (!dir_rec)
2139 return 0;
2140 dir_rec->found_size += backref->namelen;
2141 if (dir_rec->found_size == dir_rec->isize &&
2142 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2143 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2144 if (dir_rec->found_size != dir_rec->isize)
2145 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2146
2147 return 0;
2148 }
2149
2150 static int delete_dir_index(struct btrfs_root *root,
2151 struct cache_tree *inode_cache,
2152 struct inode_record *rec,
2153 struct inode_backref *backref)
2154 {
2155 struct btrfs_trans_handle *trans;
2156 struct btrfs_dir_item *di;
2157 struct btrfs_path *path;
2158 int ret = 0;
2159
2160 path = btrfs_alloc_path();
2161 if (!path)
2162 return -ENOMEM;
2163
2164 trans = btrfs_start_transaction(root, 1);
2165 if (IS_ERR(trans)) {
2166 btrfs_free_path(path);
2167 return PTR_ERR(trans);
2168 }
2169
2170
2171 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2172 (unsigned long long)backref->dir,
2173 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2174 (unsigned long long)root->objectid);
2175
2176 di = btrfs_lookup_dir_index(trans, root, path, backref->dir,
2177 backref->name, backref->namelen,
2178 backref->index, -1);
2179 if (IS_ERR(di)) {
2180 ret = PTR_ERR(di);
2181 btrfs_free_path(path);
2182 btrfs_commit_transaction(trans, root);
2183 if (ret == -ENOENT)
2184 return 0;
2185 return ret;
2186 }
2187
2188 if (!di)
2189 ret = btrfs_del_item(trans, root, path);
2190 else
2191 ret = btrfs_delete_one_dir_name(trans, root, path, di);
2192 BUG_ON(ret);
2193 btrfs_free_path(path);
2194 btrfs_commit_transaction(trans, root);
2195 return ret;
2196 }
2197
2198 static int create_inode_item(struct btrfs_root *root,
2199 struct inode_record *rec,
2200 struct inode_backref *backref, int root_dir)
2201 {
2202 struct btrfs_trans_handle *trans;
2203 struct btrfs_inode_item inode_item;
2204 time_t now = time(NULL);
2205 int ret;
2206
2207 trans = btrfs_start_transaction(root, 1);
2208 if (IS_ERR(trans)) {
2209 ret = PTR_ERR(trans);
2210 return ret;
2211 }
2212
2213 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2214 "be incomplete, please check permissions and content after "
2215 "the fsck completes.\n", (unsigned long long)root->objectid,
2216 (unsigned long long)rec->ino);
2217
2218 memset(&inode_item, 0, sizeof(inode_item));
2219 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2220 if (root_dir)
2221 btrfs_set_stack_inode_nlink(&inode_item, 1);
2222 else
2223 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2224 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2225 if (rec->found_dir_item) {
2226 if (rec->found_file_extent)
2227 fprintf(stderr, "root %llu inode %llu has both a dir "
2228 "item and extents, unsure if it is a dir or a "
2229 "regular file so setting it as a directory\n",
2230 (unsigned long long)root->objectid,
2231 (unsigned long long)rec->ino);
2232 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2233 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2234 } else if (!rec->found_dir_item) {
2235 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2236 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2237 }
2238 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2239 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2240 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2241 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2242 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2243 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2244 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2245 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2246
2247 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2248 BUG_ON(ret);
2249 btrfs_commit_transaction(trans, root);
2250 return 0;
2251 }
2252
2253 static int repair_inode_backrefs(struct btrfs_root *root,
2254 struct inode_record *rec,
2255 struct cache_tree *inode_cache,
2256 int delete)
2257 {
2258 struct inode_backref *tmp, *backref;
2259 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2260 int ret = 0;
2261 int repaired = 0;
2262
2263 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2264 if (!delete && rec->ino == root_dirid) {
2265 if (!rec->found_inode_item) {
2266 ret = create_inode_item(root, rec, backref, 1);
2267 if (ret)
2268 break;
2269 repaired++;
2270 }
2271 }
2272
2273 /* Index 0 for root dir's are special, don't mess with it */
2274 if (rec->ino == root_dirid && backref->index == 0)
2275 continue;
2276
2277 if (delete &&
2278 ((backref->found_dir_index && !backref->found_inode_ref) ||
2279 (backref->found_dir_index && backref->found_inode_ref &&
2280 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2281 ret = delete_dir_index(root, inode_cache, rec, backref);
2282 if (ret)
2283 break;
2284 repaired++;
2285 list_del(&backref->list);
2286 free(backref);
2287 }
2288
2289 if (!delete && !backref->found_dir_index &&
2290 backref->found_dir_item && backref->found_inode_ref) {
2291 ret = add_missing_dir_index(root, inode_cache, rec,
2292 backref);
2293 if (ret)
2294 break;
2295 repaired++;
2296 if (backref->found_dir_item &&
2297 backref->found_dir_index &&
2298 backref->found_dir_index) {
2299 if (!backref->errors &&
2300 backref->found_inode_ref) {
2301 list_del(&backref->list);
2302 free(backref);
2303 }
2304 }
2305 }
2306
2307 if (!delete && (!backref->found_dir_index &&
2308 !backref->found_dir_item &&
2309 backref->found_inode_ref)) {
2310 struct btrfs_trans_handle *trans;
2311 struct btrfs_key location;
2312
2313 ret = check_dir_conflict(root, backref->name,
2314 backref->namelen,
2315 backref->dir,
2316 backref->index);
2317 if (ret) {
2318 /*
2319 * let nlink fixing routine to handle it,
2320 * which can do it better.
2321 */
2322 ret = 0;
2323 break;
2324 }
2325 location.objectid = rec->ino;
2326 location.type = BTRFS_INODE_ITEM_KEY;
2327 location.offset = 0;
2328
2329 trans = btrfs_start_transaction(root, 1);
2330 if (IS_ERR(trans)) {
2331 ret = PTR_ERR(trans);
2332 break;
2333 }
2334 fprintf(stderr, "adding missing dir index/item pair "
2335 "for inode %llu\n",
2336 (unsigned long long)rec->ino);
2337 ret = btrfs_insert_dir_item(trans, root, backref->name,
2338 backref->namelen,
2339 backref->dir, &location,
2340 imode_to_type(rec->imode),
2341 backref->index);
2342 BUG_ON(ret);
2343 btrfs_commit_transaction(trans, root);
2344 repaired++;
2345 }
2346
2347 if (!delete && (backref->found_inode_ref &&
2348 backref->found_dir_index &&
2349 backref->found_dir_item &&
2350 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2351 !rec->found_inode_item)) {
2352 ret = create_inode_item(root, rec, backref, 0);
2353 if (ret)
2354 break;
2355 repaired++;
2356 }
2357
2358 }
2359 return ret ? ret : repaired;
2360 }
2361
2362 /*
2363 * To determine the file type for nlink/inode_item repair
2364 *
2365 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2366 * Return -ENOENT if file type is not found.
2367 */
2368 static int find_file_type(struct inode_record *rec, u8 *type)
2369 {
2370 struct inode_backref *backref;
2371
2372 /* For inode item recovered case */
2373 if (rec->found_inode_item) {
2374 *type = imode_to_type(rec->imode);
2375 return 0;
2376 }
2377
2378 list_for_each_entry(backref, &rec->backrefs, list) {
2379 if (backref->found_dir_index || backref->found_dir_item) {
2380 *type = backref->filetype;
2381 return 0;
2382 }
2383 }
2384 return -ENOENT;
2385 }
2386
2387 /*
2388 * To determine the file name for nlink repair
2389 *
2390 * Return 0 if file name is found, set name and namelen.
2391 * Return -ENOENT if file name is not found.
2392 */
2393 static int find_file_name(struct inode_record *rec,
2394 char *name, int *namelen)
2395 {
2396 struct inode_backref *backref;
2397
2398 list_for_each_entry(backref, &rec->backrefs, list) {
2399 if (backref->found_dir_index || backref->found_dir_item ||
2400 backref->found_inode_ref) {
2401 memcpy(name, backref->name, backref->namelen);
2402 *namelen = backref->namelen;
2403 return 0;
2404 }
2405 }
2406 return -ENOENT;
2407 }
2408
2409 /* Reset the nlink of the inode to the correct one */
2410 static int reset_nlink(struct btrfs_trans_handle *trans,
2411 struct btrfs_root *root,
2412 struct btrfs_path *path,
2413 struct inode_record *rec)
2414 {
2415 struct inode_backref *backref;
2416 struct inode_backref *tmp;
2417 struct btrfs_key key;
2418 struct btrfs_inode_item *inode_item;
2419 int ret = 0;
2420
2421 /* We don't believe this either, reset it and iterate backref */
2422 rec->found_link = 0;
2423
2424 /* Remove all backref including the valid ones */
2425 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2426 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2427 backref->index, backref->name,
2428 backref->namelen, 0);
2429 if (ret < 0)
2430 goto out;
2431
2432 /* remove invalid backref, so it won't be added back */
2433 if (!(backref->found_dir_index &&
2434 backref->found_dir_item &&
2435 backref->found_inode_ref)) {
2436 list_del(&backref->list);
2437 free(backref);
2438 } else {
2439 rec->found_link++;
2440 }
2441 }
2442
2443 /* Set nlink to 0 */
2444 key.objectid = rec->ino;
2445 key.type = BTRFS_INODE_ITEM_KEY;
2446 key.offset = 0;
2447 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2448 if (ret < 0)
2449 goto out;
2450 if (ret > 0) {
2451 ret = -ENOENT;
2452 goto out;
2453 }
2454 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2455 struct btrfs_inode_item);
2456 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2457 btrfs_mark_buffer_dirty(path->nodes[0]);
2458 btrfs_release_path(path);
2459
2460 /*
2461 * Add back valid inode_ref/dir_item/dir_index,
2462 * add_link() will handle the nlink inc, so new nlink must be correct
2463 */
2464 list_for_each_entry(backref, &rec->backrefs, list) {
2465 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2466 backref->name, backref->namelen,
2467 backref->filetype, &backref->index, 1);
2468 if (ret < 0)
2469 goto out;
2470 }
2471 out:
2472 btrfs_release_path(path);
2473 return ret;
2474 }
2475
2476 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2477 struct btrfs_root *root,
2478 struct btrfs_path *path,
2479 struct inode_record *rec)
2480 {
2481 char *dir_name = "lost+found";
2482 char namebuf[BTRFS_NAME_LEN] = {0};
2483 u64 lost_found_ino;
2484 u32 mode = 0700;
2485 u8 type = 0;
2486 int namelen = 0;
2487 int name_recovered = 0;
2488 int type_recovered = 0;
2489 int ret = 0;
2490
2491 /*
2492 * Get file name and type first before these invalid inode ref
2493 * are deleted by remove_all_invalid_backref()
2494 */
2495 name_recovered = !find_file_name(rec, namebuf, &namelen);
2496 type_recovered = !find_file_type(rec, &type);
2497
2498 if (!name_recovered) {
2499 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2500 rec->ino, rec->ino);
2501 namelen = count_digits(rec->ino);
2502 sprintf(namebuf, "%llu", rec->ino);
2503 name_recovered = 1;
2504 }
2505 if (!type_recovered) {
2506 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2507 rec->ino);
2508 type = BTRFS_FT_REG_FILE;
2509 type_recovered = 1;
2510 }
2511
2512 ret = reset_nlink(trans, root, path, rec);
2513 if (ret < 0) {
2514 fprintf(stderr,
2515 "Failed to reset nlink for inode %llu: %s\n",
2516 rec->ino, strerror(-ret));
2517 goto out;
2518 }
2519
2520 if (rec->found_link == 0) {
2521 lost_found_ino = root->highest_inode;
2522 if (lost_found_ino >= BTRFS_LAST_FREE_OBJECTID) {
2523 ret = -EOVERFLOW;
2524 goto out;
2525 }
2526 lost_found_ino++;
2527 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2528 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2529 mode);
2530 if (ret < 0) {
2531 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2532 dir_name, strerror(-ret));
2533 goto out;
2534 }
2535 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2536 namebuf, namelen, type, NULL, 1);
2537 /*
2538 * Add ".INO" suffix several times to handle case where
2539 * "FILENAME.INO" is already taken by another file.
2540 */
2541 while (ret == -EEXIST) {
2542 /*
2543 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2544 */
2545 if (namelen + count_digits(rec->ino) + 1 >
2546 BTRFS_NAME_LEN) {
2547 ret = -EFBIG;
2548 goto out;
2549 }
2550 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2551 ".%llu", rec->ino);
2552 namelen += count_digits(rec->ino) + 1;
2553 ret = btrfs_add_link(trans, root, rec->ino,
2554 lost_found_ino, namebuf,
2555 namelen, type, NULL, 1);
2556 }
2557 if (ret < 0) {
2558 fprintf(stderr,
2559 "Failed to link the inode %llu to %s dir: %s\n",
2560 rec->ino, dir_name, strerror(-ret));
2561 goto out;
2562 }
2563 /*
2564 * Just increase the found_link, don't actually add the
2565 * backref. This will make things easier and this inode
2566 * record will be freed after the repair is done.
2567 * So fsck will not report problem about this inode.
2568 */
2569 rec->found_link++;
2570 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2571 namelen, namebuf, dir_name);
2572 }
2573 printf("Fixed the nlink of inode %llu\n", rec->ino);
2574 out:
2575 /*
2576 * Clear the flag anyway, or we will loop forever for the same inode
2577 * as it will not be removed from the bad inode list and the dead loop
2578 * happens.
2579 */
2580 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2581 btrfs_release_path(path);
2582 return ret;
2583 }
2584
2585 /*
2586 * Check if there is any normal(reg or prealloc) file extent for given
2587 * ino.
2588 * This is used to determine the file type when neither its dir_index/item or
2589 * inode_item exists.
2590 *
2591 * This will *NOT* report error, if any error happens, just consider it does
2592 * not have any normal file extent.
2593 */
2594 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
2595 {
2596 struct btrfs_path *path;
2597 struct btrfs_key key;
2598 struct btrfs_key found_key;
2599 struct btrfs_file_extent_item *fi;
2600 u8 type;
2601 int ret = 0;
2602
2603 path = btrfs_alloc_path();
2604 if (!path)
2605 goto out;
2606 key.objectid = ino;
2607 key.type = BTRFS_EXTENT_DATA_KEY;
2608 key.offset = 0;
2609
2610 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2611 if (ret < 0) {
2612 ret = 0;
2613 goto out;
2614 }
2615 if (ret && path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2616 ret = btrfs_next_leaf(root, path);
2617 if (ret) {
2618 ret = 0;
2619 goto out;
2620 }
2621 }
2622 while (1) {
2623 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2624 path->slots[0]);
2625 if (found_key.objectid != ino ||
2626 found_key.type != BTRFS_EXTENT_DATA_KEY)
2627 break;
2628 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
2629 struct btrfs_file_extent_item);
2630 type = btrfs_file_extent_type(path->nodes[0], fi);
2631 if (type != BTRFS_FILE_EXTENT_INLINE) {
2632 ret = 1;
2633 goto out;
2634 }
2635 }
2636 out:
2637 btrfs_free_path(path);
2638 return ret;
2639 }
2640
2641 static u32 btrfs_type_to_imode(u8 type)
2642 {
2643 static u32 imode_by_btrfs_type[] = {
2644 [BTRFS_FT_REG_FILE] = S_IFREG,
2645 [BTRFS_FT_DIR] = S_IFDIR,
2646 [BTRFS_FT_CHRDEV] = S_IFCHR,
2647 [BTRFS_FT_BLKDEV] = S_IFBLK,
2648 [BTRFS_FT_FIFO] = S_IFIFO,
2649 [BTRFS_FT_SOCK] = S_IFSOCK,
2650 [BTRFS_FT_SYMLINK] = S_IFLNK,
2651 };
2652
2653 return imode_by_btrfs_type[(type)];
2654 }
2655
2656 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
2657 struct btrfs_root *root,
2658 struct btrfs_path *path,
2659 struct inode_record *rec)
2660 {
2661 u8 filetype;
2662 u32 mode = 0700;
2663 int type_recovered = 0;
2664 int ret = 0;
2665
2666 printf("Trying to rebuild inode:%llu\n", rec->ino);
2667
2668 type_recovered = !find_file_type(rec, &filetype);
2669
2670 /*
2671 * Try to determine inode type if type not found.
2672 *
2673 * For found regular file extent, it must be FILE.
2674 * For found dir_item/index, it must be DIR.
2675 *
2676 * For undetermined one, use FILE as fallback.
2677 *
2678 * TODO:
2679 * 1. If found backref(inode_index/item is already handled) to it,
2680 * it must be DIR.
2681 * Need new inode-inode ref structure to allow search for that.
2682 */
2683 if (!type_recovered) {
2684 if (rec->found_file_extent &&
2685 find_normal_file_extent(root, rec->ino)) {
2686 type_recovered = 1;
2687 filetype = BTRFS_FT_REG_FILE;
2688 } else if (rec->found_dir_item) {
2689 type_recovered = 1;
2690 filetype = BTRFS_FT_DIR;
2691 } else if (!list_empty(&rec->orphan_extents)) {
2692 type_recovered = 1;
2693 filetype = BTRFS_FT_REG_FILE;
2694 } else{
2695 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
2696 rec->ino);
2697 type_recovered = 1;
2698 filetype = BTRFS_FT_REG_FILE;
2699 }
2700 }
2701
2702 ret = btrfs_new_inode(trans, root, rec->ino,
2703 mode | btrfs_type_to_imode(filetype));
2704 if (ret < 0)
2705 goto out;
2706
2707 /*
2708 * Here inode rebuild is done, we only rebuild the inode item,
2709 * don't repair the nlink(like move to lost+found).
2710 * That is the job of nlink repair.
2711 *
2712 * We just fill the record and return
2713 */
2714 rec->found_dir_item = 1;
2715 rec->imode = mode | btrfs_type_to_imode(filetype);
2716 rec->nlink = 0;
2717 rec->errors &= ~I_ERR_NO_INODE_ITEM;
2718 /* Ensure the inode_nlinks repair function will be called */
2719 rec->errors |= I_ERR_LINK_COUNT_WRONG;
2720 out:
2721 return ret;
2722 }
2723
2724 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
2725 struct btrfs_root *root,
2726 struct btrfs_path *path,
2727 struct inode_record *rec)
2728 {
2729 struct orphan_data_extent *orphan;
2730 struct orphan_data_extent *tmp;
2731 int ret = 0;
2732
2733 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
2734 /*
2735 * Check for conflicting file extents
2736 *
2737 * Here we don't know whether the extents is compressed or not,
2738 * so we can only assume it not compressed nor data offset,
2739 * and use its disk_len as extent length.
2740 */
2741 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
2742 orphan->offset, orphan->disk_len, 0);
2743 btrfs_release_path(path);
2744 if (ret < 0)
2745 goto out;
2746 if (!ret) {
2747 fprintf(stderr,
2748 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
2749 orphan->disk_bytenr, orphan->disk_len);
2750 ret = btrfs_free_extent(trans,
2751 root->fs_info->extent_root,
2752 orphan->disk_bytenr, orphan->disk_len,
2753 0, root->objectid, orphan->objectid,
2754 orphan->offset);
2755 if (ret < 0)
2756 goto out;
2757 }
2758 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
2759 orphan->offset, orphan->disk_bytenr,
2760 orphan->disk_len, orphan->disk_len);
2761 if (ret < 0)
2762 goto out;
2763
2764 /* Update file size info */
2765 rec->found_size += orphan->disk_len;
2766 if (rec->found_size == rec->nbytes)
2767 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2768
2769 /* Update the file extent hole info too */
2770 ret = del_file_extent_hole(&rec->holes, orphan->offset,
2771 orphan->disk_len);
2772 if (ret < 0)
2773 goto out;
2774 if (RB_EMPTY_ROOT(&rec->holes))
2775 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
2776
2777 list_del(&orphan->list);
2778 free(orphan);
2779 }
2780 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
2781 out:
2782 return ret;
2783 }
2784
2785 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
2786 struct btrfs_root *root,
2787 struct btrfs_path *path,
2788 struct inode_record *rec)
2789 {
2790 struct rb_node *node;
2791 struct file_extent_hole *hole;
2792 int found = 0;
2793 int ret = 0;
2794
2795 node = rb_first(&rec->holes);
2796
2797 while (node) {
2798 found = 1;
2799 hole = rb_entry(node, struct file_extent_hole, node);
2800 ret = btrfs_punch_hole(trans, root, rec->ino,
2801 hole->start, hole->len);
2802 if (ret < 0)
2803 goto out;
2804 ret = del_file_extent_hole(&rec->holes, hole->start,
2805 hole->len);
2806 if (ret < 0)
2807 goto out;
2808 if (RB_EMPTY_ROOT(&rec->holes))
2809 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
2810 node = rb_first(&rec->holes);
2811 }
2812 /* special case for a file losing all its file extent */
2813 if (!found) {
2814 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
2815 round_up(rec->isize, root->sectorsize));
2816 if (ret < 0)
2817 goto out;
2818 }
2819 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
2820 rec->ino, root->objectid);
2821 out:
2822 return ret;
2823 }
2824
2825 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
2826 {
2827 struct btrfs_trans_handle *trans;
2828 struct btrfs_path *path;
2829 int ret = 0;
2830
2831 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
2832 I_ERR_NO_ORPHAN_ITEM |
2833 I_ERR_LINK_COUNT_WRONG |
2834 I_ERR_NO_INODE_ITEM |
2835 I_ERR_FILE_EXTENT_ORPHAN |
2836 I_ERR_FILE_EXTENT_DISCOUNT|
2837 I_ERR_FILE_NBYTES_WRONG)))
2838 return rec->errors;
2839
2840 path = btrfs_alloc_path();
2841 if (!path)
2842 return -ENOMEM;
2843
2844 /*
2845 * For nlink repair, it may create a dir and add link, so
2846 * 2 for parent(256)'s dir_index and dir_item
2847 * 2 for lost+found dir's inode_item and inode_ref
2848 * 1 for the new inode_ref of the file
2849 * 2 for lost+found dir's dir_index and dir_item for the file
2850 */
2851 trans = btrfs_start_transaction(root, 7);
2852 if (IS_ERR(trans)) {
2853 btrfs_free_path(path);
2854 return PTR_ERR(trans);
2855 }
2856
2857 if (rec->errors & I_ERR_NO_INODE_ITEM)
2858 ret = repair_inode_no_item(trans, root, path, rec);
2859 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
2860 ret = repair_inode_orphan_extent(trans, root, path, rec);
2861 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
2862 ret = repair_inode_discount_extent(trans, root, path, rec);
2863 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
2864 ret = repair_inode_isize(trans, root, path, rec);
2865 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
2866 ret = repair_inode_orphan_item(trans, root, path, rec);
2867 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
2868 ret = repair_inode_nlinks(trans, root, path, rec);
2869 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
2870 ret = repair_inode_nbytes(trans, root, path, rec);
2871 btrfs_commit_transaction(trans, root);
2872 btrfs_free_path(path);
2873 return ret;
2874 }
2875
2876 static int check_inode_recs(struct btrfs_root *root,
2877 struct cache_tree *inode_cache)
2878 {
2879 struct cache_extent *cache;
2880 struct ptr_node *node;
2881 struct inode_record *rec;
2882 struct inode_backref *backref;
2883 int stage = 0;
2884 int ret = 0;
2885 int err = 0;
2886 u64 error = 0;
2887 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2888
2889 if (btrfs_root_refs(&root->root_item) == 0) {
2890 if (!cache_tree_empty(inode_cache))
2891 fprintf(stderr, "warning line %d\n", __LINE__);
2892 return 0;
2893 }
2894
2895 /*
2896 * We need to record the highest inode number for later 'lost+found'
2897 * dir creation.
2898 * We must select an ino not used/referred by any existing inode, or
2899 * 'lost+found' ino may be a missing ino in a corrupted leaf,
2900 * this may cause 'lost+found' dir has wrong nlinks.
2901 */
2902 cache = last_cache_extent(inode_cache);
2903 if (cache) {
2904 node = container_of(cache, struct ptr_node, cache);
2905 rec = node->data;
2906 if (rec->ino > root->highest_inode)
2907 root->highest_inode = rec->ino;
2908 }
2909
2910 /*
2911 * We need to repair backrefs first because we could change some of the
2912 * errors in the inode recs.
2913 *
2914 * We also need to go through and delete invalid backrefs first and then
2915 * add the correct ones second. We do this because we may get EEXIST
2916 * when adding back the correct index because we hadn't yet deleted the
2917 * invalid index.
2918 *
2919 * For example, if we were missing a dir index then the directories
2920 * isize would be wrong, so if we fixed the isize to what we thought it
2921 * would be and then fixed the backref we'd still have a invalid fs, so
2922 * we need to add back the dir index and then check to see if the isize
2923 * is still wrong.
2924 */
2925 while (stage < 3) {
2926 stage++;
2927 if (stage == 3 && !err)
2928 break;
2929
2930 cache = search_cache_extent(inode_cache, 0);
2931 while (repair && cache) {
2932 node = container_of(cache, struct ptr_node, cache);
2933 rec = node->data;
2934 cache = next_cache_extent(cache);
2935
2936 /* Need to free everything up and rescan */
2937 if (stage == 3) {
2938 remove_cache_extent(inode_cache, &node->cache);
2939 free(node);
2940 free_inode_rec(rec);
2941 continue;
2942 }
2943
2944 if (list_empty(&rec->backrefs))
2945 continue;
2946
2947 ret = repair_inode_backrefs(root, rec, inode_cache,
2948 stage == 1);
2949 if (ret < 0) {
2950 err = ret;
2951 stage = 2;
2952 break;
2953 } if (ret > 0) {
2954 err = -EAGAIN;
2955 }
2956 }
2957 }
2958 if (err)
2959 return err;
2960
2961 rec = get_inode_rec(inode_cache, root_dirid, 0);
2962 BUG_ON(IS_ERR(rec));
2963 if (rec) {
2964 ret = check_root_dir(rec);
2965 if (ret) {
2966 fprintf(stderr, "root %llu root dir %llu error\n",
2967 (unsigned long long)root->root_key.objectid,
2968 (unsigned long long)root_dirid);
2969 print_inode_error(root, rec);
2970 error++;
2971 }
2972 } else {
2973 if (repair) {
2974 struct btrfs_trans_handle *trans;
2975
2976 trans = btrfs_start_transaction(root, 1);
2977 if (IS_ERR(trans)) {
2978 err = PTR_ERR(trans);
2979 return err;
2980 }
2981
2982 fprintf(stderr,
2983 "root %llu missing its root dir, recreating\n",
2984 (unsigned long long)root->objectid);
2985
2986 ret = btrfs_make_root_dir(trans, root, root_dirid);
2987 BUG_ON(ret);
2988
2989 btrfs_commit_transaction(trans, root);
2990 return -EAGAIN;
2991 }
2992
2993 fprintf(stderr, "root %llu root dir %llu not found\n",
2994 (unsigned long long)root->root_key.objectid,
2995 (unsigned long long)root_dirid);
2996 }
2997
2998 while (1) {
2999 cache = search_cache_extent(inode_cache, 0);
3000 if (!cache)
3001 break;
3002 node = container_of(cache, struct ptr_node, cache);
3003 rec = node->data;
3004 remove_cache_extent(inode_cache, &node->cache);
3005 free(node);
3006 if (rec->ino == root_dirid ||
3007 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3008 free_inode_rec(rec);
3009 continue;
3010 }
3011
3012 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3013 ret = check_orphan_item(root, rec->ino);
3014 if (ret == 0)
3015 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3016 if (can_free_inode_rec(rec)) {
3017 free_inode_rec(rec);
3018 continue;
3019 }
3020 }
3021
3022 if (!rec->found_inode_item)
3023 rec->errors |= I_ERR_NO_INODE_ITEM;
3024 if (rec->found_link != rec->nlink)
3025 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3026 if (repair) {
3027 ret = try_repair_inode(root, rec);
3028 if (ret == 0 && can_free_inode_rec(rec)) {
3029 free_inode_rec(rec);
3030 continue;
3031 }
3032 ret = 0;
3033 }
3034
3035 if (!(repair && ret == 0))
3036 error++;
3037 print_inode_error(root, rec);
3038 list_for_each_entry(backref, &rec->backrefs, list) {
3039 if (!backref->found_dir_item)
3040 backref->errors |= REF_ERR_NO_DIR_ITEM;
3041 if (!backref->found_dir_index)
3042 backref->errors |= REF_ERR_NO_DIR_INDEX;
3043 if (!backref->found_inode_ref)
3044 backref->errors |= REF_ERR_NO_INODE_REF;
3045 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3046 " namelen %u name %s filetype %d errors %x",
3047 (unsigned long long)backref->dir,
3048 (unsigned long long)backref->index,
3049 backref->namelen, backref->name,
3050 backref->filetype, backref->errors);
3051 print_ref_error(backref->errors);
3052 }
3053 free_inode_rec(rec);
3054 }
3055 return (error > 0) ? -1 : 0;
3056 }
3057
3058 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3059 u64 objectid)
3060 {
3061 struct cache_extent *cache;
3062 struct root_record *rec = NULL;
3063 int ret;
3064
3065 cache = lookup_cache_extent(root_cache, objectid, 1);
3066 if (cache) {
3067 rec = container_of(cache, struct root_record, cache);
3068 } else {
3069 rec = calloc(1, sizeof(*rec));
3070 if (!rec)
3071 return ERR_PTR(-ENOMEM);
3072 rec->objectid = objectid;
3073 INIT_LIST_HEAD(&rec->backrefs);
3074 rec->cache.start = objectid;
3075 rec->cache.size = 1;
3076
3077 ret = insert_cache_extent(root_cache, &rec->cache);
3078 if (ret)
3079 return ERR_PTR(-EEXIST);
3080 }
3081 return rec;
3082 }
3083
3084 static struct root_backref *get_root_backref(struct root_record *rec,
3085 u64 ref_root, u64 dir, u64 index,
3086 const char *name, int namelen)
3087 {
3088 struct root_backref *backref;
3089
3090 list_for_each_entry(backref, &rec->backrefs, list) {
3091 if (backref->ref_root != ref_root || backref->dir != dir ||
3092 backref->namelen != namelen)
3093 continue;
3094 if (memcmp(name, backref->name, namelen))
3095 continue;
3096 return backref;
3097 }
3098
3099 backref = calloc(1, sizeof(*backref) + namelen + 1);
3100 if (!backref)
3101 return NULL;
3102 backref->ref_root = ref_root;
3103 backref->dir = dir;
3104 backref->index = index;
3105 backref->namelen = namelen;
3106 memcpy(backref->name, name, namelen);
3107 backref->name[namelen] = '\0';
3108 list_add_tail(&backref->list, &rec->backrefs);
3109 return backref;
3110 }
3111
3112 static void free_root_record(struct cache_extent *cache)
3113 {
3114 struct root_record *rec;
3115 struct root_backref *backref;
3116
3117 rec = container_of(cache, struct root_record, cache);
3118 while (!list_empty(&rec->backrefs)) {
3119 backref = list_entry(rec->backrefs.next,
3120 struct root_backref, list);
3121 list_del(&backref->list);
3122 free(backref);
3123 }
3124
3125 kfree(rec);
3126 }
3127
3128 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3129
3130 static int add_root_backref(struct cache_tree *root_cache,
3131 u64 root_id, u64 ref_root, u64 dir, u64 index,
3132 const char *name, int namelen,
3133 int item_type, int errors)
3134 {
3135 struct root_record *rec;
3136 struct root_backref *backref;
3137
3138 rec = get_root_rec(root_cache, root_id);
3139 BUG_ON(IS_ERR(rec));
3140 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3141 BUG_ON(!backref);
3142
3143 backref->errors |= errors;
3144
3145 if (item_type != BTRFS_DIR_ITEM_KEY) {
3146 if (backref->found_dir_index || backref->found_back_ref ||
3147 backref->found_forward_ref) {
3148 if (backref->index != index)
3149 backref->errors |= REF_ERR_INDEX_UNMATCH;
3150 } else {
3151 backref->index = index;
3152 }
3153 }
3154
3155 if (item_type == BTRFS_DIR_ITEM_KEY) {
3156 if (backref->found_forward_ref)
3157 rec->found_ref++;
3158 backref->found_dir_item = 1;
3159 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3160 backref->found_dir_index = 1;
3161 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3162 if (backref->found_forward_ref)
3163 backref->errors |= REF_ERR_DUP_ROOT_REF;
3164 else if (backref->found_dir_item)
3165 rec->found_ref++;
3166 backref->found_forward_ref = 1;
3167 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3168 if (backref->found_back_ref)
3169 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3170 backref->found_back_ref = 1;
3171 } else {
3172 BUG_ON(1);
3173 }
3174
3175 if (backref->found_forward_ref && backref->found_dir_item)
3176 backref->reachable = 1;
3177 return 0;
3178 }
3179
3180 static int merge_root_recs(struct btrfs_root *root,
3181 struct cache_tree *src_cache,
3182 struct cache_tree *dst_cache)
3183 {
3184 struct cache_extent *cache;
3185 struct ptr_node *node;
3186 struct inode_record *rec;
3187 struct inode_backref *backref;
3188 int ret = 0;
3189
3190 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3191 free_inode_recs_tree(src_cache);
3192 return 0;
3193 }
3194
3195 while (1) {
3196 cache = search_cache_extent(src_cache, 0);
3197 if (!cache)
3198 break;
3199 node = container_of(cache, struct ptr_node, cache);
3200 rec = node->data;
3201 remove_cache_extent(src_cache, &node->cache);
3202 free(node);
3203
3204 ret = is_child_root(root, root->objectid, rec->ino);
3205 if (ret < 0)
3206 break;
3207 else if (ret == 0)
3208 goto skip;
3209
3210 list_for_each_entry(backref, &rec->backrefs, list) {
3211 BUG_ON(backref->found_inode_ref);
3212 if (backref->found_dir_item)
3213 add_root_backref(dst_cache, rec->ino,
3214 root->root_key.objectid, backref->dir,
3215 backref->index, backref->name,
3216 backref->namelen, BTRFS_DIR_ITEM_KEY,
3217 backref->errors);
3218 if (backref->found_dir_index)
3219 add_root_backref(dst_cache, rec->ino,
3220 root->root_key.objectid, backref->dir,
3221 backref->index, backref->name,
3222 backref->namelen, BTRFS_DIR_INDEX_KEY,
3223 backref->errors);
3224 }
3225 skip:
3226 free_inode_rec(rec);
3227 }
3228 if (ret < 0)
3229 return ret;
3230 return 0;
3231 }
3232
3233 static int check_root_refs(struct btrfs_root *root,
3234 struct cache_tree *root_cache)
3235 {
3236 struct root_record *rec;
3237 struct root_record *ref_root;
3238 struct root_backref *backref;
3239 struct cache_extent *cache;
3240 int loop = 1;
3241 int ret;
3242 int error;
3243 int errors = 0;
3244
3245 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3246 BUG_ON(IS_ERR(rec));
3247 rec->found_ref = 1;
3248
3249 /* fixme: this can not detect circular references */
3250 while (loop) {
3251 loop = 0;
3252 cache = search_cache_extent(root_cache, 0);
3253 while (1) {
3254 if (!cache)
3255 break;
3256 rec = container_of(cache, struct root_record, cache);
3257 cache = next_cache_extent(cache);
3258
3259 if (rec->found_ref == 0)
3260 continue;
3261
3262 list_for_each_entry(backref, &rec->backrefs, list) {
3263 if (!backref->reachable)
3264 continue;
3265
3266 ref_root = get_root_rec(root_cache,
3267 backref->ref_root);
3268 BUG_ON(IS_ERR(ref_root));
3269 if (ref_root->found_ref > 0)
3270 continue;
3271
3272 backref->reachable = 0;
3273 rec->found_ref--;
3274 if (rec->found_ref == 0)
3275 loop = 1;
3276 }
3277 }
3278 }
3279
3280 cache = search_cache_extent(root_cache, 0);
3281 while (1) {
3282 if (!cache)
3283 break;
3284 rec = container_of(cache, struct root_record, cache);
3285 cache = next_cache_extent(cache);
3286
3287 if (rec->found_ref == 0 &&
3288 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3289 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3290 ret = check_orphan_item(root->fs_info->tree_root,
3291 rec->objectid);
3292 if (ret == 0)
3293 continue;
3294
3295 /*
3296 * If we don't have a root item then we likely just have
3297 * a dir item in a snapshot for this root but no actual
3298 * ref key or anything so it's meaningless.
3299 */
3300 if (!rec->found_root_item)
3301 continue;
3302 errors++;
3303 fprintf(stderr, "fs tree %llu not referenced\n",
3304 (unsigned long long)rec->objectid);
3305 }
3306
3307 error = 0;
3308 if (rec->found_ref > 0 && !rec->found_root_item)
3309 error = 1;
3310 list_for_each_entry(backref, &rec->backrefs, list) {
3311 if (!backref->found_dir_item)
3312 backref->errors |= REF_ERR_NO_DIR_ITEM;
3313 if (!backref->found_dir_index)
3314 backref->errors |= REF_ERR_NO_DIR_INDEX;
3315 if (!backref->found_back_ref)
3316 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3317 if (!backref->found_forward_ref)
3318 backref->errors |= REF_ERR_NO_ROOT_REF;
3319 if (backref->reachable && backref->errors)
3320 error = 1;
3321 }
3322 if (!error)
3323 continue;
3324
3325 errors++;
3326 fprintf(stderr, "fs tree %llu refs %u %s\n",
3327 (unsigned long long)rec->objectid, rec->found_ref,
3328 rec->found_root_item ? "" : "not found");
3329
3330 list_for_each_entry(backref, &rec->backrefs, list) {
3331 if (!backref->reachable)
3332 continue;
3333 if (!backref->errors && rec->found_root_item)
3334 continue;
3335 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3336 " index %llu namelen %u name %s errors %x\n",
3337 (unsigned long long)backref->ref_root,
3338 (unsigned long long)backref->dir,
3339 (unsigned long long)backref->index,
3340 backref->namelen, backref->name,
3341 backref->errors);
3342 print_ref_error(backref->errors);
3343 }
3344 }
3345 return errors > 0 ? 1 : 0;
3346 }
3347
3348 static int process_root_ref(struct extent_buffer *eb, int slot,
3349 struct btrfs_key *key,
3350 struct cache_tree *root_cache)
3351 {
3352 u64 dirid;
3353 u64 index;
3354 u32 len;
3355 u32 name_len;
3356 struct btrfs_root_ref *ref;
3357 char namebuf[BTRFS_NAME_LEN];
3358 int error;
3359
3360 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3361
3362 dirid = btrfs_root_ref_dirid(eb, ref);
3363 index = btrfs_root_ref_sequence(eb, ref);
3364 name_len = btrfs_root_ref_name_len(eb, ref);
3365
3366 if (name_len <= BTRFS_NAME_LEN) {
3367 len = name_len;
3368 error = 0;
3369 } else {
3370 len = BTRFS_NAME_LEN;
3371 error = REF_ERR_NAME_TOO_LONG;
3372 }
3373 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3374
3375 if (key->type == BTRFS_ROOT_REF_KEY) {
3376 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3377 index, namebuf, len, key->type, error);
3378 } else {
3379 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3380 index, namebuf, len, key->type, error);
3381 }
3382 return 0;
3383 }
3384
3385 static void free_corrupt_block(struct cache_extent *cache)
3386 {
3387 struct btrfs_corrupt_block *corrupt;
3388
3389 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3390 free(corrupt);
3391 }
3392
3393 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3394
3395 /*
3396 * Repair the btree of the given root.
3397 *
3398 * The fix is to remove the node key in corrupt_blocks cache_tree.
3399 * and rebalance the tree.
3400 * After the fix, the btree should be writeable.
3401 */
3402 static int repair_btree(struct btrfs_root *root,
3403 struct cache_tree *corrupt_blocks)
3404 {
3405 struct btrfs_trans_handle *trans;
3406 struct btrfs_path *path;
3407 struct btrfs_corrupt_block *corrupt;
3408 struct cache_extent *cache;
3409 struct btrfs_key key;
3410 u64 offset;
3411 int level;
3412 int ret = 0;
3413
3414 if (cache_tree_empty(corrupt_blocks))
3415 return 0;
3416
3417 path = btrfs_alloc_path();
3418 if (!path)
3419 return -ENOMEM;
3420
3421 trans = btrfs_start_transaction(root, 1);
3422 if (IS_ERR(trans)) {
3423 ret = PTR_ERR(trans);
3424 fprintf(stderr, "Error starting transaction: %s\n",
3425 strerror(-ret));
3426 goto out_free_path;
3427 }
3428 cache = first_cache_extent(corrupt_blocks);
3429 while (cache) {
3430 corrupt = container_of(cache, struct btrfs_corrupt_block,
3431 cache);
3432 level = corrupt->level;
3433 path->lowest_level = level;
3434 key.objectid = corrupt->key.objectid;
3435 key.type = corrupt->key.type;
3436 key.offset = corrupt->key.offset;
3437
3438 /*
3439 * Here we don't want to do any tree balance, since it may
3440 * cause a balance with corrupted brother leaf/node,
3441 * so ins_len set to 0 here.
3442 * Balance will be done after all corrupt node/leaf is deleted.
3443 */
3444 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
3445 if (ret < 0)
3446 goto out;
3447 offset = btrfs_node_blockptr(path->nodes[level],
3448 path->slots[level]);
3449
3450 /* Remove the ptr */
3451 ret = btrfs_del_ptr(trans, root, path, level,
3452 path->slots[level]);
3453 if (ret < 0)
3454 goto out;
3455 /*
3456 * Remove the corresponding extent
3457 * return value is not concerned.
3458 */
3459 btrfs_release_path(path);
3460 ret = btrfs_free_extent(trans, root, offset, root->nodesize,
3461 0, root->root_key.objectid,
3462 level - 1, 0);
3463 cache = next_cache_extent(cache);
3464 }
3465
3466 /* Balance the btree using btrfs_search_slot() */
3467 cache = first_cache_extent(corrupt_blocks);
3468 while (cache) {
3469 corrupt = container_of(cache, struct btrfs_corrupt_block,
3470 cache);
3471 memcpy(&key, &corrupt->key, sizeof(key));
3472 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3473 if (ret < 0)
3474 goto out;
3475 /* return will always >0 since it won't find the item */
3476 ret = 0;
3477 btrfs_release_path(path);
3478 cache = next_cache_extent(cache);
3479 }
3480 out:
3481 btrfs_commit_transaction(trans, root);
3482 out_free_path:
3483 btrfs_free_path(path);
3484 return ret;
3485 }
3486
3487 static int check_fs_root(struct btrfs_root *root,
3488 struct cache_tree *root_cache,
3489 struct walk_control *wc)
3490 {
3491 int ret = 0;
3492 int err = 0;
3493 int wret;
3494 int level;
3495 struct btrfs_path path;
3496 struct shared_node root_node;
3497 struct root_record *rec;
3498 struct btrfs_root_item *root_item = &root->root_item;
3499 struct cache_tree corrupt_blocks;
3500 struct orphan_data_extent *orphan;
3501 struct orphan_data_extent *tmp;
3502 enum btrfs_tree_block_status status;
3503
3504 /*
3505 * Reuse the corrupt_block cache tree to record corrupted tree block
3506 *
3507 * Unlike the usage in extent tree check, here we do it in a per
3508 * fs/subvol tree base.
3509 */
3510 cache_tree_init(&corrupt_blocks);
3511 root->fs_info->corrupt_blocks = &corrupt_blocks;
3512
3513 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3514 rec = get_root_rec(root_cache, root->root_key.objectid);
3515 BUG_ON(IS_ERR(rec));
3516 if (btrfs_root_refs(root_item) > 0)
3517 rec->found_root_item = 1;
3518 }
3519
3520 btrfs_init_path(&path);
3521 memset(&root_node, 0, sizeof(root_node));
3522 cache_tree_init(&root_node.root_cache);
3523 cache_tree_init(&root_node.inode_cache);
3524
3525 /* Move the orphan extent record to corresponding inode_record */
3526 list_for_each_entry_safe(orphan, tmp,
3527 &root->orphan_data_extents, list) {
3528 struct inode_record *inode;
3529
3530 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3531 1);
3532 BUG_ON(IS_ERR(inode));
3533 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3534 list_move(&orphan->list, &inode->orphan_extents);
3535 }
3536
3537 level = btrfs_header_level(root->node);
3538 memset(wc->nodes, 0, sizeof(wc->nodes));
3539 wc->nodes[level] = &root_node;
3540 wc->active_node = level;
3541 wc->root_level = level;
3542
3543 /* We may not have checked the root block, lets do that now */
3544 if (btrfs_is_leaf(root->node))
3545 status = btrfs_check_leaf(root, NULL, root->node);
3546 else
3547 status = btrfs_check_node(root, NULL, root->node);
3548 if (status != BTRFS_TREE_BLOCK_CLEAN)
3549 return -EIO;
3550
3551 if (btrfs_root_refs(root_item) > 0 ||
3552 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3553 path.nodes[level] = root->node;
3554 extent_buffer_get(root->node);
3555 path.slots[level] = 0;
3556 } else {
3557 struct btrfs_key key;
3558 struct btrfs_disk_key found_key;
3559
3560 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3561 level = root_item->drop_level;
3562 path.lowest_level = level;
3563 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3564 if (wret < 0)
3565 goto skip_walking;
3566 btrfs_node_key(path.nodes[level], &found_key,
3567 path.slots[level]);
3568 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3569 sizeof(found_key)));
3570 }
3571
3572 while (1) {
3573 wret = walk_down_tree(root, &path, wc, &level);
3574 if (wret < 0)
3575 ret = wret;
3576 if (wret != 0)
3577 break;
3578
3579 wret = walk_up_tree(root, &path, wc, &level);
3580 if (wret < 0)
3581 ret = wret;
3582 if (wret != 0)
3583 break;
3584 }
3585 skip_walking:
3586 btrfs_release_path(&path);
3587
3588 if (!cache_tree_empty(&corrupt_blocks)) {
3589 struct cache_extent *cache;
3590 struct btrfs_corrupt_block *corrupt;
3591
3592 printf("The following tree block(s) is corrupted in tree %llu:\n",
3593 root->root_key.objectid);
3594 cache = first_cache_extent(&corrupt_blocks);
3595 while (cache) {
3596 corrupt = container_of(cache,
3597 struct btrfs_corrupt_block,
3598 cache);
3599 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
3600 cache->start, corrupt->level,
3601 corrupt->key.objectid, corrupt->key.type,
3602 corrupt->key.offset);
3603 cache = next_cache_extent(cache);
3604 }
3605 if (repair) {
3606 printf("Try to repair the btree for root %llu\n",
3607 root->root_key.objectid);
3608 ret = repair_btree(root, &corrupt_blocks);
3609 if (ret < 0)
3610 fprintf(stderr, "Failed to repair btree: %s\n",
3611 strerror(-ret));
3612 if (!ret)
3613 printf("Btree for root %llu is fixed\n",
3614 root->root_key.objectid);
3615 }
3616 }
3617
3618 err = merge_root_recs(root, &root_node.root_cache, root_cache);
3619 if (err < 0)
3620 ret = err;
3621
3622 if (root_node.current) {
3623 root_node.current->checked = 1;
3624 maybe_free_inode_rec(&root_node.inode_cache,
3625 root_node.current);
3626 }
3627
3628 err = check_inode_recs(root, &root_node.inode_cache);
3629 if (!ret)
3630 ret = err;
3631
3632 free_corrupt_blocks_tree(&corrupt_blocks);
3633 root->fs_info->corrupt_blocks = NULL;
3634 free_orphan_data_extents(&root->orphan_data_extents);
3635 return ret;
3636 }
3637
3638 static int fs_root_objectid(u64 objectid)
3639 {
3640 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
3641 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
3642 return 1;
3643 return is_fstree(objectid);
3644 }
3645
3646 static int check_fs_roots(struct btrfs_root *root,
3647 struct cache_tree *root_cache)
3648 {
3649 struct btrfs_path path;
3650 struct btrfs_key key;
3651 struct walk_control wc;
3652 struct extent_buffer *leaf, *tree_node;
3653 struct btrfs_root *tmp_root;
3654 struct btrfs_root *tree_root = root->fs_info->tree_root;
3655 int ret;
3656 int err = 0;
3657
3658 if (ctx.progress_enabled) {
3659 ctx.tp = TASK_FS_ROOTS;
3660 task_start(ctx.info);
3661 }
3662
3663 /*
3664 * Just in case we made any changes to the extent tree that weren't
3665 * reflected into the free space cache yet.
3666 */
3667 if (repair)
3668 reset_cached_block_groups(root->fs_info);
3669 memset(&wc, 0, sizeof(wc));
3670 cache_tree_init(&wc.shared);
3671 btrfs_init_path(&path);
3672
3673 again:
3674 key.offset = 0;
3675 key.objectid = 0;
3676 key.type = BTRFS_ROOT_ITEM_KEY;
3677 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
3678 if (ret < 0) {
3679 err = 1;
3680 goto out;
3681 }
3682 tree_node = tree_root->node;
3683 while (1) {
3684 if (tree_node != tree_root->node) {
3685 free_root_recs_tree(root_cache);
3686 btrfs_release_path(&path);
3687 goto again;
3688 }
3689 leaf = path.nodes[0];
3690 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
3691 ret = btrfs_next_leaf(tree_root, &path);
3692 if (ret) {
3693 if (ret < 0)
3694 err = 1;
3695 break;
3696 }
3697 leaf = path.nodes[0];
3698 }
3699 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
3700 if (key.type == BTRFS_ROOT_ITEM_KEY &&
3701 fs_root_objectid(key.objectid)) {
3702 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3703 tmp_root = btrfs_read_fs_root_no_cache(
3704 root->fs_info, &key);
3705 } else {
3706 key.offset = (u64)-1;
3707 tmp_root = btrfs_read_fs_root(
3708 root->fs_info, &key);
3709 }
3710 if (IS_ERR(tmp_root)) {
3711 err = 1;
3712 goto next;
3713 }
3714 ret = check_fs_root(tmp_root, root_cache, &wc);
3715 if (ret == -EAGAIN) {
3716 free_root_recs_tree(root_cache);
3717 btrfs_release_path(&path);
3718 goto again;
3719 }
3720 if (ret)
3721 err = 1;
3722 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
3723 btrfs_free_fs_root(tmp_root);
3724 } else if (key.type == BTRFS_ROOT_REF_KEY ||
3725 key.type == BTRFS_ROOT_BACKREF_KEY) {
3726 process_root_ref(leaf, path.slots[0], &key,
3727 root_cache);
3728 }
3729 next:
3730 path.slots[0]++;
3731 }
3732 out:
3733 btrfs_release_path(&path);
3734 if (err)
3735 free_extent_cache_tree(&wc.shared);
3736 if (!cache_tree_empty(&wc.shared))
3737 fprintf(stderr, "warning line %d\n", __LINE__);
3738
3739 task_stop(ctx.info);
3740
3741 return err;
3742 }
3743
3744 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
3745 {
3746 struct list_head *cur = rec->backrefs.next;
3747 struct extent_backref *back;
3748 struct tree_backref *tback;
3749 struct data_backref *dback;
3750 u64 found = 0;
3751 int err = 0;
3752
3753 while(cur != &rec->backrefs) {
3754 back = list_entry(cur, struct extent_backref, list);
3755 cur = cur->next;
3756 if (!back->found_extent_tree) {
3757 err = 1;
3758 if (!print_errs)
3759 goto out;
3760 if (back->is_data) {
3761 dback = (struct data_backref *)back;
3762 fprintf(stderr, "Backref %llu %s %llu"
3763 " owner %llu offset %llu num_refs %lu"
3764 " not found in extent tree\n",
3765 (unsigned long long)rec->start,
3766 back->full_backref ?
3767 "parent" : "root",
3768 back->full_backref ?
3769 (unsigned long long)dback->parent:
3770 (unsigned long long)dback->root,
3771 (unsigned long long)dback->owner,
3772 (unsigned long long)dback->offset,
3773 (unsigned long)dback->num_refs);
3774 } else {
3775 tback = (struct tree_backref *)back;
3776 fprintf(stderr, "Backref %llu parent %llu"
3777 " root %llu not found in extent tree\n",
3778 (unsigned long long)rec->start,
3779 (unsigned long long)tback->parent,
3780 (unsigned long long)tback->root);
3781 }
3782 }
3783 if (!back->is_data && !back->found_ref) {
3784 err = 1;
3785 if (!print_errs)
3786 goto out;
3787 tback = (struct tree_backref *)back;
3788 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
3789 (unsigned long long)rec->start,
3790 back->full_backref ? "parent" : "root",
3791 back->full_backref ?
3792 (unsigned long long)tback->parent :
3793 (unsigned long long)tback->root, back);
3794 }
3795 if (back->is_data) {
3796 dback = (struct data_backref *)back;
3797 if (dback->found_ref != dback->num_refs) {
3798 err = 1;
3799 if (!print_errs)
3800 goto out;
3801 fprintf(stderr, "Incorrect local backref count"
3802 " on %llu %s %llu owner %llu"
3803 " offset %llu found %u wanted %u back %p\n",
3804 (unsigned long long)rec->start,
3805 back->full_backref ?
3806 "parent" : "root",
3807 back->full_backref ?
3808 (unsigned long long)dback->parent:
3809 (unsigned long long)dback->root,
3810 (unsigned long long)dback->owner,
3811 (unsigned long long)dback->offset,
3812 dback->found_ref, dback->num_refs, back);
3813 }
3814 if (dback->disk_bytenr != rec->start) {
3815 err = 1;
3816 if (!print_errs)
3817 goto out;
3818 fprintf(stderr, "Backref disk bytenr does not"
3819 " match extent record, bytenr=%llu, "
3820 "ref bytenr=%llu\n",
3821 (unsigned long long)rec->start,
3822 (unsigned long long)dback->disk_bytenr);
3823 }
3824
3825 if (dback->bytes != rec->nr) {
3826 err = 1;
3827 if (!print_errs)
3828 goto out;
3829 fprintf(stderr, "Backref bytes do not match "
3830 "extent backref, bytenr=%llu, ref "
3831 "bytes=%llu, backref bytes=%llu\n",
3832 (unsigned long long)rec->start,
3833 (unsigned long long)rec->nr,
3834 (unsigned long long)dback->bytes);
3835 }
3836 }
3837 if (!back->is_data) {
3838 found += 1;
3839 } else {
3840 dback = (struct data_backref *)back;
3841 found += dback->found_ref;
3842 }
3843 }
3844 if (found != rec->refs) {
3845 err = 1;
3846 if (!print_errs)
3847 goto out;
3848 fprintf(stderr, "Incorrect global backref count "
3849 "on %llu found %llu wanted %llu\n",
3850 (unsigned long long)rec->start,
3851 (unsigned long long)found,
3852 (unsigned long long)rec->refs);
3853 }
3854 out:
3855 return err;
3856 }
3857
3858 static int free_all_extent_backrefs(struct extent_record *rec)
3859 {
3860 struct extent_backref *back;
3861 struct list_head *cur;
3862 while (!list_empty(&rec->backrefs)) {
3863 cur = rec->backrefs.next;
3864 back = list_entry(cur, struct extent_backref, list);
3865 list_del(cur);
3866 free(back);
3867 }
3868 return 0;
3869 }
3870
3871 static void free_extent_record_cache(struct btrfs_fs_info *fs_info,
3872 struct cache_tree *extent_cache)
3873 {
3874 struct cache_extent *cache;
3875 struct extent_record *rec;
3876
3877 while (1) {
3878 cache = first_cache_extent(extent_cache);
3879 if (!cache)
3880 break;
3881 rec = container_of(cache, struct extent_record, cache);
3882 remove_cache_extent(extent_cache, cache);
3883 free_all_extent_backrefs(rec);
3884 free(rec);
3885 }
3886 }
3887
3888 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
3889 struct extent_record *rec)
3890 {
3891 if (rec->content_checked && rec->owner_ref_checked &&
3892 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
3893 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
3894 !rec->bad_full_backref && !rec->crossing_stripes &&
3895 !rec->wrong_chunk_type) {
3896 remove_cache_extent(extent_cache, &rec->cache);
3897 free_all_extent_backrefs(rec);
3898 list_del_init(&rec->list);
3899 free(rec);
3900 }
3901 return 0;
3902 }
3903
3904 static int check_owner_ref(struct btrfs_root *root,
3905 struct extent_record *rec,
3906 struct extent_buffer *buf)
3907 {
3908 struct extent_backref *node;
3909 struct tree_backref *back;
3910 struct btrfs_root *ref_root;
3911 struct btrfs_key key;
3912 struct btrfs_path path;
3913 struct extent_buffer *parent;
3914 int level;
3915 int found = 0;
3916 int ret;
3917
3918 list_for_each_entry(node, &rec->backrefs, list) {
3919 if (node->is_data)
3920 continue;
3921 if (!node->found_ref)
3922 continue;
3923 if (node->full_backref)
3924 continue;
3925 back = (struct tree_backref *)node;
3926 if (btrfs_header_owner(buf) == back->root)
3927 return 0;
3928 }
3929 BUG_ON(rec->is_root);
3930
3931 /* try to find the block by search corresponding fs tree */
3932 key.objectid = btrfs_header_owner(buf);
3933 key.type = BTRFS_ROOT_ITEM_KEY;
3934 key.offset = (u64)-1;
3935
3936 ref_root = btrfs_read_fs_root(root->fs_info, &key);
3937 if (IS_ERR(ref_root))
3938 return 1;
3939
3940 level = btrfs_header_level(buf);
3941 if (level == 0)
3942 btrfs_item_key_to_cpu(buf, &key, 0);
3943 else
3944 btrfs_node_key_to_cpu(buf, &key, 0);
3945
3946 btrfs_init_path(&path);
3947 path.lowest_level = level + 1;
3948 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
3949 if (ret < 0)
3950 return 0;
3951
3952 parent = path.nodes[level + 1];
3953 if (parent && buf->start == btrfs_node_blockptr(parent,
3954 path.slots[level + 1]))
3955 found = 1;
3956
3957 btrfs_release_path(&path);
3958 return found ? 0 : 1;
3959 }
3960
3961 static int is_extent_tree_record(struct extent_record *rec)
3962 {
3963 struct list_head *cur = rec->backrefs.next;
3964 struct extent_backref *node;
3965 struct tree_backref *back;
3966 int is_extent = 0;
3967
3968 while(cur != &rec->backrefs) {
3969 node = list_entry(cur, struct extent_backref, list);
3970 cur = cur->next;
3971 if (node->is_data)
3972 return 0;
3973 back = (struct tree_backref *)node;
3974 if (node->full_backref)
3975 return 0;
3976 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
3977 is_extent = 1;
3978 }
3979 return is_extent;
3980 }
3981
3982
3983 static int record_bad_block_io(struct btrfs_fs_info *info,
3984 struct cache_tree *extent_cache,
3985 u64 start, u64 len)
3986 {
3987 struct extent_record *rec;
3988 struct cache_extent *cache;
3989 struct btrfs_key key;
3990
3991 cache = lookup_cache_extent(extent_cache, start, len);
3992 if (!cache)
3993 return 0;
3994
3995 rec = container_of(cache, struct extent_record, cache);
3996 if (!is_extent_tree_record(rec))
3997 return 0;
3998
3999 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
4000 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
4001 }
4002
4003 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
4004 struct extent_buffer *buf, int slot)
4005 {
4006 if (btrfs_header_level(buf)) {
4007 struct btrfs_key_ptr ptr1, ptr2;
4008
4009 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
4010 sizeof(struct btrfs_key_ptr));
4011 read_extent_buffer(buf, &ptr2,
4012 btrfs_node_key_ptr_offset(slot + 1),
4013 sizeof(struct btrfs_key_ptr));
4014 write_extent_buffer(buf, &ptr1,
4015 btrfs_node_key_ptr_offset(slot + 1),
4016 sizeof(struct btrfs_key_ptr));
4017 write_extent_buffer(buf, &ptr2,
4018 btrfs_node_key_ptr_offset(slot),
4019 sizeof(struct btrfs_key_ptr));
4020 if (slot == 0) {
4021 struct btrfs_disk_key key;
4022 btrfs_node_key(buf, &key, 0);
4023 btrfs_fixup_low_keys(root, path, &key,
4024 btrfs_header_level(buf) + 1);
4025 }
4026 } else {
4027 struct btrfs_item *item1, *item2;
4028 struct btrfs_key k1, k2;
4029 char *item1_data, *item2_data;
4030 u32 item1_offset, item2_offset, item1_size, item2_size;
4031
4032 item1 = btrfs_item_nr(slot);
4033 item2 = btrfs_item_nr(slot + 1);
4034 btrfs_item_key_to_cpu(buf, &k1, slot);
4035 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
4036 item1_offset = btrfs_item_offset(buf, item1);
4037 item2_offset = btrfs_item_offset(buf, item2);
4038 item1_size = btrfs_item_size(buf, item1);
4039 item2_size = btrfs_item_size(buf, item2);
4040
4041 item1_data = malloc(item1_size);
4042 if (!item1_data)
4043 return -ENOMEM;
4044 item2_data = malloc(item2_size);
4045 if (!item2_data) {
4046 free(item1_data);
4047 return -ENOMEM;
4048 }
4049
4050 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
4051 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
4052
4053 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
4054 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
4055 free(item1_data);
4056 free(item2_data);
4057
4058 btrfs_set_item_offset(buf, item1, item2_offset);
4059 btrfs_set_item_offset(buf, item2, item1_offset);
4060 btrfs_set_item_size(buf, item1, item2_size);
4061 btrfs_set_item_size(buf, item2, item1_size);
4062
4063 path->slots[0] = slot;
4064 btrfs_set_item_key_unsafe(root, path, &k2);
4065 path->slots[0] = slot + 1;
4066 btrfs_set_item_key_unsafe(root, path, &k1);
4067 }
4068 return 0;
4069 }
4070
4071 static int fix_key_order(struct btrfs_trans_handle *trans,
4072 struct btrfs_root *root,
4073 struct btrfs_path *path)
4074 {
4075 struct extent_buffer *buf;
4076 struct btrfs_key k1, k2;
4077 int i;
4078 int level = path->lowest_level;
4079 int ret = -EIO;
4080
4081 buf = path->nodes[level];
4082 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
4083 if (level) {
4084 btrfs_node_key_to_cpu(buf, &k1, i);
4085 btrfs_node_key_to_cpu(buf, &k2, i + 1);
4086 } else {
4087 btrfs_item_key_to_cpu(buf, &k1, i);
4088 btrfs_item_key_to_cpu(buf, &k2, i + 1);
4089 }
4090 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
4091 continue;
4092 ret = swap_values(root, path, buf, i);
4093 if (ret)
4094 break;
4095 btrfs_mark_buffer_dirty(buf);
4096 i = 0;
4097 }
4098 return ret;
4099 }
4100
4101 static int delete_bogus_item(struct btrfs_trans_handle *trans,
4102 struct btrfs_root *root,
4103 struct btrfs_path *path,
4104 struct extent_buffer *buf, int slot)
4105 {
4106 struct btrfs_key key;
4107 int nritems = btrfs_header_nritems(buf);
4108
4109 btrfs_item_key_to_cpu(buf, &key, slot);
4110
4111 /* These are all the keys we can deal with missing. */
4112 if (key.type != BTRFS_DIR_INDEX_KEY &&
4113 key.type != BTRFS_EXTENT_ITEM_KEY &&
4114 key.type != BTRFS_METADATA_ITEM_KEY &&
4115 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
4116 key.type != BTRFS_EXTENT_DATA_REF_KEY)
4117 return -1;
4118
4119 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
4120 (unsigned long long)key.objectid, key.type,
4121 (unsigned long long)key.offset, slot, buf->start);
4122 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
4123 btrfs_item_nr_offset(slot + 1),
4124 sizeof(struct btrfs_item) *
4125 (nritems - slot - 1));
4126 btrfs_set_header_nritems(buf, nritems - 1);
4127 if (slot == 0) {
4128 struct btrfs_disk_key disk_key;
4129
4130 btrfs_item_key(buf, &disk_key, 0);
4131 btrfs_fixup_low_keys(root, path, &disk_key, 1);
4132 }
4133 btrfs_mark_buffer_dirty(buf);
4134 return 0;
4135 }
4136
4137 static int fix_item_offset(struct btrfs_trans_handle *trans,
4138 struct btrfs_root *root,
4139 struct btrfs_path *path)
4140 {
4141 struct extent_buffer *buf;
4142 int i;
4143 int ret = 0;
4144
4145 /* We should only get this for leaves */
4146 BUG_ON(path->lowest_level);
4147 buf = path->nodes[0];
4148 again:
4149 for (i = 0; i < btrfs_header_nritems(buf); i++) {
4150 unsigned int shift = 0, offset;
4151
4152 if (i == 0 && btrfs_item_end_nr(buf, i) !=
4153 BTRFS_LEAF_DATA_SIZE(root)) {
4154 if (btrfs_item_end_nr(buf, i) >
4155 BTRFS_LEAF_DATA_SIZE(root)) {
4156 ret = delete_bogus_item(trans, root, path,
4157 buf, i);
4158 if (!ret)
4159 goto again;
4160 fprintf(stderr, "item is off the end of the "
4161 "leaf, can't fix\n");
4162 ret = -EIO;
4163 break;
4164 }
4165 shift = BTRFS_LEAF_DATA_SIZE(root) -
4166 btrfs_item_end_nr(buf, i);
4167 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
4168 btrfs_item_offset_nr(buf, i - 1)) {
4169 if (btrfs_item_end_nr(buf, i) >
4170 btrfs_item_offset_nr(buf, i - 1)) {
4171 ret = delete_bogus_item(trans, root, path,
4172 buf, i);
4173 if (!ret)
4174 goto again;
4175 fprintf(stderr, "items overlap, can't fix\n");
4176 ret = -EIO;
4177 break;
4178 }
4179 shift = btrfs_item_offset_nr(buf, i - 1) -
4180 btrfs_item_end_nr(buf, i);
4181 }
4182 if (!shift)
4183 continue;
4184
4185 printf("Shifting item nr %d by %u bytes in block %llu\n",
4186 i, shift, (unsigned long long)buf->start);
4187 offset = btrfs_item_offset_nr(buf, i);
4188 memmove_extent_buffer(buf,
4189 btrfs_leaf_data(buf) + offset + shift,
4190 btrfs_leaf_data(buf) + offset,
4191 btrfs_item_size_nr(buf, i));
4192 btrfs_set_item_offset(buf, btrfs_item_nr(i),
4193 offset + shift);
4194 btrfs_mark_buffer_dirty(buf);
4195 }
4196
4197 /*
4198 * We may have moved things, in which case we want to exit so we don't
4199 * write those changes out. Once we have proper abort functionality in
4200 * progs this can be changed to something nicer.
4201 */
4202 BUG_ON(ret);
4203 return ret;
4204 }
4205
4206 /*
4207 * Attempt to fix basic block failures. If we can't fix it for whatever reason
4208 * then just return -EIO.
4209 */
4210 static int try_to_fix_bad_block(struct btrfs_root *root,
4211 struct extent_buffer *buf,
4212 enum btrfs_tree_block_status status)
4213 {
4214 struct btrfs_trans_handle *trans;
4215 struct ulist *roots;
4216 struct ulist_node *node;
4217 struct btrfs_root *search_root;
4218 struct btrfs_path *path;
4219 struct ulist_iterator iter;
4220 struct btrfs_key root_key, key;
4221 int ret;
4222
4223 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
4224 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
4225 return -EIO;
4226
4227 path = btrfs_alloc_path();
4228 if (!path)
4229 return -EIO;
4230
4231 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start,
4232 0, &roots);
4233 if (ret) {
4234 btrfs_free_path(path);
4235 return -EIO;
4236 }
4237
4238 ULIST_ITER_INIT(&iter);
4239 while ((node = ulist_next(roots, &iter))) {
4240 root_key.objectid = node->val;
4241 root_key.type = BTRFS_ROOT_ITEM_KEY;
4242 root_key.offset = (u64)-1;
4243
4244 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
4245 if (IS_ERR(root)) {
4246 ret = -EIO;
4247 break;
4248 }
4249
4250
4251 trans = btrfs_start_transaction(search_root, 0);
4252 if (IS_ERR(trans)) {
4253 ret = PTR_ERR(trans);
4254 break;
4255 }
4256
4257 path->lowest_level = btrfs_header_level(buf);
4258 path->skip_check_block = 1;
4259 if (path->lowest_level)
4260 btrfs_node_key_to_cpu(buf, &key, 0);
4261 else
4262 btrfs_item_key_to_cpu(buf, &key, 0);
4263 ret = btrfs_search_slot(trans, search_root, &key, path, 0, 1);
4264 if (ret) {
4265 ret = -EIO;
4266 btrfs_commit_transaction(trans, search_root);
4267 break;
4268 }
4269 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
4270 ret = fix_key_order(trans, search_root, path);
4271 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
4272 ret = fix_item_offset(trans, search_root, path);
4273 if (ret) {
4274 btrfs_commit_transaction(trans, search_root);
4275 break;
4276 }
4277 btrfs_release_path(path);
4278 btrfs_commit_transaction(trans, search_root);
4279 }
4280 ulist_free(roots);
4281 btrfs_free_path(path);
4282 return ret;
4283 }
4284
4285 static int check_block(struct btrfs_root *root,
4286 struct cache_tree *extent_cache,
4287 struct extent_buffer *buf, u64 flags)
4288 {
4289 struct extent_record *rec;
4290 struct cache_extent *cache;
4291 struct btrfs_key key;
4292 enum btrfs_tree_block_status status;
4293 int ret = 0;
4294 int level;
4295
4296 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
4297 if (!cache)
4298 return 1;
4299 rec = container_of(cache, struct extent_record, cache);
4300 rec->generation = btrfs_header_generation(buf);
4301
4302 level = btrfs_header_level(buf);
4303 if (btrfs_header_nritems(buf) > 0) {
4304
4305 if (level == 0)
4306 btrfs_item_key_to_cpu(buf, &key, 0);
4307 else
4308 btrfs_node_key_to_cpu(buf, &key, 0);
4309
4310 rec->info_objectid = key.objectid;
4311 }
4312 rec->info_level = level;
4313
4314 if (btrfs_is_leaf(buf))
4315 status = btrfs_check_leaf(root, &rec->parent_key, buf);
4316 else
4317 status = btrfs_check_node(root, &rec->parent_key, buf);
4318
4319 if (status != BTRFS_TREE_BLOCK_CLEAN) {
4320 if (repair)
4321 status = try_to_fix_bad_block(root, buf, status);
4322 if (status != BTRFS_TREE_BLOCK_CLEAN) {
4323 ret = -EIO;
4324 fprintf(stderr, "bad block %llu\n",
4325 (unsigned long long)buf->start);
4326 } else {
4327 /*
4328 * Signal to callers we need to start the scan over
4329 * again since we'll have cowed blocks.
4330 */
4331 ret = -EAGAIN;
4332 }
4333 } else {
4334 rec->content_checked = 1;
4335 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
4336 rec->owner_ref_checked = 1;
4337 else {
4338 ret = check_owner_ref(root, rec, buf);
4339 if (!ret)
4340 rec->owner_ref_checked = 1;
4341 }
4342 }
4343 if (!ret)
4344 maybe_free_extent_rec(extent_cache, rec);
4345 return ret;
4346 }
4347
4348 static struct tree_backref *find_tree_backref(struct extent_record *rec,
4349 u64 parent, u64 root)
4350 {
4351 struct list_head *cur = rec->backrefs.next;
4352 struct extent_backref *node;
4353 struct tree_backref *back;
4354
4355 while(cur != &rec->backrefs) {
4356 node = list_entry(cur, struct extent_backref, list);
4357 cur = cur->next;
4358 if (node->is_data)
4359 continue;
4360 back = (struct tree_backref *)node;
4361 if (parent > 0) {
4362 if (!node->full_backref)
4363 continue;
4364 if (parent == back->parent)
4365 return back;
4366 } else {
4367 if (node->full_backref)
4368 continue;
4369 if (back->root == root)
4370 return back;
4371 }
4372 }
4373 return NULL;
4374 }
4375
4376 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
4377 u64 parent, u64 root)
4378 {
4379 struct tree_backref *ref = malloc(sizeof(*ref));
4380
4381 if (!ref)
4382 return NULL;
4383 memset(&ref->node, 0, sizeof(ref->node));
4384 if (parent > 0) {
4385 ref->parent = parent;
4386 ref->node.full_backref = 1;
4387 } else {
4388 ref->root = root;
4389 ref->node.full_backref = 0;
4390 }
4391 list_add_tail(&ref->node.list, &rec->backrefs);
4392
4393 return ref;
4394 }
4395
4396 static struct data_backref *find_data_backref(struct extent_record *rec,
4397 u64 parent, u64 root,
4398 u64 owner, u64 offset,
4399 int found_ref,
4400 u64 disk_bytenr, u64 bytes)
4401 {
4402 struct list_head *cur = rec->backrefs.next;
4403 struct extent_backref *node;
4404 struct data_backref *back;
4405
4406 while(cur != &rec->backrefs) {
4407 node = list_entry(cur, struct extent_backref, list);
4408 cur = cur->next;
4409 if (!node->is_data)
4410 continue;
4411 back = (struct data_backref *)node;
4412 if (parent > 0) {
4413 if (!node->full_backref)
4414 continue;
4415 if (parent == back->parent)
4416 return back;
4417 } else {
4418 if (node->full_backref)
4419 continue;
4420 if (back->root == root && back->owner == owner &&
4421 back->offset == offset) {
4422 if (found_ref && node->found_ref &&
4423 (back->bytes != bytes ||
4424 back->disk_bytenr != disk_bytenr))
4425 continue;
4426 return back;
4427 }
4428 }
4429 }
4430 return NULL;
4431 }
4432
4433 static struct data_backref *alloc_data_backref(struct extent_record *rec,
4434 u64 parent, u64 root,
4435 u64 owner, u64 offset,
4436 u64 max_size)
4437 {
4438 struct data_backref *ref = malloc(sizeof(*ref));
4439
4440 if (!ref)
4441 return NULL;
4442 memset(&ref->node, 0, sizeof(ref->node));
4443 ref->node.is_data = 1;
4444
4445 if (parent > 0) {
4446 ref->parent = parent;
4447 ref->owner = 0;
4448 ref->offset = 0;
4449 ref->node.full_backref = 1;
4450 } else {
4451 ref->root = root;
4452 ref->owner = owner;
4453 ref->offset = offset;
4454 ref->node.full_backref = 0;
4455 }
4456 ref->bytes = max_size;
4457 ref->found_ref = 0;
4458 ref->num_refs = 0;
4459 list_add_tail(&ref->node.list, &rec->backrefs);
4460 if (max_size > rec->max_size)
4461 rec->max_size = max_size;
4462 return ref;
4463 }
4464
4465 /* Check if the type of extent matches with its chunk */
4466 static void check_extent_type(struct extent_record *rec)
4467 {
4468 struct btrfs_block_group_cache *bg_cache;
4469
4470 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
4471 if (!bg_cache)
4472 return;
4473
4474 /* data extent, check chunk directly*/
4475 if (!rec->metadata) {
4476 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
4477 rec->wrong_chunk_type = 1;
4478 return;
4479 }
4480
4481 /* metadata extent, check the obvious case first */
4482 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
4483 BTRFS_BLOCK_GROUP_METADATA))) {
4484 rec->wrong_chunk_type = 1;
4485 return;
4486 }
4487
4488 /*
4489 * Check SYSTEM extent, as it's also marked as metadata, we can only
4490 * make sure it's a SYSTEM extent by its backref
4491 */
4492 if (!list_empty(&rec->backrefs)) {
4493 struct extent_backref *node;
4494 struct tree_backref *tback;
4495 u64 bg_type;
4496
4497 node = list_entry(rec->backrefs.next, struct extent_backref,
4498 list);
4499 if (node->is_data) {
4500 /* tree block shouldn't have data backref */
4501 rec->wrong_chunk_type = 1;
4502 return;
4503 }
4504 tback = container_of(node, struct tree_backref, node);
4505
4506 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
4507 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
4508 else
4509 bg_type = BTRFS_BLOCK_GROUP_METADATA;
4510 if (!(bg_cache->flags & bg_type))
4511 rec->wrong_chunk_type = 1;
4512 }
4513 }
4514
4515 /*
4516 * Allocate a new extent record, fill default values from @tmpl and insert int
4517 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
4518 * the cache, otherwise it fails.
4519 */
4520 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
4521 struct extent_record *tmpl)
4522 {
4523 struct extent_record *rec;
4524 int ret = 0;
4525
4526 rec = malloc(sizeof(*rec));
4527 if (!rec)
4528 return -ENOMEM;
4529 rec->start = tmpl->start;
4530 rec->max_size = tmpl->max_size;
4531 rec->nr = max(tmpl->nr, tmpl->max_size);
4532 rec->found_rec = tmpl->found_rec;
4533 rec->content_checked = tmpl->content_checked;
4534 rec->owner_ref_checked = tmpl->owner_ref_checked;
4535 rec->num_duplicates = 0;
4536 rec->metadata = tmpl->metadata;
4537 rec->flag_block_full_backref = FLAG_UNSET;
4538 rec->bad_full_backref = 0;
4539 rec->crossing_stripes = 0;
4540 rec->wrong_chunk_type = 0;
4541 rec->is_root = tmpl->is_root;
4542 rec->refs = tmpl->refs;
4543 rec->extent_item_refs = tmpl->extent_item_refs;
4544 rec->parent_generation = tmpl->parent_generation;
4545 INIT_LIST_HEAD(&rec->backrefs);
4546 INIT_LIST_HEAD(&rec->dups);
4547 INIT_LIST_HEAD(&rec->list);
4548 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
4549 rec->cache.start = tmpl->start;
4550 rec->cache.size = tmpl->nr;
4551 ret = insert_cache_extent(extent_cache, &rec->cache);
4552 BUG_ON(ret);
4553 bytes_used += rec->nr;
4554
4555 if (tmpl->metadata)
4556 rec->crossing_stripes = check_crossing_stripes(rec->start,
4557 global_info->tree_root->nodesize);
4558 check_extent_type(rec);
4559 return ret;
4560 }
4561
4562 /*
4563 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
4564 * some are hints:
4565 * - refs - if found, increase refs
4566 * - is_root - if found, set
4567 * - content_checked - if found, set
4568 * - owner_ref_checked - if found, set
4569 *
4570 * If not found, create a new one, initialize and insert.
4571 */
4572 static int add_extent_rec(struct cache_tree *extent_cache,
4573 struct extent_record *tmpl)
4574 {
4575 struct extent_record *rec;
4576 struct cache_extent *cache;
4577 int ret = 0;
4578 int dup = 0;
4579
4580 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
4581 if (cache) {
4582 rec = container_of(cache, struct extent_record, cache);
4583 if (tmpl->refs)
4584 rec->refs++;
4585 if (rec->nr == 1)
4586 rec->nr = max(tmpl->nr, tmpl->max_size);
4587
4588 /*
4589 * We need to make sure to reset nr to whatever the extent
4590 * record says was the real size, this way we can compare it to
4591 * the backrefs.
4592 */
4593 if (tmpl->found_rec) {
4594 if (tmpl->start != rec->start || rec->found_rec) {
4595 struct extent_record *tmp;
4596
4597 dup = 1;
4598 if (list_empty(&rec->list))
4599 list_add_tail(&rec->list,
4600 &duplicate_extents);
4601
4602 /*
4603 * We have to do this song and dance in case we
4604 * find an extent record that falls inside of
4605 * our current extent record but does not have
4606 * the same objectid.
4607 */
4608 tmp = malloc(sizeof(*tmp));
4609 if (!tmp)
4610 return -ENOMEM;
4611 tmp->start = tmpl->start;
4612 tmp->max_size = tmpl->max_size;
4613 tmp->nr = tmpl->nr;
4614 tmp->found_rec = 1;
4615 tmp->metadata = tmpl->metadata;
4616 tmp->extent_item_refs = tmpl->extent_item_refs;
4617 INIT_LIST_HEAD(&tmp->list);
4618 list_add_tail(&tmp->list, &rec->dups);
4619 rec->num_duplicates++;
4620 } else {
4621 rec->nr = tmpl->nr;
4622 rec->found_rec = 1;
4623 }
4624 }
4625
4626 if (tmpl->extent_item_refs && !dup) {
4627 if (rec->extent_item_refs) {
4628 fprintf(stderr, "block %llu rec "
4629 "extent_item_refs %llu, passed %llu\n",
4630 (unsigned long long)tmpl->start,
4631 (unsigned long long)
4632 rec->extent_item_refs,
4633 (unsigned long long)tmpl->extent_item_refs);
4634 }
4635 rec->extent_item_refs = tmpl->extent_item_refs;
4636 }
4637 if (tmpl->is_root)
4638 rec->is_root = 1;
4639 if (tmpl->content_checked)
4640 rec->content_checked = 1;
4641 if (tmpl->owner_ref_checked)
4642 rec->owner_ref_checked = 1;
4643 memcpy(&rec->parent_key, &tmpl->parent_key,
4644 sizeof(tmpl->parent_key));
4645 if (tmpl->parent_generation)
4646 rec->parent_generation = tmpl->parent_generation;
4647 if (rec->max_size < tmpl->max_size)
4648 rec->max_size = tmpl->max_size;
4649
4650 /*
4651 * A metadata extent can't cross stripe_len boundary, otherwise
4652 * kernel scrub won't be able to handle it.
4653 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
4654 * it.
4655 */
4656 if (tmpl->metadata)
4657 rec->crossing_stripes = check_crossing_stripes(
4658 rec->start, global_info->tree_root->nodesize);
4659 check_extent_type(rec);
4660 maybe_free_extent_rec(extent_cache, rec);
4661 return ret;
4662 }
4663
4664 ret = add_extent_rec_nolookup(extent_cache, tmpl);
4665
4666 return ret;
4667 }
4668
4669 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
4670 u64 parent, u64 root, int found_ref)
4671 {
4672 struct extent_record *rec;
4673 struct tree_backref *back;
4674 struct cache_extent *cache;
4675
4676 cache = lookup_cache_extent(extent_cache, bytenr, 1);
4677 if (!cache) {
4678 struct extent_record tmpl;
4679
4680 memset(&tmpl, 0, sizeof(tmpl));
4681 tmpl.start = bytenr;
4682 tmpl.nr = 1;
4683 tmpl.metadata = 1;
4684
4685 add_extent_rec_nolookup(extent_cache, &tmpl);
4686
4687 cache = lookup_cache_extent(extent_cache, bytenr, 1);
4688 if (!cache)
4689 abort();
4690 }
4691
4692 rec = container_of(cache, struct extent_record, cache);
4693 if (rec->start != bytenr) {
4694 abort();
4695 }
4696
4697 back = find_tree_backref(rec, parent, root);
4698 if (!back) {
4699 back = alloc_tree_backref(rec, parent, root);
4700 BUG_ON(!back);
4701 }
4702
4703 if (found_ref) {
4704 if (back->node.found_ref) {
4705 fprintf(stderr, "Extent back ref already exists "
4706 "for %llu parent %llu root %llu \n",
4707 (unsigned long long)bytenr,
4708 (unsigned long long)parent,
4709 (unsigned long long)root);
4710 }
4711 back->node.found_ref = 1;
4712 } else {
4713 if (back->node.found_extent_tree) {
4714 fprintf(stderr, "Extent back ref already exists "
4715 "for %llu parent %llu root %llu \n",
4716 (unsigned long long)bytenr,
4717 (unsigned long long)parent,
4718 (unsigned long long)root);
4719 }
4720 back->node.found_extent_tree = 1;
4721 }
4722 check_extent_type(rec);
4723 maybe_free_extent_rec(extent_cache, rec);
4724 return 0;
4725 }
4726
4727 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
4728 u64 parent, u64 root, u64 owner, u64 offset,
4729 u32 num_refs, int found_ref, u64 max_size)
4730 {
4731 struct extent_record *rec;
4732 struct data_backref *back;
4733 struct cache_extent *cache;
4734
4735 cache = lookup_cache_extent(extent_cache, bytenr, 1);
4736 if (!cache) {
4737 struct extent_record tmpl;
4738
4739 memset(&tmpl, 0, sizeof(tmpl));
4740 tmpl.start = bytenr;
4741 tmpl.nr = 1;
4742 tmpl.max_size = max_size;
4743
4744 add_extent_rec_nolookup(extent_cache, &tmpl);
4745
4746 cache = lookup_cache_extent(extent_cache, bytenr, 1);
4747 if (!cache)
4748 abort();
4749 }
4750
4751 rec = container_of(cache, struct extent_record, cache);
4752 if (rec->max_size < max_size)
4753 rec->max_size = max_size;
4754
4755 /*
4756 * If found_ref is set then max_size is the real size and must match the
4757 * existing refs. So if we have already found a ref then we need to
4758 * make sure that this ref matches the existing one, otherwise we need
4759 * to add a new backref so we can notice that the backrefs don't match
4760 * and we need to figure out who is telling the truth. This is to
4761 * account for that awful fsync bug I introduced where we'd end up with
4762 * a btrfs_file_extent_item that would have its length include multiple
4763 * prealloc extents or point inside of a prealloc extent.
4764 */
4765 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
4766 bytenr, max_size);
4767 if (!back) {
4768 back = alloc_data_backref(rec, parent, root, owner, offset,
4769 max_size);
4770 BUG_ON(!back);
4771 }
4772
4773 if (found_ref) {
4774 BUG_ON(num_refs != 1);
4775 if (back->node.found_ref)
4776 BUG_ON(back->bytes != max_size);
4777 back->node.found_ref = 1;
4778 back->found_ref += 1;
4779 back->bytes = max_size;
4780 back->disk_bytenr = bytenr;
4781 rec->refs += 1;
4782 rec->content_checked = 1;
4783 rec->owner_ref_checked = 1;
4784 } else {
4785 if (back->node.found_extent_tree) {
4786 fprintf(stderr, "Extent back ref already exists "
4787 "for %llu parent %llu root %llu "
4788 "owner %llu offset %llu num_refs %lu\n",
4789 (unsigned long long)bytenr,
4790 (unsigned long long)parent,
4791 (unsigned long long)root,
4792 (unsigned long long)owner,
4793 (unsigned long long)offset,
4794 (unsigned long)num_refs);
4795 }
4796 back->num_refs = num_refs;
4797 back->node.found_extent_tree = 1;
4798 }
4799 maybe_free_extent_rec(extent_cache, rec);
4800 return 0;
4801 }
4802
4803 static int add_pending(struct cache_tree *pending,
4804 struct cache_tree *seen, u64 bytenr, u32 size)
4805 {
4806 int ret;
4807 ret = add_cache_extent(seen, bytenr, size);
4808 if (ret)
4809 return ret;
4810 add_cache_extent(pending, bytenr, size);
4811 return 0;
4812 }
4813
4814 static int pick_next_pending(struct cache_tree *pending,
4815 struct cache_tree *reada,
4816 struct cache_tree *nodes,
4817 u64 last, struct block_info *bits, int bits_nr,
4818 int *reada_bits)
4819 {
4820 unsigned long node_start = last;
4821 struct cache_extent *cache;
4822 int ret;
4823
4824 cache = search_cache_extent(reada, 0);
4825 if (cache) {
4826 bits[0].start = cache->start;
4827 bits[0].size = cache->size;
4828 *reada_bits = 1;
4829 return 1;
4830 }
4831 *reada_bits = 0;
4832 if (node_start > 32768)
4833 node_start -= 32768;
4834
4835 cache = search_cache_extent(nodes, node_start);
4836 if (!cache)
4837 cache = search_cache_extent(nodes, 0);
4838
4839 if (!cache) {
4840 cache = search_cache_extent(pending, 0);
4841 if (!cache)
4842 return 0;
4843 ret = 0;
4844 do {
4845 bits[ret].start = cache->start;
4846 bits[ret].size = cache->size;
4847 cache = next_cache_extent(cache);
4848 ret++;
4849 } while (cache && ret < bits_nr);
4850 return ret;
4851 }
4852
4853 ret = 0;
4854 do {
4855 bits[ret].start = cache->start;
4856 bits[ret].size = cache->size;
4857 cache = next_cache_extent(cache);
4858 ret++;
4859 } while (cache && ret < bits_nr);
4860
4861 if (bits_nr - ret > 8) {
4862 u64 lookup = bits[0].start + bits[0].size;
4863 struct cache_extent *next;
4864 next = search_cache_extent(pending, lookup);
4865 while(next) {
4866 if (next->start - lookup > 32768)
4867 break;
4868 bits[ret].start = next->start;
4869 bits[ret].size = next->size;
4870 lookup = next->start + next->size;
4871 ret++;
4872 if (ret == bits_nr)
4873 break;
4874 next = next_cache_extent(next);
4875 if (!next)
4876 break;
4877 }
4878 }
4879 return ret;
4880 }
4881
4882 static void free_chunk_record(struct cache_extent *cache)
4883 {
4884 struct chunk_record *rec;
4885
4886 rec = container_of(cache, struct chunk_record, cache);
4887 list_del_init(&rec->list);
4888 list_del_init(&rec->dextents);
4889 free(rec);
4890 }
4891
4892 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
4893 {
4894 cache_tree_free_extents(chunk_cache, free_chunk_record);
4895 }
4896
4897 static void free_device_record(struct rb_node *node)
4898 {
4899 struct device_record *rec;
4900
4901 rec = container_of(node, struct device_record, node);
4902 free(rec);
4903 }
4904
4905 FREE_RB_BASED_TREE(device_cache, free_device_record);
4906
4907 int insert_block_group_record(struct block_group_tree *tree,
4908 struct block_group_record *bg_rec)
4909 {
4910 int ret;
4911
4912 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
4913 if (ret)
4914 return ret;
4915
4916 list_add_tail(&bg_rec->list, &tree->block_groups);
4917 return 0;
4918 }
4919
4920 static void free_block_group_record(struct cache_extent *cache)
4921 {
4922 struct block_group_record *rec;
4923
4924 rec = container_of(cache, struct block_group_record, cache);
4925 list_del_init(&rec->list);
4926 free(rec);
4927 }
4928
4929 void free_block_group_tree(struct block_group_tree *tree)
4930 {
4931 cache_tree_free_extents(&tree->tree, free_block_group_record);
4932 }
4933
4934 int insert_device_extent_record(struct device_extent_tree *tree,
4935 struct device_extent_record *de_rec)
4936 {
4937 int ret;
4938
4939 /*
4940 * Device extent is a bit different from the other extents, because
4941 * the extents which belong to the different devices may have the
4942 * same start and size, so we need use the special extent cache
4943 * search/insert functions.
4944 */
4945 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
4946 if (ret)
4947 return ret;
4948
4949 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
4950 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
4951 return 0;
4952 }
4953
4954 static void free_device_extent_record(struct cache_extent *cache)
4955 {
4956 struct device_extent_record *rec;
4957
4958 rec = container_of(cache, struct device_extent_record, cache);
4959 if (!list_empty(&rec->chunk_list))
4960 list_del_init(&rec->chunk_list);
4961 if (!list_empty(&rec->device_list))
4962 list_del_init(&rec->device_list);
4963 free(rec);
4964 }
4965
4966 void free_device_extent_tree(struct device_extent_tree *tree)
4967 {
4968 cache_tree_free_extents(&tree->tree, free_device_extent_record);
4969 }
4970
4971 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4972 static int process_extent_ref_v0(struct cache_tree *extent_cache,
4973 struct extent_buffer *leaf, int slot)
4974 {
4975 struct btrfs_extent_ref_v0 *ref0;
4976 struct btrfs_key key;
4977
4978 btrfs_item_key_to_cpu(leaf, &key, slot);
4979 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
4980 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
4981 add_tree_backref(extent_cache, key.objectid, key.offset, 0, 0);
4982 } else {
4983 add_data_backref(extent_cache, key.objectid, key.offset, 0,
4984 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
4985 }
4986 return 0;
4987 }
4988 #endif
4989
4990 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
4991 struct btrfs_key *key,
4992 int slot)
4993 {
4994 struct btrfs_chunk *ptr;
4995 struct chunk_record *rec;
4996 int num_stripes, i;
4997
4998 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
4999 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
5000
5001 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
5002 if (!rec) {
5003 fprintf(stderr, "memory allocation failed\n");
5004 exit(-1);
5005 }
5006
5007 INIT_LIST_HEAD(&rec->list);
5008 INIT_LIST_HEAD(&rec->dextents);
5009 rec->bg_rec = NULL;
5010
5011 rec->cache.start = key->offset;
5012 rec->cache.size = btrfs_chunk_length(leaf, ptr);
5013
5014 rec->generation = btrfs_header_generation(leaf);
5015
5016 rec->objectid = key->objectid;
5017 rec->type = key->type;
5018 rec->offset = key->offset;
5019
5020 rec->length = rec->cache.size;
5021 rec->owner = btrfs_chunk_owner(leaf, ptr);
5022 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
5023 rec->type_flags = btrfs_chunk_type(leaf, ptr);
5024 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
5025 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
5026 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
5027 rec->num_stripes = num_stripes;
5028 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
5029
5030 for (i = 0; i < rec->num_stripes; ++i) {
5031 rec->stripes[i].devid =
5032 btrfs_stripe_devid_nr(leaf, ptr, i);
5033 rec->stripes[i].offset =
5034 btrfs_stripe_offset_nr(leaf, ptr, i);
5035 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
5036 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
5037 BTRFS_UUID_SIZE);
5038 }
5039
5040 return rec;
5041 }
5042
5043 static int process_chunk_item(struct cache_tree *chunk_cache,
5044 struct btrfs_key *key, struct extent_buffer *eb,
5045 int slot)
5046 {
5047 struct chunk_record *rec;
5048 int ret = 0;
5049
5050 rec = btrfs_new_chunk_record(eb, key, slot);
5051 ret = insert_cache_extent(chunk_cache, &rec->cache);
5052 if (ret) {
5053 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
5054 rec->offset, rec->length);
5055 free(rec);
5056 }
5057
5058 return ret;
5059 }
5060
5061 static int process_device_item(struct rb_root *dev_cache,
5062 struct btrfs_key *key, struct extent_buffer *eb, int slot)
5063 {
5064 struct btrfs_dev_item *ptr;
5065 struct device_record *rec;
5066 int ret = 0;
5067
5068 ptr = btrfs_item_ptr(eb,
5069 slot, struct btrfs_dev_item);
5070
5071 rec = malloc(sizeof(*rec));
5072 if (!rec) {
5073 fprintf(stderr, "memory allocation failed\n");
5074 return -ENOMEM;
5075 }
5076
5077 rec->devid = key->offset;
5078 rec->generation = btrfs_header_generation(eb);
5079
5080 rec->objectid = key->objectid;
5081 rec->type = key->type;
5082 rec->offset = key->offset;
5083
5084 rec->devid = btrfs_device_id(eb, ptr);
5085 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
5086 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
5087
5088 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
5089 if (ret) {
5090 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
5091 free(rec);
5092 }
5093
5094 return ret;
5095 }
5096
5097 struct block_group_record *
5098 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
5099 int slot)
5100 {
5101 struct btrfs_block_group_item *ptr;
5102 struct block_group_record *rec;
5103
5104 rec = calloc(1, sizeof(*rec));
5105 if (!rec) {
5106 fprintf(stderr, "memory allocation failed\n");
5107 exit(-1);
5108 }
5109
5110 rec->cache.start = key->objectid;
5111 rec->cache.size = key->offset;
5112
5113 rec->generation = btrfs_header_generation(leaf);
5114
5115 rec->objectid = key->objectid;
5116 rec->type = key->type;
5117 rec->offset = key->offset;
5118
5119 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
5120 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
5121
5122 INIT_LIST_HEAD(&rec->list);
5123
5124 return rec;
5125 }
5126
5127 static int process_block_group_item(struct block_group_tree *block_group_cache,
5128 struct btrfs_key *key,
5129 struct extent_buffer *eb, int slot)
5130 {
5131 struct block_group_record *rec;
5132 int ret = 0;
5133
5134 rec = btrfs_new_block_group_record(eb, key, slot);
5135 ret = insert_block_group_record(block_group_cache, rec);
5136 if (ret) {
5137 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
5138 rec->objectid, rec->offset);
5139 free(rec);
5140 }
5141
5142 return ret;
5143 }
5144
5145 struct device_extent_record *
5146 btrfs_new_device_extent_record(struct extent_buffer *leaf,
5147 struct btrfs_key *key, int slot)
5148 {
5149 struct device_extent_record *rec;
5150 struct btrfs_dev_extent *ptr;
5151
5152 rec = calloc(1, sizeof(*rec));
5153 if (!rec) {
5154 fprintf(stderr, "memory allocation failed\n");
5155 exit(-1);
5156 }
5157
5158 rec->cache.objectid = key->objectid;
5159 rec->cache.start = key->offset;
5160
5161 rec->generation = btrfs_header_generation(leaf);
5162
5163 rec->objectid = key->objectid;
5164 rec->type = key->type;
5165 rec->offset = key->offset;
5166
5167 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
5168 rec->chunk_objecteid =
5169 btrfs_dev_extent_chunk_objectid(leaf, ptr);
5170 rec->chunk_offset =
5171 btrfs_dev_extent_chunk_offset(leaf, ptr);
5172 rec->length = btrfs_dev_extent_length(leaf, ptr);
5173 rec->cache.size = rec->length;
5174
5175 INIT_LIST_HEAD(&rec->chunk_list);
5176 INIT_LIST_HEAD(&rec->device_list);
5177
5178 return rec;
5179 }
5180
5181 static int
5182 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
5183 struct btrfs_key *key, struct extent_buffer *eb,
5184 int slot)
5185 {
5186 struct device_extent_record *rec;
5187 int ret;
5188
5189 rec = btrfs_new_device_extent_record(eb, key, slot);
5190 ret = insert_device_extent_record(dev_extent_cache, rec);
5191 if (ret) {
5192 fprintf(stderr,
5193 "Device extent[%llu, %llu, %llu] existed.\n",
5194 rec->objectid, rec->offset, rec->length);
5195 free(rec);
5196 }
5197
5198 return ret;
5199 }
5200
5201 static int process_extent_item(struct btrfs_root *root,
5202 struct cache_tree *extent_cache,
5203 struct extent_buffer *eb, int slot)
5204 {
5205 struct btrfs_extent_item *ei;
5206 struct btrfs_extent_inline_ref *iref;
5207 struct btrfs_extent_data_ref *dref;
5208 struct btrfs_shared_data_ref *sref;
5209 struct btrfs_key key;
5210 struct extent_record tmpl;
5211 unsigned long end;
5212 unsigned long ptr;
5213 int type;
5214 u32 item_size = btrfs_item_size_nr(eb, slot);
5215 u64 refs = 0;
5216 u64 offset;
5217 u64 num_bytes;
5218 int metadata = 0;
5219
5220 btrfs_item_key_to_cpu(eb, &key, slot);
5221
5222 if (key.type == BTRFS_METADATA_ITEM_KEY) {
5223 metadata = 1;
5224 num_bytes = root->nodesize;
5225 } else {
5226 num_bytes = key.offset;
5227 }
5228
5229 if (item_size < sizeof(*ei)) {
5230 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5231 struct btrfs_extent_item_v0 *ei0;
5232 BUG_ON(item_size != sizeof(*ei0));
5233 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
5234 refs = btrfs_extent_refs_v0(eb, ei0);
5235 #else
5236 BUG();
5237 #endif
5238 memset(&tmpl, 0, sizeof(tmpl));
5239 tmpl.start = key.objectid;
5240 tmpl.nr = num_bytes;
5241 tmpl.extent_item_refs = refs;
5242 tmpl.metadata = metadata;
5243 tmpl.found_rec = 1;
5244 tmpl.max_size = num_bytes;
5245
5246 return add_extent_rec(extent_cache, &tmpl);
5247 }
5248
5249 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
5250 refs = btrfs_extent_refs(eb, ei);
5251 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
5252 metadata = 1;
5253 else
5254 metadata = 0;
5255
5256 memset(&tmpl, 0, sizeof(tmpl));
5257 tmpl.start = key.objectid;
5258 tmpl.nr = num_bytes;
5259 tmpl.extent_item_refs = refs;
5260 tmpl.metadata = metadata;
5261 tmpl.found_rec = 1;
5262 tmpl.max_size = num_bytes;
5263 add_extent_rec(extent_cache, &tmpl);
5264
5265 ptr = (unsigned long)(ei + 1);
5266 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
5267 key.type == BTRFS_EXTENT_ITEM_KEY)
5268 ptr += sizeof(struct btrfs_tree_block_info);
5269
5270 end = (unsigned long)ei + item_size;
5271 while (ptr < end) {
5272 iref = (struct btrfs_extent_inline_ref *)ptr;
5273 type = btrfs_extent_inline_ref_type(eb, iref);
5274 offset = btrfs_extent_inline_ref_offset(eb, iref);
5275 switch (type) {
5276 case BTRFS_TREE_BLOCK_REF_KEY:
5277 add_tree_backref(extent_cache, key.objectid,
5278 0, offset, 0);
5279 break;
5280 case BTRFS_SHARED_BLOCK_REF_KEY:
5281 add_tree_backref(extent_cache, key.objectid,
5282 offset, 0, 0);
5283 break;
5284 case BTRFS_EXTENT_DATA_REF_KEY:
5285 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
5286 add_data_backref(extent_cache, key.objectid, 0,
5287 btrfs_extent_data_ref_root(eb, dref),
5288 btrfs_extent_data_ref_objectid(eb,
5289 dref),
5290 btrfs_extent_data_ref_offset(eb, dref),
5291 btrfs_extent_data_ref_count(eb, dref),
5292 0, num_bytes);
5293 break;
5294 case BTRFS_SHARED_DATA_REF_KEY:
5295 sref = (struct btrfs_shared_data_ref *)(iref + 1);
5296 add_data_backref(extent_cache, key.objectid, offset,
5297 0, 0, 0,
5298 btrfs_shared_data_ref_count(eb, sref),
5299 0, num_bytes);
5300 break;
5301 default:
5302 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
5303 key.objectid, key.type, num_bytes);
5304 goto out;
5305 }
5306 ptr += btrfs_extent_inline_ref_size(type);
5307 }
5308 WARN_ON(ptr > end);
5309 out:
5310 return 0;
5311 }
5312
5313 static int check_cache_range(struct btrfs_root *root,
5314 struct btrfs_block_group_cache *cache,
5315 u64 offset, u64 bytes)
5316 {
5317 struct btrfs_free_space *entry;
5318 u64 *logical;
5319 u64 bytenr;
5320 int stripe_len;
5321 int i, nr, ret;
5322
5323 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
5324 bytenr = btrfs_sb_offset(i);
5325 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
5326 cache->key.objectid, bytenr, 0,
5327 &logical, &nr, &stripe_len);
5328 if (ret)
5329 return ret;
5330
5331 while (nr--) {
5332 if (logical[nr] + stripe_len <= offset)
5333 continue;
5334 if (offset + bytes <= logical[nr])
5335 continue;
5336 if (logical[nr] == offset) {
5337 if (stripe_len >= bytes) {
5338 kfree(logical);
5339 return 0;
5340 }
5341 bytes -= stripe_len;
5342 offset += stripe_len;
5343 } else if (logical[nr] < offset) {
5344 if (logical[nr] + stripe_len >=
5345 offset + bytes) {
5346 kfree(logical);
5347 return 0;
5348 }
5349 bytes = (offset + bytes) -
5350 (logical[nr] + stripe_len);
5351 offset = logical[nr] + stripe_len;
5352 } else {
5353 /*
5354 * Could be tricky, the super may land in the
5355 * middle of the area we're checking. First
5356 * check the easiest case, it's at the end.
5357 */
5358 if (logical[nr] + stripe_len >=
5359 bytes + offset) {
5360 bytes = logical[nr] - offset;
5361 continue;
5362 }
5363
5364 /* Check the left side */
5365 ret = check_cache_range(root, cache,
5366 offset,
5367 logical[nr] - offset);
5368 if (ret) {
5369 kfree(logical);
5370 return ret;
5371 }
5372
5373 /* Now we continue with the right side */
5374 bytes = (offset + bytes) -
5375 (logical[nr] + stripe_len);
5376 offset = logical[nr] + stripe_len;
5377 }
5378 }
5379
5380 kfree(logical);
5381 }
5382
5383 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
5384 if (!entry) {
5385 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
5386 offset, offset+bytes);
5387 return -EINVAL;
5388 }
5389
5390 if (entry->offset != offset) {
5391 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
5392 entry->offset);
5393 return -EINVAL;
5394 }
5395
5396 if (entry->bytes != bytes) {
5397 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
5398 bytes, entry->bytes, offset);
5399 return -EINVAL;
5400 }
5401
5402 unlink_free_space(cache->free_space_ctl, entry);
5403 free(entry);
5404 return 0;
5405 }
5406
5407 static int verify_space_cache(struct btrfs_root *root,
5408 struct btrfs_block_group_cache *cache)
5409 {
5410 struct btrfs_path *path;
5411 struct extent_buffer *leaf;
5412 struct btrfs_key key;
5413 u64 last;
5414 int ret = 0;
5415
5416 path = btrfs_alloc_path();
5417 if (!path)
5418 return -ENOMEM;
5419
5420 root = root->fs_info->extent_root;
5421
5422 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
5423
5424 key.objectid = last;
5425 key.offset = 0;
5426 key.type = BTRFS_EXTENT_ITEM_KEY;
5427
5428 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5429 if (ret < 0)
5430 goto out;
5431 ret = 0;
5432 while (1) {
5433 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
5434 ret = btrfs_next_leaf(root, path);
5435 if (ret < 0)
5436 goto out;
5437 if (ret > 0) {
5438 ret = 0;
5439 break;
5440 }
5441 }
5442 leaf = path->nodes[0];
5443 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
5444 if (key.objectid >= cache->key.offset + cache->key.objectid)
5445 break;
5446 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
5447 key.type != BTRFS_METADATA_ITEM_KEY) {
5448 path->slots[0]++;
5449 continue;
5450 }
5451
5452 if (last == key.objectid) {
5453 if (key.type == BTRFS_EXTENT_ITEM_KEY)
5454 last = key.objectid + key.offset;
5455 else
5456 last = key.objectid + root->nodesize;
5457 path->slots[0]++;
5458 continue;
5459 }
5460
5461 ret = check_cache_range(root, cache, last,
5462 key.objectid - last);
5463 if (ret)
5464 break;
5465 if (key.type == BTRFS_EXTENT_ITEM_KEY)
5466 last = key.objectid + key.offset;
5467 else
5468 last = key.objectid + root->nodesize;
5469 path->slots[0]++;
5470 }
5471
5472 if (last < cache->key.objectid + cache->key.offset)
5473 ret = check_cache_range(root, cache, last,
5474 cache->key.objectid +
5475 cache->key.offset - last);
5476
5477 out:
5478 btrfs_free_path(path);
5479
5480 if (!ret &&
5481 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
5482 fprintf(stderr, "There are still entries left in the space "
5483 "cache\n");
5484 ret = -EINVAL;
5485 }
5486
5487 return ret;
5488 }
5489
5490 static int check_space_cache(struct btrfs_root *root)
5491 {
5492 struct btrfs_block_group_cache *cache;
5493 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
5494 int ret;
5495 int error = 0;
5496
5497 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
5498 btrfs_super_generation(root->fs_info->super_copy) !=
5499 btrfs_super_cache_generation(root->fs_info->super_copy)) {
5500 printf("cache and super generation don't match, space cache "
5501 "will be invalidated\n");
5502 return 0;
5503 }
5504
5505 if (ctx.progress_enabled) {
5506 ctx.tp = TASK_FREE_SPACE;
5507 task_start(ctx.info);
5508 }
5509
5510 while (1) {
5511 cache = btrfs_lookup_first_block_group(root->fs_info, start);
5512 if (!cache)
5513 break;
5514
5515 start = cache->key.objectid + cache->key.offset;
5516 if (!cache->free_space_ctl) {
5517 if (btrfs_init_free_space_ctl(cache,
5518 root->sectorsize)) {
5519 ret = -ENOMEM;
5520 break;
5521 }
5522 } else {
5523 btrfs_remove_free_space_cache(cache);
5524 }
5525
5526 if (btrfs_fs_compat_ro(root->fs_info,
5527 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE)) {
5528 ret = exclude_super_stripes(root, cache);
5529 if (ret) {
5530 fprintf(stderr, "could not exclude super stripes: %s\n",
5531 strerror(-ret));
5532 error++;
5533 continue;
5534 }
5535 ret = load_free_space_tree(root->fs_info, cache);
5536 free_excluded_extents(root, cache);
5537 if (ret < 0) {
5538 fprintf(stderr, "could not load free space tree: %s\n",
5539 strerror(-ret));
5540 error++;
5541 continue;
5542 }
5543 error += ret;
5544 } else {
5545 ret = load_free_space_cache(root->fs_info, cache);
5546 if (!ret)
5547 continue;
5548 }
5549
5550 ret = verify_space_cache(root, cache);
5551 if (ret) {
5552 fprintf(stderr, "cache appears valid but isn't %Lu\n",
5553 cache->key.objectid);
5554 error++;
5555 }
5556 }
5557
5558 task_stop(ctx.info);
5559
5560 return error ? -EINVAL : 0;
5561 }
5562
5563 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
5564 u64 num_bytes, unsigned long leaf_offset,
5565 struct extent_buffer *eb) {
5566
5567 u64 offset = 0;
5568 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
5569 char *data;
5570 unsigned long csum_offset;
5571 u32 csum;
5572 u32 csum_expected;
5573 u64 read_len;
5574 u64 data_checked = 0;
5575 u64 tmp;
5576 int ret = 0;
5577 int mirror;
5578 int num_copies;
5579
5580 if (num_bytes % root->sectorsize)
5581 return -EINVAL;
5582
5583 data = malloc(num_bytes);
5584 if (!data)
5585 return -ENOMEM;
5586
5587 while (offset < num_bytes) {
5588 mirror = 0;
5589 again:
5590 read_len = num_bytes - offset;
5591 /* read as much space once a time */
5592 ret = read_extent_data(root, data + offset,
5593 bytenr + offset, &read_len, mirror);
5594 if (ret)
5595 goto out;
5596 data_checked = 0;
5597 /* verify every 4k data's checksum */
5598 while (data_checked < read_len) {
5599 csum = ~(u32)0;
5600 tmp = offset + data_checked;
5601
5602 csum = btrfs_csum_data(NULL, (char *)data + tmp,
5603 csum, root->sectorsize);
5604 btrfs_csum_final(csum, (char *)&csum);
5605
5606 csum_offset = leaf_offset +
5607 tmp / root->sectorsize * csum_size;
5608 read_extent_buffer(eb, (char *)&csum_expected,
5609 csum_offset, csum_size);
5610 /* try another mirror */
5611 if (csum != csum_expected) {
5612 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
5613 mirror, bytenr + tmp,
5614 csum, csum_expected);
5615 num_copies = btrfs_num_copies(
5616 &root->fs_info->mapping_tree,
5617 bytenr, num_bytes);
5618 if (mirror < num_copies - 1) {
5619 mirror += 1;
5620 goto again;
5621 }
5622 }
5623 data_checked += root->sectorsize;
5624 }
5625 offset += read_len;
5626 }
5627 out:
5628 free(data);
5629 return ret;
5630 }
5631
5632 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
5633 u64 num_bytes)
5634 {
5635 struct btrfs_path *path;
5636 struct extent_buffer *leaf;
5637 struct btrfs_key key;
5638 int ret;
5639
5640 path = btrfs_alloc_path();
5641 if (!path) {
5642 fprintf(stderr, "Error allocating path\n");
5643 return -ENOMEM;
5644 }
5645
5646 key.objectid = bytenr;
5647 key.type = BTRFS_EXTENT_ITEM_KEY;
5648 key.offset = (u64)-1;
5649
5650 again:
5651 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
5652 0, 0);
5653 if (ret < 0) {
5654 fprintf(stderr, "Error looking up extent record %d\n", ret);
5655 btrfs_free_path(path);
5656 return ret;
5657 } else if (ret) {
5658 if (path->slots[0] > 0) {
5659 path->slots[0]--;
5660 } else {
5661 ret = btrfs_prev_leaf(root, path);
5662 if (ret < 0) {
5663 goto out;
5664 } else if (ret > 0) {
5665 ret = 0;
5666 goto out;
5667 }
5668 }
5669 }
5670
5671 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5672
5673 /*
5674 * Block group items come before extent items if they have the same
5675 * bytenr, so walk back one more just in case. Dear future traveller,
5676 * first congrats on mastering time travel. Now if it's not too much
5677 * trouble could you go back to 2006 and tell Chris to make the
5678 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
5679 * EXTENT_ITEM_KEY please?
5680 */
5681 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
5682 if (path->slots[0] > 0) {
5683 path->slots[0]--;
5684 } else {
5685 ret = btrfs_prev_leaf(root, path);
5686 if (ret < 0) {
5687 goto out;
5688 } else if (ret > 0) {
5689 ret = 0;
5690 goto out;
5691 }
5692 }
5693 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
5694 }
5695
5696 while (num_bytes) {
5697 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
5698 ret = btrfs_next_leaf(root, path);
5699 if (ret < 0) {
5700 fprintf(stderr, "Error going to next leaf "
5701 "%d\n", ret);
5702 btrfs_free_path(path);
5703 return ret;
5704 } else if (ret) {
5705 break;
5706 }
5707 }
5708 leaf = path->nodes[0];
5709 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
5710 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
5711 path->slots[0]++;
5712 continue;
5713 }
5714 if (key.objectid + key.offset < bytenr) {
5715 path->slots[0]++;
5716 continue;
5717 }
5718 if (key.objectid > bytenr + num_bytes)
5719 break;
5720
5721 if (key.objectid == bytenr) {
5722 if (key.offset >= num_bytes) {
5723 num_bytes = 0;
5724 break;
5725 }
5726 num_bytes -= key.offset;
5727 bytenr += key.offset;
5728 } else if (key.objectid < bytenr) {
5729 if (key.objectid + key.offset >= bytenr + num_bytes) {
5730 num_bytes = 0;
5731 break;
5732 }
5733 num_bytes = (bytenr + num_bytes) -
5734 (key.objectid + key.offset);
5735 bytenr = key.objectid + key.offset;
5736 } else {
5737 if (key.objectid + key.offset < bytenr + num_bytes) {
5738 u64 new_start = key.objectid + key.offset;
5739 u64 new_bytes = bytenr + num_bytes - new_start;
5740
5741 /*
5742 * Weird case, the extent is in the middle of
5743 * our range, we'll have to search one side
5744 * and then the other. Not sure if this happens
5745 * in real life, but no harm in coding it up
5746 * anyway just in case.
5747 */
5748 btrfs_release_path(path);
5749 ret = check_extent_exists(root, new_start,
5750 new_bytes);
5751 if (ret) {
5752 fprintf(stderr, "Right section didn't "
5753 "have a record\n");
5754 break;
5755 }
5756 num_bytes = key.objectid - bytenr;
5757 goto again;
5758 }
5759 num_bytes = key.objectid - bytenr;
5760 }
5761 path->slots[0]++;
5762 }
5763 ret = 0;
5764
5765 out:
5766 if (num_bytes && !ret) {
5767 fprintf(stderr, "There are no extents for csum range "
5768 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
5769 ret = 1;
5770 }
5771
5772 btrfs_free_path(path);
5773 return ret;
5774 }
5775
5776 static int check_csums(struct btrfs_root *root)
5777 {
5778 struct btrfs_path *path;
5779 struct extent_buffer *leaf;
5780 struct btrfs_key key;
5781 u64 offset = 0, num_bytes = 0;
5782 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
5783 int errors = 0;
5784 int ret;
5785 u64 data_len;
5786 unsigned long leaf_offset;
5787
5788 root = root->fs_info->csum_root;
5789 if (!extent_buffer_uptodate(root->node)) {
5790 fprintf(stderr, "No valid csum tree found\n");
5791 return -ENOENT;
5792 }
5793
5794 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
5795 key.type = BTRFS_EXTENT_CSUM_KEY;
5796 key.offset = 0;
5797
5798 path = btrfs_alloc_path();
5799 if (!path)
5800 return -ENOMEM;
5801
5802 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5803 if (ret < 0) {
5804 fprintf(stderr, "Error searching csum tree %d\n", ret);
5805 btrfs_free_path(path);
5806 return ret;
5807 }
5808
5809 if (ret > 0 && path->slots[0])
5810 path->slots[0]--;
5811 ret = 0;
5812
5813 while (1) {
5814 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
5815 ret = btrfs_next_leaf(root, path);
5816 if (ret < 0) {
5817 fprintf(stderr, "Error going to next leaf "
5818 "%d\n", ret);
5819 break;
5820 }
5821 if (ret)
5822 break;
5823 }
5824 leaf = path->nodes[0];
5825
5826 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
5827 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
5828 path->slots[0]++;
5829 continue;
5830 }
5831
5832 data_len = (btrfs_item_size_nr(leaf, path->slots[0]) /
5833 csum_size) * root->sectorsize;
5834 if (!check_data_csum)
5835 goto skip_csum_check;
5836 leaf_offset = btrfs_item_ptr_offset(leaf, path->slots[0]);
5837 ret = check_extent_csums(root, key.offset, data_len,
5838 leaf_offset, leaf);
5839 if (ret)
5840 break;
5841 skip_csum_check:
5842 if (!num_bytes) {
5843 offset = key.offset;
5844 } else if (key.offset != offset + num_bytes) {
5845 ret = check_extent_exists(root, offset, num_bytes);
5846 if (ret) {
5847 fprintf(stderr, "Csum exists for %Lu-%Lu but "
5848 "there is no extent record\n",
5849 offset, offset+num_bytes);
5850 errors++;
5851 }
5852 offset = key.offset;
5853 num_bytes = 0;
5854 }
5855 num_bytes += data_len;
5856 path->slots[0]++;
5857 }
5858
5859 btrfs_free_path(path);
5860 return errors;
5861 }
5862
5863 static int is_dropped_key(struct btrfs_key *key,
5864 struct btrfs_key *drop_key) {
5865 if (key->objectid < drop_key->objectid)
5866 return 1;
5867 else if (key->objectid == drop_key->objectid) {
5868 if (key->type < drop_key->type)
5869 return 1;
5870 else if (key->type == drop_key->type) {
5871 if (key->offset < drop_key->offset)
5872 return 1;
5873 }
5874 }
5875 return 0;
5876 }
5877
5878 /*
5879 * Here are the rules for FULL_BACKREF.
5880 *
5881 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
5882 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
5883 * FULL_BACKREF set.
5884 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
5885 * if it happened after the relocation occurred since we'll have dropped the
5886 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
5887 * have no real way to know for sure.
5888 *
5889 * We process the blocks one root at a time, and we start from the lowest root
5890 * objectid and go to the highest. So we can just lookup the owner backref for
5891 * the record and if we don't find it then we know it doesn't exist and we have
5892 * a FULL BACKREF.
5893 *
5894 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
5895 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
5896 * be set or not and then we can check later once we've gathered all the refs.
5897 */
5898 static int calc_extent_flag(struct btrfs_root *root,
5899 struct cache_tree *extent_cache,
5900 struct extent_buffer *buf,
5901 struct root_item_record *ri,
5902 u64 *flags)
5903 {
5904 struct extent_record *rec;
5905 struct cache_extent *cache;
5906 struct tree_backref *tback;
5907 u64 owner = 0;
5908
5909 cache = lookup_cache_extent(extent_cache, buf->start, 1);
5910 /* we have added this extent before */
5911 BUG_ON(!cache);
5912 rec = container_of(cache, struct extent_record, cache);
5913
5914 /*
5915 * Except file/reloc tree, we can not have
5916 * FULL BACKREF MODE
5917 */
5918 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
5919 goto normal;
5920 /*
5921 * root node
5922 */
5923 if (buf->start == ri->bytenr)
5924 goto normal;
5925
5926 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
5927 goto full_backref;
5928
5929 owner = btrfs_header_owner(buf);
5930 if (owner == ri->objectid)
5931 goto normal;
5932
5933 tback = find_tree_backref(rec, 0, owner);
5934 if (!tback)
5935 goto full_backref;
5936 normal:
5937 *flags = 0;
5938 if (rec->flag_block_full_backref != FLAG_UNSET &&
5939 rec->flag_block_full_backref != 0)
5940 rec->bad_full_backref = 1;
5941 return 0;
5942 full_backref:
5943 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
5944 if (rec->flag_block_full_backref != FLAG_UNSET &&
5945 rec->flag_block_full_backref != 1)
5946 rec->bad_full_backref = 1;
5947 return 0;
5948 }
5949
5950 static int run_next_block(struct btrfs_root *root,
5951 struct block_info *bits,
5952 int bits_nr,
5953 u64 *last,
5954 struct cache_tree *pending,
5955 struct cache_tree *seen,
5956 struct cache_tree *reada,
5957 struct cache_tree *nodes,
5958 struct cache_tree *extent_cache,
5959 struct cache_tree *chunk_cache,
5960 struct rb_root *dev_cache,
5961 struct block_group_tree *block_group_cache,
5962 struct device_extent_tree *dev_extent_cache,
5963 struct root_item_record *ri)
5964 {
5965 struct extent_buffer *buf;
5966 struct extent_record *rec = NULL;
5967 u64 bytenr;
5968 u32 size;
5969 u64 parent;
5970 u64 owner;
5971 u64 flags;
5972 u64 ptr;
5973 u64 gen = 0;
5974 int ret = 0;
5975 int i;
5976 int nritems;
5977 struct btrfs_key key;
5978 struct cache_extent *cache;
5979 int reada_bits;
5980
5981 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
5982 bits_nr, &reada_bits);
5983 if (nritems == 0)
5984 return 1;
5985
5986 if (!reada_bits) {
5987 for(i = 0; i < nritems; i++) {
5988 ret = add_cache_extent(reada, bits[i].start,
5989 bits[i].size);
5990 if (ret == -EEXIST)
5991 continue;
5992
5993 /* fixme, get the parent transid */
5994 readahead_tree_block(root, bits[i].start,
5995 bits[i].size, 0);
5996 }
5997 }
5998 *last = bits[0].start;
5999 bytenr = bits[0].start;
6000 size = bits[0].size;
6001
6002 cache = lookup_cache_extent(pending, bytenr, size);
6003 if (cache) {
6004 remove_cache_extent(pending, cache);
6005 free(cache);
6006 }
6007 cache = lookup_cache_extent(reada, bytenr, size);
6008 if (cache) {
6009 remove_cache_extent(reada, cache);
6010 free(cache);
6011 }
6012 cache = lookup_cache_extent(nodes, bytenr, size);
6013 if (cache) {
6014 remove_cache_extent(nodes, cache);
6015 free(cache);
6016 }
6017 cache = lookup_cache_extent(extent_cache, bytenr, size);
6018 if (cache) {
6019 rec = container_of(cache, struct extent_record, cache);
6020 gen = rec->parent_generation;
6021 }
6022
6023 /* fixme, get the real parent transid */
6024 buf = read_tree_block(root, bytenr, size, gen);
6025 if (!extent_buffer_uptodate(buf)) {
6026 record_bad_block_io(root->fs_info,
6027 extent_cache, bytenr, size);
6028 goto out;
6029 }
6030
6031 nritems = btrfs_header_nritems(buf);
6032
6033 flags = 0;
6034 if (!init_extent_tree) {
6035 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
6036 btrfs_header_level(buf), 1, NULL,
6037 &flags);
6038 if (ret < 0) {
6039 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
6040 if (ret < 0) {
6041 fprintf(stderr, "Couldn't calc extent flags\n");
6042 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
6043 }
6044 }
6045 } else {
6046 flags = 0;
6047 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
6048 if (ret < 0) {
6049 fprintf(stderr, "Couldn't calc extent flags\n");
6050 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
6051 }
6052 }
6053
6054 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
6055 if (ri != NULL &&
6056 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
6057 ri->objectid == btrfs_header_owner(buf)) {
6058 /*
6059 * Ok we got to this block from it's original owner and
6060 * we have FULL_BACKREF set. Relocation can leave
6061 * converted blocks over so this is altogether possible,
6062 * however it's not possible if the generation > the
6063 * last snapshot, so check for this case.
6064 */
6065 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
6066 btrfs_header_generation(buf) > ri->last_snapshot) {
6067 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
6068 rec->bad_full_backref = 1;
6069 }
6070 }
6071 } else {
6072 if (ri != NULL &&
6073 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
6074 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
6075 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
6076 rec->bad_full_backref = 1;
6077 }
6078 }
6079
6080 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
6081 rec->flag_block_full_backref = 1;
6082 parent = bytenr;
6083 owner = 0;
6084 } else {
6085 rec->flag_block_full_backref = 0;
6086 parent = 0;
6087 owner = btrfs_header_owner(buf);
6088 }
6089
6090 ret = check_block(root, extent_cache, buf, flags);
6091 if (ret)
6092 goto out;
6093
6094 if (btrfs_is_leaf(buf)) {
6095 btree_space_waste += btrfs_leaf_free_space(root, buf);
6096 for (i = 0; i < nritems; i++) {
6097 struct btrfs_file_extent_item *fi;
6098 btrfs_item_key_to_cpu(buf, &key, i);
6099 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
6100 process_extent_item(root, extent_cache, buf,
6101 i);
6102 continue;
6103 }
6104 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6105 process_extent_item(root, extent_cache, buf,
6106 i);
6107 continue;
6108 }
6109 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
6110 total_csum_bytes +=
6111 btrfs_item_size_nr(buf, i);
6112 continue;
6113 }
6114 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
6115 process_chunk_item(chunk_cache, &key, buf, i);
6116 continue;
6117 }
6118 if (key.type == BTRFS_DEV_ITEM_KEY) {
6119 process_device_item(dev_cache, &key, buf, i);
6120 continue;
6121 }
6122 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
6123 process_block_group_item(block_group_cache,
6124 &key, buf, i);
6125 continue;
6126 }
6127 if (key.type == BTRFS_DEV_EXTENT_KEY) {
6128 process_device_extent_item(dev_extent_cache,
6129 &key, buf, i);
6130 continue;
6131
6132 }
6133 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
6134 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6135 process_extent_ref_v0(extent_cache, buf, i);
6136 #else
6137 BUG();
6138 #endif
6139 continue;
6140 }
6141
6142 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
6143 add_tree_backref(extent_cache, key.objectid, 0,
6144 key.offset, 0);
6145 continue;
6146 }
6147 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
6148 add_tree_backref(extent_cache, key.objectid,
6149 key.offset, 0, 0);
6150 continue;
6151 }
6152 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
6153 struct btrfs_extent_data_ref *ref;
6154 ref = btrfs_item_ptr(buf, i,
6155 struct btrfs_extent_data_ref);
6156 add_data_backref(extent_cache,
6157 key.objectid, 0,
6158 btrfs_extent_data_ref_root(buf, ref),
6159 btrfs_extent_data_ref_objectid(buf,
6160 ref),
6161 btrfs_extent_data_ref_offset(buf, ref),
6162 btrfs_extent_data_ref_count(buf, ref),
6163 0, root->sectorsize);
6164 continue;
6165 }
6166 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
6167 struct btrfs_shared_data_ref *ref;
6168 ref = btrfs_item_ptr(buf, i,
6169 struct btrfs_shared_data_ref);
6170 add_data_backref(extent_cache,
6171 key.objectid, key.offset, 0, 0, 0,
6172 btrfs_shared_data_ref_count(buf, ref),
6173 0, root->sectorsize);
6174 continue;
6175 }
6176 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
6177 struct bad_item *bad;
6178
6179 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
6180 continue;
6181 if (!owner)
6182 continue;
6183 bad = malloc(sizeof(struct bad_item));
6184 if (!bad)
6185 continue;
6186 INIT_LIST_HEAD(&bad->list);
6187 memcpy(&bad->key, &key,
6188 sizeof(struct btrfs_key));
6189 bad->root_id = owner;
6190 list_add_tail(&bad->list, &delete_items);
6191 continue;
6192 }
6193 if (key.type != BTRFS_EXTENT_DATA_KEY)
6194 continue;
6195 fi = btrfs_item_ptr(buf, i,
6196 struct btrfs_file_extent_item);
6197 if (btrfs_file_extent_type(buf, fi) ==
6198 BTRFS_FILE_EXTENT_INLINE)
6199 continue;
6200 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
6201 continue;
6202
6203 data_bytes_allocated +=
6204 btrfs_file_extent_disk_num_bytes(buf, fi);
6205 if (data_bytes_allocated < root->sectorsize) {
6206 abort();
6207 }
6208 data_bytes_referenced +=
6209 btrfs_file_extent_num_bytes(buf, fi);
6210 add_data_backref(extent_cache,
6211 btrfs_file_extent_disk_bytenr(buf, fi),
6212 parent, owner, key.objectid, key.offset -
6213 btrfs_file_extent_offset(buf, fi), 1, 1,
6214 btrfs_file_extent_disk_num_bytes(buf, fi));
6215 }
6216 } else {
6217 int level;
6218 struct btrfs_key first_key;
6219
6220 first_key.objectid = 0;
6221
6222 if (nritems > 0)
6223 btrfs_item_key_to_cpu(buf, &first_key, 0);
6224 level = btrfs_header_level(buf);
6225 for (i = 0; i < nritems; i++) {
6226 struct extent_record tmpl;
6227
6228 ptr = btrfs_node_blockptr(buf, i);
6229 size = root->nodesize;
6230 btrfs_node_key_to_cpu(buf, &key, i);
6231 if (ri != NULL) {
6232 if ((level == ri->drop_level)
6233 && is_dropped_key(&key, &ri->drop_key)) {
6234 continue;
6235 }
6236 }
6237
6238 memset(&tmpl, 0, sizeof(tmpl));
6239 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
6240 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
6241 tmpl.start = ptr;
6242 tmpl.nr = size;
6243 tmpl.refs = 1;
6244 tmpl.metadata = 1;
6245 tmpl.max_size = size;
6246 ret = add_extent_rec(extent_cache, &tmpl);
6247 BUG_ON(ret);
6248
6249 add_tree_backref(extent_cache, ptr, parent, owner, 1);
6250
6251 if (level > 1) {
6252 add_pending(nodes, seen, ptr, size);
6253 } else {
6254 add_pending(pending, seen, ptr, size);
6255 }
6256 }
6257 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
6258 nritems) * sizeof(struct btrfs_key_ptr);
6259 }
6260 total_btree_bytes += buf->len;
6261 if (fs_root_objectid(btrfs_header_owner(buf)))
6262 total_fs_tree_bytes += buf->len;
6263 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
6264 total_extent_tree_bytes += buf->len;
6265 if (!found_old_backref &&
6266 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
6267 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
6268 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
6269 found_old_backref = 1;
6270 out:
6271 free_extent_buffer(buf);
6272 return ret;
6273 }
6274
6275 static int add_root_to_pending(struct extent_buffer *buf,
6276 struct cache_tree *extent_cache,
6277 struct cache_tree *pending,
6278 struct cache_tree *seen,
6279 struct cache_tree *nodes,
6280 u64 objectid)
6281 {
6282 struct extent_record tmpl;
6283
6284 if (btrfs_header_level(buf) > 0)
6285 add_pending(nodes, seen, buf->start, buf->len);
6286 else
6287 add_pending(pending, seen, buf->start, buf->len);
6288
6289 memset(&tmpl, 0, sizeof(tmpl));
6290 tmpl.start = buf->start;
6291 tmpl.nr = buf->len;
6292 tmpl.is_root = 1;
6293 tmpl.refs = 1;
6294 tmpl.metadata = 1;
6295 tmpl.max_size = buf->len;
6296 add_extent_rec(extent_cache, &tmpl);
6297
6298 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
6299 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
6300 add_tree_backref(extent_cache, buf->start, buf->start,
6301 0, 1);
6302 else
6303 add_tree_backref(extent_cache, buf->start, 0, objectid, 1);
6304 return 0;
6305 }
6306
6307 /* as we fix the tree, we might be deleting blocks that
6308 * we're tracking for repair. This hook makes sure we
6309 * remove any backrefs for blocks as we are fixing them.
6310 */
6311 static int free_extent_hook(struct btrfs_trans_handle *trans,
6312 struct btrfs_root *root,
6313 u64 bytenr, u64 num_bytes, u64 parent,
6314 u64 root_objectid, u64 owner, u64 offset,
6315 int refs_to_drop)
6316 {
6317 struct extent_record *rec;
6318 struct cache_extent *cache;
6319 int is_data;
6320 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
6321
6322 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
6323 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
6324 if (!cache)
6325 return 0;
6326
6327 rec = container_of(cache, struct extent_record, cache);
6328 if (is_data) {
6329 struct data_backref *back;
6330 back = find_data_backref(rec, parent, root_objectid, owner,
6331 offset, 1, bytenr, num_bytes);
6332 if (!back)
6333 goto out;
6334 if (back->node.found_ref) {
6335 back->found_ref -= refs_to_drop;
6336 if (rec->refs)
6337 rec->refs -= refs_to_drop;
6338 }
6339 if (back->node.found_extent_tree) {
6340 back->num_refs -= refs_to_drop;
6341 if (rec->extent_item_refs)
6342 rec->extent_item_refs -= refs_to_drop;
6343 }
6344 if (back->found_ref == 0)
6345 back->node.found_ref = 0;
6346 if (back->num_refs == 0)
6347 back->node.found_extent_tree = 0;
6348
6349 if (!back->node.found_extent_tree && back->node.found_ref) {
6350 list_del(&back->node.list);
6351 free(back);
6352 }
6353 } else {
6354 struct tree_backref *back;
6355 back = find_tree_backref(rec, parent, root_objectid);
6356 if (!back)
6357 goto out;
6358 if (back->node.found_ref) {
6359 if (rec->refs)
6360 rec->refs--;
6361 back->node.found_ref = 0;
6362 }
6363 if (back->node.found_extent_tree) {
6364 if (rec->extent_item_refs)
6365 rec->extent_item_refs--;
6366 back->node.found_extent_tree = 0;
6367 }
6368 if (!back->node.found_extent_tree && back->node.found_ref) {
6369 list_del(&back->node.list);
6370 free(back);
6371 }
6372 }
6373 maybe_free_extent_rec(extent_cache, rec);
6374 out:
6375 return 0;
6376 }
6377
6378 static int delete_extent_records(struct btrfs_trans_handle *trans,
6379 struct btrfs_root *root,
6380 struct btrfs_path *path,
6381 u64 bytenr, u64 new_len)
6382 {
6383 struct btrfs_key key;
6384 struct btrfs_key found_key;
6385 struct extent_buffer *leaf;
6386 int ret;
6387 int slot;
6388
6389
6390 key.objectid = bytenr;
6391 key.type = (u8)-1;
6392 key.offset = (u64)-1;
6393
6394 while(1) {
6395 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
6396 &key, path, 0, 1);
6397 if (ret < 0)
6398 break;
6399
6400 if (ret > 0) {
6401 ret = 0;
6402 if (path->slots[0] == 0)
6403 break;
6404 path->slots[0]--;
6405 }
6406 ret = 0;
6407
6408 leaf = path->nodes[0];
6409 slot = path->slots[0];
6410
6411 btrfs_item_key_to_cpu(leaf, &found_key, slot);
6412 if (found_key.objectid != bytenr)
6413 break;
6414
6415 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
6416 found_key.type != BTRFS_METADATA_ITEM_KEY &&
6417 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
6418 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
6419 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
6420 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
6421 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
6422 btrfs_release_path(path);
6423 if (found_key.type == 0) {
6424 if (found_key.offset == 0)
6425 break;
6426 key.offset = found_key.offset - 1;
6427 key.type = found_key.type;
6428 }
6429 key.type = found_key.type - 1;
6430 key.offset = (u64)-1;
6431 continue;
6432 }
6433
6434 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
6435 found_key.objectid, found_key.type, found_key.offset);
6436
6437 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
6438 if (ret)
6439 break;
6440 btrfs_release_path(path);
6441
6442 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
6443 found_key.type == BTRFS_METADATA_ITEM_KEY) {
6444 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
6445 found_key.offset : root->nodesize;
6446
6447 ret = btrfs_update_block_group(trans, root, bytenr,
6448 bytes, 0, 0);
6449 if (ret)
6450 break;
6451 }
6452 }
6453
6454 btrfs_release_path(path);
6455 return ret;
6456 }
6457
6458 /*
6459 * for a single backref, this will allocate a new extent
6460 * and add the backref to it.
6461 */
6462 static int record_extent(struct btrfs_trans_handle *trans,
6463 struct btrfs_fs_info *info,
6464 struct btrfs_path *path,
6465 struct extent_record *rec,
6466 struct extent_backref *back,
6467 int allocated, u64 flags)
6468 {
6469 int ret;
6470 struct btrfs_root *extent_root = info->extent_root;
6471 struct extent_buffer *leaf;
6472 struct btrfs_key ins_key;
6473 struct btrfs_extent_item *ei;
6474 struct tree_backref *tback;
6475 struct data_backref *dback;
6476 struct btrfs_tree_block_info *bi;
6477
6478 if (!back->is_data)
6479 rec->max_size = max_t(u64, rec->max_size,
6480 info->extent_root->nodesize);
6481
6482 if (!allocated) {
6483 u32 item_size = sizeof(*ei);
6484
6485 if (!back->is_data)
6486 item_size += sizeof(*bi);
6487
6488 ins_key.objectid = rec->start;
6489 ins_key.offset = rec->max_size;
6490 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
6491
6492 ret = btrfs_insert_empty_item(trans, extent_root, path,
6493 &ins_key, item_size);
6494 if (ret)
6495 goto fail;
6496
6497 leaf = path->nodes[0];
6498 ei = btrfs_item_ptr(leaf, path->slots[0],
6499 struct btrfs_extent_item);
6500
6501 btrfs_set_extent_refs(leaf, ei, 0);
6502 btrfs_set_extent_generation(leaf, ei, rec->generation);
6503
6504 if (back->is_data) {
6505 btrfs_set_extent_flags(leaf, ei,
6506 BTRFS_EXTENT_FLAG_DATA);
6507 } else {
6508 struct btrfs_disk_key copy_key;;
6509
6510 tback = (struct tree_backref *)back;
6511 bi = (struct btrfs_tree_block_info *)(ei + 1);
6512 memset_extent_buffer(leaf, 0, (unsigned long)bi,
6513 sizeof(*bi));
6514
6515 btrfs_set_disk_key_objectid(&copy_key,
6516 rec->info_objectid);
6517 btrfs_set_disk_key_type(&copy_key, 0);
6518 btrfs_set_disk_key_offset(&copy_key, 0);
6519
6520 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
6521 btrfs_set_tree_block_key(leaf, bi, &copy_key);
6522
6523 btrfs_set_extent_flags(leaf, ei,
6524 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
6525 }
6526
6527 btrfs_mark_buffer_dirty(leaf);
6528 ret = btrfs_update_block_group(trans, extent_root, rec->start,
6529 rec->max_size, 1, 0);
6530 if (ret)
6531 goto fail;
6532 btrfs_release_path(path);
6533 }
6534
6535 if (back->is_data) {
6536 u64 parent;
6537 int i;
6538
6539 dback = (struct data_backref *)back;
6540 if (back->full_backref)
6541 parent = dback->parent;
6542 else
6543 parent = 0;
6544
6545 for (i = 0; i < dback->found_ref; i++) {
6546 /* if parent != 0, we're doing a full backref
6547 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
6548 * just makes the backref allocator create a data
6549 * backref
6550 */
6551 ret = btrfs_inc_extent_ref(trans, info->extent_root,
6552 rec->start, rec->max_size,
6553 parent,
6554 dback->root,
6555 parent ?
6556 BTRFS_FIRST_FREE_OBJECTID :
6557 dback->owner,
6558 dback->offset);
6559 if (ret)
6560 break;
6561 }
6562 fprintf(stderr, "adding new data backref"
6563 " on %llu %s %llu owner %llu"
6564 " offset %llu found %d\n",
6565 (unsigned long long)rec->start,
6566 back->full_backref ?
6567 "parent" : "root",
6568 back->full_backref ?
6569 (unsigned long long)parent :
6570 (unsigned long long)dback->root,
6571 (unsigned long long)dback->owner,
6572 (unsigned long long)dback->offset,
6573 dback->found_ref);
6574 } else {
6575 u64 parent;
6576
6577 tback = (struct tree_backref *)back;
6578 if (back->full_backref)
6579 parent = tback->parent;
6580 else
6581 parent = 0;
6582
6583 ret = btrfs_inc_extent_ref(trans, info->extent_root,
6584 rec->start, rec->max_size,
6585 parent, tback->root, 0, 0);
6586 fprintf(stderr, "adding new tree backref on "
6587 "start %llu len %llu parent %llu root %llu\n",
6588 rec->start, rec->max_size, parent, tback->root);
6589 }
6590 fail:
6591 btrfs_release_path(path);
6592 return ret;
6593 }
6594
6595 static struct extent_entry *find_entry(struct list_head *entries,
6596 u64 bytenr, u64 bytes)
6597 {
6598 struct extent_entry *entry = NULL;
6599
6600 list_for_each_entry(entry, entries, list) {
6601 if (entry->bytenr == bytenr && entry->bytes == bytes)
6602 return entry;
6603 }
6604
6605 return NULL;
6606 }
6607
6608 static struct extent_entry *find_most_right_entry(struct list_head *entries)
6609 {
6610 struct extent_entry *entry, *best = NULL, *prev = NULL;
6611
6612 list_for_each_entry(entry, entries, list) {
6613 if (!prev) {
6614 prev = entry;
6615 continue;
6616 }
6617
6618 /*
6619 * If there are as many broken entries as entries then we know
6620 * not to trust this particular entry.
6621 */
6622 if (entry->broken == entry->count)
6623 continue;
6624
6625 /*
6626 * If our current entry == best then we can't be sure our best
6627 * is really the best, so we need to keep searching.
6628 */
6629 if (best && best->count == entry->count) {
6630 prev = entry;
6631 best = NULL;
6632 continue;
6633 }
6634
6635 /* Prev == entry, not good enough, have to keep searching */
6636 if (!prev->broken && prev->count == entry->count)
6637 continue;
6638
6639 if (!best)
6640 best = (prev->count > entry->count) ? prev : entry;
6641 else if (best->count < entry->count)
6642 best = entry;
6643 prev = entry;
6644 }
6645
6646 return best;
6647 }
6648
6649 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
6650 struct data_backref *dback, struct extent_entry *entry)
6651 {
6652 struct btrfs_trans_handle *trans;
6653 struct btrfs_root *root;
6654 struct btrfs_file_extent_item *fi;
6655 struct extent_buffer *leaf;
6656 struct btrfs_key key;
6657 u64 bytenr, bytes;
6658 int ret, err;
6659
6660 key.objectid = dback->root;
6661 key.type = BTRFS_ROOT_ITEM_KEY;
6662 key.offset = (u64)-1;
6663 root = btrfs_read_fs_root(info, &key);
6664 if (IS_ERR(root)) {
6665 fprintf(stderr, "Couldn't find root for our ref\n");
6666 return -EINVAL;
6667 }
6668
6669 /*
6670 * The backref points to the original offset of the extent if it was
6671 * split, so we need to search down to the offset we have and then walk
6672 * forward until we find the backref we're looking for.
6673 */
6674 key.objectid = dback->owner;
6675 key.type = BTRFS_EXTENT_DATA_KEY;
6676 key.offset = dback->offset;
6677 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6678 if (ret < 0) {
6679 fprintf(stderr, "Error looking up ref %d\n", ret);
6680 return ret;
6681 }
6682
6683 while (1) {
6684 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
6685 ret = btrfs_next_leaf(root, path);
6686 if (ret) {
6687 fprintf(stderr, "Couldn't find our ref, next\n");
6688 return -EINVAL;
6689 }
6690 }
6691 leaf = path->nodes[0];
6692 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
6693 if (key.objectid != dback->owner ||
6694 key.type != BTRFS_EXTENT_DATA_KEY) {
6695 fprintf(stderr, "Couldn't find our ref, search\n");
6696 return -EINVAL;
6697 }
6698 fi = btrfs_item_ptr(leaf, path->slots[0],
6699 struct btrfs_file_extent_item);
6700 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
6701 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
6702
6703 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
6704 break;
6705 path->slots[0]++;
6706 }
6707
6708 btrfs_release_path(path);
6709
6710 trans = btrfs_start_transaction(root, 1);
6711 if (IS_ERR(trans))
6712 return PTR_ERR(trans);
6713
6714 /*
6715 * Ok we have the key of the file extent we want to fix, now we can cow
6716 * down to the thing and fix it.
6717 */
6718 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
6719 if (ret < 0) {
6720 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
6721 key.objectid, key.type, key.offset, ret);
6722 goto out;
6723 }
6724 if (ret > 0) {
6725 fprintf(stderr, "Well that's odd, we just found this key "
6726 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
6727 key.offset);
6728 ret = -EINVAL;
6729 goto out;
6730 }
6731 leaf = path->nodes[0];
6732 fi = btrfs_item_ptr(leaf, path->slots[0],
6733 struct btrfs_file_extent_item);
6734
6735 if (btrfs_file_extent_compression(leaf, fi) &&
6736 dback->disk_bytenr != entry->bytenr) {
6737 fprintf(stderr, "Ref doesn't match the record start and is "
6738 "compressed, please take a btrfs-image of this file "
6739 "system and send it to a btrfs developer so they can "
6740 "complete this functionality for bytenr %Lu\n",
6741 dback->disk_bytenr);
6742 ret = -EINVAL;
6743 goto out;
6744 }
6745
6746 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
6747 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6748 } else if (dback->disk_bytenr > entry->bytenr) {
6749 u64 off_diff, offset;
6750
6751 off_diff = dback->disk_bytenr - entry->bytenr;
6752 offset = btrfs_file_extent_offset(leaf, fi);
6753 if (dback->disk_bytenr + offset +
6754 btrfs_file_extent_num_bytes(leaf, fi) >
6755 entry->bytenr + entry->bytes) {
6756 fprintf(stderr, "Ref is past the entry end, please "
6757 "take a btrfs-image of this file system and "
6758 "send it to a btrfs developer, ref %Lu\n",
6759 dback->disk_bytenr);
6760 ret = -EINVAL;
6761 goto out;
6762 }
6763 offset += off_diff;
6764 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6765 btrfs_set_file_extent_offset(leaf, fi, offset);
6766 } else if (dback->disk_bytenr < entry->bytenr) {
6767 u64 offset;
6768
6769 offset = btrfs_file_extent_offset(leaf, fi);
6770 if (dback->disk_bytenr + offset < entry->bytenr) {
6771 fprintf(stderr, "Ref is before the entry start, please"
6772 " take a btrfs-image of this file system and "
6773 "send it to a btrfs developer, ref %Lu\n",
6774 dback->disk_bytenr);
6775 ret = -EINVAL;
6776 goto out;
6777 }
6778
6779 offset += dback->disk_bytenr;
6780 offset -= entry->bytenr;
6781 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6782 btrfs_set_file_extent_offset(leaf, fi, offset);
6783 }
6784
6785 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
6786
6787 /*
6788 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
6789 * only do this if we aren't using compression, otherwise it's a
6790 * trickier case.
6791 */
6792 if (!btrfs_file_extent_compression(leaf, fi))
6793 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
6794 else
6795 printf("ram bytes may be wrong?\n");
6796 btrfs_mark_buffer_dirty(leaf);
6797 out:
6798 err = btrfs_commit_transaction(trans, root);
6799 btrfs_release_path(path);
6800 return ret ? ret : err;
6801 }
6802
6803 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
6804 struct extent_record *rec)
6805 {
6806 struct extent_backref *back;
6807 struct data_backref *dback;
6808 struct extent_entry *entry, *best = NULL;
6809 LIST_HEAD(entries);
6810 int nr_entries = 0;
6811 int broken_entries = 0;
6812 int ret = 0;
6813 short mismatch = 0;
6814
6815 /*
6816 * Metadata is easy and the backrefs should always agree on bytenr and
6817 * size, if not we've got bigger issues.
6818 */
6819 if (rec->metadata)
6820 return 0;
6821
6822 list_for_each_entry(back, &rec->backrefs, list) {
6823 if (back->full_backref || !back->is_data)
6824 continue;
6825
6826 dback = (struct data_backref *)back;
6827
6828 /*
6829 * We only pay attention to backrefs that we found a real
6830 * backref for.
6831 */
6832 if (dback->found_ref == 0)
6833 continue;
6834
6835 /*
6836 * For now we only catch when the bytes don't match, not the
6837 * bytenr. We can easily do this at the same time, but I want
6838 * to have a fs image to test on before we just add repair
6839 * functionality willy-nilly so we know we won't screw up the
6840 * repair.
6841 */
6842
6843 entry = find_entry(&entries, dback->disk_bytenr,
6844 dback->bytes);
6845 if (!entry) {
6846 entry = malloc(sizeof(struct extent_entry));
6847 if (!entry) {
6848 ret = -ENOMEM;
6849 goto out;
6850 }
6851 memset(entry, 0, sizeof(*entry));
6852 entry->bytenr = dback->disk_bytenr;
6853 entry->bytes = dback->bytes;
6854 list_add_tail(&entry->list, &entries);
6855 nr_entries++;
6856 }
6857
6858 /*
6859 * If we only have on entry we may think the entries agree when
6860 * in reality they don't so we have to do some extra checking.
6861 */
6862 if (dback->disk_bytenr != rec->start ||
6863 dback->bytes != rec->nr || back->broken)
6864 mismatch = 1;
6865
6866 if (back->broken) {
6867 entry->broken++;
6868 broken_entries++;
6869 }
6870
6871 entry->count++;
6872 }
6873
6874 /* Yay all the backrefs agree, carry on good sir */
6875 if (nr_entries <= 1 && !mismatch)
6876 goto out;
6877
6878 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
6879 "%Lu\n", rec->start);
6880
6881 /*
6882 * First we want to see if the backrefs can agree amongst themselves who
6883 * is right, so figure out which one of the entries has the highest
6884 * count.
6885 */
6886 best = find_most_right_entry(&entries);
6887
6888 /*
6889 * Ok so we may have an even split between what the backrefs think, so
6890 * this is where we use the extent ref to see what it thinks.
6891 */
6892 if (!best) {
6893 entry = find_entry(&entries, rec->start, rec->nr);
6894 if (!entry && (!broken_entries || !rec->found_rec)) {
6895 fprintf(stderr, "Backrefs don't agree with each other "
6896 "and extent record doesn't agree with anybody,"
6897 " so we can't fix bytenr %Lu bytes %Lu\n",
6898 rec->start, rec->nr);
6899 ret = -EINVAL;
6900 goto out;
6901 } else if (!entry) {
6902 /*
6903 * Ok our backrefs were broken, we'll assume this is the
6904 * correct value and add an entry for this range.
6905 */
6906 entry = malloc(sizeof(struct extent_entry));
6907 if (!entry) {
6908 ret = -ENOMEM;
6909 goto out;
6910 }
6911 memset(entry, 0, sizeof(*entry));
6912 entry->bytenr = rec->start;
6913 entry->bytes = rec->nr;
6914 list_add_tail(&entry->list, &entries);
6915 nr_entries++;
6916 }
6917 entry->count++;
6918 best = find_most_right_entry(&entries);
6919 if (!best) {
6920 fprintf(stderr, "Backrefs and extent record evenly "
6921 "split on who is right, this is going to "
6922 "require user input to fix bytenr %Lu bytes "
6923 "%Lu\n", rec->start, rec->nr);
6924 ret = -EINVAL;
6925 goto out;
6926 }
6927 }
6928
6929 /*
6930 * I don't think this can happen currently as we'll abort() if we catch
6931 * this case higher up, but in case somebody removes that we still can't
6932 * deal with it properly here yet, so just bail out of that's the case.
6933 */
6934 if (best->bytenr != rec->start) {
6935 fprintf(stderr, "Extent start and backref starts don't match, "
6936 "please use btrfs-image on this file system and send "
6937 "it to a btrfs developer so they can make fsck fix "
6938 "this particular case. bytenr is %Lu, bytes is %Lu\n",
6939 rec->start, rec->nr);
6940 ret = -EINVAL;
6941 goto out;
6942 }
6943
6944 /*
6945 * Ok great we all agreed on an extent record, let's go find the real
6946 * references and fix up the ones that don't match.
6947 */
6948 list_for_each_entry(back, &rec->backrefs, list) {
6949 if (back->full_backref || !back->is_data)
6950 continue;
6951
6952 dback = (struct data_backref *)back;
6953
6954 /*
6955 * Still ignoring backrefs that don't have a real ref attached
6956 * to them.
6957 */
6958 if (dback->found_ref == 0)
6959 continue;
6960
6961 if (dback->bytes == best->bytes &&
6962 dback->disk_bytenr == best->bytenr)
6963 continue;
6964
6965 ret = repair_ref(info, path, dback, best);
6966 if (ret)
6967 goto out;
6968 }
6969
6970 /*
6971 * Ok we messed with the actual refs, which means we need to drop our
6972 * entire cache and go back and rescan. I know this is a huge pain and
6973 * adds a lot of extra work, but it's the only way to be safe. Once all
6974 * the backrefs agree we may not need to do anything to the extent
6975 * record itself.
6976 */
6977 ret = -EAGAIN;
6978 out:
6979 while (!list_empty(&entries)) {
6980 entry = list_entry(entries.next, struct extent_entry, list);
6981 list_del_init(&entry->list);
6982 free(entry);
6983 }
6984 return ret;
6985 }
6986
6987 static int process_duplicates(struct btrfs_root *root,
6988 struct cache_tree *extent_cache,
6989 struct extent_record *rec)
6990 {
6991 struct extent_record *good, *tmp;
6992 struct cache_extent *cache;
6993 int ret;
6994
6995 /*
6996 * If we found a extent record for this extent then return, or if we
6997 * have more than one duplicate we are likely going to need to delete
6998 * something.
6999 */
7000 if (rec->found_rec || rec->num_duplicates > 1)
7001 return 0;
7002
7003 /* Shouldn't happen but just in case */
7004 BUG_ON(!rec->num_duplicates);
7005
7006 /*
7007 * So this happens if we end up with a backref that doesn't match the
7008 * actual extent entry. So either the backref is bad or the extent
7009 * entry is bad. Either way we want to have the extent_record actually
7010 * reflect what we found in the extent_tree, so we need to take the
7011 * duplicate out and use that as the extent_record since the only way we
7012 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
7013 */
7014 remove_cache_extent(extent_cache, &rec->cache);
7015
7016 good = list_entry(rec->dups.next, struct extent_record, list);
7017 list_del_init(&good->list);
7018 INIT_LIST_HEAD(&good->backrefs);
7019 INIT_LIST_HEAD(&good->dups);
7020 good->cache.start = good->start;
7021 good->cache.size = good->nr;
7022 good->content_checked = 0;
7023 good->owner_ref_checked = 0;
7024 good->num_duplicates = 0;
7025 good->refs = rec->refs;
7026 list_splice_init(&rec->backrefs, &good->backrefs);
7027 while (1) {
7028 cache = lookup_cache_extent(extent_cache, good->start,
7029 good->nr);
7030 if (!cache)
7031 break;
7032 tmp = container_of(cache, struct extent_record, cache);
7033
7034 /*
7035 * If we find another overlapping extent and it's found_rec is
7036 * set then it's a duplicate and we need to try and delete
7037 * something.
7038 */
7039 if (tmp->found_rec || tmp->num_duplicates > 0) {
7040 if (list_empty(&good->list))
7041 list_add_tail(&good->list,
7042 &duplicate_extents);
7043 good->num_duplicates += tmp->num_duplicates + 1;
7044 list_splice_init(&tmp->dups, &good->dups);
7045 list_del_init(&tmp->list);
7046 list_add_tail(&tmp->list, &good->dups);
7047 remove_cache_extent(extent_cache, &tmp->cache);
7048 continue;
7049 }
7050
7051 /*
7052 * Ok we have another non extent item backed extent rec, so lets
7053 * just add it to this extent and carry on like we did above.
7054 */
7055 good->refs += tmp->refs;
7056 list_splice_init(&tmp->backrefs, &good->backrefs);
7057 remove_cache_extent(extent_cache, &tmp->cache);
7058 free(tmp);
7059 }
7060 ret = insert_cache_extent(extent_cache, &good->cache);
7061 BUG_ON(ret);
7062 free(rec);
7063 return good->num_duplicates ? 0 : 1;
7064 }
7065
7066 static int delete_duplicate_records(struct btrfs_root *root,
7067 struct extent_record *rec)
7068 {
7069 struct btrfs_trans_handle *trans;
7070 LIST_HEAD(delete_list);
7071 struct btrfs_path *path;
7072 struct extent_record *tmp, *good, *n;
7073 int nr_del = 0;
7074 int ret = 0, err;
7075 struct btrfs_key key;
7076
7077 path = btrfs_alloc_path();
7078 if (!path) {
7079 ret = -ENOMEM;
7080 goto out;
7081 }
7082
7083 good = rec;
7084 /* Find the record that covers all of the duplicates. */
7085 list_for_each_entry(tmp, &rec->dups, list) {
7086 if (good->start < tmp->start)
7087 continue;
7088 if (good->nr > tmp->nr)
7089 continue;
7090
7091 if (tmp->start + tmp->nr < good->start + good->nr) {
7092 fprintf(stderr, "Ok we have overlapping extents that "
7093 "aren't completely covered by each other, this "
7094 "is going to require more careful thought. "
7095 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
7096 tmp->start, tmp->nr, good->start, good->nr);
7097 abort();
7098 }
7099 good = tmp;
7100 }
7101
7102 if (good != rec)
7103 list_add_tail(&rec->list, &delete_list);
7104
7105 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
7106 if (tmp == good)
7107 continue;
7108 list_move_tail(&tmp->list, &delete_list);
7109 }
7110
7111 root = root->fs_info->extent_root;
7112 trans = btrfs_start_transaction(root, 1);
7113 if (IS_ERR(trans)) {
7114 ret = PTR_ERR(trans);
7115 goto out;
7116 }
7117
7118 list_for_each_entry(tmp, &delete_list, list) {
7119 if (tmp->found_rec == 0)
7120 continue;
7121 key.objectid = tmp->start;
7122 key.type = BTRFS_EXTENT_ITEM_KEY;
7123 key.offset = tmp->nr;
7124
7125 /* Shouldn't happen but just in case */
7126 if (tmp->metadata) {
7127 fprintf(stderr, "Well this shouldn't happen, extent "
7128 "record overlaps but is metadata? "
7129 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
7130 abort();
7131 }
7132
7133 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
7134 if (ret) {
7135 if (ret > 0)
7136 ret = -EINVAL;
7137 break;
7138 }
7139 ret = btrfs_del_item(trans, root, path);
7140 if (ret)
7141 break;
7142 btrfs_release_path(path);
7143 nr_del++;
7144 }
7145 err = btrfs_commit_transaction(trans, root);
7146 if (err && !ret)
7147 ret = err;
7148 out:
7149 while (!list_empty(&delete_list)) {
7150 tmp = list_entry(delete_list.next, struct extent_record, list);
7151 list_del_init(&tmp->list);
7152 if (tmp == rec)
7153 continue;
7154 free(tmp);
7155 }
7156
7157 while (!list_empty(&rec->dups)) {
7158 tmp = list_entry(rec->dups.next, struct extent_record, list);
7159 list_del_init(&tmp->list);
7160 free(tmp);
7161 }
7162
7163 btrfs_free_path(path);
7164
7165 if (!ret && !nr_del)
7166 rec->num_duplicates = 0;
7167
7168 return ret ? ret : nr_del;
7169 }
7170
7171 static int find_possible_backrefs(struct btrfs_fs_info *info,
7172 struct btrfs_path *path,
7173 struct cache_tree *extent_cache,
7174 struct extent_record *rec)
7175 {
7176 struct btrfs_root *root;
7177 struct extent_backref *back;
7178 struct data_backref *dback;
7179 struct cache_extent *cache;
7180 struct btrfs_file_extent_item *fi;
7181 struct btrfs_key key;
7182 u64 bytenr, bytes;
7183 int ret;
7184
7185 list_for_each_entry(back, &rec->backrefs, list) {
7186 /* Don't care about full backrefs (poor unloved backrefs) */
7187 if (back->full_backref || !back->is_data)
7188 continue;
7189
7190 dback = (struct data_backref *)back;
7191
7192 /* We found this one, we don't need to do a lookup */
7193 if (dback->found_ref)
7194 continue;
7195
7196 key.objectid = dback->root;
7197 key.type = BTRFS_ROOT_ITEM_KEY;
7198 key.offset = (u64)-1;
7199
7200 root = btrfs_read_fs_root(info, &key);
7201
7202 /* No root, definitely a bad ref, skip */
7203 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
7204 continue;
7205 /* Other err, exit */
7206 if (IS_ERR(root))
7207 return PTR_ERR(root);
7208
7209 key.objectid = dback->owner;
7210 key.type = BTRFS_EXTENT_DATA_KEY;
7211 key.offset = dback->offset;
7212 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
7213 if (ret) {
7214 btrfs_release_path(path);
7215 if (ret < 0)
7216 return ret;
7217 /* Didn't find it, we can carry on */
7218 ret = 0;
7219 continue;
7220 }
7221
7222 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
7223 struct btrfs_file_extent_item);
7224 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
7225 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
7226 btrfs_release_path(path);
7227 cache = lookup_cache_extent(extent_cache, bytenr, 1);
7228 if (cache) {
7229 struct extent_record *tmp;
7230 tmp = container_of(cache, struct extent_record, cache);
7231
7232 /*
7233 * If we found an extent record for the bytenr for this
7234 * particular backref then we can't add it to our
7235 * current extent record. We only want to add backrefs
7236 * that don't have a corresponding extent item in the
7237 * extent tree since they likely belong to this record
7238 * and we need to fix it if it doesn't match bytenrs.
7239 */
7240 if (tmp->found_rec)
7241 continue;
7242 }
7243
7244 dback->found_ref += 1;
7245 dback->disk_bytenr = bytenr;
7246 dback->bytes = bytes;
7247
7248 /*
7249 * Set this so the verify backref code knows not to trust the
7250 * values in this backref.
7251 */
7252 back->broken = 1;
7253 }
7254
7255 return 0;
7256 }
7257
7258 /*
7259 * Record orphan data ref into corresponding root.
7260 *
7261 * Return 0 if the extent item contains data ref and recorded.
7262 * Return 1 if the extent item contains no useful data ref
7263 * On that case, it may contains only shared_dataref or metadata backref
7264 * or the file extent exists(this should be handled by the extent bytenr
7265 * recovery routine)
7266 * Return <0 if something goes wrong.
7267 */
7268 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
7269 struct extent_record *rec)
7270 {
7271 struct btrfs_key key;
7272 struct btrfs_root *dest_root;
7273 struct extent_backref *back;
7274 struct data_backref *dback;
7275 struct orphan_data_extent *orphan;
7276 struct btrfs_path *path;
7277 int recorded_data_ref = 0;
7278 int ret = 0;
7279
7280 if (rec->metadata)
7281 return 1;
7282 path = btrfs_alloc_path();
7283 if (!path)
7284 return -ENOMEM;
7285 list_for_each_entry(back, &rec->backrefs, list) {
7286 if (back->full_backref || !back->is_data ||
7287 !back->found_extent_tree)
7288 continue;
7289 dback = (struct data_backref *)back;
7290 if (dback->found_ref)
7291 continue;
7292 key.objectid = dback->root;
7293 key.type = BTRFS_ROOT_ITEM_KEY;
7294 key.offset = (u64)-1;
7295
7296 dest_root = btrfs_read_fs_root(fs_info, &key);
7297
7298 /* For non-exist root we just skip it */
7299 if (IS_ERR(dest_root) || !dest_root)
7300 continue;
7301
7302 key.objectid = dback->owner;
7303 key.type = BTRFS_EXTENT_DATA_KEY;
7304 key.offset = dback->offset;
7305
7306 ret = btrfs_search_slot(NULL, dest_root, &key, path, 0, 0);
7307 /*
7308 * For ret < 0, it's OK since the fs-tree may be corrupted,
7309 * we need to record it for inode/file extent rebuild.
7310 * For ret > 0, we record it only for file extent rebuild.
7311 * For ret == 0, the file extent exists but only bytenr
7312 * mismatch, let the original bytenr fix routine to handle,
7313 * don't record it.
7314 */
7315 if (ret == 0)
7316 continue;
7317 ret = 0;
7318 orphan = malloc(sizeof(*orphan));
7319 if (!orphan) {
7320 ret = -ENOMEM;
7321 goto out;
7322 }
7323 INIT_LIST_HEAD(&orphan->list);
7324 orphan->root = dback->root;
7325 orphan->objectid = dback->owner;
7326 orphan->offset = dback->offset;
7327 orphan->disk_bytenr = rec->cache.start;
7328 orphan->disk_len = rec->cache.size;
7329 list_add(&dest_root->orphan_data_extents, &orphan->list);
7330 recorded_data_ref = 1;
7331 }
7332 out:
7333 btrfs_free_path(path);
7334 if (!ret)
7335 return !recorded_data_ref;
7336 else
7337 return ret;
7338 }
7339
7340 /*
7341 * when an incorrect extent item is found, this will delete
7342 * all of the existing entries for it and recreate them
7343 * based on what the tree scan found.
7344 */
7345 static int fixup_extent_refs(struct btrfs_fs_info *info,
7346 struct cache_tree *extent_cache,
7347 struct extent_record *rec)
7348 {
7349 struct btrfs_trans_handle *trans = NULL;
7350 int ret;
7351 struct btrfs_path *path;
7352 struct list_head *cur = rec->backrefs.next;
7353 struct cache_extent *cache;
7354 struct extent_backref *back;
7355 int allocated = 0;
7356 u64 flags = 0;
7357
7358 if (rec->flag_block_full_backref)
7359 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7360
7361 path = btrfs_alloc_path();
7362 if (!path)
7363 return -ENOMEM;
7364
7365 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
7366 /*
7367 * Sometimes the backrefs themselves are so broken they don't
7368 * get attached to any meaningful rec, so first go back and
7369 * check any of our backrefs that we couldn't find and throw
7370 * them into the list if we find the backref so that
7371 * verify_backrefs can figure out what to do.
7372 */
7373 ret = find_possible_backrefs(info, path, extent_cache, rec);
7374 if (ret < 0)
7375 goto out;
7376 }
7377
7378 /* step one, make sure all of the backrefs agree */
7379 ret = verify_backrefs(info, path, rec);
7380 if (ret < 0)
7381 goto out;
7382
7383 trans = btrfs_start_transaction(info->extent_root, 1);
7384 if (IS_ERR(trans)) {
7385 ret = PTR_ERR(trans);
7386 goto out;
7387 }
7388
7389 /* step two, delete all the existing records */
7390 ret = delete_extent_records(trans, info->extent_root, path,
7391 rec->start, rec->max_size);
7392
7393 if (ret < 0)
7394 goto out;
7395
7396 /* was this block corrupt? If so, don't add references to it */
7397 cache = lookup_cache_extent(info->corrupt_blocks,
7398 rec->start, rec->max_size);
7399 if (cache) {
7400 ret = 0;
7401 goto out;
7402 }
7403
7404 /* step three, recreate all the refs we did find */
7405 while(cur != &rec->backrefs) {
7406 back = list_entry(cur, struct extent_backref, list);
7407 cur = cur->next;
7408
7409 /*
7410 * if we didn't find any references, don't create a
7411 * new extent record
7412 */
7413 if (!back->found_ref)
7414 continue;
7415
7416 rec->bad_full_backref = 0;
7417 ret = record_extent(trans, info, path, rec, back, allocated, flags);
7418 allocated = 1;
7419
7420 if (ret)
7421 goto out;
7422 }
7423 out:
7424 if (trans) {
7425 int err = btrfs_commit_transaction(trans, info->extent_root);
7426 if (!ret)
7427 ret = err;
7428 }
7429
7430 btrfs_free_path(path);
7431 return ret;
7432 }
7433
7434 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
7435 struct extent_record *rec)
7436 {
7437 struct btrfs_trans_handle *trans;
7438 struct btrfs_root *root = fs_info->extent_root;
7439 struct btrfs_path *path;
7440 struct btrfs_extent_item *ei;
7441 struct btrfs_key key;
7442 u64 flags;
7443 int ret = 0;
7444
7445 key.objectid = rec->start;
7446 if (rec->metadata) {
7447 key.type = BTRFS_METADATA_ITEM_KEY;
7448 key.offset = rec->info_level;
7449 } else {
7450 key.type = BTRFS_EXTENT_ITEM_KEY;
7451 key.offset = rec->max_size;
7452 }
7453
7454 path = btrfs_alloc_path();
7455 if (!path)
7456 return -ENOMEM;
7457
7458 trans = btrfs_start_transaction(root, 0);
7459 if (IS_ERR(trans)) {
7460 btrfs_free_path(path);
7461 return PTR_ERR(trans);
7462 }
7463
7464 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
7465 if (ret < 0) {
7466 btrfs_free_path(path);
7467 btrfs_commit_transaction(trans, root);
7468 return ret;
7469 } else if (ret) {
7470 fprintf(stderr, "Didn't find extent for %llu\n",
7471 (unsigned long long)rec->start);
7472 btrfs_free_path(path);
7473 btrfs_commit_transaction(trans, root);
7474 return -ENOENT;
7475 }
7476
7477 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
7478 struct btrfs_extent_item);
7479 flags = btrfs_extent_flags(path->nodes[0], ei);
7480 if (rec->flag_block_full_backref) {
7481 fprintf(stderr, "setting full backref on %llu\n",
7482 (unsigned long long)key.objectid);
7483 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7484 } else {
7485 fprintf(stderr, "clearing full backref on %llu\n",
7486 (unsigned long long)key.objectid);
7487 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7488 }
7489 btrfs_set_extent_flags(path->nodes[0], ei, flags);
7490 btrfs_mark_buffer_dirty(path->nodes[0]);
7491 btrfs_free_path(path);
7492 return btrfs_commit_transaction(trans, root);
7493 }
7494
7495 /* right now we only prune from the extent allocation tree */
7496 static int prune_one_block(struct btrfs_trans_handle *trans,
7497 struct btrfs_fs_info *info,
7498 struct btrfs_corrupt_block *corrupt)
7499 {
7500 int ret;
7501 struct btrfs_path path;
7502 struct extent_buffer *eb;
7503 u64 found;
7504 int slot;
7505 int nritems;
7506 int level = corrupt->level + 1;
7507
7508 btrfs_init_path(&path);
7509 again:
7510 /* we want to stop at the parent to our busted block */
7511 path.lowest_level = level;
7512
7513 ret = btrfs_search_slot(trans, info->extent_root,
7514 &corrupt->key, &path, -1, 1);
7515
7516 if (ret < 0)
7517 goto out;
7518
7519 eb = path.nodes[level];
7520 if (!eb) {
7521 ret = -ENOENT;
7522 goto out;
7523 }
7524
7525 /*
7526 * hopefully the search gave us the block we want to prune,
7527 * lets try that first
7528 */
7529 slot = path.slots[level];
7530 found = btrfs_node_blockptr(eb, slot);
7531 if (found == corrupt->cache.start)
7532 goto del_ptr;
7533
7534 nritems = btrfs_header_nritems(eb);
7535
7536 /* the search failed, lets scan this node and hope we find it */
7537 for (slot = 0; slot < nritems; slot++) {
7538 found = btrfs_node_blockptr(eb, slot);
7539 if (found == corrupt->cache.start)
7540 goto del_ptr;
7541 }
7542 /*
7543 * we couldn't find the bad block. TODO, search all the nodes for pointers
7544 * to this block
7545 */
7546 if (eb == info->extent_root->node) {
7547 ret = -ENOENT;
7548 goto out;
7549 } else {
7550 level++;
7551 btrfs_release_path(&path);
7552 goto again;
7553 }
7554
7555 del_ptr:
7556 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
7557 ret = btrfs_del_ptr(trans, info->extent_root, &path, level, slot);
7558
7559 out:
7560 btrfs_release_path(&path);
7561 return ret;
7562 }
7563
7564 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
7565 {
7566 struct btrfs_trans_handle *trans = NULL;
7567 struct cache_extent *cache;
7568 struct btrfs_corrupt_block *corrupt;
7569
7570 while (1) {
7571 cache = search_cache_extent(info->corrupt_blocks, 0);
7572 if (!cache)
7573 break;
7574 if (!trans) {
7575 trans = btrfs_start_transaction(info->extent_root, 1);
7576 if (IS_ERR(trans))
7577 return PTR_ERR(trans);
7578 }
7579 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
7580 prune_one_block(trans, info, corrupt);
7581 remove_cache_extent(info->corrupt_blocks, cache);
7582 }
7583 if (trans)
7584 return btrfs_commit_transaction(trans, info->extent_root);
7585 return 0;
7586 }
7587
7588 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
7589 {
7590 struct btrfs_block_group_cache *cache;
7591 u64 start, end;
7592 int ret;
7593
7594 while (1) {
7595 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
7596 &start, &end, EXTENT_DIRTY);
7597 if (ret)
7598 break;
7599 clear_extent_dirty(&fs_info->free_space_cache, start, end,
7600 GFP_NOFS);
7601 }
7602
7603 start = 0;
7604 while (1) {
7605 cache = btrfs_lookup_first_block_group(fs_info, start);
7606 if (!cache)
7607 break;
7608 if (cache->cached)
7609 cache->cached = 0;
7610 start = cache->key.objectid + cache->key.offset;
7611 }
7612 }
7613
7614 static int check_extent_refs(struct btrfs_root *root,
7615 struct cache_tree *extent_cache)
7616 {
7617 struct extent_record *rec;
7618 struct cache_extent *cache;
7619 int err = 0;
7620 int ret = 0;
7621 int fixed = 0;
7622 int had_dups = 0;
7623 int recorded = 0;
7624
7625 if (repair) {
7626 /*
7627 * if we're doing a repair, we have to make sure
7628 * we don't allocate from the problem extents.
7629 * In the worst case, this will be all the
7630 * extents in the FS
7631 */
7632 cache = search_cache_extent(extent_cache, 0);
7633 while(cache) {
7634 rec = container_of(cache, struct extent_record, cache);
7635 set_extent_dirty(root->fs_info->excluded_extents,
7636 rec->start,
7637 rec->start + rec->max_size - 1,
7638 GFP_NOFS);
7639 cache = next_cache_extent(cache);
7640 }
7641
7642 /* pin down all the corrupted blocks too */
7643 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
7644 while(cache) {
7645 set_extent_dirty(root->fs_info->excluded_extents,
7646 cache->start,
7647 cache->start + cache->size - 1,
7648 GFP_NOFS);
7649 cache = next_cache_extent(cache);
7650 }
7651 prune_corrupt_blocks(root->fs_info);
7652 reset_cached_block_groups(root->fs_info);
7653 }
7654
7655 reset_cached_block_groups(root->fs_info);
7656
7657 /*
7658 * We need to delete any duplicate entries we find first otherwise we
7659 * could mess up the extent tree when we have backrefs that actually
7660 * belong to a different extent item and not the weird duplicate one.
7661 */
7662 while (repair && !list_empty(&duplicate_extents)) {
7663 rec = list_entry(duplicate_extents.next, struct extent_record,
7664 list);
7665 list_del_init(&rec->list);
7666
7667 /* Sometimes we can find a backref before we find an actual
7668 * extent, so we need to process it a little bit to see if there
7669 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
7670 * if this is a backref screwup. If we need to delete stuff
7671 * process_duplicates() will return 0, otherwise it will return
7672 * 1 and we
7673 */
7674 if (process_duplicates(root, extent_cache, rec))
7675 continue;
7676 ret = delete_duplicate_records(root, rec);
7677 if (ret < 0)
7678 return ret;
7679 /*
7680 * delete_duplicate_records will return the number of entries
7681 * deleted, so if it's greater than 0 then we know we actually
7682 * did something and we need to remove.
7683 */
7684 if (ret)
7685 had_dups = 1;
7686 }
7687
7688 if (had_dups)
7689 return -EAGAIN;
7690
7691 while(1) {
7692 int cur_err = 0;
7693
7694 fixed = 0;
7695 recorded = 0;
7696 cache = search_cache_extent(extent_cache, 0);
7697 if (!cache)
7698 break;
7699 rec = container_of(cache, struct extent_record, cache);
7700 if (rec->num_duplicates) {
7701 fprintf(stderr, "extent item %llu has multiple extent "
7702 "items\n", (unsigned long long)rec->start);
7703 err = 1;
7704 cur_err = 1;
7705 }
7706
7707 if (rec->refs != rec->extent_item_refs) {
7708 fprintf(stderr, "ref mismatch on [%llu %llu] ",
7709 (unsigned long long)rec->start,
7710 (unsigned long long)rec->nr);
7711 fprintf(stderr, "extent item %llu, found %llu\n",
7712 (unsigned long long)rec->extent_item_refs,
7713 (unsigned long long)rec->refs);
7714 ret = record_orphan_data_extents(root->fs_info, rec);
7715 if (ret < 0)
7716 goto repair_abort;
7717 if (ret == 0) {
7718 recorded = 1;
7719 } else {
7720 /*
7721 * we can't use the extent to repair file
7722 * extent, let the fallback method handle it.
7723 */
7724 if (!fixed && repair) {
7725 ret = fixup_extent_refs(
7726 root->fs_info,
7727 extent_cache, rec);
7728 if (ret)
7729 goto repair_abort;
7730 fixed = 1;
7731 }
7732 }
7733 err = 1;
7734 cur_err = 1;
7735 }
7736 if (all_backpointers_checked(rec, 1)) {
7737 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
7738 (unsigned long long)rec->start,
7739 (unsigned long long)rec->nr);
7740
7741 if (!fixed && !recorded && repair) {
7742 ret = fixup_extent_refs(root->fs_info,
7743 extent_cache, rec);
7744 if (ret)
7745 goto repair_abort;
7746 fixed = 1;
7747 }
7748 cur_err = 1;
7749 err = 1;
7750 }
7751 if (!rec->owner_ref_checked) {
7752 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
7753 (unsigned long long)rec->start,
7754 (unsigned long long)rec->nr);
7755 if (!fixed && !recorded && repair) {
7756 ret = fixup_extent_refs(root->fs_info,
7757 extent_cache, rec);
7758 if (ret)
7759 goto repair_abort;
7760 fixed = 1;
7761 }
7762 err = 1;
7763 cur_err = 1;
7764 }
7765 if (rec->bad_full_backref) {
7766 fprintf(stderr, "bad full backref, on [%llu]\n",
7767 (unsigned long long)rec->start);
7768 if (repair) {
7769 ret = fixup_extent_flags(root->fs_info, rec);
7770 if (ret)
7771 goto repair_abort;
7772 fixed = 1;
7773 }
7774 err = 1;
7775 cur_err = 1;
7776 }
7777 /*
7778 * Although it's not a extent ref's problem, we reuse this
7779 * routine for error reporting.
7780 * No repair function yet.
7781 */
7782 if (rec->crossing_stripes) {
7783 fprintf(stderr,
7784 "bad metadata [%llu, %llu) crossing stripe boundary\n",
7785 rec->start, rec->start + rec->max_size);
7786 err = 1;
7787 cur_err = 1;
7788 }
7789
7790 if (rec->wrong_chunk_type) {
7791 fprintf(stderr,
7792 "bad extent [%llu, %llu), type mismatch with chunk\n",
7793 rec->start, rec->start + rec->max_size);
7794 err = 1;
7795 cur_err = 1;
7796 }
7797
7798 remove_cache_extent(extent_cache, cache);
7799 free_all_extent_backrefs(rec);
7800 if (!init_extent_tree && repair && (!cur_err || fixed))
7801 clear_extent_dirty(root->fs_info->excluded_extents,
7802 rec->start,
7803 rec->start + rec->max_size - 1,
7804 GFP_NOFS);
7805 free(rec);
7806 }
7807 repair_abort:
7808 if (repair) {
7809 if (ret && ret != -EAGAIN) {
7810 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
7811 exit(1);
7812 } else if (!ret) {
7813 struct btrfs_trans_handle *trans;
7814
7815 root = root->fs_info->extent_root;
7816 trans = btrfs_start_transaction(root, 1);
7817 if (IS_ERR(trans)) {
7818 ret = PTR_ERR(trans);
7819 goto repair_abort;
7820 }
7821
7822 btrfs_fix_block_accounting(trans, root);
7823 ret = btrfs_commit_transaction(trans, root);
7824 if (ret)
7825 goto repair_abort;
7826 }
7827 if (err)
7828 fprintf(stderr, "repaired damaged extent references\n");
7829 return ret;
7830 }
7831 return err;
7832 }
7833
7834 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
7835 {
7836 u64 stripe_size;
7837
7838 if (type & BTRFS_BLOCK_GROUP_RAID0) {
7839 stripe_size = length;
7840 stripe_size /= num_stripes;
7841 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
7842 stripe_size = length * 2;
7843 stripe_size /= num_stripes;
7844 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
7845 stripe_size = length;
7846 stripe_size /= (num_stripes - 1);
7847 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
7848 stripe_size = length;
7849 stripe_size /= (num_stripes - 2);
7850 } else {
7851 stripe_size = length;
7852 }
7853 return stripe_size;
7854 }
7855
7856 /*
7857 * Check the chunk with its block group/dev list ref:
7858 * Return 0 if all refs seems valid.
7859 * Return 1 if part of refs seems valid, need later check for rebuild ref
7860 * like missing block group and needs to search extent tree to rebuild them.
7861 * Return -1 if essential refs are missing and unable to rebuild.
7862 */
7863 static int check_chunk_refs(struct chunk_record *chunk_rec,
7864 struct block_group_tree *block_group_cache,
7865 struct device_extent_tree *dev_extent_cache,
7866 int silent)
7867 {
7868 struct cache_extent *block_group_item;
7869 struct block_group_record *block_group_rec;
7870 struct cache_extent *dev_extent_item;
7871 struct device_extent_record *dev_extent_rec;
7872 u64 devid;
7873 u64 offset;
7874 u64 length;
7875 int metadump_v2 = 0;
7876 int i;
7877 int ret = 0;
7878
7879 block_group_item = lookup_cache_extent(&block_group_cache->tree,
7880 chunk_rec->offset,
7881 chunk_rec->length);
7882 if (block_group_item) {
7883 block_group_rec = container_of(block_group_item,
7884 struct block_group_record,
7885 cache);
7886 if (chunk_rec->length != block_group_rec->offset ||
7887 chunk_rec->offset != block_group_rec->objectid ||
7888 (!metadump_v2 &&
7889 chunk_rec->type_flags != block_group_rec->flags)) {
7890 if (!silent)
7891 fprintf(stderr,
7892 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
7893 chunk_rec->objectid,
7894 chunk_rec->type,
7895 chunk_rec->offset,
7896 chunk_rec->length,
7897 chunk_rec->offset,
7898 chunk_rec->type_flags,
7899 block_group_rec->objectid,
7900 block_group_rec->type,
7901 block_group_rec->offset,
7902 block_group_rec->offset,
7903 block_group_rec->objectid,
7904 block_group_rec->flags);
7905 ret = -1;
7906 } else {
7907 list_del_init(&block_group_rec->list);
7908 chunk_rec->bg_rec = block_group_rec;
7909 }
7910 } else {
7911 if (!silent)
7912 fprintf(stderr,
7913 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
7914 chunk_rec->objectid,
7915 chunk_rec->type,
7916 chunk_rec->offset,
7917 chunk_rec->length,
7918 chunk_rec->offset,
7919 chunk_rec->type_flags);
7920 ret = 1;
7921 }
7922
7923 if (metadump_v2)
7924 return ret;
7925
7926 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
7927 chunk_rec->num_stripes);
7928 for (i = 0; i < chunk_rec->num_stripes; ++i) {
7929 devid = chunk_rec->stripes[i].devid;
7930 offset = chunk_rec->stripes[i].offset;
7931 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
7932 devid, offset, length);
7933 if (dev_extent_item) {
7934 dev_extent_rec = container_of(dev_extent_item,
7935 struct device_extent_record,
7936 cache);
7937 if (dev_extent_rec->objectid != devid ||
7938 dev_extent_rec->offset != offset ||
7939 dev_extent_rec->chunk_offset != chunk_rec->offset ||
7940 dev_extent_rec->length != length) {
7941 if (!silent)
7942 fprintf(stderr,
7943 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
7944 chunk_rec->objectid,
7945 chunk_rec->type,
7946 chunk_rec->offset,
7947 chunk_rec->stripes[i].devid,
7948 chunk_rec->stripes[i].offset,
7949 dev_extent_rec->objectid,
7950 dev_extent_rec->offset,
7951 dev_extent_rec->length);
7952 ret = -1;
7953 } else {
7954 list_move(&dev_extent_rec->chunk_list,
7955 &chunk_rec->dextents);
7956 }
7957 } else {
7958 if (!silent)
7959 fprintf(stderr,
7960 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
7961 chunk_rec->objectid,
7962 chunk_rec->type,
7963 chunk_rec->offset,
7964 chunk_rec->stripes[i].devid,
7965 chunk_rec->stripes[i].offset);
7966 ret = -1;
7967 }
7968 }
7969 return ret;
7970 }
7971
7972 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
7973 int check_chunks(struct cache_tree *chunk_cache,
7974 struct block_group_tree *block_group_cache,
7975 struct device_extent_tree *dev_extent_cache,
7976 struct list_head *good, struct list_head *bad,
7977 struct list_head *rebuild, int silent)
7978 {
7979 struct cache_extent *chunk_item;
7980 struct chunk_record *chunk_rec;
7981 struct block_group_record *bg_rec;
7982 struct device_extent_record *dext_rec;
7983 int err;
7984 int ret = 0;
7985
7986 chunk_item = first_cache_extent(chunk_cache);
7987 while (chunk_item) {
7988 chunk_rec = container_of(chunk_item, struct chunk_record,
7989 cache);
7990 err = check_chunk_refs(chunk_rec, block_group_cache,
7991 dev_extent_cache, silent);
7992 if (err < 0)
7993 ret = err;
7994 if (err == 0 && good)
7995 list_add_tail(&chunk_rec->list, good);
7996 if (err > 0 && rebuild)
7997 list_add_tail(&chunk_rec->list, rebuild);
7998 if (err < 0 && bad)
7999 list_add_tail(&chunk_rec->list, bad);
8000 chunk_item = next_cache_extent(chunk_item);
8001 }
8002
8003 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
8004 if (!silent)
8005 fprintf(stderr,
8006 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
8007 bg_rec->objectid,
8008 bg_rec->offset,
8009 bg_rec->flags);
8010 if (!ret)
8011 ret = 1;
8012 }
8013
8014 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
8015 chunk_list) {
8016 if (!silent)
8017 fprintf(stderr,
8018 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
8019 dext_rec->objectid,
8020 dext_rec->offset,
8021 dext_rec->length);
8022 if (!ret)
8023 ret = 1;
8024 }
8025 return ret;
8026 }
8027
8028
8029 static int check_device_used(struct device_record *dev_rec,
8030 struct device_extent_tree *dext_cache)
8031 {
8032 struct cache_extent *cache;
8033 struct device_extent_record *dev_extent_rec;
8034 u64 total_byte = 0;
8035
8036 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
8037 while (cache) {
8038 dev_extent_rec = container_of(cache,
8039 struct device_extent_record,
8040 cache);
8041 if (dev_extent_rec->objectid != dev_rec->devid)
8042 break;
8043
8044 list_del_init(&dev_extent_rec->device_list);
8045 total_byte += dev_extent_rec->length;
8046 cache = next_cache_extent(cache);
8047 }
8048
8049 if (total_byte != dev_rec->byte_used) {
8050 fprintf(stderr,
8051 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
8052 total_byte, dev_rec->byte_used, dev_rec->objectid,
8053 dev_rec->type, dev_rec->offset);
8054 return -1;
8055 } else {
8056 return 0;
8057 }
8058 }
8059
8060 /* check btrfs_dev_item -> btrfs_dev_extent */
8061 static int check_devices(struct rb_root *dev_cache,
8062 struct device_extent_tree *dev_extent_cache)
8063 {
8064 struct rb_node *dev_node;
8065 struct device_record *dev_rec;
8066 struct device_extent_record *dext_rec;
8067 int err;
8068 int ret = 0;
8069
8070 dev_node = rb_first(dev_cache);
8071 while (dev_node) {
8072 dev_rec = container_of(dev_node, struct device_record, node);
8073 err = check_device_used(dev_rec, dev_extent_cache);
8074 if (err)
8075 ret = err;
8076
8077 dev_node = rb_next(dev_node);
8078 }
8079 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
8080 device_list) {
8081 fprintf(stderr,
8082 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
8083 dext_rec->objectid, dext_rec->offset, dext_rec->length);
8084 if (!ret)
8085 ret = 1;
8086 }
8087 return ret;
8088 }
8089
8090 static int add_root_item_to_list(struct list_head *head,
8091 u64 objectid, u64 bytenr, u64 last_snapshot,
8092 u8 level, u8 drop_level,
8093 int level_size, struct btrfs_key *drop_key)
8094 {
8095
8096 struct root_item_record *ri_rec;
8097 ri_rec = malloc(sizeof(*ri_rec));
8098 if (!ri_rec)
8099 return -ENOMEM;
8100 ri_rec->bytenr = bytenr;
8101 ri_rec->objectid = objectid;
8102 ri_rec->level = level;
8103 ri_rec->level_size = level_size;
8104 ri_rec->drop_level = drop_level;
8105 ri_rec->last_snapshot = last_snapshot;
8106 if (drop_key)
8107 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
8108 list_add_tail(&ri_rec->list, head);
8109
8110 return 0;
8111 }
8112
8113 static void free_root_item_list(struct list_head *list)
8114 {
8115 struct root_item_record *ri_rec;
8116
8117 while (!list_empty(list)) {
8118 ri_rec = list_first_entry(list, struct root_item_record,
8119 list);
8120 list_del_init(&ri_rec->list);
8121 free(ri_rec);
8122 }
8123 }
8124
8125 static int deal_root_from_list(struct list_head *list,
8126 struct btrfs_root *root,
8127 struct block_info *bits,
8128 int bits_nr,
8129 struct cache_tree *pending,
8130 struct cache_tree *seen,
8131 struct cache_tree *reada,
8132 struct cache_tree *nodes,
8133 struct cache_tree *extent_cache,
8134 struct cache_tree *chunk_cache,
8135 struct rb_root *dev_cache,
8136 struct block_group_tree *block_group_cache,
8137 struct device_extent_tree *dev_extent_cache)
8138 {
8139 int ret = 0;
8140 u64 last;
8141
8142 while (!list_empty(list)) {
8143 struct root_item_record *rec;
8144 struct extent_buffer *buf;
8145 rec = list_entry(list->next,
8146 struct root_item_record, list);
8147 last = 0;
8148 buf = read_tree_block(root->fs_info->tree_root,
8149 rec->bytenr, rec->level_size, 0);
8150 if (!extent_buffer_uptodate(buf)) {
8151 free_extent_buffer(buf);
8152 ret = -EIO;
8153 break;
8154 }
8155 add_root_to_pending(buf, extent_cache, pending,
8156 seen, nodes, rec->objectid);
8157 /*
8158 * To rebuild extent tree, we need deal with snapshot
8159 * one by one, otherwise we deal with node firstly which
8160 * can maximize readahead.
8161 */
8162 while (1) {
8163 ret = run_next_block(root, bits, bits_nr, &last,
8164 pending, seen, reada, nodes,
8165 extent_cache, chunk_cache,
8166 dev_cache, block_group_cache,
8167 dev_extent_cache, rec);
8168 if (ret != 0)
8169 break;
8170 }
8171 free_extent_buffer(buf);
8172 list_del(&rec->list);
8173 free(rec);
8174 if (ret < 0)
8175 break;
8176 }
8177 while (ret >= 0) {
8178 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
8179 reada, nodes, extent_cache, chunk_cache,
8180 dev_cache, block_group_cache,
8181 dev_extent_cache, NULL);
8182 if (ret != 0) {
8183 if (ret > 0)
8184 ret = 0;
8185 break;
8186 }
8187 }
8188 return ret;
8189 }
8190
8191 static int check_chunks_and_extents(struct btrfs_root *root)
8192 {
8193 struct rb_root dev_cache;
8194 struct cache_tree chunk_cache;
8195 struct block_group_tree block_group_cache;
8196 struct device_extent_tree dev_extent_cache;
8197 struct cache_tree extent_cache;
8198 struct cache_tree seen;
8199 struct cache_tree pending;
8200 struct cache_tree reada;
8201 struct cache_tree nodes;
8202 struct extent_io_tree excluded_extents;
8203 struct cache_tree corrupt_blocks;
8204 struct btrfs_path path;
8205 struct btrfs_key key;
8206 struct btrfs_key found_key;
8207 int ret, err = 0;
8208 struct block_info *bits;
8209 int bits_nr;
8210 struct extent_buffer *leaf;
8211 int slot;
8212 struct btrfs_root_item ri;
8213 struct list_head dropping_trees;
8214 struct list_head normal_trees;
8215 struct btrfs_root *root1;
8216 u64 objectid;
8217 u32 level_size;
8218 u8 level;
8219
8220 dev_cache = RB_ROOT;
8221 cache_tree_init(&chunk_cache);
8222 block_group_tree_init(&block_group_cache);
8223 device_extent_tree_init(&dev_extent_cache);
8224
8225 cache_tree_init(&extent_cache);
8226 cache_tree_init(&seen);
8227 cache_tree_init(&pending);
8228 cache_tree_init(&nodes);
8229 cache_tree_init(&reada);
8230 cache_tree_init(&corrupt_blocks);
8231 extent_io_tree_init(&excluded_extents);
8232 INIT_LIST_HEAD(&dropping_trees);
8233 INIT_LIST_HEAD(&normal_trees);
8234
8235 if (repair) {
8236 root->fs_info->excluded_extents = &excluded_extents;
8237 root->fs_info->fsck_extent_cache = &extent_cache;
8238 root->fs_info->free_extent_hook = free_extent_hook;
8239 root->fs_info->corrupt_blocks = &corrupt_blocks;
8240 }
8241
8242 bits_nr = 1024;
8243 bits = malloc(bits_nr * sizeof(struct block_info));
8244 if (!bits) {
8245 perror("malloc");
8246 exit(1);
8247 }
8248
8249 if (ctx.progress_enabled) {
8250 ctx.tp = TASK_EXTENTS;
8251 task_start(ctx.info);
8252 }
8253
8254 again:
8255 root1 = root->fs_info->tree_root;
8256 level = btrfs_header_level(root1->node);
8257 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
8258 root1->node->start, 0, level, 0,
8259 root1->nodesize, NULL);
8260 if (ret < 0)
8261 goto out;
8262 root1 = root->fs_info->chunk_root;
8263 level = btrfs_header_level(root1->node);
8264 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
8265 root1->node->start, 0, level, 0,
8266 root1->nodesize, NULL);
8267 if (ret < 0)
8268 goto out;
8269 btrfs_init_path(&path);
8270 key.offset = 0;
8271 key.objectid = 0;
8272 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
8273 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
8274 &key, &path, 0, 0);
8275 if (ret < 0)
8276 goto out;
8277 while(1) {
8278 leaf = path.nodes[0];
8279 slot = path.slots[0];
8280 if (slot >= btrfs_header_nritems(path.nodes[0])) {
8281 ret = btrfs_next_leaf(root, &path);
8282 if (ret != 0)
8283 break;
8284 leaf = path.nodes[0];
8285 slot = path.slots[0];
8286 }
8287 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
8288 if (btrfs_key_type(&found_key) == BTRFS_ROOT_ITEM_KEY) {
8289 unsigned long offset;
8290 u64 last_snapshot;
8291
8292 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
8293 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
8294 last_snapshot = btrfs_root_last_snapshot(&ri);
8295 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
8296 level = btrfs_root_level(&ri);
8297 level_size = root->nodesize;
8298 ret = add_root_item_to_list(&normal_trees,
8299 found_key.objectid,
8300 btrfs_root_bytenr(&ri),
8301 last_snapshot, level,
8302 0, level_size, NULL);
8303 if (ret < 0)
8304 goto out;
8305 } else {
8306 level = btrfs_root_level(&ri);
8307 level_size = root->nodesize;
8308 objectid = found_key.objectid;
8309 btrfs_disk_key_to_cpu(&found_key,
8310 &ri.drop_progress);
8311 ret = add_root_item_to_list(&dropping_trees,
8312 objectid,
8313 btrfs_root_bytenr(&ri),
8314 last_snapshot, level,
8315 ri.drop_level,
8316 level_size, &found_key);
8317 if (ret < 0)
8318 goto out;
8319 }
8320 }
8321 path.slots[0]++;
8322 }
8323 btrfs_release_path(&path);
8324
8325 /*
8326 * check_block can return -EAGAIN if it fixes something, please keep
8327 * this in mind when dealing with return values from these functions, if
8328 * we get -EAGAIN we want to fall through and restart the loop.
8329 */
8330 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
8331 &seen, &reada, &nodes, &extent_cache,
8332 &chunk_cache, &dev_cache, &block_group_cache,
8333 &dev_extent_cache);
8334 if (ret < 0) {
8335 if (ret == -EAGAIN)
8336 goto loop;
8337 goto out;
8338 }
8339 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
8340 &pending, &seen, &reada, &nodes,
8341 &extent_cache, &chunk_cache, &dev_cache,
8342 &block_group_cache, &dev_extent_cache);
8343 if (ret < 0) {
8344 if (ret == -EAGAIN)
8345 goto loop;
8346 goto out;
8347 }
8348
8349 ret = check_chunks(&chunk_cache, &block_group_cache,
8350 &dev_extent_cache, NULL, NULL, NULL, 0);
8351 if (ret) {
8352 if (ret == -EAGAIN)
8353 goto loop;
8354 err = ret;
8355 }
8356
8357 ret = check_extent_refs(root, &extent_cache);
8358 if (ret < 0) {
8359 if (ret == -EAGAIN)
8360 goto loop;
8361 goto out;
8362 }
8363
8364 ret = check_devices(&dev_cache, &dev_extent_cache);
8365 if (ret && err)
8366 ret = err;
8367
8368 out:
8369 task_stop(ctx.info);
8370 if (repair) {
8371 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
8372 extent_io_tree_cleanup(&excluded_extents);
8373 root->fs_info->fsck_extent_cache = NULL;
8374 root->fs_info->free_extent_hook = NULL;
8375 root->fs_info->corrupt_blocks = NULL;
8376 root->fs_info->excluded_extents = NULL;
8377 }
8378 free(bits);
8379 free_chunk_cache_tree(&chunk_cache);
8380 free_device_cache_tree(&dev_cache);
8381 free_block_group_tree(&block_group_cache);
8382 free_device_extent_tree(&dev_extent_cache);
8383 free_extent_cache_tree(&seen);
8384 free_extent_cache_tree(&pending);
8385 free_extent_cache_tree(&reada);
8386 free_extent_cache_tree(&nodes);
8387 return ret;
8388 loop:
8389 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
8390 free_extent_cache_tree(&seen);
8391 free_extent_cache_tree(&pending);
8392 free_extent_cache_tree(&reada);
8393 free_extent_cache_tree(&nodes);
8394 free_chunk_cache_tree(&chunk_cache);
8395 free_block_group_tree(&block_group_cache);
8396 free_device_cache_tree(&dev_cache);
8397 free_device_extent_tree(&dev_extent_cache);
8398 free_extent_record_cache(root->fs_info, &extent_cache);
8399 free_root_item_list(&normal_trees);
8400 free_root_item_list(&dropping_trees);
8401 extent_io_tree_cleanup(&excluded_extents);
8402 goto again;
8403 }
8404
8405 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
8406 struct btrfs_root *root, int overwrite)
8407 {
8408 struct extent_buffer *c;
8409 struct extent_buffer *old = root->node;
8410 int level;
8411 int ret;
8412 struct btrfs_disk_key disk_key = {0,0,0};
8413
8414 level = 0;
8415
8416 if (overwrite) {
8417 c = old;
8418 extent_buffer_get(c);
8419 goto init;
8420 }
8421 c = btrfs_alloc_free_block(trans, root,
8422 root->nodesize,
8423 root->root_key.objectid,
8424 &disk_key, level, 0, 0);
8425 if (IS_ERR(c)) {
8426 c = old;
8427 extent_buffer_get(c);
8428 overwrite = 1;
8429 }
8430 init:
8431 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
8432 btrfs_set_header_level(c, level);
8433 btrfs_set_header_bytenr(c, c->start);
8434 btrfs_set_header_generation(c, trans->transid);
8435 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
8436 btrfs_set_header_owner(c, root->root_key.objectid);
8437
8438 write_extent_buffer(c, root->fs_info->fsid,
8439 btrfs_header_fsid(), BTRFS_FSID_SIZE);
8440
8441 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
8442 btrfs_header_chunk_tree_uuid(c),
8443 BTRFS_UUID_SIZE);
8444
8445 btrfs_mark_buffer_dirty(c);
8446 /*
8447 * this case can happen in the following case:
8448 *
8449 * 1.overwrite previous root.
8450 *
8451 * 2.reinit reloc data root, this is because we skip pin
8452 * down reloc data tree before which means we can allocate
8453 * same block bytenr here.
8454 */
8455 if (old->start == c->start) {
8456 btrfs_set_root_generation(&root->root_item,
8457 trans->transid);
8458 root->root_item.level = btrfs_header_level(root->node);
8459 ret = btrfs_update_root(trans, root->fs_info->tree_root,
8460 &root->root_key, &root->root_item);
8461 if (ret) {
8462 free_extent_buffer(c);
8463 return ret;
8464 }
8465 }
8466 free_extent_buffer(old);
8467 root->node = c;
8468 add_root_to_dirty_list(root);
8469 return 0;
8470 }
8471
8472 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
8473 struct extent_buffer *eb, int tree_root)
8474 {
8475 struct extent_buffer *tmp;
8476 struct btrfs_root_item *ri;
8477 struct btrfs_key key;
8478 u64 bytenr;
8479 u32 nodesize;
8480 int level = btrfs_header_level(eb);
8481 int nritems;
8482 int ret;
8483 int i;
8484
8485 /*
8486 * If we have pinned this block before, don't pin it again.
8487 * This can not only avoid forever loop with broken filesystem
8488 * but also give us some speedups.
8489 */
8490 if (test_range_bit(&fs_info->pinned_extents, eb->start,
8491 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
8492 return 0;
8493
8494 btrfs_pin_extent(fs_info, eb->start, eb->len);
8495
8496 nodesize = btrfs_super_nodesize(fs_info->super_copy);
8497 nritems = btrfs_header_nritems(eb);
8498 for (i = 0; i < nritems; i++) {
8499 if (level == 0) {
8500 btrfs_item_key_to_cpu(eb, &key, i);
8501 if (key.type != BTRFS_ROOT_ITEM_KEY)
8502 continue;
8503 /* Skip the extent root and reloc roots */
8504 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
8505 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
8506 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
8507 continue;
8508 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
8509 bytenr = btrfs_disk_root_bytenr(eb, ri);
8510
8511 /*
8512 * If at any point we start needing the real root we
8513 * will have to build a stump root for the root we are
8514 * in, but for now this doesn't actually use the root so
8515 * just pass in extent_root.
8516 */
8517 tmp = read_tree_block(fs_info->extent_root, bytenr,
8518 nodesize, 0);
8519 if (!extent_buffer_uptodate(tmp)) {
8520 fprintf(stderr, "Error reading root block\n");
8521 return -EIO;
8522 }
8523 ret = pin_down_tree_blocks(fs_info, tmp, 0);
8524 free_extent_buffer(tmp);
8525 if (ret)
8526 return ret;
8527 } else {
8528 bytenr = btrfs_node_blockptr(eb, i);
8529
8530 /* If we aren't the tree root don't read the block */
8531 if (level == 1 && !tree_root) {
8532 btrfs_pin_extent(fs_info, bytenr, nodesize);
8533 continue;
8534 }
8535
8536 tmp = read_tree_block(fs_info->extent_root, bytenr,
8537 nodesize, 0);
8538 if (!extent_buffer_uptodate(tmp)) {
8539 fprintf(stderr, "Error reading tree block\n");
8540 return -EIO;
8541 }
8542 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
8543 free_extent_buffer(tmp);
8544 if (ret)
8545 return ret;
8546 }
8547 }
8548
8549 return 0;
8550 }
8551
8552 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
8553 {
8554 int ret;
8555
8556 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
8557 if (ret)
8558 return ret;
8559
8560 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
8561 }
8562
8563 static int reset_block_groups(struct btrfs_fs_info *fs_info)
8564 {
8565 struct btrfs_block_group_cache *cache;
8566 struct btrfs_path *path;
8567 struct extent_buffer *leaf;
8568 struct btrfs_chunk *chunk;
8569 struct btrfs_key key;
8570 int ret;
8571 u64 start;
8572
8573 path = btrfs_alloc_path();
8574 if (!path)
8575 return -ENOMEM;
8576
8577 key.objectid = 0;
8578 key.type = BTRFS_CHUNK_ITEM_KEY;
8579 key.offset = 0;
8580
8581 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
8582 if (ret < 0) {
8583 btrfs_free_path(path);
8584 return ret;
8585 }
8586
8587 /*
8588 * We do this in case the block groups were screwed up and had alloc
8589 * bits that aren't actually set on the chunks. This happens with
8590 * restored images every time and could happen in real life I guess.
8591 */
8592 fs_info->avail_data_alloc_bits = 0;
8593 fs_info->avail_metadata_alloc_bits = 0;
8594 fs_info->avail_system_alloc_bits = 0;
8595
8596 /* First we need to create the in-memory block groups */
8597 while (1) {
8598 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8599 ret = btrfs_next_leaf(fs_info->chunk_root, path);
8600 if (ret < 0) {
8601 btrfs_free_path(path);
8602 return ret;
8603 }
8604 if (ret) {
8605 ret = 0;
8606 break;
8607 }
8608 }
8609 leaf = path->nodes[0];
8610 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8611 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
8612 path->slots[0]++;
8613 continue;
8614 }
8615
8616 chunk = btrfs_item_ptr(leaf, path->slots[0],
8617 struct btrfs_chunk);
8618 btrfs_add_block_group(fs_info, 0,
8619 btrfs_chunk_type(leaf, chunk),
8620 key.objectid, key.offset,
8621 btrfs_chunk_length(leaf, chunk));
8622 set_extent_dirty(&fs_info->free_space_cache, key.offset,
8623 key.offset + btrfs_chunk_length(leaf, chunk),
8624 GFP_NOFS);
8625 path->slots[0]++;
8626 }
8627 start = 0;
8628 while (1) {
8629 cache = btrfs_lookup_first_block_group(fs_info, start);
8630 if (!cache)
8631 break;
8632 cache->cached = 1;
8633 start = cache->key.objectid + cache->key.offset;
8634 }
8635
8636 btrfs_free_path(path);
8637 return 0;
8638 }
8639
8640 static int reset_balance(struct btrfs_trans_handle *trans,
8641 struct btrfs_fs_info *fs_info)
8642 {
8643 struct btrfs_root *root = fs_info->tree_root;
8644 struct btrfs_path *path;
8645 struct extent_buffer *leaf;
8646 struct btrfs_key key;
8647 int del_slot, del_nr = 0;
8648 int ret;
8649 int found = 0;
8650
8651 path = btrfs_alloc_path();
8652 if (!path)
8653 return -ENOMEM;
8654
8655 key.objectid = BTRFS_BALANCE_OBJECTID;
8656 key.type = BTRFS_BALANCE_ITEM_KEY;
8657 key.offset = 0;
8658
8659 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8660 if (ret) {
8661 if (ret > 0)
8662 ret = 0;
8663 if (!ret)
8664 goto reinit_data_reloc;
8665 else
8666 goto out;
8667 }
8668
8669 ret = btrfs_del_item(trans, root, path);
8670 if (ret)
8671 goto out;
8672 btrfs_release_path(path);
8673
8674 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
8675 key.type = BTRFS_ROOT_ITEM_KEY;
8676 key.offset = 0;
8677
8678 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8679 if (ret < 0)
8680 goto out;
8681 while (1) {
8682 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8683 if (!found)
8684 break;
8685
8686 if (del_nr) {
8687 ret = btrfs_del_items(trans, root, path,
8688 del_slot, del_nr);
8689 del_nr = 0;
8690 if (ret)
8691 goto out;
8692 }
8693 key.offset++;
8694 btrfs_release_path(path);
8695
8696 found = 0;
8697 ret = btrfs_search_slot(trans, root, &key, path,
8698 -1, 1);
8699 if (ret < 0)
8700 goto out;
8701 continue;
8702 }
8703 found = 1;
8704 leaf = path->nodes[0];
8705 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8706 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
8707 break;
8708 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
8709 path->slots[0]++;
8710 continue;
8711 }
8712 if (!del_nr) {
8713 del_slot = path->slots[0];
8714 del_nr = 1;
8715 } else {
8716 del_nr++;
8717 }
8718 path->slots[0]++;
8719 }
8720
8721 if (del_nr) {
8722 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
8723 if (ret)
8724 goto out;
8725 }
8726 btrfs_release_path(path);
8727
8728 reinit_data_reloc:
8729 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
8730 key.type = BTRFS_ROOT_ITEM_KEY;
8731 key.offset = (u64)-1;
8732 root = btrfs_read_fs_root(fs_info, &key);
8733 if (IS_ERR(root)) {
8734 fprintf(stderr, "Error reading data reloc tree\n");
8735 ret = PTR_ERR(root);
8736 goto out;
8737 }
8738 record_root_in_trans(trans, root);
8739 ret = btrfs_fsck_reinit_root(trans, root, 0);
8740 if (ret)
8741 goto out;
8742 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
8743 out:
8744 btrfs_free_path(path);
8745 return ret;
8746 }
8747
8748 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
8749 struct btrfs_fs_info *fs_info)
8750 {
8751 u64 start = 0;
8752 int ret;
8753
8754 /*
8755 * The only reason we don't do this is because right now we're just
8756 * walking the trees we find and pinning down their bytes, we don't look
8757 * at any of the leaves. In order to do mixed groups we'd have to check
8758 * the leaves of any fs roots and pin down the bytes for any file
8759 * extents we find. Not hard but why do it if we don't have to?
8760 */
8761 if (btrfs_fs_incompat(fs_info, BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)) {
8762 fprintf(stderr, "We don't support re-initing the extent tree "
8763 "for mixed block groups yet, please notify a btrfs "
8764 "developer you want to do this so they can add this "
8765 "functionality.\n");
8766 return -EINVAL;
8767 }
8768
8769 /*
8770 * first we need to walk all of the trees except the extent tree and pin
8771 * down the bytes that are in use so we don't overwrite any existing
8772 * metadata.
8773 */
8774 ret = pin_metadata_blocks(fs_info);
8775 if (ret) {
8776 fprintf(stderr, "error pinning down used bytes\n");
8777 return ret;
8778 }
8779
8780 /*
8781 * Need to drop all the block groups since we're going to recreate all
8782 * of them again.
8783 */
8784 btrfs_free_block_groups(fs_info);
8785 ret = reset_block_groups(fs_info);
8786 if (ret) {
8787 fprintf(stderr, "error resetting the block groups\n");
8788 return ret;
8789 }
8790
8791 /* Ok we can allocate now, reinit the extent root */
8792 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
8793 if (ret) {
8794 fprintf(stderr, "extent root initialization failed\n");
8795 /*
8796 * When the transaction code is updated we should end the
8797 * transaction, but for now progs only knows about commit so
8798 * just return an error.
8799 */
8800 return ret;
8801 }
8802
8803 /*
8804 * Now we have all the in-memory block groups setup so we can make
8805 * allocations properly, and the metadata we care about is safe since we
8806 * pinned all of it above.
8807 */
8808 while (1) {
8809 struct btrfs_block_group_cache *cache;
8810
8811 cache = btrfs_lookup_first_block_group(fs_info, start);
8812 if (!cache)
8813 break;
8814 start = cache->key.objectid + cache->key.offset;
8815 ret = btrfs_insert_item(trans, fs_info->extent_root,
8816 &cache->key, &cache->item,
8817 sizeof(cache->item));
8818 if (ret) {
8819 fprintf(stderr, "Error adding block group\n");
8820 return ret;
8821 }
8822 btrfs_extent_post_op(trans, fs_info->extent_root);
8823 }
8824
8825 ret = reset_balance(trans, fs_info);
8826 if (ret)
8827 fprintf(stderr, "error resetting the pending balance\n");
8828
8829 return ret;
8830 }
8831
8832 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
8833 {
8834 struct btrfs_path *path;
8835 struct btrfs_trans_handle *trans;
8836 struct btrfs_key key;
8837 int ret;
8838
8839 printf("Recowing metadata block %llu\n", eb->start);
8840 key.objectid = btrfs_header_owner(eb);
8841 key.type = BTRFS_ROOT_ITEM_KEY;
8842 key.offset = (u64)-1;
8843
8844 root = btrfs_read_fs_root(root->fs_info, &key);
8845 if (IS_ERR(root)) {
8846 fprintf(stderr, "Couldn't find owner root %llu\n",
8847 key.objectid);
8848 return PTR_ERR(root);
8849 }
8850
8851 path = btrfs_alloc_path();
8852 if (!path)
8853 return -ENOMEM;
8854
8855 trans = btrfs_start_transaction(root, 1);
8856 if (IS_ERR(trans)) {
8857 btrfs_free_path(path);
8858 return PTR_ERR(trans);
8859 }
8860
8861 path->lowest_level = btrfs_header_level(eb);
8862 if (path->lowest_level)
8863 btrfs_node_key_to_cpu(eb, &key, 0);
8864 else
8865 btrfs_item_key_to_cpu(eb, &key, 0);
8866
8867 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8868 btrfs_commit_transaction(trans, root);
8869 btrfs_free_path(path);
8870 return ret;
8871 }
8872
8873 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
8874 {
8875 struct btrfs_path *path;
8876 struct btrfs_trans_handle *trans;
8877 struct btrfs_key key;
8878 int ret;
8879
8880 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
8881 bad->key.type, bad->key.offset);
8882 key.objectid = bad->root_id;
8883 key.type = BTRFS_ROOT_ITEM_KEY;
8884 key.offset = (u64)-1;
8885
8886 root = btrfs_read_fs_root(root->fs_info, &key);
8887 if (IS_ERR(root)) {
8888 fprintf(stderr, "Couldn't find owner root %llu\n",
8889 key.objectid);
8890 return PTR_ERR(root);
8891 }
8892
8893 path = btrfs_alloc_path();
8894 if (!path)
8895 return -ENOMEM;
8896
8897 trans = btrfs_start_transaction(root, 1);
8898 if (IS_ERR(trans)) {
8899 btrfs_free_path(path);
8900 return PTR_ERR(trans);
8901 }
8902
8903 ret = btrfs_search_slot(trans, root, &bad->key, path, -1, 1);
8904 if (ret) {
8905 if (ret > 0)
8906 ret = 0;
8907 goto out;
8908 }
8909 ret = btrfs_del_item(trans, root, path);
8910 out:
8911 btrfs_commit_transaction(trans, root);
8912 btrfs_free_path(path);
8913 return ret;
8914 }
8915
8916 static int zero_log_tree(struct btrfs_root *root)
8917 {
8918 struct btrfs_trans_handle *trans;
8919 int ret;
8920
8921 trans = btrfs_start_transaction(root, 1);
8922 if (IS_ERR(trans)) {
8923 ret = PTR_ERR(trans);
8924 return ret;
8925 }
8926 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
8927 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
8928 ret = btrfs_commit_transaction(trans, root);
8929 return ret;
8930 }
8931
8932 static int populate_csum(struct btrfs_trans_handle *trans,
8933 struct btrfs_root *csum_root, char *buf, u64 start,
8934 u64 len)
8935 {
8936 u64 offset = 0;
8937 u64 sectorsize;
8938 int ret = 0;
8939
8940 while (offset < len) {
8941 sectorsize = csum_root->sectorsize;
8942 ret = read_extent_data(csum_root, buf, start + offset,
8943 &sectorsize, 0);
8944 if (ret)
8945 break;
8946 ret = btrfs_csum_file_block(trans, csum_root, start + len,
8947 start + offset, buf, sectorsize);
8948 if (ret)
8949 break;
8950 offset += sectorsize;
8951 }
8952 return ret;
8953 }
8954
8955 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
8956 struct btrfs_root *csum_root,
8957 struct btrfs_root *cur_root)
8958 {
8959 struct btrfs_path *path;
8960 struct btrfs_key key;
8961 struct extent_buffer *node;
8962 struct btrfs_file_extent_item *fi;
8963 char *buf = NULL;
8964 u64 start = 0;
8965 u64 len = 0;
8966 int slot = 0;
8967 int ret = 0;
8968
8969 path = btrfs_alloc_path();
8970 if (!path)
8971 return -ENOMEM;
8972 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
8973 if (!buf) {
8974 ret = -ENOMEM;
8975 goto out;
8976 }
8977
8978 key.objectid = 0;
8979 key.offset = 0;
8980 key.type = 0;
8981
8982 ret = btrfs_search_slot(NULL, cur_root, &key, path, 0, 0);
8983 if (ret < 0)
8984 goto out;
8985 /* Iterate all regular file extents and fill its csum */
8986 while (1) {
8987 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
8988
8989 if (key.type != BTRFS_EXTENT_DATA_KEY)
8990 goto next;
8991 node = path->nodes[0];
8992 slot = path->slots[0];
8993 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
8994 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
8995 goto next;
8996 start = btrfs_file_extent_disk_bytenr(node, fi);
8997 len = btrfs_file_extent_disk_num_bytes(node, fi);
8998
8999 ret = populate_csum(trans, csum_root, buf, start, len);
9000 if (ret == -EEXIST)
9001 ret = 0;
9002 if (ret < 0)
9003 goto out;
9004 next:
9005 /*
9006 * TODO: if next leaf is corrupted, jump to nearest next valid
9007 * leaf.
9008 */
9009 ret = btrfs_next_item(cur_root, path);
9010 if (ret < 0)
9011 goto out;
9012 if (ret > 0) {
9013 ret = 0;
9014 goto out;
9015 }
9016 }
9017
9018 out:
9019 btrfs_free_path(path);
9020 free(buf);
9021 return ret;
9022 }
9023
9024 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
9025 struct btrfs_root *csum_root)
9026 {
9027 struct btrfs_fs_info *fs_info = csum_root->fs_info;
9028 struct btrfs_path *path;
9029 struct btrfs_root *tree_root = fs_info->tree_root;
9030 struct btrfs_root *cur_root;
9031 struct extent_buffer *node;
9032 struct btrfs_key key;
9033 int slot = 0;
9034 int ret = 0;
9035
9036 path = btrfs_alloc_path();
9037 if (!path)
9038 return -ENOMEM;
9039
9040 key.objectid = BTRFS_FS_TREE_OBJECTID;
9041 key.offset = 0;
9042 key.type = BTRFS_ROOT_ITEM_KEY;
9043
9044 ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
9045 if (ret < 0)
9046 goto out;
9047 if (ret > 0) {
9048 ret = -ENOENT;
9049 goto out;
9050 }
9051
9052 while (1) {
9053 node = path->nodes[0];
9054 slot = path->slots[0];
9055 btrfs_item_key_to_cpu(node, &key, slot);
9056 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
9057 goto out;
9058 if (key.type != BTRFS_ROOT_ITEM_KEY)
9059 goto next;
9060 if (!is_fstree(key.objectid))
9061 goto next;
9062 key.offset = (u64)-1;
9063
9064 cur_root = btrfs_read_fs_root(fs_info, &key);
9065 if (IS_ERR(cur_root) || !cur_root) {
9066 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
9067 key.objectid);
9068 goto out;
9069 }
9070 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
9071 cur_root);
9072 if (ret < 0)
9073 goto out;
9074 next:
9075 ret = btrfs_next_item(tree_root, path);
9076 if (ret > 0) {
9077 ret = 0;
9078 goto out;
9079 }
9080 if (ret < 0)
9081 goto out;
9082 }
9083
9084 out:
9085 btrfs_free_path(path);
9086 return ret;
9087 }
9088
9089 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
9090 struct btrfs_root *csum_root)
9091 {
9092 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
9093 struct btrfs_path *path;
9094 struct btrfs_extent_item *ei;
9095 struct extent_buffer *leaf;
9096 char *buf;
9097 struct btrfs_key key;
9098 int ret;
9099
9100 path = btrfs_alloc_path();
9101 if (!path)
9102 return -ENOMEM;
9103
9104 key.objectid = 0;
9105 key.type = BTRFS_EXTENT_ITEM_KEY;
9106 key.offset = 0;
9107
9108 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
9109 if (ret < 0) {
9110 btrfs_free_path(path);
9111 return ret;
9112 }
9113
9114 buf = malloc(csum_root->sectorsize);
9115 if (!buf) {
9116 btrfs_free_path(path);
9117 return -ENOMEM;
9118 }
9119
9120 while (1) {
9121 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
9122 ret = btrfs_next_leaf(extent_root, path);
9123 if (ret < 0)
9124 break;
9125 if (ret) {
9126 ret = 0;
9127 break;
9128 }
9129 }
9130 leaf = path->nodes[0];
9131
9132 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
9133 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
9134 path->slots[0]++;
9135 continue;
9136 }
9137
9138 ei = btrfs_item_ptr(leaf, path->slots[0],
9139 struct btrfs_extent_item);
9140 if (!(btrfs_extent_flags(leaf, ei) &
9141 BTRFS_EXTENT_FLAG_DATA)) {
9142 path->slots[0]++;
9143 continue;
9144 }
9145
9146 ret = populate_csum(trans, csum_root, buf, key.objectid,
9147 key.offset);
9148 if (ret)
9149 break;
9150 path->slots[0]++;
9151 }
9152
9153 btrfs_free_path(path);
9154 free(buf);
9155 return ret;
9156 }
9157
9158 /*
9159 * Recalculate the csum and put it into the csum tree.
9160 *
9161 * Extent tree init will wipe out all the extent info, so in that case, we
9162 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
9163 * will use fs/subvol trees to init the csum tree.
9164 */
9165 static int fill_csum_tree(struct btrfs_trans_handle *trans,
9166 struct btrfs_root *csum_root,
9167 int search_fs_tree)
9168 {
9169 if (search_fs_tree)
9170 return fill_csum_tree_from_fs(trans, csum_root);
9171 else
9172 return fill_csum_tree_from_extent(trans, csum_root);
9173 }
9174
9175 static void free_roots_info_cache(void)
9176 {
9177 if (!roots_info_cache)
9178 return;
9179
9180 while (!cache_tree_empty(roots_info_cache)) {
9181 struct cache_extent *entry;
9182 struct root_item_info *rii;
9183
9184 entry = first_cache_extent(roots_info_cache);
9185 if (!entry)
9186 break;
9187 remove_cache_extent(roots_info_cache, entry);
9188 rii = container_of(entry, struct root_item_info, cache_extent);
9189 free(rii);
9190 }
9191
9192 free(roots_info_cache);
9193 roots_info_cache = NULL;
9194 }
9195
9196 static int build_roots_info_cache(struct btrfs_fs_info *info)
9197 {
9198 int ret = 0;
9199 struct btrfs_key key;
9200 struct extent_buffer *leaf;
9201 struct btrfs_path *path;
9202
9203 if (!roots_info_cache) {
9204 roots_info_cache = malloc(sizeof(*roots_info_cache));
9205 if (!roots_info_cache)
9206 return -ENOMEM;
9207 cache_tree_init(roots_info_cache);
9208 }
9209
9210 path = btrfs_alloc_path();
9211 if (!path)
9212 return -ENOMEM;
9213
9214 key.objectid = 0;
9215 key.type = BTRFS_EXTENT_ITEM_KEY;
9216 key.offset = 0;
9217
9218 ret = btrfs_search_slot(NULL, info->extent_root, &key, path, 0, 0);
9219 if (ret < 0)
9220 goto out;
9221 leaf = path->nodes[0];
9222
9223 while (1) {
9224 struct btrfs_key found_key;
9225 struct btrfs_extent_item *ei;
9226 struct btrfs_extent_inline_ref *iref;
9227 int slot = path->slots[0];
9228 int type;
9229 u64 flags;
9230 u64 root_id;
9231 u8 level;
9232 struct cache_extent *entry;
9233 struct root_item_info *rii;
9234
9235 if (slot >= btrfs_header_nritems(leaf)) {
9236 ret = btrfs_next_leaf(info->extent_root, path);
9237 if (ret < 0) {
9238 break;
9239 } else if (ret) {
9240 ret = 0;
9241 break;
9242 }
9243 leaf = path->nodes[0];
9244 slot = path->slots[0];
9245 }
9246
9247 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
9248
9249 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
9250 found_key.type != BTRFS_METADATA_ITEM_KEY)
9251 goto next;
9252
9253 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
9254 flags = btrfs_extent_flags(leaf, ei);
9255
9256 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
9257 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
9258 goto next;
9259
9260 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
9261 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
9262 level = found_key.offset;
9263 } else {
9264 struct btrfs_tree_block_info *binfo;
9265
9266 binfo = (struct btrfs_tree_block_info *)(ei + 1);
9267 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
9268 level = btrfs_tree_block_level(leaf, binfo);
9269 }
9270
9271 /*
9272 * For a root extent, it must be of the following type and the
9273 * first (and only one) iref in the item.
9274 */
9275 type = btrfs_extent_inline_ref_type(leaf, iref);
9276 if (type != BTRFS_TREE_BLOCK_REF_KEY)
9277 goto next;
9278
9279 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
9280 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
9281 if (!entry) {
9282 rii = malloc(sizeof(struct root_item_info));
9283 if (!rii) {
9284 ret = -ENOMEM;
9285 goto out;
9286 }
9287 rii->cache_extent.start = root_id;
9288 rii->cache_extent.size = 1;
9289 rii->level = (u8)-1;
9290 entry = &rii->cache_extent;
9291 ret = insert_cache_extent(roots_info_cache, entry);
9292 ASSERT(ret == 0);
9293 } else {
9294 rii = container_of(entry, struct root_item_info,
9295 cache_extent);
9296 }
9297
9298 ASSERT(rii->cache_extent.start == root_id);
9299 ASSERT(rii->cache_extent.size == 1);
9300
9301 if (level > rii->level || rii->level == (u8)-1) {
9302 rii->level = level;
9303 rii->bytenr = found_key.objectid;
9304 rii->gen = btrfs_extent_generation(leaf, ei);
9305 rii->node_count = 1;
9306 } else if (level == rii->level) {
9307 rii->node_count++;
9308 }
9309 next:
9310 path->slots[0]++;
9311 }
9312
9313 out:
9314 btrfs_free_path(path);
9315
9316 return ret;
9317 }
9318
9319 static int maybe_repair_root_item(struct btrfs_fs_info *info,
9320 struct btrfs_path *path,
9321 const struct btrfs_key *root_key,
9322 const int read_only_mode)
9323 {
9324 const u64 root_id = root_key->objectid;
9325 struct cache_extent *entry;
9326 struct root_item_info *rii;
9327 struct btrfs_root_item ri;
9328 unsigned long offset;
9329
9330 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
9331 if (!entry) {
9332 fprintf(stderr,
9333 "Error: could not find extent items for root %llu\n",
9334 root_key->objectid);
9335 return -ENOENT;
9336 }
9337
9338 rii = container_of(entry, struct root_item_info, cache_extent);
9339 ASSERT(rii->cache_extent.start == root_id);
9340 ASSERT(rii->cache_extent.size == 1);
9341
9342 if (rii->node_count != 1) {
9343 fprintf(stderr,
9344 "Error: could not find btree root extent for root %llu\n",
9345 root_id);
9346 return -ENOENT;
9347 }
9348
9349 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
9350 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
9351
9352 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
9353 btrfs_root_level(&ri) != rii->level ||
9354 btrfs_root_generation(&ri) != rii->gen) {
9355
9356 /*
9357 * If we're in repair mode but our caller told us to not update
9358 * the root item, i.e. just check if it needs to be updated, don't
9359 * print this message, since the caller will call us again shortly
9360 * for the same root item without read only mode (the caller will
9361 * open a transaction first).
9362 */
9363 if (!(read_only_mode && repair))
9364 fprintf(stderr,
9365 "%sroot item for root %llu,"
9366 " current bytenr %llu, current gen %llu, current level %u,"
9367 " new bytenr %llu, new gen %llu, new level %u\n",
9368 (read_only_mode ? "" : "fixing "),
9369 root_id,
9370 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
9371 btrfs_root_level(&ri),
9372 rii->bytenr, rii->gen, rii->level);
9373
9374 if (btrfs_root_generation(&ri) > rii->gen) {
9375 fprintf(stderr,
9376 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
9377 root_id, btrfs_root_generation(&ri), rii->gen);
9378 return -EINVAL;
9379 }
9380
9381 if (!read_only_mode) {
9382 btrfs_set_root_bytenr(&ri, rii->bytenr);
9383 btrfs_set_root_level(&ri, rii->level);
9384 btrfs_set_root_generation(&ri, rii->gen);
9385 write_extent_buffer(path->nodes[0], &ri,
9386 offset, sizeof(ri));
9387 }
9388
9389 return 1;
9390 }
9391
9392 return 0;
9393 }
9394
9395 /*
9396 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
9397 * caused read-only snapshots to be corrupted if they were created at a moment
9398 * when the source subvolume/snapshot had orphan items. The issue was that the
9399 * on-disk root items became incorrect, referring to the pre orphan cleanup root
9400 * node instead of the post orphan cleanup root node.
9401 * So this function, and its callees, just detects and fixes those cases. Even
9402 * though the regression was for read-only snapshots, this function applies to
9403 * any snapshot/subvolume root.
9404 * This must be run before any other repair code - not doing it so, makes other
9405 * repair code delete or modify backrefs in the extent tree for example, which
9406 * will result in an inconsistent fs after repairing the root items.
9407 */
9408 static int repair_root_items(struct btrfs_fs_info *info)
9409 {
9410 struct btrfs_path *path = NULL;
9411 struct btrfs_key key;
9412 struct extent_buffer *leaf;
9413 struct btrfs_trans_handle *trans = NULL;
9414 int ret = 0;
9415 int bad_roots = 0;
9416 int need_trans = 0;
9417
9418 ret = build_roots_info_cache(info);
9419 if (ret)
9420 goto out;
9421
9422 path = btrfs_alloc_path();
9423 if (!path) {
9424 ret = -ENOMEM;
9425 goto out;
9426 }
9427
9428 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
9429 key.type = BTRFS_ROOT_ITEM_KEY;
9430 key.offset = 0;
9431
9432 again:
9433 /*
9434 * Avoid opening and committing transactions if a leaf doesn't have
9435 * any root items that need to be fixed, so that we avoid rotating
9436 * backup roots unnecessarily.
9437 */
9438 if (need_trans) {
9439 trans = btrfs_start_transaction(info->tree_root, 1);
9440 if (IS_ERR(trans)) {
9441 ret = PTR_ERR(trans);
9442 goto out;
9443 }
9444 }
9445
9446 ret = btrfs_search_slot(trans, info->tree_root, &key, path,
9447 0, trans ? 1 : 0);
9448 if (ret < 0)
9449 goto out;
9450 leaf = path->nodes[0];
9451
9452 while (1) {
9453 struct btrfs_key found_key;
9454
9455 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
9456 int no_more_keys = find_next_key(path, &key);
9457
9458 btrfs_release_path(path);
9459 if (trans) {
9460 ret = btrfs_commit_transaction(trans,
9461 info->tree_root);
9462 trans = NULL;
9463 if (ret < 0)
9464 goto out;
9465 }
9466 need_trans = 0;
9467 if (no_more_keys)
9468 break;
9469 goto again;
9470 }
9471
9472 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
9473
9474 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
9475 goto next;
9476 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
9477 goto next;
9478
9479 ret = maybe_repair_root_item(info, path, &found_key,
9480 trans ? 0 : 1);
9481 if (ret < 0)
9482 goto out;
9483 if (ret) {
9484 if (!trans && repair) {
9485 need_trans = 1;
9486 key = found_key;
9487 btrfs_release_path(path);
9488 goto again;
9489 }
9490 bad_roots++;
9491 }
9492 next:
9493 path->slots[0]++;
9494 }
9495 ret = 0;
9496 out:
9497 free_roots_info_cache();
9498 btrfs_free_path(path);
9499 if (trans)
9500 btrfs_commit_transaction(trans, info->tree_root);
9501 if (ret < 0)
9502 return ret;
9503
9504 return bad_roots;
9505 }
9506
9507 const char * const cmd_check_usage[] = {
9508 "btrfs check [options] <device>",
9509 "Check structural integrity of a filesystem (unmounted).",
9510 "Check structural integrity of an unmounted filesystem. Verify internal",
9511 "trees' consistency and item connectivity. In the repair mode try to",
9512 "fix the problems found.",
9513 "WARNING: the repair mode is considered dangerous",
9514 "",
9515 "-s|--super <superblock> use this superblock copy",
9516 "-b|--backup use the first valid backup root copy",
9517 "--repair try to repair the filesystem",
9518 "--readonly run in read-only mode (default)",
9519 "--init-csum-tree create a new CRC tree",
9520 "--init-extent-tree create a new extent tree",
9521 "--check-data-csum verify checksums of data blocks",
9522 "-Q|--qgroup-report print a report on qgroup consistency",
9523 "-E|--subvol-extents <subvolid>",
9524 " print subvolume extents and sharing state",
9525 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
9526 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
9527 "-p|--progress indicate progress",
9528 NULL
9529 };
9530
9531 int cmd_check(int argc, char **argv)
9532 {
9533 struct cache_tree root_cache;
9534 struct btrfs_root *root;
9535 struct btrfs_fs_info *info;
9536 u64 bytenr = 0;
9537 u64 subvolid = 0;
9538 u64 tree_root_bytenr = 0;
9539 u64 chunk_root_bytenr = 0;
9540 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
9541 int ret;
9542 u64 num;
9543 int init_csum_tree = 0;
9544 int readonly = 0;
9545 int qgroup_report = 0;
9546 enum btrfs_open_ctree_flags ctree_flags = OPEN_CTREE_EXCLUSIVE;
9547
9548 while(1) {
9549 int c;
9550 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
9551 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
9552 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE };
9553 static const struct option long_options[] = {
9554 { "super", required_argument, NULL, 's' },
9555 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
9556 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
9557 { "init-csum-tree", no_argument, NULL,
9558 GETOPT_VAL_INIT_CSUM },
9559 { "init-extent-tree", no_argument, NULL,
9560 GETOPT_VAL_INIT_EXTENT },
9561 { "check-data-csum", no_argument, NULL,
9562 GETOPT_VAL_CHECK_CSUM },
9563 { "backup", no_argument, NULL, 'b' },
9564 { "subvol-extents", required_argument, NULL, 'E' },
9565 { "qgroup-report", no_argument, NULL, 'Q' },
9566 { "tree-root", required_argument, NULL, 'r' },
9567 { "chunk-root", required_argument, NULL,
9568 GETOPT_VAL_CHUNK_TREE },
9569 { "progress", no_argument, NULL, 'p' },
9570 { NULL, 0, NULL, 0}
9571 };
9572
9573 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
9574 if (c < 0)
9575 break;
9576 switch(c) {
9577 case 'a': /* ignored */ break;
9578 case 'b':
9579 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
9580 break;
9581 case 's':
9582 num = arg_strtou64(optarg);
9583 if (num >= BTRFS_SUPER_MIRROR_MAX) {
9584 fprintf(stderr,
9585 "ERROR: super mirror should be less than: %d\n",
9586 BTRFS_SUPER_MIRROR_MAX);
9587 exit(1);
9588 }
9589 bytenr = btrfs_sb_offset(((int)num));
9590 printf("using SB copy %llu, bytenr %llu\n", num,
9591 (unsigned long long)bytenr);
9592 break;
9593 case 'Q':
9594 qgroup_report = 1;
9595 break;
9596 case 'E':
9597 subvolid = arg_strtou64(optarg);
9598 break;
9599 case 'r':
9600 tree_root_bytenr = arg_strtou64(optarg);
9601 break;
9602 case GETOPT_VAL_CHUNK_TREE:
9603 chunk_root_bytenr = arg_strtou64(optarg);
9604 break;
9605 case 'p':
9606 ctx.progress_enabled = true;
9607 break;
9608 case '?':
9609 case 'h':
9610 usage(cmd_check_usage);
9611 case GETOPT_VAL_REPAIR:
9612 printf("enabling repair mode\n");
9613 repair = 1;
9614 ctree_flags |= OPEN_CTREE_WRITES;
9615 break;
9616 case GETOPT_VAL_READONLY:
9617 readonly = 1;
9618 break;
9619 case GETOPT_VAL_INIT_CSUM:
9620 printf("Creating a new CRC tree\n");
9621 init_csum_tree = 1;
9622 repair = 1;
9623 ctree_flags |= OPEN_CTREE_WRITES;
9624 break;
9625 case GETOPT_VAL_INIT_EXTENT:
9626 init_extent_tree = 1;
9627 ctree_flags |= (OPEN_CTREE_WRITES |
9628 OPEN_CTREE_NO_BLOCK_GROUPS);
9629 repair = 1;
9630 break;
9631 case GETOPT_VAL_CHECK_CSUM:
9632 check_data_csum = 1;
9633 break;
9634 }
9635 }
9636
9637 if (check_argc_exact(argc - optind, 1))
9638 usage(cmd_check_usage);
9639
9640 if (ctx.progress_enabled) {
9641 ctx.tp = TASK_NOTHING;
9642 ctx.info = task_init(print_status_check, print_status_return, &ctx);
9643 }
9644
9645 /* This check is the only reason for --readonly to exist */
9646 if (readonly && repair) {
9647 fprintf(stderr, "Repair options are not compatible with --readonly\n");
9648 exit(1);
9649 }
9650
9651 radix_tree_init();
9652 cache_tree_init(&root_cache);
9653
9654 if((ret = check_mounted(argv[optind])) < 0) {
9655 fprintf(stderr, "Could not check mount status: %s\n", strerror(-ret));
9656 goto err_out;
9657 } else if(ret) {
9658 fprintf(stderr, "%s is currently mounted. Aborting.\n", argv[optind]);
9659 ret = -EBUSY;
9660 goto err_out;
9661 }
9662
9663 /* only allow partial opening under repair mode */
9664 if (repair)
9665 ctree_flags |= OPEN_CTREE_PARTIAL;
9666
9667 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
9668 chunk_root_bytenr, ctree_flags);
9669 if (!info) {
9670 fprintf(stderr, "Couldn't open file system\n");
9671 ret = -EIO;
9672 goto err_out;
9673 }
9674
9675 global_info = info;
9676 root = info->fs_root;
9677
9678 /*
9679 * repair mode will force us to commit transaction which
9680 * will make us fail to load log tree when mounting.
9681 */
9682 if (repair && btrfs_super_log_root(info->super_copy)) {
9683 ret = ask_user("repair mode will force to clear out log tree, Are you sure?");
9684 if (!ret) {
9685 ret = 1;
9686 goto close_out;
9687 }
9688 ret = zero_log_tree(root);
9689 if (ret) {
9690 fprintf(stderr, "fail to zero log tree\n");
9691 goto close_out;
9692 }
9693 }
9694
9695 uuid_unparse(info->super_copy->fsid, uuidbuf);
9696 if (qgroup_report) {
9697 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
9698 uuidbuf);
9699 ret = qgroup_verify_all(info);
9700 if (ret == 0)
9701 ret = report_qgroups(1);
9702 goto close_out;
9703 }
9704 if (subvolid) {
9705 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
9706 subvolid, argv[optind], uuidbuf);
9707 ret = print_extent_state(info, subvolid);
9708 goto close_out;
9709 }
9710 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
9711
9712 if (!extent_buffer_uptodate(info->tree_root->node) ||
9713 !extent_buffer_uptodate(info->dev_root->node) ||
9714 !extent_buffer_uptodate(info->chunk_root->node)) {
9715 fprintf(stderr, "Critical roots corrupted, unable to fsck the FS\n");
9716 ret = -EIO;
9717 goto close_out;
9718 }
9719
9720 if (init_extent_tree || init_csum_tree) {
9721 struct btrfs_trans_handle *trans;
9722
9723 trans = btrfs_start_transaction(info->extent_root, 0);
9724 if (IS_ERR(trans)) {
9725 fprintf(stderr, "Error starting transaction\n");
9726 ret = PTR_ERR(trans);
9727 goto close_out;
9728 }
9729
9730 if (init_extent_tree) {
9731 printf("Creating a new extent tree\n");
9732 ret = reinit_extent_tree(trans, info);
9733 if (ret)
9734 goto close_out;
9735 }
9736
9737 if (init_csum_tree) {
9738 fprintf(stderr, "Reinit crc root\n");
9739 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
9740 if (ret) {
9741 fprintf(stderr, "crc root initialization failed\n");
9742 ret = -EIO;
9743 goto close_out;
9744 }
9745
9746 ret = fill_csum_tree(trans, info->csum_root,
9747 init_extent_tree);
9748 if (ret) {
9749 fprintf(stderr, "crc refilling failed\n");
9750 return -EIO;
9751 }
9752 }
9753 /*
9754 * Ok now we commit and run the normal fsck, which will add
9755 * extent entries for all of the items it finds.
9756 */
9757 ret = btrfs_commit_transaction(trans, info->extent_root);
9758 if (ret)
9759 goto close_out;
9760 }
9761 if (!extent_buffer_uptodate(info->extent_root->node)) {
9762 fprintf(stderr, "Critical roots corrupted, unable to fsck the FS\n");
9763 ret = -EIO;
9764 goto close_out;
9765 }
9766 if (!extent_buffer_uptodate(info->csum_root->node)) {
9767 fprintf(stderr, "Checksum root corrupted, rerun with --init-csum-tree option\n");
9768 ret = -EIO;
9769 goto close_out;
9770 }
9771
9772 if (!ctx.progress_enabled)
9773 fprintf(stderr, "checking extents\n");
9774 ret = check_chunks_and_extents(root);
9775 if (ret)
9776 fprintf(stderr, "Errors found in extent allocation tree or chunk allocation\n");
9777
9778 ret = repair_root_items(info);
9779 if (ret < 0)
9780 goto close_out;
9781 if (repair) {
9782 fprintf(stderr, "Fixed %d roots.\n", ret);
9783 ret = 0;
9784 } else if (ret > 0) {
9785 fprintf(stderr,
9786 "Found %d roots with an outdated root item.\n",
9787 ret);
9788 fprintf(stderr,
9789 "Please run a filesystem check with the option --repair to fix them.\n");
9790 ret = 1;
9791 goto close_out;
9792 }
9793
9794 if (!ctx.progress_enabled) {
9795 if (btrfs_fs_compat_ro(info, BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE))
9796 fprintf(stderr, "checking free space tree\n");
9797 else
9798 fprintf(stderr, "checking free space cache\n");
9799 }
9800 ret = check_space_cache(root);
9801 if (ret)
9802 goto out;
9803
9804 /*
9805 * We used to have to have these hole extents in between our real
9806 * extents so if we don't have this flag set we need to make sure there
9807 * are no gaps in the file extents for inodes, otherwise we can just
9808 * ignore it when this happens.
9809 */
9810 no_holes = btrfs_fs_incompat(root->fs_info,
9811 BTRFS_FEATURE_INCOMPAT_NO_HOLES);
9812 if (!ctx.progress_enabled)
9813 fprintf(stderr, "checking fs roots\n");
9814 ret = check_fs_roots(root, &root_cache);
9815 if (ret)
9816 goto out;
9817
9818 fprintf(stderr, "checking csums\n");
9819 ret = check_csums(root);
9820 if (ret)
9821 goto out;
9822
9823 fprintf(stderr, "checking root refs\n");
9824 ret = check_root_refs(root, &root_cache);
9825 if (ret)
9826 goto out;
9827
9828 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
9829 struct extent_buffer *eb;
9830
9831 eb = list_first_entry(&root->fs_info->recow_ebs,
9832 struct extent_buffer, recow);
9833 list_del_init(&eb->recow);
9834 ret = recow_extent_buffer(root, eb);
9835 if (ret)
9836 break;
9837 }
9838
9839 while (!list_empty(&delete_items)) {
9840 struct bad_item *bad;
9841
9842 bad = list_first_entry(&delete_items, struct bad_item, list);
9843 list_del_init(&bad->list);
9844 if (repair)
9845 ret = delete_bad_item(root, bad);
9846 free(bad);
9847 }
9848
9849 if (info->quota_enabled) {
9850 int err;
9851 fprintf(stderr, "checking quota groups\n");
9852 err = qgroup_verify_all(info);
9853 if (err)
9854 goto out;
9855 }
9856
9857 if (!list_empty(&root->fs_info->recow_ebs)) {
9858 fprintf(stderr, "Transid errors in file system\n");
9859 ret = 1;
9860 }
9861 out:
9862 /* Don't override original ret */
9863 if (ret)
9864 report_qgroups(0);
9865 else
9866 ret = report_qgroups(0);
9867 if (found_old_backref) { /*
9868 * there was a disk format change when mixed
9869 * backref was in testing tree. The old format
9870 * existed about one week.
9871 */
9872 printf("\n * Found old mixed backref format. "
9873 "The old format is not supported! *"
9874 "\n * Please mount the FS in readonly mode, "
9875 "backup data and re-format the FS. *\n\n");
9876 ret = 1;
9877 }
9878 printf("found %llu bytes used err is %d\n",
9879 (unsigned long long)bytes_used, ret);
9880 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
9881 printf("total tree bytes: %llu\n",
9882 (unsigned long long)total_btree_bytes);
9883 printf("total fs tree bytes: %llu\n",
9884 (unsigned long long)total_fs_tree_bytes);
9885 printf("total extent tree bytes: %llu\n",
9886 (unsigned long long)total_extent_tree_bytes);
9887 printf("btree space waste bytes: %llu\n",
9888 (unsigned long long)btree_space_waste);
9889 printf("file data blocks allocated: %llu\n referenced %llu\n",
9890 (unsigned long long)data_bytes_allocated,
9891 (unsigned long long)data_bytes_referenced);
9892
9893 free_root_recs_tree(&root_cache);
9894 close_out:
9895 close_ctree(root);
9896 err_out:
9897 if (ctx.progress_enabled)
9898 task_deinit(ctx.info);
9899
9900 return ret;
9901 }
(deprecated) Btrfs progs developments and patch integration