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