thin-provisioning-tools/thin-provisioning/thin_journal.cc
Joe Thornber de7c9a5781 [thin_journal_check] Checks journal of block manager activity.
You need to apply doc/bm-journal.patch to create the journal.

thin_journal_check confirms that if the machine had crashed at any time
during the test run no metadata corruption would have occured.
2018-09-24 14:51:46 +01:00

367 lines
6.7 KiB
C++

// Copyright (C) 2018 Red Hat, Inc. All rights reserved.
//
// This file is part of the thin-provisioning-tools source.
//
// thin-provisioning-tools is free software: you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// thin-provisioning-tools is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with thin-provisioning-tools. If not, see
// <http://www.gnu.org/licenses/>.
#include "thin-provisioning/thin_journal.h"
#include <algorithm>
using namespace thin_provisioning;
using namespace persistent_data;
using namespace std;
//----------------------------------------------------------------
byte_stream::byte_stream(block_manager<JOURNAL_BLOCK_SIZE>::ptr bm)
: bm_(bm),
current_block_(0),
cursor_(0)
{
}
void
byte_stream::read_bytes(uint8_t *b, uint8_t *e)
{
while (b != e)
b += read_some_(b, e);
assert(b == e);
}
void
byte_stream::next_block_()
{
current_block_++;
cursor_ = 0;
}
size_t
byte_stream::read_some_(uint8_t *b, uint8_t *e)
{
assert(cursor_ <= JOURNAL_BLOCK_SIZE);
if (cursor_ == JOURNAL_BLOCK_SIZE)
next_block_();
size_t len = min<uint64_t>(e - b, JOURNAL_BLOCK_SIZE - cursor_);
auto rr = bm_->read_lock(current_block_);
uint8_t const *data_begin = reinterpret_cast<uint8_t const *>(rr.data()) + cursor_;
memcpy(b, data_begin, len);
cursor_ += len;
return len;
}
//---------------------------------
journal_msg::journal_msg(bool success)
: success_(success)
{
}
open_journal_msg::open_journal_msg(uint64_t nr_metadata_blocks)
: journal_msg(true),
nr_metadata_blocks_(nr_metadata_blocks)
{
}
void
open_journal_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
close_journal_msg::close_journal_msg()
: journal_msg(true)
{
}
void
close_journal_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
block_msg::block_msg(bool success, uint64_t index)
: journal_msg(success), index_(index)
{
}
read_lock_msg::read_lock_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
read_lock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
write_lock_msg::write_lock_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
write_lock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
zero_lock_msg::zero_lock_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
zero_lock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
try_read_lock_msg::try_read_lock_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
try_read_lock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
unlock_msg::unlock_msg(bool success, uint64_t index, delta_list const &deltas)
: block_msg(success, index),
deltas_(deltas)
{
}
void
unlock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
verify_msg::verify_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
verify_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
prepare_msg::prepare_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
prepare_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
flush_msg::flush_msg(bool success)
: journal_msg(success)
{
}
void
flush_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
flush_and_unlock_msg::flush_and_unlock_msg(bool success, uint64_t index, delta_list const &deltas)
: block_msg(success, index),
deltas_(deltas)
{
}
void
flush_and_unlock_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
prefetch_msg::prefetch_msg(bool success, uint64_t index)
: block_msg(success, index)
{
}
void
prefetch_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
set_read_only_msg::set_read_only_msg()
: journal_msg(true)
{
}
void
set_read_only_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
set_read_write_msg::set_read_write_msg()
: journal_msg(true)
{
}
void
set_read_write_msg::visit(journal_visitor &v) const
{
v.visit(*this);
}
//------------------------------------------
journal::journal(block_manager<JOURNAL_BLOCK_SIZE>::ptr bm)
: in_(bm)
{
}
void
journal::read_journal(struct journal_visitor &v)
{
while (read_one_(v))
;
}
bool
journal::read_one_(struct journal_visitor &v)
{
uint8_t header = read_<uint8_t>();
uint8_t t = header >> 1;
uint8_t success = header & 0x1;
uint64_t index, nr_blocks;
switch (static_cast<msg_type>(t)) {
case MT_OPEN_JOURNAL:
nr_blocks = read_<uint64_t>();
v.visit(open_journal_msg(nr_blocks));
break;
case MT_CLOSE_JOURNAL:
v.visit(close_journal_msg());
return false;
case MT_READ_LOCK:
index = read_<uint64_t>();
v.visit(read_lock_msg(success, index));
break;
case MT_WRITE_LOCK:
index = read_<uint64_t>();
v.visit(write_lock_msg(success, index));
break;
case MT_ZERO_LOCK:
index = read_<uint64_t>();
v.visit(zero_lock_msg(success, index));
break;
case MT_TRY_READ_LOCK:
index = read_<uint64_t>();
v.visit(try_read_lock_msg(success, index));
break;
case MT_UNLOCK: {
index = read_<uint64_t>();
auto deltas = read_deltas_();
v.visit(unlock_msg(success, index, deltas));
}
break;
case MT_VERIFY:
index = read_<uint64_t>();
v.visit(verify_msg(success, index));
break;
case MT_PREPARE:
index = read_<uint64_t>();
v.visit(prepare_msg(success, index));
break;
case MT_FLUSH:
v.visit(flush_msg(success));
break;
case MT_FLUSH_AND_UNLOCK: {
cerr << "reading flush_and_unlock msg\n";
index = read_<uint64_t>();
auto deltas = read_deltas_();
v.visit(flush_and_unlock_msg(success, index, deltas));
}
break;
case MT_PREFETCH:
index = read_<uint64_t>();
v.visit(prefetch_msg(success, index));
break;
case MT_SET_READ_ONLY:
v.visit(set_read_only_msg());
break;
case MT_SET_READ_WRITE:
v.visit(set_read_write_msg());
break;
}
return true;
}
bool
journal::read_delta_(delta_list &ds)
{
uint16_t chunk = read_<uint16_t>();
if (chunk == 0xffff)
return false;
assert(chunk < JOURNAL_NR_CHUNKS);
auto bytes = vector<uint8_t>(JOURNAL_CHUNK_SIZE, 0);
in_.read_bytes(bytes.data(), bytes.data() + JOURNAL_CHUNK_SIZE);
ds.push_back(delta(chunk * JOURNAL_CHUNK_SIZE, bytes));
return true;
}
thin_provisioning::delta_list
journal::read_deltas_()
{
delta_list ds;
while (read_delta_(ds))
;
return ds;
}
//----------------------------------------------------------------