Btrfs: cleanup scrub bio and worker wait code
[linux-3.10.git] / fs / btrfs / check-integrity.c
1 /*
2  * Copyright (C) STRATO AG 2011.  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 /*
20  * This module can be used to catch cases when the btrfs kernel
21  * code executes write requests to the disk that bring the file
22  * system in an inconsistent state. In such a state, a power-loss
23  * or kernel panic event would cause that the data on disk is
24  * lost or at least damaged.
25  *
26  * Code is added that examines all block write requests during
27  * runtime (including writes of the super block). Three rules
28  * are verified and an error is printed on violation of the
29  * rules:
30  * 1. It is not allowed to write a disk block which is
31  *    currently referenced by the super block (either directly
32  *    or indirectly).
33  * 2. When a super block is written, it is verified that all
34  *    referenced (directly or indirectly) blocks fulfill the
35  *    following requirements:
36  *    2a. All referenced blocks have either been present when
37  *        the file system was mounted, (i.e., they have been
38  *        referenced by the super block) or they have been
39  *        written since then and the write completion callback
40  *        was called and no write error was indicated and a
41  *        FLUSH request to the device where these blocks are
42  *        located was received and completed.
43  *    2b. All referenced blocks need to have a generation
44  *        number which is equal to the parent's number.
45  *
46  * One issue that was found using this module was that the log
47  * tree on disk became temporarily corrupted because disk blocks
48  * that had been in use for the log tree had been freed and
49  * reused too early, while being referenced by the written super
50  * block.
51  *
52  * The search term in the kernel log that can be used to filter
53  * on the existence of detected integrity issues is
54  * "btrfs: attempt".
55  *
56  * The integrity check is enabled via mount options. These
57  * mount options are only supported if the integrity check
58  * tool is compiled by defining BTRFS_FS_CHECK_INTEGRITY.
59  *
60  * Example #1, apply integrity checks to all metadata:
61  * mount /dev/sdb1 /mnt -o check_int
62  *
63  * Example #2, apply integrity checks to all metadata and
64  * to data extents:
65  * mount /dev/sdb1 /mnt -o check_int_data
66  *
67  * Example #3, apply integrity checks to all metadata and dump
68  * the tree that the super block references to kernel messages
69  * each time after a super block was written:
70  * mount /dev/sdb1 /mnt -o check_int,check_int_print_mask=263
71  *
72  * If the integrity check tool is included and activated in
73  * the mount options, plenty of kernel memory is used, and
74  * plenty of additional CPU cycles are spent. Enabling this
75  * functionality is not intended for normal use. In most
76  * cases, unless you are a btrfs developer who needs to verify
77  * the integrity of (super)-block write requests, do not
78  * enable the config option BTRFS_FS_CHECK_INTEGRITY to
79  * include and compile the integrity check tool.
80  */
81
82 #include <linux/sched.h>
83 #include <linux/slab.h>
84 #include <linux/buffer_head.h>
85 #include <linux/mutex.h>
86 #include <linux/crc32c.h>
87 #include <linux/genhd.h>
88 #include <linux/blkdev.h>
89 #include "ctree.h"
90 #include "disk-io.h"
91 #include "transaction.h"
92 #include "extent_io.h"
93 #include "volumes.h"
94 #include "print-tree.h"
95 #include "locking.h"
96 #include "check-integrity.h"
97 #include "rcu-string.h"
98
99 #define BTRFSIC_BLOCK_HASHTABLE_SIZE 0x10000
100 #define BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE 0x10000
101 #define BTRFSIC_DEV2STATE_HASHTABLE_SIZE 0x100
102 #define BTRFSIC_BLOCK_MAGIC_NUMBER 0x14491051
103 #define BTRFSIC_BLOCK_LINK_MAGIC_NUMBER 0x11070807
104 #define BTRFSIC_DEV2STATE_MAGIC_NUMBER 0x20111530
105 #define BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER 20111300
106 #define BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL (200 - 6)    /* in characters,
107                                                          * excluding " [...]" */
108 #define BTRFSIC_GENERATION_UNKNOWN ((u64)-1)
109
110 /*
111  * The definition of the bitmask fields for the print_mask.
112  * They are specified with the mount option check_integrity_print_mask.
113  */
114 #define BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE                     0x00000001
115 #define BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION         0x00000002
116 #define BTRFSIC_PRINT_MASK_TREE_AFTER_SB_WRITE                  0x00000004
117 #define BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE                 0x00000008
118 #define BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH                        0x00000010
119 #define BTRFSIC_PRINT_MASK_END_IO_BIO_BH                        0x00000020
120 #define BTRFSIC_PRINT_MASK_VERBOSE                              0x00000040
121 #define BTRFSIC_PRINT_MASK_VERY_VERBOSE                         0x00000080
122 #define BTRFSIC_PRINT_MASK_INITIAL_TREE                         0x00000100
123 #define BTRFSIC_PRINT_MASK_INITIAL_ALL_TREES                    0x00000200
124 #define BTRFSIC_PRINT_MASK_INITIAL_DATABASE                     0x00000400
125 #define BTRFSIC_PRINT_MASK_NUM_COPIES                           0x00000800
126 #define BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS                0x00001000
127
128 struct btrfsic_dev_state;
129 struct btrfsic_state;
130
131 struct btrfsic_block {
132         u32 magic_num;          /* only used for debug purposes */
133         unsigned int is_metadata:1;     /* if it is meta-data, not data-data */
134         unsigned int is_superblock:1;   /* if it is one of the superblocks */
135         unsigned int is_iodone:1;       /* if is done by lower subsystem */
136         unsigned int iodone_w_error:1;  /* error was indicated to endio */
137         unsigned int never_written:1;   /* block was added because it was
138                                          * referenced, not because it was
139                                          * written */
140         unsigned int mirror_num:2;      /* large enough to hold
141                                          * BTRFS_SUPER_MIRROR_MAX */
142         struct btrfsic_dev_state *dev_state;
143         u64 dev_bytenr;         /* key, physical byte num on disk */
144         u64 logical_bytenr;     /* logical byte num on disk */
145         u64 generation;
146         struct btrfs_disk_key disk_key; /* extra info to print in case of
147                                          * issues, will not always be correct */
148         struct list_head collision_resolving_node;      /* list node */
149         struct list_head all_blocks_node;       /* list node */
150
151         /* the following two lists contain block_link items */
152         struct list_head ref_to_list;   /* list */
153         struct list_head ref_from_list; /* list */
154         struct btrfsic_block *next_in_same_bio;
155         void *orig_bio_bh_private;
156         union {
157                 bio_end_io_t *bio;
158                 bh_end_io_t *bh;
159         } orig_bio_bh_end_io;
160         int submit_bio_bh_rw;
161         u64 flush_gen; /* only valid if !never_written */
162 };
163
164 /*
165  * Elements of this type are allocated dynamically and required because
166  * each block object can refer to and can be ref from multiple blocks.
167  * The key to lookup them in the hashtable is the dev_bytenr of
168  * the block ref to plus the one from the block refered from.
169  * The fact that they are searchable via a hashtable and that a
170  * ref_cnt is maintained is not required for the btrfs integrity
171  * check algorithm itself, it is only used to make the output more
172  * beautiful in case that an error is detected (an error is defined
173  * as a write operation to a block while that block is still referenced).
174  */
175 struct btrfsic_block_link {
176         u32 magic_num;          /* only used for debug purposes */
177         u32 ref_cnt;
178         struct list_head node_ref_to;   /* list node */
179         struct list_head node_ref_from; /* list node */
180         struct list_head collision_resolving_node;      /* list node */
181         struct btrfsic_block *block_ref_to;
182         struct btrfsic_block *block_ref_from;
183         u64 parent_generation;
184 };
185
186 struct btrfsic_dev_state {
187         u32 magic_num;          /* only used for debug purposes */
188         struct block_device *bdev;
189         struct btrfsic_state *state;
190         struct list_head collision_resolving_node;      /* list node */
191         struct btrfsic_block dummy_block_for_bio_bh_flush;
192         u64 last_flush_gen;
193         char name[BDEVNAME_SIZE];
194 };
195
196 struct btrfsic_block_hashtable {
197         struct list_head table[BTRFSIC_BLOCK_HASHTABLE_SIZE];
198 };
199
200 struct btrfsic_block_link_hashtable {
201         struct list_head table[BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE];
202 };
203
204 struct btrfsic_dev_state_hashtable {
205         struct list_head table[BTRFSIC_DEV2STATE_HASHTABLE_SIZE];
206 };
207
208 struct btrfsic_block_data_ctx {
209         u64 start;              /* virtual bytenr */
210         u64 dev_bytenr;         /* physical bytenr on device */
211         u32 len;
212         struct btrfsic_dev_state *dev;
213         char **datav;
214         struct page **pagev;
215         void *mem_to_free;
216 };
217
218 /* This structure is used to implement recursion without occupying
219  * any stack space, refer to btrfsic_process_metablock() */
220 struct btrfsic_stack_frame {
221         u32 magic;
222         u32 nr;
223         int error;
224         int i;
225         int limit_nesting;
226         int num_copies;
227         int mirror_num;
228         struct btrfsic_block *block;
229         struct btrfsic_block_data_ctx *block_ctx;
230         struct btrfsic_block *next_block;
231         struct btrfsic_block_data_ctx next_block_ctx;
232         struct btrfs_header *hdr;
233         struct btrfsic_stack_frame *prev;
234 };
235
236 /* Some state per mounted filesystem */
237 struct btrfsic_state {
238         u32 print_mask;
239         int include_extent_data;
240         int csum_size;
241         struct list_head all_blocks_list;
242         struct btrfsic_block_hashtable block_hashtable;
243         struct btrfsic_block_link_hashtable block_link_hashtable;
244         struct btrfs_root *root;
245         u64 max_superblock_generation;
246         struct btrfsic_block *latest_superblock;
247         u32 metablock_size;
248         u32 datablock_size;
249 };
250
251 static void btrfsic_block_init(struct btrfsic_block *b);
252 static struct btrfsic_block *btrfsic_block_alloc(void);
253 static void btrfsic_block_free(struct btrfsic_block *b);
254 static void btrfsic_block_link_init(struct btrfsic_block_link *n);
255 static struct btrfsic_block_link *btrfsic_block_link_alloc(void);
256 static void btrfsic_block_link_free(struct btrfsic_block_link *n);
257 static void btrfsic_dev_state_init(struct btrfsic_dev_state *ds);
258 static struct btrfsic_dev_state *btrfsic_dev_state_alloc(void);
259 static void btrfsic_dev_state_free(struct btrfsic_dev_state *ds);
260 static void btrfsic_block_hashtable_init(struct btrfsic_block_hashtable *h);
261 static void btrfsic_block_hashtable_add(struct btrfsic_block *b,
262                                         struct btrfsic_block_hashtable *h);
263 static void btrfsic_block_hashtable_remove(struct btrfsic_block *b);
264 static struct btrfsic_block *btrfsic_block_hashtable_lookup(
265                 struct block_device *bdev,
266                 u64 dev_bytenr,
267                 struct btrfsic_block_hashtable *h);
268 static void btrfsic_block_link_hashtable_init(
269                 struct btrfsic_block_link_hashtable *h);
270 static void btrfsic_block_link_hashtable_add(
271                 struct btrfsic_block_link *l,
272                 struct btrfsic_block_link_hashtable *h);
273 static void btrfsic_block_link_hashtable_remove(struct btrfsic_block_link *l);
274 static struct btrfsic_block_link *btrfsic_block_link_hashtable_lookup(
275                 struct block_device *bdev_ref_to,
276                 u64 dev_bytenr_ref_to,
277                 struct block_device *bdev_ref_from,
278                 u64 dev_bytenr_ref_from,
279                 struct btrfsic_block_link_hashtable *h);
280 static void btrfsic_dev_state_hashtable_init(
281                 struct btrfsic_dev_state_hashtable *h);
282 static void btrfsic_dev_state_hashtable_add(
283                 struct btrfsic_dev_state *ds,
284                 struct btrfsic_dev_state_hashtable *h);
285 static void btrfsic_dev_state_hashtable_remove(struct btrfsic_dev_state *ds);
286 static struct btrfsic_dev_state *btrfsic_dev_state_hashtable_lookup(
287                 struct block_device *bdev,
288                 struct btrfsic_dev_state_hashtable *h);
289 static struct btrfsic_stack_frame *btrfsic_stack_frame_alloc(void);
290 static void btrfsic_stack_frame_free(struct btrfsic_stack_frame *sf);
291 static int btrfsic_process_superblock(struct btrfsic_state *state,
292                                       struct btrfs_fs_devices *fs_devices);
293 static int btrfsic_process_metablock(struct btrfsic_state *state,
294                                      struct btrfsic_block *block,
295                                      struct btrfsic_block_data_ctx *block_ctx,
296                                      int limit_nesting, int force_iodone_flag);
297 static void btrfsic_read_from_block_data(
298         struct btrfsic_block_data_ctx *block_ctx,
299         void *dst, u32 offset, size_t len);
300 static int btrfsic_create_link_to_next_block(
301                 struct btrfsic_state *state,
302                 struct btrfsic_block *block,
303                 struct btrfsic_block_data_ctx
304                 *block_ctx, u64 next_bytenr,
305                 int limit_nesting,
306                 struct btrfsic_block_data_ctx *next_block_ctx,
307                 struct btrfsic_block **next_blockp,
308                 int force_iodone_flag,
309                 int *num_copiesp, int *mirror_nump,
310                 struct btrfs_disk_key *disk_key,
311                 u64 parent_generation);
312 static int btrfsic_handle_extent_data(struct btrfsic_state *state,
313                                       struct btrfsic_block *block,
314                                       struct btrfsic_block_data_ctx *block_ctx,
315                                       u32 item_offset, int force_iodone_flag);
316 static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len,
317                              struct btrfsic_block_data_ctx *block_ctx_out,
318                              int mirror_num);
319 static int btrfsic_map_superblock(struct btrfsic_state *state, u64 bytenr,
320                                   u32 len, struct block_device *bdev,
321                                   struct btrfsic_block_data_ctx *block_ctx_out);
322 static void btrfsic_release_block_ctx(struct btrfsic_block_data_ctx *block_ctx);
323 static int btrfsic_read_block(struct btrfsic_state *state,
324                               struct btrfsic_block_data_ctx *block_ctx);
325 static void btrfsic_dump_database(struct btrfsic_state *state);
326 static void btrfsic_complete_bio_end_io(struct bio *bio, int err);
327 static int btrfsic_test_for_metadata(struct btrfsic_state *state,
328                                      char **datav, unsigned int num_pages);
329 static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state,
330                                           u64 dev_bytenr, char **mapped_datav,
331                                           unsigned int num_pages,
332                                           struct bio *bio, int *bio_is_patched,
333                                           struct buffer_head *bh,
334                                           int submit_bio_bh_rw);
335 static int btrfsic_process_written_superblock(
336                 struct btrfsic_state *state,
337                 struct btrfsic_block *const block,
338                 struct btrfs_super_block *const super_hdr);
339 static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status);
340 static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate);
341 static int btrfsic_is_block_ref_by_superblock(const struct btrfsic_state *state,
342                                               const struct btrfsic_block *block,
343                                               int recursion_level);
344 static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state,
345                                         struct btrfsic_block *const block,
346                                         int recursion_level);
347 static void btrfsic_print_add_link(const struct btrfsic_state *state,
348                                    const struct btrfsic_block_link *l);
349 static void btrfsic_print_rem_link(const struct btrfsic_state *state,
350                                    const struct btrfsic_block_link *l);
351 static char btrfsic_get_block_type(const struct btrfsic_state *state,
352                                    const struct btrfsic_block *block);
353 static void btrfsic_dump_tree(const struct btrfsic_state *state);
354 static void btrfsic_dump_tree_sub(const struct btrfsic_state *state,
355                                   const struct btrfsic_block *block,
356                                   int indent_level);
357 static struct btrfsic_block_link *btrfsic_block_link_lookup_or_add(
358                 struct btrfsic_state *state,
359                 struct btrfsic_block_data_ctx *next_block_ctx,
360                 struct btrfsic_block *next_block,
361                 struct btrfsic_block *from_block,
362                 u64 parent_generation);
363 static struct btrfsic_block *btrfsic_block_lookup_or_add(
364                 struct btrfsic_state *state,
365                 struct btrfsic_block_data_ctx *block_ctx,
366                 const char *additional_string,
367                 int is_metadata,
368                 int is_iodone,
369                 int never_written,
370                 int mirror_num,
371                 int *was_created);
372 static int btrfsic_process_superblock_dev_mirror(
373                 struct btrfsic_state *state,
374                 struct btrfsic_dev_state *dev_state,
375                 struct btrfs_device *device,
376                 int superblock_mirror_num,
377                 struct btrfsic_dev_state **selected_dev_state,
378                 struct btrfs_super_block *selected_super);
379 static struct btrfsic_dev_state *btrfsic_dev_state_lookup(
380                 struct block_device *bdev);
381 static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state,
382                                            u64 bytenr,
383                                            struct btrfsic_dev_state *dev_state,
384                                            u64 dev_bytenr);
385
386 static struct mutex btrfsic_mutex;
387 static int btrfsic_is_initialized;
388 static struct btrfsic_dev_state_hashtable btrfsic_dev_state_hashtable;
389
390
391 static void btrfsic_block_init(struct btrfsic_block *b)
392 {
393         b->magic_num = BTRFSIC_BLOCK_MAGIC_NUMBER;
394         b->dev_state = NULL;
395         b->dev_bytenr = 0;
396         b->logical_bytenr = 0;
397         b->generation = BTRFSIC_GENERATION_UNKNOWN;
398         b->disk_key.objectid = 0;
399         b->disk_key.type = 0;
400         b->disk_key.offset = 0;
401         b->is_metadata = 0;
402         b->is_superblock = 0;
403         b->is_iodone = 0;
404         b->iodone_w_error = 0;
405         b->never_written = 0;
406         b->mirror_num = 0;
407         b->next_in_same_bio = NULL;
408         b->orig_bio_bh_private = NULL;
409         b->orig_bio_bh_end_io.bio = NULL;
410         INIT_LIST_HEAD(&b->collision_resolving_node);
411         INIT_LIST_HEAD(&b->all_blocks_node);
412         INIT_LIST_HEAD(&b->ref_to_list);
413         INIT_LIST_HEAD(&b->ref_from_list);
414         b->submit_bio_bh_rw = 0;
415         b->flush_gen = 0;
416 }
417
418 static struct btrfsic_block *btrfsic_block_alloc(void)
419 {
420         struct btrfsic_block *b;
421
422         b = kzalloc(sizeof(*b), GFP_NOFS);
423         if (NULL != b)
424                 btrfsic_block_init(b);
425
426         return b;
427 }
428
429 static void btrfsic_block_free(struct btrfsic_block *b)
430 {
431         BUG_ON(!(NULL == b || BTRFSIC_BLOCK_MAGIC_NUMBER == b->magic_num));
432         kfree(b);
433 }
434
435 static void btrfsic_block_link_init(struct btrfsic_block_link *l)
436 {
437         l->magic_num = BTRFSIC_BLOCK_LINK_MAGIC_NUMBER;
438         l->ref_cnt = 1;
439         INIT_LIST_HEAD(&l->node_ref_to);
440         INIT_LIST_HEAD(&l->node_ref_from);
441         INIT_LIST_HEAD(&l->collision_resolving_node);
442         l->block_ref_to = NULL;
443         l->block_ref_from = NULL;
444 }
445
446 static struct btrfsic_block_link *btrfsic_block_link_alloc(void)
447 {
448         struct btrfsic_block_link *l;
449
450         l = kzalloc(sizeof(*l), GFP_NOFS);
451         if (NULL != l)
452                 btrfsic_block_link_init(l);
453
454         return l;
455 }
456
457 static void btrfsic_block_link_free(struct btrfsic_block_link *l)
458 {
459         BUG_ON(!(NULL == l || BTRFSIC_BLOCK_LINK_MAGIC_NUMBER == l->magic_num));
460         kfree(l);
461 }
462
463 static void btrfsic_dev_state_init(struct btrfsic_dev_state *ds)
464 {
465         ds->magic_num = BTRFSIC_DEV2STATE_MAGIC_NUMBER;
466         ds->bdev = NULL;
467         ds->state = NULL;
468         ds->name[0] = '\0';
469         INIT_LIST_HEAD(&ds->collision_resolving_node);
470         ds->last_flush_gen = 0;
471         btrfsic_block_init(&ds->dummy_block_for_bio_bh_flush);
472         ds->dummy_block_for_bio_bh_flush.is_iodone = 1;
473         ds->dummy_block_for_bio_bh_flush.dev_state = ds;
474 }
475
476 static struct btrfsic_dev_state *btrfsic_dev_state_alloc(void)
477 {
478         struct btrfsic_dev_state *ds;
479
480         ds = kzalloc(sizeof(*ds), GFP_NOFS);
481         if (NULL != ds)
482                 btrfsic_dev_state_init(ds);
483
484         return ds;
485 }
486
487 static void btrfsic_dev_state_free(struct btrfsic_dev_state *ds)
488 {
489         BUG_ON(!(NULL == ds ||
490                  BTRFSIC_DEV2STATE_MAGIC_NUMBER == ds->magic_num));
491         kfree(ds);
492 }
493
494 static void btrfsic_block_hashtable_init(struct btrfsic_block_hashtable *h)
495 {
496         int i;
497
498         for (i = 0; i < BTRFSIC_BLOCK_HASHTABLE_SIZE; i++)
499                 INIT_LIST_HEAD(h->table + i);
500 }
501
502 static void btrfsic_block_hashtable_add(struct btrfsic_block *b,
503                                         struct btrfsic_block_hashtable *h)
504 {
505         const unsigned int hashval =
506             (((unsigned int)(b->dev_bytenr >> 16)) ^
507              ((unsigned int)((uintptr_t)b->dev_state->bdev))) &
508              (BTRFSIC_BLOCK_HASHTABLE_SIZE - 1);
509
510         list_add(&b->collision_resolving_node, h->table + hashval);
511 }
512
513 static void btrfsic_block_hashtable_remove(struct btrfsic_block *b)
514 {
515         list_del(&b->collision_resolving_node);
516 }
517
518 static struct btrfsic_block *btrfsic_block_hashtable_lookup(
519                 struct block_device *bdev,
520                 u64 dev_bytenr,
521                 struct btrfsic_block_hashtable *h)
522 {
523         const unsigned int hashval =
524             (((unsigned int)(dev_bytenr >> 16)) ^
525              ((unsigned int)((uintptr_t)bdev))) &
526              (BTRFSIC_BLOCK_HASHTABLE_SIZE - 1);
527         struct list_head *elem;
528
529         list_for_each(elem, h->table + hashval) {
530                 struct btrfsic_block *const b =
531                     list_entry(elem, struct btrfsic_block,
532                                collision_resolving_node);
533
534                 if (b->dev_state->bdev == bdev && b->dev_bytenr == dev_bytenr)
535                         return b;
536         }
537
538         return NULL;
539 }
540
541 static void btrfsic_block_link_hashtable_init(
542                 struct btrfsic_block_link_hashtable *h)
543 {
544         int i;
545
546         for (i = 0; i < BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE; i++)
547                 INIT_LIST_HEAD(h->table + i);
548 }
549
550 static void btrfsic_block_link_hashtable_add(
551                 struct btrfsic_block_link *l,
552                 struct btrfsic_block_link_hashtable *h)
553 {
554         const unsigned int hashval =
555             (((unsigned int)(l->block_ref_to->dev_bytenr >> 16)) ^
556              ((unsigned int)(l->block_ref_from->dev_bytenr >> 16)) ^
557              ((unsigned int)((uintptr_t)l->block_ref_to->dev_state->bdev)) ^
558              ((unsigned int)((uintptr_t)l->block_ref_from->dev_state->bdev)))
559              & (BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE - 1);
560
561         BUG_ON(NULL == l->block_ref_to);
562         BUG_ON(NULL == l->block_ref_from);
563         list_add(&l->collision_resolving_node, h->table + hashval);
564 }
565
566 static void btrfsic_block_link_hashtable_remove(struct btrfsic_block_link *l)
567 {
568         list_del(&l->collision_resolving_node);
569 }
570
571 static struct btrfsic_block_link *btrfsic_block_link_hashtable_lookup(
572                 struct block_device *bdev_ref_to,
573                 u64 dev_bytenr_ref_to,
574                 struct block_device *bdev_ref_from,
575                 u64 dev_bytenr_ref_from,
576                 struct btrfsic_block_link_hashtable *h)
577 {
578         const unsigned int hashval =
579             (((unsigned int)(dev_bytenr_ref_to >> 16)) ^
580              ((unsigned int)(dev_bytenr_ref_from >> 16)) ^
581              ((unsigned int)((uintptr_t)bdev_ref_to)) ^
582              ((unsigned int)((uintptr_t)bdev_ref_from))) &
583              (BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE - 1);
584         struct list_head *elem;
585
586         list_for_each(elem, h->table + hashval) {
587                 struct btrfsic_block_link *const l =
588                     list_entry(elem, struct btrfsic_block_link,
589                                collision_resolving_node);
590
591                 BUG_ON(NULL == l->block_ref_to);
592                 BUG_ON(NULL == l->block_ref_from);
593                 if (l->block_ref_to->dev_state->bdev == bdev_ref_to &&
594                     l->block_ref_to->dev_bytenr == dev_bytenr_ref_to &&
595                     l->block_ref_from->dev_state->bdev == bdev_ref_from &&
596                     l->block_ref_from->dev_bytenr == dev_bytenr_ref_from)
597                         return l;
598         }
599
600         return NULL;
601 }
602
603 static void btrfsic_dev_state_hashtable_init(
604                 struct btrfsic_dev_state_hashtable *h)
605 {
606         int i;
607
608         for (i = 0; i < BTRFSIC_DEV2STATE_HASHTABLE_SIZE; i++)
609                 INIT_LIST_HEAD(h->table + i);
610 }
611
612 static void btrfsic_dev_state_hashtable_add(
613                 struct btrfsic_dev_state *ds,
614                 struct btrfsic_dev_state_hashtable *h)
615 {
616         const unsigned int hashval =
617             (((unsigned int)((uintptr_t)ds->bdev)) &
618              (BTRFSIC_DEV2STATE_HASHTABLE_SIZE - 1));
619
620         list_add(&ds->collision_resolving_node, h->table + hashval);
621 }
622
623 static void btrfsic_dev_state_hashtable_remove(struct btrfsic_dev_state *ds)
624 {
625         list_del(&ds->collision_resolving_node);
626 }
627
628 static struct btrfsic_dev_state *btrfsic_dev_state_hashtable_lookup(
629                 struct block_device *bdev,
630                 struct btrfsic_dev_state_hashtable *h)
631 {
632         const unsigned int hashval =
633             (((unsigned int)((uintptr_t)bdev)) &
634              (BTRFSIC_DEV2STATE_HASHTABLE_SIZE - 1));
635         struct list_head *elem;
636
637         list_for_each(elem, h->table + hashval) {
638                 struct btrfsic_dev_state *const ds =
639                     list_entry(elem, struct btrfsic_dev_state,
640                                collision_resolving_node);
641
642                 if (ds->bdev == bdev)
643                         return ds;
644         }
645
646         return NULL;
647 }
648
649 static int btrfsic_process_superblock(struct btrfsic_state *state,
650                                       struct btrfs_fs_devices *fs_devices)
651 {
652         int ret = 0;
653         struct btrfs_super_block *selected_super;
654         struct list_head *dev_head = &fs_devices->devices;
655         struct btrfs_device *device;
656         struct btrfsic_dev_state *selected_dev_state = NULL;
657         int pass;
658
659         BUG_ON(NULL == state);
660         selected_super = kzalloc(sizeof(*selected_super), GFP_NOFS);
661         if (NULL == selected_super) {
662                 printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");
663                 return -1;
664         }
665
666         list_for_each_entry(device, dev_head, dev_list) {
667                 int i;
668                 struct btrfsic_dev_state *dev_state;
669
670                 if (!device->bdev || !device->name)
671                         continue;
672
673                 dev_state = btrfsic_dev_state_lookup(device->bdev);
674                 BUG_ON(NULL == dev_state);
675                 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
676                         ret = btrfsic_process_superblock_dev_mirror(
677                                         state, dev_state, device, i,
678                                         &selected_dev_state, selected_super);
679                         if (0 != ret && 0 == i) {
680                                 kfree(selected_super);
681                                 return ret;
682                         }
683                 }
684         }
685
686         if (NULL == state->latest_superblock) {
687                 printk(KERN_INFO "btrfsic: no superblock found!\n");
688                 kfree(selected_super);
689                 return -1;
690         }
691
692         state->csum_size = btrfs_super_csum_size(selected_super);
693
694         for (pass = 0; pass < 3; pass++) {
695                 int num_copies;
696                 int mirror_num;
697                 u64 next_bytenr;
698
699                 switch (pass) {
700                 case 0:
701                         next_bytenr = btrfs_super_root(selected_super);
702                         if (state->print_mask &
703                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
704                                 printk(KERN_INFO "root@%llu\n",
705                                        (unsigned long long)next_bytenr);
706                         break;
707                 case 1:
708                         next_bytenr = btrfs_super_chunk_root(selected_super);
709                         if (state->print_mask &
710                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
711                                 printk(KERN_INFO "chunk@%llu\n",
712                                        (unsigned long long)next_bytenr);
713                         break;
714                 case 2:
715                         next_bytenr = btrfs_super_log_root(selected_super);
716                         if (0 == next_bytenr)
717                                 continue;
718                         if (state->print_mask &
719                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
720                                 printk(KERN_INFO "log@%llu\n",
721                                        (unsigned long long)next_bytenr);
722                         break;
723                 }
724
725                 num_copies =
726                     btrfs_num_copies(&state->root->fs_info->mapping_tree,
727                                      next_bytenr, state->metablock_size);
728                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
729                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
730                                (unsigned long long)next_bytenr, num_copies);
731
732                 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
733                         struct btrfsic_block *next_block;
734                         struct btrfsic_block_data_ctx tmp_next_block_ctx;
735                         struct btrfsic_block_link *l;
736
737                         ret = btrfsic_map_block(state, next_bytenr,
738                                                 state->metablock_size,
739                                                 &tmp_next_block_ctx,
740                                                 mirror_num);
741                         if (ret) {
742                                 printk(KERN_INFO "btrfsic:"
743                                        " btrfsic_map_block(root @%llu,"
744                                        " mirror %d) failed!\n",
745                                        (unsigned long long)next_bytenr,
746                                        mirror_num);
747                                 kfree(selected_super);
748                                 return -1;
749                         }
750
751                         next_block = btrfsic_block_hashtable_lookup(
752                                         tmp_next_block_ctx.dev->bdev,
753                                         tmp_next_block_ctx.dev_bytenr,
754                                         &state->block_hashtable);
755                         BUG_ON(NULL == next_block);
756
757                         l = btrfsic_block_link_hashtable_lookup(
758                                         tmp_next_block_ctx.dev->bdev,
759                                         tmp_next_block_ctx.dev_bytenr,
760                                         state->latest_superblock->dev_state->
761                                         bdev,
762                                         state->latest_superblock->dev_bytenr,
763                                         &state->block_link_hashtable);
764                         BUG_ON(NULL == l);
765
766                         ret = btrfsic_read_block(state, &tmp_next_block_ctx);
767                         if (ret < (int)PAGE_CACHE_SIZE) {
768                                 printk(KERN_INFO
769                                        "btrfsic: read @logical %llu failed!\n",
770                                        (unsigned long long)
771                                        tmp_next_block_ctx.start);
772                                 btrfsic_release_block_ctx(&tmp_next_block_ctx);
773                                 kfree(selected_super);
774                                 return -1;
775                         }
776
777                         ret = btrfsic_process_metablock(state,
778                                                         next_block,
779                                                         &tmp_next_block_ctx,
780                                                         BTRFS_MAX_LEVEL + 3, 1);
781                         btrfsic_release_block_ctx(&tmp_next_block_ctx);
782                 }
783         }
784
785         kfree(selected_super);
786         return ret;
787 }
788
789 static int btrfsic_process_superblock_dev_mirror(
790                 struct btrfsic_state *state,
791                 struct btrfsic_dev_state *dev_state,
792                 struct btrfs_device *device,
793                 int superblock_mirror_num,
794                 struct btrfsic_dev_state **selected_dev_state,
795                 struct btrfs_super_block *selected_super)
796 {
797         struct btrfs_super_block *super_tmp;
798         u64 dev_bytenr;
799         struct buffer_head *bh;
800         struct btrfsic_block *superblock_tmp;
801         int pass;
802         struct block_device *const superblock_bdev = device->bdev;
803
804         /* super block bytenr is always the unmapped device bytenr */
805         dev_bytenr = btrfs_sb_offset(superblock_mirror_num);
806         if (dev_bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)
807                 return -1;
808         bh = __bread(superblock_bdev, dev_bytenr / 4096,
809                      BTRFS_SUPER_INFO_SIZE);
810         if (NULL == bh)
811                 return -1;
812         super_tmp = (struct btrfs_super_block *)
813             (bh->b_data + (dev_bytenr & 4095));
814
815         if (btrfs_super_bytenr(super_tmp) != dev_bytenr ||
816             strncmp((char *)(&(super_tmp->magic)), BTRFS_MAGIC,
817                     sizeof(super_tmp->magic)) ||
818             memcmp(device->uuid, super_tmp->dev_item.uuid, BTRFS_UUID_SIZE) ||
819             btrfs_super_nodesize(super_tmp) != state->metablock_size ||
820             btrfs_super_leafsize(super_tmp) != state->metablock_size ||
821             btrfs_super_sectorsize(super_tmp) != state->datablock_size) {
822                 brelse(bh);
823                 return 0;
824         }
825
826         superblock_tmp =
827             btrfsic_block_hashtable_lookup(superblock_bdev,
828                                            dev_bytenr,
829                                            &state->block_hashtable);
830         if (NULL == superblock_tmp) {
831                 superblock_tmp = btrfsic_block_alloc();
832                 if (NULL == superblock_tmp) {
833                         printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");
834                         brelse(bh);
835                         return -1;
836                 }
837                 /* for superblock, only the dev_bytenr makes sense */
838                 superblock_tmp->dev_bytenr = dev_bytenr;
839                 superblock_tmp->dev_state = dev_state;
840                 superblock_tmp->logical_bytenr = dev_bytenr;
841                 superblock_tmp->generation = btrfs_super_generation(super_tmp);
842                 superblock_tmp->is_metadata = 1;
843                 superblock_tmp->is_superblock = 1;
844                 superblock_tmp->is_iodone = 1;
845                 superblock_tmp->never_written = 0;
846                 superblock_tmp->mirror_num = 1 + superblock_mirror_num;
847                 if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)
848                         printk_in_rcu(KERN_INFO "New initial S-block (bdev %p, %s)"
849                                      " @%llu (%s/%llu/%d)\n",
850                                      superblock_bdev,
851                                      rcu_str_deref(device->name),
852                                      (unsigned long long)dev_bytenr,
853                                      dev_state->name,
854                                      (unsigned long long)dev_bytenr,
855                                      superblock_mirror_num);
856                 list_add(&superblock_tmp->all_blocks_node,
857                          &state->all_blocks_list);
858                 btrfsic_block_hashtable_add(superblock_tmp,
859                                             &state->block_hashtable);
860         }
861
862         /* select the one with the highest generation field */
863         if (btrfs_super_generation(super_tmp) >
864             state->max_superblock_generation ||
865             0 == state->max_superblock_generation) {
866                 memcpy(selected_super, super_tmp, sizeof(*selected_super));
867                 *selected_dev_state = dev_state;
868                 state->max_superblock_generation =
869                     btrfs_super_generation(super_tmp);
870                 state->latest_superblock = superblock_tmp;
871         }
872
873         for (pass = 0; pass < 3; pass++) {
874                 u64 next_bytenr;
875                 int num_copies;
876                 int mirror_num;
877                 const char *additional_string = NULL;
878                 struct btrfs_disk_key tmp_disk_key;
879
880                 tmp_disk_key.type = BTRFS_ROOT_ITEM_KEY;
881                 tmp_disk_key.offset = 0;
882                 switch (pass) {
883                 case 0:
884                         tmp_disk_key.objectid =
885                             cpu_to_le64(BTRFS_ROOT_TREE_OBJECTID);
886                         additional_string = "initial root ";
887                         next_bytenr = btrfs_super_root(super_tmp);
888                         break;
889                 case 1:
890                         tmp_disk_key.objectid =
891                             cpu_to_le64(BTRFS_CHUNK_TREE_OBJECTID);
892                         additional_string = "initial chunk ";
893                         next_bytenr = btrfs_super_chunk_root(super_tmp);
894                         break;
895                 case 2:
896                         tmp_disk_key.objectid =
897                             cpu_to_le64(BTRFS_TREE_LOG_OBJECTID);
898                         additional_string = "initial log ";
899                         next_bytenr = btrfs_super_log_root(super_tmp);
900                         if (0 == next_bytenr)
901                                 continue;
902                         break;
903                 }
904
905                 num_copies =
906                     btrfs_num_copies(&state->root->fs_info->mapping_tree,
907                                      next_bytenr, state->metablock_size);
908                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
909                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
910                                (unsigned long long)next_bytenr, num_copies);
911                 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
912                         struct btrfsic_block *next_block;
913                         struct btrfsic_block_data_ctx tmp_next_block_ctx;
914                         struct btrfsic_block_link *l;
915
916                         if (btrfsic_map_block(state, next_bytenr,
917                                               state->metablock_size,
918                                               &tmp_next_block_ctx,
919                                               mirror_num)) {
920                                 printk(KERN_INFO "btrfsic: btrfsic_map_block("
921                                        "bytenr @%llu, mirror %d) failed!\n",
922                                        (unsigned long long)next_bytenr,
923                                        mirror_num);
924                                 brelse(bh);
925                                 return -1;
926                         }
927
928                         next_block = btrfsic_block_lookup_or_add(
929                                         state, &tmp_next_block_ctx,
930                                         additional_string, 1, 1, 0,
931                                         mirror_num, NULL);
932                         if (NULL == next_block) {
933                                 btrfsic_release_block_ctx(&tmp_next_block_ctx);
934                                 brelse(bh);
935                                 return -1;
936                         }
937
938                         next_block->disk_key = tmp_disk_key;
939                         next_block->generation = BTRFSIC_GENERATION_UNKNOWN;
940                         l = btrfsic_block_link_lookup_or_add(
941                                         state, &tmp_next_block_ctx,
942                                         next_block, superblock_tmp,
943                                         BTRFSIC_GENERATION_UNKNOWN);
944                         btrfsic_release_block_ctx(&tmp_next_block_ctx);
945                         if (NULL == l) {
946                                 brelse(bh);
947                                 return -1;
948                         }
949                 }
950         }
951         if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_ALL_TREES)
952                 btrfsic_dump_tree_sub(state, superblock_tmp, 0);
953
954         brelse(bh);
955         return 0;
956 }
957
958 static struct btrfsic_stack_frame *btrfsic_stack_frame_alloc(void)
959 {
960         struct btrfsic_stack_frame *sf;
961
962         sf = kzalloc(sizeof(*sf), GFP_NOFS);
963         if (NULL == sf)
964                 printk(KERN_INFO "btrfsic: alloc memory failed!\n");
965         else
966                 sf->magic = BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER;
967         return sf;
968 }
969
970 static void btrfsic_stack_frame_free(struct btrfsic_stack_frame *sf)
971 {
972         BUG_ON(!(NULL == sf ||
973                  BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER == sf->magic));
974         kfree(sf);
975 }
976
977 static int btrfsic_process_metablock(
978                 struct btrfsic_state *state,
979                 struct btrfsic_block *const first_block,
980                 struct btrfsic_block_data_ctx *const first_block_ctx,
981                 int first_limit_nesting, int force_iodone_flag)
982 {
983         struct btrfsic_stack_frame initial_stack_frame = { 0 };
984         struct btrfsic_stack_frame *sf;
985         struct btrfsic_stack_frame *next_stack;
986         struct btrfs_header *const first_hdr =
987                 (struct btrfs_header *)first_block_ctx->datav[0];
988
989         BUG_ON(!first_hdr);
990         sf = &initial_stack_frame;
991         sf->error = 0;
992         sf->i = -1;
993         sf->limit_nesting = first_limit_nesting;
994         sf->block = first_block;
995         sf->block_ctx = first_block_ctx;
996         sf->next_block = NULL;
997         sf->hdr = first_hdr;
998         sf->prev = NULL;
999
1000 continue_with_new_stack_frame:
1001         sf->block->generation = le64_to_cpu(sf->hdr->generation);
1002         if (0 == sf->hdr->level) {
1003                 struct btrfs_leaf *const leafhdr =
1004                     (struct btrfs_leaf *)sf->hdr;
1005
1006                 if (-1 == sf->i) {
1007                         sf->nr = le32_to_cpu(leafhdr->header.nritems);
1008
1009                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1010                                 printk(KERN_INFO
1011                                        "leaf %llu items %d generation %llu"
1012                                        " owner %llu\n",
1013                                        (unsigned long long)
1014                                        sf->block_ctx->start,
1015                                        sf->nr,
1016                                        (unsigned long long)
1017                                        le64_to_cpu(leafhdr->header.generation),
1018                                        (unsigned long long)
1019                                        le64_to_cpu(leafhdr->header.owner));
1020                 }
1021
1022 continue_with_current_leaf_stack_frame:
1023                 if (0 == sf->num_copies || sf->mirror_num > sf->num_copies) {
1024                         sf->i++;
1025                         sf->num_copies = 0;
1026                 }
1027
1028                 if (sf->i < sf->nr) {
1029                         struct btrfs_item disk_item;
1030                         u32 disk_item_offset =
1031                                 (uintptr_t)(leafhdr->items + sf->i) -
1032                                 (uintptr_t)leafhdr;
1033                         struct btrfs_disk_key *disk_key;
1034                         u8 type;
1035                         u32 item_offset;
1036                         u32 item_size;
1037
1038                         if (disk_item_offset + sizeof(struct btrfs_item) >
1039                             sf->block_ctx->len) {
1040 leaf_item_out_of_bounce_error:
1041                                 printk(KERN_INFO
1042                                        "btrfsic: leaf item out of bounce at logical %llu, dev %s\n",
1043                                        sf->block_ctx->start,
1044                                        sf->block_ctx->dev->name);
1045                                 goto one_stack_frame_backwards;
1046                         }
1047                         btrfsic_read_from_block_data(sf->block_ctx,
1048                                                      &disk_item,
1049                                                      disk_item_offset,
1050                                                      sizeof(struct btrfs_item));
1051                         item_offset = le32_to_cpu(disk_item.offset);
1052                         item_size = le32_to_cpu(disk_item.size);
1053                         disk_key = &disk_item.key;
1054                         type = disk_key->type;
1055
1056                         if (BTRFS_ROOT_ITEM_KEY == type) {
1057                                 struct btrfs_root_item root_item;
1058                                 u32 root_item_offset;
1059                                 u64 next_bytenr;
1060
1061                                 root_item_offset = item_offset +
1062                                         offsetof(struct btrfs_leaf, items);
1063                                 if (root_item_offset + item_size >
1064                                     sf->block_ctx->len)
1065                                         goto leaf_item_out_of_bounce_error;
1066                                 btrfsic_read_from_block_data(
1067                                         sf->block_ctx, &root_item,
1068                                         root_item_offset,
1069                                         item_size);
1070                                 next_bytenr = le64_to_cpu(root_item.bytenr);
1071
1072                                 sf->error =
1073                                     btrfsic_create_link_to_next_block(
1074                                                 state,
1075                                                 sf->block,
1076                                                 sf->block_ctx,
1077                                                 next_bytenr,
1078                                                 sf->limit_nesting,
1079                                                 &sf->next_block_ctx,
1080                                                 &sf->next_block,
1081                                                 force_iodone_flag,
1082                                                 &sf->num_copies,
1083                                                 &sf->mirror_num,
1084                                                 disk_key,
1085                                                 le64_to_cpu(root_item.
1086                                                 generation));
1087                                 if (sf->error)
1088                                         goto one_stack_frame_backwards;
1089
1090                                 if (NULL != sf->next_block) {
1091                                         struct btrfs_header *const next_hdr =
1092                                             (struct btrfs_header *)
1093                                             sf->next_block_ctx.datav[0];
1094
1095                                         next_stack =
1096                                             btrfsic_stack_frame_alloc();
1097                                         if (NULL == next_stack) {
1098                                                 btrfsic_release_block_ctx(
1099                                                                 &sf->
1100                                                                 next_block_ctx);
1101                                                 goto one_stack_frame_backwards;
1102                                         }
1103
1104                                         next_stack->i = -1;
1105                                         next_stack->block = sf->next_block;
1106                                         next_stack->block_ctx =
1107                                             &sf->next_block_ctx;
1108                                         next_stack->next_block = NULL;
1109                                         next_stack->hdr = next_hdr;
1110                                         next_stack->limit_nesting =
1111                                             sf->limit_nesting - 1;
1112                                         next_stack->prev = sf;
1113                                         sf = next_stack;
1114                                         goto continue_with_new_stack_frame;
1115                                 }
1116                         } else if (BTRFS_EXTENT_DATA_KEY == type &&
1117                                    state->include_extent_data) {
1118                                 sf->error = btrfsic_handle_extent_data(
1119                                                 state,
1120                                                 sf->block,
1121                                                 sf->block_ctx,
1122                                                 item_offset,
1123                                                 force_iodone_flag);
1124                                 if (sf->error)
1125                                         goto one_stack_frame_backwards;
1126                         }
1127
1128                         goto continue_with_current_leaf_stack_frame;
1129                 }
1130         } else {
1131                 struct btrfs_node *const nodehdr = (struct btrfs_node *)sf->hdr;
1132
1133                 if (-1 == sf->i) {
1134                         sf->nr = le32_to_cpu(nodehdr->header.nritems);
1135
1136                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1137                                 printk(KERN_INFO "node %llu level %d items %d"
1138                                        " generation %llu owner %llu\n",
1139                                        (unsigned long long)
1140                                        sf->block_ctx->start,
1141                                        nodehdr->header.level, sf->nr,
1142                                        (unsigned long long)
1143                                        le64_to_cpu(nodehdr->header.generation),
1144                                        (unsigned long long)
1145                                        le64_to_cpu(nodehdr->header.owner));
1146                 }
1147
1148 continue_with_current_node_stack_frame:
1149                 if (0 == sf->num_copies || sf->mirror_num > sf->num_copies) {
1150                         sf->i++;
1151                         sf->num_copies = 0;
1152                 }
1153
1154                 if (sf->i < sf->nr) {
1155                         struct btrfs_key_ptr key_ptr;
1156                         u32 key_ptr_offset;
1157                         u64 next_bytenr;
1158
1159                         key_ptr_offset = (uintptr_t)(nodehdr->ptrs + sf->i) -
1160                                           (uintptr_t)nodehdr;
1161                         if (key_ptr_offset + sizeof(struct btrfs_key_ptr) >
1162                             sf->block_ctx->len) {
1163                                 printk(KERN_INFO
1164                                        "btrfsic: node item out of bounce at logical %llu, dev %s\n",
1165                                        sf->block_ctx->start,
1166                                        sf->block_ctx->dev->name);
1167                                 goto one_stack_frame_backwards;
1168                         }
1169                         btrfsic_read_from_block_data(
1170                                 sf->block_ctx, &key_ptr, key_ptr_offset,
1171                                 sizeof(struct btrfs_key_ptr));
1172                         next_bytenr = le64_to_cpu(key_ptr.blockptr);
1173
1174                         sf->error = btrfsic_create_link_to_next_block(
1175                                         state,
1176                                         sf->block,
1177                                         sf->block_ctx,
1178                                         next_bytenr,
1179                                         sf->limit_nesting,
1180                                         &sf->next_block_ctx,
1181                                         &sf->next_block,
1182                                         force_iodone_flag,
1183                                         &sf->num_copies,
1184                                         &sf->mirror_num,
1185                                         &key_ptr.key,
1186                                         le64_to_cpu(key_ptr.generation));
1187                         if (sf->error)
1188                                 goto one_stack_frame_backwards;
1189
1190                         if (NULL != sf->next_block) {
1191                                 struct btrfs_header *const next_hdr =
1192                                     (struct btrfs_header *)
1193                                     sf->next_block_ctx.datav[0];
1194
1195                                 next_stack = btrfsic_stack_frame_alloc();
1196                                 if (NULL == next_stack)
1197                                         goto one_stack_frame_backwards;
1198
1199                                 next_stack->i = -1;
1200                                 next_stack->block = sf->next_block;
1201                                 next_stack->block_ctx = &sf->next_block_ctx;
1202                                 next_stack->next_block = NULL;
1203                                 next_stack->hdr = next_hdr;
1204                                 next_stack->limit_nesting =
1205                                     sf->limit_nesting - 1;
1206                                 next_stack->prev = sf;
1207                                 sf = next_stack;
1208                                 goto continue_with_new_stack_frame;
1209                         }
1210
1211                         goto continue_with_current_node_stack_frame;
1212                 }
1213         }
1214
1215 one_stack_frame_backwards:
1216         if (NULL != sf->prev) {
1217                 struct btrfsic_stack_frame *const prev = sf->prev;
1218
1219                 /* the one for the initial block is freed in the caller */
1220                 btrfsic_release_block_ctx(sf->block_ctx);
1221
1222                 if (sf->error) {
1223                         prev->error = sf->error;
1224                         btrfsic_stack_frame_free(sf);
1225                         sf = prev;
1226                         goto one_stack_frame_backwards;
1227                 }
1228
1229                 btrfsic_stack_frame_free(sf);
1230                 sf = prev;
1231                 goto continue_with_new_stack_frame;
1232         } else {
1233                 BUG_ON(&initial_stack_frame != sf);
1234         }
1235
1236         return sf->error;
1237 }
1238
1239 static void btrfsic_read_from_block_data(
1240         struct btrfsic_block_data_ctx *block_ctx,
1241         void *dstv, u32 offset, size_t len)
1242 {
1243         size_t cur;
1244         size_t offset_in_page;
1245         char *kaddr;
1246         char *dst = (char *)dstv;
1247         size_t start_offset = block_ctx->start & ((u64)PAGE_CACHE_SIZE - 1);
1248         unsigned long i = (start_offset + offset) >> PAGE_CACHE_SHIFT;
1249
1250         WARN_ON(offset + len > block_ctx->len);
1251         offset_in_page = (start_offset + offset) &
1252                          ((unsigned long)PAGE_CACHE_SIZE - 1);
1253
1254         while (len > 0) {
1255                 cur = min(len, ((size_t)PAGE_CACHE_SIZE - offset_in_page));
1256                 BUG_ON(i >= (block_ctx->len + PAGE_CACHE_SIZE - 1) >>
1257                             PAGE_CACHE_SHIFT);
1258                 kaddr = block_ctx->datav[i];
1259                 memcpy(dst, kaddr + offset_in_page, cur);
1260
1261                 dst += cur;
1262                 len -= cur;
1263                 offset_in_page = 0;
1264                 i++;
1265         }
1266 }
1267
1268 static int btrfsic_create_link_to_next_block(
1269                 struct btrfsic_state *state,
1270                 struct btrfsic_block *block,
1271                 struct btrfsic_block_data_ctx *block_ctx,
1272                 u64 next_bytenr,
1273                 int limit_nesting,
1274                 struct btrfsic_block_data_ctx *next_block_ctx,
1275                 struct btrfsic_block **next_blockp,
1276                 int force_iodone_flag,
1277                 int *num_copiesp, int *mirror_nump,
1278                 struct btrfs_disk_key *disk_key,
1279                 u64 parent_generation)
1280 {
1281         struct btrfsic_block *next_block = NULL;
1282         int ret;
1283         struct btrfsic_block_link *l;
1284         int did_alloc_block_link;
1285         int block_was_created;
1286
1287         *next_blockp = NULL;
1288         if (0 == *num_copiesp) {
1289                 *num_copiesp =
1290                     btrfs_num_copies(&state->root->fs_info->mapping_tree,
1291                                      next_bytenr, state->metablock_size);
1292                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
1293                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
1294                                (unsigned long long)next_bytenr, *num_copiesp);
1295                 *mirror_nump = 1;
1296         }
1297
1298         if (*mirror_nump > *num_copiesp)
1299                 return 0;
1300
1301         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1302                 printk(KERN_INFO
1303                        "btrfsic_create_link_to_next_block(mirror_num=%d)\n",
1304                        *mirror_nump);
1305         ret = btrfsic_map_block(state, next_bytenr,
1306                                 state->metablock_size,
1307                                 next_block_ctx, *mirror_nump);
1308         if (ret) {
1309                 printk(KERN_INFO
1310                        "btrfsic: btrfsic_map_block(@%llu, mirror=%d) failed!\n",
1311                        (unsigned long long)next_bytenr, *mirror_nump);
1312                 btrfsic_release_block_ctx(next_block_ctx);
1313                 *next_blockp = NULL;
1314                 return -1;
1315         }
1316
1317         next_block = btrfsic_block_lookup_or_add(state,
1318                                                  next_block_ctx, "referenced ",
1319                                                  1, force_iodone_flag,
1320                                                  !force_iodone_flag,
1321                                                  *mirror_nump,
1322                                                  &block_was_created);
1323         if (NULL == next_block) {
1324                 btrfsic_release_block_ctx(next_block_ctx);
1325                 *next_blockp = NULL;
1326                 return -1;
1327         }
1328         if (block_was_created) {
1329                 l = NULL;
1330                 next_block->generation = BTRFSIC_GENERATION_UNKNOWN;
1331         } else {
1332                 if (next_block->logical_bytenr != next_bytenr &&
1333                     !(!next_block->is_metadata &&
1334                       0 == next_block->logical_bytenr)) {
1335                         printk(KERN_INFO
1336                                "Referenced block @%llu (%s/%llu/%d)"
1337                                " found in hash table, %c,"
1338                                " bytenr mismatch (!= stored %llu).\n",
1339                                (unsigned long long)next_bytenr,
1340                                next_block_ctx->dev->name,
1341                                (unsigned long long)next_block_ctx->dev_bytenr,
1342                                *mirror_nump,
1343                                btrfsic_get_block_type(state, next_block),
1344                                (unsigned long long)next_block->logical_bytenr);
1345                 } else if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1346                         printk(KERN_INFO
1347                                "Referenced block @%llu (%s/%llu/%d)"
1348                                " found in hash table, %c.\n",
1349                                (unsigned long long)next_bytenr,
1350                                next_block_ctx->dev->name,
1351                                (unsigned long long)next_block_ctx->dev_bytenr,
1352                                *mirror_nump,
1353                                btrfsic_get_block_type(state, next_block));
1354                 next_block->logical_bytenr = next_bytenr;
1355
1356                 next_block->mirror_num = *mirror_nump;
1357                 l = btrfsic_block_link_hashtable_lookup(
1358                                 next_block_ctx->dev->bdev,
1359                                 next_block_ctx->dev_bytenr,
1360                                 block_ctx->dev->bdev,
1361                                 block_ctx->dev_bytenr,
1362                                 &state->block_link_hashtable);
1363         }
1364
1365         next_block->disk_key = *disk_key;
1366         if (NULL == l) {
1367                 l = btrfsic_block_link_alloc();
1368                 if (NULL == l) {
1369                         printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");
1370                         btrfsic_release_block_ctx(next_block_ctx);
1371                         *next_blockp = NULL;
1372                         return -1;
1373                 }
1374
1375                 did_alloc_block_link = 1;
1376                 l->block_ref_to = next_block;
1377                 l->block_ref_from = block;
1378                 l->ref_cnt = 1;
1379                 l->parent_generation = parent_generation;
1380
1381                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1382                         btrfsic_print_add_link(state, l);
1383
1384                 list_add(&l->node_ref_to, &block->ref_to_list);
1385                 list_add(&l->node_ref_from, &next_block->ref_from_list);
1386
1387                 btrfsic_block_link_hashtable_add(l,
1388                                                  &state->block_link_hashtable);
1389         } else {
1390                 did_alloc_block_link = 0;
1391                 if (0 == limit_nesting) {
1392                         l->ref_cnt++;
1393                         l->parent_generation = parent_generation;
1394                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1395                                 btrfsic_print_add_link(state, l);
1396                 }
1397         }
1398
1399         if (limit_nesting > 0 && did_alloc_block_link) {
1400                 ret = btrfsic_read_block(state, next_block_ctx);
1401                 if (ret < (int)next_block_ctx->len) {
1402                         printk(KERN_INFO
1403                                "btrfsic: read block @logical %llu failed!\n",
1404                                (unsigned long long)next_bytenr);
1405                         btrfsic_release_block_ctx(next_block_ctx);
1406                         *next_blockp = NULL;
1407                         return -1;
1408                 }
1409
1410                 *next_blockp = next_block;
1411         } else {
1412                 *next_blockp = NULL;
1413         }
1414         (*mirror_nump)++;
1415
1416         return 0;
1417 }
1418
1419 static int btrfsic_handle_extent_data(
1420                 struct btrfsic_state *state,
1421                 struct btrfsic_block *block,
1422                 struct btrfsic_block_data_ctx *block_ctx,
1423                 u32 item_offset, int force_iodone_flag)
1424 {
1425         int ret;
1426         struct btrfs_file_extent_item file_extent_item;
1427         u64 file_extent_item_offset;
1428         u64 next_bytenr;
1429         u64 num_bytes;
1430         u64 generation;
1431         struct btrfsic_block_link *l;
1432
1433         file_extent_item_offset = offsetof(struct btrfs_leaf, items) +
1434                                   item_offset;
1435         if (file_extent_item_offset +
1436             offsetof(struct btrfs_file_extent_item, disk_num_bytes) >
1437             block_ctx->len) {
1438                 printk(KERN_INFO
1439                        "btrfsic: file item out of bounce at logical %llu, dev %s\n",
1440                        block_ctx->start, block_ctx->dev->name);
1441                 return -1;
1442         }
1443
1444         btrfsic_read_from_block_data(block_ctx, &file_extent_item,
1445                 file_extent_item_offset,
1446                 offsetof(struct btrfs_file_extent_item, disk_num_bytes));
1447         if (BTRFS_FILE_EXTENT_REG != file_extent_item.type ||
1448             ((u64)0) == le64_to_cpu(file_extent_item.disk_bytenr)) {
1449                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE)
1450                         printk(KERN_INFO "extent_data: type %u, disk_bytenr = %llu\n",
1451                                file_extent_item.type,
1452                                (unsigned long long)
1453                                le64_to_cpu(file_extent_item.disk_bytenr));
1454                 return 0;
1455         }
1456
1457         if (file_extent_item_offset + sizeof(struct btrfs_file_extent_item) >
1458             block_ctx->len) {
1459                 printk(KERN_INFO
1460                        "btrfsic: file item out of bounce at logical %llu, dev %s\n",
1461                        block_ctx->start, block_ctx->dev->name);
1462                 return -1;
1463         }
1464         btrfsic_read_from_block_data(block_ctx, &file_extent_item,
1465                                      file_extent_item_offset,
1466                                      sizeof(struct btrfs_file_extent_item));
1467         next_bytenr = le64_to_cpu(file_extent_item.disk_bytenr) +
1468                       le64_to_cpu(file_extent_item.offset);
1469         generation = le64_to_cpu(file_extent_item.generation);
1470         num_bytes = le64_to_cpu(file_extent_item.num_bytes);
1471         generation = le64_to_cpu(file_extent_item.generation);
1472
1473         if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE)
1474                 printk(KERN_INFO "extent_data: type %u, disk_bytenr = %llu,"
1475                        " offset = %llu, num_bytes = %llu\n",
1476                        file_extent_item.type,
1477                        (unsigned long long)
1478                        le64_to_cpu(file_extent_item.disk_bytenr),
1479                        (unsigned long long)le64_to_cpu(file_extent_item.offset),
1480                        (unsigned long long)num_bytes);
1481         while (num_bytes > 0) {
1482                 u32 chunk_len;
1483                 int num_copies;
1484                 int mirror_num;
1485
1486                 if (num_bytes > state->datablock_size)
1487                         chunk_len = state->datablock_size;
1488                 else
1489                         chunk_len = num_bytes;
1490
1491                 num_copies =
1492                     btrfs_num_copies(&state->root->fs_info->mapping_tree,
1493                                      next_bytenr, state->datablock_size);
1494                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
1495                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
1496                                (unsigned long long)next_bytenr, num_copies);
1497                 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
1498                         struct btrfsic_block_data_ctx next_block_ctx;
1499                         struct btrfsic_block *next_block;
1500                         int block_was_created;
1501
1502                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1503                                 printk(KERN_INFO "btrfsic_handle_extent_data("
1504                                        "mirror_num=%d)\n", mirror_num);
1505                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE)
1506                                 printk(KERN_INFO
1507                                        "\tdisk_bytenr = %llu, num_bytes %u\n",
1508                                        (unsigned long long)next_bytenr,
1509                                        chunk_len);
1510                         ret = btrfsic_map_block(state, next_bytenr,
1511                                                 chunk_len, &next_block_ctx,
1512                                                 mirror_num);
1513                         if (ret) {
1514                                 printk(KERN_INFO
1515                                        "btrfsic: btrfsic_map_block(@%llu,"
1516                                        " mirror=%d) failed!\n",
1517                                        (unsigned long long)next_bytenr,
1518                                        mirror_num);
1519                                 return -1;
1520                         }
1521
1522                         next_block = btrfsic_block_lookup_or_add(
1523                                         state,
1524                                         &next_block_ctx,
1525                                         "referenced ",
1526                                         0,
1527                                         force_iodone_flag,
1528                                         !force_iodone_flag,
1529                                         mirror_num,
1530                                         &block_was_created);
1531                         if (NULL == next_block) {
1532                                 printk(KERN_INFO
1533                                        "btrfsic: error, kmalloc failed!\n");
1534                                 btrfsic_release_block_ctx(&next_block_ctx);
1535                                 return -1;
1536                         }
1537                         if (!block_was_created) {
1538                                 if (next_block->logical_bytenr != next_bytenr &&
1539                                     !(!next_block->is_metadata &&
1540                                       0 == next_block->logical_bytenr)) {
1541                                         printk(KERN_INFO
1542                                                "Referenced block"
1543                                                " @%llu (%s/%llu/%d)"
1544                                                " found in hash table, D,"
1545                                                " bytenr mismatch"
1546                                                " (!= stored %llu).\n",
1547                                                (unsigned long long)next_bytenr,
1548                                                next_block_ctx.dev->name,
1549                                                (unsigned long long)
1550                                                next_block_ctx.dev_bytenr,
1551                                                mirror_num,
1552                                                (unsigned long long)
1553                                                next_block->logical_bytenr);
1554                                 }
1555                                 next_block->logical_bytenr = next_bytenr;
1556                                 next_block->mirror_num = mirror_num;
1557                         }
1558
1559                         l = btrfsic_block_link_lookup_or_add(state,
1560                                                              &next_block_ctx,
1561                                                              next_block, block,
1562                                                              generation);
1563                         btrfsic_release_block_ctx(&next_block_ctx);
1564                         if (NULL == l)
1565                                 return -1;
1566                 }
1567
1568                 next_bytenr += chunk_len;
1569                 num_bytes -= chunk_len;
1570         }
1571
1572         return 0;
1573 }
1574
1575 static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len,
1576                              struct btrfsic_block_data_ctx *block_ctx_out,
1577                              int mirror_num)
1578 {
1579         int ret;
1580         u64 length;
1581         struct btrfs_bio *multi = NULL;
1582         struct btrfs_device *device;
1583
1584         length = len;
1585         ret = btrfs_map_block(&state->root->fs_info->mapping_tree, READ,
1586                               bytenr, &length, &multi, mirror_num);
1587
1588         device = multi->stripes[0].dev;
1589         block_ctx_out->dev = btrfsic_dev_state_lookup(device->bdev);
1590         block_ctx_out->dev_bytenr = multi->stripes[0].physical;
1591         block_ctx_out->start = bytenr;
1592         block_ctx_out->len = len;
1593         block_ctx_out->datav = NULL;
1594         block_ctx_out->pagev = NULL;
1595         block_ctx_out->mem_to_free = NULL;
1596
1597         if (0 == ret)
1598                 kfree(multi);
1599         if (NULL == block_ctx_out->dev) {
1600                 ret = -ENXIO;
1601                 printk(KERN_INFO "btrfsic: error, cannot lookup dev (#1)!\n");
1602         }
1603
1604         return ret;
1605 }
1606
1607 static int btrfsic_map_superblock(struct btrfsic_state *state, u64 bytenr,
1608                                   u32 len, struct block_device *bdev,
1609                                   struct btrfsic_block_data_ctx *block_ctx_out)
1610 {
1611         block_ctx_out->dev = btrfsic_dev_state_lookup(bdev);
1612         block_ctx_out->dev_bytenr = bytenr;
1613         block_ctx_out->start = bytenr;
1614         block_ctx_out->len = len;
1615         block_ctx_out->datav = NULL;
1616         block_ctx_out->pagev = NULL;
1617         block_ctx_out->mem_to_free = NULL;
1618         if (NULL != block_ctx_out->dev) {
1619                 return 0;
1620         } else {
1621                 printk(KERN_INFO "btrfsic: error, cannot lookup dev (#2)!\n");
1622                 return -ENXIO;
1623         }
1624 }
1625
1626 static void btrfsic_release_block_ctx(struct btrfsic_block_data_ctx *block_ctx)
1627 {
1628         if (block_ctx->mem_to_free) {
1629                 unsigned int num_pages;
1630
1631                 BUG_ON(!block_ctx->datav);
1632                 BUG_ON(!block_ctx->pagev);
1633                 num_pages = (block_ctx->len + (u64)PAGE_CACHE_SIZE - 1) >>
1634                             PAGE_CACHE_SHIFT;
1635                 while (num_pages > 0) {
1636                         num_pages--;
1637                         if (block_ctx->datav[num_pages]) {
1638                                 kunmap(block_ctx->pagev[num_pages]);
1639                                 block_ctx->datav[num_pages] = NULL;
1640                         }
1641                         if (block_ctx->pagev[num_pages]) {
1642                                 __free_page(block_ctx->pagev[num_pages]);
1643                                 block_ctx->pagev[num_pages] = NULL;
1644                         }
1645                 }
1646
1647                 kfree(block_ctx->mem_to_free);
1648                 block_ctx->mem_to_free = NULL;
1649                 block_ctx->pagev = NULL;
1650                 block_ctx->datav = NULL;
1651         }
1652 }
1653
1654 static int btrfsic_read_block(struct btrfsic_state *state,
1655                               struct btrfsic_block_data_ctx *block_ctx)
1656 {
1657         unsigned int num_pages;
1658         unsigned int i;
1659         u64 dev_bytenr;
1660         int ret;
1661
1662         BUG_ON(block_ctx->datav);
1663         BUG_ON(block_ctx->pagev);
1664         BUG_ON(block_ctx->mem_to_free);
1665         if (block_ctx->dev_bytenr & ((u64)PAGE_CACHE_SIZE - 1)) {
1666                 printk(KERN_INFO
1667                        "btrfsic: read_block() with unaligned bytenr %llu\n",
1668                        (unsigned long long)block_ctx->dev_bytenr);
1669                 return -1;
1670         }
1671
1672         num_pages = (block_ctx->len + (u64)PAGE_CACHE_SIZE - 1) >>
1673                     PAGE_CACHE_SHIFT;
1674         block_ctx->mem_to_free = kzalloc((sizeof(*block_ctx->datav) +
1675                                           sizeof(*block_ctx->pagev)) *
1676                                          num_pages, GFP_NOFS);
1677         if (!block_ctx->mem_to_free)
1678                 return -1;
1679         block_ctx->datav = block_ctx->mem_to_free;
1680         block_ctx->pagev = (struct page **)(block_ctx->datav + num_pages);
1681         for (i = 0; i < num_pages; i++) {
1682                 block_ctx->pagev[i] = alloc_page(GFP_NOFS);
1683                 if (!block_ctx->pagev[i])
1684                         return -1;
1685         }
1686
1687         dev_bytenr = block_ctx->dev_bytenr;
1688         for (i = 0; i < num_pages;) {
1689                 struct bio *bio;
1690                 unsigned int j;
1691                 DECLARE_COMPLETION_ONSTACK(complete);
1692
1693                 bio = bio_alloc(GFP_NOFS, num_pages - i);
1694                 if (!bio) {
1695                         printk(KERN_INFO
1696                                "btrfsic: bio_alloc() for %u pages failed!\n",
1697                                num_pages - i);
1698                         return -1;
1699                 }
1700                 bio->bi_bdev = block_ctx->dev->bdev;
1701                 bio->bi_sector = dev_bytenr >> 9;
1702                 bio->bi_end_io = btrfsic_complete_bio_end_io;
1703                 bio->bi_private = &complete;
1704
1705                 for (j = i; j < num_pages; j++) {
1706                         ret = bio_add_page(bio, block_ctx->pagev[j],
1707                                            PAGE_CACHE_SIZE, 0);
1708                         if (PAGE_CACHE_SIZE != ret)
1709                                 break;
1710                 }
1711                 if (j == i) {
1712                         printk(KERN_INFO
1713                                "btrfsic: error, failed to add a single page!\n");
1714                         return -1;
1715                 }
1716                 submit_bio(READ, bio);
1717
1718                 /* this will also unplug the queue */
1719                 wait_for_completion(&complete);
1720
1721                 if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
1722                         printk(KERN_INFO
1723                                "btrfsic: read error at logical %llu dev %s!\n",
1724                                block_ctx->start, block_ctx->dev->name);
1725                         bio_put(bio);
1726                         return -1;
1727                 }
1728                 bio_put(bio);
1729                 dev_bytenr += (j - i) * PAGE_CACHE_SIZE;
1730                 i = j;
1731         }
1732         for (i = 0; i < num_pages; i++) {
1733                 block_ctx->datav[i] = kmap(block_ctx->pagev[i]);
1734                 if (!block_ctx->datav[i]) {
1735                         printk(KERN_INFO "btrfsic: kmap() failed (dev %s)!\n",
1736                                block_ctx->dev->name);
1737                         return -1;
1738                 }
1739         }
1740
1741         return block_ctx->len;
1742 }
1743
1744 static void btrfsic_complete_bio_end_io(struct bio *bio, int err)
1745 {
1746         complete((struct completion *)bio->bi_private);
1747 }
1748
1749 static void btrfsic_dump_database(struct btrfsic_state *state)
1750 {
1751         struct list_head *elem_all;
1752
1753         BUG_ON(NULL == state);
1754
1755         printk(KERN_INFO "all_blocks_list:\n");
1756         list_for_each(elem_all, &state->all_blocks_list) {
1757                 const struct btrfsic_block *const b_all =
1758                     list_entry(elem_all, struct btrfsic_block,
1759                                all_blocks_node);
1760                 struct list_head *elem_ref_to;
1761                 struct list_head *elem_ref_from;
1762
1763                 printk(KERN_INFO "%c-block @%llu (%s/%llu/%d)\n",
1764                        btrfsic_get_block_type(state, b_all),
1765                        (unsigned long long)b_all->logical_bytenr,
1766                        b_all->dev_state->name,
1767                        (unsigned long long)b_all->dev_bytenr,
1768                        b_all->mirror_num);
1769
1770                 list_for_each(elem_ref_to, &b_all->ref_to_list) {
1771                         const struct btrfsic_block_link *const l =
1772                             list_entry(elem_ref_to,
1773                                        struct btrfsic_block_link,
1774                                        node_ref_to);
1775
1776                         printk(KERN_INFO " %c @%llu (%s/%llu/%d)"
1777                                " refers %u* to"
1778                                " %c @%llu (%s/%llu/%d)\n",
1779                                btrfsic_get_block_type(state, b_all),
1780                                (unsigned long long)b_all->logical_bytenr,
1781                                b_all->dev_state->name,
1782                                (unsigned long long)b_all->dev_bytenr,
1783                                b_all->mirror_num,
1784                                l->ref_cnt,
1785                                btrfsic_get_block_type(state, l->block_ref_to),
1786                                (unsigned long long)
1787                                l->block_ref_to->logical_bytenr,
1788                                l->block_ref_to->dev_state->name,
1789                                (unsigned long long)l->block_ref_to->dev_bytenr,
1790                                l->block_ref_to->mirror_num);
1791                 }
1792
1793                 list_for_each(elem_ref_from, &b_all->ref_from_list) {
1794                         const struct btrfsic_block_link *const l =
1795                             list_entry(elem_ref_from,
1796                                        struct btrfsic_block_link,
1797                                        node_ref_from);
1798
1799                         printk(KERN_INFO " %c @%llu (%s/%llu/%d)"
1800                                " is ref %u* from"
1801                                " %c @%llu (%s/%llu/%d)\n",
1802                                btrfsic_get_block_type(state, b_all),
1803                                (unsigned long long)b_all->logical_bytenr,
1804                                b_all->dev_state->name,
1805                                (unsigned long long)b_all->dev_bytenr,
1806                                b_all->mirror_num,
1807                                l->ref_cnt,
1808                                btrfsic_get_block_type(state, l->block_ref_from),
1809                                (unsigned long long)
1810                                l->block_ref_from->logical_bytenr,
1811                                l->block_ref_from->dev_state->name,
1812                                (unsigned long long)
1813                                l->block_ref_from->dev_bytenr,
1814                                l->block_ref_from->mirror_num);
1815                 }
1816
1817                 printk(KERN_INFO "\n");
1818         }
1819 }
1820
1821 /*
1822  * Test whether the disk block contains a tree block (leaf or node)
1823  * (note that this test fails for the super block)
1824  */
1825 static int btrfsic_test_for_metadata(struct btrfsic_state *state,
1826                                      char **datav, unsigned int num_pages)
1827 {
1828         struct btrfs_header *h;
1829         u8 csum[BTRFS_CSUM_SIZE];
1830         u32 crc = ~(u32)0;
1831         unsigned int i;
1832
1833         if (num_pages * PAGE_CACHE_SIZE < state->metablock_size)
1834                 return 1; /* not metadata */
1835         num_pages = state->metablock_size >> PAGE_CACHE_SHIFT;
1836         h = (struct btrfs_header *)datav[0];
1837
1838         if (memcmp(h->fsid, state->root->fs_info->fsid, BTRFS_UUID_SIZE))
1839                 return 1;
1840
1841         for (i = 0; i < num_pages; i++) {
1842                 u8 *data = i ? datav[i] : (datav[i] + BTRFS_CSUM_SIZE);
1843                 size_t sublen = i ? PAGE_CACHE_SIZE :
1844                                     (PAGE_CACHE_SIZE - BTRFS_CSUM_SIZE);
1845
1846                 crc = crc32c(crc, data, sublen);
1847         }
1848         btrfs_csum_final(crc, csum);
1849         if (memcmp(csum, h->csum, state->csum_size))
1850                 return 1;
1851
1852         return 0; /* is metadata */
1853 }
1854
1855 static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state,
1856                                           u64 dev_bytenr, char **mapped_datav,
1857                                           unsigned int num_pages,
1858                                           struct bio *bio, int *bio_is_patched,
1859                                           struct buffer_head *bh,
1860                                           int submit_bio_bh_rw)
1861 {
1862         int is_metadata;
1863         struct btrfsic_block *block;
1864         struct btrfsic_block_data_ctx block_ctx;
1865         int ret;
1866         struct btrfsic_state *state = dev_state->state;
1867         struct block_device *bdev = dev_state->bdev;
1868         unsigned int processed_len;
1869
1870         if (NULL != bio_is_patched)
1871                 *bio_is_patched = 0;
1872
1873 again:
1874         if (num_pages == 0)
1875                 return;
1876
1877         processed_len = 0;
1878         is_metadata = (0 == btrfsic_test_for_metadata(state, mapped_datav,
1879                                                       num_pages));
1880
1881         block = btrfsic_block_hashtable_lookup(bdev, dev_bytenr,
1882                                                &state->block_hashtable);
1883         if (NULL != block) {
1884                 u64 bytenr = 0;
1885                 struct list_head *elem_ref_to;
1886                 struct list_head *tmp_ref_to;
1887
1888                 if (block->is_superblock) {
1889                         bytenr = le64_to_cpu(((struct btrfs_super_block *)
1890                                               mapped_datav[0])->bytenr);
1891                         if (num_pages * PAGE_CACHE_SIZE <
1892                             BTRFS_SUPER_INFO_SIZE) {
1893                                 printk(KERN_INFO
1894                                        "btrfsic: cannot work with too short bios!\n");
1895                                 return;
1896                         }
1897                         is_metadata = 1;
1898                         BUG_ON(BTRFS_SUPER_INFO_SIZE & (PAGE_CACHE_SIZE - 1));
1899                         processed_len = BTRFS_SUPER_INFO_SIZE;
1900                         if (state->print_mask &
1901                             BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE) {
1902                                 printk(KERN_INFO
1903                                        "[before new superblock is written]:\n");
1904                                 btrfsic_dump_tree_sub(state, block, 0);
1905                         }
1906                 }
1907                 if (is_metadata) {
1908                         if (!block->is_superblock) {
1909                                 if (num_pages * PAGE_CACHE_SIZE <
1910                                     state->metablock_size) {
1911                                         printk(KERN_INFO
1912                                                "btrfsic: cannot work with too short bios!\n");
1913                                         return;
1914                                 }
1915                                 processed_len = state->metablock_size;
1916                                 bytenr = le64_to_cpu(((struct btrfs_header *)
1917                                                       mapped_datav[0])->bytenr);
1918                                 btrfsic_cmp_log_and_dev_bytenr(state, bytenr,
1919                                                                dev_state,
1920                                                                dev_bytenr);
1921                         }
1922                         if (block->logical_bytenr != bytenr) {
1923                                 printk(KERN_INFO
1924                                        "Written block @%llu (%s/%llu/%d)"
1925                                        " found in hash table, %c,"
1926                                        " bytenr mismatch"
1927                                        " (!= stored %llu).\n",
1928                                        (unsigned long long)bytenr,
1929                                        dev_state->name,
1930                                        (unsigned long long)dev_bytenr,
1931                                        block->mirror_num,
1932                                        btrfsic_get_block_type(state, block),
1933                                        (unsigned long long)
1934                                        block->logical_bytenr);
1935                                 block->logical_bytenr = bytenr;
1936                         } else if (state->print_mask &
1937                                    BTRFSIC_PRINT_MASK_VERBOSE)
1938                                 printk(KERN_INFO
1939                                        "Written block @%llu (%s/%llu/%d)"
1940                                        " found in hash table, %c.\n",
1941                                        (unsigned long long)bytenr,
1942                                        dev_state->name,
1943                                        (unsigned long long)dev_bytenr,
1944                                        block->mirror_num,
1945                                        btrfsic_get_block_type(state, block));
1946                 } else {
1947                         if (num_pages * PAGE_CACHE_SIZE <
1948                             state->datablock_size) {
1949                                 printk(KERN_INFO
1950                                        "btrfsic: cannot work with too short bios!\n");
1951                                 return;
1952                         }
1953                         processed_len = state->datablock_size;
1954                         bytenr = block->logical_bytenr;
1955                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1956                                 printk(KERN_INFO
1957                                        "Written block @%llu (%s/%llu/%d)"
1958                                        " found in hash table, %c.\n",
1959                                        (unsigned long long)bytenr,
1960                                        dev_state->name,
1961                                        (unsigned long long)dev_bytenr,
1962                                        block->mirror_num,
1963                                        btrfsic_get_block_type(state, block));
1964                 }
1965
1966                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
1967                         printk(KERN_INFO
1968                                "ref_to_list: %cE, ref_from_list: %cE\n",
1969                                list_empty(&block->ref_to_list) ? ' ' : '!',
1970                                list_empty(&block->ref_from_list) ? ' ' : '!');
1971                 if (btrfsic_is_block_ref_by_superblock(state, block, 0)) {
1972                         printk(KERN_INFO "btrfs: attempt to overwrite %c-block"
1973                                " @%llu (%s/%llu/%d), old(gen=%llu,"
1974                                " objectid=%llu, type=%d, offset=%llu),"
1975                                " new(gen=%llu),"
1976                                " which is referenced by most recent superblock"
1977                                " (superblockgen=%llu)!\n",
1978                                btrfsic_get_block_type(state, block),
1979                                (unsigned long long)bytenr,
1980                                dev_state->name,
1981                                (unsigned long long)dev_bytenr,
1982                                block->mirror_num,
1983                                (unsigned long long)block->generation,
1984                                (unsigned long long)
1985                                le64_to_cpu(block->disk_key.objectid),
1986                                block->disk_key.type,
1987                                (unsigned long long)
1988                                le64_to_cpu(block->disk_key.offset),
1989                                (unsigned long long)
1990                                le64_to_cpu(((struct btrfs_header *)
1991                                             mapped_datav[0])->generation),
1992                                (unsigned long long)
1993                                state->max_superblock_generation);
1994                         btrfsic_dump_tree(state);
1995                 }
1996
1997                 if (!block->is_iodone && !block->never_written) {
1998                         printk(KERN_INFO "btrfs: attempt to overwrite %c-block"
1999                                " @%llu (%s/%llu/%d), oldgen=%llu, newgen=%llu,"
2000                                " which is not yet iodone!\n",
2001                                btrfsic_get_block_type(state, block),
2002                                (unsigned long long)bytenr,
2003                                dev_state->name,
2004                                (unsigned long long)dev_bytenr,
2005                                block->mirror_num,
2006                                (unsigned long long)block->generation,
2007                                (unsigned long long)
2008                                le64_to_cpu(((struct btrfs_header *)
2009                                             mapped_datav[0])->generation));
2010                         /* it would not be safe to go on */
2011                         btrfsic_dump_tree(state);
2012                         goto continue_loop;
2013                 }
2014
2015                 /*
2016                  * Clear all references of this block. Do not free
2017                  * the block itself even if is not referenced anymore
2018                  * because it still carries valueable information
2019                  * like whether it was ever written and IO completed.
2020                  */
2021                 list_for_each_safe(elem_ref_to, tmp_ref_to,
2022                                    &block->ref_to_list) {
2023                         struct btrfsic_block_link *const l =
2024                             list_entry(elem_ref_to,
2025                                        struct btrfsic_block_link,
2026                                        node_ref_to);
2027
2028                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2029                                 btrfsic_print_rem_link(state, l);
2030                         l->ref_cnt--;
2031                         if (0 == l->ref_cnt) {
2032                                 list_del(&l->node_ref_to);
2033                                 list_del(&l->node_ref_from);
2034                                 btrfsic_block_link_hashtable_remove(l);
2035                                 btrfsic_block_link_free(l);
2036                         }
2037                 }
2038
2039                 if (block->is_superblock)
2040                         ret = btrfsic_map_superblock(state, bytenr,
2041                                                      processed_len,
2042                                                      bdev, &block_ctx);
2043                 else
2044                         ret = btrfsic_map_block(state, bytenr, processed_len,
2045                                                 &block_ctx, 0);
2046                 if (ret) {
2047                         printk(KERN_INFO
2048                                "btrfsic: btrfsic_map_block(root @%llu)"
2049                                " failed!\n", (unsigned long long)bytenr);
2050                         goto continue_loop;
2051                 }
2052                 block_ctx.datav = mapped_datav;
2053                 /* the following is required in case of writes to mirrors,
2054                  * use the same that was used for the lookup */
2055                 block_ctx.dev = dev_state;
2056                 block_ctx.dev_bytenr = dev_bytenr;
2057
2058                 if (is_metadata || state->include_extent_data) {
2059                         block->never_written = 0;
2060                         block->iodone_w_error = 0;
2061                         if (NULL != bio) {
2062                                 block->is_iodone = 0;
2063                                 BUG_ON(NULL == bio_is_patched);
2064                                 if (!*bio_is_patched) {
2065                                         block->orig_bio_bh_private =
2066                                             bio->bi_private;
2067                                         block->orig_bio_bh_end_io.bio =
2068                                             bio->bi_end_io;
2069                                         block->next_in_same_bio = NULL;
2070                                         bio->bi_private = block;
2071                                         bio->bi_end_io = btrfsic_bio_end_io;
2072                                         *bio_is_patched = 1;
2073                                 } else {
2074                                         struct btrfsic_block *chained_block =
2075                                             (struct btrfsic_block *)
2076                                             bio->bi_private;
2077
2078                                         BUG_ON(NULL == chained_block);
2079                                         block->orig_bio_bh_private =
2080                                             chained_block->orig_bio_bh_private;
2081                                         block->orig_bio_bh_end_io.bio =
2082                                             chained_block->orig_bio_bh_end_io.
2083                                             bio;
2084                                         block->next_in_same_bio = chained_block;
2085                                         bio->bi_private = block;
2086                                 }
2087                         } else if (NULL != bh) {
2088                                 block->is_iodone = 0;
2089                                 block->orig_bio_bh_private = bh->b_private;
2090                                 block->orig_bio_bh_end_io.bh = bh->b_end_io;
2091                                 block->next_in_same_bio = NULL;
2092                                 bh->b_private = block;
2093                                 bh->b_end_io = btrfsic_bh_end_io;
2094                         } else {
2095                                 block->is_iodone = 1;
2096                                 block->orig_bio_bh_private = NULL;
2097                                 block->orig_bio_bh_end_io.bio = NULL;
2098                                 block->next_in_same_bio = NULL;
2099                         }
2100                 }
2101
2102                 block->flush_gen = dev_state->last_flush_gen + 1;
2103                 block->submit_bio_bh_rw = submit_bio_bh_rw;
2104                 if (is_metadata) {
2105                         block->logical_bytenr = bytenr;
2106                         block->is_metadata = 1;
2107                         if (block->is_superblock) {
2108                                 BUG_ON(PAGE_CACHE_SIZE !=
2109                                        BTRFS_SUPER_INFO_SIZE);
2110                                 ret = btrfsic_process_written_superblock(
2111                                                 state,
2112                                                 block,
2113                                                 (struct btrfs_super_block *)
2114                                                 mapped_datav[0]);
2115                                 if (state->print_mask &
2116                                     BTRFSIC_PRINT_MASK_TREE_AFTER_SB_WRITE) {
2117                                         printk(KERN_INFO
2118                                         "[after new superblock is written]:\n");
2119                                         btrfsic_dump_tree_sub(state, block, 0);
2120                                 }
2121                         } else {
2122                                 block->mirror_num = 0;  /* unknown */
2123                                 ret = btrfsic_process_metablock(
2124                                                 state,
2125                                                 block,
2126                                                 &block_ctx,
2127                                                 0, 0);
2128                         }
2129                         if (ret)
2130                                 printk(KERN_INFO
2131                                        "btrfsic: btrfsic_process_metablock"
2132                                        "(root @%llu) failed!\n",
2133                                        (unsigned long long)dev_bytenr);
2134                 } else {
2135                         block->is_metadata = 0;
2136                         block->mirror_num = 0;  /* unknown */
2137                         block->generation = BTRFSIC_GENERATION_UNKNOWN;
2138                         if (!state->include_extent_data
2139                             && list_empty(&block->ref_from_list)) {
2140                                 /*
2141                                  * disk block is overwritten with extent
2142                                  * data (not meta data) and we are configured
2143                                  * to not include extent data: take the
2144                                  * chance and free the block's memory
2145                                  */
2146                                 btrfsic_block_hashtable_remove(block);
2147                                 list_del(&block->all_blocks_node);
2148                                 btrfsic_block_free(block);
2149                         }
2150                 }
2151                 btrfsic_release_block_ctx(&block_ctx);
2152         } else {
2153                 /* block has not been found in hash table */
2154                 u64 bytenr;
2155
2156                 if (!is_metadata) {
2157                         processed_len = state->datablock_size;
2158                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2159                                 printk(KERN_INFO "Written block (%s/%llu/?)"
2160                                        " !found in hash table, D.\n",
2161                                        dev_state->name,
2162                                        (unsigned long long)dev_bytenr);
2163                         if (!state->include_extent_data) {
2164                                 /* ignore that written D block */
2165                                 goto continue_loop;
2166                         }
2167
2168                         /* this is getting ugly for the
2169                          * include_extent_data case... */
2170                         bytenr = 0;     /* unknown */
2171                         block_ctx.start = bytenr;
2172                         block_ctx.len = processed_len;
2173                         block_ctx.mem_to_free = NULL;
2174                         block_ctx.pagev = NULL;
2175                 } else {
2176                         processed_len = state->metablock_size;
2177                         bytenr = le64_to_cpu(((struct btrfs_header *)
2178                                               mapped_datav[0])->bytenr);
2179                         btrfsic_cmp_log_and_dev_bytenr(state, bytenr, dev_state,
2180                                                        dev_bytenr);
2181                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2182                                 printk(KERN_INFO
2183                                        "Written block @%llu (%s/%llu/?)"
2184                                        " !found in hash table, M.\n",
2185                                        (unsigned long long)bytenr,
2186                                        dev_state->name,
2187                                        (unsigned long long)dev_bytenr);
2188
2189                         ret = btrfsic_map_block(state, bytenr, processed_len,
2190                                                 &block_ctx, 0);
2191                         if (ret) {
2192                                 printk(KERN_INFO
2193                                        "btrfsic: btrfsic_map_block(root @%llu)"
2194                                        " failed!\n",
2195                                        (unsigned long long)dev_bytenr);
2196                                 goto continue_loop;
2197                         }
2198                 }
2199                 block_ctx.datav = mapped_datav;
2200                 /* the following is required in case of writes to mirrors,
2201                  * use the same that was used for the lookup */
2202                 block_ctx.dev = dev_state;
2203                 block_ctx.dev_bytenr = dev_bytenr;
2204
2205                 block = btrfsic_block_alloc();
2206                 if (NULL == block) {
2207                         printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");
2208                         btrfsic_release_block_ctx(&block_ctx);
2209                         goto continue_loop;
2210                 }
2211                 block->dev_state = dev_state;
2212                 block->dev_bytenr = dev_bytenr;
2213                 block->logical_bytenr = bytenr;
2214                 block->is_metadata = is_metadata;
2215                 block->never_written = 0;
2216                 block->iodone_w_error = 0;
2217                 block->mirror_num = 0;  /* unknown */
2218                 block->flush_gen = dev_state->last_flush_gen + 1;
2219                 block->submit_bio_bh_rw = submit_bio_bh_rw;
2220                 if (NULL != bio) {
2221                         block->is_iodone = 0;
2222                         BUG_ON(NULL == bio_is_patched);
2223                         if (!*bio_is_patched) {
2224                                 block->orig_bio_bh_private = bio->bi_private;
2225                                 block->orig_bio_bh_end_io.bio = bio->bi_end_io;
2226                                 block->next_in_same_bio = NULL;
2227                                 bio->bi_private = block;
2228                                 bio->bi_end_io = btrfsic_bio_end_io;
2229                                 *bio_is_patched = 1;
2230                         } else {
2231                                 struct btrfsic_block *chained_block =
2232                                     (struct btrfsic_block *)
2233                                     bio->bi_private;
2234
2235                                 BUG_ON(NULL == chained_block);
2236                                 block->orig_bio_bh_private =
2237                                     chained_block->orig_bio_bh_private;
2238                                 block->orig_bio_bh_end_io.bio =
2239                                     chained_block->orig_bio_bh_end_io.bio;
2240                                 block->next_in_same_bio = chained_block;
2241                                 bio->bi_private = block;
2242                         }
2243                 } else if (NULL != bh) {
2244                         block->is_iodone = 0;
2245                         block->orig_bio_bh_private = bh->b_private;
2246                         block->orig_bio_bh_end_io.bh = bh->b_end_io;
2247                         block->next_in_same_bio = NULL;
2248                         bh->b_private = block;
2249                         bh->b_end_io = btrfsic_bh_end_io;
2250                 } else {
2251                         block->is_iodone = 1;
2252                         block->orig_bio_bh_private = NULL;
2253                         block->orig_bio_bh_end_io.bio = NULL;
2254                         block->next_in_same_bio = NULL;
2255                 }
2256                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2257                         printk(KERN_INFO
2258                                "New written %c-block @%llu (%s/%llu/%d)\n",
2259                                is_metadata ? 'M' : 'D',
2260                                (unsigned long long)block->logical_bytenr,
2261                                block->dev_state->name,
2262                                (unsigned long long)block->dev_bytenr,
2263                                block->mirror_num);
2264                 list_add(&block->all_blocks_node, &state->all_blocks_list);
2265                 btrfsic_block_hashtable_add(block, &state->block_hashtable);
2266
2267                 if (is_metadata) {
2268                         ret = btrfsic_process_metablock(state, block,
2269                                                         &block_ctx, 0, 0);
2270                         if (ret)
2271                                 printk(KERN_INFO
2272                                        "btrfsic: process_metablock(root @%llu)"
2273                                        " failed!\n",
2274                                        (unsigned long long)dev_bytenr);
2275                 }
2276                 btrfsic_release_block_ctx(&block_ctx);
2277         }
2278
2279 continue_loop:
2280         BUG_ON(!processed_len);
2281         dev_bytenr += processed_len;
2282         mapped_datav += processed_len >> PAGE_CACHE_SHIFT;
2283         num_pages -= processed_len >> PAGE_CACHE_SHIFT;
2284         goto again;
2285 }
2286
2287 static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status)
2288 {
2289         struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private;
2290         int iodone_w_error;
2291
2292         /* mutex is not held! This is not save if IO is not yet completed
2293          * on umount */
2294         iodone_w_error = 0;
2295         if (bio_error_status)
2296                 iodone_w_error = 1;
2297
2298         BUG_ON(NULL == block);
2299         bp->bi_private = block->orig_bio_bh_private;
2300         bp->bi_end_io = block->orig_bio_bh_end_io.bio;
2301
2302         do {
2303                 struct btrfsic_block *next_block;
2304                 struct btrfsic_dev_state *const dev_state = block->dev_state;
2305
2306                 if ((dev_state->state->print_mask &
2307                      BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
2308                         printk(KERN_INFO
2309                                "bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n",
2310                                bio_error_status,
2311                                btrfsic_get_block_type(dev_state->state, block),
2312                                (unsigned long long)block->logical_bytenr,
2313                                dev_state->name,
2314                                (unsigned long long)block->dev_bytenr,
2315                                block->mirror_num);
2316                 next_block = block->next_in_same_bio;
2317                 block->iodone_w_error = iodone_w_error;
2318                 if (block->submit_bio_bh_rw & REQ_FLUSH) {
2319                         dev_state->last_flush_gen++;
2320                         if ((dev_state->state->print_mask &
2321                              BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
2322                                 printk(KERN_INFO
2323                                        "bio_end_io() new %s flush_gen=%llu\n",
2324                                        dev_state->name,
2325                                        (unsigned long long)
2326                                        dev_state->last_flush_gen);
2327                 }
2328                 if (block->submit_bio_bh_rw & REQ_FUA)
2329                         block->flush_gen = 0; /* FUA completed means block is
2330                                                * on disk */
2331                 block->is_iodone = 1; /* for FLUSH, this releases the block */
2332                 block = next_block;
2333         } while (NULL != block);
2334
2335         bp->bi_end_io(bp, bio_error_status);
2336 }
2337
2338 static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate)
2339 {
2340         struct btrfsic_block *block = (struct btrfsic_block *)bh->b_private;
2341         int iodone_w_error = !uptodate;
2342         struct btrfsic_dev_state *dev_state;
2343
2344         BUG_ON(NULL == block);
2345         dev_state = block->dev_state;
2346         if ((dev_state->state->print_mask & BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
2347                 printk(KERN_INFO
2348                        "bh_end_io(error=%d) for %c @%llu (%s/%llu/%d)\n",
2349                        iodone_w_error,
2350                        btrfsic_get_block_type(dev_state->state, block),
2351                        (unsigned long long)block->logical_bytenr,
2352                        block->dev_state->name,
2353                        (unsigned long long)block->dev_bytenr,
2354                        block->mirror_num);
2355
2356         block->iodone_w_error = iodone_w_error;
2357         if (block->submit_bio_bh_rw & REQ_FLUSH) {
2358                 dev_state->last_flush_gen++;
2359                 if ((dev_state->state->print_mask &
2360                      BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
2361                         printk(KERN_INFO
2362                                "bh_end_io() new %s flush_gen=%llu\n",
2363                                dev_state->name,
2364                                (unsigned long long)dev_state->last_flush_gen);
2365         }
2366         if (block->submit_bio_bh_rw & REQ_FUA)
2367                 block->flush_gen = 0; /* FUA completed means block is on disk */
2368
2369         bh->b_private = block->orig_bio_bh_private;
2370         bh->b_end_io = block->orig_bio_bh_end_io.bh;
2371         block->is_iodone = 1; /* for FLUSH, this releases the block */
2372         bh->b_end_io(bh, uptodate);
2373 }
2374
2375 static int btrfsic_process_written_superblock(
2376                 struct btrfsic_state *state,
2377                 struct btrfsic_block *const superblock,
2378                 struct btrfs_super_block *const super_hdr)
2379 {
2380         int pass;
2381
2382         superblock->generation = btrfs_super_generation(super_hdr);
2383         if (!(superblock->generation > state->max_superblock_generation ||
2384               0 == state->max_superblock_generation)) {
2385                 if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)
2386                         printk(KERN_INFO
2387                                "btrfsic: superblock @%llu (%s/%llu/%d)"
2388                                " with old gen %llu <= %llu\n",
2389                                (unsigned long long)superblock->logical_bytenr,
2390                                superblock->dev_state->name,
2391                                (unsigned long long)superblock->dev_bytenr,
2392                                superblock->mirror_num,
2393                                (unsigned long long)
2394                                btrfs_super_generation(super_hdr),
2395                                (unsigned long long)
2396                                state->max_superblock_generation);
2397         } else {
2398                 if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)
2399                         printk(KERN_INFO
2400                                "btrfsic: got new superblock @%llu (%s/%llu/%d)"
2401                                " with new gen %llu > %llu\n",
2402                                (unsigned long long)superblock->logical_bytenr,
2403                                superblock->dev_state->name,
2404                                (unsigned long long)superblock->dev_bytenr,
2405                                superblock->mirror_num,
2406                                (unsigned long long)
2407                                btrfs_super_generation(super_hdr),
2408                                (unsigned long long)
2409                                state->max_superblock_generation);
2410
2411                 state->max_superblock_generation =
2412                     btrfs_super_generation(super_hdr);
2413                 state->latest_superblock = superblock;
2414         }
2415
2416         for (pass = 0; pass < 3; pass++) {
2417                 int ret;
2418                 u64 next_bytenr;
2419                 struct btrfsic_block *next_block;
2420                 struct btrfsic_block_data_ctx tmp_next_block_ctx;
2421                 struct btrfsic_block_link *l;
2422                 int num_copies;
2423                 int mirror_num;
2424                 const char *additional_string = NULL;
2425                 struct btrfs_disk_key tmp_disk_key;
2426
2427                 tmp_disk_key.type = BTRFS_ROOT_ITEM_KEY;
2428                 tmp_disk_key.offset = 0;
2429
2430                 switch (pass) {
2431                 case 0:
2432                         tmp_disk_key.objectid =
2433                             cpu_to_le64(BTRFS_ROOT_TREE_OBJECTID);
2434                         additional_string = "root ";
2435                         next_bytenr = btrfs_super_root(super_hdr);
2436                         if (state->print_mask &
2437                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
2438                                 printk(KERN_INFO "root@%llu\n",
2439                                        (unsigned long long)next_bytenr);
2440                         break;
2441                 case 1:
2442                         tmp_disk_key.objectid =
2443                             cpu_to_le64(BTRFS_CHUNK_TREE_OBJECTID);
2444                         additional_string = "chunk ";
2445                         next_bytenr = btrfs_super_chunk_root(super_hdr);
2446                         if (state->print_mask &
2447                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
2448                                 printk(KERN_INFO "chunk@%llu\n",
2449                                        (unsigned long long)next_bytenr);
2450                         break;
2451                 case 2:
2452                         tmp_disk_key.objectid =
2453                             cpu_to_le64(BTRFS_TREE_LOG_OBJECTID);
2454                         additional_string = "log ";
2455                         next_bytenr = btrfs_super_log_root(super_hdr);
2456                         if (0 == next_bytenr)
2457                                 continue;
2458                         if (state->print_mask &
2459                             BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION)
2460                                 printk(KERN_INFO "log@%llu\n",
2461                                        (unsigned long long)next_bytenr);
2462                         break;
2463                 }
2464
2465                 num_copies =
2466                     btrfs_num_copies(&state->root->fs_info->mapping_tree,
2467                                      next_bytenr, BTRFS_SUPER_INFO_SIZE);
2468                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
2469                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
2470                                (unsigned long long)next_bytenr, num_copies);
2471                 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
2472                         int was_created;
2473
2474                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2475                                 printk(KERN_INFO
2476                                        "btrfsic_process_written_superblock("
2477                                        "mirror_num=%d)\n", mirror_num);
2478                         ret = btrfsic_map_block(state, next_bytenr,
2479                                                 BTRFS_SUPER_INFO_SIZE,
2480                                                 &tmp_next_block_ctx,
2481                                                 mirror_num);
2482                         if (ret) {
2483                                 printk(KERN_INFO
2484                                        "btrfsic: btrfsic_map_block(@%llu,"
2485                                        " mirror=%d) failed!\n",
2486                                        (unsigned long long)next_bytenr,
2487                                        mirror_num);
2488                                 return -1;
2489                         }
2490
2491                         next_block = btrfsic_block_lookup_or_add(
2492                                         state,
2493                                         &tmp_next_block_ctx,
2494                                         additional_string,
2495                                         1, 0, 1,
2496                                         mirror_num,
2497                                         &was_created);
2498                         if (NULL == next_block) {
2499                                 printk(KERN_INFO
2500                                        "btrfsic: error, kmalloc failed!\n");
2501                                 btrfsic_release_block_ctx(&tmp_next_block_ctx);
2502                                 return -1;
2503                         }
2504
2505                         next_block->disk_key = tmp_disk_key;
2506                         if (was_created)
2507                                 next_block->generation =
2508                                     BTRFSIC_GENERATION_UNKNOWN;
2509                         l = btrfsic_block_link_lookup_or_add(
2510                                         state,
2511                                         &tmp_next_block_ctx,
2512                                         next_block,
2513                                         superblock,
2514                                         BTRFSIC_GENERATION_UNKNOWN);
2515                         btrfsic_release_block_ctx(&tmp_next_block_ctx);
2516                         if (NULL == l)
2517                                 return -1;
2518                 }
2519         }
2520
2521         if (-1 == btrfsic_check_all_ref_blocks(state, superblock, 0)) {
2522                 WARN_ON(1);
2523                 btrfsic_dump_tree(state);
2524         }
2525
2526         return 0;
2527 }
2528
2529 static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state,
2530                                         struct btrfsic_block *const block,
2531                                         int recursion_level)
2532 {
2533         struct list_head *elem_ref_to;
2534         int ret = 0;
2535
2536         if (recursion_level >= 3 + BTRFS_MAX_LEVEL) {
2537                 /*
2538                  * Note that this situation can happen and does not
2539                  * indicate an error in regular cases. It happens
2540                  * when disk blocks are freed and later reused.
2541                  * The check-integrity module is not aware of any
2542                  * block free operations, it just recognizes block
2543                  * write operations. Therefore it keeps the linkage
2544                  * information for a block until a block is
2545                  * rewritten. This can temporarily cause incorrect
2546                  * and even circular linkage informations. This
2547                  * causes no harm unless such blocks are referenced
2548                  * by the most recent super block.
2549                  */
2550                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2551                         printk(KERN_INFO
2552                                "btrfsic: abort cyclic linkage (case 1).\n");
2553
2554                 return ret;
2555         }
2556
2557         /*
2558          * This algorithm is recursive because the amount of used stack
2559          * space is very small and the max recursion depth is limited.
2560          */
2561         list_for_each(elem_ref_to, &block->ref_to_list) {
2562                 const struct btrfsic_block_link *const l =
2563                     list_entry(elem_ref_to, struct btrfsic_block_link,
2564                                node_ref_to);
2565
2566                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2567                         printk(KERN_INFO
2568                                "rl=%d, %c @%llu (%s/%llu/%d)"
2569                                " %u* refers to %c @%llu (%s/%llu/%d)\n",
2570                                recursion_level,
2571                                btrfsic_get_block_type(state, block),
2572                                (unsigned long long)block->logical_bytenr,
2573                                block->dev_state->name,
2574                                (unsigned long long)block->dev_bytenr,
2575                                block->mirror_num,
2576                                l->ref_cnt,
2577                                btrfsic_get_block_type(state, l->block_ref_to),
2578                                (unsigned long long)
2579                                l->block_ref_to->logical_bytenr,
2580                                l->block_ref_to->dev_state->name,
2581                                (unsigned long long)l->block_ref_to->dev_bytenr,
2582                                l->block_ref_to->mirror_num);
2583                 if (l->block_ref_to->never_written) {
2584                         printk(KERN_INFO "btrfs: attempt to write superblock"
2585                                " which references block %c @%llu (%s/%llu/%d)"
2586                                " which is never written!\n",
2587                                btrfsic_get_block_type(state, l->block_ref_to),
2588                                (unsigned long long)
2589                                l->block_ref_to->logical_bytenr,
2590                                l->block_ref_to->dev_state->name,
2591                                (unsigned long long)l->block_ref_to->dev_bytenr,
2592                                l->block_ref_to->mirror_num);
2593                         ret = -1;
2594                 } else if (!l->block_ref_to->is_iodone) {
2595                         printk(KERN_INFO "btrfs: attempt to write superblock"
2596                                " which references block %c @%llu (%s/%llu/%d)"
2597                                " which is not yet iodone!\n",
2598                                btrfsic_get_block_type(state, l->block_ref_to),
2599                                (unsigned long long)
2600                                l->block_ref_to->logical_bytenr,
2601                                l->block_ref_to->dev_state->name,
2602                                (unsigned long long)l->block_ref_to->dev_bytenr,
2603                                l->block_ref_to->mirror_num);
2604                         ret = -1;
2605                 } else if (l->block_ref_to->iodone_w_error) {
2606                         printk(KERN_INFO "btrfs: attempt to write superblock"
2607                                " which references block %c @%llu (%s/%llu/%d)"
2608                                " which has write error!\n",
2609                                btrfsic_get_block_type(state, l->block_ref_to),
2610                                (unsigned long long)
2611                                l->block_ref_to->logical_bytenr,
2612                                l->block_ref_to->dev_state->name,
2613                                (unsigned long long)l->block_ref_to->dev_bytenr,
2614                                l->block_ref_to->mirror_num);
2615                         ret = -1;
2616                 } else if (l->parent_generation !=
2617                            l->block_ref_to->generation &&
2618                            BTRFSIC_GENERATION_UNKNOWN !=
2619                            l->parent_generation &&
2620                            BTRFSIC_GENERATION_UNKNOWN !=
2621                            l->block_ref_to->generation) {
2622                         printk(KERN_INFO "btrfs: attempt to write superblock"
2623                                " which references block %c @%llu (%s/%llu/%d)"
2624                                " with generation %llu !="
2625                                " parent generation %llu!\n",
2626                                btrfsic_get_block_type(state, l->block_ref_to),
2627                                (unsigned long long)
2628                                l->block_ref_to->logical_bytenr,
2629                                l->block_ref_to->dev_state->name,
2630                                (unsigned long long)l->block_ref_to->dev_bytenr,
2631                                l->block_ref_to->mirror_num,
2632                                (unsigned long long)l->block_ref_to->generation,
2633                                (unsigned long long)l->parent_generation);
2634                         ret = -1;
2635                 } else if (l->block_ref_to->flush_gen >
2636                            l->block_ref_to->dev_state->last_flush_gen) {
2637                         printk(KERN_INFO "btrfs: attempt to write superblock"
2638                                " which references block %c @%llu (%s/%llu/%d)"
2639                                " which is not flushed out of disk's write cache"
2640                                " (block flush_gen=%llu,"
2641                                " dev->flush_gen=%llu)!\n",
2642                                btrfsic_get_block_type(state, l->block_ref_to),
2643                                (unsigned long long)
2644                                l->block_ref_to->logical_bytenr,
2645                                l->block_ref_to->dev_state->name,
2646                                (unsigned long long)l->block_ref_to->dev_bytenr,
2647                                l->block_ref_to->mirror_num,
2648                                (unsigned long long)block->flush_gen,
2649                                (unsigned long long)
2650                                l->block_ref_to->dev_state->last_flush_gen);
2651                         ret = -1;
2652                 } else if (-1 == btrfsic_check_all_ref_blocks(state,
2653                                                               l->block_ref_to,
2654                                                               recursion_level +
2655                                                               1)) {
2656                         ret = -1;
2657                 }
2658         }
2659
2660         return ret;
2661 }
2662
2663 static int btrfsic_is_block_ref_by_superblock(
2664                 const struct btrfsic_state *state,
2665                 const struct btrfsic_block *block,
2666                 int recursion_level)
2667 {
2668         struct list_head *elem_ref_from;
2669
2670         if (recursion_level >= 3 + BTRFS_MAX_LEVEL) {
2671                 /* refer to comment at "abort cyclic linkage (case 1)" */
2672                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2673                         printk(KERN_INFO
2674                                "btrfsic: abort cyclic linkage (case 2).\n");
2675
2676                 return 0;
2677         }
2678
2679         /*
2680          * This algorithm is recursive because the amount of used stack space
2681          * is very small and the max recursion depth is limited.
2682          */
2683         list_for_each(elem_ref_from, &block->ref_from_list) {
2684                 const struct btrfsic_block_link *const l =
2685                     list_entry(elem_ref_from, struct btrfsic_block_link,
2686                                node_ref_from);
2687
2688                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2689                         printk(KERN_INFO
2690                                "rl=%d, %c @%llu (%s/%llu/%d)"
2691                                " is ref %u* from %c @%llu (%s/%llu/%d)\n",
2692                                recursion_level,
2693                                btrfsic_get_block_type(state, block),
2694                                (unsigned long long)block->logical_bytenr,
2695                                block->dev_state->name,
2696                                (unsigned long long)block->dev_bytenr,
2697                                block->mirror_num,
2698                                l->ref_cnt,
2699                                btrfsic_get_block_type(state, l->block_ref_from),
2700                                (unsigned long long)
2701                                l->block_ref_from->logical_bytenr,
2702                                l->block_ref_from->dev_state->name,
2703                                (unsigned long long)
2704                                l->block_ref_from->dev_bytenr,
2705                                l->block_ref_from->mirror_num);
2706                 if (l->block_ref_from->is_superblock &&
2707                     state->latest_superblock->dev_bytenr ==
2708                     l->block_ref_from->dev_bytenr &&
2709                     state->latest_superblock->dev_state->bdev ==
2710                     l->block_ref_from->dev_state->bdev)
2711                         return 1;
2712                 else if (btrfsic_is_block_ref_by_superblock(state,
2713                                                             l->block_ref_from,
2714                                                             recursion_level +
2715                                                             1))
2716                         return 1;
2717         }
2718
2719         return 0;
2720 }
2721
2722 static void btrfsic_print_add_link(const struct btrfsic_state *state,
2723                                    const struct btrfsic_block_link *l)
2724 {
2725         printk(KERN_INFO
2726                "Add %u* link from %c @%llu (%s/%llu/%d)"
2727                " to %c @%llu (%s/%llu/%d).\n",
2728                l->ref_cnt,
2729                btrfsic_get_block_type(state, l->block_ref_from),
2730                (unsigned long long)l->block_ref_from->logical_bytenr,
2731                l->block_ref_from->dev_state->name,
2732                (unsigned long long)l->block_ref_from->dev_bytenr,
2733                l->block_ref_from->mirror_num,
2734                btrfsic_get_block_type(state, l->block_ref_to),
2735                (unsigned long long)l->block_ref_to->logical_bytenr,
2736                l->block_ref_to->dev_state->name,
2737                (unsigned long long)l->block_ref_to->dev_bytenr,
2738                l->block_ref_to->mirror_num);
2739 }
2740
2741 static void btrfsic_print_rem_link(const struct btrfsic_state *state,
2742                                    const struct btrfsic_block_link *l)
2743 {
2744         printk(KERN_INFO
2745                "Rem %u* link from %c @%llu (%s/%llu/%d)"
2746                " to %c @%llu (%s/%llu/%d).\n",
2747                l->ref_cnt,
2748                btrfsic_get_block_type(state, l->block_ref_from),
2749                (unsigned long long)l->block_ref_from->logical_bytenr,
2750                l->block_ref_from->dev_state->name,
2751                (unsigned long long)l->block_ref_from->dev_bytenr,
2752                l->block_ref_from->mirror_num,
2753                btrfsic_get_block_type(state, l->block_ref_to),
2754                (unsigned long long)l->block_ref_to->logical_bytenr,
2755                l->block_ref_to->dev_state->name,
2756                (unsigned long long)l->block_ref_to->dev_bytenr,
2757                l->block_ref_to->mirror_num);
2758 }
2759
2760 static char btrfsic_get_block_type(const struct btrfsic_state *state,
2761                                    const struct btrfsic_block *block)
2762 {
2763         if (block->is_superblock &&
2764             state->latest_superblock->dev_bytenr == block->dev_bytenr &&
2765             state->latest_superblock->dev_state->bdev == block->dev_state->bdev)
2766                 return 'S';
2767         else if (block->is_superblock)
2768                 return 's';
2769         else if (block->is_metadata)
2770                 return 'M';
2771         else
2772                 return 'D';
2773 }
2774
2775 static void btrfsic_dump_tree(const struct btrfsic_state *state)
2776 {
2777         btrfsic_dump_tree_sub(state, state->latest_superblock, 0);
2778 }
2779
2780 static void btrfsic_dump_tree_sub(const struct btrfsic_state *state,
2781                                   const struct btrfsic_block *block,
2782                                   int indent_level)
2783 {
2784         struct list_head *elem_ref_to;
2785         int indent_add;
2786         static char buf[80];
2787         int cursor_position;
2788
2789         /*
2790          * Should better fill an on-stack buffer with a complete line and
2791          * dump it at once when it is time to print a newline character.
2792          */
2793
2794         /*
2795          * This algorithm is recursive because the amount of used stack space
2796          * is very small and the max recursion depth is limited.
2797          */
2798         indent_add = sprintf(buf, "%c-%llu(%s/%llu/%d)",
2799                              btrfsic_get_block_type(state, block),
2800                              (unsigned long long)block->logical_bytenr,
2801                              block->dev_state->name,
2802                              (unsigned long long)block->dev_bytenr,
2803                              block->mirror_num);
2804         if (indent_level + indent_add > BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) {
2805                 printk("[...]\n");
2806                 return;
2807         }
2808         printk(buf);
2809         indent_level += indent_add;
2810         if (list_empty(&block->ref_to_list)) {
2811                 printk("\n");
2812                 return;
2813         }
2814         if (block->mirror_num > 1 &&
2815             !(state->print_mask & BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS)) {
2816                 printk(" [...]\n");
2817                 return;
2818         }
2819
2820         cursor_position = indent_level;
2821         list_for_each(elem_ref_to, &block->ref_to_list) {
2822                 const struct btrfsic_block_link *const l =
2823                     list_entry(elem_ref_to, struct btrfsic_block_link,
2824                                node_ref_to);
2825
2826                 while (cursor_position < indent_level) {
2827                         printk(" ");
2828                         cursor_position++;
2829                 }
2830                 if (l->ref_cnt > 1)
2831                         indent_add = sprintf(buf, " %d*--> ", l->ref_cnt);
2832                 else
2833                         indent_add = sprintf(buf, " --> ");
2834                 if (indent_level + indent_add >
2835                     BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) {
2836                         printk("[...]\n");
2837                         cursor_position = 0;
2838                         continue;
2839                 }
2840
2841                 printk(buf);
2842
2843                 btrfsic_dump_tree_sub(state, l->block_ref_to,
2844                                       indent_level + indent_add);
2845                 cursor_position = 0;
2846         }
2847 }
2848
2849 static struct btrfsic_block_link *btrfsic_block_link_lookup_or_add(
2850                 struct btrfsic_state *state,
2851                 struct btrfsic_block_data_ctx *next_block_ctx,
2852                 struct btrfsic_block *next_block,
2853                 struct btrfsic_block *from_block,
2854                 u64 parent_generation)
2855 {
2856         struct btrfsic_block_link *l;
2857
2858         l = btrfsic_block_link_hashtable_lookup(next_block_ctx->dev->bdev,
2859                                                 next_block_ctx->dev_bytenr,
2860                                                 from_block->dev_state->bdev,
2861                                                 from_block->dev_bytenr,
2862                                                 &state->block_link_hashtable);
2863         if (NULL == l) {
2864                 l = btrfsic_block_link_alloc();
2865                 if (NULL == l) {
2866                         printk(KERN_INFO
2867                                "btrfsic: error, kmalloc" " failed!\n");
2868                         return NULL;
2869                 }
2870
2871                 l->block_ref_to = next_block;
2872                 l->block_ref_from = from_block;
2873                 l->ref_cnt = 1;
2874                 l->parent_generation = parent_generation;
2875
2876                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2877                         btrfsic_print_add_link(state, l);
2878
2879                 list_add(&l->node_ref_to, &from_block->ref_to_list);
2880                 list_add(&l->node_ref_from, &next_block->ref_from_list);
2881
2882                 btrfsic_block_link_hashtable_add(l,
2883                                                  &state->block_link_hashtable);
2884         } else {
2885                 l->ref_cnt++;
2886                 l->parent_generation = parent_generation;
2887                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2888                         btrfsic_print_add_link(state, l);
2889         }
2890
2891         return l;
2892 }
2893
2894 static struct btrfsic_block *btrfsic_block_lookup_or_add(
2895                 struct btrfsic_state *state,
2896                 struct btrfsic_block_data_ctx *block_ctx,
2897                 const char *additional_string,
2898                 int is_metadata,
2899                 int is_iodone,
2900                 int never_written,
2901                 int mirror_num,
2902                 int *was_created)
2903 {
2904         struct btrfsic_block *block;
2905
2906         block = btrfsic_block_hashtable_lookup(block_ctx->dev->bdev,
2907                                                block_ctx->dev_bytenr,
2908                                                &state->block_hashtable);
2909         if (NULL == block) {
2910                 struct btrfsic_dev_state *dev_state;
2911
2912                 block = btrfsic_block_alloc();
2913                 if (NULL == block) {
2914                         printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");
2915                         return NULL;
2916                 }
2917                 dev_state = btrfsic_dev_state_lookup(block_ctx->dev->bdev);
2918                 if (NULL == dev_state) {
2919                         printk(KERN_INFO
2920                                "btrfsic: error, lookup dev_state failed!\n");
2921                         btrfsic_block_free(block);
2922                         return NULL;
2923                 }
2924                 block->dev_state = dev_state;
2925                 block->dev_bytenr = block_ctx->dev_bytenr;
2926                 block->logical_bytenr = block_ctx->start;
2927                 block->is_metadata = is_metadata;
2928                 block->is_iodone = is_iodone;
2929                 block->never_written = never_written;
2930                 block->mirror_num = mirror_num;
2931                 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
2932                         printk(KERN_INFO
2933                                "New %s%c-block @%llu (%s/%llu/%d)\n",
2934                                additional_string,
2935                                btrfsic_get_block_type(state, block),
2936                                (unsigned long long)block->logical_bytenr,
2937                                dev_state->name,
2938                                (unsigned long long)block->dev_bytenr,
2939                                mirror_num);
2940                 list_add(&block->all_blocks_node, &state->all_blocks_list);
2941                 btrfsic_block_hashtable_add(block, &state->block_hashtable);
2942                 if (NULL != was_created)
2943                         *was_created = 1;
2944         } else {
2945                 if (NULL != was_created)
2946                         *was_created = 0;
2947         }
2948
2949         return block;
2950 }
2951
2952 static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state,
2953                                            u64 bytenr,
2954                                            struct btrfsic_dev_state *dev_state,
2955                                            u64 dev_bytenr)
2956 {
2957         int num_copies;
2958         int mirror_num;
2959         int ret;
2960         struct btrfsic_block_data_ctx block_ctx;
2961         int match = 0;
2962
2963         num_copies = btrfs_num_copies(&state->root->fs_info->mapping_tree,
2964                                       bytenr, state->metablock_size);
2965
2966         for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
2967                 ret = btrfsic_map_block(state, bytenr, state->metablock_size,
2968                                         &block_ctx, mirror_num);
2969                 if (ret) {
2970                         printk(KERN_INFO "btrfsic:"
2971                                " btrfsic_map_block(logical @%llu,"
2972                                " mirror %d) failed!\n",
2973                                (unsigned long long)bytenr, mirror_num);
2974                         continue;
2975                 }
2976
2977                 if (dev_state->bdev == block_ctx.dev->bdev &&
2978                     dev_bytenr == block_ctx.dev_bytenr) {
2979                         match++;
2980                         btrfsic_release_block_ctx(&block_ctx);
2981                         break;
2982                 }
2983                 btrfsic_release_block_ctx(&block_ctx);
2984         }
2985
2986         if (!match) {
2987                 printk(KERN_INFO "btrfs: attempt to write M-block which contains logical bytenr that doesn't map to dev+physical bytenr of submit_bio,"
2988                        " buffer->log_bytenr=%llu, submit_bio(bdev=%s,"
2989                        " phys_bytenr=%llu)!\n",
2990                        (unsigned long long)bytenr, dev_state->name,
2991                        (unsigned long long)dev_bytenr);
2992                 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
2993                         ret = btrfsic_map_block(state, bytenr,
2994                                                 state->metablock_size,
2995                                                 &block_ctx, mirror_num);
2996                         if (ret)
2997                                 continue;
2998
2999                         printk(KERN_INFO "Read logical bytenr @%llu maps to"
3000                                " (%s/%llu/%d)\n",
3001                                (unsigned long long)bytenr,
3002                                block_ctx.dev->name,
3003                                (unsigned long long)block_ctx.dev_bytenr,
3004                                mirror_num);
3005                 }
3006                 WARN_ON(1);
3007         }
3008 }
3009
3010 static struct btrfsic_dev_state *btrfsic_dev_state_lookup(
3011                 struct block_device *bdev)
3012 {
3013         struct btrfsic_dev_state *ds;
3014
3015         ds = btrfsic_dev_state_hashtable_lookup(bdev,
3016                                                 &btrfsic_dev_state_hashtable);
3017         return ds;
3018 }
3019
3020 int btrfsic_submit_bh(int rw, struct buffer_head *bh)
3021 {
3022         struct btrfsic_dev_state *dev_state;
3023
3024         if (!btrfsic_is_initialized)
3025                 return submit_bh(rw, bh);
3026
3027         mutex_lock(&btrfsic_mutex);
3028         /* since btrfsic_submit_bh() might also be called before
3029          * btrfsic_mount(), this might return NULL */
3030         dev_state = btrfsic_dev_state_lookup(bh->b_bdev);
3031
3032         /* Only called to write the superblock (incl. FLUSH/FUA) */
3033         if (NULL != dev_state &&
3034             (rw & WRITE) && bh->b_size > 0) {
3035                 u64 dev_bytenr;
3036
3037                 dev_bytenr = 4096 * bh->b_blocknr;
3038                 if (dev_state->state->print_mask &
3039                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
3040                         printk(KERN_INFO
3041                                "submit_bh(rw=0x%x, blocknr=%lu (bytenr %llu),"
3042                                " size=%lu, data=%p, bdev=%p)\n",
3043                                rw, (unsigned long)bh->b_blocknr,
3044                                (unsigned long long)dev_bytenr,
3045                                (unsigned long)bh->b_size, bh->b_data,
3046                                bh->b_bdev);
3047                 btrfsic_process_written_block(dev_state, dev_bytenr,
3048                                               &bh->b_data, 1, NULL,
3049                                               NULL, bh, rw);
3050         } else if (NULL != dev_state && (rw & REQ_FLUSH)) {
3051                 if (dev_state->state->print_mask &
3052                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
3053                         printk(KERN_INFO
3054                                "submit_bh(rw=0x%x FLUSH, bdev=%p)\n",
3055                                rw, bh->b_bdev);
3056                 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) {
3057                         if ((dev_state->state->print_mask &
3058                              (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
3059                               BTRFSIC_PRINT_MASK_VERBOSE)))
3060                                 printk(KERN_INFO
3061                                        "btrfsic_submit_bh(%s) with FLUSH"
3062                                        " but dummy block already in use"
3063                                        " (ignored)!\n",
3064                                        dev_state->name);
3065                 } else {
3066                         struct btrfsic_block *const block =
3067                                 &dev_state->dummy_block_for_bio_bh_flush;
3068
3069                         block->is_iodone = 0;
3070                         block->never_written = 0;
3071                         block->iodone_w_error = 0;
3072                         block->flush_gen = dev_state->last_flush_gen + 1;
3073                         block->submit_bio_bh_rw = rw;
3074                         block->orig_bio_bh_private = bh->b_private;
3075                         block->orig_bio_bh_end_io.bh = bh->b_end_io;
3076                         block->next_in_same_bio = NULL;
3077                         bh->b_private = block;
3078                         bh->b_end_io = btrfsic_bh_end_io;
3079                 }
3080         }
3081         mutex_unlock(&btrfsic_mutex);
3082         return submit_bh(rw, bh);
3083 }
3084
3085 void btrfsic_submit_bio(int rw, struct bio *bio)
3086 {
3087         struct btrfsic_dev_state *dev_state;
3088
3089         if (!btrfsic_is_initialized) {
3090                 submit_bio(rw, bio);
3091                 return;
3092         }
3093
3094         mutex_lock(&btrfsic_mutex);
3095         /* since btrfsic_submit_bio() is also called before
3096          * btrfsic_mount(), this might return NULL */
3097         dev_state = btrfsic_dev_state_lookup(bio->bi_bdev);
3098         if (NULL != dev_state &&
3099             (rw & WRITE) && NULL != bio->bi_io_vec) {
3100                 unsigned int i;
3101                 u64 dev_bytenr;
3102                 int bio_is_patched;
3103                 char **mapped_datav;
3104
3105                 dev_bytenr = 512 * bio->bi_sector;
3106                 bio_is_patched = 0;
3107                 if (dev_state->state->print_mask &
3108                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
3109                         printk(KERN_INFO
3110                                "submit_bio(rw=0x%x, bi_vcnt=%u,"
3111                                " bi_sector=%lu (bytenr %llu), bi_bdev=%p)\n",
3112                                rw, bio->bi_vcnt, (unsigned long)bio->bi_sector,
3113                                (unsigned long long)dev_bytenr,
3114                                bio->bi_bdev);
3115
3116                 mapped_datav = kmalloc(sizeof(*mapped_datav) * bio->bi_vcnt,
3117                                        GFP_NOFS);
3118                 if (!mapped_datav)
3119                         goto leave;
3120                 for (i = 0; i < bio->bi_vcnt; i++) {
3121                         BUG_ON(bio->bi_io_vec[i].bv_len != PAGE_CACHE_SIZE);
3122                         mapped_datav[i] = kmap(bio->bi_io_vec[i].bv_page);
3123                         if (!mapped_datav[i]) {
3124                                 while (i > 0) {
3125                                         i--;
3126                                         kunmap(bio->bi_io_vec[i].bv_page);
3127                                 }
3128                                 kfree(mapped_datav);
3129                                 goto leave;
3130                         }
3131                         if ((BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
3132                              BTRFSIC_PRINT_MASK_VERBOSE) ==
3133                             (dev_state->state->print_mask &
3134                              (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
3135                               BTRFSIC_PRINT_MASK_VERBOSE)))
3136                                 printk(KERN_INFO
3137                                        "#%u: page=%p, len=%u, offset=%u\n",
3138                                        i, bio->bi_io_vec[i].bv_page,
3139                                        bio->bi_io_vec[i].bv_len,
3140                                        bio->bi_io_vec[i].bv_offset);
3141                 }
3142                 btrfsic_process_written_block(dev_state, dev_bytenr,
3143                                               mapped_datav, bio->bi_vcnt,
3144                                               bio, &bio_is_patched,
3145                                               NULL, rw);
3146                 while (i > 0) {
3147                         i--;
3148                         kunmap(bio->bi_io_vec[i].bv_page);
3149                 }
3150                 kfree(mapped_datav);
3151         } else if (NULL != dev_state && (rw & REQ_FLUSH)) {
3152                 if (dev_state->state->print_mask &
3153                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
3154                         printk(KERN_INFO
3155                                "submit_bio(rw=0x%x FLUSH, bdev=%p)\n",
3156                                rw, bio->bi_bdev);
3157                 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) {
3158                         if ((dev_state->state->print_mask &
3159                              (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
3160                               BTRFSIC_PRINT_MASK_VERBOSE)))
3161                                 printk(KERN_INFO
3162                                        "btrfsic_submit_bio(%s) with FLUSH"
3163                                        " but dummy block already in use"
3164                                        " (ignored)!\n",
3165                                        dev_state->name);
3166                 } else {
3167                         struct btrfsic_block *const block =
3168                                 &dev_state->dummy_block_for_bio_bh_flush;
3169
3170                         block->is_iodone = 0;
3171                         block->never_written = 0;
3172                         block->iodone_w_error = 0;
3173                         block->flush_gen = dev_state->last_flush_gen + 1;
3174                         block->submit_bio_bh_rw = rw;
3175                         block->orig_bio_bh_private = bio->bi_private;
3176                         block->orig_bio_bh_end_io.bio = bio->bi_end_io;
3177                         block->next_in_same_bio = NULL;
3178                         bio->bi_private = block;
3179                         bio->bi_end_io = btrfsic_bio_end_io;
3180                 }
3181         }
3182 leave:
3183         mutex_unlock(&btrfsic_mutex);
3184
3185         submit_bio(rw, bio);
3186 }
3187
3188 int btrfsic_mount(struct btrfs_root *root,
3189                   struct btrfs_fs_devices *fs_devices,
3190                   int including_extent_data, u32 print_mask)
3191 {
3192         int ret;
3193         struct btrfsic_state *state;
3194         struct list_head *dev_head = &fs_devices->devices;
3195         struct btrfs_device *device;
3196
3197         if (root->nodesize != root->leafsize) {
3198                 printk(KERN_INFO
3199                        "btrfsic: cannot handle nodesize %d != leafsize %d!\n",
3200                        root->nodesize, root->leafsize);
3201                 return -1;
3202         }
3203         if (root->nodesize & ((u64)PAGE_CACHE_SIZE - 1)) {
3204                 printk(KERN_INFO
3205                        "btrfsic: cannot handle nodesize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",
3206                        root->nodesize, (unsigned long)PAGE_CACHE_SIZE);
3207                 return -1;
3208         }
3209         if (root->leafsize & ((u64)PAGE_CACHE_SIZE - 1)) {
3210                 printk(KERN_INFO
3211                        "btrfsic: cannot handle leafsize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",
3212                        root->leafsize, (unsigned long)PAGE_CACHE_SIZE);
3213                 return -1;
3214         }
3215         if (root->sectorsize & ((u64)PAGE_CACHE_SIZE - 1)) {
3216                 printk(KERN_INFO
3217                        "btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",
3218                        root->sectorsize, (unsigned long)PAGE_CACHE_SIZE);
3219                 return -1;
3220         }
3221         state = kzalloc(sizeof(*state), GFP_NOFS);
3222         if (NULL == state) {
3223                 printk(KERN_INFO "btrfs check-integrity: kmalloc() failed!\n");
3224                 return -1;
3225         }
3226
3227         if (!btrfsic_is_initialized) {
3228                 mutex_init(&btrfsic_mutex);
3229                 btrfsic_dev_state_hashtable_init(&btrfsic_dev_state_hashtable);
3230                 btrfsic_is_initialized = 1;
3231         }
3232         mutex_lock(&btrfsic_mutex);
3233         state->root = root;
3234         state->print_mask = print_mask;
3235         state->include_extent_data = including_extent_data;
3236         state->csum_size = 0;
3237         state->metablock_size = root->nodesize;
3238         state->datablock_size = root->sectorsize;
3239         INIT_LIST_HEAD(&state->all_blocks_list);
3240         btrfsic_block_hashtable_init(&state->block_hashtable);
3241         btrfsic_block_link_hashtable_init(&state->block_link_hashtable);
3242         state->max_superblock_generation = 0;
3243         state->latest_superblock = NULL;
3244
3245         list_for_each_entry(device, dev_head, dev_list) {
3246                 struct btrfsic_dev_state *ds;
3247                 char *p;
3248
3249                 if (!device->bdev || !device->name)
3250                         continue;
3251
3252                 ds = btrfsic_dev_state_alloc();
3253                 if (NULL == ds) {
3254                         printk(KERN_INFO
3255                                "btrfs check-integrity: kmalloc() failed!\n");
3256                         mutex_unlock(&btrfsic_mutex);
3257                         return -1;
3258                 }
3259                 ds->bdev = device->bdev;
3260                 ds->state = state;
3261                 bdevname(ds->bdev, ds->name);
3262                 ds->name[BDEVNAME_SIZE - 1] = '\0';
3263                 for (p = ds->name; *p != '\0'; p++);
3264                 while (p > ds->name && *p != '/')
3265                         p--;
3266                 if (*p == '/')
3267                         p++;
3268                 strlcpy(ds->name, p, sizeof(ds->name));
3269                 btrfsic_dev_state_hashtable_add(ds,
3270                                                 &btrfsic_dev_state_hashtable);
3271         }
3272
3273         ret = btrfsic_process_superblock(state, fs_devices);
3274         if (0 != ret) {
3275                 mutex_unlock(&btrfsic_mutex);
3276                 btrfsic_unmount(root, fs_devices);
3277                 return ret;
3278         }
3279
3280         if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_DATABASE)
3281                 btrfsic_dump_database(state);
3282         if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_TREE)
3283                 btrfsic_dump_tree(state);
3284
3285         mutex_unlock(&btrfsic_mutex);
3286         return 0;
3287 }
3288
3289 void btrfsic_unmount(struct btrfs_root *root,
3290                      struct btrfs_fs_devices *fs_devices)
3291 {
3292         struct list_head *elem_all;
3293         struct list_head *tmp_all;
3294         struct btrfsic_state *state;
3295         struct list_head *dev_head = &fs_devices->devices;
3296         struct btrfs_device *device;
3297
3298         if (!btrfsic_is_initialized)
3299                 return;
3300
3301         mutex_lock(&btrfsic_mutex);
3302
3303         state = NULL;
3304         list_for_each_entry(device, dev_head, dev_list) {
3305                 struct btrfsic_dev_state *ds;
3306
3307                 if (!device->bdev || !device->name)
3308                         continue;
3309
3310                 ds = btrfsic_dev_state_hashtable_lookup(
3311                                 device->bdev,
3312                                 &btrfsic_dev_state_hashtable);
3313                 if (NULL != ds) {
3314                         state = ds->state;
3315                         btrfsic_dev_state_hashtable_remove(ds);
3316                         btrfsic_dev_state_free(ds);
3317                 }
3318         }
3319
3320         if (NULL == state) {
3321                 printk(KERN_INFO
3322                        "btrfsic: error, cannot find state information"
3323                        " on umount!\n");
3324                 mutex_unlock(&btrfsic_mutex);
3325                 return;
3326         }
3327
3328         /*
3329          * Don't care about keeping the lists' state up to date,
3330          * just free all memory that was allocated dynamically.
3331          * Free the blocks and the block_links.
3332          */
3333         list_for_each_safe(elem_all, tmp_all, &state->all_blocks_list) {
3334                 struct btrfsic_block *const b_all =
3335                     list_entry(elem_all, struct btrfsic_block,
3336                                all_blocks_node);
3337                 struct list_head *elem_ref_to;
3338                 struct list_head *tmp_ref_to;
3339
3340                 list_for_each_safe(elem_ref_to, tmp_ref_to,
3341                                    &b_all->ref_to_list) {
3342                         struct btrfsic_block_link *const l =
3343                             list_entry(elem_ref_to,
3344                                        struct btrfsic_block_link,
3345                                        node_ref_to);
3346
3347                         if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
3348                                 btrfsic_print_rem_link(state, l);
3349
3350                         l->ref_cnt--;
3351                         if (0 == l->ref_cnt)
3352                                 btrfsic_block_link_free(l);
3353                 }
3354
3355                 if (b_all->is_iodone || b_all->never_written)
3356                         btrfsic_block_free(b_all);
3357                 else
3358                         printk(KERN_INFO "btrfs: attempt to free %c-block"
3359                                " @%llu (%s/%llu/%d) on umount which is"
3360                                " not yet iodone!\n",
3361                                btrfsic_get_block_type(state, b_all),
3362                                (unsigned long long)b_all->logical_bytenr,
3363                                b_all->dev_state->name,
3364                                (unsigned long long)b_all->dev_bytenr,
3365                                b_all->mirror_num);
3366         }
3367
3368         mutex_unlock(&btrfsic_mutex);
3369
3370         kfree(state);
3371 }