From 6706493304d1a7c87da920311dcaf0b7a8f74ca3 Mon Sep 17 00:00:00 2001 From: Joe Thornber Date: Tue, 28 May 2013 13:48:10 +0100 Subject: [PATCH] Remove some global 'using namespace's --- persistent-data/block.tcc | 756 ++++++++++---------- persistent-data/data-structures/btree.h | 2 +- persistent-data/data-structures/btree.tcc | 3 +- persistent-data/space-maps/careful_alloc.cc | 2 + thin-provisioning/file_utils.cc | 4 +- thin-provisioning/file_utils.h | 2 +- thin-provisioning/superblock.h | 6 +- unit-tests/test_utils.cc | 5 +- unit-tests/test_utils.h | 2 + 9 files changed, 395 insertions(+), 387 deletions(-) diff --git a/persistent-data/block.tcc b/persistent-data/block.tcc index e1ced4a..a103563 100644 --- a/persistent-data/block.tcc +++ b/persistent-data/block.tcc @@ -30,13 +30,9 @@ #include #include -// FIXME: remove these from a header! -using namespace boost; -using namespace persistent_data; -using namespace std; - //---------------------------------------------------------------- +// FIXME: give this namesace a name namespace { using namespace std; @@ -105,433 +101,435 @@ namespace { } }; -template -block_io::block_io(std::string const &path, block_address nr_blocks, mode m) - : nr_blocks_(nr_blocks), - mode_(m) -{ - off_t file_size = nr_blocks * BlockSize; +namespace persistent_data { + template + block_io::block_io(std::string const &path, block_address nr_blocks, mode m) + : nr_blocks_(nr_blocks), + mode_(m) + { + off_t file_size = nr_blocks * BlockSize; - switch (m) { - case READ_ONLY: - fd_ = open_block_file(path, file_size, false); - break; + switch (m) { + case READ_ONLY: + fd_ = open_block_file(path, file_size, false); + break; - case READ_WRITE: - fd_ = open_block_file(path, file_size, true); - break; + case READ_WRITE: + fd_ = open_block_file(path, file_size, true); + break; - case CREATE: - fd_ = create_block_file(path, file_size); - break; + case CREATE: + fd_ = create_block_file(path, file_size); + break; - default: - throw runtime_error("unsupported mode"); - } -} - -template -block_io::~block_io() -{ - if (::close(fd_) < 0) - syscall_failed("close"); -} - -template -void -block_io::read_buffer(block_address location, buffer &buffer) const -{ - off_t r; - r = ::lseek(fd_, BlockSize * location, SEEK_SET); - if (r == (off_t) -1) - throw std::runtime_error("lseek failed"); - - ssize_t n; - size_t remaining = BlockSize; - unsigned char *buf = buffer.raw(); - do { - n = ::read(fd_, buf, remaining); - if (n > 0) { - remaining -= n; - buf += n; + default: + throw runtime_error("unsupported mode"); + } + } + + template + block_io::~block_io() + { + if (::close(fd_) < 0) + syscall_failed("close"); + } + + template + void + block_io::read_buffer(block_address location, buffer &buffer) const + { + off_t r; + r = ::lseek(fd_, BlockSize * location, SEEK_SET); + if (r == (off_t) -1) + throw std::runtime_error("lseek failed"); + + ssize_t n; + size_t remaining = BlockSize; + unsigned char *buf = buffer.raw(); + do { + n = ::read(fd_, buf, remaining); + if (n > 0) { + remaining -= n; + buf += n; + } + } while (remaining && ((n > 0) || (n == EINTR) || (n == EAGAIN))); + + if (n < 0) + throw std::runtime_error("read failed"); + } + + template + void + block_io::write_buffer(block_address location, buffer const &buffer) + { + off_t r; + r = ::lseek(fd_, BlockSize * location, SEEK_SET); + if (r == (off_t) -1) + throw std::runtime_error("lseek failed"); + + ssize_t n; + size_t remaining = BlockSize; + unsigned char const *buf = buffer.raw(); + do { + n = ::write(fd_, buf, remaining); + if (n > 0) { + remaining -= n; + buf += n; + } + } while (remaining && ((n > 0) || (n == EINTR) || (n == EAGAIN))); + + if (n < 0) { + std::ostringstream out; + out << "write failed to block " << location + << ", block size = " << BlockSize + << ", remaining = " << remaining + << ", n = " << n + << ", errno = " << errno + << ", fd_ = " << fd_ + << std::endl; + throw std::runtime_error(out.str()); } - } while (remaining && ((n > 0) || (n == EINTR) || (n == EAGAIN))); - - if (n < 0) - throw std::runtime_error("read failed"); -} - -template -void -block_io::write_buffer(block_address location, buffer const &buffer) -{ - off_t r; - r = ::lseek(fd_, BlockSize * location, SEEK_SET); - if (r == (off_t) -1) - throw std::runtime_error("lseek failed"); - - ssize_t n; - size_t remaining = BlockSize; - unsigned char const *buf = buffer.raw(); - do { - n = ::write(fd_, buf, remaining); - if (n > 0) { - remaining -= n; - buf += n; - } - } while (remaining && ((n > 0) || (n == EINTR) || (n == EAGAIN))); - - if (n < 0) { - std::ostringstream out; - out << "write failed to block " << location - << ", block size = " << BlockSize - << ", remaining = " << remaining - << ", n = " << n - << ", errno = " << errno - << ", fd_ = " << fd_ - << std::endl; - throw std::runtime_error(out.str()); } -} //---------------------------------------------------------------- -template -block_manager::block::block(typename block_io::ptr io, - block_address location, - block_type bt, - typename validator::ptr v, - bool zero) - : io_(io), - location_(location), - data_(new buffer()), - validator_(v), - bt_(bt), - dirty_(false) -{ - if (zero) { - // FIXME: duplicate memset - memset(data_->raw(), 0, BlockSize); - dirty_ = true; // redundant? - } else { - io_->read_buffer(location_, *data_); - validator_->check(*data_, location_); - } -} - -template -block_manager::block::~block() -{ - flush(); -} - -template -void -block_manager::block::flush() -{ - if (dirty_) { - validator_->prepare(*data_, location_); - io_->write_buffer(location_, *data_); - dirty_ = false; - } -} - -template -void -block_manager::block::change_validator(typename block_manager::validator::ptr v, - bool check) -{ - if (v.get() != validator_.get()) { - if (dirty_) - // It may have already happened, by calling - // this we ensure we're consistent. - validator_->prepare(*data_, location_); - - validator_ = v; - - if (check) + template + block_manager::block::block(typename block_io::ptr io, + block_address location, + block_type bt, + typename validator::ptr v, + bool zero) + : io_(io), + location_(location), + data_(new buffer()), + validator_(v), + bt_(bt), + dirty_(false) + { + if (zero) { + // FIXME: duplicate memset + memset(data_->raw(), 0, BlockSize); + dirty_ = true; // redundant? + } else { + io_->read_buffer(location_, *data_); validator_->check(*data_, location_); + } + } + + template + block_manager::block::~block() + { + flush(); + } + + template + void + block_manager::block::flush() + { + if (dirty_) { + validator_->prepare(*data_, location_); + io_->write_buffer(location_, *data_); + dirty_ = false; + } + } + + template + void + block_manager::block::change_validator(typename block_manager::validator::ptr v, + bool check) + { + if (v.get() != validator_.get()) { + if (dirty_) + // It may have already happened, by calling + // this we ensure we're consistent. + validator_->prepare(*data_, location_); + + validator_ = v; + + if (check) + validator_->check(*data_, location_); + } } -} //---------------------------------------------------------------- -template -block_manager::read_ref::read_ref(block_manager const &bm, - typename block::ptr b) - : bm_(&bm), - block_(b), - holders_(new unsigned) -{ - *holders_ = 1; -} - -template -block_manager::read_ref::read_ref(read_ref const &rhs) - : bm_(rhs.bm_), - block_(rhs.block_), - holders_(rhs.holders_) -{ - (*holders_)++; -} - -template -block_manager::read_ref::~read_ref() -{ - if (!--(*holders_)) { - if (block_->bt_ == BT_SUPERBLOCK) { - bm_->flush(); - bm_->cache_.put(block_); - bm_->flush(); - } else - bm_->cache_.put(block_); - - bm_->tracker_.unlock(block_->location_); - delete holders_; + template + block_manager::read_ref::read_ref(block_manager const &bm, + typename block::ptr b) + : bm_(&bm), + block_(b), + holders_(new unsigned) + { + *holders_ = 1; } -} -template -typename block_manager::read_ref const & -block_manager::read_ref::operator =(read_ref const &rhs) -{ - if (this != &rhs) { - block_ = rhs.block_; - bm_ = rhs.bm_; - holders_ = rhs.holders_; + template + block_manager::read_ref::read_ref(read_ref const &rhs) + : bm_(rhs.bm_), + block_(rhs.block_), + holders_(rhs.holders_) + { (*holders_)++; } - return *this; -} + template + block_manager::read_ref::~read_ref() + { + if (!--(*holders_)) { + if (block_->bt_ == BT_SUPERBLOCK) { + bm_->flush(); + bm_->cache_.put(block_); + bm_->flush(); + } else + bm_->cache_.put(block_); -template -block_address -block_manager::read_ref::get_location() const -{ - return block_->location_; -} + bm_->tracker_.unlock(block_->location_); + delete holders_; + } + } -template -buffer const & -block_manager::read_ref::data() const -{ - return *block_->data_; -} + template + typename block_manager::read_ref const & + block_manager::read_ref::operator =(read_ref const &rhs) + { + if (this != &rhs) { + block_ = rhs.block_; + bm_ = rhs.bm_; + holders_ = rhs.holders_; + (*holders_)++; + } + + return *this; + } + + template + block_address + block_manager::read_ref::get_location() const + { + return block_->location_; + } + + template + buffer const & + block_manager::read_ref::data() const + { + return *block_->data_; + } //-------------------------------- -template -block_manager::write_ref::write_ref(block_manager const &bm, - typename block::ptr b) - : read_ref(bm, b) -{ - b->dirty_ = true; -} + template + block_manager::write_ref::write_ref(block_manager const &bm, + typename block::ptr b) + : read_ref(bm, b) + { + b->dirty_ = true; + } -template -buffer & -block_manager::write_ref::data() -{ - return *read_ref::block_->data_; -} + template + buffer & + block_manager::write_ref::data() + { + return *read_ref::block_->data_; + } //---------------------------------------------------------------- -template -block_manager::block_manager(std::string const &path, - block_address nr_blocks, - unsigned max_concurrent_blocks, - typename block_io::mode mode) - : io_(new block_io(path, nr_blocks, mode)), - cache_(max(1024u, max_concurrent_blocks)), - tracker_(0, nr_blocks) -{ -} - -template -typename block_manager::read_ref -block_manager::read_lock(block_address location, - typename block_manager::validator::ptr v) const -{ - tracker_.read_lock(location); - try { - check(location); - boost::optional cached_block = cache_.get(location); - - if (cached_block) { - typename block::ptr cb = *cached_block; - cb->check_read_lockable(); - cb->change_validator(v); - - return read_ref(*this, *cached_block); - } - - typename block::ptr b(new block(io_, location, BT_NORMAL, v)); - cache_.insert(b); - return read_ref(*this, b); - - } catch (...) { - tracker_.unlock(location); - throw; - } -} - -template -typename block_manager::write_ref -block_manager::write_lock(block_address location, - typename block_manager::validator::ptr v) -{ - tracker_.write_lock(location); - try { - check(location); - - boost::optional cached_block = cache_.get(location); - - if (cached_block) { - typename block::ptr cb = *cached_block; - cb->check_write_lockable(); - cb->change_validator(v); - - return write_ref(*this, *cached_block); - } - - typename block::ptr b(new block(io_, location, BT_NORMAL, v)); - cache_.insert(b); - return write_ref(*this, b); - - } catch (...) { - tracker_.unlock(location); - throw; + template + block_manager::block_manager(std::string const &path, + block_address nr_blocks, + unsigned max_concurrent_blocks, + typename block_io::mode mode) + : io_(new block_io(path, nr_blocks, mode)), + cache_(max(1024u, max_concurrent_blocks)), + tracker_(0, nr_blocks) + { } -} + template + typename block_manager::read_ref + block_manager::read_lock(block_address location, + typename block_manager::validator::ptr v) const + { + tracker_.read_lock(location); + try { + check(location); + boost::optional cached_block = cache_.get(location); -template -typename block_manager::write_ref -block_manager::write_lock_zero(block_address location, - typename block_manager::validator::ptr v) -{ - tracker_.write_lock(location); - try { - check(location); + if (cached_block) { + typename block::ptr cb = *cached_block; + cb->check_read_lockable(); + cb->change_validator(v); - boost::optional cached_block = cache_.get(location); - if (cached_block) { - typename block::ptr cb = *cached_block; - cb->check_write_lockable(); - cb->change_validator(v, false); - memset((*cached_block)->data_->raw(), 0, BlockSize); + return read_ref(*this, *cached_block); + } - return write_ref(*this, *cached_block); + typename block::ptr b(new block(io_, location, BT_NORMAL, v)); + cache_.insert(b); + return read_ref(*this, b); + + } catch (...) { + tracker_.unlock(location); + throw; + } + } + + template + typename block_manager::write_ref + block_manager::write_lock(block_address location, + typename block_manager::validator::ptr v) + { + tracker_.write_lock(location); + try { + check(location); + + boost::optional cached_block = cache_.get(location); + + if (cached_block) { + typename block::ptr cb = *cached_block; + cb->check_write_lockable(); + cb->change_validator(v); + + return write_ref(*this, *cached_block); + } + + typename block::ptr b(new block(io_, location, BT_NORMAL, v)); + cache_.insert(b); + return write_ref(*this, b); + + } catch (...) { + tracker_.unlock(location); + throw; } - typename block::ptr b(new block(io_, location, BT_NORMAL, v, true)); - cache_.insert(b); - return write_ref(*this, b); - - } catch (...) { - tracker_.unlock(location); - throw; } -} -template -typename block_manager::write_ref -block_manager::superblock(block_address location, - typename block_manager::validator::ptr v) -{ - tracker_.superblock_lock(location); - try { - check(location); + template + typename block_manager::write_ref + block_manager::write_lock_zero(block_address location, + typename block_manager::validator::ptr v) + { + tracker_.write_lock(location); + try { + check(location); - boost::optional cached_block = cache_.get(location); + boost::optional cached_block = cache_.get(location); + if (cached_block) { + typename block::ptr cb = *cached_block; + cb->check_write_lockable(); + cb->change_validator(v, false); + memset((*cached_block)->data_->raw(), 0, BlockSize); - if (cached_block) { - typename block::ptr cb = *cached_block; - cb->check_write_lockable(); - cb->bt_ = BT_SUPERBLOCK; - cb->change_validator(v); + return write_ref(*this, *cached_block); + } - return write_ref(*this, *cached_block); + typename block::ptr b(new block(io_, location, BT_NORMAL, v, true)); + cache_.insert(b); + return write_ref(*this, b); + + } catch (...) { + tracker_.unlock(location); + throw; } - - typename block::ptr b(new block(io_, location, BT_SUPERBLOCK, v)); - cache_.insert(b); - return write_ref(*this, b); - - } catch (...) { - tracker_.unlock(location); - throw; } -} -template -typename block_manager::write_ref -block_manager::superblock_zero(block_address location, - typename block_manager::validator::ptr v) -{ - tracker_.superblock_lock(location); - try { - check(location); + template + typename block_manager::write_ref + block_manager::superblock(block_address location, + typename block_manager::validator::ptr v) + { + tracker_.superblock_lock(location); + try { + check(location); - boost::optional cached_block = cache_.get(location); + boost::optional cached_block = cache_.get(location); - if (cached_block) { - typename block::ptr cb = *cached_block; - cb->check_write_lockable(); - cb->bt_ = BT_SUPERBLOCK; - cb->change_validator(v, false); - memset(cb->data_->raw(), 0, BlockSize); // FIXME: add a zero method to buffer + if (cached_block) { + typename block::ptr cb = *cached_block; + cb->check_write_lockable(); + cb->bt_ = BT_SUPERBLOCK; + cb->change_validator(v); - return write_ref(*this, *cached_block); + return write_ref(*this, *cached_block); + } + + typename block::ptr b(new block(io_, location, BT_SUPERBLOCK, v)); + cache_.insert(b); + return write_ref(*this, b); + + } catch (...) { + tracker_.unlock(location); + throw; } - - typename block::ptr b(new block(io_, location, BT_SUPERBLOCK, v, true)); - cache_.insert(b); - return write_ref(*this, b); - - } catch (...) { - tracker_.unlock(location); - throw; } -} -template -void -block_manager::check(block_address b) const -{ - if (b >= io_->get_nr_blocks()) - throw std::runtime_error("block address out of bounds"); -} + template + typename block_manager::write_ref + block_manager::superblock_zero(block_address location, + typename block_manager::validator::ptr v) + { + tracker_.superblock_lock(location); + try { + check(location); -template -block_address -block_manager::get_nr_blocks() const -{ - return io_->get_nr_blocks(); -} + boost::optional cached_block = cache_.get(location); -template -void -block_manager::write_block(typename block::ptr b) const -{ - b->flush(); -} + if (cached_block) { + typename block::ptr cb = *cached_block; + cb->check_write_lockable(); + cb->bt_ = BT_SUPERBLOCK; + cb->change_validator(v, false); + memset(cb->data_->raw(), 0, BlockSize); // FIXME: add a zero method to buffer -template -void -block_manager::flush() const -{ - cache_.iterate_unheld( - boost::bind(&block_manager::write_block, this, _1)); -} + return write_ref(*this, *cached_block); + } -template -bool -block_manager::is_locked(block_address b) const -{ - return tracker_.is_locked(b); + typename block::ptr b(new block(io_, location, BT_SUPERBLOCK, v, true)); + cache_.insert(b); + return write_ref(*this, b); + + } catch (...) { + tracker_.unlock(location); + throw; + } + } + + template + void + block_manager::check(block_address b) const + { + if (b >= io_->get_nr_blocks()) + throw std::runtime_error("block address out of bounds"); + } + + template + block_address + block_manager::get_nr_blocks() const + { + return io_->get_nr_blocks(); + } + + template + void + block_manager::write_block(typename block::ptr b) const + { + b->flush(); + } + + template + void + block_manager::flush() const + { + cache_.iterate_unheld( + boost::bind(&block_manager::write_block, this, _1)); + } + + template + bool + block_manager::is_locked(block_address b) const + { + return tracker_.is_locked(b); + } } //---------------------------------------------------------------- diff --git a/persistent-data/data-structures/btree.h b/persistent-data/data-structures/btree.h index e0c5946..5c58108 100644 --- a/persistent-data/data-structures/btree.h +++ b/persistent-data/data-structures/btree.h @@ -380,7 +380,7 @@ namespace persistent_data { private: template - optional + boost::optional lookup_raw(btree_detail::ro_spine &spine, block_address block, uint64_t key) const; template diff --git a/persistent-data/data-structures/btree.tcc b/persistent-data/data-structures/btree.tcc index e5b4e9f..9fc61ad 100644 --- a/persistent-data/data-structures/btree.tcc +++ b/persistent-data/data-structures/btree.tcc @@ -24,9 +24,10 @@ #include +// FIXME: remove using namespace base; -using namespace btree_detail; using namespace persistent_data; +using namespace btree_detail; using namespace std; //---------------------------------------------------------------- diff --git a/persistent-data/space-maps/careful_alloc.cc b/persistent-data/space-maps/careful_alloc.cc index c95cceb..ae35ec2 100644 --- a/persistent-data/space-maps/careful_alloc.cc +++ b/persistent-data/space-maps/careful_alloc.cc @@ -22,6 +22,8 @@ //---------------------------------------------------------------- namespace { + using namespace persistent_data; + class sm_careful_alloc : public checked_space_map { public: typedef std::shared_ptr ptr; diff --git a/thin-provisioning/file_utils.cc b/thin-provisioning/file_utils.cc index d3d4dfd..4110ff2 100644 --- a/thin-provisioning/file_utils.cc +++ b/thin-provisioning/file_utils.cc @@ -11,9 +11,11 @@ using namespace base; //---------------------------------------------------------------- -block_address +persistent_data::block_address thin_provisioning::get_nr_blocks(string const &path) { + using namespace persistent_data; + struct stat info; block_address nr_blocks; diff --git a/thin-provisioning/file_utils.h b/thin-provisioning/file_utils.h index 4c8eee0..9990032 100644 --- a/thin-provisioning/file_utils.h +++ b/thin-provisioning/file_utils.h @@ -6,7 +6,7 @@ //---------------------------------------------------------------- namespace thin_provisioning { - block_address get_nr_blocks(string const &path); + persistent_data::block_address get_nr_blocks(string const &path); } //---------------------------------------------------------------- diff --git a/thin-provisioning/superblock.h b/thin-provisioning/superblock.h index 6e47c26..e993497 100644 --- a/thin-provisioning/superblock.h +++ b/thin-provisioning/superblock.h @@ -120,10 +120,10 @@ namespace thin_provisioning { }; } - block_manager<>::validator::ptr superblock_validator(); + persistent_data::block_manager<>::validator::ptr superblock_validator(); - superblock_detail::superblock read_superblock(block_manager<>::ptr bm); - void check_superblock(block_manager<>::ptr bm, + superblock_detail::superblock read_superblock(persistent_data::block_manager<>::ptr bm); + void check_superblock(persistent_data::block_manager<>::ptr bm, superblock_detail::damage_visitor &visitor); } diff --git a/unit-tests/test_utils.cc b/unit-tests/test_utils.cc index e569b08..f551f91 100644 --- a/unit-tests/test_utils.cc +++ b/unit-tests/test_utils.cc @@ -2,6 +2,8 @@ #include "persistent-data/space-maps/core.h" +using namespace persistent_data; + //---------------------------------------------------------------- void test::zero_block(block_manager<>::ptr bm, block_address b) @@ -10,7 +12,8 @@ void test::zero_block(block_manager<>::ptr bm, block_address b) memset(&wr.data(), 0, sizeof(wr.data())); } -transaction_manager::ptr test::open_temporary_tm(block_manager<>::ptr bm) +transaction_manager::ptr +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 fa982a8..06ce41c 100644 --- a/unit-tests/test_utils.h +++ b/unit-tests/test_utils.h @@ -22,6 +22,8 @@ //---------------------------------------------------------------- namespace test { + using namespace persistent_data; + unsigned const MAX_HELD_LOCKS = 16; template