328 lines
8.7 KiB
C++
328 lines
8.7 KiB
C++
// Copyright (C) 2016 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 "gmock/gmock.h"
|
|
#include "block-cache/copier.h"
|
|
#include "test_utils.h"
|
|
|
|
#include <fcntl.h>
|
|
|
|
using namespace boost;
|
|
using namespace std;
|
|
using namespace test;
|
|
using namespace testing;
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
namespace {
|
|
unsigned const BLOCK_SIZE = 64u;
|
|
using wait_result = io_engine::wait_result;
|
|
|
|
ostream &operator <<(ostream &out, optional<wait_result> const &mwr) {
|
|
if (mwr) {
|
|
out << "Just[wait_result[" << mwr->first << ", " << mwr->second << "]]";
|
|
} else
|
|
out << "Nothing";
|
|
return out;
|
|
}
|
|
|
|
class io_engine_mock : public io_engine {
|
|
public:
|
|
MOCK_METHOD3(open_file, handle(string const &, mode, sharing));
|
|
MOCK_METHOD1(close_file, void(handle));
|
|
MOCK_METHOD6(issue_io, bool(handle, dir, sector_t, sector_t, void *, unsigned));
|
|
|
|
MOCK_METHOD0(wait, optional<wait_result>());
|
|
MOCK_METHOD1(wait, optional<wait_result>(unsigned &));
|
|
};
|
|
|
|
class CopierTests : public Test {
|
|
public:
|
|
CopierTests()
|
|
: src_file_("copy_src"),
|
|
dest_file_("copy_dest") {
|
|
}
|
|
|
|
unique_ptr<copier> make_copier() {
|
|
return make_copier(BLOCK_SIZE, 0, 0);
|
|
}
|
|
|
|
unique_ptr<copier> make_copier(sector_t block_size,
|
|
sector_t src_offset,
|
|
sector_t dest_offset) {
|
|
EXPECT_CALL(engine_, open_file(src_file_, io_engine::M_READ_ONLY, io_engine::EXCLUSIVE)).
|
|
WillOnce(Return(SRC_HANDLE));
|
|
EXPECT_CALL(engine_, open_file(dest_file_, io_engine::M_READ_WRITE, io_engine::EXCLUSIVE)).
|
|
WillOnce(Return(DEST_HANDLE));
|
|
|
|
EXPECT_CALL(engine_, close_file(SRC_HANDLE)).Times(1);
|
|
EXPECT_CALL(engine_, close_file(DEST_HANDLE)).Times(1);
|
|
|
|
return unique_ptr<copier>(new copier(engine_, src_file_,
|
|
dest_file_,
|
|
block_size, 1 * 1024 * 1024,
|
|
src_offset, dest_offset));
|
|
}
|
|
|
|
static optional<wait_result> make_wr(bool success, unsigned context) {
|
|
return optional<wait_result>(wait_result(success, context));
|
|
}
|
|
|
|
// issue a copy_op, and wait for its completion synchronously
|
|
void issue_successful_op(copier &c, copy_op &op, unsigned context) {
|
|
InSequence dummy;
|
|
|
|
unsigned nr_pending = c.nr_pending();
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ,
|
|
expected_src_sector(c, op.src_b),
|
|
expected_src_sector(c, op.src_e), _, context)).
|
|
WillOnce(Return(true));
|
|
c.issue(op);
|
|
|
|
ASSERT_TRUE(c.nr_pending() == nr_pending + 1);
|
|
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(true, context)));
|
|
|
|
EXPECT_CALL(engine_, issue_io(DEST_HANDLE, io_engine::D_WRITE,
|
|
expected_dest_sector(c, op.dest_b),
|
|
expected_dest_sector(c, op.dest_b + (op.src_e - op.src_b)),
|
|
_, context)).
|
|
WillOnce(Return(true));
|
|
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(true, context)));
|
|
|
|
auto mop = c.wait();
|
|
ASSERT_EQ(c.nr_pending(), nr_pending);
|
|
|
|
ASSERT_TRUE(mop->success());
|
|
}
|
|
|
|
unsigned const SRC_HANDLE = 10;
|
|
unsigned const DEST_HANDLE = 11;
|
|
|
|
StrictMock<io_engine_mock> engine_;
|
|
|
|
private:
|
|
sector_t expected_src_sector(const copier &c, block_address b) {
|
|
return c.get_src_offset() + b * c.get_block_size();
|
|
}
|
|
|
|
sector_t expected_dest_sector(const copier &c, block_address b) {
|
|
return c.get_dest_offset() + b * c.get_block_size();
|
|
}
|
|
|
|
string src_file_;
|
|
string dest_file_;
|
|
};
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
TEST_F(CopierTests, create_default_copier)
|
|
{
|
|
auto c = make_copier();
|
|
ASSERT_EQ(c->get_block_size(), BLOCK_SIZE);
|
|
ASSERT_EQ(c->get_src_offset(), 0u);
|
|
ASSERT_EQ(c->get_dest_offset(), 0u);
|
|
}
|
|
|
|
TEST_F(CopierTests, create_copier_with_offsets)
|
|
{
|
|
sector_t src_offset = 2048;
|
|
sector_t dest_offset = 8192;
|
|
|
|
auto c = make_copier(BLOCK_SIZE, src_offset, dest_offset);
|
|
ASSERT_EQ(c->get_block_size(), BLOCK_SIZE);
|
|
ASSERT_EQ(c->get_src_offset(), src_offset);
|
|
ASSERT_EQ(c->get_dest_offset(), dest_offset);
|
|
}
|
|
|
|
TEST_F(CopierTests, successful_copy)
|
|
{
|
|
// Copy first block
|
|
copy_op op1(0, 1, 0);
|
|
|
|
auto c = make_copier();
|
|
issue_successful_op(*c, op1, 0);
|
|
}
|
|
|
|
TEST_F(CopierTests, successful_copy_with_offsets)
|
|
{
|
|
copy_op op1(0, 1, 0);
|
|
|
|
auto c = make_copier(BLOCK_SIZE, 2048, 8192);
|
|
issue_successful_op(*c, op1, 0);
|
|
}
|
|
|
|
// Verify copier's error handling against unsucessful engine operations
|
|
// at different stages.
|
|
// Test the first stage (issue_read (failed) => read => issue_write => write)
|
|
TEST_F(CopierTests, unsuccessful_issue_read)
|
|
{
|
|
copy_op op1(0, 1, 0);
|
|
auto c = make_copier();
|
|
|
|
InSequence dummy;
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(false));
|
|
c->issue(op1);
|
|
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
auto mop = c->wait();
|
|
ASSERT_EQ(c->nr_pending(), 0u);
|
|
ASSERT_FALSE(mop->success());
|
|
}
|
|
|
|
// Test the second stage (issue_read => read (failed) => issue_write => write)
|
|
TEST_F(CopierTests, unsuccessful_read)
|
|
{
|
|
copy_op op1(0, 1, 0);
|
|
auto c = make_copier();
|
|
|
|
InSequence dummy;
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
c->issue(op1);
|
|
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(false, 0u)));
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
auto mop = c->wait();
|
|
ASSERT_EQ(c->nr_pending(), 0u);
|
|
ASSERT_FALSE(mop->success());
|
|
}
|
|
|
|
// Test the third stage (issue_read => read => issue_write (failed) => write)
|
|
TEST_F(CopierTests, unsuccessful_issue_write)
|
|
{
|
|
copy_op op1(0, 1, 0);
|
|
auto c = make_copier();
|
|
|
|
InSequence dummy;
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
c->issue(op1);
|
|
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(true, 0u)));
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
EXPECT_CALL(engine_, issue_io(DEST_HANDLE, io_engine::D_WRITE, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(false));
|
|
|
|
auto mop = c->wait();
|
|
ASSERT_EQ(c->nr_pending(), 0u);
|
|
ASSERT_FALSE(mop->success());
|
|
}
|
|
|
|
// Test the last stage (issue_read => read => issue_write => write (failed))
|
|
TEST_F(CopierTests, unsuccessful_write)
|
|
{
|
|
// Copy first block
|
|
copy_op op1(0, 1, 0);
|
|
|
|
auto c = make_copier();
|
|
|
|
InSequence dummy;
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
c->issue(op1);
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(true, 0u)));
|
|
|
|
EXPECT_CALL(engine_, issue_io(DEST_HANDLE, io_engine::D_WRITE, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
|
|
EXPECT_CALL(engine_, wait()).
|
|
WillOnce(Return(make_wr(false, 0u)));
|
|
|
|
auto mop = c->wait();
|
|
ASSERT_EQ(c->nr_pending(), 0u);
|
|
|
|
ASSERT_FALSE(mop->success());
|
|
}
|
|
|
|
TEST_F(CopierTests, copy_the_same_block_many_times)
|
|
{
|
|
auto c = make_copier();
|
|
copy_op op1(0, 1, 0);
|
|
|
|
for (unsigned i = 0; i < 50000; i++)
|
|
issue_successful_op(*c, op1, i);
|
|
}
|
|
|
|
TEST_F(CopierTests, copy_different_blocks)
|
|
{
|
|
auto c = make_copier();
|
|
for (unsigned i = 0; i < 5000; i++) {
|
|
copy_op op(i, i + 1, i);
|
|
issue_successful_op(*c, op, i);
|
|
}
|
|
}
|
|
|
|
TEST_F(CopierTests, copy_different_blocks_with_offsets)
|
|
{
|
|
sector_t src_offset = 2048;
|
|
sector_t dest_offset = 8192;
|
|
|
|
auto c = make_copier(BLOCK_SIZE, src_offset, dest_offset);
|
|
for (unsigned i = 0; i < 5000; i++) {
|
|
copy_op op(i, i + 1, i);
|
|
issue_successful_op(*c, op, i);
|
|
}
|
|
}
|
|
|
|
TEST_F(CopierTests, wait_can_timeout)
|
|
{
|
|
copy_op op1(0, 1, 0);
|
|
auto c = make_copier();
|
|
|
|
InSequence dummy;
|
|
EXPECT_CALL(engine_, issue_io(SRC_HANDLE, io_engine::D_READ, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
c->issue(op1);
|
|
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
unsigned micro = 10000;
|
|
EXPECT_CALL(engine_, wait(micro)).
|
|
WillOnce(Return(make_wr(true, 0u)));
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
|
|
EXPECT_CALL(engine_, issue_io(DEST_HANDLE, io_engine::D_WRITE, 0, BLOCK_SIZE, _, 0)).
|
|
WillOnce(Return(true));
|
|
|
|
EXPECT_CALL(engine_, wait(micro)).
|
|
WillOnce(DoAll(SetArgReferee<0>(0u), Return(optional<wait_result>())));
|
|
|
|
auto mop = c->wait(micro);
|
|
ASSERT_FALSE(mop);
|
|
ASSERT_EQ(c->nr_pending(), 1u);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|