From 04d7b7ce5b6e75031007e4632ad18b9838665a2e Mon Sep 17 00:00:00 2001 From: Joe Thornber Date: Wed, 24 Aug 2011 14:27:45 +0100 Subject: [PATCH] [thin-repair] stop using c++0x features --- Makefile | 3 +- block.h | 3 +- block.tcc | 5 +-- btree.h | 22 ++++++------ btree.tcc | 75 ++++++++++++++++++++++------------------- btree_validator.h | 36 +++++++++++++++----- error_set.cc | 25 +++++++------- error_set.h | 1 + metadata.cc | 35 +++++++++---------- metadata.h | 2 ++ space_map_disk.h | 21 +++++++----- thin_repair.cc | 3 +- transaction_manager.tcc | 12 +++---- 13 files changed, 141 insertions(+), 102 deletions(-) diff --git a/Makefile b/Makefile index b9b6019..ba7a075 100644 --- a/Makefile +++ b/Makefile @@ -15,7 +15,8 @@ TEST_SOURCE=\ OBJECTS=$(subst .cc,.o,$(SOURCE)) TEST_PROGRAMS=$(subst .cc,,$(TEST_SOURCE)) TOP_DIR:=$(PWD) -CPPFLAGS=-Wall -std=c++0x -g -I$(TOP_DIR) +CPPFLAGS=-Wall -g -I$(TOP_DIR) +#CPPFLAGS=-Wall -std=c++0x -g -I$(TOP_DIR) LIBS=-lstdc++ .PHONEY: unit-tests test-programs diff --git a/block.h b/block.h index 879f82f..bbebec5 100644 --- a/block.h +++ b/block.h @@ -181,7 +181,8 @@ namespace persistent_data { mutable unsigned superblock_count_; mutable unsigned ordinary_count_; - mutable std::map > held_locks_; + typedef std::map > held_map; + mutable held_map held_locks_; }; } diff --git a/block.tcc b/block.tcc index 16c1f7a..5d4d3d4 100644 --- a/block.tcc +++ b/block.tcc @@ -1,5 +1,6 @@ #include "block.h" +#include #include #include #include @@ -352,7 +353,7 @@ template void block_manager::register_lock(block_address b, lock_type t) const { - auto it = held_locks_.find(b); + typename held_map::iterator it = held_locks_.find(b); if (it == held_locks_.end()) held_locks_.insert(make_pair(b, make_pair(t, 1))); else { @@ -370,7 +371,7 @@ template void block_manager::unregister_lock(block_address b, lock_type t) const { - auto it = held_locks_.find(b); + typename held_map::iterator it = held_locks_.find(b); if (it == held_locks_.end()) throw std::runtime_error("lock not held"); diff --git a/btree.h b/btree.h index b93a72f..07e4cb9 100644 --- a/btree.h +++ b/btree.h @@ -189,13 +189,16 @@ namespace persistent_data { template class shadow_spine : private noncopyable { public: + typedef typename transaction_manager::read_ref read_ref; + typedef typename transaction_manager::write_ref write_ref; + shadow_spine(typename transaction_manager::ptr tm) : tm_(tm) { } // true if the children of the shadow need incrementing bool step(block_address b) { - auto p = tm_->shadow(b); + pair p = tm_->shadow(b); try { step(p.first); } catch (...) { @@ -261,16 +264,16 @@ namespace persistent_data { for (;;) { spine.step(block); - auto leaf = spine.template get_node(); + node_ref leaf = spine.template get_node(); - auto mi = leaf.exact_search(key); + optional mi = leaf.exact_search(key); if (!mi) return optional(); if (leaf.get_type() == btree_detail::LEAF) return optional(leaf.value_at(*mi)); - auto internal = spine.template get_node(); + node_ref internal = spine.template get_node(); block = internal.value_at(*mi); } } @@ -287,6 +290,8 @@ namespace persistent_data { typedef boost::optional > maybe_pair; 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; btree(typename persistent_data::transaction_manager::ptr tm, typename ValueTraits::ref_counter rc); @@ -320,12 +325,9 @@ namespace persistent_data { virtual ~visitor() {} typedef boost::shared_ptr ptr; - virtual void visit_internal(unsigned level, bool is_root, - btree_detail::node_ref const &n) = 0; - virtual void visit_internal_leaf(unsigned level, bool is_root, - btree_detail::node_ref const &n) = 0; - virtual void visit_leaf(unsigned level, bool is_root, - btree_detail::node_ref const &n) = 0; + virtual void visit_internal(unsigned level, bool is_root, internal_node const &n) = 0; + virtual void visit_internal_leaf(unsigned level, bool is_root, internal_node const &n) = 0; + virtual void visit_leaf(unsigned level, bool is_root, leaf_node const &n) = 0; }; // Walks the tree in depth first order diff --git a/btree.tcc b/btree.tcc index faaff56..ac8ee80 100644 --- a/btree.tcc +++ b/btree.tcc @@ -277,7 +277,7 @@ btree(typename transaction_manager::ptr tm, write_ref root = tm_->new_block(); - auto n = to_node(root); + leaf_node n = to_node(root); n.set_type(btree_detail::LEAF); n.set_nr_entries(0); n.set_max_entries(); @@ -357,7 +357,7 @@ insert(key const &key, for (unsigned level = 0; level < Levels - 1; ++level) { bool need_insert = insert_location(spine, block, key[level], &index); - auto n = spine.template get_node(); + internal_node n = spine.template get_node(); if (need_insert) { btree new_tree(tm_, rc_); n.insert_at(index, key[level], new_tree.get_root()); @@ -368,7 +368,7 @@ insert(key const &key, bool need_insert = insert_location(spine, block, key[Levels - 1], &index); - auto n = spine.template get_node(); + leaf_node n = spine.template get_node(); if (need_insert) n.insert_at(index, key[Levels - 1], value); else @@ -406,17 +406,17 @@ btree::clone() const ro_spine spine(tm_); spine.step(root_); - auto new_root = tm_->new_block(); + write_ref new_root = tm_->new_block(); - auto o = spine.template get_node(); + internal_node o = spine.template get_node(); if (o.get_type() == INTERNAL) { - auto n = to_node(new_root); + internal_node n = to_node(new_root); ::memcpy(n.raw(), o.raw(), BlockSize); typename uint64_traits::ref_counter rc(internal_rc_); n.inc_children(rc); } else { - auto n = to_node(new_root); + leaf_node n = to_node(new_root); ::memcpy(n.raw(), o.raw(), BlockSize); typename ValueTraits::ref_counter rc(rc_); @@ -447,7 +447,7 @@ split_node(btree_detail::shadow_spine &spine, uint64_t key, bool top) { - auto n = spine.template get_node(); + node_ref n = spine.template get_node(); if (n.get_nr_entries() == n.get_max_entries()) { if (top) split_beneath(spine, key); @@ -468,18 +468,18 @@ split_beneath(btree_detail::shadow_spine &spine, node_type type; unsigned nr_left, nr_right; - auto left = tm_->new_block(); - auto l = to_node(left); + write_ref left = tm_->new_block(); + node_ref l = to_node(left); l.set_nr_entries(0); l.set_max_entries(); - auto right = tm_->new_block(); - auto r = to_node(right); + write_ref right = tm_->new_block(); + node_ref r = to_node(right); r.set_nr_entries(0); r.set_max_entries(); { - auto p = spine.template get_node(); + node_ref p = spine.template get_node(); nr_left = p.get_nr_entries() / 2; nr_right = p.get_nr_entries() - nr_left; type = p.get_type(); @@ -493,10 +493,11 @@ split_beneath(btree_detail::shadow_spine &spine, { // The parent may have changed value type, so we re-get it. - auto p = spine.template get_node(); + internal_node p = spine.template get_node(); p.set_type(btree_detail::INTERNAL); p.set_nr_entries(2); + // FIXME: set the value_size p.overwrite_at(0, l.key_at(0), left.get_location()); p.overwrite_at(1, r.key_at(0), right.get_location()); } @@ -517,11 +518,11 @@ split_sibling(btree_detail::shadow_spine &spine, { using namespace btree_detail; - auto l = spine.template get_node(); - auto left = spine.get_block(); + node_ref l = spine.template get_node(); + block_address left = spine.get_block(); - auto right = tm_->new_block(); - auto r = to_node(right); + write_ref right = tm_->new_block(); + node_ref r = to_node(right); unsigned nr_left = l.get_nr_entries() / 2; unsigned nr_right = l.get_nr_entries() - nr_left; @@ -532,7 +533,7 @@ split_sibling(btree_detail::shadow_spine &spine, r.copy_entries(l, nr_left, nr_left + nr_right); l.set_nr_entries(nr_left); - auto p = spine.get_parent(); + internal_node p = spine.get_parent(); p.overwrite_at(parent_index, l.key_at(0), left); p.insert_at(parent_index + 1, r.key_at(0), right.get_location()); @@ -568,11 +569,11 @@ insert_location(btree_detail::shadow_spine &spine, // patch up the parent to point to the new shadow if (spine.has_parent()) { - auto p = spine.get_parent(); + internal_node p = spine.get_parent(); p.set_value(i, spine.get_block()); } - auto internal = spine.template get_node(); + internal_node internal = spine.template get_node(); // Split the node if we're full if (internal.get_type() == INTERNAL) @@ -594,7 +595,7 @@ insert_location(btree_detail::shadow_spine &spine, top = false; } - auto leaf = spine.template get_node(); + node_ref leaf = spine.template get_node(); // FIXME: gross if (i < 0 || leaf.key_at(i) != key) i++; @@ -626,21 +627,25 @@ walk_tree(typename visitor::ptr visitor, { using namespace btree_detail; - auto blk = tm_->read_lock(b); - auto o = to_node(blk); - if (o.get_type() == INTERNAL) { - visitor->visit_internal(level, is_root, o); - for (unsigned i = 0; i < o.get_nr_entries(); i++) - walk_tree(visitor, level, false, o.value_at(i)); + try { + read_ref blk = tm_->read_lock(b); + internal_node o = to_node(blk); + if (o.get_type() == INTERNAL) { + visitor->visit_internal(level, is_root, o); + for (unsigned i = 0; i < o.get_nr_entries(); i++) + walk_tree(visitor, level, false, o.value_at(i)); - } else if (level < Levels - 1) { - visitor->visit_internal_leaf(level, is_root, o); - for (unsigned i = 0; i < o.get_nr_entries(); i++) - walk_tree(visitor, level + 1, true, o.value_at(i)); + } else if (level < Levels - 1) { + visitor->visit_internal_leaf(level, is_root, o); + for (unsigned i = 0; i < o.get_nr_entries(); i++) + walk_tree(visitor, level + 1, true, o.value_at(i)); + + } else { + leaf_node ov = to_node(blk); + visitor->visit_leaf(level, is_root, ov); + } + } catch (...) { // FIXME: we should only catch terminate_walk type exceptions - } else { - auto ov = to_node(blk); - visitor->visit_leaf(level, is_root, ov); } } diff --git a/btree_validator.h b/btree_validator.h index ad132d9..ea85dfc 100644 --- a/btree_validator.h +++ b/btree_validator.h @@ -3,10 +3,15 @@ #include "btree.h" +#include "error_set.h" + #include #include #include +using namespace persistent_data; +using namespace std; + //---------------------------------------------------------------- namespace persistent_data { @@ -16,8 +21,10 @@ namespace persistent_data { //---------------------------------------------------------------- class block_counter { public: + typedef typename std::map count_map; + void inc(block_address b) { - auto it = counts_.find(b); + typename count_map::iterator it = counts_.find(b); if (it == counts_.end()) counts_.insert(make_pair(b, 1)); #if 0 @@ -27,16 +34,16 @@ namespace persistent_data { } unsigned get_count(block_address b) const { - auto it = counts_.find(b); + count_map::const_iterator it = counts_.find(b); return (it == counts_.end()) ? 0 : it->second; } - std::map const &get_counts() const { + count_map const &get_counts() const { return counts_; } private: - std::map counts_; + count_map counts_; }; //---------------------------------------------------------------- @@ -63,7 +70,8 @@ namespace persistent_data { class btree_validator : public btree::visitor { public: btree_validator(block_counter &counter) - : counter_(counter) { + : counter_(counter), + errs_(new error_set("btree errors")) { } void visit_internal(unsigned level, bool is_root, @@ -93,12 +101,17 @@ namespace persistent_data { check_nr_entries(n, is_root); } + boost::optional get_errors() const { + return errs_; + } + private: void check_duplicate_block(block_address b) { if (seen_.count(b)) { std::ostringstream out; out << "duplicate block in btree: " << b; - throw std::runtime_error(out.str()); + errs_->add_child(out.str()); + throw runtime_error(out.str()); } seen_.insert(b); @@ -111,7 +124,8 @@ namespace persistent_data { out << "block number mismatch: actually " << n.get_location() << ", claims " << n.get_block_nr(); - throw std::runtime_error(out.str()); + errs_->add_child(out.str()); + throw runtime_error(out.str()); } } @@ -121,13 +135,14 @@ namespace persistent_data { if (elt_size * n.get_max_entries() + sizeof(node_header) > BlockSize) { std::ostringstream out; out << "max entries too large: " << n.get_max_entries(); - throw std::runtime_error(out.str()); + errs_->add_child(out.str()); } if (n.get_max_entries() % 3) { std::ostringstream out; out << "max entries is not divisible by 3: " << n.get_max_entries(); - throw std::runtime_error(out.str()); + errs_->add_child(out.str()); + throw runtime_error(out.str()); } } @@ -138,6 +153,7 @@ namespace persistent_data { out << "bad nr_entries: " << n.get_nr_entries() << " < " << n.get_max_entries(); + errs_->add_child(out.str()); throw std::runtime_error(out.str()); } @@ -148,12 +164,14 @@ namespace persistent_data { << n.get_nr_entries() << ", expected at least " << min; + errs_->add_child(out.str()); throw runtime_error(out.str()); } } block_counter &counter_; std::set seen_; + error_set::ptr errs_; }; } diff --git a/error_set.cc b/error_set.cc index 36ec8f5..11bd012 100644 --- a/error_set.cc +++ b/error_set.cc @@ -3,20 +3,21 @@ #include using namespace persistent_data; +using namespace std; //---------------------------------------------------------------- -error_set::error_set(std::string const &err) +error_set::error_set(string const &err) : err_(err) { } -std::string const & +string const & error_set::get_description() const { return err_; } -std::list const & +list const & error_set::get_children() const { return children_; @@ -29,7 +30,7 @@ error_set::add_child(error_set::ptr err) } void -error_set::add_child(std::string const &err) +error_set::add_child(string const &err) { error_set::ptr e(new error_set(err)); add_child(e); @@ -38,21 +39,21 @@ error_set::add_child(std::string const &err) //-------------------------------- namespace { - void indent_by(std::ostream &out, unsigned indent) { + void indent_by(ostream &out, unsigned indent) { for (unsigned i = 0; i < indent; i++) out << ' '; } - void print_errs(std::ostream &out, error_set::ptr e, unsigned depth, unsigned indent) { + void print_errs(ostream &out, error_set::ptr e, unsigned depth, unsigned indent) { if (depth == 0) return; indent_by(out, indent); - out << e->get_description() << std::endl; + out << e->get_description() << endl; if (depth > 1) { - auto children = e->get_children(); - for (auto it = children.begin(); it != children.end(); ++it) + list const &children = e->get_children(); + for (list::const_iterator it = children.begin(); it != children.end(); ++it) print_errs(out, *it, depth - 1, indent + 2); } } @@ -65,13 +66,13 @@ error_selector::error_selector(error_set::ptr errs, unsigned depth) } void -error_selector::print(std::ostream &out) const +error_selector::print(ostream &out) const { print_errs(out, errs_, depth_, 0); } -std::ostream & -persistent_data::operator << (std::ostream &out, error_selector const &errs) +ostream & +persistent_data::operator << (ostream &out, error_selector const &errs) { errs.print(out); return out; diff --git a/error_set.h b/error_set.h index b3a27ca..ad4893c 100644 --- a/error_set.h +++ b/error_set.h @@ -4,6 +4,7 @@ #include #include #include +#include //---------------------------------------------------------------- diff --git a/metadata.cc b/metadata.cc index e8c9f1d..93d869b 100644 --- a/metadata.cc +++ b/metadata.cc @@ -35,7 +35,7 @@ namespace { superblock read_superblock(block_manager<4096>::ptr bm) { superblock sb; - auto r = bm->read_lock(SUPERBLOCK_LOCATION); + block_manager<4096>::read_ref r = bm->read_lock(SUPERBLOCK_LOCATION); superblock_disk const *sbd = reinterpret_cast(&r.data()); superblock_traits::unpack(*sbd, sb); return sb; @@ -70,7 +70,7 @@ namespace { data_counter_.inc(n.value_at(i).block_); } - set get_devices() const { + set const &get_devices() const { return devices_; } @@ -95,7 +95,7 @@ namespace { devices_.insert(n.key_at(i)); } - set get_devices() const { + set const &get_devices() const { return devices_; } @@ -146,7 +146,7 @@ void thin::set_snapshot_time(uint32_t time) { uint64_t key[1] = { dev_ }; - auto mdetail = metadata_->details_.lookup(key); + optional mdetail = metadata_->details_.lookup(key); if (!mdetail) throw runtime_error("no such device"); @@ -158,7 +158,7 @@ block_address thin::get_mapped_blocks() const { uint64_t key[1] = { dev_ }; - auto mdetail = metadata_->details_.lookup(key); + optional mdetail = metadata_->details_.lookup(key); if (!mdetail) throw runtime_error("no such device"); @@ -169,7 +169,7 @@ void thin::set_mapped_blocks(block_address count) { uint64_t key[1] = { dev_ }; - auto mdetail = metadata_->details_.lookup(key); + optional mdetail = metadata_->details_.lookup(key); if (!mdetail) throw runtime_error("no such device"); @@ -207,8 +207,8 @@ metadata::commit() sb_.data_mapping_root_ = mappings_.get_root(); sb_.device_details_root_ = details_.get_root(); - auto superblock = tm_->get_bm()->superblock(SUPERBLOCK_LOCATION); - auto disk = reinterpret_cast(superblock.data()); + write_ref superblock = tm_->get_bm()->superblock(SUPERBLOCK_LOCATION); + superblock_disk *disk = reinterpret_cast(superblock.data()); superblock_traits::pack(sb_, *disk); } @@ -231,7 +231,7 @@ metadata::create_snap(thin_dev_t dev, thin_dev_t origin) uint64_t snap_key[1] = {dev}; uint64_t origin_key[1] = {origin}; - auto mtree_root = mappings_top_level_.lookup(origin_key); + optional mtree_root = mappings_top_level_.lookup(origin_key); if (!mtree_root) throw std::runtime_error("unknown origin"); @@ -244,8 +244,8 @@ metadata::create_snap(thin_dev_t dev, thin_dev_t origin) sb_.time_++; - auto o = open_thin(origin); - auto s = open_thin(dev); + thin::ptr o = open_thin(origin); + thin::ptr s = open_thin(dev); o->set_snapshot_time(sb_.time_); s->set_snapshot_time(sb_.time_); s->set_mapped_blocks(o->get_mapped_blocks()); @@ -310,7 +310,7 @@ thin::ptr metadata::open_thin(thin_dev_t dev) { uint64_t key[1] = {dev}; - auto mdetails = details_.lookup(key); + optional mdetails = details_.lookup(key); if (!mdetails) throw runtime_error("no such device"); @@ -336,13 +336,13 @@ metadata::check() mapping_validator::ptr mv(new mapping_validator(metadata_counter, data_counter)); mappings_.visit(mv); - auto mapped_devs = mv->get_devices(); + set const &mapped_devs = mv->get_devices(); details_validator::ptr dv(new details_validator(metadata_counter)); details_.visit(dv); - auto details_devs = dv->get_devices(); + set const &details_devs = dv->get_devices(); - for (auto it = mapped_devs.begin(); it != mapped_devs.end(); ++it) + for (set::const_iterator it = mapped_devs.begin(); it != mapped_devs.end(); ++it) if (details_devs.count(*it) == 0) { ostringstream out; out << "mapping exists for device " << *it @@ -356,8 +356,9 @@ metadata::check() error_set::ptr data_errors(new error_set("Errors in data reference counts")); bool bad = false; - auto data_counts = data_counter.get_counts(); - for (auto it = data_counts.begin(); it != data_counts.end(); ++it) { + block_counter::count_map const &data_counts = data_counter.get_counts(); + for (block_counter::count_map::const_iterator it = data_counts.begin(); + it != data_counts.end(); ++it) { uint32_t ref_count = data_sm_->get_count(it->first); if (ref_count != it->second) { ostringstream out; diff --git a/metadata.h b/metadata.h index 99997a4..f91195f 100644 --- a/metadata.h +++ b/metadata.h @@ -146,6 +146,8 @@ namespace thin_provisioning { class metadata { public: typedef boost::shared_ptr ptr; + typedef typename block_manager::read_ref read_ref; + typedef typename block_manager::write_ref write_ref; metadata(std::string const &dev_path); ~metadata(); diff --git a/space_map_disk.h b/space_map_disk.h index 5c1b0a6..0523f85 100644 --- a/space_map_disk.h +++ b/space_map_disk.h @@ -19,6 +19,9 @@ namespace persistent_data { template class bitmap { public: + typedef typename transaction_manager::read_ref read_ref; + typedef typename transaction_manager::write_ref write_ref; + bitmap(typename transaction_manager::ptr tm, index_entry const &ie) : tm_(tm), @@ -26,7 +29,7 @@ namespace persistent_data { } ref_t lookup(unsigned b) const { - auto rr = tm_->read_lock(ie_.blocknr_); + read_ref rr = tm_->read_lock(ie_.blocknr_); void const *bits = bitmap_data(rr); ref_t b1 = test_bit_le(bits, b * 2); ref_t b2 = test_bit_le(bits, b * 2 + 1); @@ -36,7 +39,7 @@ namespace persistent_data { } void insert(unsigned b, ref_t n) { - auto wr = tm_->shadow(ie_.blocknr_).first; + write_ref wr = tm_->shadow(ie_.blocknr_).first; void *bits = bitmap_data(wr); bool was_free = !test_bit_le(bits, b * 2) && !test_bit_le(bits, b * 2 + 1); if (n == 1 || n == 3) @@ -113,6 +116,8 @@ namespace persistent_data { class sm_disk_base : public persistent_space_map { public: typedef boost::shared_ptr > ptr; + typedef typename transaction_manager::read_ref read_ref; + typedef typename transaction_manager::write_ref write_ref; sm_disk_base(typename transaction_manager::ptr tm) : tm_(tm), @@ -140,7 +145,7 @@ namespace persistent_data { } ref_t get_count(block_address b) const { - auto count = lookup_bitmap(b); + ref_t count = lookup_bitmap(b); if (count == 3) return lookup_ref_count(b); @@ -188,7 +193,7 @@ namespace persistent_data { // beginning. block_address nr_indexes = div_up(nr_blocks_, entries_per_block_); for (block_address index = 0; index < nr_indexes; index++) { - auto ie = find_ie(index); + index_entry ie = find_ie(index); bitmap bm(tm_, ie); block_address b = bm.find_free((index == nr_indexes - 1) ? @@ -213,7 +218,7 @@ namespace persistent_data { block_address bitmap_count = div_up(nr_blocks, entries_per_block_); block_address old_bitmap_count = div_up(nr_blocks_, entries_per_block_); for (block_address i = old_bitmap_count; i < bitmap_count; i++) { - auto wr = tm_->new_block(); + write_ref wr = tm_->new_block(); struct index_entry ie; ie.blocknr_ = wr.get_location(); @@ -258,7 +263,7 @@ namespace persistent_data { if (n > 3) throw runtime_error("bitmap can only hold 2 bit values"); - auto ie = find_ie(b); + index_entry ie = find_ie(b); bitmap bm(tm_, ie); bm.insert(b % entries_per_block_, n); save_ie(b, bm.get_ie()); @@ -266,7 +271,7 @@ namespace persistent_data { ref_t lookup_ref_count(block_address b) const { uint64_t key[1] = {b}; - auto mvalue = ref_counts_.lookup(key); + optional mvalue = ref_counts_.lookup(key); if (!mvalue) throw runtime_error("ref count not in tree"); return *mvalue; @@ -343,7 +348,7 @@ namespace persistent_data { private: index_entry find_ie(block_address b) const { uint64_t key[1] = {b / sm_disk_base::get_entries_per_block()}; - auto mindex = bitmaps_.lookup(key); + optional mindex = bitmaps_.lookup(key); if (!mindex) throw runtime_error("Couldn't lookup bitmap"); diff --git a/thin_repair.cc b/thin_repair.cc index 2b93a0b..c60a645 100644 --- a/thin_repair.cc +++ b/thin_repair.cc @@ -2,6 +2,7 @@ #include "metadata.h" +using namespace boost; using namespace persistent_data; using namespace std; using namespace thin_provisioning; @@ -10,7 +11,7 @@ namespace { int check(string const &path) { metadata md(path); - auto maybe_errors = md.check(); + optional maybe_errors = md.check(); if (maybe_errors) { cerr << error_selector(*maybe_errors, 3); return 1; diff --git a/transaction_manager.tcc b/transaction_manager.tcc index 2a42ae6..90f1d3f 100644 --- a/transaction_manager.tcc +++ b/transaction_manager.tcc @@ -25,7 +25,7 @@ template typename transaction_manager::write_ref transaction_manager::begin(block_address superblock) { - auto wr = bm_->superblock(superblock); + write_ref wr = bm_->superblock(superblock); wipe_shadow_table(); return wr; } @@ -35,7 +35,7 @@ typename transaction_manager::write_ref transaction_manager::begin(block_address superblock, validator v) { - auto wr = bm_->superblock(superblock, v); + write_ref wr = bm_->superblock(superblock, v); wipe_shadow_table(); return wr; } @@ -89,8 +89,8 @@ transaction_manager::shadow(block_address orig) !sm_->count_possibly_greater_than_one(orig)) return make_pair(bm_->write_lock(orig), false); - auto src = bm_->read_lock(orig); - auto dest = bm_->write_lock_zero(sm_->new_block()); + read_ref src = bm_->read_lock(orig); + write_ref dest = bm_->write_lock_zero(sm_->new_block()); ::memcpy(dest.data(), src.data(), BlockSize); ref_t count = sm_->get_count(orig); @@ -110,8 +110,8 @@ transaction_manager::shadow(block_address orig, validator v) sm_->count_possibly_greater_than_one(orig)) return make_pair(bm_->write_lock(orig), false); - auto src = bm_->read_lock(orig, v); - auto dest = bm_->write_lock_zero(sm_->new_block(), v); + read_ref src = bm_->read_lock(orig, v); + write_ref dest = bm_->write_lock_zero(sm_->new_block(), v); ::memcpy(dest->data_, src->data_, BlockSize); ref_t count = sm_->get_count(orig);