From e801cc607bc36a7c5510415f08ff830a2c606daf Mon Sep 17 00:00:00 2001 From: Joe Thornber Date: Thu, 30 Apr 2020 14:30:01 +0100 Subject: [PATCH] [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. --- Makefile.in | 1 + block-cache/block_cache.cc | 4 - block-cache/block_cache.h | 1 + caching/cache_check.cc | 4 +- caching/cache_dump.cc | 2 +- caching/cache_repair.cc | 4 +- caching/cache_restore.cc | 2 +- caching/cache_writeback.cc | 2 +- caching/metadata.cc | 10 +- caching/metadata.h | 12 +- caching/superblock.cc | 10 +- caching/superblock.h | 6 +- era/era_check.cc | 2 +- era/era_dump.cc | 2 +- era/era_invalidate.cc | 2 +- era/era_restore.cc | 2 +- era/metadata.cc | 10 +- era/metadata.h | 12 +- era/superblock.cc | 10 +- era/superblock.h | 6 +- persistent-data/block.cc | 203 +++++++++++++++++++++ persistent-data/block.h | 5 +- persistent-data/block.tcc | 224 ------------------------ persistent-data/data-structures/array.h | 8 +- persistent-data/data-structures/btree.h | 12 +- persistent-data/file_utils.cc | 18 +- persistent-data/file_utils.h | 10 +- persistent-data/space-maps/disk.cc | 6 +- persistent-data/transaction_manager.cc | 2 +- persistent-data/transaction_manager.h | 10 +- thin-provisioning/metadata.cc | 8 +- thin-provisioning/metadata.h | 12 +- thin-provisioning/metadata_checker.cc | 8 +- thin-provisioning/metadata_checker.h | 2 +- thin-provisioning/metadata_dumper.cc | 18 +- thin-provisioning/metadata_dumper.h | 2 +- thin-provisioning/superblock.cc | 16 +- thin-provisioning/superblock.h | 10 +- thin-provisioning/thin_check.cc | 4 +- thin-provisioning/thin_delta.cc | 2 +- thin-provisioning/thin_dump.cc | 4 +- thin-provisioning/thin_ls.cc | 2 +- thin-provisioning/thin_repair.cc | 4 +- thin-provisioning/thin_restore.cc | 2 +- thin-provisioning/thin_rmap.cc | 2 +- thin-provisioning/thin_trim.cc | 2 +- unit-tests/array_block_t.cc | 6 +- unit-tests/array_t.cc | 4 +- unit-tests/bitset_t.cc | 4 +- unit-tests/block_t.cc | 73 +++----- unit-tests/btree_counter_t.cc | 6 +- unit-tests/btree_damage_visitor_t.cc | 6 +- unit-tests/btree_t.cc | 4 +- unit-tests/space_map_t.cc | 8 +- unit-tests/test_utils.cc | 6 +- unit-tests/test_utils.h | 13 +- unit-tests/transaction_manager_t.cc | 8 +- 57 files changed, 390 insertions(+), 448 deletions(-) create mode 100644 persistent-data/block.cc delete mode 100644 persistent-data/block.tcc diff --git a/Makefile.in b/Makefile.in index 180d474..b3b3ce5 100644 --- a/Makefile.in +++ b/Makefile.in @@ -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 \ diff --git a/block-cache/block_cache.cc b/block-cache/block_cache.cc index 18a1606..0dfaa38 100644 --- a/block-cache/block_cache.cc +++ b/block-cache/block_cache.cc @@ -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 diff --git a/block-cache/block_cache.h b/block-cache/block_cache.h index 3658e89..0ef2231 100644 --- a/block-cache/block_cache.h +++ b/block-cache/block_cache.h @@ -3,6 +3,7 @@ #include "base/container_of.h" #include "base/file_utils.h" +#include "block-cache/io_engine.h" #include #include diff --git a/caching/cache_check.cc b/caching/cache_check.cc index 4e0af8e..ada4a2d 100644 --- a/caching/cache_check.cc +++ b/caching/cache_check.cc @@ -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); diff --git a/caching/cache_dump.cc b/caching/cache_dump.cc index ec3e31c..631445c 100644 --- a/caching/cache_dump.cc +++ b/caching/cache_dump.cc @@ -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)) { diff --git a/caching/cache_repair.cc b/caching/cache_repair.cc index 8a837a8..720047f 100644 --- a/caching/cache_repair.cc +++ b/caching/cache_repair.cc @@ -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); } diff --git a/caching/cache_restore.cc b/caching/cache_restore.cc index f4c71a2..23beec2 100644 --- a/caching/cache_restore.cc +++ b/caching/cache_restore.cc @@ -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); diff --git a/caching/cache_writeback.cc b/caching/cache_writeback.cc index 9bcf973..416e0d5 100644 --- a/caching/cache_writeback.cc +++ b/caching/cache_writeback.cc @@ -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 diff --git a/caching/metadata.cc b/caching/metadata.cc index b8d3183..b98aeb3 100644 --- a/caching/metadata.cc +++ b/caching/metadata.cc @@ -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()); diff --git a/caching/metadata.h b/caching/metadata.h index 1bb3607..7949c20 100644 --- a/caching/metadata.h +++ b/caching/metadata.h @@ -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 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(); diff --git a/caching/superblock.cc b/caching/superblock.cc index 630762c..cb1f97c 100644 --- a/caching/superblock.cc +++ b/caching/superblock.cc @@ -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(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(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) { diff --git a/caching/superblock.h b/caching/superblock.h index 2366bbc..a9cbdb6 100644 --- a/caching/superblock.h +++ b/caching/superblock.h @@ -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); } diff --git a/era/era_check.cc b/era/era_check.cc index af51c26..6f8be82 100644 --- a/era/era_check.cc +++ b/era/era_check.cc @@ -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); diff --git a/era/era_dump.cc b/era/era_dump.cc index f2c1957..18b7b38 100644 --- a/era/era_dump.cc +++ b/era/era_dump.cc @@ -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)) { diff --git a/era/era_invalidate.cc b/era/era_invalidate.cc index 76eaadd..4a44aff 100644 --- a/era/era_invalidate.cc +++ b/era/era_invalidate.cc @@ -152,7 +152,7 @@ namespace { int invalidate(string const &dev, string const &output, flags const &fs) { try { set 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); diff --git a/era/era_restore.cc b/era/era_restore.cc index 9ca0e93..0603a56 100644 --- a/era/era_restore.cc +++ b/era/era_restore.cc @@ -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)); diff --git a/era/metadata.cc b/era/metadata.cc index 905b0d2..e6fdcbd 100644 --- a/era/metadata.cc +++ b/era/metadata.cc @@ -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); diff --git a/era/metadata.h b/era/metadata.h index 687e2b9..0a2ad3d 100644 --- a/era/metadata.h +++ b/era/metadata.h @@ -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 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(); diff --git a/era/superblock.cc b/era/superblock.cc index 4c97e9b..1d69165 100644 --- a/era/superblock.cc +++ b/era/superblock.cc @@ -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(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(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) { diff --git a/era/superblock.h b/era/superblock.h index 408039d..232dcca 100644 --- a/era/superblock.h +++ b/era/superblock.h @@ -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); } diff --git a/persistent-data/block.cc b/persistent-data/block.cc new file mode 100644 index 0000000..57d7028 --- /dev/null +++ b/persistent-data/block.cc @@ -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 +// . + +#include "block.h" + +#include "base/error_string.h" +#include "base/file_utils.h" +#include "block-cache/io_engine.h" + +#include +#include + +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(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(); +} + +//---------------------------------------------------------------- diff --git a/persistent-data/block.h b/persistent-data/block.h index 393c60f..7d06fbd 100644 --- a/persistent-data/block.h +++ b/persistent-data/block.h @@ -38,7 +38,6 @@ namespace persistent_data { uint32_t const MD_BLOCK_SIZE = 4096; - template class block_manager : private boost::noncopyable { public: typedef boost::shared_ptr 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 diff --git a/persistent-data/block.tcc b/persistent-data/block.tcc deleted file mode 100644 index 792c658..0000000 --- a/persistent-data/block.tcc +++ /dev/null @@ -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 -// . - -#include "block.h" - -#include "base/error_string.h" -#include "base/file_utils.h" -#include "block-cache/io_engine.h" - -#include -#include - -//---------------------------------------------------------------- - -namespace persistent_data { - template - block_manager::read_ref::read_ref(block_cache::block &b) - : b_(b) - { - } - - template - block_manager::read_ref::read_ref(read_ref const &rhs) - : b_(rhs.b_) - { - b_.get(); - } - - template - block_manager::read_ref::~read_ref() - { - b_.put(); - } - - template - block_address - block_manager::read_ref::get_location() const - { - return b_.get_index(); - } - - template - void const * - block_manager::read_ref::data() const - { - return b_.get_data(); - } - - //-------------------------------- - - template - block_manager::write_ref::write_ref(block_cache::block &b) - : read_ref(b), - ref_count_(NULL) - { - } - - template - 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_)++; - } - - template - block_manager::write_ref::write_ref(write_ref const &rhs) - : read_ref(rhs), - ref_count_(rhs.ref_count_) { - if (ref_count_) - (*ref_count_)++; - } - - template - 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_)--; - } - } - - template - void * - block_manager::write_ref::data() - { - return read_ref::b_.get_data(); - } - - //---------------------------------------------------------------- - - template - uint64_t - block_manager::choose_cache_size(block_address nr_blocks) const - { - uint64_t const DEFAULT_CACHE_SIZE = 1024 * 1024 * 16; - return std::min(DEFAULT_CACHE_SIZE, BlockSize * nr_blocks); - } - - template - 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 * BlockSize, m, excl)), - bc_(fd_, BlockSize >> SECTOR_SHIFT, nr_blocks, choose_cache_size(nr_blocks)), - superblock_ref_count_(0) - { - } - - template - 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"); - } - } - - template - typename 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); - } - - template - typename 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); - } - - template - typename 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); - } - - template - typename 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_); - } - - template - typename 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_); - } - - template - block_address - block_manager::get_nr_blocks() const - { - return bc_.get_nr_blocks(); - } - - template - void - block_manager::prefetch(block_address b) const - { - bc_.prefetch(b); - } - - template - void - block_manager::flush() const - { - bc_.flush(); - } -} - -//---------------------------------------------------------------- diff --git a/persistent-data/data-structures/array.h b/persistent-data/data-structures/array.h index ba19408..7348d1a 100644 --- a/persistent-data/data-structures/array.h +++ b/persistent-data/data-structures/array.h @@ -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::write_ref> wblock; - typedef array_block::read_ref> rblock; + typedef array_block wblock; + typedef array_block rblock; typedef boost::shared_ptr > ptr; typedef typename ValueTraits::value_type value_type; diff --git a/persistent-data/data-structures/btree.h b/persistent-data/data-structures/btree.h index 9e85a36..bd1252a 100644 --- a/persistent-data/data-structures/btree.h +++ b/persistent-data/data-structures/btree.h @@ -152,7 +152,7 @@ namespace persistent_data { // template node_ref - 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( @@ -163,7 +163,7 @@ namespace persistent_data { template node_ref - to_node(typename block_manager<>::write_ref &b) + to_node(typename block_manager::write_ref &b) { return node_ref( b.get_location(), @@ -188,7 +188,7 @@ namespace persistent_data { private: transaction_manager &tm_; bcache::validator::ptr validator_; - std::list::read_ref> spine_; + std::list spine_; }; class shadow_spine : private boost::noncopyable { @@ -252,7 +252,7 @@ namespace persistent_data { private: transaction_manager &tm_; bcache::validator::ptr validator_; - std::list::write_ref> spine_; + std::list spine_; maybe_block root_; }; @@ -304,8 +304,8 @@ namespace persistent_data { typedef typename ValueTraits::value_type value_type; typedef boost::optional maybe_value; typedef boost::optional > 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 leaf_node; typedef typename btree_detail::node_ref internal_node; diff --git a/persistent-data/file_utils.cc b/persistent-data/file_utils.cc index 1743aff..fc1b005 100644 --- a/persistent-data/file_utils.cc +++ b/persistent-data/file_utils.cc @@ -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(b.data()); return (!strncmp(data, "::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."); diff --git a/persistent-data/file_utils.h b/persistent-data/file_utils.h index c6f1f4d..f44aa42 100644 --- a/persistent-data/file_utils.h +++ b/persistent-data/file_utils.h @@ -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); } diff --git a/persistent-data/space-maps/disk.cc b/persistent-data/space-maps/disk.cc index c0057af..18736cd 100644 --- a/persistent-data/space-maps/disk.cc +++ b/persistent-data/space-maps/disk.cc @@ -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::write_ref, bool> p = + std::pair 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(rr.data()); diff --git a/persistent-data/transaction_manager.cc b/persistent-data/transaction_manager.cc index 279b188..2bcdda7 100644 --- a/persistent-data/transaction_manager.cc +++ b/persistent-data/transaction_manager.cc @@ -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) diff --git a/persistent-data/transaction_manager.h b/persistent-data/transaction_manager.h index 10ac8b7..26264e2 100644 --- a/persistent-data/transaction_manager.h +++ b/persistent-data/transaction_manager.h @@ -31,15 +31,15 @@ namespace persistent_data { class transaction_manager : boost::noncopyable { public: typedef boost::shared_ptr 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 shadows_; diff --git a/thin-provisioning/metadata.cc b/thin-provisioning/metadata.cc index 8efea77..9f81a51 100644 --- a/thin-provisioning/metadata.cc +++ b/thin-provisioning/metadata.cc @@ -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 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; diff --git a/thin-provisioning/metadata.h b/thin-provisioning/metadata.h index bafd933..ca98566 100644 --- a/thin-provisioning/metadata.h +++ b/thin-provisioning/metadata.h @@ -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 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 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(); diff --git a/thin-provisioning/metadata_checker.cc b/thin-provisioning/metadata_checker.cc index 2765d55..02c12c6 100644 --- a/thin-provisioning/metadata_checker.cc +++ b/thin-provisioning/metadata_checker.cc @@ -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) { diff --git a/thin-provisioning/metadata_checker.h b/thin-provisioning/metadata_checker.h index 4b84c4b..48c82b9 100644 --- a/thin-provisioning/metadata_checker.h +++ b/thin-provisioning/metadata_checker.h @@ -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); } diff --git a/thin-provisioning/metadata_dumper.cc b/thin-provisioning/metadata_dumper.cc index be4b666..0dd43c6 100644 --- a/thin-provisioning/metadata_dumper.cc +++ b/thin-provisioning/metadata_dumper.cc @@ -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(it->second); } - block_manager<> &bm_; + block_manager &bm_; vector referenced_; vector examined_; map 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 - 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); diff --git a/thin-provisioning/metadata_dumper.h b/thin-provisioning/metadata_dumper.h index f588015..258d0f3 100644 --- a/thin-provisioning/metadata_dumper.h +++ b/thin-provisioning/metadata_dumper.h @@ -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); diff --git a/thin-provisioning/superblock.cc b/thin-provisioning/superblock.cc index 3651707..7b1c493 100644 --- a/thin-provisioning/superblock.cc +++ b/thin-provisioning/superblock.cc @@ -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(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(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; diff --git a/thin-provisioning/superblock.h b/thin-provisioning/superblock.h index 4c5cc66..62bceb7 100644 --- a/thin-provisioning/superblock.h +++ b/thin-provisioning/superblock.h @@ -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); } diff --git a/thin-provisioning/thin_check.cc b/thin-provisioning/thin_check.cc index 36ba41b..79ea171 100644 --- a/thin-provisioning/thin_check.cc +++ b/thin-provisioning/thin_check.cc @@ -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(); diff --git a/thin-provisioning/thin_delta.cc b/thin-provisioning/thin_delta.cc index 5d54759..b1055d1 100644 --- a/thin-provisioning/thin_delta.cc +++ b/thin-provisioning/thin_delta.cc @@ -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_; diff --git a/thin-provisioning/thin_dump.cc b/thin-provisioning/thin_dump.cc index e049202..74cfa91 100644 --- a/thin-provisioning/thin_dump.cc +++ b/thin-provisioning/thin_dump.cc @@ -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); diff --git a/thin-provisioning/thin_ls.cc b/thin-provisioning/thin_ls.cc index fe608a7..31fb81d 100644 --- a/thin-provisioning/thin_ls.cc +++ b/thin-provisioning/thin_ls.cc @@ -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; diff --git a/thin-provisioning/thin_repair.cc b/thin-provisioning/thin_repair.cc index 6d2e0d3..3bfd482 100644 --- a/thin-provisioning/thin_repair.cc +++ b/thin-provisioning/thin_repair.cc @@ -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) { diff --git a/thin-provisioning/thin_restore.cc b/thin-provisioning/thin_restore.cc index 6cdc6e8..5ee5ae3 100644 --- a/thin-provisioning/thin_restore.cc +++ b/thin-provisioning/thin_restore.cc @@ -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)); diff --git a/thin-provisioning/thin_rmap.cc b/thin-provisioning/thin_rmap.cc index 3622ea2..8f73c60 100644 --- a/thin-provisioning/thin_rmap.cc +++ b/thin-provisioning/thin_rmap.cc @@ -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); diff --git a/thin-provisioning/thin_trim.cc b/thin-provisioning/thin_trim.cc index 82498bd..935f32c 100644 --- a/thin-provisioning/thin_trim.cc +++ b/thin-provisioning/thin_trim.cc @@ -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()) { diff --git a/unit-tests/array_block_t.cc b/unit-tests/array_block_t.cc index 9ce3823..e06887c 100644 --- a/unit-tests/array_block_t.cc +++ b/unit-tests/array_block_t.cc @@ -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; diff --git a/unit-tests/array_t.cc b/unit-tests/array_t.cc index 0e5cf15..ff0b78f 100644 --- a/unit-tests/array_t.cc +++ b/unit-tests/array_t.cc @@ -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_; }; diff --git a/unit-tests/bitset_t.cc b/unit-tests/bitset_t.cc index 0973041..e337013 100644 --- a/unit-tests/bitset_t.cc +++ b/unit-tests/bitset_t.cc @@ -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_; }; diff --git a/unit-tests/block_t.cc b/unit-tests/block_t.cc index 948a42f..07d3ab3 100644 --- a/unit-tests/block_t.cc +++ b/unit-tests/block_t.cc @@ -29,7 +29,7 @@ using namespace testing; namespace { template - void check_all_bytes(typename block_manager::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(rr.data()); for (unsigned b = 0; b < BlockSize; b++) ASSERT_THAT(data[b], Eq(static_cast(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) { } diff --git a/unit-tests/btree_counter_t.cc b/unit-tests/btree_counter_t.cc index c6b8c67..751f871 100644 --- a/unit-tests/btree_counter_t.cc +++ b/unit-tests/btree_counter_t.cc @@ -23,7 +23,7 @@ namespace { class BTreeCounterTests : public Test { public: BTreeCounterTests() - : bm_(create_bm(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)); } }; } diff --git a/unit-tests/btree_damage_visitor_t.cc b/unit-tests/btree_damage_visitor_t.cc index 71f6006..b4f1129 100644 --- a/unit-tests/btree_damage_visitor_t.cc +++ b/unit-tests/btree_damage_visitor_t.cc @@ -256,7 +256,7 @@ namespace { class DamageTests : public Test { public: DamageTests() - : bm_(create_bm(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; diff --git a/unit-tests/btree_t.cc b/unit-tests/btree_t.cc index 46d5cd3..1b55ac7 100644 --- a/unit-tests/btree_t.cc +++ b/unit-tests/btree_t.cc @@ -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_; }; diff --git a/unit-tests/space_map_t.cc b/unit-tests/space_map_t.cc index 5ee8b30..d68db7e 100644 --- a/unit-tests/space_map_t.cc +++ b/unit-tests/space_map_t.cc @@ -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); diff --git a/unit-tests/test_utils.cc b/unit-tests/test_utils.cc index 7f65607..f3e6c05 100644 --- a/unit-tests/test_utils.cc +++ b/unit-tests/test_utils.cc @@ -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)); diff --git a/unit-tests/test_utils.h b/unit-tests/test_utils.h index 56862e2..1953d7a 100644 --- a/unit-tests/test_utils.h +++ b/unit-tests/test_utils.h @@ -28,23 +28,22 @@ namespace test { unsigned const MAX_HELD_LOCKS = 16; - template - typename block_manager::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::ptr( - new block_manager(path, nr, MAX_HELD_LOCKS, - block_manager::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); //-------------------------------- diff --git a/unit-tests/transaction_manager_t.cc b/unit-tests/transaction_manager_t.cc index edb3337..925b8f3 100644 --- a/unit-tests/transaction_manager_t.cc +++ b/unit-tests/transaction_manager_t.cc @@ -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);