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