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 1677 for (j = i; j < num_pages; j++) { 1678 ret = bio_add_page(bio, block_ctx->pagev[j], 1679 PAGE_SIZE, 0); 1680 if (PAGE_SIZE != ret) 1681 break; 1682 } 1683 if (j == i) { 1684 printk(KERN_INFO 1685 "btrfsic: error, failed to add a single page!\n"); 1686 return -1; 1687 } 1688 if (submit_bio_wait(READ, bio)) { 1689 printk(KERN_INFO 1690 "btrfsic: read error at logical %llu dev %s!\n", 1691 block_ctx->start, block_ctx->dev->name); 1692 bio_put(bio); 1693 return -1; 1694 } 1695 bio_put(bio); 1696 dev_bytenr += (j - i) * PAGE_SIZE; 1697 i = j; 1698 } 1699 for (i = 0; i < num_pages; i++) { 1700 block_ctx->datav[i] = kmap(block_ctx->pagev[i]); 1701 if (!block_ctx->datav[i]) { 1702 printk(KERN_INFO "btrfsic: kmap() failed (dev %s)!\n", 1703 block_ctx->dev->name); 1704 return -1; 1705 } 1706 } 1707 1708 return block_ctx->len; 1709 } 1710 1711 static void btrfsic_dump_database(struct btrfsic_state *state) 1712 { 1713 const struct btrfsic_block *b_all; 1714 1715 BUG_ON(NULL == state); 1716 1717 printk(KERN_INFO "all_blocks_list:\n"); 1718 list_for_each_entry(b_all, &state->all_blocks_list, all_blocks_node) { 1719 const struct btrfsic_block_link *l; 1720 1721 printk(KERN_INFO "%c-block @%llu (%s/%llu/%d)\n", 1722 btrfsic_get_block_type(state, b_all), 1723 b_all->logical_bytenr, b_all->dev_state->name, 1724 b_all->dev_bytenr, b_all->mirror_num); 1725 1726 list_for_each_entry(l, &b_all->ref_to_list, node_ref_to) { 1727 printk(KERN_INFO " %c @%llu (%s/%llu/%d)" 1728 " refers %u* to" 1729 " %c @%llu (%s/%llu/%d)\n", 1730 btrfsic_get_block_type(state, b_all), 1731 b_all->logical_bytenr, b_all->dev_state->name, 1732 b_all->dev_bytenr, b_all->mirror_num, 1733 l->ref_cnt, 1734 btrfsic_get_block_type(state, l->block_ref_to), 1735 l->block_ref_to->logical_bytenr, 1736 l->block_ref_to->dev_state->name, 1737 l->block_ref_to->dev_bytenr, 1738 l->block_ref_to->mirror_num); 1739 } 1740 1741 list_for_each_entry(l, &b_all->ref_from_list, node_ref_from) { 1742 printk(KERN_INFO " %c @%llu (%s/%llu/%d)" 1743 " is ref %u* from" 1744 " %c @%llu (%s/%llu/%d)\n", 1745 btrfsic_get_block_type(state, b_all), 1746 b_all->logical_bytenr, b_all->dev_state->name, 1747 b_all->dev_bytenr, b_all->mirror_num, 1748 l->ref_cnt, 1749 btrfsic_get_block_type(state, l->block_ref_from), 1750 l->block_ref_from->logical_bytenr, 1751 l->block_ref_from->dev_state->name, 1752 l->block_ref_from->dev_bytenr, 1753 l->block_ref_from->mirror_num); 1754 } 1755 1756 printk(KERN_INFO "\n"); 1757 } 1758 } 1759 1760 /* 1761 * Test whether the disk block contains a tree block (leaf or node) 1762 * (note that this test fails for the super block) 1763 */ 1764 static int btrfsic_test_for_metadata(struct btrfsic_state *state, 1765 char **datav, unsigned int num_pages) 1766 { 1767 struct btrfs_header *h; 1768 u8 csum[BTRFS_CSUM_SIZE]; 1769 u32 crc = ~(u32)0; 1770 unsigned int i; 1771 1772 if (num_pages * PAGE_SIZE < state->metablock_size) 1773 return 1; /* not metadata */ 1774 num_pages = state->metablock_size >> PAGE_SHIFT; 1775 h = (struct btrfs_header *)datav[0]; 1776 1777 if (memcmp(h->fsid, state->root->fs_info->fsid, BTRFS_UUID_SIZE)) 1778 return 1; 1779 1780 for (i = 0; i < num_pages; i++) { 1781 u8 *data = i ? datav[i] : (datav[i] + BTRFS_CSUM_SIZE); 1782 size_t sublen = i ? PAGE_SIZE : 1783 (PAGE_SIZE - BTRFS_CSUM_SIZE); 1784 1785 crc = btrfs_crc32c(crc, data, sublen); 1786 } 1787 btrfs_csum_final(crc, csum); 1788 if (memcmp(csum, h->csum, state->csum_size)) 1789 return 1; 1790 1791 return 0; /* is metadata */ 1792 } 1793 1794 static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state, 1795 u64 dev_bytenr, char **mapped_datav, 1796 unsigned int num_pages, 1797 struct bio *bio, int *bio_is_patched, 1798 struct buffer_head *bh, 1799 int submit_bio_bh_rw) 1800 { 1801 int is_metadata; 1802 struct btrfsic_block *block; 1803 struct btrfsic_block_data_ctx block_ctx; 1804 int ret; 1805 struct btrfsic_state *state = dev_state->state; 1806 struct block_device *bdev = dev_state->bdev; 1807 unsigned int processed_len; 1808 1809 if (NULL != bio_is_patched) 1810 *bio_is_patched = 0; 1811 1812 again: 1813 if (num_pages == 0) 1814 return; 1815 1816 processed_len = 0; 1817 is_metadata = (0 == btrfsic_test_for_metadata(state, mapped_datav, 1818 num_pages)); 1819 1820 block = btrfsic_block_hashtable_lookup(bdev, dev_bytenr, 1821 &state->block_hashtable); 1822 if (NULL != block) { 1823 u64 bytenr = 0; 1824 struct btrfsic_block_link *l, *tmp; 1825 1826 if (block->is_superblock) { 1827 bytenr = btrfs_super_bytenr((struct btrfs_super_block *) 1828 mapped_datav[0]); 1829 if (num_pages * PAGE_SIZE < 1830 BTRFS_SUPER_INFO_SIZE) { 1831 printk(KERN_INFO 1832 "btrfsic: cannot work with too short bios!\n"); 1833 return; 1834 } 1835 is_metadata = 1; 1836 BUG_ON(BTRFS_SUPER_INFO_SIZE & (PAGE_SIZE - 1)); 1837 processed_len = BTRFS_SUPER_INFO_SIZE; 1838 if (state->print_mask & 1839 BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE) { 1840 printk(KERN_INFO 1841 "[before new superblock is written]:\n"); 1842 btrfsic_dump_tree_sub(state, block, 0); 1843 } 1844 } 1845 if (is_metadata) { 1846 if (!block->is_superblock) { 1847 if (num_pages * PAGE_SIZE < 1848 state->metablock_size) { 1849 printk(KERN_INFO 1850 "btrfsic: cannot work with too short bios!\n"); 1851 return; 1852 } 1853 processed_len = state->metablock_size; 1854 bytenr = btrfs_stack_header_bytenr( 1855 (struct btrfs_header *) 1856 mapped_datav[0]); 1857 btrfsic_cmp_log_and_dev_bytenr(state, bytenr, 1858 dev_state, 1859 dev_bytenr); 1860 } 1861 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) { 1862 if (block->logical_bytenr != bytenr && 1863 !(!block->is_metadata && 1864 block->logical_bytenr == 0)) 1865 printk(KERN_INFO 1866 "Written block @%llu (%s/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu).\n", 1867 bytenr, dev_state->name, 1868 dev_bytenr, 1869 block->mirror_num, 1870 btrfsic_get_block_type(state, 1871 block), 1872 block->logical_bytenr); 1873 else 1874 printk(KERN_INFO 1875 "Written block @%llu (%s/%llu/%d) found in hash table, %c.\n", 1876 bytenr, dev_state->name, 1877 dev_bytenr, block->mirror_num, 1878 btrfsic_get_block_type(state, 1879 block)); 1880 } 1881 block->logical_bytenr = bytenr; 1882 } else { 1883 if (num_pages * PAGE_SIZE < 1884 state->datablock_size) { 1885 printk(KERN_INFO 1886 "btrfsic: cannot work with too short bios!\n"); 1887 return; 1888 } 1889 processed_len = state->datablock_size; 1890 bytenr = block->logical_bytenr; 1891 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 1892 printk(KERN_INFO 1893 "Written block @%llu (%s/%llu/%d)" 1894 " found in hash table, %c.\n", 1895 bytenr, dev_state->name, dev_bytenr, 1896 block->mirror_num, 1897 btrfsic_get_block_type(state, block)); 1898 } 1899 1900 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 1901 printk(KERN_INFO 1902 "ref_to_list: %cE, ref_from_list: %cE\n", 1903 list_empty(&block->ref_to_list) ? ' ' : '!', 1904 list_empty(&block->ref_from_list) ? ' ' : '!'); 1905 if (btrfsic_is_block_ref_by_superblock(state, block, 0)) { 1906 printk(KERN_INFO "btrfs: attempt to overwrite %c-block" 1907 " @%llu (%s/%llu/%d), old(gen=%llu," 1908 " objectid=%llu, type=%d, offset=%llu)," 1909 " new(gen=%llu)," 1910 " which is referenced by most recent superblock" 1911 " (superblockgen=%llu)!\n", 1912 btrfsic_get_block_type(state, block), bytenr, 1913 dev_state->name, dev_bytenr, block->mirror_num, 1914 block->generation, 1915 btrfs_disk_key_objectid(&block->disk_key), 1916 block->disk_key.type, 1917 btrfs_disk_key_offset(&block->disk_key), 1918 btrfs_stack_header_generation( 1919 (struct btrfs_header *) mapped_datav[0]), 1920 state->max_superblock_generation); 1921 btrfsic_dump_tree(state); 1922 } 1923 1924 if (!block->is_iodone && !block->never_written) { 1925 printk(KERN_INFO "btrfs: attempt to overwrite %c-block" 1926 " @%llu (%s/%llu/%d), oldgen=%llu, newgen=%llu," 1927 " which is not yet iodone!\n", 1928 btrfsic_get_block_type(state, block), bytenr, 1929 dev_state->name, dev_bytenr, block->mirror_num, 1930 block->generation, 1931 btrfs_stack_header_generation( 1932 (struct btrfs_header *) 1933 mapped_datav[0])); 1934 /* it would not be safe to go on */ 1935 btrfsic_dump_tree(state); 1936 goto continue_loop; 1937 } 1938 1939 /* 1940 * Clear all references of this block. Do not free 1941 * the block itself even if is not referenced anymore 1942 * because it still carries valueable information 1943 * like whether it was ever written and IO completed. 1944 */ 1945 list_for_each_entry_safe(l, tmp, &block->ref_to_list, 1946 node_ref_to) { 1947 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 1948 btrfsic_print_rem_link(state, l); 1949 l->ref_cnt--; 1950 if (0 == l->ref_cnt) { 1951 list_del(&l->node_ref_to); 1952 list_del(&l->node_ref_from); 1953 btrfsic_block_link_hashtable_remove(l); 1954 btrfsic_block_link_free(l); 1955 } 1956 } 1957 1958 block_ctx.dev = dev_state; 1959 block_ctx.dev_bytenr = dev_bytenr; 1960 block_ctx.start = bytenr; 1961 block_ctx.len = processed_len; 1962 block_ctx.pagev = NULL; 1963 block_ctx.mem_to_free = NULL; 1964 block_ctx.datav = mapped_datav; 1965 1966 if (is_metadata || state->include_extent_data) { 1967 block->never_written = 0; 1968 block->iodone_w_error = 0; 1969 if (NULL != bio) { 1970 block->is_iodone = 0; 1971 BUG_ON(NULL == bio_is_patched); 1972 if (!*bio_is_patched) { 1973 block->orig_bio_bh_private = 1974 bio->bi_private; 1975 block->orig_bio_bh_end_io.bio = 1976 bio->bi_end_io; 1977 block->next_in_same_bio = NULL; 1978 bio->bi_private = block; 1979 bio->bi_end_io = btrfsic_bio_end_io; 1980 *bio_is_patched = 1; 1981 } else { 1982 struct btrfsic_block *chained_block = 1983 (struct btrfsic_block *) 1984 bio->bi_private; 1985 1986 BUG_ON(NULL == chained_block); 1987 block->orig_bio_bh_private = 1988 chained_block->orig_bio_bh_private; 1989 block->orig_bio_bh_end_io.bio = 1990 chained_block->orig_bio_bh_end_io. 1991 bio; 1992 block->next_in_same_bio = chained_block; 1993 bio->bi_private = block; 1994 } 1995 } else if (NULL != bh) { 1996 block->is_iodone = 0; 1997 block->orig_bio_bh_private = bh->b_private; 1998 block->orig_bio_bh_end_io.bh = bh->b_end_io; 1999 block->next_in_same_bio = NULL; 2000 bh->b_private = block; 2001 bh->b_end_io = btrfsic_bh_end_io; 2002 } else { 2003 block->is_iodone = 1; 2004 block->orig_bio_bh_private = NULL; 2005 block->orig_bio_bh_end_io.bio = NULL; 2006 block->next_in_same_bio = NULL; 2007 } 2008 } 2009 2010 block->flush_gen = dev_state->last_flush_gen + 1; 2011 block->submit_bio_bh_rw = submit_bio_bh_rw; 2012 if (is_metadata) { 2013 block->logical_bytenr = bytenr; 2014 block->is_metadata = 1; 2015 if (block->is_superblock) { 2016 BUG_ON(PAGE_SIZE != 2017 BTRFS_SUPER_INFO_SIZE); 2018 ret = btrfsic_process_written_superblock( 2019 state, 2020 block, 2021 (struct btrfs_super_block *) 2022 mapped_datav[0]); 2023 if (state->print_mask & 2024 BTRFSIC_PRINT_MASK_TREE_AFTER_SB_WRITE) { 2025 printk(KERN_INFO 2026 "[after new superblock is written]:\n"); 2027 btrfsic_dump_tree_sub(state, block, 0); 2028 } 2029 } else { 2030 block->mirror_num = 0; /* unknown */ 2031 ret = btrfsic_process_metablock( 2032 state, 2033 block, 2034 &block_ctx, 2035 0, 0); 2036 } 2037 if (ret) 2038 printk(KERN_INFO 2039 "btrfsic: btrfsic_process_metablock" 2040 "(root @%llu) failed!\n", 2041 dev_bytenr); 2042 } else { 2043 block->is_metadata = 0; 2044 block->mirror_num = 0; /* unknown */ 2045 block->generation = BTRFSIC_GENERATION_UNKNOWN; 2046 if (!state->include_extent_data 2047 && list_empty(&block->ref_from_list)) { 2048 /* 2049 * disk block is overwritten with extent 2050 * data (not meta data) and we are configured 2051 * to not include extent data: take the 2052 * chance and free the block's memory 2053 */ 2054 btrfsic_block_hashtable_remove(block); 2055 list_del(&block->all_blocks_node); 2056 btrfsic_block_free(block); 2057 } 2058 } 2059 btrfsic_release_block_ctx(&block_ctx); 2060 } else { 2061 /* block has not been found in hash table */ 2062 u64 bytenr; 2063 2064 if (!is_metadata) { 2065 processed_len = state->datablock_size; 2066 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2067 printk(KERN_INFO "Written block (%s/%llu/?)" 2068 " !found in hash table, D.\n", 2069 dev_state->name, dev_bytenr); 2070 if (!state->include_extent_data) { 2071 /* ignore that written D block */ 2072 goto continue_loop; 2073 } 2074 2075 /* this is getting ugly for the 2076 * include_extent_data case... */ 2077 bytenr = 0; /* unknown */ 2078 } else { 2079 processed_len = state->metablock_size; 2080 bytenr = btrfs_stack_header_bytenr( 2081 (struct btrfs_header *) 2082 mapped_datav[0]); 2083 btrfsic_cmp_log_and_dev_bytenr(state, bytenr, dev_state, 2084 dev_bytenr); 2085 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2086 printk(KERN_INFO 2087 "Written block @%llu (%s/%llu/?)" 2088 " !found in hash table, M.\n", 2089 bytenr, dev_state->name, dev_bytenr); 2090 } 2091 2092 block_ctx.dev = dev_state; 2093 block_ctx.dev_bytenr = dev_bytenr; 2094 block_ctx.start = bytenr; 2095 block_ctx.len = processed_len; 2096 block_ctx.pagev = NULL; 2097 block_ctx.mem_to_free = NULL; 2098 block_ctx.datav = mapped_datav; 2099 2100 block = btrfsic_block_alloc(); 2101 if (NULL == block) { 2102 printk(KERN_INFO "btrfsic: error, kmalloc failed!\n"); 2103 btrfsic_release_block_ctx(&block_ctx); 2104 goto continue_loop; 2105 } 2106 block->dev_state = dev_state; 2107 block->dev_bytenr = dev_bytenr; 2108 block->logical_bytenr = bytenr; 2109 block->is_metadata = is_metadata; 2110 block->never_written = 0; 2111 block->iodone_w_error = 0; 2112 block->mirror_num = 0; /* unknown */ 2113 block->flush_gen = dev_state->last_flush_gen + 1; 2114 block->submit_bio_bh_rw = submit_bio_bh_rw; 2115 if (NULL != bio) { 2116 block->is_iodone = 0; 2117 BUG_ON(NULL == bio_is_patched); 2118 if (!*bio_is_patched) { 2119 block->orig_bio_bh_private = bio->bi_private; 2120 block->orig_bio_bh_end_io.bio = bio->bi_end_io; 2121 block->next_in_same_bio = NULL; 2122 bio->bi_private = block; 2123 bio->bi_end_io = btrfsic_bio_end_io; 2124 *bio_is_patched = 1; 2125 } else { 2126 struct btrfsic_block *chained_block = 2127 (struct btrfsic_block *) 2128 bio->bi_private; 2129 2130 BUG_ON(NULL == chained_block); 2131 block->orig_bio_bh_private = 2132 chained_block->orig_bio_bh_private; 2133 block->orig_bio_bh_end_io.bio = 2134 chained_block->orig_bio_bh_end_io.bio; 2135 block->next_in_same_bio = chained_block; 2136 bio->bi_private = block; 2137 } 2138 } else if (NULL != bh) { 2139 block->is_iodone = 0; 2140 block->orig_bio_bh_private = bh->b_private; 2141 block->orig_bio_bh_end_io.bh = bh->b_end_io; 2142 block->next_in_same_bio = NULL; 2143 bh->b_private = block; 2144 bh->b_end_io = btrfsic_bh_end_io; 2145 } else { 2146 block->is_iodone = 1; 2147 block->orig_bio_bh_private = NULL; 2148 block->orig_bio_bh_end_io.bio = NULL; 2149 block->next_in_same_bio = NULL; 2150 } 2151 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2152 printk(KERN_INFO 2153 "New written %c-block @%llu (%s/%llu/%d)\n", 2154 is_metadata ? 'M' : 'D', 2155 block->logical_bytenr, block->dev_state->name, 2156 block->dev_bytenr, block->mirror_num); 2157 list_add(&block->all_blocks_node, &state->all_blocks_list); 2158 btrfsic_block_hashtable_add(block, &state->block_hashtable); 2159 2160 if (is_metadata) { 2161 ret = btrfsic_process_metablock(state, block, 2162 &block_ctx, 0, 0); 2163 if (ret) 2164 printk(KERN_INFO 2165 "btrfsic: process_metablock(root @%llu)" 2166 " failed!\n", 2167 dev_bytenr); 2168 } 2169 btrfsic_release_block_ctx(&block_ctx); 2170 } 2171 2172 continue_loop: 2173 BUG_ON(!processed_len); 2174 dev_bytenr += processed_len; 2175 mapped_datav += processed_len >> PAGE_SHIFT; 2176 num_pages -= processed_len >> PAGE_SHIFT; 2177 goto again; 2178 } 2179 2180 static void btrfsic_bio_end_io(struct bio *bp) 2181 { 2182 struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private; 2183 int iodone_w_error; 2184 2185 /* mutex is not held! This is not save if IO is not yet completed 2186 * on umount */ 2187 iodone_w_error = 0; 2188 if (bp->bi_error) 2189 iodone_w_error = 1; 2190 2191 BUG_ON(NULL == block); 2192 bp->bi_private = block->orig_bio_bh_private; 2193 bp->bi_end_io = block->orig_bio_bh_end_io.bio; 2194 2195 do { 2196 struct btrfsic_block *next_block; 2197 struct btrfsic_dev_state *const dev_state = block->dev_state; 2198 2199 if ((dev_state->state->print_mask & 2200 BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) 2201 printk(KERN_INFO 2202 "bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n", 2203 bp->bi_error, 2204 btrfsic_get_block_type(dev_state->state, block), 2205 block->logical_bytenr, dev_state->name, 2206 block->dev_bytenr, block->mirror_num); 2207 next_block = block->next_in_same_bio; 2208 block->iodone_w_error = iodone_w_error; 2209 if (block->submit_bio_bh_rw & REQ_FLUSH) { 2210 dev_state->last_flush_gen++; 2211 if ((dev_state->state->print_mask & 2212 BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) 2213 printk(KERN_INFO 2214 "bio_end_io() new %s flush_gen=%llu\n", 2215 dev_state->name, 2216 dev_state->last_flush_gen); 2217 } 2218 if (block->submit_bio_bh_rw & REQ_FUA) 2219 block->flush_gen = 0; /* FUA completed means block is 2220 * on disk */ 2221 block->is_iodone = 1; /* for FLUSH, this releases the block */ 2222 block = next_block; 2223 } while (NULL != block); 2224 2225 bp->bi_end_io(bp); 2226 } 2227 2228 static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate) 2229 { 2230 struct btrfsic_block *block = (struct btrfsic_block *)bh->b_private; 2231 int iodone_w_error = !uptodate; 2232 struct btrfsic_dev_state *dev_state; 2233 2234 BUG_ON(NULL == block); 2235 dev_state = block->dev_state; 2236 if ((dev_state->state->print_mask & BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) 2237 printk(KERN_INFO 2238 "bh_end_io(error=%d) for %c @%llu (%s/%llu/%d)\n", 2239 iodone_w_error, 2240 btrfsic_get_block_type(dev_state->state, block), 2241 block->logical_bytenr, block->dev_state->name, 2242 block->dev_bytenr, block->mirror_num); 2243 2244 block->iodone_w_error = iodone_w_error; 2245 if (block->submit_bio_bh_rw & REQ_FLUSH) { 2246 dev_state->last_flush_gen++; 2247 if ((dev_state->state->print_mask & 2248 BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) 2249 printk(KERN_INFO 2250 "bh_end_io() new %s flush_gen=%llu\n", 2251 dev_state->name, dev_state->last_flush_gen); 2252 } 2253 if (block->submit_bio_bh_rw & REQ_FUA) 2254 block->flush_gen = 0; /* FUA completed means block is on disk */ 2255 2256 bh->b_private = block->orig_bio_bh_private; 2257 bh->b_end_io = block->orig_bio_bh_end_io.bh; 2258 block->is_iodone = 1; /* for FLUSH, this releases the block */ 2259 bh->b_end_io(bh, uptodate); 2260 } 2261 2262 static int btrfsic_process_written_superblock( 2263 struct btrfsic_state *state, 2264 struct btrfsic_block *const superblock, 2265 struct btrfs_super_block *const super_hdr) 2266 { 2267 int pass; 2268 2269 superblock->generation = btrfs_super_generation(super_hdr); 2270 if (!(superblock->generation > state->max_superblock_generation || 2271 0 == state->max_superblock_generation)) { 2272 if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE) 2273 printk(KERN_INFO 2274 "btrfsic: superblock @%llu (%s/%llu/%d)" 2275 " with old gen %llu <= %llu\n", 2276 superblock->logical_bytenr, 2277 superblock->dev_state->name, 2278 superblock->dev_bytenr, superblock->mirror_num, 2279 btrfs_super_generation(super_hdr), 2280 state->max_superblock_generation); 2281 } else { 2282 if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE) 2283 printk(KERN_INFO 2284 "btrfsic: got new superblock @%llu (%s/%llu/%d)" 2285 " with new gen %llu > %llu\n", 2286 superblock->logical_bytenr, 2287 superblock->dev_state->name, 2288 superblock->dev_bytenr, superblock->mirror_num, 2289 btrfs_super_generation(super_hdr), 2290 state->max_superblock_generation); 2291 2292 state->max_superblock_generation = 2293 btrfs_super_generation(super_hdr); 2294 state->latest_superblock = superblock; 2295 } 2296 2297 for (pass = 0; pass < 3; pass++) { 2298 int ret; 2299 u64 next_bytenr; 2300 struct btrfsic_block *next_block; 2301 struct btrfsic_block_data_ctx tmp_next_block_ctx; 2302 struct btrfsic_block_link *l; 2303 int num_copies; 2304 int mirror_num; 2305 const char *additional_string = NULL; 2306 struct btrfs_disk_key tmp_disk_key = {0}; 2307 2308 btrfs_set_disk_key_objectid(&tmp_disk_key, 2309 BTRFS_ROOT_ITEM_KEY); 2310 btrfs_set_disk_key_objectid(&tmp_disk_key, 0); 2311 2312 switch (pass) { 2313 case 0: 2314 btrfs_set_disk_key_objectid(&tmp_disk_key, 2315 BTRFS_ROOT_TREE_OBJECTID); 2316 additional_string = "root "; 2317 next_bytenr = btrfs_super_root(super_hdr); 2318 if (state->print_mask & 2319 BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) 2320 printk(KERN_INFO "root@%llu\n", next_bytenr); 2321 break; 2322 case 1: 2323 btrfs_set_disk_key_objectid(&tmp_disk_key, 2324 BTRFS_CHUNK_TREE_OBJECTID); 2325 additional_string = "chunk "; 2326 next_bytenr = btrfs_super_chunk_root(super_hdr); 2327 if (state->print_mask & 2328 BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) 2329 printk(KERN_INFO "chunk@%llu\n", next_bytenr); 2330 break; 2331 case 2: 2332 btrfs_set_disk_key_objectid(&tmp_disk_key, 2333 BTRFS_TREE_LOG_OBJECTID); 2334 additional_string = "log "; 2335 next_bytenr = btrfs_super_log_root(super_hdr); 2336 if (0 == next_bytenr) 2337 continue; 2338 if (state->print_mask & 2339 BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) 2340 printk(KERN_INFO "log@%llu\n", next_bytenr); 2341 break; 2342 } 2343 2344 num_copies = 2345 btrfs_num_copies(state->root->fs_info, 2346 next_bytenr, BTRFS_SUPER_INFO_SIZE); 2347 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) 2348 printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n", 2349 next_bytenr, num_copies); 2350 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { 2351 int was_created; 2352 2353 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2354 printk(KERN_INFO 2355 "btrfsic_process_written_superblock(" 2356 "mirror_num=%d)\n", mirror_num); 2357 ret = btrfsic_map_block(state, next_bytenr, 2358 BTRFS_SUPER_INFO_SIZE, 2359 &tmp_next_block_ctx, 2360 mirror_num); 2361 if (ret) { 2362 printk(KERN_INFO 2363 "btrfsic: btrfsic_map_block(@%llu," 2364 " mirror=%d) failed!\n", 2365 next_bytenr, mirror_num); 2366 return -1; 2367 } 2368 2369 next_block = btrfsic_block_lookup_or_add( 2370 state, 2371 &tmp_next_block_ctx, 2372 additional_string, 2373 1, 0, 1, 2374 mirror_num, 2375 &was_created); 2376 if (NULL == next_block) { 2377 printk(KERN_INFO 2378 "btrfsic: error, kmalloc failed!\n"); 2379 btrfsic_release_block_ctx(&tmp_next_block_ctx); 2380 return -1; 2381 } 2382 2383 next_block->disk_key = tmp_disk_key; 2384 if (was_created) 2385 next_block->generation = 2386 BTRFSIC_GENERATION_UNKNOWN; 2387 l = btrfsic_block_link_lookup_or_add( 2388 state, 2389 &tmp_next_block_ctx, 2390 next_block, 2391 superblock, 2392 BTRFSIC_GENERATION_UNKNOWN); 2393 btrfsic_release_block_ctx(&tmp_next_block_ctx); 2394 if (NULL == l) 2395 return -1; 2396 } 2397 } 2398 2399 if (WARN_ON(-1 == btrfsic_check_all_ref_blocks(state, superblock, 0))) 2400 btrfsic_dump_tree(state); 2401 2402 return 0; 2403 } 2404 2405 static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state, 2406 struct btrfsic_block *const block, 2407 int recursion_level) 2408 { 2409 const struct btrfsic_block_link *l; 2410 int ret = 0; 2411 2412 if (recursion_level >= 3 + BTRFS_MAX_LEVEL) { 2413 /* 2414 * Note that this situation can happen and does not 2415 * indicate an error in regular cases. It happens 2416 * when disk blocks are freed and later reused. 2417 * The check-integrity module is not aware of any 2418 * block free operations, it just recognizes block 2419 * write operations. Therefore it keeps the linkage 2420 * information for a block until a block is 2421 * rewritten. This can temporarily cause incorrect 2422 * and even circular linkage informations. This 2423 * causes no harm unless such blocks are referenced 2424 * by the most recent super block. 2425 */ 2426 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2427 printk(KERN_INFO 2428 "btrfsic: abort cyclic linkage (case 1).\n"); 2429 2430 return ret; 2431 } 2432 2433 /* 2434 * This algorithm is recursive because the amount of used stack 2435 * space is very small and the max recursion depth is limited. 2436 */ 2437 list_for_each_entry(l, &block->ref_to_list, node_ref_to) { 2438 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2439 printk(KERN_INFO 2440 "rl=%d, %c @%llu (%s/%llu/%d)" 2441 " %u* refers to %c @%llu (%s/%llu/%d)\n", 2442 recursion_level, 2443 btrfsic_get_block_type(state, block), 2444 block->logical_bytenr, block->dev_state->name, 2445 block->dev_bytenr, block->mirror_num, 2446 l->ref_cnt, 2447 btrfsic_get_block_type(state, l->block_ref_to), 2448 l->block_ref_to->logical_bytenr, 2449 l->block_ref_to->dev_state->name, 2450 l->block_ref_to->dev_bytenr, 2451 l->block_ref_to->mirror_num); 2452 if (l->block_ref_to->never_written) { 2453 printk(KERN_INFO "btrfs: attempt to write superblock" 2454 " which references block %c @%llu (%s/%llu/%d)" 2455 " which is never written!\n", 2456 btrfsic_get_block_type(state, l->block_ref_to), 2457 l->block_ref_to->logical_bytenr, 2458 l->block_ref_to->dev_state->name, 2459 l->block_ref_to->dev_bytenr, 2460 l->block_ref_to->mirror_num); 2461 ret = -1; 2462 } else if (!l->block_ref_to->is_iodone) { 2463 printk(KERN_INFO "btrfs: attempt to write superblock" 2464 " which references block %c @%llu (%s/%llu/%d)" 2465 " which is not yet iodone!\n", 2466 btrfsic_get_block_type(state, l->block_ref_to), 2467 l->block_ref_to->logical_bytenr, 2468 l->block_ref_to->dev_state->name, 2469 l->block_ref_to->dev_bytenr, 2470 l->block_ref_to->mirror_num); 2471 ret = -1; 2472 } else if (l->block_ref_to->iodone_w_error) { 2473 printk(KERN_INFO "btrfs: attempt to write superblock" 2474 " which references block %c @%llu (%s/%llu/%d)" 2475 " which has write error!\n", 2476 btrfsic_get_block_type(state, l->block_ref_to), 2477 l->block_ref_to->logical_bytenr, 2478 l->block_ref_to->dev_state->name, 2479 l->block_ref_to->dev_bytenr, 2480 l->block_ref_to->mirror_num); 2481 ret = -1; 2482 } else if (l->parent_generation != 2483 l->block_ref_to->generation && 2484 BTRFSIC_GENERATION_UNKNOWN != 2485 l->parent_generation && 2486 BTRFSIC_GENERATION_UNKNOWN != 2487 l->block_ref_to->generation) { 2488 printk(KERN_INFO "btrfs: attempt to write superblock" 2489 " which references block %c @%llu (%s/%llu/%d)" 2490 " with generation %llu !=" 2491 " parent generation %llu!\n", 2492 btrfsic_get_block_type(state, l->block_ref_to), 2493 l->block_ref_to->logical_bytenr, 2494 l->block_ref_to->dev_state->name, 2495 l->block_ref_to->dev_bytenr, 2496 l->block_ref_to->mirror_num, 2497 l->block_ref_to->generation, 2498 l->parent_generation); 2499 ret = -1; 2500 } else if (l->block_ref_to->flush_gen > 2501 l->block_ref_to->dev_state->last_flush_gen) { 2502 printk(KERN_INFO "btrfs: attempt to write superblock" 2503 " which references block %c @%llu (%s/%llu/%d)" 2504 " which is not flushed out of disk's write cache" 2505 " (block flush_gen=%llu," 2506 " dev->flush_gen=%llu)!\n", 2507 btrfsic_get_block_type(state, l->block_ref_to), 2508 l->block_ref_to->logical_bytenr, 2509 l->block_ref_to->dev_state->name, 2510 l->block_ref_to->dev_bytenr, 2511 l->block_ref_to->mirror_num, block->flush_gen, 2512 l->block_ref_to->dev_state->last_flush_gen); 2513 ret = -1; 2514 } else if (-1 == btrfsic_check_all_ref_blocks(state, 2515 l->block_ref_to, 2516 recursion_level + 2517 1)) { 2518 ret = -1; 2519 } 2520 } 2521 2522 return ret; 2523 } 2524 2525 static int btrfsic_is_block_ref_by_superblock( 2526 const struct btrfsic_state *state, 2527 const struct btrfsic_block *block, 2528 int recursion_level) 2529 { 2530 const struct btrfsic_block_link *l; 2531 2532 if (recursion_level >= 3 + BTRFS_MAX_LEVEL) { 2533 /* refer to comment at "abort cyclic linkage (case 1)" */ 2534 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2535 printk(KERN_INFO 2536 "btrfsic: abort cyclic linkage (case 2).\n"); 2537 2538 return 0; 2539 } 2540 2541 /* 2542 * This algorithm is recursive because the amount of used stack space 2543 * is very small and the max recursion depth is limited. 2544 */ 2545 list_for_each_entry(l, &block->ref_from_list, node_ref_from) { 2546 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2547 printk(KERN_INFO 2548 "rl=%d, %c @%llu (%s/%llu/%d)" 2549 " is ref %u* from %c @%llu (%s/%llu/%d)\n", 2550 recursion_level, 2551 btrfsic_get_block_type(state, block), 2552 block->logical_bytenr, block->dev_state->name, 2553 block->dev_bytenr, block->mirror_num, 2554 l->ref_cnt, 2555 btrfsic_get_block_type(state, l->block_ref_from), 2556 l->block_ref_from->logical_bytenr, 2557 l->block_ref_from->dev_state->name, 2558 l->block_ref_from->dev_bytenr, 2559 l->block_ref_from->mirror_num); 2560 if (l->block_ref_from->is_superblock && 2561 state->latest_superblock->dev_bytenr == 2562 l->block_ref_from->dev_bytenr && 2563 state->latest_superblock->dev_state->bdev == 2564 l->block_ref_from->dev_state->bdev) 2565 return 1; 2566 else if (btrfsic_is_block_ref_by_superblock(state, 2567 l->block_ref_from, 2568 recursion_level + 2569 1)) 2570 return 1; 2571 } 2572 2573 return 0; 2574 } 2575 2576 static void btrfsic_print_add_link(const struct btrfsic_state *state, 2577 const struct btrfsic_block_link *l) 2578 { 2579 printk(KERN_INFO 2580 "Add %u* link from %c @%llu (%s/%llu/%d)" 2581 " to %c @%llu (%s/%llu/%d).\n", 2582 l->ref_cnt, 2583 btrfsic_get_block_type(state, l->block_ref_from), 2584 l->block_ref_from->logical_bytenr, 2585 l->block_ref_from->dev_state->name, 2586 l->block_ref_from->dev_bytenr, l->block_ref_from->mirror_num, 2587 btrfsic_get_block_type(state, l->block_ref_to), 2588 l->block_ref_to->logical_bytenr, 2589 l->block_ref_to->dev_state->name, l->block_ref_to->dev_bytenr, 2590 l->block_ref_to->mirror_num); 2591 } 2592 2593 static void btrfsic_print_rem_link(const struct btrfsic_state *state, 2594 const struct btrfsic_block_link *l) 2595 { 2596 printk(KERN_INFO 2597 "Rem %u* link from %c @%llu (%s/%llu/%d)" 2598 " to %c @%llu (%s/%llu/%d).\n", 2599 l->ref_cnt, 2600 btrfsic_get_block_type(state, l->block_ref_from), 2601 l->block_ref_from->logical_bytenr, 2602 l->block_ref_from->dev_state->name, 2603 l->block_ref_from->dev_bytenr, l->block_ref_from->mirror_num, 2604 btrfsic_get_block_type(state, l->block_ref_to), 2605 l->block_ref_to->logical_bytenr, 2606 l->block_ref_to->dev_state->name, l->block_ref_to->dev_bytenr, 2607 l->block_ref_to->mirror_num); 2608 } 2609 2610 static char btrfsic_get_block_type(const struct btrfsic_state *state, 2611 const struct btrfsic_block *block) 2612 { 2613 if (block->is_superblock && 2614 state->latest_superblock->dev_bytenr == block->dev_bytenr && 2615 state->latest_superblock->dev_state->bdev == block->dev_state->bdev) 2616 return 'S'; 2617 else if (block->is_superblock) 2618 return 's'; 2619 else if (block->is_metadata) 2620 return 'M'; 2621 else 2622 return 'D'; 2623 } 2624 2625 static void btrfsic_dump_tree(const struct btrfsic_state *state) 2626 { 2627 btrfsic_dump_tree_sub(state, state->latest_superblock, 0); 2628 } 2629 2630 static void btrfsic_dump_tree_sub(const struct btrfsic_state *state, 2631 const struct btrfsic_block *block, 2632 int indent_level) 2633 { 2634 const struct btrfsic_block_link *l; 2635 int indent_add; 2636 static char buf[80]; 2637 int cursor_position; 2638 2639 /* 2640 * Should better fill an on-stack buffer with a complete line and 2641 * dump it at once when it is time to print a newline character. 2642 */ 2643 2644 /* 2645 * This algorithm is recursive because the amount of used stack space 2646 * is very small and the max recursion depth is limited. 2647 */ 2648 indent_add = sprintf(buf, "%c-%llu(%s/%llu/%d)", 2649 btrfsic_get_block_type(state, block), 2650 block->logical_bytenr, block->dev_state->name, 2651 block->dev_bytenr, block->mirror_num); 2652 if (indent_level + indent_add > BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) { 2653 printk("[...]\n"); 2654 return; 2655 } 2656 printk(buf); 2657 indent_level += indent_add; 2658 if (list_empty(&block->ref_to_list)) { 2659 printk("\n"); 2660 return; 2661 } 2662 if (block->mirror_num > 1 && 2663 !(state->print_mask & BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS)) { 2664 printk(" [...]\n"); 2665 return; 2666 } 2667 2668 cursor_position = indent_level; 2669 list_for_each_entry(l, &block->ref_to_list, node_ref_to) { 2670 while (cursor_position < indent_level) { 2671 printk(" "); 2672 cursor_position++; 2673 } 2674 if (l->ref_cnt > 1) 2675 indent_add = sprintf(buf, " %d*--> ", l->ref_cnt); 2676 else 2677 indent_add = sprintf(buf, " --> "); 2678 if (indent_level + indent_add > 2679 BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) { 2680 printk("[...]\n"); 2681 cursor_position = 0; 2682 continue; 2683 } 2684 2685 printk(buf); 2686 2687 btrfsic_dump_tree_sub(state, l->block_ref_to, 2688 indent_level + indent_add); 2689 cursor_position = 0; 2690 } 2691 } 2692 2693 static struct btrfsic_block_link *btrfsic_block_link_lookup_or_add( 2694 struct btrfsic_state *state, 2695 struct btrfsic_block_data_ctx *next_block_ctx, 2696 struct btrfsic_block *next_block, 2697 struct btrfsic_block *from_block, 2698 u64 parent_generation) 2699 { 2700 struct btrfsic_block_link *l; 2701 2702 l = btrfsic_block_link_hashtable_lookup(next_block_ctx->dev->bdev, 2703 next_block_ctx->dev_bytenr, 2704 from_block->dev_state->bdev, 2705 from_block->dev_bytenr, 2706 &state->block_link_hashtable); 2707 if (NULL == l) { 2708 l = btrfsic_block_link_alloc(); 2709 if (NULL == l) { 2710 printk(KERN_INFO 2711 "btrfsic: error, kmalloc" " failed!\n"); 2712 return NULL; 2713 } 2714 2715 l->block_ref_to = next_block; 2716 l->block_ref_from = from_block; 2717 l->ref_cnt = 1; 2718 l->parent_generation = parent_generation; 2719 2720 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2721 btrfsic_print_add_link(state, l); 2722 2723 list_add(&l->node_ref_to, &from_block->ref_to_list); 2724 list_add(&l->node_ref_from, &next_block->ref_from_list); 2725 2726 btrfsic_block_link_hashtable_add(l, 2727 &state->block_link_hashtable); 2728 } else { 2729 l->ref_cnt++; 2730 l->parent_generation = parent_generation; 2731 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2732 btrfsic_print_add_link(state, l); 2733 } 2734 2735 return l; 2736 } 2737 2738 static struct btrfsic_block *btrfsic_block_lookup_or_add( 2739 struct btrfsic_state *state, 2740 struct btrfsic_block_data_ctx *block_ctx, 2741 const char *additional_string, 2742 int is_metadata, 2743 int is_iodone, 2744 int never_written, 2745 int mirror_num, 2746 int *was_created) 2747 { 2748 struct btrfsic_block *block; 2749 2750 block = btrfsic_block_hashtable_lookup(block_ctx->dev->bdev, 2751 block_ctx->dev_bytenr, 2752 &state->block_hashtable); 2753 if (NULL == block) { 2754 struct btrfsic_dev_state *dev_state; 2755 2756 block = btrfsic_block_alloc(); 2757 if (NULL == block) { 2758 printk(KERN_INFO "btrfsic: error, kmalloc failed!\n"); 2759 return NULL; 2760 } 2761 dev_state = btrfsic_dev_state_lookup(block_ctx->dev->bdev); 2762 if (NULL == dev_state) { 2763 printk(KERN_INFO 2764 "btrfsic: error, lookup dev_state failed!\n"); 2765 btrfsic_block_free(block); 2766 return NULL; 2767 } 2768 block->dev_state = dev_state; 2769 block->dev_bytenr = block_ctx->dev_bytenr; 2770 block->logical_bytenr = block_ctx->start; 2771 block->is_metadata = is_metadata; 2772 block->is_iodone = is_iodone; 2773 block->never_written = never_written; 2774 block->mirror_num = mirror_num; 2775 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 2776 printk(KERN_INFO 2777 "New %s%c-block @%llu (%s/%llu/%d)\n", 2778 additional_string, 2779 btrfsic_get_block_type(state, block), 2780 block->logical_bytenr, dev_state->name, 2781 block->dev_bytenr, mirror_num); 2782 list_add(&block->all_blocks_node, &state->all_blocks_list); 2783 btrfsic_block_hashtable_add(block, &state->block_hashtable); 2784 if (NULL != was_created) 2785 *was_created = 1; 2786 } else { 2787 if (NULL != was_created) 2788 *was_created = 0; 2789 } 2790 2791 return block; 2792 } 2793 2794 static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state, 2795 u64 bytenr, 2796 struct btrfsic_dev_state *dev_state, 2797 u64 dev_bytenr) 2798 { 2799 int num_copies; 2800 int mirror_num; 2801 int ret; 2802 struct btrfsic_block_data_ctx block_ctx; 2803 int match = 0; 2804 2805 num_copies = btrfs_num_copies(state->root->fs_info, 2806 bytenr, state->metablock_size); 2807 2808 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { 2809 ret = btrfsic_map_block(state, bytenr, state->metablock_size, 2810 &block_ctx, mirror_num); 2811 if (ret) { 2812 printk(KERN_INFO "btrfsic:" 2813 " btrfsic_map_block(logical @%llu," 2814 " mirror %d) failed!\n", 2815 bytenr, mirror_num); 2816 continue; 2817 } 2818 2819 if (dev_state->bdev == block_ctx.dev->bdev && 2820 dev_bytenr == block_ctx.dev_bytenr) { 2821 match++; 2822 btrfsic_release_block_ctx(&block_ctx); 2823 break; 2824 } 2825 btrfsic_release_block_ctx(&block_ctx); 2826 } 2827 2828 if (WARN_ON(!match)) { 2829 printk(KERN_INFO "btrfs: attempt to write M-block which contains logical bytenr that doesn't map to dev+physical bytenr of submit_bio," 2830 " buffer->log_bytenr=%llu, submit_bio(bdev=%s," 2831 " phys_bytenr=%llu)!\n", 2832 bytenr, dev_state->name, dev_bytenr); 2833 for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { 2834 ret = btrfsic_map_block(state, bytenr, 2835 state->metablock_size, 2836 &block_ctx, mirror_num); 2837 if (ret) 2838 continue; 2839 2840 printk(KERN_INFO "Read logical bytenr @%llu maps to" 2841 " (%s/%llu/%d)\n", 2842 bytenr, block_ctx.dev->name, 2843 block_ctx.dev_bytenr, mirror_num); 2844 } 2845 } 2846 } 2847 2848 static struct btrfsic_dev_state *btrfsic_dev_state_lookup( 2849 struct block_device *bdev) 2850 { 2851 struct btrfsic_dev_state *ds; 2852 2853 ds = btrfsic_dev_state_hashtable_lookup(bdev, 2854 &btrfsic_dev_state_hashtable); 2855 return ds; 2856 } 2857 2858 int btrfsic_submit_bh(int rw, struct buffer_head *bh) 2859 { 2860 struct btrfsic_dev_state *dev_state; 2861 2862 if (!btrfsic_is_initialized) 2863 return submit_bh(rw, bh); 2864 2865 mutex_lock(&btrfsic_mutex); 2866 /* since btrfsic_submit_bh() might also be called before 2867 * btrfsic_mount(), this might return NULL */ 2868 dev_state = btrfsic_dev_state_lookup(bh->b_bdev); 2869 2870 /* Only called to write the superblock (incl. FLUSH/FUA) */ 2871 if (NULL != dev_state && 2872 (rw & WRITE) && bh->b_size > 0) { 2873 u64 dev_bytenr; 2874 2875 dev_bytenr = 4096 * bh->b_blocknr; 2876 if (dev_state->state->print_mask & 2877 BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) 2878 printk(KERN_INFO 2879 "submit_bh(rw=0x%x, blocknr=%llu (bytenr %llu)," 2880 " size=%zu, data=%p, bdev=%p)\n", 2881 rw, (unsigned long long)bh->b_blocknr, 2882 dev_bytenr, bh->b_size, bh->b_data, bh->b_bdev); 2883 btrfsic_process_written_block(dev_state, dev_bytenr, 2884 &bh->b_data, 1, NULL, 2885 NULL, bh, rw); 2886 } else if (NULL != dev_state && (rw & REQ_FLUSH)) { 2887 if (dev_state->state->print_mask & 2888 BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) 2889 printk(KERN_INFO 2890 "submit_bh(rw=0x%x FLUSH, bdev=%p)\n", 2891 rw, bh->b_bdev); 2892 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) { 2893 if ((dev_state->state->print_mask & 2894 (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH | 2895 BTRFSIC_PRINT_MASK_VERBOSE))) 2896 printk(KERN_INFO 2897 "btrfsic_submit_bh(%s) with FLUSH" 2898 " but dummy block already in use" 2899 " (ignored)!\n", 2900 dev_state->name); 2901 } else { 2902 struct btrfsic_block *const block = 2903 &dev_state->dummy_block_for_bio_bh_flush; 2904 2905 block->is_iodone = 0; 2906 block->never_written = 0; 2907 block->iodone_w_error = 0; 2908 block->flush_gen = dev_state->last_flush_gen + 1; 2909 block->submit_bio_bh_rw = rw; 2910 block->orig_bio_bh_private = bh->b_private; 2911 block->orig_bio_bh_end_io.bh = bh->b_end_io; 2912 block->next_in_same_bio = NULL; 2913 bh->b_private = block; 2914 bh->b_end_io = btrfsic_bh_end_io; 2915 } 2916 } 2917 mutex_unlock(&btrfsic_mutex); 2918 return submit_bh(rw, bh); 2919 } 2920 2921 static void __btrfsic_submit_bio(int rw, struct bio *bio) 2922 { 2923 struct btrfsic_dev_state *dev_state; 2924 2925 if (!btrfsic_is_initialized) 2926 return; 2927 2928 mutex_lock(&btrfsic_mutex); 2929 /* since btrfsic_submit_bio() is also called before 2930 * btrfsic_mount(), this might return NULL */ 2931 dev_state = btrfsic_dev_state_lookup(bio->bi_bdev); 2932 if (NULL != dev_state && 2933 (rw & WRITE) && NULL != bio->bi_io_vec) { 2934 unsigned int i; 2935 u64 dev_bytenr; 2936 u64 cur_bytenr; 2937 int bio_is_patched; 2938 char **mapped_datav; 2939 2940 dev_bytenr = 512 * bio->bi_iter.bi_sector; 2941 bio_is_patched = 0; 2942 if (dev_state->state->print_mask & 2943 BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) 2944 printk(KERN_INFO 2945 "submit_bio(rw=0x%x, bi_vcnt=%u," 2946 " bi_sector=%llu (bytenr %llu), bi_bdev=%p)\n", 2947 rw, bio->bi_vcnt, 2948 (unsigned long long)bio->bi_iter.bi_sector, 2949 dev_bytenr, bio->bi_bdev); 2950 2951 mapped_datav = kmalloc_array(bio->bi_vcnt, 2952 sizeof(*mapped_datav), GFP_NOFS); 2953 if (!mapped_datav) 2954 goto leave; 2955 cur_bytenr = dev_bytenr; 2956 for (i = 0; i < bio->bi_vcnt; i++) { 2957 BUG_ON(bio->bi_io_vec[i].bv_len != PAGE_SIZE); 2958 mapped_datav[i] = kmap(bio->bi_io_vec[i].bv_page); 2959 if (!mapped_datav[i]) { 2960 while (i > 0) { 2961 i--; 2962 kunmap(bio->bi_io_vec[i].bv_page); 2963 } 2964 kfree(mapped_datav); 2965 goto leave; 2966 } 2967 if (dev_state->state->print_mask & 2968 BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE) 2969 printk(KERN_INFO 2970 "#%u: bytenr=%llu, len=%u, offset=%u\n", 2971 i, cur_bytenr, bio->bi_io_vec[i].bv_len, 2972 bio->bi_io_vec[i].bv_offset); 2973 cur_bytenr += bio->bi_io_vec[i].bv_len; 2974 } 2975 btrfsic_process_written_block(dev_state, dev_bytenr, 2976 mapped_datav, bio->bi_vcnt, 2977 bio, &bio_is_patched, 2978 NULL, rw); 2979 while (i > 0) { 2980 i--; 2981 kunmap(bio->bi_io_vec[i].bv_page); 2982 } 2983 kfree(mapped_datav); 2984 } else if (NULL != dev_state && (rw & REQ_FLUSH)) { 2985 if (dev_state->state->print_mask & 2986 BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) 2987 printk(KERN_INFO 2988 "submit_bio(rw=0x%x FLUSH, bdev=%p)\n", 2989 rw, bio->bi_bdev); 2990 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) { 2991 if ((dev_state->state->print_mask & 2992 (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH | 2993 BTRFSIC_PRINT_MASK_VERBOSE))) 2994 printk(KERN_INFO 2995 "btrfsic_submit_bio(%s) with FLUSH" 2996 " but dummy block already in use" 2997 " (ignored)!\n", 2998 dev_state->name); 2999 } else { 3000 struct btrfsic_block *const block = 3001 &dev_state->dummy_block_for_bio_bh_flush; 3002 3003 block->is_iodone = 0; 3004 block->never_written = 0; 3005 block->iodone_w_error = 0; 3006 block->flush_gen = dev_state->last_flush_gen + 1; 3007 block->submit_bio_bh_rw = rw; 3008 block->orig_bio_bh_private = bio->bi_private; 3009 block->orig_bio_bh_end_io.bio = bio->bi_end_io; 3010 block->next_in_same_bio = NULL; 3011 bio->bi_private = block; 3012 bio->bi_end_io = btrfsic_bio_end_io; 3013 } 3014 } 3015 leave: 3016 mutex_unlock(&btrfsic_mutex); 3017 } 3018 3019 void btrfsic_submit_bio(int rw, struct bio *bio) 3020 { 3021 __btrfsic_submit_bio(rw, bio); 3022 submit_bio(rw, bio); 3023 } 3024 3025 int btrfsic_submit_bio_wait(int rw, struct bio *bio) 3026 { 3027 __btrfsic_submit_bio(rw, bio); 3028 return submit_bio_wait(rw, bio); 3029 } 3030 3031 int btrfsic_mount(struct btrfs_root *root, 3032 struct btrfs_fs_devices *fs_devices, 3033 int including_extent_data, u32 print_mask) 3034 { 3035 int ret; 3036 struct btrfsic_state *state; 3037 struct list_head *dev_head = &fs_devices->devices; 3038 struct btrfs_device *device; 3039 3040 if (root->nodesize & ((u64)PAGE_SIZE - 1)) { 3041 printk(KERN_INFO 3042 "btrfsic: cannot handle nodesize %d not being a multiple of PAGE_SIZE %ld!\n", 3043 root->nodesize, PAGE_SIZE); 3044 return -1; 3045 } 3046 if (root->sectorsize & ((u64)PAGE_SIZE - 1)) { 3047 printk(KERN_INFO 3048 "btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_SIZE %ld!\n", 3049 root->sectorsize, PAGE_SIZE); 3050 return -1; 3051 } 3052 state = kzalloc(sizeof(*state), GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT); 3053 if (!state) { 3054 state = vzalloc(sizeof(*state)); 3055 if (!state) { 3056 printk(KERN_INFO "btrfs check-integrity: vzalloc() failed!\n"); 3057 return -1; 3058 } 3059 } 3060 3061 if (!btrfsic_is_initialized) { 3062 mutex_init(&btrfsic_mutex); 3063 btrfsic_dev_state_hashtable_init(&btrfsic_dev_state_hashtable); 3064 btrfsic_is_initialized = 1; 3065 } 3066 mutex_lock(&btrfsic_mutex); 3067 state->root = root; 3068 state->print_mask = print_mask; 3069 state->include_extent_data = including_extent_data; 3070 state->csum_size = 0; 3071 state->metablock_size = root->nodesize; 3072 state->datablock_size = root->sectorsize; 3073 INIT_LIST_HEAD(&state->all_blocks_list); 3074 btrfsic_block_hashtable_init(&state->block_hashtable); 3075 btrfsic_block_link_hashtable_init(&state->block_link_hashtable); 3076 state->max_superblock_generation = 0; 3077 state->latest_superblock = NULL; 3078 3079 list_for_each_entry(device, dev_head, dev_list) { 3080 struct btrfsic_dev_state *ds; 3081 const char *p; 3082 3083 if (!device->bdev || !device->name) 3084 continue; 3085 3086 ds = btrfsic_dev_state_alloc(); 3087 if (NULL == ds) { 3088 printk(KERN_INFO 3089 "btrfs check-integrity: kmalloc() failed!\n"); 3090 mutex_unlock(&btrfsic_mutex); 3091 return -1; 3092 } 3093 ds->bdev = device->bdev; 3094 ds->state = state; 3095 bdevname(ds->bdev, ds->name); 3096 ds->name[BDEVNAME_SIZE - 1] = '\0'; 3097 p = kbasename(ds->name); 3098 strlcpy(ds->name, p, sizeof(ds->name)); 3099 btrfsic_dev_state_hashtable_add(ds, 3100 &btrfsic_dev_state_hashtable); 3101 } 3102 3103 ret = btrfsic_process_superblock(state, fs_devices); 3104 if (0 != ret) { 3105 mutex_unlock(&btrfsic_mutex); 3106 btrfsic_unmount(root, fs_devices); 3107 return ret; 3108 } 3109 3110 if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_DATABASE) 3111 btrfsic_dump_database(state); 3112 if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_TREE) 3113 btrfsic_dump_tree(state); 3114 3115 mutex_unlock(&btrfsic_mutex); 3116 return 0; 3117 } 3118 3119 void btrfsic_unmount(struct btrfs_root *root, 3120 struct btrfs_fs_devices *fs_devices) 3121 { 3122 struct btrfsic_block *b_all, *tmp_all; 3123 struct btrfsic_state *state; 3124 struct list_head *dev_head = &fs_devices->devices; 3125 struct btrfs_device *device; 3126 3127 if (!btrfsic_is_initialized) 3128 return; 3129 3130 mutex_lock(&btrfsic_mutex); 3131 3132 state = NULL; 3133 list_for_each_entry(device, dev_head, dev_list) { 3134 struct btrfsic_dev_state *ds; 3135 3136 if (!device->bdev || !device->name) 3137 continue; 3138 3139 ds = btrfsic_dev_state_hashtable_lookup( 3140 device->bdev, 3141 &btrfsic_dev_state_hashtable); 3142 if (NULL != ds) { 3143 state = ds->state; 3144 btrfsic_dev_state_hashtable_remove(ds); 3145 btrfsic_dev_state_free(ds); 3146 } 3147 } 3148 3149 if (NULL == state) { 3150 printk(KERN_INFO 3151 "btrfsic: error, cannot find state information" 3152 " on umount!\n"); 3153 mutex_unlock(&btrfsic_mutex); 3154 return; 3155 } 3156 3157 /* 3158 * Don't care about keeping the lists' state up to date, 3159 * just free all memory that was allocated dynamically. 3160 * Free the blocks and the block_links. 3161 */ 3162 list_for_each_entry_safe(b_all, tmp_all, &state->all_blocks_list, 3163 all_blocks_node) { 3164 struct btrfsic_block_link *l, *tmp; 3165 3166 list_for_each_entry_safe(l, tmp, &b_all->ref_to_list, 3167 node_ref_to) { 3168 if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) 3169 btrfsic_print_rem_link(state, l); 3170 3171 l->ref_cnt--; 3172 if (0 == l->ref_cnt) 3173 btrfsic_block_link_free(l); 3174 } 3175 3176 if (b_all->is_iodone || b_all->never_written) 3177 btrfsic_block_free(b_all); 3178 else 3179 printk(KERN_INFO "btrfs: attempt to free %c-block" 3180 " @%llu (%s/%llu/%d) on umount which is" 3181 " not yet iodone!\n", 3182 btrfsic_get_block_type(state, b_all), 3183 b_all->logical_bytenr, b_all->dev_state->name, 3184 b_all->dev_bytenr, b_all->mirror_num); 3185 } 3186 3187 mutex_unlock(&btrfsic_mutex); 3188 3189 kvfree(state); 3190 } 3191