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