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