mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![David Sterba](/assets/img/avatar_default.png)
Since commit 72deb455b5
("block: remove CONFIG_LBDAF") (5.2) the
sector_t type is u64 on all arches and configs so we don't need to
typecast it. It used to be unsigned long and the result of sector size
shifts were not guaranteed to fit in the type.
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2908 lines
89 KiB
C
2908 lines
89 KiB
C
// 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;
|
|
char name[BDEVNAME_SIZE];
|
|
};
|
|
|
|
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 void btrfsic_block_init(struct btrfsic_block *b);
|
|
static struct btrfsic_block *btrfsic_block_alloc(void);
|
|
static void btrfsic_block_free(struct btrfsic_block *b);
|
|
static void btrfsic_block_link_init(struct btrfsic_block_link *n);
|
|
static struct btrfsic_block_link *btrfsic_block_link_alloc(void);
|
|
static void btrfsic_block_link_free(struct btrfsic_block_link *n);
|
|
static void btrfsic_dev_state_init(struct btrfsic_dev_state *ds);
|
|
static struct btrfsic_dev_state *btrfsic_dev_state_alloc(void);
|
|
static void btrfsic_dev_state_free(struct btrfsic_dev_state *ds);
|
|
static void btrfsic_block_hashtable_init(struct btrfsic_block_hashtable *h);
|
|
static void btrfsic_block_hashtable_add(struct btrfsic_block *b,
|
|
struct btrfsic_block_hashtable *h);
|
|
static void btrfsic_block_hashtable_remove(struct btrfsic_block *b);
|
|
static struct btrfsic_block *btrfsic_block_hashtable_lookup(
|
|
struct block_device *bdev,
|
|
u64 dev_bytenr,
|
|
struct btrfsic_block_hashtable *h);
|
|
static void btrfsic_block_link_hashtable_init(
|
|
struct btrfsic_block_link_hashtable *h);
|
|
static void btrfsic_block_link_hashtable_add(
|
|
struct btrfsic_block_link *l,
|
|
struct btrfsic_block_link_hashtable *h);
|
|
static void btrfsic_block_link_hashtable_remove(struct btrfsic_block_link *l);
|
|
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);
|
|
static void btrfsic_dev_state_hashtable_init(
|
|
struct btrfsic_dev_state_hashtable *h);
|
|
static void btrfsic_dev_state_hashtable_add(
|
|
struct btrfsic_dev_state *ds,
|
|
struct btrfsic_dev_state_hashtable *h);
|
|
static void btrfsic_dev_state_hashtable_remove(struct btrfsic_dev_state *ds);
|
|
static struct btrfsic_dev_state *btrfsic_dev_state_hashtable_lookup(dev_t dev,
|
|
struct btrfsic_dev_state_hashtable *h);
|
|
static struct btrfsic_stack_frame *btrfsic_stack_frame_alloc(void);
|
|
static void btrfsic_stack_frame_free(struct btrfsic_stack_frame *sf);
|
|
static int btrfsic_process_superblock(struct btrfsic_state *state,
|
|
struct btrfs_fs_devices *fs_devices);
|
|
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 void btrfsic_dump_database(struct btrfsic_state *state);
|
|
static int btrfsic_test_for_metadata(struct btrfsic_state *state,
|
|
char **datav, unsigned int num_pages);
|
|
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);
|
|
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;
|
|
ds->name[0] = '\0';
|
|
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 (%s/%llu/%d)",
|
|
superblock_bdev,
|
|
rcu_str_deref(device->name), dev_bytenr,
|
|
dev_state->name, 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 %s\n",
|
|
sf->block_ctx->start,
|
|
sf->block_ctx->dev->name);
|
|
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 %s\n",
|
|
sf->block_ctx->start,
|
|
sf->block_ctx->dev->name);
|
|
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 (%s/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu).\n",
|
|
next_bytenr, next_block_ctx->dev->name,
|
|
next_block_ctx->dev_bytenr, *mirror_nump,
|
|
btrfsic_get_block_type(state,
|
|
next_block),
|
|
next_block->logical_bytenr);
|
|
else
|
|
pr_info("Referenced block @%llu (%s/%llu/%d) found in hash table, %c.\n",
|
|
next_bytenr, next_block_ctx->dev->name,
|
|
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 %s\n",
|
|
block_ctx->start, block_ctx->dev->name);
|
|
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 %s\n",
|
|
block_ctx->start, block_ctx->dev->name);
|
|
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 (%s/%llu/%d) found in hash table, D, bytenr mismatch (!= stored %llu).\n",
|
|
next_bytenr,
|
|
next_block_ctx.dev->name,
|
|
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_bio *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;
|
|
while (num_pages > 0) {
|
|
num_pages--;
|
|
if (block_ctx->datav[num_pages]) {
|
|
kunmap(block_ctx->pagev[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_io_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 %s!\n",
|
|
block_ctx->start, block_ctx->dev->name);
|
|
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] = kmap(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 (%s/%llu/%d)\n",
|
|
btrfsic_get_block_type(state, b_all),
|
|
b_all->logical_bytenr, b_all->dev_state->name,
|
|
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 (%s/%llu/%d) refers %u* to %c @%llu (%s/%llu/%d)\n",
|
|
btrfsic_get_block_type(state, b_all),
|
|
b_all->logical_bytenr, b_all->dev_state->name,
|
|
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->name,
|
|
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 (%s/%llu/%d) is ref %u* from %c @%llu (%s/%llu/%d)\n",
|
|
btrfsic_get_block_type(state, b_all),
|
|
b_all->logical_bytenr, b_all->dev_state->name,
|
|
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->name,
|
|
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 (%s/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu).\n",
|
|
bytenr, dev_state->name,
|
|
dev_bytenr,
|
|
block->mirror_num,
|
|
btrfsic_get_block_type(state,
|
|
block),
|
|
block->logical_bytenr);
|
|
else
|
|
pr_info("Written block @%llu (%s/%llu/%d) found in hash table, %c.\n",
|
|
bytenr, dev_state->name,
|
|
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 (%s/%llu/%d) found in hash table, %c.\n",
|
|
bytenr, dev_state->name, 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 (%s/%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->name, 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 (%s/%llu/%d), oldgen=%llu, newgen=%llu, which is not yet iodone!\n",
|
|
btrfsic_get_block_type(state, block), bytenr,
|
|
dev_state->name, 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 (%s/%llu/?) !found in hash table, D.\n",
|
|
dev_state->name, 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 (%s/%llu/?) !found in hash table, M.\n",
|
|
bytenr, dev_state->name, 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 (%s/%llu/%d)\n",
|
|
is_metadata ? 'M' : 'D',
|
|
block->logical_bytenr, block->dev_state->name,
|
|
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 (%s/%llu/%d)\n",
|
|
bp->bi_status,
|
|
btrfsic_get_block_type(dev_state->state, block),
|
|
block->logical_bytenr, dev_state->name,
|
|
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 %s flush_gen=%llu\n",
|
|
dev_state->name,
|
|
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 (%s/%llu/%d) with old gen %llu <= %llu\n",
|
|
superblock->logical_bytenr,
|
|
superblock->dev_state->name,
|
|
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 (%s/%llu/%d) with new gen %llu > %llu\n",
|
|
superblock->logical_bytenr,
|
|
superblock->dev_state->name,
|
|
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 (%s/%llu/%d) %u* refers to %c @%llu (%s/%llu/%d)\n",
|
|
recursion_level,
|
|
btrfsic_get_block_type(state, block),
|
|
block->logical_bytenr, block->dev_state->name,
|
|
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->name,
|
|
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 (%s/%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->name,
|
|
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 (%s/%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->name,
|
|
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 (%s/%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->name,
|
|
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 (%s/%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->name,
|
|
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 (%s/%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->name,
|
|
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 (%s/%llu/%d) is ref %u* from %c @%llu (%s/%llu/%d)\n",
|
|
recursion_level,
|
|
btrfsic_get_block_type(state, block),
|
|
block->logical_bytenr, block->dev_state->name,
|
|
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->name,
|
|
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 (%s/%llu/%d) to %c @%llu (%s/%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->name,
|
|
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->name, 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 (%s/%llu/%d) to %c @%llu (%s/%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->name,
|
|
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->name, 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(%s/%llu/%u)",
|
|
btrfsic_get_block_type(state, block),
|
|
block->logical_bytenr, block->dev_state->name,
|
|
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 (%s/%llu/%d)\n",
|
|
additional_string,
|
|
btrfsic_get_block_type(state, block),
|
|
block->logical_bytenr, dev_state->name,
|
|
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=%s, phys_bytenr=%llu)!\n",
|
|
bytenr, dev_state->name, 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 (%s/%llu/%d)\n",
|
|
bytenr, block_ctx.dev->name,
|
|
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_dev(bio) + bio->bi_partno);
|
|
if (NULL != dev_state &&
|
|
(bio_op(bio) == REQ_OP_WRITE) && bio_has_data(bio)) {
|
|
unsigned 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_disk=%p)\n",
|
|
bio_op(bio), bio->bi_opf, segs,
|
|
bio->bi_iter.bi_sector, dev_bytenr, bio->bi_disk);
|
|
|
|
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] = kmap(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);
|
|
bio_for_each_segment(bvec, bio, iter)
|
|
kunmap(bvec.bv_page);
|
|
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, disk=%p)\n",
|
|
bio_op(bio), bio->bi_opf, bio->bi_disk);
|
|
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(%s) with FLUSH but dummy block already in use (ignored)!\n",
|
|
dev_state->name);
|
|
} 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;
|
|
const char *p;
|
|
|
|
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;
|
|
bdevname(ds->bdev, ds->name);
|
|
ds->name[BDEVNAME_SIZE - 1] = '\0';
|
|
p = kbasename(ds->name);
|
|
strlcpy(ds->name, p, sizeof(ds->name));
|
|
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 (%s/%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->name,
|
|
b_all->dev_bytenr, b_all->mirror_num);
|
|
}
|
|
|
|
mutex_unlock(&btrfsic_mutex);
|
|
|
|
kvfree(state);
|
|
}
|