forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2875 lines
86 KiB
2875 lines
86 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) STRATO AG 2011. All rights reserved. |
|
*/ |
|
|
|
/* |
|
* This module can be used to catch cases when the btrfs kernel |
|
* code executes write requests to the disk that bring the file |
|
* system in an inconsistent state. In such a state, a power-loss |
|
* or kernel panic event would cause that the data on disk is |
|
* lost or at least damaged. |
|
* |
|
* Code is added that examines all block write requests during |
|
* runtime (including writes of the super block). Three rules |
|
* are verified and an error is printed on violation of the |
|
* rules: |
|
* 1. It is not allowed to write a disk block which is |
|
* currently referenced by the super block (either directly |
|
* or indirectly). |
|
* 2. When a super block is written, it is verified that all |
|
* referenced (directly or indirectly) blocks fulfill the |
|
* following requirements: |
|
* 2a. All referenced blocks have either been present when |
|
* the file system was mounted, (i.e., they have been |
|
* referenced by the super block) or they have been |
|
* written since then and the write completion callback |
|
* was called and no write error was indicated and a |
|
* FLUSH request to the device where these blocks are |
|
* located was received and completed. |
|
* 2b. All referenced blocks need to have a generation |
|
* number which is equal to the parent's number. |
|
* |
|
* One issue that was found using this module was that the log |
|
* tree on disk became temporarily corrupted because disk blocks |
|
* that had been in use for the log tree had been freed and |
|
* reused too early, while being referenced by the written super |
|
* block. |
|
* |
|
* The search term in the kernel log that can be used to filter |
|
* on the existence of detected integrity issues is |
|
* "btrfs: attempt". |
|
* |
|
* The integrity check is enabled via mount options. These |
|
* mount options are only supported if the integrity check |
|
* tool is compiled by defining BTRFS_FS_CHECK_INTEGRITY. |
|
* |
|
* Example #1, apply integrity checks to all metadata: |
|
* mount /dev/sdb1 /mnt -o check_int |
|
* |
|
* Example #2, apply integrity checks to all metadata and |
|
* to data extents: |
|
* mount /dev/sdb1 /mnt -o check_int_data |
|
* |
|
* Example #3, apply integrity checks to all metadata and dump |
|
* the tree that the super block references to kernel messages |
|
* each time after a super block was written: |
|
* mount /dev/sdb1 /mnt -o check_int,check_int_print_mask=263 |
|
* |
|
* If the integrity check tool is included and activated in |
|
* the mount options, plenty of kernel memory is used, and |
|
* plenty of additional CPU cycles are spent. Enabling this |
|
* functionality is not intended for normal use. In most |
|
* cases, unless you are a btrfs developer who needs to verify |
|
* the integrity of (super)-block write requests, do not |
|
* enable the config option BTRFS_FS_CHECK_INTEGRITY to |
|
* include and compile the integrity check tool. |
|
* |
|
* Expect millions of lines of information in the kernel log with an |
|
* enabled check_int_print_mask. Therefore set LOG_BUF_SHIFT in the |
|
* kernel config to at least 26 (which is 64MB). Usually the value is |
|
* limited to 21 (which is 2MB) in init/Kconfig. The file needs to be |
|
* changed like this before LOG_BUF_SHIFT can be set to a high value: |
|
* config LOG_BUF_SHIFT |
|
* int "Kernel log buffer size (16 => 64KB, 17 => 128KB)" |
|
* range 12 30 |
|
*/ |
|
|
|
#include <linux/sched.h> |
|
#include <linux/slab.h> |
|
#include <linux/mutex.h> |
|
#include <linux/genhd.h> |
|
#include <linux/blkdev.h> |
|
#include <linux/mm.h> |
|
#include <linux/string.h> |
|
#include <crypto/hash.h> |
|
#include "ctree.h" |
|
#include "disk-io.h" |
|
#include "transaction.h" |
|
#include "extent_io.h" |
|
#include "volumes.h" |
|
#include "print-tree.h" |
|
#include "locking.h" |
|
#include "check-integrity.h" |
|
#include "rcu-string.h" |
|
#include "compression.h" |
|
|
|
#define BTRFSIC_BLOCK_HASHTABLE_SIZE 0x10000 |
|
#define BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE 0x10000 |
|
#define BTRFSIC_DEV2STATE_HASHTABLE_SIZE 0x100 |
|
#define BTRFSIC_BLOCK_MAGIC_NUMBER 0x14491051 |
|
#define BTRFSIC_BLOCK_LINK_MAGIC_NUMBER 0x11070807 |
|
#define BTRFSIC_DEV2STATE_MAGIC_NUMBER 0x20111530 |
|
#define BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER 20111300 |
|
#define BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL (200 - 6) /* in characters, |
|
* excluding " [...]" */ |
|
#define BTRFSIC_GENERATION_UNKNOWN ((u64)-1) |
|
|
|
/* |
|
* The definition of the bitmask fields for the print_mask. |
|
* They are specified with the mount option check_integrity_print_mask. |
|
*/ |
|
#define BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE 0x00000001 |
|
#define BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION 0x00000002 |
|
#define BTRFSIC_PRINT_MASK_TREE_AFTER_SB_WRITE 0x00000004 |
|
#define BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE 0x00000008 |
|
#define BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH 0x00000010 |
|
#define BTRFSIC_PRINT_MASK_END_IO_BIO_BH 0x00000020 |
|
#define BTRFSIC_PRINT_MASK_VERBOSE 0x00000040 |
|
#define BTRFSIC_PRINT_MASK_VERY_VERBOSE 0x00000080 |
|
#define BTRFSIC_PRINT_MASK_INITIAL_TREE 0x00000100 |
|
#define BTRFSIC_PRINT_MASK_INITIAL_ALL_TREES 0x00000200 |
|
#define BTRFSIC_PRINT_MASK_INITIAL_DATABASE 0x00000400 |
|
#define BTRFSIC_PRINT_MASK_NUM_COPIES 0x00000800 |
|
#define BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS 0x00001000 |
|
#define BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE 0x00002000 |
|
|
|
struct btrfsic_dev_state; |
|
struct btrfsic_state; |
|
|
|
struct btrfsic_block { |
|
u32 magic_num; /* only used for debug purposes */ |
|
unsigned int is_metadata:1; /* if it is meta-data, not data-data */ |
|
unsigned int is_superblock:1; /* if it is one of the superblocks */ |
|
unsigned int is_iodone:1; /* if is done by lower subsystem */ |
|
unsigned int iodone_w_error:1; /* error was indicated to endio */ |
|
unsigned int never_written:1; /* block was added because it was |
|
* referenced, not because it was |
|
* written */ |
|
unsigned int mirror_num; /* large enough to hold |
|
* BTRFS_SUPER_MIRROR_MAX */ |
|
struct btrfsic_dev_state *dev_state; |
|
u64 dev_bytenr; /* key, physical byte num on disk */ |
|
u64 logical_bytenr; /* logical byte num on disk */ |
|
u64 generation; |
|
struct btrfs_disk_key disk_key; /* extra info to print in case of |
|
* issues, will not always be correct */ |
|
struct list_head collision_resolving_node; /* list node */ |
|
struct list_head all_blocks_node; /* list node */ |
|
|
|
/* the following two lists contain block_link items */ |
|
struct list_head ref_to_list; /* list */ |
|
struct list_head ref_from_list; /* list */ |
|
struct btrfsic_block *next_in_same_bio; |
|
void *orig_bio_private; |
|
bio_end_io_t *orig_bio_end_io; |
|
int submit_bio_bh_rw; |
|
u64 flush_gen; /* only valid if !never_written */ |
|
}; |
|
|
|
/* |
|
* Elements of this type are allocated dynamically and required because |
|
* each block object can refer to and can be ref from multiple blocks. |
|
* The key to lookup them in the hashtable is the dev_bytenr of |
|
* the block ref to plus the one from the block referred from. |
|
* The fact that they are searchable via a hashtable and that a |
|
* ref_cnt is maintained is not required for the btrfs integrity |
|
* check algorithm itself, it is only used to make the output more |
|
* beautiful in case that an error is detected (an error is defined |
|
* as a write operation to a block while that block is still referenced). |
|
*/ |
|
struct btrfsic_block_link { |
|
u32 magic_num; /* only used for debug purposes */ |
|
u32 ref_cnt; |
|
struct list_head node_ref_to; /* list node */ |
|
struct list_head node_ref_from; /* list node */ |
|
struct list_head collision_resolving_node; /* list node */ |
|
struct btrfsic_block *block_ref_to; |
|
struct btrfsic_block *block_ref_from; |
|
u64 parent_generation; |
|
}; |
|
|
|
struct btrfsic_dev_state { |
|
u32 magic_num; /* only used for debug purposes */ |
|
struct block_device *bdev; |
|
struct btrfsic_state *state; |
|
struct list_head collision_resolving_node; /* list node */ |
|
struct btrfsic_block dummy_block_for_bio_bh_flush; |
|
u64 last_flush_gen; |
|
}; |
|
|
|
struct btrfsic_block_hashtable { |
|
struct list_head table[BTRFSIC_BLOCK_HASHTABLE_SIZE]; |
|
}; |
|
|
|
struct btrfsic_block_link_hashtable { |
|
struct list_head table[BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE]; |
|
}; |
|
|
|
struct btrfsic_dev_state_hashtable { |
|
struct list_head table[BTRFSIC_DEV2STATE_HASHTABLE_SIZE]; |
|
}; |
|
|
|
struct btrfsic_block_data_ctx { |
|
u64 start; /* virtual bytenr */ |
|
u64 dev_bytenr; /* physical bytenr on device */ |
|
u32 len; |
|
struct btrfsic_dev_state *dev; |
|
char **datav; |
|
struct page **pagev; |
|
void *mem_to_free; |
|
}; |
|
|
|
/* This structure is used to implement recursion without occupying |
|
* any stack space, refer to btrfsic_process_metablock() */ |
|
struct btrfsic_stack_frame { |
|
u32 magic; |
|
u32 nr; |
|
int error; |
|
int i; |
|
int limit_nesting; |
|
int num_copies; |
|
int mirror_num; |
|
struct btrfsic_block *block; |
|
struct btrfsic_block_data_ctx *block_ctx; |
|
struct btrfsic_block *next_block; |
|
struct btrfsic_block_data_ctx next_block_ctx; |
|
struct btrfs_header *hdr; |
|
struct btrfsic_stack_frame *prev; |
|
}; |
|
|
|
/* Some state per mounted filesystem */ |
|
struct btrfsic_state { |
|
u32 print_mask; |
|
int include_extent_data; |
|
struct list_head all_blocks_list; |
|
struct btrfsic_block_hashtable block_hashtable; |
|
struct btrfsic_block_link_hashtable block_link_hashtable; |
|
struct btrfs_fs_info *fs_info; |
|
u64 max_superblock_generation; |
|
struct btrfsic_block *latest_superblock; |
|
u32 metablock_size; |
|
u32 datablock_size; |
|
}; |
|
|
|
static int btrfsic_process_metablock(struct btrfsic_state *state, |
|
struct btrfsic_block *block, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
int limit_nesting, int force_iodone_flag); |
|
static void btrfsic_read_from_block_data( |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
void *dst, u32 offset, size_t len); |
|
static int btrfsic_create_link_to_next_block( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *block, |
|
struct btrfsic_block_data_ctx |
|
*block_ctx, u64 next_bytenr, |
|
int limit_nesting, |
|
struct btrfsic_block_data_ctx *next_block_ctx, |
|
struct btrfsic_block **next_blockp, |
|
int force_iodone_flag, |
|
int *num_copiesp, int *mirror_nump, |
|
struct btrfs_disk_key *disk_key, |
|
u64 parent_generation); |
|
static int btrfsic_handle_extent_data(struct btrfsic_state *state, |
|
struct btrfsic_block *block, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
u32 item_offset, int force_iodone_flag); |
|
static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len, |
|
struct btrfsic_block_data_ctx *block_ctx_out, |
|
int mirror_num); |
|
static void btrfsic_release_block_ctx(struct btrfsic_block_data_ctx *block_ctx); |
|
static int btrfsic_read_block(struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *block_ctx); |
|
static int btrfsic_process_written_superblock( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *const block, |
|
struct btrfs_super_block *const super_hdr); |
|
static void btrfsic_bio_end_io(struct bio *bp); |
|
static int btrfsic_is_block_ref_by_superblock(const struct btrfsic_state *state, |
|
const struct btrfsic_block *block, |
|
int recursion_level); |
|
static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state, |
|
struct btrfsic_block *const block, |
|
int recursion_level); |
|
static void btrfsic_print_add_link(const struct btrfsic_state *state, |
|
const struct btrfsic_block_link *l); |
|
static void btrfsic_print_rem_link(const struct btrfsic_state *state, |
|
const struct btrfsic_block_link *l); |
|
static char btrfsic_get_block_type(const struct btrfsic_state *state, |
|
const struct btrfsic_block *block); |
|
static void btrfsic_dump_tree(const struct btrfsic_state *state); |
|
static void btrfsic_dump_tree_sub(const struct btrfsic_state *state, |
|
const struct btrfsic_block *block, |
|
int indent_level); |
|
static struct btrfsic_block_link *btrfsic_block_link_lookup_or_add( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *next_block_ctx, |
|
struct btrfsic_block *next_block, |
|
struct btrfsic_block *from_block, |
|
u64 parent_generation); |
|
static struct btrfsic_block *btrfsic_block_lookup_or_add( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
const char *additional_string, |
|
int is_metadata, |
|
int is_iodone, |
|
int never_written, |
|
int mirror_num, |
|
int *was_created); |
|
static int btrfsic_process_superblock_dev_mirror( |
|
struct btrfsic_state *state, |
|
struct btrfsic_dev_state *dev_state, |
|
struct btrfs_device *device, |
|
int superblock_mirror_num, |
|
struct btrfsic_dev_state **selected_dev_state, |
|
struct btrfs_super_block *selected_super); |
|
static struct btrfsic_dev_state *btrfsic_dev_state_lookup(dev_t dev); |
|
static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state, |
|
u64 bytenr, |
|
struct btrfsic_dev_state *dev_state, |
|
u64 dev_bytenr); |
|
|
|
static struct mutex btrfsic_mutex; |
|
static int btrfsic_is_initialized; |
|
static struct btrfsic_dev_state_hashtable btrfsic_dev_state_hashtable; |
|
|
|
|
|
static void btrfsic_block_init(struct btrfsic_block *b) |
|
{ |
|
b->magic_num = BTRFSIC_BLOCK_MAGIC_NUMBER; |
|
b->dev_state = NULL; |
|
b->dev_bytenr = 0; |
|
b->logical_bytenr = 0; |
|
b->generation = BTRFSIC_GENERATION_UNKNOWN; |
|
b->disk_key.objectid = 0; |
|
b->disk_key.type = 0; |
|
b->disk_key.offset = 0; |
|
b->is_metadata = 0; |
|
b->is_superblock = 0; |
|
b->is_iodone = 0; |
|
b->iodone_w_error = 0; |
|
b->never_written = 0; |
|
b->mirror_num = 0; |
|
b->next_in_same_bio = NULL; |
|
b->orig_bio_private = NULL; |
|
b->orig_bio_end_io = NULL; |
|
INIT_LIST_HEAD(&b->collision_resolving_node); |
|
INIT_LIST_HEAD(&b->all_blocks_node); |
|
INIT_LIST_HEAD(&b->ref_to_list); |
|
INIT_LIST_HEAD(&b->ref_from_list); |
|
b->submit_bio_bh_rw = 0; |
|
b->flush_gen = 0; |
|
} |
|
|
|
static struct btrfsic_block *btrfsic_block_alloc(void) |
|
{ |
|
struct btrfsic_block *b; |
|
|
|
b = kzalloc(sizeof(*b), GFP_NOFS); |
|
if (NULL != b) |
|
btrfsic_block_init(b); |
|
|
|
return b; |
|
} |
|
|
|
static void btrfsic_block_free(struct btrfsic_block *b) |
|
{ |
|
BUG_ON(!(NULL == b || BTRFSIC_BLOCK_MAGIC_NUMBER == b->magic_num)); |
|
kfree(b); |
|
} |
|
|
|
static void btrfsic_block_link_init(struct btrfsic_block_link *l) |
|
{ |
|
l->magic_num = BTRFSIC_BLOCK_LINK_MAGIC_NUMBER; |
|
l->ref_cnt = 1; |
|
INIT_LIST_HEAD(&l->node_ref_to); |
|
INIT_LIST_HEAD(&l->node_ref_from); |
|
INIT_LIST_HEAD(&l->collision_resolving_node); |
|
l->block_ref_to = NULL; |
|
l->block_ref_from = NULL; |
|
} |
|
|
|
static struct btrfsic_block_link *btrfsic_block_link_alloc(void) |
|
{ |
|
struct btrfsic_block_link *l; |
|
|
|
l = kzalloc(sizeof(*l), GFP_NOFS); |
|
if (NULL != l) |
|
btrfsic_block_link_init(l); |
|
|
|
return l; |
|
} |
|
|
|
static void btrfsic_block_link_free(struct btrfsic_block_link *l) |
|
{ |
|
BUG_ON(!(NULL == l || BTRFSIC_BLOCK_LINK_MAGIC_NUMBER == l->magic_num)); |
|
kfree(l); |
|
} |
|
|
|
static void btrfsic_dev_state_init(struct btrfsic_dev_state *ds) |
|
{ |
|
ds->magic_num = BTRFSIC_DEV2STATE_MAGIC_NUMBER; |
|
ds->bdev = NULL; |
|
ds->state = NULL; |
|
INIT_LIST_HEAD(&ds->collision_resolving_node); |
|
ds->last_flush_gen = 0; |
|
btrfsic_block_init(&ds->dummy_block_for_bio_bh_flush); |
|
ds->dummy_block_for_bio_bh_flush.is_iodone = 1; |
|
ds->dummy_block_for_bio_bh_flush.dev_state = ds; |
|
} |
|
|
|
static struct btrfsic_dev_state *btrfsic_dev_state_alloc(void) |
|
{ |
|
struct btrfsic_dev_state *ds; |
|
|
|
ds = kzalloc(sizeof(*ds), GFP_NOFS); |
|
if (NULL != ds) |
|
btrfsic_dev_state_init(ds); |
|
|
|
return ds; |
|
} |
|
|
|
static void btrfsic_dev_state_free(struct btrfsic_dev_state *ds) |
|
{ |
|
BUG_ON(!(NULL == ds || |
|
BTRFSIC_DEV2STATE_MAGIC_NUMBER == ds->magic_num)); |
|
kfree(ds); |
|
} |
|
|
|
static void btrfsic_block_hashtable_init(struct btrfsic_block_hashtable *h) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < BTRFSIC_BLOCK_HASHTABLE_SIZE; i++) |
|
INIT_LIST_HEAD(h->table + i); |
|
} |
|
|
|
static void btrfsic_block_hashtable_add(struct btrfsic_block *b, |
|
struct btrfsic_block_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
(((unsigned int)(b->dev_bytenr >> 16)) ^ |
|
((unsigned int)((uintptr_t)b->dev_state->bdev))) & |
|
(BTRFSIC_BLOCK_HASHTABLE_SIZE - 1); |
|
|
|
list_add(&b->collision_resolving_node, h->table + hashval); |
|
} |
|
|
|
static void btrfsic_block_hashtable_remove(struct btrfsic_block *b) |
|
{ |
|
list_del(&b->collision_resolving_node); |
|
} |
|
|
|
static struct btrfsic_block *btrfsic_block_hashtable_lookup( |
|
struct block_device *bdev, |
|
u64 dev_bytenr, |
|
struct btrfsic_block_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
(((unsigned int)(dev_bytenr >> 16)) ^ |
|
((unsigned int)((uintptr_t)bdev))) & |
|
(BTRFSIC_BLOCK_HASHTABLE_SIZE - 1); |
|
struct btrfsic_block *b; |
|
|
|
list_for_each_entry(b, h->table + hashval, collision_resolving_node) { |
|
if (b->dev_state->bdev == bdev && b->dev_bytenr == dev_bytenr) |
|
return b; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
static void btrfsic_block_link_hashtable_init( |
|
struct btrfsic_block_link_hashtable *h) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE; i++) |
|
INIT_LIST_HEAD(h->table + i); |
|
} |
|
|
|
static void btrfsic_block_link_hashtable_add( |
|
struct btrfsic_block_link *l, |
|
struct btrfsic_block_link_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
(((unsigned int)(l->block_ref_to->dev_bytenr >> 16)) ^ |
|
((unsigned int)(l->block_ref_from->dev_bytenr >> 16)) ^ |
|
((unsigned int)((uintptr_t)l->block_ref_to->dev_state->bdev)) ^ |
|
((unsigned int)((uintptr_t)l->block_ref_from->dev_state->bdev))) |
|
& (BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE - 1); |
|
|
|
BUG_ON(NULL == l->block_ref_to); |
|
BUG_ON(NULL == l->block_ref_from); |
|
list_add(&l->collision_resolving_node, h->table + hashval); |
|
} |
|
|
|
static void btrfsic_block_link_hashtable_remove(struct btrfsic_block_link *l) |
|
{ |
|
list_del(&l->collision_resolving_node); |
|
} |
|
|
|
static struct btrfsic_block_link *btrfsic_block_link_hashtable_lookup( |
|
struct block_device *bdev_ref_to, |
|
u64 dev_bytenr_ref_to, |
|
struct block_device *bdev_ref_from, |
|
u64 dev_bytenr_ref_from, |
|
struct btrfsic_block_link_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
(((unsigned int)(dev_bytenr_ref_to >> 16)) ^ |
|
((unsigned int)(dev_bytenr_ref_from >> 16)) ^ |
|
((unsigned int)((uintptr_t)bdev_ref_to)) ^ |
|
((unsigned int)((uintptr_t)bdev_ref_from))) & |
|
(BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE - 1); |
|
struct btrfsic_block_link *l; |
|
|
|
list_for_each_entry(l, h->table + hashval, collision_resolving_node) { |
|
BUG_ON(NULL == l->block_ref_to); |
|
BUG_ON(NULL == l->block_ref_from); |
|
if (l->block_ref_to->dev_state->bdev == bdev_ref_to && |
|
l->block_ref_to->dev_bytenr == dev_bytenr_ref_to && |
|
l->block_ref_from->dev_state->bdev == bdev_ref_from && |
|
l->block_ref_from->dev_bytenr == dev_bytenr_ref_from) |
|
return l; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
static void btrfsic_dev_state_hashtable_init( |
|
struct btrfsic_dev_state_hashtable *h) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < BTRFSIC_DEV2STATE_HASHTABLE_SIZE; i++) |
|
INIT_LIST_HEAD(h->table + i); |
|
} |
|
|
|
static void btrfsic_dev_state_hashtable_add( |
|
struct btrfsic_dev_state *ds, |
|
struct btrfsic_dev_state_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
(((unsigned int)((uintptr_t)ds->bdev->bd_dev)) & |
|
(BTRFSIC_DEV2STATE_HASHTABLE_SIZE - 1)); |
|
|
|
list_add(&ds->collision_resolving_node, h->table + hashval); |
|
} |
|
|
|
static void btrfsic_dev_state_hashtable_remove(struct btrfsic_dev_state *ds) |
|
{ |
|
list_del(&ds->collision_resolving_node); |
|
} |
|
|
|
static struct btrfsic_dev_state *btrfsic_dev_state_hashtable_lookup(dev_t dev, |
|
struct btrfsic_dev_state_hashtable *h) |
|
{ |
|
const unsigned int hashval = |
|
dev & (BTRFSIC_DEV2STATE_HASHTABLE_SIZE - 1); |
|
struct btrfsic_dev_state *ds; |
|
|
|
list_for_each_entry(ds, h->table + hashval, collision_resolving_node) { |
|
if (ds->bdev->bd_dev == dev) |
|
return ds; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
static int btrfsic_process_superblock(struct btrfsic_state *state, |
|
struct btrfs_fs_devices *fs_devices) |
|
{ |
|
struct btrfs_super_block *selected_super; |
|
struct list_head *dev_head = &fs_devices->devices; |
|
struct btrfs_device *device; |
|
struct btrfsic_dev_state *selected_dev_state = NULL; |
|
int ret = 0; |
|
int pass; |
|
|
|
selected_super = kzalloc(sizeof(*selected_super), GFP_NOFS); |
|
if (!selected_super) |
|
return -ENOMEM; |
|
|
|
list_for_each_entry(device, dev_head, dev_list) { |
|
int i; |
|
struct btrfsic_dev_state *dev_state; |
|
|
|
if (!device->bdev || !device->name) |
|
continue; |
|
|
|
dev_state = btrfsic_dev_state_lookup(device->bdev->bd_dev); |
|
BUG_ON(NULL == dev_state); |
|
for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { |
|
ret = btrfsic_process_superblock_dev_mirror( |
|
state, dev_state, device, i, |
|
&selected_dev_state, selected_super); |
|
if (0 != ret && 0 == i) { |
|
kfree(selected_super); |
|
return ret; |
|
} |
|
} |
|
} |
|
|
|
if (NULL == state->latest_superblock) { |
|
pr_info("btrfsic: no superblock found!\n"); |
|
kfree(selected_super); |
|
return -1; |
|
} |
|
|
|
for (pass = 0; pass < 3; pass++) { |
|
int num_copies; |
|
int mirror_num; |
|
u64 next_bytenr; |
|
|
|
switch (pass) { |
|
case 0: |
|
next_bytenr = btrfs_super_root(selected_super); |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("root@%llu\n", next_bytenr); |
|
break; |
|
case 1: |
|
next_bytenr = btrfs_super_chunk_root(selected_super); |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("chunk@%llu\n", next_bytenr); |
|
break; |
|
case 2: |
|
next_bytenr = btrfs_super_log_root(selected_super); |
|
if (0 == next_bytenr) |
|
continue; |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("log@%llu\n", next_bytenr); |
|
break; |
|
} |
|
|
|
num_copies = btrfs_num_copies(state->fs_info, next_bytenr, |
|
state->metablock_size); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) |
|
pr_info("num_copies(log_bytenr=%llu) = %d\n", |
|
next_bytenr, num_copies); |
|
|
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
struct btrfsic_block *next_block; |
|
struct btrfsic_block_data_ctx tmp_next_block_ctx; |
|
struct btrfsic_block_link *l; |
|
|
|
ret = btrfsic_map_block(state, next_bytenr, |
|
state->metablock_size, |
|
&tmp_next_block_ctx, |
|
mirror_num); |
|
if (ret) { |
|
pr_info("btrfsic: btrfsic_map_block(root @%llu, mirror %d) failed!\n", |
|
next_bytenr, mirror_num); |
|
kfree(selected_super); |
|
return -1; |
|
} |
|
|
|
next_block = btrfsic_block_hashtable_lookup( |
|
tmp_next_block_ctx.dev->bdev, |
|
tmp_next_block_ctx.dev_bytenr, |
|
&state->block_hashtable); |
|
BUG_ON(NULL == next_block); |
|
|
|
l = btrfsic_block_link_hashtable_lookup( |
|
tmp_next_block_ctx.dev->bdev, |
|
tmp_next_block_ctx.dev_bytenr, |
|
state->latest_superblock->dev_state-> |
|
bdev, |
|
state->latest_superblock->dev_bytenr, |
|
&state->block_link_hashtable); |
|
BUG_ON(NULL == l); |
|
|
|
ret = btrfsic_read_block(state, &tmp_next_block_ctx); |
|
if (ret < (int)PAGE_SIZE) { |
|
pr_info("btrfsic: read @logical %llu failed!\n", |
|
tmp_next_block_ctx.start); |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
kfree(selected_super); |
|
return -1; |
|
} |
|
|
|
ret = btrfsic_process_metablock(state, |
|
next_block, |
|
&tmp_next_block_ctx, |
|
BTRFS_MAX_LEVEL + 3, 1); |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
} |
|
} |
|
|
|
kfree(selected_super); |
|
return ret; |
|
} |
|
|
|
static int btrfsic_process_superblock_dev_mirror( |
|
struct btrfsic_state *state, |
|
struct btrfsic_dev_state *dev_state, |
|
struct btrfs_device *device, |
|
int superblock_mirror_num, |
|
struct btrfsic_dev_state **selected_dev_state, |
|
struct btrfs_super_block *selected_super) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
struct btrfs_super_block *super_tmp; |
|
u64 dev_bytenr; |
|
struct btrfsic_block *superblock_tmp; |
|
int pass; |
|
struct block_device *const superblock_bdev = device->bdev; |
|
struct page *page; |
|
struct address_space *mapping = superblock_bdev->bd_inode->i_mapping; |
|
int ret = 0; |
|
|
|
/* super block bytenr is always the unmapped device bytenr */ |
|
dev_bytenr = btrfs_sb_offset(superblock_mirror_num); |
|
if (dev_bytenr + BTRFS_SUPER_INFO_SIZE > device->commit_total_bytes) |
|
return -1; |
|
|
|
page = read_cache_page_gfp(mapping, dev_bytenr >> PAGE_SHIFT, GFP_NOFS); |
|
if (IS_ERR(page)) |
|
return -1; |
|
|
|
super_tmp = page_address(page); |
|
|
|
if (btrfs_super_bytenr(super_tmp) != dev_bytenr || |
|
btrfs_super_magic(super_tmp) != BTRFS_MAGIC || |
|
memcmp(device->uuid, super_tmp->dev_item.uuid, BTRFS_UUID_SIZE) || |
|
btrfs_super_nodesize(super_tmp) != state->metablock_size || |
|
btrfs_super_sectorsize(super_tmp) != state->datablock_size) { |
|
ret = 0; |
|
goto out; |
|
} |
|
|
|
superblock_tmp = |
|
btrfsic_block_hashtable_lookup(superblock_bdev, |
|
dev_bytenr, |
|
&state->block_hashtable); |
|
if (NULL == superblock_tmp) { |
|
superblock_tmp = btrfsic_block_alloc(); |
|
if (NULL == superblock_tmp) { |
|
ret = -1; |
|
goto out; |
|
} |
|
/* for superblock, only the dev_bytenr makes sense */ |
|
superblock_tmp->dev_bytenr = dev_bytenr; |
|
superblock_tmp->dev_state = dev_state; |
|
superblock_tmp->logical_bytenr = dev_bytenr; |
|
superblock_tmp->generation = btrfs_super_generation(super_tmp); |
|
superblock_tmp->is_metadata = 1; |
|
superblock_tmp->is_superblock = 1; |
|
superblock_tmp->is_iodone = 1; |
|
superblock_tmp->never_written = 0; |
|
superblock_tmp->mirror_num = 1 + superblock_mirror_num; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE) |
|
btrfs_info_in_rcu(fs_info, |
|
"new initial S-block (bdev %p, %s) @%llu (%pg/%llu/%d)", |
|
superblock_bdev, |
|
rcu_str_deref(device->name), dev_bytenr, |
|
dev_state->bdev, dev_bytenr, |
|
superblock_mirror_num); |
|
list_add(&superblock_tmp->all_blocks_node, |
|
&state->all_blocks_list); |
|
btrfsic_block_hashtable_add(superblock_tmp, |
|
&state->block_hashtable); |
|
} |
|
|
|
/* select the one with the highest generation field */ |
|
if (btrfs_super_generation(super_tmp) > |
|
state->max_superblock_generation || |
|
0 == state->max_superblock_generation) { |
|
memcpy(selected_super, super_tmp, sizeof(*selected_super)); |
|
*selected_dev_state = dev_state; |
|
state->max_superblock_generation = |
|
btrfs_super_generation(super_tmp); |
|
state->latest_superblock = superblock_tmp; |
|
} |
|
|
|
for (pass = 0; pass < 3; pass++) { |
|
u64 next_bytenr; |
|
int num_copies; |
|
int mirror_num; |
|
const char *additional_string = NULL; |
|
struct btrfs_disk_key tmp_disk_key; |
|
|
|
tmp_disk_key.type = BTRFS_ROOT_ITEM_KEY; |
|
tmp_disk_key.offset = 0; |
|
switch (pass) { |
|
case 0: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_ROOT_TREE_OBJECTID); |
|
additional_string = "initial root "; |
|
next_bytenr = btrfs_super_root(super_tmp); |
|
break; |
|
case 1: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_CHUNK_TREE_OBJECTID); |
|
additional_string = "initial chunk "; |
|
next_bytenr = btrfs_super_chunk_root(super_tmp); |
|
break; |
|
case 2: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_TREE_LOG_OBJECTID); |
|
additional_string = "initial log "; |
|
next_bytenr = btrfs_super_log_root(super_tmp); |
|
if (0 == next_bytenr) |
|
continue; |
|
break; |
|
} |
|
|
|
num_copies = btrfs_num_copies(fs_info, next_bytenr, |
|
state->metablock_size); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) |
|
pr_info("num_copies(log_bytenr=%llu) = %d\n", |
|
next_bytenr, num_copies); |
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
struct btrfsic_block *next_block; |
|
struct btrfsic_block_data_ctx tmp_next_block_ctx; |
|
struct btrfsic_block_link *l; |
|
|
|
if (btrfsic_map_block(state, next_bytenr, |
|
state->metablock_size, |
|
&tmp_next_block_ctx, |
|
mirror_num)) { |
|
pr_info("btrfsic: btrfsic_map_block(bytenr @%llu, mirror %d) failed!\n", |
|
next_bytenr, mirror_num); |
|
ret = -1; |
|
goto out; |
|
} |
|
|
|
next_block = btrfsic_block_lookup_or_add( |
|
state, &tmp_next_block_ctx, |
|
additional_string, 1, 1, 0, |
|
mirror_num, NULL); |
|
if (NULL == next_block) { |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
ret = -1; |
|
goto out; |
|
} |
|
|
|
next_block->disk_key = tmp_disk_key; |
|
next_block->generation = BTRFSIC_GENERATION_UNKNOWN; |
|
l = btrfsic_block_link_lookup_or_add( |
|
state, &tmp_next_block_ctx, |
|
next_block, superblock_tmp, |
|
BTRFSIC_GENERATION_UNKNOWN); |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
if (NULL == l) { |
|
ret = -1; |
|
goto out; |
|
} |
|
} |
|
} |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_ALL_TREES) |
|
btrfsic_dump_tree_sub(state, superblock_tmp, 0); |
|
|
|
out: |
|
put_page(page); |
|
return ret; |
|
} |
|
|
|
static struct btrfsic_stack_frame *btrfsic_stack_frame_alloc(void) |
|
{ |
|
struct btrfsic_stack_frame *sf; |
|
|
|
sf = kzalloc(sizeof(*sf), GFP_NOFS); |
|
if (sf) |
|
sf->magic = BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER; |
|
return sf; |
|
} |
|
|
|
static void btrfsic_stack_frame_free(struct btrfsic_stack_frame *sf) |
|
{ |
|
BUG_ON(!(NULL == sf || |
|
BTRFSIC_BLOCK_STACK_FRAME_MAGIC_NUMBER == sf->magic)); |
|
kfree(sf); |
|
} |
|
|
|
static noinline_for_stack int btrfsic_process_metablock( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *const first_block, |
|
struct btrfsic_block_data_ctx *const first_block_ctx, |
|
int first_limit_nesting, int force_iodone_flag) |
|
{ |
|
struct btrfsic_stack_frame initial_stack_frame = { 0 }; |
|
struct btrfsic_stack_frame *sf; |
|
struct btrfsic_stack_frame *next_stack; |
|
struct btrfs_header *const first_hdr = |
|
(struct btrfs_header *)first_block_ctx->datav[0]; |
|
|
|
BUG_ON(!first_hdr); |
|
sf = &initial_stack_frame; |
|
sf->error = 0; |
|
sf->i = -1; |
|
sf->limit_nesting = first_limit_nesting; |
|
sf->block = first_block; |
|
sf->block_ctx = first_block_ctx; |
|
sf->next_block = NULL; |
|
sf->hdr = first_hdr; |
|
sf->prev = NULL; |
|
|
|
continue_with_new_stack_frame: |
|
sf->block->generation = btrfs_stack_header_generation(sf->hdr); |
|
if (0 == sf->hdr->level) { |
|
struct btrfs_leaf *const leafhdr = |
|
(struct btrfs_leaf *)sf->hdr; |
|
|
|
if (-1 == sf->i) { |
|
sf->nr = btrfs_stack_header_nritems(&leafhdr->header); |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("leaf %llu items %d generation %llu owner %llu\n", |
|
sf->block_ctx->start, sf->nr, |
|
btrfs_stack_header_generation( |
|
&leafhdr->header), |
|
btrfs_stack_header_owner( |
|
&leafhdr->header)); |
|
} |
|
|
|
continue_with_current_leaf_stack_frame: |
|
if (0 == sf->num_copies || sf->mirror_num > sf->num_copies) { |
|
sf->i++; |
|
sf->num_copies = 0; |
|
} |
|
|
|
if (sf->i < sf->nr) { |
|
struct btrfs_item disk_item; |
|
u32 disk_item_offset = |
|
(uintptr_t)(leafhdr->items + sf->i) - |
|
(uintptr_t)leafhdr; |
|
struct btrfs_disk_key *disk_key; |
|
u8 type; |
|
u32 item_offset; |
|
u32 item_size; |
|
|
|
if (disk_item_offset + sizeof(struct btrfs_item) > |
|
sf->block_ctx->len) { |
|
leaf_item_out_of_bounce_error: |
|
pr_info( |
|
"btrfsic: leaf item out of bounce at logical %llu, dev %pg\n", |
|
sf->block_ctx->start, |
|
sf->block_ctx->dev->bdev); |
|
goto one_stack_frame_backwards; |
|
} |
|
btrfsic_read_from_block_data(sf->block_ctx, |
|
&disk_item, |
|
disk_item_offset, |
|
sizeof(struct btrfs_item)); |
|
item_offset = btrfs_stack_item_offset(&disk_item); |
|
item_size = btrfs_stack_item_size(&disk_item); |
|
disk_key = &disk_item.key; |
|
type = btrfs_disk_key_type(disk_key); |
|
|
|
if (BTRFS_ROOT_ITEM_KEY == type) { |
|
struct btrfs_root_item root_item; |
|
u32 root_item_offset; |
|
u64 next_bytenr; |
|
|
|
root_item_offset = item_offset + |
|
offsetof(struct btrfs_leaf, items); |
|
if (root_item_offset + item_size > |
|
sf->block_ctx->len) |
|
goto leaf_item_out_of_bounce_error; |
|
btrfsic_read_from_block_data( |
|
sf->block_ctx, &root_item, |
|
root_item_offset, |
|
item_size); |
|
next_bytenr = btrfs_root_bytenr(&root_item); |
|
|
|
sf->error = |
|
btrfsic_create_link_to_next_block( |
|
state, |
|
sf->block, |
|
sf->block_ctx, |
|
next_bytenr, |
|
sf->limit_nesting, |
|
&sf->next_block_ctx, |
|
&sf->next_block, |
|
force_iodone_flag, |
|
&sf->num_copies, |
|
&sf->mirror_num, |
|
disk_key, |
|
btrfs_root_generation( |
|
&root_item)); |
|
if (sf->error) |
|
goto one_stack_frame_backwards; |
|
|
|
if (NULL != sf->next_block) { |
|
struct btrfs_header *const next_hdr = |
|
(struct btrfs_header *) |
|
sf->next_block_ctx.datav[0]; |
|
|
|
next_stack = |
|
btrfsic_stack_frame_alloc(); |
|
if (NULL == next_stack) { |
|
sf->error = -1; |
|
btrfsic_release_block_ctx( |
|
&sf-> |
|
next_block_ctx); |
|
goto one_stack_frame_backwards; |
|
} |
|
|
|
next_stack->i = -1; |
|
next_stack->block = sf->next_block; |
|
next_stack->block_ctx = |
|
&sf->next_block_ctx; |
|
next_stack->next_block = NULL; |
|
next_stack->hdr = next_hdr; |
|
next_stack->limit_nesting = |
|
sf->limit_nesting - 1; |
|
next_stack->prev = sf; |
|
sf = next_stack; |
|
goto continue_with_new_stack_frame; |
|
} |
|
} else if (BTRFS_EXTENT_DATA_KEY == type && |
|
state->include_extent_data) { |
|
sf->error = btrfsic_handle_extent_data( |
|
state, |
|
sf->block, |
|
sf->block_ctx, |
|
item_offset, |
|
force_iodone_flag); |
|
if (sf->error) |
|
goto one_stack_frame_backwards; |
|
} |
|
|
|
goto continue_with_current_leaf_stack_frame; |
|
} |
|
} else { |
|
struct btrfs_node *const nodehdr = (struct btrfs_node *)sf->hdr; |
|
|
|
if (-1 == sf->i) { |
|
sf->nr = btrfs_stack_header_nritems(&nodehdr->header); |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("node %llu level %d items %d generation %llu owner %llu\n", |
|
sf->block_ctx->start, |
|
nodehdr->header.level, sf->nr, |
|
btrfs_stack_header_generation( |
|
&nodehdr->header), |
|
btrfs_stack_header_owner( |
|
&nodehdr->header)); |
|
} |
|
|
|
continue_with_current_node_stack_frame: |
|
if (0 == sf->num_copies || sf->mirror_num > sf->num_copies) { |
|
sf->i++; |
|
sf->num_copies = 0; |
|
} |
|
|
|
if (sf->i < sf->nr) { |
|
struct btrfs_key_ptr key_ptr; |
|
u32 key_ptr_offset; |
|
u64 next_bytenr; |
|
|
|
key_ptr_offset = (uintptr_t)(nodehdr->ptrs + sf->i) - |
|
(uintptr_t)nodehdr; |
|
if (key_ptr_offset + sizeof(struct btrfs_key_ptr) > |
|
sf->block_ctx->len) { |
|
pr_info( |
|
"btrfsic: node item out of bounce at logical %llu, dev %pg\n", |
|
sf->block_ctx->start, |
|
sf->block_ctx->dev->bdev); |
|
goto one_stack_frame_backwards; |
|
} |
|
btrfsic_read_from_block_data( |
|
sf->block_ctx, &key_ptr, key_ptr_offset, |
|
sizeof(struct btrfs_key_ptr)); |
|
next_bytenr = btrfs_stack_key_blockptr(&key_ptr); |
|
|
|
sf->error = btrfsic_create_link_to_next_block( |
|
state, |
|
sf->block, |
|
sf->block_ctx, |
|
next_bytenr, |
|
sf->limit_nesting, |
|
&sf->next_block_ctx, |
|
&sf->next_block, |
|
force_iodone_flag, |
|
&sf->num_copies, |
|
&sf->mirror_num, |
|
&key_ptr.key, |
|
btrfs_stack_key_generation(&key_ptr)); |
|
if (sf->error) |
|
goto one_stack_frame_backwards; |
|
|
|
if (NULL != sf->next_block) { |
|
struct btrfs_header *const next_hdr = |
|
(struct btrfs_header *) |
|
sf->next_block_ctx.datav[0]; |
|
|
|
next_stack = btrfsic_stack_frame_alloc(); |
|
if (NULL == next_stack) { |
|
sf->error = -1; |
|
goto one_stack_frame_backwards; |
|
} |
|
|
|
next_stack->i = -1; |
|
next_stack->block = sf->next_block; |
|
next_stack->block_ctx = &sf->next_block_ctx; |
|
next_stack->next_block = NULL; |
|
next_stack->hdr = next_hdr; |
|
next_stack->limit_nesting = |
|
sf->limit_nesting - 1; |
|
next_stack->prev = sf; |
|
sf = next_stack; |
|
goto continue_with_new_stack_frame; |
|
} |
|
|
|
goto continue_with_current_node_stack_frame; |
|
} |
|
} |
|
|
|
one_stack_frame_backwards: |
|
if (NULL != sf->prev) { |
|
struct btrfsic_stack_frame *const prev = sf->prev; |
|
|
|
/* the one for the initial block is freed in the caller */ |
|
btrfsic_release_block_ctx(sf->block_ctx); |
|
|
|
if (sf->error) { |
|
prev->error = sf->error; |
|
btrfsic_stack_frame_free(sf); |
|
sf = prev; |
|
goto one_stack_frame_backwards; |
|
} |
|
|
|
btrfsic_stack_frame_free(sf); |
|
sf = prev; |
|
goto continue_with_new_stack_frame; |
|
} else { |
|
BUG_ON(&initial_stack_frame != sf); |
|
} |
|
|
|
return sf->error; |
|
} |
|
|
|
static void btrfsic_read_from_block_data( |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
void *dstv, u32 offset, size_t len) |
|
{ |
|
size_t cur; |
|
size_t pgoff; |
|
char *kaddr; |
|
char *dst = (char *)dstv; |
|
size_t start_offset = offset_in_page(block_ctx->start); |
|
unsigned long i = (start_offset + offset) >> PAGE_SHIFT; |
|
|
|
WARN_ON(offset + len > block_ctx->len); |
|
pgoff = offset_in_page(start_offset + offset); |
|
|
|
while (len > 0) { |
|
cur = min(len, ((size_t)PAGE_SIZE - pgoff)); |
|
BUG_ON(i >= DIV_ROUND_UP(block_ctx->len, PAGE_SIZE)); |
|
kaddr = block_ctx->datav[i]; |
|
memcpy(dst, kaddr + pgoff, cur); |
|
|
|
dst += cur; |
|
len -= cur; |
|
pgoff = 0; |
|
i++; |
|
} |
|
} |
|
|
|
static int btrfsic_create_link_to_next_block( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *block, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
u64 next_bytenr, |
|
int limit_nesting, |
|
struct btrfsic_block_data_ctx *next_block_ctx, |
|
struct btrfsic_block **next_blockp, |
|
int force_iodone_flag, |
|
int *num_copiesp, int *mirror_nump, |
|
struct btrfs_disk_key *disk_key, |
|
u64 parent_generation) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
struct btrfsic_block *next_block = NULL; |
|
int ret; |
|
struct btrfsic_block_link *l; |
|
int did_alloc_block_link; |
|
int block_was_created; |
|
|
|
*next_blockp = NULL; |
|
if (0 == *num_copiesp) { |
|
*num_copiesp = btrfs_num_copies(fs_info, next_bytenr, |
|
state->metablock_size); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) |
|
pr_info("num_copies(log_bytenr=%llu) = %d\n", |
|
next_bytenr, *num_copiesp); |
|
*mirror_nump = 1; |
|
} |
|
|
|
if (*mirror_nump > *num_copiesp) |
|
return 0; |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("btrfsic_create_link_to_next_block(mirror_num=%d)\n", |
|
*mirror_nump); |
|
ret = btrfsic_map_block(state, next_bytenr, |
|
state->metablock_size, |
|
next_block_ctx, *mirror_nump); |
|
if (ret) { |
|
pr_info("btrfsic: btrfsic_map_block(@%llu, mirror=%d) failed!\n", |
|
next_bytenr, *mirror_nump); |
|
btrfsic_release_block_ctx(next_block_ctx); |
|
*next_blockp = NULL; |
|
return -1; |
|
} |
|
|
|
next_block = btrfsic_block_lookup_or_add(state, |
|
next_block_ctx, "referenced ", |
|
1, force_iodone_flag, |
|
!force_iodone_flag, |
|
*mirror_nump, |
|
&block_was_created); |
|
if (NULL == next_block) { |
|
btrfsic_release_block_ctx(next_block_ctx); |
|
*next_blockp = NULL; |
|
return -1; |
|
} |
|
if (block_was_created) { |
|
l = NULL; |
|
next_block->generation = BTRFSIC_GENERATION_UNKNOWN; |
|
} else { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) { |
|
if (next_block->logical_bytenr != next_bytenr && |
|
!(!next_block->is_metadata && |
|
0 == next_block->logical_bytenr)) |
|
pr_info( |
|
"referenced block @%llu (%pg/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu)\n", |
|
next_bytenr, next_block_ctx->dev->bdev, |
|
next_block_ctx->dev_bytenr, *mirror_nump, |
|
btrfsic_get_block_type(state, |
|
next_block), |
|
next_block->logical_bytenr); |
|
else |
|
pr_info( |
|
"referenced block @%llu (%pg/%llu/%d) found in hash table, %c\n", |
|
next_bytenr, next_block_ctx->dev->bdev, |
|
next_block_ctx->dev_bytenr, *mirror_nump, |
|
btrfsic_get_block_type(state, |
|
next_block)); |
|
} |
|
next_block->logical_bytenr = next_bytenr; |
|
|
|
next_block->mirror_num = *mirror_nump; |
|
l = btrfsic_block_link_hashtable_lookup( |
|
next_block_ctx->dev->bdev, |
|
next_block_ctx->dev_bytenr, |
|
block_ctx->dev->bdev, |
|
block_ctx->dev_bytenr, |
|
&state->block_link_hashtable); |
|
} |
|
|
|
next_block->disk_key = *disk_key; |
|
if (NULL == l) { |
|
l = btrfsic_block_link_alloc(); |
|
if (NULL == l) { |
|
btrfsic_release_block_ctx(next_block_ctx); |
|
*next_blockp = NULL; |
|
return -1; |
|
} |
|
|
|
did_alloc_block_link = 1; |
|
l->block_ref_to = next_block; |
|
l->block_ref_from = block; |
|
l->ref_cnt = 1; |
|
l->parent_generation = parent_generation; |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_add_link(state, l); |
|
|
|
list_add(&l->node_ref_to, &block->ref_to_list); |
|
list_add(&l->node_ref_from, &next_block->ref_from_list); |
|
|
|
btrfsic_block_link_hashtable_add(l, |
|
&state->block_link_hashtable); |
|
} else { |
|
did_alloc_block_link = 0; |
|
if (0 == limit_nesting) { |
|
l->ref_cnt++; |
|
l->parent_generation = parent_generation; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_add_link(state, l); |
|
} |
|
} |
|
|
|
if (limit_nesting > 0 && did_alloc_block_link) { |
|
ret = btrfsic_read_block(state, next_block_ctx); |
|
if (ret < (int)next_block_ctx->len) { |
|
pr_info("btrfsic: read block @logical %llu failed!\n", |
|
next_bytenr); |
|
btrfsic_release_block_ctx(next_block_ctx); |
|
*next_blockp = NULL; |
|
return -1; |
|
} |
|
|
|
*next_blockp = next_block; |
|
} else { |
|
*next_blockp = NULL; |
|
} |
|
(*mirror_nump)++; |
|
|
|
return 0; |
|
} |
|
|
|
static int btrfsic_handle_extent_data( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *block, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
u32 item_offset, int force_iodone_flag) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
struct btrfs_file_extent_item file_extent_item; |
|
u64 file_extent_item_offset; |
|
u64 next_bytenr; |
|
u64 num_bytes; |
|
u64 generation; |
|
struct btrfsic_block_link *l; |
|
int ret; |
|
|
|
file_extent_item_offset = offsetof(struct btrfs_leaf, items) + |
|
item_offset; |
|
if (file_extent_item_offset + |
|
offsetof(struct btrfs_file_extent_item, disk_num_bytes) > |
|
block_ctx->len) { |
|
pr_info("btrfsic: file item out of bounce at logical %llu, dev %pg\n", |
|
block_ctx->start, block_ctx->dev->bdev); |
|
return -1; |
|
} |
|
|
|
btrfsic_read_from_block_data(block_ctx, &file_extent_item, |
|
file_extent_item_offset, |
|
offsetof(struct btrfs_file_extent_item, disk_num_bytes)); |
|
if (BTRFS_FILE_EXTENT_REG != file_extent_item.type || |
|
btrfs_stack_file_extent_disk_bytenr(&file_extent_item) == 0) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE) |
|
pr_info("extent_data: type %u, disk_bytenr = %llu\n", |
|
file_extent_item.type, |
|
btrfs_stack_file_extent_disk_bytenr( |
|
&file_extent_item)); |
|
return 0; |
|
} |
|
|
|
if (file_extent_item_offset + sizeof(struct btrfs_file_extent_item) > |
|
block_ctx->len) { |
|
pr_info("btrfsic: file item out of bounce at logical %llu, dev %pg\n", |
|
block_ctx->start, block_ctx->dev->bdev); |
|
return -1; |
|
} |
|
btrfsic_read_from_block_data(block_ctx, &file_extent_item, |
|
file_extent_item_offset, |
|
sizeof(struct btrfs_file_extent_item)); |
|
next_bytenr = btrfs_stack_file_extent_disk_bytenr(&file_extent_item); |
|
if (btrfs_stack_file_extent_compression(&file_extent_item) == |
|
BTRFS_COMPRESS_NONE) { |
|
next_bytenr += btrfs_stack_file_extent_offset(&file_extent_item); |
|
num_bytes = btrfs_stack_file_extent_num_bytes(&file_extent_item); |
|
} else { |
|
num_bytes = btrfs_stack_file_extent_disk_num_bytes(&file_extent_item); |
|
} |
|
generation = btrfs_stack_file_extent_generation(&file_extent_item); |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE) |
|
pr_info("extent_data: type %u, disk_bytenr = %llu, offset = %llu, num_bytes = %llu\n", |
|
file_extent_item.type, |
|
btrfs_stack_file_extent_disk_bytenr(&file_extent_item), |
|
btrfs_stack_file_extent_offset(&file_extent_item), |
|
num_bytes); |
|
while (num_bytes > 0) { |
|
u32 chunk_len; |
|
int num_copies; |
|
int mirror_num; |
|
|
|
if (num_bytes > state->datablock_size) |
|
chunk_len = state->datablock_size; |
|
else |
|
chunk_len = num_bytes; |
|
|
|
num_copies = btrfs_num_copies(fs_info, next_bytenr, |
|
state->datablock_size); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) |
|
pr_info("num_copies(log_bytenr=%llu) = %d\n", |
|
next_bytenr, num_copies); |
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
struct btrfsic_block_data_ctx next_block_ctx; |
|
struct btrfsic_block *next_block; |
|
int block_was_created; |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("btrfsic_handle_extent_data(mirror_num=%d)\n", |
|
mirror_num); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERY_VERBOSE) |
|
pr_info("\tdisk_bytenr = %llu, num_bytes %u\n", |
|
next_bytenr, chunk_len); |
|
ret = btrfsic_map_block(state, next_bytenr, |
|
chunk_len, &next_block_ctx, |
|
mirror_num); |
|
if (ret) { |
|
pr_info("btrfsic: btrfsic_map_block(@%llu, mirror=%d) failed!\n", |
|
next_bytenr, mirror_num); |
|
return -1; |
|
} |
|
|
|
next_block = btrfsic_block_lookup_or_add( |
|
state, |
|
&next_block_ctx, |
|
"referenced ", |
|
0, |
|
force_iodone_flag, |
|
!force_iodone_flag, |
|
mirror_num, |
|
&block_was_created); |
|
if (NULL == next_block) { |
|
btrfsic_release_block_ctx(&next_block_ctx); |
|
return -1; |
|
} |
|
if (!block_was_created) { |
|
if ((state->print_mask & |
|
BTRFSIC_PRINT_MASK_VERBOSE) && |
|
next_block->logical_bytenr != next_bytenr && |
|
!(!next_block->is_metadata && |
|
0 == next_block->logical_bytenr)) { |
|
pr_info( |
|
"referenced block @%llu (%pg/%llu/%d) found in hash table, D, bytenr mismatch (!= stored %llu)\n", |
|
next_bytenr, |
|
next_block_ctx.dev->bdev, |
|
next_block_ctx.dev_bytenr, |
|
mirror_num, |
|
next_block->logical_bytenr); |
|
} |
|
next_block->logical_bytenr = next_bytenr; |
|
next_block->mirror_num = mirror_num; |
|
} |
|
|
|
l = btrfsic_block_link_lookup_or_add(state, |
|
&next_block_ctx, |
|
next_block, block, |
|
generation); |
|
btrfsic_release_block_ctx(&next_block_ctx); |
|
if (NULL == l) |
|
return -1; |
|
} |
|
|
|
next_bytenr += chunk_len; |
|
num_bytes -= chunk_len; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len, |
|
struct btrfsic_block_data_ctx *block_ctx_out, |
|
int mirror_num) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
int ret; |
|
u64 length; |
|
struct btrfs_io_context *multi = NULL; |
|
struct btrfs_device *device; |
|
|
|
length = len; |
|
ret = btrfs_map_block(fs_info, BTRFS_MAP_READ, |
|
bytenr, &length, &multi, mirror_num); |
|
|
|
if (ret) { |
|
block_ctx_out->start = 0; |
|
block_ctx_out->dev_bytenr = 0; |
|
block_ctx_out->len = 0; |
|
block_ctx_out->dev = NULL; |
|
block_ctx_out->datav = NULL; |
|
block_ctx_out->pagev = NULL; |
|
block_ctx_out->mem_to_free = NULL; |
|
|
|
return ret; |
|
} |
|
|
|
device = multi->stripes[0].dev; |
|
if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state) || |
|
!device->bdev || !device->name) |
|
block_ctx_out->dev = NULL; |
|
else |
|
block_ctx_out->dev = btrfsic_dev_state_lookup( |
|
device->bdev->bd_dev); |
|
block_ctx_out->dev_bytenr = multi->stripes[0].physical; |
|
block_ctx_out->start = bytenr; |
|
block_ctx_out->len = len; |
|
block_ctx_out->datav = NULL; |
|
block_ctx_out->pagev = NULL; |
|
block_ctx_out->mem_to_free = NULL; |
|
|
|
kfree(multi); |
|
if (NULL == block_ctx_out->dev) { |
|
ret = -ENXIO; |
|
pr_info("btrfsic: error, cannot lookup dev (#1)!\n"); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static void btrfsic_release_block_ctx(struct btrfsic_block_data_ctx *block_ctx) |
|
{ |
|
if (block_ctx->mem_to_free) { |
|
unsigned int num_pages; |
|
|
|
BUG_ON(!block_ctx->datav); |
|
BUG_ON(!block_ctx->pagev); |
|
num_pages = (block_ctx->len + (u64)PAGE_SIZE - 1) >> |
|
PAGE_SHIFT; |
|
/* Pages must be unmapped in reverse order */ |
|
while (num_pages > 0) { |
|
num_pages--; |
|
if (block_ctx->datav[num_pages]) |
|
block_ctx->datav[num_pages] = NULL; |
|
if (block_ctx->pagev[num_pages]) { |
|
__free_page(block_ctx->pagev[num_pages]); |
|
block_ctx->pagev[num_pages] = NULL; |
|
} |
|
} |
|
|
|
kfree(block_ctx->mem_to_free); |
|
block_ctx->mem_to_free = NULL; |
|
block_ctx->pagev = NULL; |
|
block_ctx->datav = NULL; |
|
} |
|
} |
|
|
|
static int btrfsic_read_block(struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *block_ctx) |
|
{ |
|
unsigned int num_pages; |
|
unsigned int i; |
|
size_t size; |
|
u64 dev_bytenr; |
|
int ret; |
|
|
|
BUG_ON(block_ctx->datav); |
|
BUG_ON(block_ctx->pagev); |
|
BUG_ON(block_ctx->mem_to_free); |
|
if (!PAGE_ALIGNED(block_ctx->dev_bytenr)) { |
|
pr_info("btrfsic: read_block() with unaligned bytenr %llu\n", |
|
block_ctx->dev_bytenr); |
|
return -1; |
|
} |
|
|
|
num_pages = (block_ctx->len + (u64)PAGE_SIZE - 1) >> |
|
PAGE_SHIFT; |
|
size = sizeof(*block_ctx->datav) + sizeof(*block_ctx->pagev); |
|
block_ctx->mem_to_free = kcalloc(num_pages, size, GFP_NOFS); |
|
if (!block_ctx->mem_to_free) |
|
return -ENOMEM; |
|
block_ctx->datav = block_ctx->mem_to_free; |
|
block_ctx->pagev = (struct page **)(block_ctx->datav + num_pages); |
|
for (i = 0; i < num_pages; i++) { |
|
block_ctx->pagev[i] = alloc_page(GFP_NOFS); |
|
if (!block_ctx->pagev[i]) |
|
return -1; |
|
} |
|
|
|
dev_bytenr = block_ctx->dev_bytenr; |
|
for (i = 0; i < num_pages;) { |
|
struct bio *bio; |
|
unsigned int j; |
|
|
|
bio = btrfs_bio_alloc(num_pages - i); |
|
bio_set_dev(bio, block_ctx->dev->bdev); |
|
bio->bi_iter.bi_sector = dev_bytenr >> 9; |
|
bio->bi_opf = REQ_OP_READ; |
|
|
|
for (j = i; j < num_pages; j++) { |
|
ret = bio_add_page(bio, block_ctx->pagev[j], |
|
PAGE_SIZE, 0); |
|
if (PAGE_SIZE != ret) |
|
break; |
|
} |
|
if (j == i) { |
|
pr_info("btrfsic: error, failed to add a single page!\n"); |
|
return -1; |
|
} |
|
if (submit_bio_wait(bio)) { |
|
pr_info("btrfsic: read error at logical %llu dev %pg!\n", |
|
block_ctx->start, block_ctx->dev->bdev); |
|
bio_put(bio); |
|
return -1; |
|
} |
|
bio_put(bio); |
|
dev_bytenr += (j - i) * PAGE_SIZE; |
|
i = j; |
|
} |
|
for (i = 0; i < num_pages; i++) |
|
block_ctx->datav[i] = page_address(block_ctx->pagev[i]); |
|
|
|
return block_ctx->len; |
|
} |
|
|
|
static void btrfsic_dump_database(struct btrfsic_state *state) |
|
{ |
|
const struct btrfsic_block *b_all; |
|
|
|
BUG_ON(NULL == state); |
|
|
|
pr_info("all_blocks_list:\n"); |
|
list_for_each_entry(b_all, &state->all_blocks_list, all_blocks_node) { |
|
const struct btrfsic_block_link *l; |
|
|
|
pr_info("%c-block @%llu (%pg/%llu/%d)\n", |
|
btrfsic_get_block_type(state, b_all), |
|
b_all->logical_bytenr, b_all->dev_state->bdev, |
|
b_all->dev_bytenr, b_all->mirror_num); |
|
|
|
list_for_each_entry(l, &b_all->ref_to_list, node_ref_to) { |
|
pr_info( |
|
" %c @%llu (%pg/%llu/%d) refers %u* to %c @%llu (%pg/%llu/%d)\n", |
|
btrfsic_get_block_type(state, b_all), |
|
b_all->logical_bytenr, b_all->dev_state->bdev, |
|
b_all->dev_bytenr, b_all->mirror_num, |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
} |
|
|
|
list_for_each_entry(l, &b_all->ref_from_list, node_ref_from) { |
|
pr_info( |
|
" %c @%llu (%pg/%llu/%d) is ref %u* from %c @%llu (%pg/%llu/%d)\n", |
|
btrfsic_get_block_type(state, b_all), |
|
b_all->logical_bytenr, b_all->dev_state->bdev, |
|
b_all->dev_bytenr, b_all->mirror_num, |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_from), |
|
l->block_ref_from->logical_bytenr, |
|
l->block_ref_from->dev_state->bdev, |
|
l->block_ref_from->dev_bytenr, |
|
l->block_ref_from->mirror_num); |
|
} |
|
|
|
pr_info("\n"); |
|
} |
|
} |
|
|
|
/* |
|
* Test whether the disk block contains a tree block (leaf or node) |
|
* (note that this test fails for the super block) |
|
*/ |
|
static noinline_for_stack int btrfsic_test_for_metadata( |
|
struct btrfsic_state *state, |
|
char **datav, unsigned int num_pages) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); |
|
struct btrfs_header *h; |
|
u8 csum[BTRFS_CSUM_SIZE]; |
|
unsigned int i; |
|
|
|
if (num_pages * PAGE_SIZE < state->metablock_size) |
|
return 1; /* not metadata */ |
|
num_pages = state->metablock_size >> PAGE_SHIFT; |
|
h = (struct btrfs_header *)datav[0]; |
|
|
|
if (memcmp(h->fsid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE)) |
|
return 1; |
|
|
|
shash->tfm = fs_info->csum_shash; |
|
crypto_shash_init(shash); |
|
|
|
for (i = 0; i < num_pages; i++) { |
|
u8 *data = i ? datav[i] : (datav[i] + BTRFS_CSUM_SIZE); |
|
size_t sublen = i ? PAGE_SIZE : |
|
(PAGE_SIZE - BTRFS_CSUM_SIZE); |
|
|
|
crypto_shash_update(shash, data, sublen); |
|
} |
|
crypto_shash_final(shash, csum); |
|
if (memcmp(csum, h->csum, fs_info->csum_size)) |
|
return 1; |
|
|
|
return 0; /* is metadata */ |
|
} |
|
|
|
static void btrfsic_process_written_block(struct btrfsic_dev_state *dev_state, |
|
u64 dev_bytenr, char **mapped_datav, |
|
unsigned int num_pages, |
|
struct bio *bio, int *bio_is_patched, |
|
int submit_bio_bh_rw) |
|
{ |
|
int is_metadata; |
|
struct btrfsic_block *block; |
|
struct btrfsic_block_data_ctx block_ctx; |
|
int ret; |
|
struct btrfsic_state *state = dev_state->state; |
|
struct block_device *bdev = dev_state->bdev; |
|
unsigned int processed_len; |
|
|
|
if (NULL != bio_is_patched) |
|
*bio_is_patched = 0; |
|
|
|
again: |
|
if (num_pages == 0) |
|
return; |
|
|
|
processed_len = 0; |
|
is_metadata = (0 == btrfsic_test_for_metadata(state, mapped_datav, |
|
num_pages)); |
|
|
|
block = btrfsic_block_hashtable_lookup(bdev, dev_bytenr, |
|
&state->block_hashtable); |
|
if (NULL != block) { |
|
u64 bytenr = 0; |
|
struct btrfsic_block_link *l, *tmp; |
|
|
|
if (block->is_superblock) { |
|
bytenr = btrfs_super_bytenr((struct btrfs_super_block *) |
|
mapped_datav[0]); |
|
if (num_pages * PAGE_SIZE < |
|
BTRFS_SUPER_INFO_SIZE) { |
|
pr_info("btrfsic: cannot work with too short bios!\n"); |
|
return; |
|
} |
|
is_metadata = 1; |
|
BUG_ON(!PAGE_ALIGNED(BTRFS_SUPER_INFO_SIZE)); |
|
processed_len = BTRFS_SUPER_INFO_SIZE; |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE) { |
|
pr_info("[before new superblock is written]:\n"); |
|
btrfsic_dump_tree_sub(state, block, 0); |
|
} |
|
} |
|
if (is_metadata) { |
|
if (!block->is_superblock) { |
|
if (num_pages * PAGE_SIZE < |
|
state->metablock_size) { |
|
pr_info("btrfsic: cannot work with too short bios!\n"); |
|
return; |
|
} |
|
processed_len = state->metablock_size; |
|
bytenr = btrfs_stack_header_bytenr( |
|
(struct btrfs_header *) |
|
mapped_datav[0]); |
|
btrfsic_cmp_log_and_dev_bytenr(state, bytenr, |
|
dev_state, |
|
dev_bytenr); |
|
} |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) { |
|
if (block->logical_bytenr != bytenr && |
|
!(!block->is_metadata && |
|
block->logical_bytenr == 0)) |
|
pr_info( |
|
"written block @%llu (%pg/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu)\n", |
|
bytenr, dev_state->bdev, |
|
dev_bytenr, |
|
block->mirror_num, |
|
btrfsic_get_block_type(state, |
|
block), |
|
block->logical_bytenr); |
|
else |
|
pr_info( |
|
"written block @%llu (%pg/%llu/%d) found in hash table, %c\n", |
|
bytenr, dev_state->bdev, |
|
dev_bytenr, block->mirror_num, |
|
btrfsic_get_block_type(state, |
|
block)); |
|
} |
|
block->logical_bytenr = bytenr; |
|
} else { |
|
if (num_pages * PAGE_SIZE < |
|
state->datablock_size) { |
|
pr_info("btrfsic: cannot work with too short bios!\n"); |
|
return; |
|
} |
|
processed_len = state->datablock_size; |
|
bytenr = block->logical_bytenr; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info( |
|
"written block @%llu (%pg/%llu/%d) found in hash table, %c\n", |
|
bytenr, dev_state->bdev, dev_bytenr, |
|
block->mirror_num, |
|
btrfsic_get_block_type(state, block)); |
|
} |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("ref_to_list: %cE, ref_from_list: %cE\n", |
|
list_empty(&block->ref_to_list) ? ' ' : '!', |
|
list_empty(&block->ref_from_list) ? ' ' : '!'); |
|
if (btrfsic_is_block_ref_by_superblock(state, block, 0)) { |
|
pr_info( |
|
"btrfs: attempt to overwrite %c-block @%llu (%pg/%llu/%d), old(gen=%llu, objectid=%llu, type=%d, offset=%llu), new(gen=%llu), which is referenced by most recent superblock (superblockgen=%llu)!\n", |
|
btrfsic_get_block_type(state, block), bytenr, |
|
dev_state->bdev, dev_bytenr, block->mirror_num, |
|
block->generation, |
|
btrfs_disk_key_objectid(&block->disk_key), |
|
block->disk_key.type, |
|
btrfs_disk_key_offset(&block->disk_key), |
|
btrfs_stack_header_generation( |
|
(struct btrfs_header *) mapped_datav[0]), |
|
state->max_superblock_generation); |
|
btrfsic_dump_tree(state); |
|
} |
|
|
|
if (!block->is_iodone && !block->never_written) { |
|
pr_info( |
|
"btrfs: attempt to overwrite %c-block @%llu (%pg/%llu/%d), oldgen=%llu, newgen=%llu, which is not yet iodone!\n", |
|
btrfsic_get_block_type(state, block), bytenr, |
|
dev_state->bdev, dev_bytenr, block->mirror_num, |
|
block->generation, |
|
btrfs_stack_header_generation( |
|
(struct btrfs_header *) |
|
mapped_datav[0])); |
|
/* it would not be safe to go on */ |
|
btrfsic_dump_tree(state); |
|
goto continue_loop; |
|
} |
|
|
|
/* |
|
* Clear all references of this block. Do not free |
|
* the block itself even if is not referenced anymore |
|
* because it still carries valuable information |
|
* like whether it was ever written and IO completed. |
|
*/ |
|
list_for_each_entry_safe(l, tmp, &block->ref_to_list, |
|
node_ref_to) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_rem_link(state, l); |
|
l->ref_cnt--; |
|
if (0 == l->ref_cnt) { |
|
list_del(&l->node_ref_to); |
|
list_del(&l->node_ref_from); |
|
btrfsic_block_link_hashtable_remove(l); |
|
btrfsic_block_link_free(l); |
|
} |
|
} |
|
|
|
block_ctx.dev = dev_state; |
|
block_ctx.dev_bytenr = dev_bytenr; |
|
block_ctx.start = bytenr; |
|
block_ctx.len = processed_len; |
|
block_ctx.pagev = NULL; |
|
block_ctx.mem_to_free = NULL; |
|
block_ctx.datav = mapped_datav; |
|
|
|
if (is_metadata || state->include_extent_data) { |
|
block->never_written = 0; |
|
block->iodone_w_error = 0; |
|
if (NULL != bio) { |
|
block->is_iodone = 0; |
|
BUG_ON(NULL == bio_is_patched); |
|
if (!*bio_is_patched) { |
|
block->orig_bio_private = |
|
bio->bi_private; |
|
block->orig_bio_end_io = |
|
bio->bi_end_io; |
|
block->next_in_same_bio = NULL; |
|
bio->bi_private = block; |
|
bio->bi_end_io = btrfsic_bio_end_io; |
|
*bio_is_patched = 1; |
|
} else { |
|
struct btrfsic_block *chained_block = |
|
(struct btrfsic_block *) |
|
bio->bi_private; |
|
|
|
BUG_ON(NULL == chained_block); |
|
block->orig_bio_private = |
|
chained_block->orig_bio_private; |
|
block->orig_bio_end_io = |
|
chained_block->orig_bio_end_io; |
|
block->next_in_same_bio = chained_block; |
|
bio->bi_private = block; |
|
} |
|
} else { |
|
block->is_iodone = 1; |
|
block->orig_bio_private = NULL; |
|
block->orig_bio_end_io = NULL; |
|
block->next_in_same_bio = NULL; |
|
} |
|
} |
|
|
|
block->flush_gen = dev_state->last_flush_gen + 1; |
|
block->submit_bio_bh_rw = submit_bio_bh_rw; |
|
if (is_metadata) { |
|
block->logical_bytenr = bytenr; |
|
block->is_metadata = 1; |
|
if (block->is_superblock) { |
|
BUG_ON(PAGE_SIZE != |
|
BTRFS_SUPER_INFO_SIZE); |
|
ret = btrfsic_process_written_superblock( |
|
state, |
|
block, |
|
(struct btrfs_super_block *) |
|
mapped_datav[0]); |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_TREE_AFTER_SB_WRITE) { |
|
pr_info("[after new superblock is written]:\n"); |
|
btrfsic_dump_tree_sub(state, block, 0); |
|
} |
|
} else { |
|
block->mirror_num = 0; /* unknown */ |
|
ret = btrfsic_process_metablock( |
|
state, |
|
block, |
|
&block_ctx, |
|
0, 0); |
|
} |
|
if (ret) |
|
pr_info("btrfsic: btrfsic_process_metablock(root @%llu) failed!\n", |
|
dev_bytenr); |
|
} else { |
|
block->is_metadata = 0; |
|
block->mirror_num = 0; /* unknown */ |
|
block->generation = BTRFSIC_GENERATION_UNKNOWN; |
|
if (!state->include_extent_data |
|
&& list_empty(&block->ref_from_list)) { |
|
/* |
|
* disk block is overwritten with extent |
|
* data (not meta data) and we are configured |
|
* to not include extent data: take the |
|
* chance and free the block's memory |
|
*/ |
|
btrfsic_block_hashtable_remove(block); |
|
list_del(&block->all_blocks_node); |
|
btrfsic_block_free(block); |
|
} |
|
} |
|
btrfsic_release_block_ctx(&block_ctx); |
|
} else { |
|
/* block has not been found in hash table */ |
|
u64 bytenr; |
|
|
|
if (!is_metadata) { |
|
processed_len = state->datablock_size; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info( |
|
"written block (%pg/%llu/?) !found in hash table, D\n", |
|
dev_state->bdev, dev_bytenr); |
|
if (!state->include_extent_data) { |
|
/* ignore that written D block */ |
|
goto continue_loop; |
|
} |
|
|
|
/* this is getting ugly for the |
|
* include_extent_data case... */ |
|
bytenr = 0; /* unknown */ |
|
} else { |
|
processed_len = state->metablock_size; |
|
bytenr = btrfs_stack_header_bytenr( |
|
(struct btrfs_header *) |
|
mapped_datav[0]); |
|
btrfsic_cmp_log_and_dev_bytenr(state, bytenr, dev_state, |
|
dev_bytenr); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info( |
|
"written block @%llu (%pg/%llu/?) !found in hash table, M\n", |
|
bytenr, dev_state->bdev, dev_bytenr); |
|
} |
|
|
|
block_ctx.dev = dev_state; |
|
block_ctx.dev_bytenr = dev_bytenr; |
|
block_ctx.start = bytenr; |
|
block_ctx.len = processed_len; |
|
block_ctx.pagev = NULL; |
|
block_ctx.mem_to_free = NULL; |
|
block_ctx.datav = mapped_datav; |
|
|
|
block = btrfsic_block_alloc(); |
|
if (NULL == block) { |
|
btrfsic_release_block_ctx(&block_ctx); |
|
goto continue_loop; |
|
} |
|
block->dev_state = dev_state; |
|
block->dev_bytenr = dev_bytenr; |
|
block->logical_bytenr = bytenr; |
|
block->is_metadata = is_metadata; |
|
block->never_written = 0; |
|
block->iodone_w_error = 0; |
|
block->mirror_num = 0; /* unknown */ |
|
block->flush_gen = dev_state->last_flush_gen + 1; |
|
block->submit_bio_bh_rw = submit_bio_bh_rw; |
|
if (NULL != bio) { |
|
block->is_iodone = 0; |
|
BUG_ON(NULL == bio_is_patched); |
|
if (!*bio_is_patched) { |
|
block->orig_bio_private = bio->bi_private; |
|
block->orig_bio_end_io = bio->bi_end_io; |
|
block->next_in_same_bio = NULL; |
|
bio->bi_private = block; |
|
bio->bi_end_io = btrfsic_bio_end_io; |
|
*bio_is_patched = 1; |
|
} else { |
|
struct btrfsic_block *chained_block = |
|
(struct btrfsic_block *) |
|
bio->bi_private; |
|
|
|
BUG_ON(NULL == chained_block); |
|
block->orig_bio_private = |
|
chained_block->orig_bio_private; |
|
block->orig_bio_end_io = |
|
chained_block->orig_bio_end_io; |
|
block->next_in_same_bio = chained_block; |
|
bio->bi_private = block; |
|
} |
|
} else { |
|
block->is_iodone = 1; |
|
block->orig_bio_private = NULL; |
|
block->orig_bio_end_io = NULL; |
|
block->next_in_same_bio = NULL; |
|
} |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("new written %c-block @%llu (%pg/%llu/%d)\n", |
|
is_metadata ? 'M' : 'D', |
|
block->logical_bytenr, block->dev_state->bdev, |
|
block->dev_bytenr, block->mirror_num); |
|
list_add(&block->all_blocks_node, &state->all_blocks_list); |
|
btrfsic_block_hashtable_add(block, &state->block_hashtable); |
|
|
|
if (is_metadata) { |
|
ret = btrfsic_process_metablock(state, block, |
|
&block_ctx, 0, 0); |
|
if (ret) |
|
pr_info("btrfsic: process_metablock(root @%llu) failed!\n", |
|
dev_bytenr); |
|
} |
|
btrfsic_release_block_ctx(&block_ctx); |
|
} |
|
|
|
continue_loop: |
|
BUG_ON(!processed_len); |
|
dev_bytenr += processed_len; |
|
mapped_datav += processed_len >> PAGE_SHIFT; |
|
num_pages -= processed_len >> PAGE_SHIFT; |
|
goto again; |
|
} |
|
|
|
static void btrfsic_bio_end_io(struct bio *bp) |
|
{ |
|
struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private; |
|
int iodone_w_error; |
|
|
|
/* mutex is not held! This is not save if IO is not yet completed |
|
* on umount */ |
|
iodone_w_error = 0; |
|
if (bp->bi_status) |
|
iodone_w_error = 1; |
|
|
|
BUG_ON(NULL == block); |
|
bp->bi_private = block->orig_bio_private; |
|
bp->bi_end_io = block->orig_bio_end_io; |
|
|
|
do { |
|
struct btrfsic_block *next_block; |
|
struct btrfsic_dev_state *const dev_state = block->dev_state; |
|
|
|
if ((dev_state->state->print_mask & |
|
BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) |
|
pr_info("bio_end_io(err=%d) for %c @%llu (%pg/%llu/%d)\n", |
|
bp->bi_status, |
|
btrfsic_get_block_type(dev_state->state, block), |
|
block->logical_bytenr, dev_state->bdev, |
|
block->dev_bytenr, block->mirror_num); |
|
next_block = block->next_in_same_bio; |
|
block->iodone_w_error = iodone_w_error; |
|
if (block->submit_bio_bh_rw & REQ_PREFLUSH) { |
|
dev_state->last_flush_gen++; |
|
if ((dev_state->state->print_mask & |
|
BTRFSIC_PRINT_MASK_END_IO_BIO_BH)) |
|
pr_info("bio_end_io() new %pg flush_gen=%llu\n", |
|
dev_state->bdev, |
|
dev_state->last_flush_gen); |
|
} |
|
if (block->submit_bio_bh_rw & REQ_FUA) |
|
block->flush_gen = 0; /* FUA completed means block is |
|
* on disk */ |
|
block->is_iodone = 1; /* for FLUSH, this releases the block */ |
|
block = next_block; |
|
} while (NULL != block); |
|
|
|
bp->bi_end_io(bp); |
|
} |
|
|
|
static int btrfsic_process_written_superblock( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block *const superblock, |
|
struct btrfs_super_block *const super_hdr) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
int pass; |
|
|
|
superblock->generation = btrfs_super_generation(super_hdr); |
|
if (!(superblock->generation > state->max_superblock_generation || |
|
0 == state->max_superblock_generation)) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE) |
|
pr_info( |
|
"btrfsic: superblock @%llu (%pg/%llu/%d) with old gen %llu <= %llu\n", |
|
superblock->logical_bytenr, |
|
superblock->dev_state->bdev, |
|
superblock->dev_bytenr, superblock->mirror_num, |
|
btrfs_super_generation(super_hdr), |
|
state->max_superblock_generation); |
|
} else { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE) |
|
pr_info( |
|
"btrfsic: got new superblock @%llu (%pg/%llu/%d) with new gen %llu > %llu\n", |
|
superblock->logical_bytenr, |
|
superblock->dev_state->bdev, |
|
superblock->dev_bytenr, superblock->mirror_num, |
|
btrfs_super_generation(super_hdr), |
|
state->max_superblock_generation); |
|
|
|
state->max_superblock_generation = |
|
btrfs_super_generation(super_hdr); |
|
state->latest_superblock = superblock; |
|
} |
|
|
|
for (pass = 0; pass < 3; pass++) { |
|
int ret; |
|
u64 next_bytenr; |
|
struct btrfsic_block *next_block; |
|
struct btrfsic_block_data_ctx tmp_next_block_ctx; |
|
struct btrfsic_block_link *l; |
|
int num_copies; |
|
int mirror_num; |
|
const char *additional_string = NULL; |
|
struct btrfs_disk_key tmp_disk_key = {0}; |
|
|
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_ROOT_ITEM_KEY); |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, 0); |
|
|
|
switch (pass) { |
|
case 0: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_ROOT_TREE_OBJECTID); |
|
additional_string = "root "; |
|
next_bytenr = btrfs_super_root(super_hdr); |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("root@%llu\n", next_bytenr); |
|
break; |
|
case 1: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_CHUNK_TREE_OBJECTID); |
|
additional_string = "chunk "; |
|
next_bytenr = btrfs_super_chunk_root(super_hdr); |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("chunk@%llu\n", next_bytenr); |
|
break; |
|
case 2: |
|
btrfs_set_disk_key_objectid(&tmp_disk_key, |
|
BTRFS_TREE_LOG_OBJECTID); |
|
additional_string = "log "; |
|
next_bytenr = btrfs_super_log_root(super_hdr); |
|
if (0 == next_bytenr) |
|
continue; |
|
if (state->print_mask & |
|
BTRFSIC_PRINT_MASK_ROOT_CHUNK_LOG_TREE_LOCATION) |
|
pr_info("log@%llu\n", next_bytenr); |
|
break; |
|
} |
|
|
|
num_copies = btrfs_num_copies(fs_info, next_bytenr, |
|
BTRFS_SUPER_INFO_SIZE); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES) |
|
pr_info("num_copies(log_bytenr=%llu) = %d\n", |
|
next_bytenr, num_copies); |
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
int was_created; |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("btrfsic_process_written_superblock(mirror_num=%d)\n", mirror_num); |
|
ret = btrfsic_map_block(state, next_bytenr, |
|
BTRFS_SUPER_INFO_SIZE, |
|
&tmp_next_block_ctx, |
|
mirror_num); |
|
if (ret) { |
|
pr_info("btrfsic: btrfsic_map_block(@%llu, mirror=%d) failed!\n", |
|
next_bytenr, mirror_num); |
|
return -1; |
|
} |
|
|
|
next_block = btrfsic_block_lookup_or_add( |
|
state, |
|
&tmp_next_block_ctx, |
|
additional_string, |
|
1, 0, 1, |
|
mirror_num, |
|
&was_created); |
|
if (NULL == next_block) { |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
return -1; |
|
} |
|
|
|
next_block->disk_key = tmp_disk_key; |
|
if (was_created) |
|
next_block->generation = |
|
BTRFSIC_GENERATION_UNKNOWN; |
|
l = btrfsic_block_link_lookup_or_add( |
|
state, |
|
&tmp_next_block_ctx, |
|
next_block, |
|
superblock, |
|
BTRFSIC_GENERATION_UNKNOWN); |
|
btrfsic_release_block_ctx(&tmp_next_block_ctx); |
|
if (NULL == l) |
|
return -1; |
|
} |
|
} |
|
|
|
if (WARN_ON(-1 == btrfsic_check_all_ref_blocks(state, superblock, 0))) |
|
btrfsic_dump_tree(state); |
|
|
|
return 0; |
|
} |
|
|
|
static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state, |
|
struct btrfsic_block *const block, |
|
int recursion_level) |
|
{ |
|
const struct btrfsic_block_link *l; |
|
int ret = 0; |
|
|
|
if (recursion_level >= 3 + BTRFS_MAX_LEVEL) { |
|
/* |
|
* Note that this situation can happen and does not |
|
* indicate an error in regular cases. It happens |
|
* when disk blocks are freed and later reused. |
|
* The check-integrity module is not aware of any |
|
* block free operations, it just recognizes block |
|
* write operations. Therefore it keeps the linkage |
|
* information for a block until a block is |
|
* rewritten. This can temporarily cause incorrect |
|
* and even circular linkage information. This |
|
* causes no harm unless such blocks are referenced |
|
* by the most recent super block. |
|
*/ |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("btrfsic: abort cyclic linkage (case 1).\n"); |
|
|
|
return ret; |
|
} |
|
|
|
/* |
|
* This algorithm is recursive because the amount of used stack |
|
* space is very small and the max recursion depth is limited. |
|
*/ |
|
list_for_each_entry(l, &block->ref_to_list, node_ref_to) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info( |
|
"rl=%d, %c @%llu (%pg/%llu/%d) %u* refers to %c @%llu (%pg/%llu/%d)\n", |
|
recursion_level, |
|
btrfsic_get_block_type(state, block), |
|
block->logical_bytenr, block->dev_state->bdev, |
|
block->dev_bytenr, block->mirror_num, |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
if (l->block_ref_to->never_written) { |
|
pr_info( |
|
"btrfs: attempt to write superblock which references block %c @%llu (%pg/%llu/%d) which is never written!\n", |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
ret = -1; |
|
} else if (!l->block_ref_to->is_iodone) { |
|
pr_info( |
|
"btrfs: attempt to write superblock which references block %c @%llu (%pg/%llu/%d) which is not yet iodone!\n", |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
ret = -1; |
|
} else if (l->block_ref_to->iodone_w_error) { |
|
pr_info( |
|
"btrfs: attempt to write superblock which references block %c @%llu (%pg/%llu/%d) which has write error!\n", |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
ret = -1; |
|
} else if (l->parent_generation != |
|
l->block_ref_to->generation && |
|
BTRFSIC_GENERATION_UNKNOWN != |
|
l->parent_generation && |
|
BTRFSIC_GENERATION_UNKNOWN != |
|
l->block_ref_to->generation) { |
|
pr_info( |
|
"btrfs: attempt to write superblock which references block %c @%llu (%pg/%llu/%d) with generation %llu != parent generation %llu!\n", |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num, |
|
l->block_ref_to->generation, |
|
l->parent_generation); |
|
ret = -1; |
|
} else if (l->block_ref_to->flush_gen > |
|
l->block_ref_to->dev_state->last_flush_gen) { |
|
pr_info( |
|
"btrfs: attempt to write superblock which references block %c @%llu (%pg/%llu/%d) which is not flushed out of disk's write cache (block flush_gen=%llu, dev->flush_gen=%llu)!\n", |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, |
|
l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num, block->flush_gen, |
|
l->block_ref_to->dev_state->last_flush_gen); |
|
ret = -1; |
|
} else if (-1 == btrfsic_check_all_ref_blocks(state, |
|
l->block_ref_to, |
|
recursion_level + |
|
1)) { |
|
ret = -1; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static int btrfsic_is_block_ref_by_superblock( |
|
const struct btrfsic_state *state, |
|
const struct btrfsic_block *block, |
|
int recursion_level) |
|
{ |
|
const struct btrfsic_block_link *l; |
|
|
|
if (recursion_level >= 3 + BTRFS_MAX_LEVEL) { |
|
/* refer to comment at "abort cyclic linkage (case 1)" */ |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("btrfsic: abort cyclic linkage (case 2).\n"); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* This algorithm is recursive because the amount of used stack space |
|
* is very small and the max recursion depth is limited. |
|
*/ |
|
list_for_each_entry(l, &block->ref_from_list, node_ref_from) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info( |
|
"rl=%d, %c @%llu (%pg/%llu/%d) is ref %u* from %c @%llu (%pg/%llu/%d)\n", |
|
recursion_level, |
|
btrfsic_get_block_type(state, block), |
|
block->logical_bytenr, block->dev_state->bdev, |
|
block->dev_bytenr, block->mirror_num, |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_from), |
|
l->block_ref_from->logical_bytenr, |
|
l->block_ref_from->dev_state->bdev, |
|
l->block_ref_from->dev_bytenr, |
|
l->block_ref_from->mirror_num); |
|
if (l->block_ref_from->is_superblock && |
|
state->latest_superblock->dev_bytenr == |
|
l->block_ref_from->dev_bytenr && |
|
state->latest_superblock->dev_state->bdev == |
|
l->block_ref_from->dev_state->bdev) |
|
return 1; |
|
else if (btrfsic_is_block_ref_by_superblock(state, |
|
l->block_ref_from, |
|
recursion_level + |
|
1)) |
|
return 1; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static void btrfsic_print_add_link(const struct btrfsic_state *state, |
|
const struct btrfsic_block_link *l) |
|
{ |
|
pr_info("add %u* link from %c @%llu (%pg/%llu/%d) to %c @%llu (%pg/%llu/%d)\n", |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_from), |
|
l->block_ref_from->logical_bytenr, |
|
l->block_ref_from->dev_state->bdev, |
|
l->block_ref_from->dev_bytenr, l->block_ref_from->mirror_num, |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
} |
|
|
|
static void btrfsic_print_rem_link(const struct btrfsic_state *state, |
|
const struct btrfsic_block_link *l) |
|
{ |
|
pr_info("rem %u* link from %c @%llu (%pg/%llu/%d) to %c @%llu (%pg/%llu/%d)\n", |
|
l->ref_cnt, |
|
btrfsic_get_block_type(state, l->block_ref_from), |
|
l->block_ref_from->logical_bytenr, |
|
l->block_ref_from->dev_state->bdev, |
|
l->block_ref_from->dev_bytenr, l->block_ref_from->mirror_num, |
|
btrfsic_get_block_type(state, l->block_ref_to), |
|
l->block_ref_to->logical_bytenr, |
|
l->block_ref_to->dev_state->bdev, l->block_ref_to->dev_bytenr, |
|
l->block_ref_to->mirror_num); |
|
} |
|
|
|
static char btrfsic_get_block_type(const struct btrfsic_state *state, |
|
const struct btrfsic_block *block) |
|
{ |
|
if (block->is_superblock && |
|
state->latest_superblock->dev_bytenr == block->dev_bytenr && |
|
state->latest_superblock->dev_state->bdev == block->dev_state->bdev) |
|
return 'S'; |
|
else if (block->is_superblock) |
|
return 's'; |
|
else if (block->is_metadata) |
|
return 'M'; |
|
else |
|
return 'D'; |
|
} |
|
|
|
static void btrfsic_dump_tree(const struct btrfsic_state *state) |
|
{ |
|
btrfsic_dump_tree_sub(state, state->latest_superblock, 0); |
|
} |
|
|
|
static void btrfsic_dump_tree_sub(const struct btrfsic_state *state, |
|
const struct btrfsic_block *block, |
|
int indent_level) |
|
{ |
|
const struct btrfsic_block_link *l; |
|
int indent_add; |
|
static char buf[80]; |
|
int cursor_position; |
|
|
|
/* |
|
* Should better fill an on-stack buffer with a complete line and |
|
* dump it at once when it is time to print a newline character. |
|
*/ |
|
|
|
/* |
|
* This algorithm is recursive because the amount of used stack space |
|
* is very small and the max recursion depth is limited. |
|
*/ |
|
indent_add = sprintf(buf, "%c-%llu(%pg/%llu/%u)", |
|
btrfsic_get_block_type(state, block), |
|
block->logical_bytenr, block->dev_state->bdev, |
|
block->dev_bytenr, block->mirror_num); |
|
if (indent_level + indent_add > BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) { |
|
printk("[...]\n"); |
|
return; |
|
} |
|
printk(buf); |
|
indent_level += indent_add; |
|
if (list_empty(&block->ref_to_list)) { |
|
printk("\n"); |
|
return; |
|
} |
|
if (block->mirror_num > 1 && |
|
!(state->print_mask & BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS)) { |
|
printk(" [...]\n"); |
|
return; |
|
} |
|
|
|
cursor_position = indent_level; |
|
list_for_each_entry(l, &block->ref_to_list, node_ref_to) { |
|
while (cursor_position < indent_level) { |
|
printk(" "); |
|
cursor_position++; |
|
} |
|
if (l->ref_cnt > 1) |
|
indent_add = sprintf(buf, " %d*--> ", l->ref_cnt); |
|
else |
|
indent_add = sprintf(buf, " --> "); |
|
if (indent_level + indent_add > |
|
BTRFSIC_TREE_DUMP_MAX_INDENT_LEVEL) { |
|
printk("[...]\n"); |
|
cursor_position = 0; |
|
continue; |
|
} |
|
|
|
printk(buf); |
|
|
|
btrfsic_dump_tree_sub(state, l->block_ref_to, |
|
indent_level + indent_add); |
|
cursor_position = 0; |
|
} |
|
} |
|
|
|
static struct btrfsic_block_link *btrfsic_block_link_lookup_or_add( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *next_block_ctx, |
|
struct btrfsic_block *next_block, |
|
struct btrfsic_block *from_block, |
|
u64 parent_generation) |
|
{ |
|
struct btrfsic_block_link *l; |
|
|
|
l = btrfsic_block_link_hashtable_lookup(next_block_ctx->dev->bdev, |
|
next_block_ctx->dev_bytenr, |
|
from_block->dev_state->bdev, |
|
from_block->dev_bytenr, |
|
&state->block_link_hashtable); |
|
if (NULL == l) { |
|
l = btrfsic_block_link_alloc(); |
|
if (!l) |
|
return NULL; |
|
|
|
l->block_ref_to = next_block; |
|
l->block_ref_from = from_block; |
|
l->ref_cnt = 1; |
|
l->parent_generation = parent_generation; |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_add_link(state, l); |
|
|
|
list_add(&l->node_ref_to, &from_block->ref_to_list); |
|
list_add(&l->node_ref_from, &next_block->ref_from_list); |
|
|
|
btrfsic_block_link_hashtable_add(l, |
|
&state->block_link_hashtable); |
|
} else { |
|
l->ref_cnt++; |
|
l->parent_generation = parent_generation; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_add_link(state, l); |
|
} |
|
|
|
return l; |
|
} |
|
|
|
static struct btrfsic_block *btrfsic_block_lookup_or_add( |
|
struct btrfsic_state *state, |
|
struct btrfsic_block_data_ctx *block_ctx, |
|
const char *additional_string, |
|
int is_metadata, |
|
int is_iodone, |
|
int never_written, |
|
int mirror_num, |
|
int *was_created) |
|
{ |
|
struct btrfsic_block *block; |
|
|
|
block = btrfsic_block_hashtable_lookup(block_ctx->dev->bdev, |
|
block_ctx->dev_bytenr, |
|
&state->block_hashtable); |
|
if (NULL == block) { |
|
struct btrfsic_dev_state *dev_state; |
|
|
|
block = btrfsic_block_alloc(); |
|
if (!block) |
|
return NULL; |
|
|
|
dev_state = btrfsic_dev_state_lookup(block_ctx->dev->bdev->bd_dev); |
|
if (NULL == dev_state) { |
|
pr_info("btrfsic: error, lookup dev_state failed!\n"); |
|
btrfsic_block_free(block); |
|
return NULL; |
|
} |
|
block->dev_state = dev_state; |
|
block->dev_bytenr = block_ctx->dev_bytenr; |
|
block->logical_bytenr = block_ctx->start; |
|
block->is_metadata = is_metadata; |
|
block->is_iodone = is_iodone; |
|
block->never_written = never_written; |
|
block->mirror_num = mirror_num; |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
pr_info("New %s%c-block @%llu (%pg/%llu/%d)\n", |
|
additional_string, |
|
btrfsic_get_block_type(state, block), |
|
block->logical_bytenr, dev_state->bdev, |
|
block->dev_bytenr, mirror_num); |
|
list_add(&block->all_blocks_node, &state->all_blocks_list); |
|
btrfsic_block_hashtable_add(block, &state->block_hashtable); |
|
if (NULL != was_created) |
|
*was_created = 1; |
|
} else { |
|
if (NULL != was_created) |
|
*was_created = 0; |
|
} |
|
|
|
return block; |
|
} |
|
|
|
static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state, |
|
u64 bytenr, |
|
struct btrfsic_dev_state *dev_state, |
|
u64 dev_bytenr) |
|
{ |
|
struct btrfs_fs_info *fs_info = state->fs_info; |
|
struct btrfsic_block_data_ctx block_ctx; |
|
int num_copies; |
|
int mirror_num; |
|
int match = 0; |
|
int ret; |
|
|
|
num_copies = btrfs_num_copies(fs_info, bytenr, state->metablock_size); |
|
|
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
ret = btrfsic_map_block(state, bytenr, state->metablock_size, |
|
&block_ctx, mirror_num); |
|
if (ret) { |
|
pr_info("btrfsic: btrfsic_map_block(logical @%llu, mirror %d) failed!\n", |
|
bytenr, mirror_num); |
|
continue; |
|
} |
|
|
|
if (dev_state->bdev == block_ctx.dev->bdev && |
|
dev_bytenr == block_ctx.dev_bytenr) { |
|
match++; |
|
btrfsic_release_block_ctx(&block_ctx); |
|
break; |
|
} |
|
btrfsic_release_block_ctx(&block_ctx); |
|
} |
|
|
|
if (WARN_ON(!match)) { |
|
pr_info( |
|
"btrfs: attempt to write M-block which contains logical bytenr that doesn't map to dev+physical bytenr of submit_bio, buffer->log_bytenr=%llu, submit_bio(bdev=%pg, phys_bytenr=%llu)!\n", |
|
bytenr, dev_state->bdev, dev_bytenr); |
|
for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) { |
|
ret = btrfsic_map_block(state, bytenr, |
|
state->metablock_size, |
|
&block_ctx, mirror_num); |
|
if (ret) |
|
continue; |
|
|
|
pr_info("read logical bytenr @%llu maps to (%pg/%llu/%d)\n", |
|
bytenr, block_ctx.dev->bdev, |
|
block_ctx.dev_bytenr, mirror_num); |
|
} |
|
} |
|
} |
|
|
|
static struct btrfsic_dev_state *btrfsic_dev_state_lookup(dev_t dev) |
|
{ |
|
return btrfsic_dev_state_hashtable_lookup(dev, |
|
&btrfsic_dev_state_hashtable); |
|
} |
|
|
|
static void __btrfsic_submit_bio(struct bio *bio) |
|
{ |
|
struct btrfsic_dev_state *dev_state; |
|
|
|
if (!btrfsic_is_initialized) |
|
return; |
|
|
|
mutex_lock(&btrfsic_mutex); |
|
/* since btrfsic_submit_bio() is also called before |
|
* btrfsic_mount(), this might return NULL */ |
|
dev_state = btrfsic_dev_state_lookup(bio->bi_bdev->bd_dev); |
|
if (NULL != dev_state && |
|
(bio_op(bio) == REQ_OP_WRITE) && bio_has_data(bio)) { |
|
int i = 0; |
|
u64 dev_bytenr; |
|
u64 cur_bytenr; |
|
struct bio_vec bvec; |
|
struct bvec_iter iter; |
|
int bio_is_patched; |
|
char **mapped_datav; |
|
unsigned int segs = bio_segments(bio); |
|
|
|
dev_bytenr = 512 * bio->bi_iter.bi_sector; |
|
bio_is_patched = 0; |
|
if (dev_state->state->print_mask & |
|
BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) |
|
pr_info("submit_bio(rw=%d,0x%x, bi_vcnt=%u, bi_sector=%llu (bytenr %llu), bi_bdev=%p)\n", |
|
bio_op(bio), bio->bi_opf, segs, |
|
bio->bi_iter.bi_sector, dev_bytenr, bio->bi_bdev); |
|
|
|
mapped_datav = kmalloc_array(segs, |
|
sizeof(*mapped_datav), GFP_NOFS); |
|
if (!mapped_datav) |
|
goto leave; |
|
cur_bytenr = dev_bytenr; |
|
|
|
bio_for_each_segment(bvec, bio, iter) { |
|
BUG_ON(bvec.bv_len != PAGE_SIZE); |
|
mapped_datav[i] = page_address(bvec.bv_page); |
|
i++; |
|
|
|
if (dev_state->state->print_mask & |
|
BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE) |
|
pr_info("#%u: bytenr=%llu, len=%u, offset=%u\n", |
|
i, cur_bytenr, bvec.bv_len, bvec.bv_offset); |
|
cur_bytenr += bvec.bv_len; |
|
} |
|
btrfsic_process_written_block(dev_state, dev_bytenr, |
|
mapped_datav, segs, |
|
bio, &bio_is_patched, |
|
bio->bi_opf); |
|
kfree(mapped_datav); |
|
} else if (NULL != dev_state && (bio->bi_opf & REQ_PREFLUSH)) { |
|
if (dev_state->state->print_mask & |
|
BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH) |
|
pr_info("submit_bio(rw=%d,0x%x FLUSH, bdev=%p)\n", |
|
bio_op(bio), bio->bi_opf, bio->bi_bdev); |
|
if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) { |
|
if ((dev_state->state->print_mask & |
|
(BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH | |
|
BTRFSIC_PRINT_MASK_VERBOSE))) |
|
pr_info( |
|
"btrfsic_submit_bio(%pg) with FLUSH but dummy block already in use (ignored)!\n", |
|
dev_state->bdev); |
|
} else { |
|
struct btrfsic_block *const block = |
|
&dev_state->dummy_block_for_bio_bh_flush; |
|
|
|
block->is_iodone = 0; |
|
block->never_written = 0; |
|
block->iodone_w_error = 0; |
|
block->flush_gen = dev_state->last_flush_gen + 1; |
|
block->submit_bio_bh_rw = bio->bi_opf; |
|
block->orig_bio_private = bio->bi_private; |
|
block->orig_bio_end_io = bio->bi_end_io; |
|
block->next_in_same_bio = NULL; |
|
bio->bi_private = block; |
|
bio->bi_end_io = btrfsic_bio_end_io; |
|
} |
|
} |
|
leave: |
|
mutex_unlock(&btrfsic_mutex); |
|
} |
|
|
|
void btrfsic_submit_bio(struct bio *bio) |
|
{ |
|
__btrfsic_submit_bio(bio); |
|
submit_bio(bio); |
|
} |
|
|
|
int btrfsic_submit_bio_wait(struct bio *bio) |
|
{ |
|
__btrfsic_submit_bio(bio); |
|
return submit_bio_wait(bio); |
|
} |
|
|
|
int btrfsic_mount(struct btrfs_fs_info *fs_info, |
|
struct btrfs_fs_devices *fs_devices, |
|
int including_extent_data, u32 print_mask) |
|
{ |
|
int ret; |
|
struct btrfsic_state *state; |
|
struct list_head *dev_head = &fs_devices->devices; |
|
struct btrfs_device *device; |
|
|
|
if (!PAGE_ALIGNED(fs_info->nodesize)) { |
|
pr_info("btrfsic: cannot handle nodesize %d not being a multiple of PAGE_SIZE %ld!\n", |
|
fs_info->nodesize, PAGE_SIZE); |
|
return -1; |
|
} |
|
if (!PAGE_ALIGNED(fs_info->sectorsize)) { |
|
pr_info("btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_SIZE %ld!\n", |
|
fs_info->sectorsize, PAGE_SIZE); |
|
return -1; |
|
} |
|
state = kvzalloc(sizeof(*state), GFP_KERNEL); |
|
if (!state) |
|
return -ENOMEM; |
|
|
|
if (!btrfsic_is_initialized) { |
|
mutex_init(&btrfsic_mutex); |
|
btrfsic_dev_state_hashtable_init(&btrfsic_dev_state_hashtable); |
|
btrfsic_is_initialized = 1; |
|
} |
|
mutex_lock(&btrfsic_mutex); |
|
state->fs_info = fs_info; |
|
state->print_mask = print_mask; |
|
state->include_extent_data = including_extent_data; |
|
state->metablock_size = fs_info->nodesize; |
|
state->datablock_size = fs_info->sectorsize; |
|
INIT_LIST_HEAD(&state->all_blocks_list); |
|
btrfsic_block_hashtable_init(&state->block_hashtable); |
|
btrfsic_block_link_hashtable_init(&state->block_link_hashtable); |
|
state->max_superblock_generation = 0; |
|
state->latest_superblock = NULL; |
|
|
|
list_for_each_entry(device, dev_head, dev_list) { |
|
struct btrfsic_dev_state *ds; |
|
|
|
if (!device->bdev || !device->name) |
|
continue; |
|
|
|
ds = btrfsic_dev_state_alloc(); |
|
if (NULL == ds) { |
|
mutex_unlock(&btrfsic_mutex); |
|
return -ENOMEM; |
|
} |
|
ds->bdev = device->bdev; |
|
ds->state = state; |
|
btrfsic_dev_state_hashtable_add(ds, |
|
&btrfsic_dev_state_hashtable); |
|
} |
|
|
|
ret = btrfsic_process_superblock(state, fs_devices); |
|
if (0 != ret) { |
|
mutex_unlock(&btrfsic_mutex); |
|
btrfsic_unmount(fs_devices); |
|
return ret; |
|
} |
|
|
|
if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_DATABASE) |
|
btrfsic_dump_database(state); |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_INITIAL_TREE) |
|
btrfsic_dump_tree(state); |
|
|
|
mutex_unlock(&btrfsic_mutex); |
|
return 0; |
|
} |
|
|
|
void btrfsic_unmount(struct btrfs_fs_devices *fs_devices) |
|
{ |
|
struct btrfsic_block *b_all, *tmp_all; |
|
struct btrfsic_state *state; |
|
struct list_head *dev_head = &fs_devices->devices; |
|
struct btrfs_device *device; |
|
|
|
if (!btrfsic_is_initialized) |
|
return; |
|
|
|
mutex_lock(&btrfsic_mutex); |
|
|
|
state = NULL; |
|
list_for_each_entry(device, dev_head, dev_list) { |
|
struct btrfsic_dev_state *ds; |
|
|
|
if (!device->bdev || !device->name) |
|
continue; |
|
|
|
ds = btrfsic_dev_state_hashtable_lookup( |
|
device->bdev->bd_dev, |
|
&btrfsic_dev_state_hashtable); |
|
if (NULL != ds) { |
|
state = ds->state; |
|
btrfsic_dev_state_hashtable_remove(ds); |
|
btrfsic_dev_state_free(ds); |
|
} |
|
} |
|
|
|
if (NULL == state) { |
|
pr_info("btrfsic: error, cannot find state information on umount!\n"); |
|
mutex_unlock(&btrfsic_mutex); |
|
return; |
|
} |
|
|
|
/* |
|
* Don't care about keeping the lists' state up to date, |
|
* just free all memory that was allocated dynamically. |
|
* Free the blocks and the block_links. |
|
*/ |
|
list_for_each_entry_safe(b_all, tmp_all, &state->all_blocks_list, |
|
all_blocks_node) { |
|
struct btrfsic_block_link *l, *tmp; |
|
|
|
list_for_each_entry_safe(l, tmp, &b_all->ref_to_list, |
|
node_ref_to) { |
|
if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE) |
|
btrfsic_print_rem_link(state, l); |
|
|
|
l->ref_cnt--; |
|
if (0 == l->ref_cnt) |
|
btrfsic_block_link_free(l); |
|
} |
|
|
|
if (b_all->is_iodone || b_all->never_written) |
|
btrfsic_block_free(b_all); |
|
else |
|
pr_info( |
|
"btrfs: attempt to free %c-block @%llu (%pg/%llu/%d) on umount which is not yet iodone!\n", |
|
btrfsic_get_block_type(state, b_all), |
|
b_all->logical_bytenr, b_all->dev_state->bdev, |
|
b_all->dev_bytenr, b_all->mirror_num); |
|
} |
|
|
|
mutex_unlock(&btrfsic_mutex); |
|
|
|
kvfree(state); |
|
}
|
|
|