emo/thin-provisioning-tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

start removing block_manager<>::block

Browse Source
This commit is contained in:
Joe Thornber
2014-07-25 14:46:51 +01:00
parent b32908d5c2
commit 7e870ea5a6
18 changed files with 208 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
persistent-data/block.h
View File

@ -40,8 +40,6 @@ namespace persistent_data {
uint32_t const MD_BLOCK_SIZE = 4096;
typedef uint64_t block_address;
template <uint32_t BlockSize = MD_BLOCK_SIZE>
class block_manager : private boost::noncopyable {
public:
@ -58,22 +56,6 @@ namespace persistent_data {
unsigned max_concurrent_locks,
mode m);
class validator {
public:
typedef boost::shared_ptr<validator> ptr;
virtual ~validator() {}
virtual void check(buffer<BlockSize> const &b, block_address location) const = 0;
virtual void prepare(buffer<BlockSize> &b, block_address location) const = 0;
};
class noop_validator : public validator {
public:
void check(buffer<BlockSize> const &b, block_address location) const {}
void prepare(buffer<BlockSize> &b, block_address location) const {}
};
enum block_type {
BT_SUPERBLOCK,
BT_NORMAL
@ -86,7 +68,7 @@ namespace persistent_data {
block(block_cache &bc,
block_address location,
block_type bt,
typename validator::ptr v,
typename bcache::validator::ptr v,
bool zero = false);
~block();
@ -98,14 +80,11 @@ namespace persistent_data {
// FIXME: finish
}
void change_validator(typename block_manager<BlockSize>::validator::ptr v,
bool check = true);
block_type get_type() const;
uint64_t get_location() const;
buffer<BlockSize> const &get_buffer() const;
buffer<BlockSize> &get_buffer();
void const *get_data() const;
void *get_data();
void mark_dirty();
void unlock();
@ -115,11 +94,9 @@ namespace persistent_data {
block_cache &bc_;
block_cache::block *internal_;
typename validator::ptr validator_;
block_type bt_;
bool dirty_;
bool unlocked_;
buffer<BlockSize> buffer_;
};
class read_ref {
@ -134,7 +111,7 @@ namespace persistent_data {
read_ref const &operator =(read_ref const &rhs);
block_address get_location() const;
buffer<BlockSize> const &data() const;
void const * data() const;
protected:
block_manager<BlockSize> const *bm_;
@ -150,24 +127,24 @@ namespace persistent_data {
typename block::ptr b);
using read_ref::data;
buffer<BlockSize> &data();
void *data();
};
// Locking methods
read_ref
read_lock(block_address location,
typename validator::ptr v =
typename validator::ptr(new noop_validator())) const;
typename validator::ptr(new bcache::noop_validator())) const;
write_ref
write_lock(block_address location,
typename validator::ptr v =
typename validator::ptr(new noop_validator()));
typename validator::ptr(new bcache::noop_validator()));
write_ref
write_lock_zero(block_address location,
typename validator::ptr v =
typename validator::ptr(new noop_validator()));
typename validator::ptr(new bcache::noop_validator()));
// The super block is the one that should be written last.
// Unlocking this block triggers the following events:
@ -181,10 +158,10 @@ namespace persistent_data {
// being unlocked then an exception will be thrown.
write_ref superblock(block_address b,
typename validator::ptr v =
typename validator::ptr(new noop_validator()));
typename validator::ptr(new bcache::noop_validator()));
write_ref superblock_zero(block_address b,
typename validator::ptr v =
typename validator::ptr(new noop_validator()));
typename validator::ptr(new bcache::noop_validator()));
block_address get_nr_blocks() const;
@ -206,9 +183,9 @@ namespace persistent_data {
};
// A little utility to help build validators
inline block_manager<>::validator::ptr
mk_validator(block_manager<>::validator *v) {
return block_manager<>::validator::ptr(v);
inline bcache::validator::ptr
mk_validator(bcache::validator *v) {
return bcache::validator::ptr(v);
}
}

64
persistent-data/block.tcc
View File

@ -112,20 +112,15 @@ namespace persistent_data {
typename validator::ptr v,
bool zero)
: bc_(bc),
validator_(v),
bt_(bt),
dirty_(false),
unlocked_(false),
buffer_(0, true) // FIXME: we don't know if it's writeable here :(
unlocked_(false)
{
if (zero) {
internal_ = &bc.get(location, block_cache::GF_ZERO | block_cache::GF_CAN_BLOCK);
internal_ = &bc.get(location, block_cache::GF_ZERO | block_cache::GF_CAN_BLOCK, v);
dirty_ = true;
buffer_.set_data(internal_->get_data());
} else {
internal_ = &bc.get(location, block_cache::GF_CAN_BLOCK);
buffer_.set_data(internal_->get_data());
validator_->check(buffer_, internal_->get_index());
internal_ = &bc.get(location, block_cache::GF_CAN_BLOCK, v);
}
}
@ -140,8 +135,6 @@ namespace persistent_data {
void
block_manager<BlockSize>::block::unlock()
{
if (dirty_)
validator_->prepare(buffer_, internal_->get_index());
bc_.put(*internal_, dirty_ ? block_cache::PF_DIRTY : 0);
unlocked_ = true;
}
@ -162,17 +155,17 @@ namespace persistent_data {
}
template <uint32_t BlockSize>
buffer<BlockSize> const &
block_manager<BlockSize>::block::get_buffer() const
void const *
block_manager<BlockSize>::block::get_data() const
{
return buffer_;
return internal_->get_data();
}
template <uint32_t BlockSize>
buffer<BlockSize> &
block_manager<BlockSize>::block::get_buffer()
void *
block_manager<BlockSize>::block::get_data()
{
return buffer_;
return internal_->get_data();
}
template <uint32_t BlockSize>
@ -183,25 +176,6 @@ namespace persistent_data {
dirty_ = true;
}
template <uint32_t BlockSize>
void
block_manager<BlockSize>::block::change_validator(typename block_manager<BlockSize>::validator::ptr v,
bool check)
{
check_not_unlocked();
if (v.get() != validator_.get()) {
if (dirty_)
// It may have already happened, by calling
// this we ensure we're consistent.
validator_->prepare(*internal_->get_data(), internal_->get_index());
validator_ = v;
if (check)
validator_->check(*internal_->get_data(), internal_->get_index());
}
}
template <uint32_t BlockSize>
void
block_manager<BlockSize>::block::check_not_unlocked() const
@ -268,10 +242,10 @@ namespace persistent_data {
}
template <uint32_t BlockSize>
buffer<BlockSize> const &
void const *
block_manager<BlockSize>::read_ref::data() const
{
return block_->get_buffer();
return block_->get_data();
}
//--------------------------------
@ -285,10 +259,10 @@ namespace persistent_data {
}
template <uint32_t BlockSize>
buffer<BlockSize> &
void *
block_manager<BlockSize>::write_ref::data()
{
return read_ref::block_->get_buffer();
return read_ref::block_->get_data();
}
//----------------------------------------------------------------
@ -299,14 +273,14 @@ namespace persistent_data {
unsigned max_concurrent_blocks,
mode m)
: fd_(open_block_file(path, nr_blocks * BlockSize, m == READ_WRITE)),
bc_(fd_, BlockSize >> SECTOR_SHIFT, nr_blocks, 1024u * 1024u * 4)
bc_(fd_, BlockSize >> SECTOR_SHIFT, nr_blocks, 1024u * 1024u * 256)
{
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::read_ref
block_manager<BlockSize>::read_lock(block_address location,
typename block_manager<BlockSize>::validator::ptr v) const
typename bcache::validator::ptr v) const
{
typename block::ptr b(new block(bc_, location, BT_NORMAL, v, false));
return read_ref(*this, b);
@ -315,7 +289,7 @@ namespace persistent_data {
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::write_lock(block_address location,
typename block_manager<BlockSize>::validator::ptr v)
typename bcache::validator::ptr v)
{
typename block::ptr b(new block(bc_, location, BT_NORMAL, v, false));
return write_ref(*this, b);
@ -324,7 +298,7 @@ namespace persistent_data {
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::write_lock_zero(block_address location,
typename block_manager<BlockSize>::validator::ptr v)
typename bcache::validator::ptr v)
{
typename block::ptr b(new block(bc_, location, BT_NORMAL, v, true));
return write_ref(*this, b);
@ -333,7 +307,7 @@ namespace persistent_data {
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::superblock(block_address location,
typename block_manager<BlockSize>::validator::ptr v)
typename bcache::validator::ptr v)
{
typename block::ptr b(new block(bc_, location, BT_SUPERBLOCK, v, false));
return write_ref(*this, b);
@ -342,7 +316,7 @@ namespace persistent_data {
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::superblock_zero(block_address location,
typename block_manager<BlockSize>::validator::ptr v)
typename bcache::validator::ptr v)
{
typename block::ptr b(new block(bc_, location, BT_SUPERBLOCK, v, true));
return write_ref(*this, b);

12
persistent-data/data-structures/array.h
View File

@ -31,9 +31,9 @@ namespace persistent_data {
namespace array_detail {
uint32_t const ARRAY_CSUM_XOR = 595846735;
struct array_block_validator : public block_manager<>::validator {
virtual void check(buffer<> const &b, block_address location) const {
array_block_disk const *data = reinterpret_cast<array_block_disk const *>(b.raw());
struct array_block_validator : public bcache::validator {
virtual void check(void const *raw, block_address location) const {
array_block_disk const *data = reinterpret_cast<array_block_disk const *>(raw);
crc32c sum(ARRAY_CSUM_XOR);
sum.append(&data->max_entries, MD_BLOCK_SIZE - sizeof(uint32_t));
if (sum.get_sum() != to_cpu<uint32_t>(data->csum))
@ -43,8 +43,8 @@ namespace persistent_data {
throw checksum_error("bad block nr in array block");
}
virtual void prepare(buffer<> &b, block_address location) const {
array_block_disk *data = reinterpret_cast<array_block_disk *>(b.raw());
virtual void prepare(void *raw, block_address location) const {
array_block_disk *data = reinterpret_cast<array_block_disk *>(raw);
data->blocknr = to_disk<base::le64, uint64_t>(location);
crc32c sum(ARRAY_CSUM_XOR);
@ -432,7 +432,7 @@ namespace persistent_data {
block_ref_counter block_rc_;
btree<1, block_traits> block_tree_;
typename ValueTraits::ref_counter rc_;
block_manager<>::validator::ptr validator_;
bcache::validator::ptr validator_;
};
}

4
persistent-data/data-structures/array_block.h
View File

@ -163,11 +163,11 @@ namespace persistent_data {
}
array_block_disk *get_header() {
return reinterpret_cast<array_block_disk *>(ref_.data().raw());
return reinterpret_cast<array_block_disk *>(ref_.data());
}
array_block_disk const *get_header() const {
return reinterpret_cast<array_block_disk const *>(ref_.data().raw());
return reinterpret_cast<array_block_disk const *>(ref_.data());
}
disk_type &element_at(unsigned int index) {

15
persistent-data/data-structures/btree.h
View File

@ -184,7 +184,7 @@ namespace persistent_data {
return node_ref<ValueTraits>(
b.get_location(),
reinterpret_cast<disk_node *>(
const_cast<unsigned char *>(b.data().raw())));
const_cast<void *>(b.data())));
}
template <typename ValueTraits>
@ -193,14 +193,13 @@ namespace persistent_data {
{
return node_ref<ValueTraits>(
b.get_location(),
reinterpret_cast<disk_node *>(
const_cast<unsigned char *>(b.data().raw())));
reinterpret_cast<disk_node *>(b.data()));
}
class ro_spine : private boost::noncopyable {
public:
ro_spine(transaction_manager::ptr tm,
block_manager<>::validator::ptr v)
bcache::validator::ptr v)
: tm_(tm),
validator_(v) {
}
@ -214,7 +213,7 @@ namespace persistent_data {
private:
transaction_manager::ptr tm_;
block_manager<>::validator::ptr validator_;
bcache::validator::ptr validator_;
std::list<block_manager<>::read_ref> spine_;
};
@ -225,7 +224,7 @@ namespace persistent_data {
typedef boost::optional<block_address> maybe_block;
shadow_spine(transaction_manager::ptr tm,
block_manager<>::validator::ptr v)
bcache::validator::ptr v)
: tm_(tm),
validator_(v) {
@ -278,7 +277,7 @@ namespace persistent_data {
private:
transaction_manager::ptr tm_;
block_manager<>::validator::ptr validator_;
bcache::validator::ptr validator_;
std::list<block_manager<>::write_ref> spine_;
maybe_block root_;
};
@ -440,7 +439,7 @@ namespace persistent_data {
block_address root_;
block_ref_counter internal_rc_;
typename ValueTraits::ref_counter rc_;
typename block_manager<>::validator::ptr validator_;
typename bcache::validator::ptr validator_;
};
};

10
persistent-data/data-structures/btree.tcc
View File

@ -32,9 +32,9 @@ namespace {
using namespace btree_detail;
using namespace std;
struct btree_node_validator : public block_manager<>::validator {
virtual void check(buffer<> const &b, block_address location) const {
disk_node const *data = reinterpret_cast<disk_node const *>(b.raw());
struct btree_node_validator : public bcache::validator {
virtual void check(void const *raw, block_address location) const {
disk_node const *data = reinterpret_cast<disk_node const *>(raw);
node_header const *n = &data->header;
crc32c sum(BTREE_CSUM_XOR);
sum.append(&n->flags, MD_BLOCK_SIZE - sizeof(uint32_t));
@ -45,8 +45,8 @@ namespace {
throw checksum_error("bad block nr in btree node");
}
virtual void prepare(buffer<> &b, block_address location) const {
disk_node *data = reinterpret_cast<disk_node *>(b.raw());
virtual void prepare(void *raw, block_address location) const {
disk_node *data = reinterpret_cast<disk_node *>(raw);
node_header *n = &data->header;
n->blocknr = to_disk<base::le64, uint64_t>(location);

38
persistent-data/space-maps/disk.cc
View File

@ -37,9 +37,9 @@ using namespace sm_disk_detail;
namespace {
uint64_t const BITMAP_CSUM_XOR = 240779;
struct bitmap_block_validator : public block_manager<>::validator {
virtual void check(buffer<> const &b, block_address location) const {
bitmap_header const *data = reinterpret_cast<bitmap_header const *>(b.raw());
struct bitmap_block_validator : public bcache::validator {
virtual void check(void const *raw, block_address location) const {
bitmap_header const *data = reinterpret_cast<bitmap_header const *>(raw);
crc32c sum(BITMAP_CSUM_XOR);
sum.append(&data->not_used, MD_BLOCK_SIZE - sizeof(uint32_t));
if (sum.get_sum() != to_cpu<uint32_t>(data->csum))
@ -49,8 +49,8 @@ namespace {
throw checksum_error("bad block nr in space map bitmap");
}
virtual void prepare(buffer<> &b, block_address location) const {
bitmap_header *data = reinterpret_cast<bitmap_header *>(b.raw());
virtual void prepare(void *raw, block_address location) const {
bitmap_header *data = reinterpret_cast<bitmap_header *>(raw);
data->blocknr = to_disk<base::le64, uint64_t>(location);
crc32c sum(BITMAP_CSUM_XOR);
@ -64,9 +64,9 @@ namespace {
uint64_t const INDEX_CSUM_XOR = 160478;
// FIXME: factor out the common code in these validators
struct index_block_validator : public block_manager<>::validator {
virtual void check(buffer<> const &b, block_address location) const {
metadata_index const *mi = reinterpret_cast<metadata_index const *>(b.raw());
struct index_block_validator : public bcache::validator {
virtual void check(void const *raw, block_address location) const {
metadata_index const *mi = reinterpret_cast<metadata_index const *>(raw);
std::cerr << "check mi = " << mi << "\n";
crc32c sum(INDEX_CSUM_XOR);
sum.append(&mi->padding_, MD_BLOCK_SIZE - sizeof(uint32_t));
@ -77,8 +77,8 @@ namespace {
throw checksum_error("bad block nr in metadata index block");
}
virtual void prepare(buffer<> &b, block_address location) const {
metadata_index *mi = reinterpret_cast<metadata_index *>(b.raw());
virtual void prepare(void *raw, block_address location) const {
metadata_index *mi = reinterpret_cast<metadata_index *>(raw);
std::cerr << "prepare mi = " << mi << "\n";
mi->blocknr_ = to_disk<base::le64, uint64_t>(location);
@ -88,9 +88,9 @@ namespace {
}
};
block_manager<>::validator::ptr
bcache::validator::ptr
index_validator() {
return block_manager<>::validator::ptr(new index_block_validator());
return bcache::validator::ptr(new index_block_validator());
}
//--------------------------------
@ -102,7 +102,7 @@ namespace {
bitmap(transaction_manager::ptr tm,
index_entry const &ie,
block_manager<>::validator::ptr v)
bcache::validator::ptr v)
: tm_(tm),
validator_(v),
ie_(ie) {
@ -174,17 +174,17 @@ namespace {
private:
void *bitmap_data(transaction_manager::write_ref &wr) {
bitmap_header *h = reinterpret_cast<bitmap_header *>(&wr.data()[0]);
bitmap_header *h = reinterpret_cast<bitmap_header *>(wr.data());
return h + 1;
}
void const *bitmap_data(transaction_manager::read_ref &rr) const {
bitmap_header const *h = reinterpret_cast<bitmap_header const *>(&rr.data()[0]);
bitmap_header const *h = reinterpret_cast<bitmap_header const *>(rr.data());
return h + 1;
}
transaction_manager::ptr tm_;
block_manager<>::validator::ptr validator_;
bcache::validator::ptr validator_;
index_entry ie_;
};
@ -504,7 +504,7 @@ namespace {
}
transaction_manager::ptr tm_;
block_manager<>::validator::ptr bitmap_validator_;
bcache::validator::ptr bitmap_validator_;
index_store::ptr indexes_;
block_address nr_blocks_;
block_address nr_allocated_;
@ -632,7 +632,7 @@ namespace {
tm_->shadow(bitmap_root_, index_validator());
bitmap_root_ = p.first.get_location();
metadata_index *mdi = reinterpret_cast<metadata_index *>(p.first.data().raw());
metadata_index *mdi = reinterpret_cast<metadata_index *>(p.first.data());
for (unsigned i = 0; i < entries_.size(); i++)
index_entry_traits::pack(entries_[i], mdi->index[i]);
@ -665,7 +665,7 @@ namespace {
block_manager<>::read_ref rr =
tm_->read_lock(bitmap_root_, index_validator());
metadata_index const *mdi = reinterpret_cast<metadata_index const *>(&rr.data());
metadata_index const *mdi = reinterpret_cast<metadata_index const *>(rr.data());
for (unsigned i = 0; i < entries_.size(); i++)
index_entry_traits::unpack(*(mdi->index + i), entries_[i]);
}

2
persistent-data/transaction_manager.cc
View File

@ -72,7 +72,7 @@ transaction_manager::shadow(block_address orig, validator v)
throw runtime_error("transaction_manager::shadow() couldn't allocate new block");
write_ref dest = bm_->write_lock_zero(*mb, v);
::memcpy(dest.data().raw(), src.data().raw(), MD_BLOCK_SIZE); // FIXME: use buffer copy method
::memcpy(dest.data(), src.data(), MD_BLOCK_SIZE);
sm_->dec(orig);
add_shadow(dest.get_location());

2
persistent-data/transaction_manager.h
View File

@ -33,7 +33,7 @@ namespace persistent_data {
typedef boost::shared_ptr<transaction_manager> ptr;
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager<>::validator::ptr validator;
typedef bcache::validator::ptr validator;
// If the space map is persistent, then the caller should
// hold onto a reference and remember to call sm_->commit()