thin-provisioning-tools/thin-provisioning/metadata_checker.h
2013-05-08 16:38:04 +01:00

167 lines
5.0 KiB
C++

// Copyright (C) 2011 Red Hat, Inc. All rights reserved.
//
// This file is part of the thin-provisioning-tools source.
//
// thin-provisioning-tools is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// thin-provisioning-tools is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with thin-provisioning-tools. If not, see
// <http://www.gnu.org/licenses/>.
#ifndef METADATA_CHECKER_H
#define METADATA_CHECKER_H
#include "persistent-data/block.h"
#include "persistent-data/error_set.h"
#include "persistent-data/range.h"
#include "persistent-data/space_map.h"
#include <deque>
//----------------------------------------------------------------
namespace thin_provisioning {
class metadata_damage_visitor;
// Base class for all types of metadata damage. Used in reporting.
class metadata_damage {
public:
typedef boost::shared_ptr<metadata_damage> ptr;
virtual ~metadata_damage() {}
virtual void visit(metadata_damage_visitor &visitor) const = 0;
void set_message(std::string const &message);
std::string const &get_message() const;
private:
std::string message_;
};
// 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::range<uint64_t> range64;
struct missing_device_details : public metadata_damage {
missing_device_details(range64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_device_details const &rhs) const;
range64 missing_;
};
struct missing_devices : public metadata_damage {
missing_devices(range64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_devices const &rhs) const;
range64 missing_;
};
struct missing_mappings : public metadata_damage {
missing_mappings(uint64_t dev, range64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_mappings const &rhs) const;
uint64_t dev_;
range64 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(range64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_metadata_ref_counts const &rhs) const;
range64 missing_;
};
struct missing_data_ref_counts : public metadata_damage {
missing_data_ref_counts(range64 missing);
virtual void visit(metadata_damage_visitor &visitor) const;
bool operator ==(missing_data_ref_counts const &rhs) const;
range64 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;
//--------------------------------
class checker {
public:
typedef persistent_data::block_manager<> block_manager;
typedef boost::shared_ptr<checker> ptr;
checker(block_manager::ptr bm);
virtual ~checker() {};
virtual damage_list_ptr check() = 0;
protected:
block_manager::ptr bm_;
};
}
//----------------------------------------------------------------
#endif