[thin_check] factor out metadata_checker

This commit is contained in:
Ming-Hung Tsai
2020-02-16 16:43:31 +08:00
committed by Joe Thornber
parent d6a8c03aa2
commit c85ea5ef76
3 changed files with 332 additions and 713 deletions

View File

@@ -19,142 +19,54 @@
#ifndef METADATA_CHECKER_H
#define METADATA_CHECKER_H
#include "base/error_state.h"
#include "block-cache/block_cache.h"
#include "persistent-data/block.h"
#include "persistent-data/error_set.h"
#include "persistent-data/run.h"
#include "persistent-data/space_map.h"
#include <deque>
//----------------------------------------------------------------
namespace thin_provisioning {
// FIXME: should take a block manager or transaction manager
void check_metadata(std::string const &path);
struct check_options {
enum data_mapping_options {
DATA_MAPPING_NONE,
DATA_MAPPING_LEVEL1,
DATA_MAPPING_LEVEL2,
};
enum metadata_space_map_options {
METADATA_SPACE_MAP_NONE,
METADATA_SPACE_MAP_FULL,
};
check_options();
void set_superblock_only();
void set_skip_mappings();
void set_override_mapping_root(bcache::block_address b);
data_mapping_options check_data_mappings_;
metadata_space_map_options check_metadata_space_map_;
boost::optional<bcache::block_address> override_mapping_root_;
};
enum output_options {
OUTPUT_NORMAL,
OUTPUT_QUIET,
};
#if 0
// Base class for all types of metadata damage. Used in reporting.
class metadata_damage {
class metadata_checker {
public:
typedef boost::shared_ptr<metadata_damage> ptr;
virtual ~metadata_damage() {}
virtual void visit(metadata_damage_visitor &visitor) const = 0;
typedef boost::shared_ptr<metadata_checker> ptr;
void set_message(std::string const &message);
std::string const &get_message() const;
virtual ~metadata_checker() {}
private:
std::string message_;
virtual base::error_state check() = 0;
};
// FIXME: there's a mix of abstraction here, some classes represent
// the actual damage on disk (bad_ref_count), others represent the
// repercussions (missing_mapping). Need to revist, probably once
// we've got the reporting layer in.
class super_block_corruption : public metadata_damage {
void visit(metadata_damage_visitor &visitor) const;
bool operator ==(super_block_corruption const &rhs) const;
};
typedef base::run<uint64_t> run64;
struct missing_device_details : public metadata_damage {
missing_device_details(run64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_device_details const &rhs) const;
run64 missing_;
};
struct missing_devices : public metadata_damage {
missing_devices(run64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_devices const &rhs) const;
run64 missing_;
};
struct missing_mappings : public metadata_damage {
missing_mappings(uint64_t dev, run64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_mappings const &rhs) const;
uint64_t dev_;
run64 missing_;
};
struct bad_metadata_ref_count : public metadata_damage {
bad_metadata_ref_count(block_address b,
ref_t actual,
ref_t expected);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(bad_metadata_ref_count const &rhs) const;
block_address b_;
ref_t actual_;
ref_t expected_;
};
struct bad_data_ref_count : public metadata_damage {
bad_data_ref_count(block_address b,
ref_t actual,
ref_t expected);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(bad_data_ref_count const &rhs) const;
block_address b_;
ref_t actual_;
ref_t expected_;
};
struct missing_metadata_ref_counts : public metadata_damage {
missing_metadata_ref_counts(run64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_metadata_ref_counts const &rhs) const;
run64 missing_;
};
struct missing_data_ref_counts : public metadata_damage {
missing_data_ref_counts(run64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_data_ref_counts const &rhs) const;
run64 missing_;
};
class metadata_damage_visitor {
public:
typedef boost::shared_ptr<metadata_damage_visitor> ptr;
virtual ~metadata_damage_visitor() {}
void visit(metadata_damage const &damage);
virtual void visit(super_block_corruption const &damage) = 0;
virtual void visit(missing_device_details const &damage) = 0;
virtual void visit(missing_devices const &damage) = 0;
virtual void visit(missing_mappings const &damage) = 0;
virtual void visit(bad_metadata_ref_count const &damage) = 0;
virtual void visit(bad_data_ref_count const &damage) = 0;
virtual void visit(missing_metadata_ref_counts const &damage) = 0;
virtual void visit(missing_data_ref_counts const &damage) = 0;
};
typedef std::deque<metadata_damage::ptr> damage_list;
typedef boost::shared_ptr<damage_list> damage_list_ptr;
#endif
metadata_checker::ptr
create_base_checker(persistent_data::block_manager<>::ptr bm,
check_options const &check_opts,
output_options output_opts);
}
//----------------------------------------------------------------