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

[block_manager] Hard code block size to 4k. 

We're never going to use anything other than 4k, and by hard coding it we
avoid making block_manager a template.
This commit is contained in:
Joe Thornber 2020-04-30 14:30:01 +01:00
parent 3e5de399a7
commit e801cc607b
57 changed files with 390 additions and 448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.in
View File

@ -76,6 +76,7 @@ SOURCE=\
era/writeset_tree.cc \
era/xml_format.cc \
main.cc \
persistent-data/block.cc \
persistent-data/checksum.cc \
persistent-data/data-structures/bitset.cc \
persistent-data/data-structures/bloom_filter.cc \

4
block-cache/block_cache.cc
View File

@ -19,10 +19,6 @@ using namespace file_utils;
//----------------------------------------------------------------
// FIXME: get from linux headers
#define SECTOR_SHIFT 9
#define PAGE_SIZE 4096
#define MIN_BLOCKS 16
#define WRITEBACK_LOW_THRESHOLD_PERCENT 33
#define WRITEBACK_HIGH_THRESHOLD_PERCENT 66

1
block-cache/block_cache.h
View File

@ -3,6 +3,7 @@
#include "base/container_of.h"
#include "base/file_utils.h"
#include "block-cache/io_engine.h"
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/set.hpp>

4
caching/cache_check.cc
View File

@ -204,7 +204,7 @@ namespace {
}
void clear_needs_check(string const &path) {
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(path, block_manager::READ_WRITE);
superblock sb = read_superblock(bm);
sb.flags.clear_flag(superblock_flags::NEEDS_CHECK);
@ -223,7 +223,7 @@ namespace {
return FATAL;
}
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(path, block_manager::READ_ONLY);
superblock_reporter sb_rep(out);
mapping_reporter mapping_rep(out);

2
caching/cache_dump.cc
View File

@ -35,7 +35,7 @@ namespace {
int dump(string const &dev, string const &output, flags const &fs) {
try {
block_manager<>::ptr bm = open_bm(dev, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(dev, block_manager::READ_ONLY);
metadata::ptr md(new metadata(bm));
if (want_stdout(output)) {

4
caching/cache_repair.cc
View File

@ -19,12 +19,12 @@ using namespace caching;
namespace {
metadata::ptr open_metadata_for_read(string const &path) {
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(path, block_manager::READ_ONLY);
return metadata::ptr(new metadata(bm));
}
emitter::ptr output_emitter(string const &path) {
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(path, block_manager::READ_WRITE);
metadata::ptr md(new metadata(bm, metadata::CREATE));
return create_restore_emitter(md, true);
}

2
caching/cache_restore.cc
View File

@ -60,7 +60,7 @@ namespace {
bool metadata_touched = false;
try {
block_manager<>::ptr bm = open_bm(*fs.output, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(*fs.output, block_manager::READ_WRITE);
check_file_exists(*fs.input);
ifstream in(fs.input->c_str(), ifstream::in);

2
caching/cache_writeback.cc
View File

@ -296,7 +296,7 @@ namespace {
}
int writeback_(flags const &f) {
block_manager<>::ptr bm = open_bm(*f.metadata_dev, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(*f.metadata_dev, block_manager::READ_WRITE);
metadata md(bm);
// FIXME: we're going to have to copy runs to get the through put with small block sizes

10
caching/metadata.cc
View File

@ -10,7 +10,7 @@ namespace pd = persistent_data;
namespace {
// FIXME: duplication
transaction_manager::ptr
open_tm(block_manager<>::ptr bm) {
open_tm(block_manager::ptr bm) {
auto nr_blocks = bm->get_nr_blocks();
if (!nr_blocks)
throw runtime_error("Metadata is not large enough for superblock.");
@ -33,7 +33,7 @@ namespace {
//----------------------------------------------------------------
metadata::metadata(block_manager<>::ptr bm, open_type ot, unsigned metadata_version)
metadata::metadata(block_manager::ptr bm, open_type ot, unsigned metadata_version)
{
switch (ot) {
case CREATE:
@ -45,7 +45,7 @@ metadata::metadata(block_manager<>::ptr bm, open_type ot, unsigned metadata_vers
}
}
metadata::metadata(block_manager<>::ptr bm)
metadata::metadata(block_manager::ptr bm)
{
open_metadata(bm);
}
@ -69,7 +69,7 @@ metadata::setup_hint_array(size_t width)
}
void
metadata::create_metadata(block_manager<>::ptr bm, unsigned metadata_version)
metadata::create_metadata(block_manager::ptr bm, unsigned metadata_version)
{
tm_ = open_tm(bm);
@ -90,7 +90,7 @@ metadata::create_metadata(block_manager<>::ptr bm, unsigned metadata_version)
}
void
metadata::open_metadata(block_manager<>::ptr bm)
metadata::open_metadata(block_manager::ptr bm)
{
tm_ = open_tm(bm);
sb_ = read_superblock(tm_->get_bm());

12
caching/metadata.h
View File

@ -22,12 +22,12 @@ namespace caching {
CREATE
};
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
typedef boost::shared_ptr<metadata> ptr;
metadata(block_manager<>::ptr bm, open_type ot, unsigned metadata_version = 2); // Create only
metadata(block_manager<>::ptr bm);
metadata(block_manager::ptr bm, open_type ot, unsigned metadata_version = 2); // Create only
metadata(block_manager::ptr bm);
void commit(bool clean_shutdown = true);
void setup_hint_array(size_t width);
@ -45,8 +45,8 @@ namespace caching {
private:
void init_superblock();
void create_metadata(block_manager<>::ptr bm, unsigned metadata_version);
void open_metadata(block_manager<>::ptr bm);
void create_metadata(block_manager::ptr bm, unsigned metadata_version);
void open_metadata(block_manager::ptr bm);
void commit_space_map();
void commit_mappings();

10
caching/superblock.cc
View File

@ -325,11 +325,11 @@ namespace validator {
//--------------------------------
superblock
caching::read_superblock(block_manager<>::ptr bm, block_address location)
caching::read_superblock(block_manager::ptr bm, block_address location)
{
using namespace validator;
superblock sb;
block_manager<>::read_ref r = bm->read_lock(location, mk_v());
block_manager::read_ref r = bm->read_lock(location, mk_v());
superblock_disk const *sbd = reinterpret_cast<superblock_disk const *>(r.data());
superblock_traits::unpack(*sbd, sb);
@ -337,10 +337,10 @@ caching::read_superblock(block_manager<>::ptr bm, block_address location)
}
void
caching::write_superblock(block_manager<>::ptr bm, superblock const &sb, block_address location)
caching::write_superblock(block_manager::ptr bm, superblock const &sb, block_address location)
{
using namespace validator;
block_manager<>::write_ref w = bm->superblock_zero(location, mk_v());
block_manager::write_ref w = bm->superblock_zero(location, mk_v());
superblock_traits::pack(sb, *reinterpret_cast<superblock_disk *>(w.data()));
}
@ -415,7 +415,7 @@ caching::check_superblock(superblock const &sb,
}
void
caching::check_superblock(persistent_data::block_manager<>::ptr bm,
caching::check_superblock(persistent_data::block_manager::ptr bm,
block_address nr_metadata_blocks,
damage_visitor &visitor)
{

6
caching/superblock.h
View File

@ -137,10 +137,10 @@ namespace caching {
bcache::validator::ptr superblock_validator();
superblock read_superblock(persistent_data::block_manager<>::ptr bm,
superblock read_superblock(persistent_data::block_manager::ptr bm,
persistent_data::block_address location = SUPERBLOCK_LOCATION);
void write_superblock(persistent_data::block_manager<>::ptr bm,
void write_superblock(persistent_data::block_manager::ptr bm,
superblock const &sb,
persistent_data::block_address location = SUPERBLOCK_LOCATION);
@ -148,7 +148,7 @@ namespace caching {
persistent_data::block_address nr_metadata_blocks,
superblock_damage::damage_visitor &visitor);
void check_superblock(persistent_data::block_manager<>::ptr bm,
void check_superblock(persistent_data::block_manager::ptr bm,
persistent_data::block_address nr_metadata_blocks,
superblock_damage::damage_visitor &visitor);
}

2
era/era_check.cc
View File

@ -197,7 +197,7 @@ namespace {
return FATAL;
}
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(path, block_manager::READ_ONLY);
superblock_reporter sb_rep(out);

2
era/era_dump.cc
View File

@ -38,7 +38,7 @@ namespace {
int dump(string const &dev, string const &output, flags const &fs) {
try {
block_manager<>::ptr bm = open_bm(dev, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(dev, block_manager::READ_ONLY);
metadata::ptr md(new metadata(bm, metadata::OPEN));
if (want_stdout(output)) {

2
era/era_invalidate.cc
View File

@ -152,7 +152,7 @@ namespace {
int invalidate(string const &dev, string const &output, flags const &fs) {
try {
set<uint32_t> blocks;
block_manager<>::ptr bm = open_bm(dev, block_manager<>::READ_ONLY, !fs.metadata_snapshot_);
block_manager::ptr bm = open_bm(dev, block_manager::READ_ONLY, !fs.metadata_snapshot_);
if (fs.metadata_snapshot_) {
superblock sb = read_superblock(bm);

2
era/era_restore.cc
View File

@ -36,7 +36,7 @@ namespace {
int restore(flags const &fs, bool quiet) {
bool metadata_touched = false;
try {
block_manager<>::ptr bm = open_bm(*fs.output, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(*fs.output, block_manager::READ_WRITE);
file_utils::check_file_exists(*fs.output);
metadata_touched = true;
metadata::ptr md(new metadata(bm, metadata::CREATE));

10
era/metadata.cc
View File

@ -8,7 +8,7 @@ using namespace era;
namespace {
// FIXME: duplication
transaction_manager::ptr
open_tm(block_manager<>::ptr bm) {
open_tm(block_manager::ptr bm) {
auto nr_blocks = bm->get_nr_blocks();
if (!nr_blocks)
throw runtime_error("Metadata is not large enough for superblock.");
@ -29,7 +29,7 @@ namespace {
}
}
metadata::metadata(block_manager<>::ptr bm, open_type ot)
metadata::metadata(block_manager::ptr bm, open_type ot)
{
switch (ot) {
case CREATE:
@ -42,13 +42,13 @@ metadata::metadata(block_manager<>::ptr bm, open_type ot)
}
}
metadata::metadata(block_manager<>::ptr bm, block_address metadata_snap)
metadata::metadata(block_manager::ptr bm, block_address metadata_snap)
{
open_metadata(bm);
}
void
metadata::create_metadata(block_manager<>::ptr bm)
metadata::create_metadata(block_manager::ptr bm)
{
tm_ = open_tm(bm);
@ -63,7 +63,7 @@ metadata::create_metadata(block_manager<>::ptr bm)
}
void
metadata::open_metadata(block_manager<>::ptr bm, block_address loc)
metadata::open_metadata(block_manager::ptr bm, block_address loc)
{
tm_ = open_tm(bm);
sb_ = read_superblock(tm_->get_bm(), loc);

12
era/metadata.h
View File

@ -23,12 +23,12 @@ namespace era {
OPEN
};
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
typedef boost::shared_ptr<metadata> ptr;
metadata(block_manager<>::ptr bm, open_type ot);
metadata(block_manager<>::ptr bm, block_address metadata_snap);
metadata(block_manager::ptr bm, open_type ot);
metadata(block_manager::ptr bm, block_address metadata_snap);
void commit();
typedef persistent_data::transaction_manager tm;
@ -39,8 +39,8 @@ namespace era {
era_array::ptr era_array_;
private:
void create_metadata(block_manager<>::ptr bm);
void open_metadata(block_manager<>::ptr bm,
void create_metadata(block_manager::ptr bm);
void open_metadata(block_manager::ptr bm,
block_address loc = SUPERBLOCK_LOCATION);
void commit_space_map();

10
era/superblock.cc
View File

@ -245,10 +245,10 @@ namespace era_validator {
//----------------------------------------------------------------
superblock
era::read_superblock(block_manager<>::ptr bm, block_address location)
era::read_superblock(block_manager::ptr bm, block_address location)
{
superblock sb;
block_manager<>::read_ref r = bm->read_lock(location, era_validator::mk_v());
block_manager::read_ref r = bm->read_lock(location, era_validator::mk_v());
superblock_disk const *sbd = reinterpret_cast<superblock_disk const *>(r.data());
superblock_traits::unpack(*sbd, sb);
@ -256,9 +256,9 @@ era::read_superblock(block_manager<>::ptr bm, block_address location)
}
void
era::write_superblock(block_manager<>::ptr bm, superblock const &sb, block_address location)
era::write_superblock(block_manager::ptr bm, superblock const &sb, block_address location)
{
block_manager<>::write_ref w = bm->superblock_zero(location, era_validator::mk_v());
block_manager::write_ref w = bm->superblock_zero(location, era_validator::mk_v());
superblock_traits::pack(sb, *reinterpret_cast<superblock_disk *>(w.data()));
}
@ -322,7 +322,7 @@ era::check_superblock(superblock const &sb,
}
void
era::check_superblock(persistent_data::block_manager<>::ptr bm,
era::check_superblock(persistent_data::block_manager::ptr bm,
block_address nr_metadata_blocks,
damage_visitor &visitor)
{

6
era/superblock.h
View File

@ -114,10 +114,10 @@ namespace era {
//--------------------------------
superblock read_superblock(persistent_data::block_manager<>::ptr bm,
superblock read_superblock(persistent_data::block_manager::ptr bm,
persistent_data::block_address location = SUPERBLOCK_LOCATION);
void write_superblock(persistent_data::block_manager<>::ptr bm,
void write_superblock(persistent_data::block_manager::ptr bm,
superblock const &sb,
persistent_data::block_address location = SUPERBLOCK_LOCATION);
@ -125,7 +125,7 @@ namespace era {
persistent_data::block_address nr_metadata_blocks,
superblock_damage::damage_visitor &visitor);
void check_superblock(persistent_data::block_manager<>::ptr bm,
void check_superblock(persistent_data::block_manager::ptr bm,
persistent_data::block_address nr_metadata_blocks,
superblock_damage::damage_visitor &visitor);
}

203
persistent-data/block.cc Normal file
View File

@ -0,0 +1,203 @@
// 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/>.
#include "block.h"
#include "base/error_string.h"
#include "base/file_utils.h"
#include "block-cache/io_engine.h"
#include <boost/bind.hpp>
#include <stdexcept>
using namespace persistent_data;
//----------------------------------------------------------------
block_manager::read_ref::read_ref(block_cache::block &b)
: b_(b)
{
}
block_manager::read_ref::read_ref(read_ref const &rhs)
: b_(rhs.b_)
{
b_.get();
}
block_manager::read_ref::~read_ref()
{
b_.put();
}
block_address
block_manager::read_ref::get_location() const
{
return b_.get_index();
}
void const *
block_manager::read_ref::data() const
{
return b_.get_data();
}
//--------------------------------
block_manager::write_ref::write_ref(block_cache::block &b)
: read_ref(b),
ref_count_(NULL)
{
}
block_manager::write_ref::write_ref(block_cache::block &b, unsigned &ref_count)
: read_ref(b),
ref_count_(&ref_count) {
if (*ref_count_)
throw std::runtime_error("superblock already locked");
(*ref_count_)++;
}
block_manager::write_ref::write_ref(write_ref const &rhs)
: read_ref(rhs),
ref_count_(rhs.ref_count_) {
if (ref_count_)
(*ref_count_)++;
}
block_manager::write_ref::~write_ref()
{
if (ref_count_) {
if (!*ref_count_) {
std::cerr << "write_ref ref_count going below zero";
::exit(1);
}
(*ref_count_)--;
}
}
void *
block_manager::write_ref::data()
{
return read_ref::b_.get_data();
}
//----------------------------------------------------------------
uint64_t
block_manager::choose_cache_size(block_address nr_blocks) const
{
uint64_t const DEFAULT_CACHE_SIZE = 1024 * 1024 * 16;
return std::min<uint64_t>(DEFAULT_CACHE_SIZE, MD_BLOCK_SIZE * nr_blocks);
}
block_manager::block_manager(std::string const &path,
block_address nr_blocks,
unsigned max_concurrent_blocks,
mode m,
bool excl)
: fd_(open_or_create_block_file(path, nr_blocks * MD_BLOCK_SIZE, m, excl)),
bc_(fd_, MD_BLOCK_SIZE >> SECTOR_SHIFT, nr_blocks, choose_cache_size(nr_blocks)),
superblock_ref_count_(0)
{
}
file_utils::file_descriptor
block_manager::open_or_create_block_file(std::string const &path, off_t file_size, mode m, bool excl)
{
switch (m) {
case READ_ONLY:
return file_utils::open_block_file(path, file_size, false, excl);
case READ_WRITE:
return file_utils::open_block_file(path, file_size, true, excl);
case CREATE:
return file_utils::create_block_file(path, file_size);
default:
throw std::runtime_error("unsupported mode");
}
}
block_manager::read_ref
block_manager::read_lock(block_address location,
typename bcache::validator::ptr v) const
{
block_cache::block &b = bc_.get(location, 0, v);
return read_ref(b);
}
block_manager::write_ref
block_manager::write_lock(block_address location,
typename bcache::validator::ptr v)
{
block_cache::block &b = bc_.get(location, block_cache::GF_DIRTY, v);
return write_ref(b);
}
block_manager::write_ref
block_manager::write_lock_zero(block_address location,
typename bcache::validator::ptr v)
{
block_cache::block &b = bc_.get(location, block_cache::GF_ZERO, v);
return write_ref(b);
}
block_manager::write_ref
block_manager::superblock(block_address location,
typename bcache::validator::ptr v)
{
if (bc_.get_nr_locked() > 0)
throw std::runtime_error("attempt to lock superblock while other locks are still held");
block_cache::block &b = bc_.get(location, block_cache::GF_DIRTY | block_cache::GF_BARRIER, v);
return write_ref(b, superblock_ref_count_);
}
block_manager::write_ref
block_manager::superblock_zero(block_address location,
typename bcache::validator::ptr v)
{
if (bc_.get_nr_locked() > 0)
throw std::runtime_error("attempt to lock superblock while other locks are still held");
block_cache::block &b = bc_.get(location, block_cache::GF_ZERO | block_cache::GF_BARRIER, v);
return write_ref(b, superblock_ref_count_);
}
block_address
block_manager::get_nr_blocks() const
{
return bc_.get_nr_blocks();
}
void
block_manager::prefetch(block_address b) const
{
bc_.prefetch(b);
}
void
block_manager::flush() const
{
bc_.flush();
}
//----------------------------------------------------------------

5
persistent-data/block.h
View File

@ -38,7 +38,6 @@ namespace persistent_data {
uint32_t const MD_BLOCK_SIZE = 4096;
template <uint32_t BlockSize = MD_BLOCK_SIZE>
class block_manager : private boost::noncopyable {
public:
typedef boost::shared_ptr<block_manager> ptr;
@ -57,7 +56,7 @@ namespace persistent_data {
class read_ref {
public:
static uint32_t const BLOCK_SIZE = BlockSize;
static uint32_t const BLOCK_SIZE = MD_BLOCK_SIZE;
read_ref(block_cache::block &b);
@ -149,8 +148,6 @@ namespace persistent_data {
}
}
#include "block.tcc"
//----------------------------------------------------------------
#endif

224
persistent-data/block.tcc
View File

@ -1,224 +0,0 @@
// 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/>.
#include "block.h"
#include "base/error_string.h"
#include "base/file_utils.h"
#include "block-cache/io_engine.h"
#include <boost/bind.hpp>
#include <stdexcept>
//----------------------------------------------------------------
namespace persistent_data {
template <uint32_t BlockSize>
block_manager<BlockSize>::read_ref::read_ref(block_cache::block &b)
: b_(b)
{
}
template <uint32_t BlockSize>
block_manager<BlockSize>::read_ref::read_ref(read_ref const &rhs)
: b_(rhs.b_)
{
b_.get();
}
template <uint32_t BlockSize>
block_manager<BlockSize>::read_ref::~read_ref()
{
b_.put();
}
template <uint32_t BlockSize>
block_address
block_manager<BlockSize>::read_ref::get_location() const
{
return b_.get_index();
}
template <uint32_t BlockSize>
void const *
block_manager<BlockSize>::read_ref::data() const
{
return b_.get_data();
}
//--------------------------------
template <uint32_t BlockSize>
block_manager<BlockSize>::write_ref::write_ref(block_cache::block &b)
: read_ref(b),
ref_count_(NULL)
{
}
template <uint32_t BlockSize>
block_manager<BlockSize>::write_ref::write_ref(block_cache::block &b, unsigned &ref_count)
: read_ref(b),
ref_count_(&ref_count) {
if (*ref_count_)
throw std::runtime_error("superblock already locked");
(*ref_count_)++;
}
template <uint32_t BlockSize>
block_manager<BlockSize>::write_ref::write_ref(write_ref const &rhs)
: read_ref(rhs),
ref_count_(rhs.ref_count_) {
if (ref_count_)
(*ref_count_)++;
}
template <uint32_t BlockSize>
block_manager<BlockSize>::write_ref::~write_ref()
{
if (ref_count_) {
if (!*ref_count_) {
std::cerr << "write_ref ref_count going below zero";
::exit(1);
}
(*ref_count_)--;
}
}
template <uint32_t BlockSize>
void *
block_manager<BlockSize>::write_ref::data()
{
return read_ref::b_.get_data();
}
//----------------------------------------------------------------
template <uint32_t BlockSize>
uint64_t
block_manager<BlockSize>::choose_cache_size(block_address nr_blocks) const
{
uint64_t const DEFAULT_CACHE_SIZE = 1024 * 1024 * 16;
return std::min<uint64_t>(DEFAULT_CACHE_SIZE, BlockSize * nr_blocks);
}
template <uint32_t BlockSize>
block_manager<BlockSize>::block_manager(std::string const &path,
block_address nr_blocks,
unsigned max_concurrent_blocks,
mode m,
bool excl)
: fd_(open_or_create_block_file(path, nr_blocks * BlockSize, m, excl)),
bc_(fd_, BlockSize >> SECTOR_SHIFT, nr_blocks, choose_cache_size(nr_blocks)),
superblock_ref_count_(0)
{
}
template <uint32_t BlockSize>
file_utils::file_descriptor
block_manager<BlockSize>::open_or_create_block_file(std::string const &path, off_t file_size, mode m, bool excl)
{
switch (m) {
case READ_ONLY:
return file_utils::open_block_file(path, file_size, false, excl);
case READ_WRITE:
return file_utils::open_block_file(path, file_size, true, excl);
case CREATE:
return file_utils::create_block_file(path, file_size);
default:
throw std::runtime_error("unsupported mode");
}
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::read_ref
block_manager<BlockSize>::read_lock(block_address location,
typename bcache::validator::ptr v) const
{
block_cache::block &b = bc_.get(location, 0, v);
return read_ref(b);
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::write_lock(block_address location,
typename bcache::validator::ptr v)
{
block_cache::block &b = bc_.get(location, block_cache::GF_DIRTY, v);
return write_ref(b);
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::write_lock_zero(block_address location,
typename bcache::validator::ptr v)
{
block_cache::block &b = bc_.get(location, block_cache::GF_ZERO, v);
return write_ref(b);
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::superblock(block_address location,
typename bcache::validator::ptr v)
{
if (bc_.get_nr_locked() > 0)
throw std::runtime_error("attempt to lock superblock while other locks are still held");
block_cache::block &b = bc_.get(location, block_cache::GF_DIRTY | block_cache::GF_BARRIER, v);
return write_ref(b, superblock_ref_count_);
}
template <uint32_t BlockSize>
typename block_manager<BlockSize>::write_ref
block_manager<BlockSize>::superblock_zero(block_address location,
typename bcache::validator::ptr v)
{
if (bc_.get_nr_locked() > 0)
throw std::runtime_error("attempt to lock superblock while other locks are still held");
block_cache::block &b = bc_.get(location, block_cache::GF_ZERO | block_cache::GF_BARRIER, v);
return write_ref(b, superblock_ref_count_);
}
template <uint32_t BlockSize>
block_address
block_manager<BlockSize>::get_nr_blocks() const
{
return bc_.get_nr_blocks();
}
template <uint32_t BlockSize>
void
block_manager<BlockSize>::prefetch(block_address b) const
{
bc_.prefetch(b);
}
template <uint32_t BlockSize>
void
block_manager<BlockSize>::flush() const
{
bc_.flush();
}
}
//----------------------------------------------------------------

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

@ -216,11 +216,11 @@ namespace persistent_data {
unsigned entries_per_block_;
};
typedef block_manager<>::write_ref write_ref;
typedef block_manager<>::read_ref read_ref;
typedef block_manager::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef array_block<ValueTraits, block_manager<>::write_ref> wblock;
typedef array_block<ValueTraits, block_manager<>::read_ref> rblock;
typedef array_block<ValueTraits, block_manager::write_ref> wblock;
typedef array_block<ValueTraits, block_manager::read_ref> rblock;
typedef boost::shared_ptr<array<ValueTraits> > ptr;
typedef typename ValueTraits::value_type value_type;

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

@ -152,7 +152,7 @@ namespace persistent_data {
//
template <typename ValueTraits>
node_ref<ValueTraits>
to_node(typename block_manager<>::read_ref &b)
to_node(typename block_manager::read_ref &b)
{
// FIXME: this should return a const read_ref somehow.
return node_ref<ValueTraits>(
@ -163,7 +163,7 @@ namespace persistent_data {
template <typename ValueTraits>
node_ref<ValueTraits>
to_node(typename block_manager<>::write_ref &b)
to_node(typename block_manager::write_ref &b)
{
return node_ref<ValueTraits>(
b.get_location(),
@ -188,7 +188,7 @@ namespace persistent_data {
private:
transaction_manager &tm_;
bcache::validator::ptr validator_;
std::list<block_manager<>::read_ref> spine_;
std::list<block_manager::read_ref> spine_;
};
class shadow_spine : private boost::noncopyable {
@ -252,7 +252,7 @@ namespace persistent_data {
private:
transaction_manager &tm_;
bcache::validator::ptr validator_;
std::list<block_manager<>::write_ref> spine_;
std::list<block_manager::write_ref> spine_;
maybe_block root_;
};
@ -304,8 +304,8 @@ namespace persistent_data {
typedef typename ValueTraits::value_type value_type;
typedef boost::optional<value_type> maybe_value;
typedef boost::optional<std::pair<unsigned, value_type> > maybe_pair;
typedef typename block_manager<>::read_ref read_ref;
typedef typename block_manager<>::write_ref write_ref;
typedef typename block_manager::read_ref read_ref;
typedef typename block_manager::write_ref write_ref;
typedef typename btree_detail::node_ref<ValueTraits> leaf_node;
typedef typename btree_detail::node_ref<block_traits> internal_node;

18
persistent-data/file_utils.cc
View File

@ -19,8 +19,8 @@ using namespace std;
//----------------------------------------------------------------
bool
persistent_data::check_for_xml(block_manager<>::ptr bm) {
block_manager<>::read_ref b = bm->read_lock(0);
persistent_data::check_for_xml(block_manager::ptr bm) {
block_manager::read_ref b = bm->read_lock(0);
const char *data = reinterpret_cast<const char *>(b.data());
return (!strncmp(data, "<superblock", 11) || !strncmp(data, "<?xml", 5)
|| !strncmp(data, "<!DOCTYPE", 9));
@ -39,22 +39,22 @@ persistent_data::get_nr_metadata_blocks(std::string const &path)
return get_nr_blocks(path, MD_BLOCK_SIZE);
}
persistent_data::block_manager<>::ptr
persistent_data::open_bm(std::string const &dev_path, block_manager<>::mode m, bool excl)
persistent_data::block_manager::ptr
persistent_data::open_bm(std::string const &dev_path, block_manager::mode m, bool excl)
{
block_address nr_blocks = get_nr_metadata_blocks(dev_path);
return block_manager<>::ptr(new block_manager<>(dev_path, nr_blocks, 1, m, excl));
return block_manager::ptr(new block_manager(dev_path, nr_blocks, 1, m, excl));
}
block_manager<>::ptr
block_manager::ptr
persistent_data::open_bm(std::string const &path) {
block_address nr_blocks = get_nr_metadata_blocks(path);
block_manager<>::mode m = block_manager<>::READ_ONLY;
return block_manager<>::ptr(new block_manager<>(path, nr_blocks, 1, m));
block_manager::mode m = block_manager::READ_ONLY;
return block_manager::ptr(new block_manager(path, nr_blocks, 1, m));
}
transaction_manager::ptr
persistent_data::open_tm(block_manager<>::ptr bm, block_address superblock_location) {
persistent_data::open_tm(block_manager::ptr bm, block_address superblock_location) {
auto nr_blocks = bm->get_nr_blocks();
if (!nr_blocks)
throw runtime_error("Metadata is not large enough for superblock.");

10
persistent-data/file_utils.h
View File

@ -10,15 +10,15 @@
// FIXME: move to a different unit
namespace persistent_data {
bool check_for_xml(block_manager<>::ptr bm);
bool check_for_xml(block_manager::ptr bm);
persistent_data::block_address get_nr_blocks(std::string const &path, sector_t block_size = MD_BLOCK_SIZE);
block_address get_nr_metadata_blocks(std::string const &path);
block_manager<>::ptr open_bm(std::string const &dev_path,
block_manager<>::mode m, bool excl = true);
block_manager::ptr open_bm(std::string const &dev_path,
block_manager::mode m, bool excl = true);
block_manager<>::ptr open_bm(std::string const &path);
transaction_manager::ptr open_tm(block_manager<>::ptr bm,
block_manager::ptr open_bm(std::string const &path);
transaction_manager::ptr open_tm(block_manager::ptr bm,
block_address superblock_location);
}

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

@ -718,7 +718,7 @@ namespace {
metadata_index_store(transaction_manager &tm)
: tm_(tm) {
block_manager<>::write_ref wr = tm_.new_block(index_validator());
block_manager::write_ref wr = tm_.new_block(index_validator());
bitmap_root_ = wr.get_location();
}
@ -753,7 +753,7 @@ namespace {
}
virtual void commit_ies() {
std::pair<block_manager<>::write_ref, bool> p =
std::pair<block_manager::write_ref, bool> p =
tm_.shadow(bitmap_root_, index_validator());
bitmap_root_ = p.first.get_location();
@ -787,7 +787,7 @@ namespace {
private:
void load_ies() {
block_manager<>::read_ref rr =
block_manager::read_ref rr =
tm_.read_lock(bitmap_root_, index_validator());
metadata_index const *mdi = reinterpret_cast<metadata_index const *>(rr.data());

2
persistent-data/transaction_manager.cc
View File

@ -26,7 +26,7 @@ using namespace std;
//----------------------------------------------------------------
transaction_manager::transaction_manager(block_manager<>::ptr bm,
transaction_manager::transaction_manager(block_manager::ptr bm,
space_map::ptr sm)
: bm_(bm),
sm_(sm)

10
persistent-data/transaction_manager.h
View File

@ -31,15 +31,15 @@ namespace persistent_data {
class transaction_manager : boost::noncopyable {
public:
typedef boost::shared_ptr<transaction_manager> ptr;
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
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()
// and update the superblock before dropping the superblock
// reference.
transaction_manager(block_manager<>::ptr bm,
transaction_manager(block_manager::ptr bm,
space_map::ptr sm);
~transaction_manager();
@ -62,7 +62,7 @@ namespace persistent_data {
sm_ = sm;
}
block_manager<>::ptr get_bm() {
block_manager::ptr get_bm() {
return bm_;
}
@ -76,7 +76,7 @@ namespace persistent_data {
bool is_shadow(block_address b) const;
void wipe_shadow_table();
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
std::set<block_address> shadows_;

8
thin-provisioning/metadata.cc
View File

@ -50,7 +50,7 @@ namespace {
//----------------------------------------------------------------
metadata::metadata(block_manager<>::ptr bm, open_type ot,
metadata::metadata(block_manager::ptr bm, open_type ot,
sector_t data_block_size,
block_address nr_data_blocks)
{
@ -102,7 +102,7 @@ metadata::metadata(block_manager<>::ptr bm, open_type ot,
}
}
metadata::metadata(block_manager<>::ptr bm, bool read_space_maps)
metadata::metadata(block_manager::ptr bm, bool read_space_maps)
{
tm_ = open_tm(bm, SUPERBLOCK_LOCATION);
sb_ = read_superblock(tm_->get_bm(), SUPERBLOCK_LOCATION);
@ -113,7 +113,7 @@ metadata::metadata(block_manager<>::ptr bm, bool read_space_maps)
open_btrees();
}
metadata::metadata(block_manager<>::ptr bm,
metadata::metadata(block_manager::ptr bm,
boost::optional<block_address> metadata_snap)
{
tm_ = open_tm(bm, SUPERBLOCK_LOCATION);
@ -132,7 +132,7 @@ metadata::metadata(block_manager<>::ptr bm,
open_btrees();
}
metadata::metadata(block_manager<>::ptr bm, superblock_detail::superblock const &sb)
metadata::metadata(block_manager::ptr bm, superblock_detail::superblock const &sb)
{
tm_ = open_tm(bm, SUPERBLOCK_LOCATION);
sb_ = sb;

12
thin-provisioning/metadata.h
View File

@ -55,11 +55,11 @@ namespace thin_provisioning {
OPEN
};
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
typedef boost::shared_ptr<metadata> ptr;
metadata(block_manager<>::ptr bm, open_type ot,
metadata(block_manager::ptr bm, open_type ot,
sector_t data_block_size = 128,
block_address nr_data_blocks = 0); // Only used if CREATE
@ -74,12 +74,12 @@ namespace thin_provisioning {
// ii) Read the metadata snap as given in the superblock
// iii) Read the metadata snap given on command line, checking it matches superblock.
//
metadata(block_manager<>::ptr bm, bool read_space_maps = true); // (i)
metadata(block_manager<>::ptr,
metadata(block_manager::ptr bm, bool read_space_maps = true); // (i)
metadata(block_manager::ptr,
boost::optional<block_address> metadata_snap); // (ii) and (iii)
// This is used by repair, when we rebuild the superblock
metadata(block_manager<>::ptr bm, superblock_detail::superblock const &sb);
metadata(block_manager::ptr bm, superblock_detail::superblock const &sb);
void commit();

8
thin-provisioning/metadata_checker.cc
View File

@ -120,7 +120,7 @@ namespace {
//--------------------------------
error_state examine_superblock(block_manager<>::ptr bm,
error_state examine_superblock(block_manager::ptr bm,
nested_output &out) {
out << "examining superblock" << end_message();
nested_output::nest _ = out.push();
@ -240,7 +240,7 @@ namespace {
class base_metadata_checker : public metadata_checker {
public:
base_metadata_checker(block_manager<>::ptr bm,
base_metadata_checker(block_manager::ptr bm,
check_options check_opts,
output_options output_opts)
: bm_(bm),
@ -322,7 +322,7 @@ namespace {
return err;
}
block_manager<>::ptr bm_;
block_manager::ptr bm_;
check_options options_;
nested_output out_;
nested_output info_out_;
@ -351,7 +351,7 @@ void check_options::set_override_mapping_root(block_address b) {
}
metadata_checker::ptr
thin_provisioning::create_base_checker(block_manager<>::ptr bm,
thin_provisioning::create_base_checker(block_manager::ptr bm,
check_options const &check_opts,
output_options output_opts)
{

2
thin-provisioning/metadata_checker.h
View File

@ -64,7 +64,7 @@ namespace thin_provisioning {
};
metadata_checker::ptr
create_base_checker(persistent_data::block_manager<>::ptr bm,
create_base_checker(persistent_data::block_manager::ptr bm,
check_options const &check_opts,
output_options output_opts);
}

18
thin-provisioning/metadata_dumper.cc
View File

@ -276,7 +276,7 @@ namespace {
class gatherer {
public:
gatherer(block_manager<> &bm)
gatherer(block_manager &bm)
: bm_(bm),
referenced_(bm.get_nr_blocks(), false),
examined_(bm.get_nr_blocks(), false) {
@ -471,7 +471,7 @@ namespace {
}
}
node_info get_internal_info(block_manager<>::read_ref &rr) {
node_info get_internal_info(block_manager::read_ref &rr) {
node_info info;
info.b = rr.get_location();
@ -520,7 +520,7 @@ namespace {
return info;
}
node_info get_leaf_info(block_manager<>::read_ref &rr, node_header const &hdr) {
node_info get_leaf_info(block_manager::read_ref &rr, node_header const &hdr) {
node_info info;
info.b = rr.get_location();
@ -631,7 +631,7 @@ namespace {
return optional<node_info>(it->second);
}
block_manager<> &bm_;
block_manager &bm_;
vector<bool> referenced_;
vector<bool> examined_;
map<block_address, node_info> infos_;
@ -778,7 +778,7 @@ namespace {
}
void
emit_trees_(block_manager<>::ptr bm, superblock_detail::superblock const &sb,
emit_trees_(block_manager::ptr bm, superblock_detail::superblock const &sb,
emitter::ptr e, override_options const &ropts)
{
metadata md(bm, sb);
@ -805,7 +805,7 @@ namespace {
}
void
find_better_roots_(block_manager<>::ptr bm, superblock_detail::superblock &sb)
find_better_roots_(block_manager::ptr bm, superblock_detail::superblock &sb)
{
// We assume the superblock is wrong, and find the best roots
// for ourselves. We've had a few cases where people have
@ -847,7 +847,7 @@ namespace {
}
optional<superblock_detail::superblock>
maybe_read_superblock(block_manager<>::ptr bm)
maybe_read_superblock(block_manager::ptr bm)
{
try {
auto sb = read_superblock(bm);
@ -859,7 +859,7 @@ namespace {
}
void
metadata_repair_(block_manager<>::ptr bm, emitter::ptr e, override_options const &opts)
metadata_repair_(block_manager::ptr bm, emitter::ptr e, override_options const &opts)
{
auto msb = maybe_read_superblock(bm);
if (!msb)
@ -902,7 +902,7 @@ thin_provisioning::metadata_dump(metadata::ptr md, emitter::ptr e, dump_options
}
void
thin_provisioning::metadata_repair(block_manager<>::ptr bm, emitter::ptr e, override_options const &opts)
thin_provisioning::metadata_repair(block_manager::ptr bm, emitter::ptr e, override_options const &opts)
{
try {
metadata_repair_(bm, e, opts);

2
thin-provisioning/metadata_dumper.h
View File

@ -63,7 +63,7 @@ namespace thin_provisioning {
// We have to provide a different interface for repairing, since
// the superblock itself may be corrupt, so we wont be able
// to create the metadata object.
void metadata_repair(block_manager<>::ptr bm, emitter::ptr e, override_options const &opts);
void metadata_repair(block_manager::ptr bm, emitter::ptr e, override_options const &opts);
// Only used by ll_restore, so we leave the repair arg
void metadata_dump_subtree(metadata::ptr md, emitter::ptr e, bool repair, uint64_t subtree_root);

16
thin-provisioning/superblock.cc
View File

@ -159,41 +159,41 @@ namespace thin_provisioning {
}
}
superblock_detail::superblock read_superblock(block_manager<> const &bm, block_address location)
superblock_detail::superblock read_superblock(block_manager const &bm, block_address location)
{
using namespace superblock_detail;
superblock sb;
block_manager<>::read_ref r = bm.read_lock(location, superblock_validator());
block_manager::read_ref r = bm.read_lock(location, superblock_validator());
superblock_disk const *sbd = reinterpret_cast<superblock_disk const *>(r.data());
superblock_traits::unpack(*sbd, sb);
return sb;
}
superblock_detail::superblock read_superblock(block_manager<>::ptr bm, block_address location)
superblock_detail::superblock read_superblock(block_manager::ptr bm, block_address location)
{
return read_superblock(*bm, location);
}
superblock_detail::superblock read_superblock(block_manager<>::ptr bm)
superblock_detail::superblock read_superblock(block_manager::ptr bm)
{
return read_superblock(bm, SUPERBLOCK_LOCATION);
}
superblock_detail::superblock read_superblock(block_manager<> const &bm)
superblock_detail::superblock read_superblock(block_manager const &bm)
{
return read_superblock(bm, SUPERBLOCK_LOCATION);
}
void write_superblock(block_manager<>::ptr bm, superblock_detail::superblock const &sb)
void write_superblock(block_manager::ptr bm, superblock_detail::superblock const &sb)
{
block_manager<>::write_ref w = bm->write_lock(SUPERBLOCK_LOCATION, superblock_validator());
block_manager::write_ref w = bm->write_lock(SUPERBLOCK_LOCATION, superblock_validator());
superblock_disk *disk = reinterpret_cast<superblock_disk *>(w.data());
superblock_traits::pack(sb, *disk);
}
void
check_superblock(block_manager<>::ptr bm,
check_superblock(block_manager::ptr bm,
superblock_detail::damage_visitor &visitor) {
using namespace superblock_detail;

10
thin-provisioning/superblock.h
View File

@ -130,15 +130,15 @@ namespace thin_provisioning {
// FIXME: should we put init_superblock in here too?
// FIXME: make the bm const, and pass by reference rather than ptr
superblock_detail::superblock read_superblock(persistent_data::block_manager<> const &bm);
superblock_detail::superblock read_superblock(persistent_data::block_manager<>::ptr bm);
superblock_detail::superblock read_superblock(persistent_data::block_manager<>::ptr bm,
superblock_detail::superblock read_superblock(persistent_data::block_manager const &bm);
superblock_detail::superblock read_superblock(persistent_data::block_manager::ptr bm);
superblock_detail::superblock read_superblock(persistent_data::block_manager::ptr bm,
persistent_data::block_address location);
void write_superblock(persistent_data::block_manager<>::ptr bm,
void write_superblock(persistent_data::block_manager::ptr bm,
superblock_detail::superblock const &sb);
void check_superblock(persistent_data::block_manager<>::ptr bm,
void check_superblock(persistent_data::block_manager::ptr bm,
superblock_detail::damage_visitor &visitor);
}

4
thin-provisioning/thin_check.cc
View File

@ -57,7 +57,7 @@ namespace {
};
void clear_needs_check(string const &path) {
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_WRITE);
block_manager::ptr bm = open_bm(path, block_manager::READ_WRITE);
superblock_detail::superblock sb = read_superblock(bm);
sb.set_needs_check_flag(false);
@ -76,7 +76,7 @@ namespace {
return 1;
}
block_manager<>::ptr bm = open_bm(path);
block_manager::ptr bm = open_bm(path);
output_options output_opts = !fs.quiet ? OUTPUT_NORMAL : OUTPUT_QUIET;
metadata_checker::ptr checker = create_base_checker(bm, fs.check_opts, output_opts);
error_state err = checker->check();

2
thin-provisioning/thin_delta.cc
View File

@ -548,7 +548,7 @@ namespace local {
block_address nr_data_blocks = 0ull;
{
block_manager<>::ptr bm = open_bm(*fs.dev, block_manager<>::READ_ONLY, !fs.use_metadata_snap);
block_manager::ptr bm = open_bm(*fs.dev, block_manager::READ_ONLY, !fs.use_metadata_snap);
metadata::ptr md(fs.use_metadata_snap ? new metadata(bm, fs.metadata_snap) : new metadata(bm));
sb = md->sb_;

4
thin-provisioning/thin_dump.cc
View File

@ -54,7 +54,7 @@ namespace {
};
metadata::ptr open_metadata(string const &path, struct flags &flags) {
block_manager<>::ptr bm = open_bm(path, block_manager<>::READ_ONLY, !flags.use_metadata_snap);
block_manager::ptr bm = open_bm(path, block_manager::READ_ONLY, !flags.use_metadata_snap);
metadata::ptr md(flags.use_metadata_snap ? new metadata(bm, flags.snap_location) : new metadata(bm, false));
return md;
@ -91,7 +91,7 @@ namespace {
emitter::ptr e = create_override_emitter(inner, flags.opts.overrides_);
if (flags.repair) {
auto bm = open_bm(path, block_manager<>::READ_ONLY, true);
auto bm = open_bm(path, block_manager::READ_ONLY, true);
metadata_repair(bm, e, flags.opts.overrides_);
} else {
metadata::ptr md = open_metadata(path, flags);

2
thin-provisioning/thin_ls.cc
View File

@ -319,7 +319,7 @@ namespace {
void ls_(string const &path, ostream &out, struct flags &flags) {
grid_layout grid;
block_manager<>::ptr bm(open_bm(path, block_manager<>::READ_ONLY,
block_manager::ptr bm(open_bm(path, block_manager::READ_ONLY,
!flags.use_metadata_snap));
metadata::ptr md;

4
thin-provisioning/thin_repair.cc
View File

@ -22,13 +22,13 @@ namespace {
bool metadata_touched = false;
try {
// block size gets updated by the restorer
block_manager<>::ptr new_bm = open_bm(new_path, block_manager<>::READ_WRITE);
block_manager::ptr new_bm = open_bm(new_path, block_manager::READ_WRITE);
file_utils::check_file_exists(old_path, false);
metadata_touched = true;
metadata::ptr new_md(new metadata(new_bm, metadata::CREATE, 128, 0));
emitter::ptr inner = create_restore_emitter(new_md);
emitter::ptr e = create_override_emitter(inner, opts);
block_manager<>::ptr old_bm = open_bm(old_path, block_manager<>::READ_ONLY);
block_manager::ptr old_bm = open_bm(old_path, block_manager::READ_ONLY);
metadata_repair(old_bm, e, opts);
} catch (std::exception &e) {

2
thin-provisioning/thin_restore.cc
View File

@ -49,7 +49,7 @@ namespace {
bool metadata_touched = false;
try {
// The block size gets updated by the restorer.
block_manager<>::ptr bm(open_bm(dev, block_manager<>::READ_WRITE));
block_manager::ptr bm(open_bm(dev, block_manager::READ_WRITE));
file_utils::check_file_exists(backup_file);
metadata_touched = true;
metadata::ptr md(new metadata(bm, metadata::CREATE, 128, 0));

2
thin-provisioning/thin_rmap.cc
View File

@ -56,7 +56,7 @@ namespace {
for (it = regions.begin(); it != regions.end(); ++it)
rv.add_data_region(*it);
block_manager<>::ptr bm = open_bm(path);
block_manager::ptr bm = open_bm(path);
transaction_manager::ptr tm =
open_tm(bm, superblock_detail::SUPERBLOCK_LOCATION);

2
thin-provisioning/thin_trim.cc
View File

@ -128,7 +128,7 @@ namespace {
// We can trim any block that has zero count in the data
// space map.
block_manager<>::ptr bm = open_bm(metadata_dev, block_manager<>::READ_ONLY);
block_manager::ptr bm = open_bm(metadata_dev, block_manager::READ_ONLY);
metadata md(bm);
if (!md.data_sm_->get_nr_free()) {

6
unit-tests/array_block_t.cc
View File

@ -36,8 +36,8 @@ namespace {
uint64_t MAX_VALUE = 1000ull;
block_address const NR_BLOCKS = 1024;
typedef bcache::noop_validator noop_validator;
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
// FIXME: lift to utils?
class simple_ref_counter {
@ -86,7 +86,7 @@ namespace {
transaction_manager::ptr
create_tm() {
block_manager<>::ptr bm = create_bm<4096>(NR_BLOCKS);
block_manager::ptr bm = create_bm(NR_BLOCKS);
space_map::ptr sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, sm));
return tm;

4
unit-tests/array_t.cc
View File

@ -37,7 +37,7 @@ namespace {
class ArrayTests : public Test {
public:
ArrayTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@ -78,7 +78,7 @@ namespace {
array64::ptr a_;
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

4
unit-tests/bitset_t.cc
View File

@ -55,7 +55,7 @@ namespace {
class BitsetTests : public Test {
public:
BitsetTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@ -71,7 +71,7 @@ namespace {
}
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

73
unit-tests/block_t.cc
View File

@ -29,7 +29,7 @@ using namespace testing;
namespace {
template <uint32_t BlockSize>
void check_all_bytes(typename block_manager<BlockSize>::read_ref const &rr, int v) {
void check_all_bytes(typename block_manager::read_ref const &rr, int v) {
unsigned char const *data = reinterpret_cast<unsigned char const *>(rr.data());
for (unsigned b = 0; b < BlockSize; b++)
ASSERT_THAT(data[b], Eq(static_cast<unsigned char>(v)));
@ -68,27 +68,27 @@ namespace {
MOCK_CONST_METHOD2(prepare, void(void *, block_address));
};
typedef block_manager<4096> bm4096;
typedef block_manager bm4096;
}
//----------------------------------------------------------------
TEST(BlockTests, bad_path)
{
ASSERT_THROW(bm4096("/bogus/bogus/bogus", 1234, 4, block_manager<>::READ_WRITE),
ASSERT_THROW(bm4096("/bogus/bogus/bogus", 1234, 4, block_manager::READ_WRITE),
runtime_error);
}
TEST(BlockTests, out_of_range_access)
{
bm4096::ptr bm = create_bm<4096>(1024);
bm4096::ptr bm = create_bm(1024);
ASSERT_THROW(bm->read_lock(1024), runtime_error);
}
TEST(BlockTests, read_lock_all_blocks)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++)
bm->read_lock(i);
}
@ -96,7 +96,7 @@ TEST(BlockTests, read_lock_all_blocks)
TEST(BlockTests, write_lock_all_blocks)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++)
bm->write_lock(i);
}
@ -104,7 +104,7 @@ TEST(BlockTests, write_lock_all_blocks)
TEST(BlockTests, writes_persist)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++) {
bm4096::write_ref wr = bm->write_lock(i);
::memset(wr.data(), i, 4096);
@ -118,52 +118,21 @@ TEST(BlockTests, writes_persist)
TEST(BlockTests, write_lock_zero_zeroes)
{
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
check_all_bytes<4096>(bm->write_lock_zero(23), 0);
}
TEST(BlockTests, different_block_sizes)
{
{
bm4096::ptr bm = create_bm<4096>(64);
{
bm4096::write_ref wr = bm->write_lock(0);
memset(wr.data(), 23, 4096);
}
{
bm4096::write_ref wr = bm->write_lock_zero(0);
check_all_bytes<4096>(wr, 0);
}
}
{
block_manager<64 * 1024>::ptr bm = create_bm<64 * 1024>(64);
{
block_manager<64 * 1024>::write_ref wr = bm->write_lock(0);
memset(wr.data(), 72, 64 * 1024);
}
{
block_manager<64 * 1024>::write_ref wr = bm->write_lock_zero(0);
check_all_bytes<64 * 1024>(wr, 0);
}
}
}
TEST(BlockTests, read_validator_works)
{
bcache::validator::ptr v(new zero_validator<4096>());
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
bm->write_lock_zero(0);
bm->read_lock(0, v);
}
TEST(BlockTests, write_validator_works)
{
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
bcache::validator::ptr v(new zero_validator<4096>());
{
@ -177,21 +146,21 @@ TEST(BlockTests, write_validator_works)
TEST(BlockTests, cannot_have_two_superblocks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref superblock = bm->superblock(0);
ASSERT_THROW(bm->superblock(1), runtime_error);
}
TEST(BlockTests, can_have_subsequent_superblocks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{ bm4096::write_ref superblock = bm->superblock(0); }
{ bm4096::write_ref superblock = bm->superblock(0); }
}
TEST(BlockTests, superblocks_can_change_address)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{ bm4096::write_ref superblock = bm->superblock(0); }
{ bm4096::write_ref superblock = bm->superblock(1); }
}
@ -203,7 +172,7 @@ TEST(BlockTests, superblocks_can_change_address)
// correct thing to do is (log the error? put the tm into a 'bad' state?).
TEST(BlockTests, superblock_must_be_last)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{
bm4096::read_ref rr = bm->read_lock(63);
{
@ -214,21 +183,21 @@ TEST(BlockTests, superblock_must_be_last)
TEST(BlockTests, references_can_be_copied)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr1 = bm->write_lock(0);
bm4096::write_ref wr2(wr1);
}
TEST(BlockTests, no_concurrent_write_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr = bm->write_lock(0);
ASSERT_THROW(bm->write_lock(0), runtime_error);
}
TEST(BlockTests, concurrent_read_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::read_ref rr = bm->read_lock(0);
bm->read_lock(0);
}
@ -238,7 +207,7 @@ TEST(BlockTests, concurrent_read_locks)
// think I'm ever going to add the extra checking to the C++ code.
TEST(BlockTests, no_concurrent_read_and_write_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr = bm->write_lock(0);
ASSERT_THROW(bm->read_lock(0), runtime_error);
}
@ -246,14 +215,14 @@ TEST(BlockTests, no_concurrent_read_and_write_locks)
TEST(BlockTests, read_then_write)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm->read_lock(0);
bm->write_lock(0);
}
TEST(BlockTests, write_then_read)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm->write_lock(0);
bm->read_lock(0);
}
@ -264,7 +233,7 @@ namespace {
class ValidatorTests : public Test {
public:
ValidatorTests()
: bm(create_bm<4096>()),
: bm(create_bm()),
vmock(new validator_mock),
vmock2(new validator_mock) {
}

6
unit-tests/btree_counter_t.cc
View File

@ -23,7 +23,7 @@ namespace {
class BTreeCounterTests : public Test {
public:
BTreeCounterTests()
: bm_(create_bm<BLOCK_SIZE>(NR_BLOCKS)),
: bm_(create_bm(NR_BLOCKS)),
sm_(setup_core_map()),
tm_(bm_, sm_) {
}
@ -36,7 +36,7 @@ namespace {
}
with_temp_directory dir_;
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
uint64_traits::ref_counter rc_;
@ -51,7 +51,7 @@ namespace {
}
void commit() {
block_manager<>::write_ref superblock(bm_->superblock(SUPERBLOCK));
block_manager::write_ref superblock(bm_->superblock(SUPERBLOCK));
}
};
}

6
unit-tests/btree_damage_visitor_t.cc
View File

@ -256,7 +256,7 @@ namespace {
class DamageTests : public Test {
public:
DamageTests()
: bm_(create_bm<BLOCK_SIZE>(NR_BLOCKS)),
: bm_(create_bm(NR_BLOCKS)),
sm_(setup_core_map()),
tm_(bm_, sm_) {
}
@ -290,7 +290,7 @@ namespace {
//--------------------------------
with_temp_directory dir_;
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
thing_traits::ref_counter rc_;
@ -308,7 +308,7 @@ namespace {
}
void commit() {
block_manager<>::write_ref superblock(bm_->superblock(SUPERBLOCK));
block_manager::write_ref superblock(bm_->superblock(SUPERBLOCK));
}
virtual void discover_layout() = 0;

4
unit-tests/btree_t.cc
View File

@ -34,7 +34,7 @@ namespace {
class BtreeTests : public Test {
public:
BtreeTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@ -48,7 +48,7 @@ namespace {
}
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

8
unit-tests/space_map_t.cc
View File

@ -36,7 +36,7 @@ namespace {
class SpaceMapTests : public Test {
public:
SpaceMapTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@ -240,7 +240,7 @@ namespace {
}
}
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};
@ -277,8 +277,8 @@ TEST_F(SpaceMapTests, test_sm_metadata)
TEST_F(SpaceMapTests, test_metadata_and_disk)
{
block_manager<>::ptr bm(
new block_manager<>("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager<>::READ_WRITE));
block_manager::ptr bm(
new block_manager("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager::READ_WRITE));
space_map::ptr core_sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, core_sm));
persistent_space_map::ptr metadata_sm = persistent_data::create_metadata_sm(*tm, NR_BLOCKS);

6
unit-tests/test_utils.cc
View File

@ -12,14 +12,14 @@ using namespace test;
//----------------------------------------------------------------
void test::zero_block(block_manager<>::ptr bm, block_address b)
void test::zero_block(block_manager::ptr bm, block_address b)
{
block_manager<>::write_ref wr = bm->write_lock(b);
block_manager::write_ref wr = bm->write_lock(b);
memset(wr.data(), 0, 4096);
}
transaction_manager::ptr
test::open_temporary_tm(block_manager<>::ptr bm)
test::open_temporary_tm(block_manager::ptr bm)
{
space_map::ptr sm(new core_map(bm->get_nr_blocks()));
transaction_manager::ptr tm(new transaction_manager(bm, sm));

13
unit-tests/test_utils.h
View File

@ -28,23 +28,22 @@ namespace test {
unsigned const MAX_HELD_LOCKS = 16;
template <uint32_t BlockSize>
typename block_manager<BlockSize>::ptr
inline block_manager::ptr
create_bm(block_address nr = 1024) {
std::string const path("./test.data");
int r = system("rm -f ./test.data");
if (r < 0)
throw std::runtime_error("couldn't rm -f ./test.data");
return typename block_manager<BlockSize>::ptr(
new block_manager<BlockSize>(path, nr, MAX_HELD_LOCKS,
block_manager<BlockSize>::CREATE));
return typename block_manager::ptr(
new block_manager(path, nr, MAX_HELD_LOCKS,
block_manager::CREATE));
}
// Don't use this to update the metadata.
transaction_manager::ptr open_temporary_tm(block_manager<>::ptr bm);
transaction_manager::ptr open_temporary_tm(block_manager::ptr bm);
void zero_block(block_manager<>::ptr bm, block_address b);
void zero_block(block_manager::ptr bm, block_address b);
//--------------------------------

8
unit-tests/transaction_manager_t.cc
View File

@ -32,8 +32,8 @@ namespace {
transaction_manager::ptr
create_tm() {
block_manager<>::ptr bm(
new block_manager<>("./test.data", NR_BLOCKS, MAX_HELD_LOCKS, block_manager<>::READ_WRITE));
block_manager::ptr bm(
new block_manager("./test.data", NR_BLOCKS, MAX_HELD_LOCKS, block_manager::READ_WRITE));
space_map::ptr sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, sm));
tm->get_sm()->inc(0);
@ -47,7 +47,7 @@ namespace {
new bcache::noop_validator);
}
typedef block_manager<>::write_ref write_ref;
typedef block_manager::write_ref write_ref;
}
//----------------------------------------------------------------
@ -61,7 +61,7 @@ TEST(TransactionManagerTests, commit_succeeds)
TEST(TransactionManagerTests, shadowing)
{
transaction_manager::ptr tm = create_tm();
block_manager<>::write_ref superblock = tm->begin(0, mk_noop_validator());
block_manager::write_ref superblock = tm->begin(0, mk_noop_validator());
space_map::ptr sm = tm->get_sm();
sm->inc(1);