[ceph.git] / ceph / src / test / librbd / object_map / test_mock_RefreshRequest.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include "test/librbd/test_mock_fixture.h"
#include "test/librbd/test_support.h"
#include "test/librbd/mock/MockImageCtx.h"
#include "test/librbd/object_map/mock/MockInvalidateRequest.h"
#include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
#include "common/bit_vector.hpp"
#include "librbd/ObjectMap.h"
#include "librbd/object_map/RefreshRequest.h"
#include "librbd/object_map/LockRequest.h"

namespace librbd {

namespace {

struct MockObjectMapImageCtx : public MockImageCtx {
  MockObjectMapImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) {
  }
};

} // anonymous namespace

namespace object_map {

template <>
class LockRequest<MockObjectMapImageCtx> {
public:
  static LockRequest *s_instance;
  static LockRequest *create(MockObjectMapImageCtx &image_ctx, Context *on_finish) {
    ceph_assert(s_instance != nullptr);
    s_instance->on_finish = on_finish;
    return s_instance;
  }

  Context *on_finish = nullptr;

  LockRequest() {
    s_instance = this;
  }

  MOCK_METHOD0(send, void());
};

template<>
struct InvalidateRequest<MockObjectMapImageCtx> :
    public MockInvalidateRequestBase<MockObjectMapImageCtx> {
};

LockRequest<MockObjectMapImageCtx> *LockRequest<MockObjectMapImageCtx>::s_instance = nullptr;

} // namespace object_map
} // namespace librbd

// template definitions
#include "librbd/object_map/RefreshRequest.cc"
#include "librbd/object_map/LockRequest.cc"

namespace librbd {
namespace object_map {

using ::testing::_;
using ::testing::DoAll;
using ::testing::DoDefault;
using ::testing::InSequence;
using ::testing::Return;
using ::testing::StrEq;
using ::testing::WithArg;

class TestMockObjectMapRefreshRequest : public TestMockFixture {
public:
  static const uint64_t TEST_SNAP_ID = 123;

  typedef RefreshRequest<MockObjectMapImageCtx> MockRefreshRequest;
  typedef LockRequest<MockObjectMapImageCtx> MockLockRequest;
  typedef InvalidateRequest<MockObjectMapImageCtx> MockInvalidateRequest;

  void expect_object_map_lock(MockObjectMapImageCtx &mock_image_ctx,
                              MockLockRequest &mock_lock_request) {
    EXPECT_CALL(mock_lock_request, send())
                  .WillOnce(FinishRequest(&mock_lock_request, 0,
                                          &mock_image_ctx));
  }

  void expect_object_map_load(MockObjectMapImageCtx &mock_image_ctx,
                              ceph::BitVector<2> *object_map, uint64_t snap_id,
                              int r) {
    std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id, snap_id));
    auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
                               exec(oid, _, StrEq("rbd"), StrEq("object_map_load"), _, _, _));
    if (r < 0) {
      expect.WillOnce(Return(r));
    } else {
      ceph_assert(object_map);
      object_map->set_crc_enabled(false);

      bufferlist bl;
      encode(*object_map, bl);

      std::string str(bl.c_str(), bl.length());
      expect.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(str)), Return(0)));
    }
  }

  void expect_get_image_size(MockObjectMapImageCtx &mock_image_ctx, uint64_t snap_id,
                             uint64_t size) {
    EXPECT_CALL(mock_image_ctx, get_image_size(snap_id))
                  .WillOnce(Return(size));
  }

  void expect_invalidate_request(MockObjectMapImageCtx &mock_image_ctx,
                                 MockInvalidateRequest &invalidate_request,
                                 int r) {
    EXPECT_CALL(invalidate_request, send())
                  .WillOnce(FinishRequest(&invalidate_request, r,
                                          &mock_image_ctx));
  }

  void expect_truncate_request(MockObjectMapImageCtx &mock_image_ctx) {
    std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
                                                 TEST_SNAP_ID));
    EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), truncate(oid, 0, _))
                  .WillOnce(Return(0));
  }

  void expect_object_map_resize(MockObjectMapImageCtx &mock_image_ctx,
                                uint64_t num_objects, int r) {
    std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
                                                 TEST_SNAP_ID));
    auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
                               exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _, _));
    expect.WillOnce(Return(r));
  }

  void init_object_map(MockObjectMapImageCtx &mock_image_ctx,
                       ceph::BitVector<2> *object_map) {
    uint64_t num_objs = Striper::get_num_objects(
      mock_image_ctx.layout, mock_image_ctx.image_ctx->size);
    object_map->resize(num_objs);
    for (uint64_t i = 0; i < num_objs; ++i) {
      (*object_map)[i] = rand() % 3;
    }
  }
};

TEST_F(TestMockObjectMapRefreshRequest, SuccessHead) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockLockRequest mock_lock_request;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, CEPH_NOSNAP, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_lock(mock_image_ctx, mock_lock_request);
  expect_object_map_load(mock_image_ctx, &on_disk_object_map, CEPH_NOSNAP, 0);
  expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
                        mock_image_ctx.image_ctx->size);
  req->send();
  ASSERT_EQ(0, ctx.wait());

  ASSERT_EQ(on_disk_object_map, object_map);
}

TEST_F(TestMockObjectMapRefreshRequest, SuccessSnapshot) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, &on_disk_object_map, TEST_SNAP_ID, 0);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  req->send();
  ASSERT_EQ(0, ctx.wait());

  ASSERT_EQ(on_disk_object_map, object_map);
}

TEST_F(TestMockObjectMapRefreshRequest, LoadError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -ENOENT);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(0, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, LoadInvalidateError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -ENOENT);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, -EPERM);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(-EPERM, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, LoadCorrupt) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -EINVAL);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
  expect_truncate_request(mock_image_ctx);
  expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(0, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, TooSmall) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  ceph::BitVector<2> small_object_map;

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
  expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(0, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, TooSmallInvalidateError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  ceph::BitVector<2> small_object_map;

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, -EPERM);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(-EPERM, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, TooLarge) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  ceph::BitVector<2> large_object_map;
  large_object_map.resize(on_disk_object_map.size() * 2);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, &large_object_map, TEST_SNAP_ID, 0);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  req->send();
  ASSERT_EQ(0, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, ResizeError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  ceph::BitVector<2> small_object_map;

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);
  expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
  expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), -ESTALE);
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        mock_image_ctx.image_ctx->size);

  req->send();
  ASSERT_EQ(0, ctx.wait());
}

TEST_F(TestMockObjectMapRefreshRequest, LargeImageError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));

  MockObjectMapImageCtx mock_image_ctx(*ictx);

  ceph::BitVector<2> on_disk_object_map;
  init_object_map(mock_image_ctx, &on_disk_object_map);

  C_SaferCond ctx;
  ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  ceph::BitVector<2> object_map;
  MockRefreshRequest *req = new MockRefreshRequest(
    mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);

  InSequence seq;
  expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
                        std::numeric_limits<int64_t>::max());

  MockInvalidateRequest invalidate_request;
  expect_invalidate_request(mock_image_ctx, invalidate_request, 0);

  req->send();
  ASSERT_EQ(-EFBIG, ctx.wait());
}

} // namespace object_map
} // namespace librbd
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3
	4	#include "test/librbd/test_mock_fixture.h"
	5	#include "test/librbd/test_support.h"
	6	#include "test/librbd/mock/MockImageCtx.h"
	7	#include "test/librbd/object_map/mock/MockInvalidateRequest.h"
	8	#include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
	9	#include "common/bit_vector.hpp"
	10	#include "librbd/ObjectMap.h"
	11	#include "librbd/object_map/RefreshRequest.h"
	12	#include "librbd/object_map/LockRequest.h"
	13
	14	namespace librbd {
	15
	16	namespace {
	17
	18	struct MockObjectMapImageCtx : public MockImageCtx {
	19	MockObjectMapImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) {
	20	}
	21	};
	22
	23	} // anonymous namespace
	24
	25	namespace object_map {
	26
	27	template <>
	28	class LockRequest<MockObjectMapImageCtx> {
	29	public:
	30	static LockRequest *s_instance;
	31	static LockRequest create(MockObjectMapImageCtx &image_ctx, Context on_finish) {
11fdf7f2	32	ceph_assert(s_instance != nullptr);
7c673cae FG	33	s_instance->on_finish = on_finish;
	34	return s_instance;
	35	}
	36
	37	Context *on_finish = nullptr;
	38
	39	LockRequest() {
	40	s_instance = this;
	41	}
	42
	43	MOCK_METHOD0(send, void());
	44	};
	45
	46	template<>
	47	struct InvalidateRequest<MockObjectMapImageCtx> :
	48	public MockInvalidateRequestBase<MockObjectMapImageCtx> {
	49	};
	50
	51	LockRequest<MockObjectMapImageCtx> *LockRequest<MockObjectMapImageCtx>::s_instance = nullptr;
	52
	53	} // namespace object_map
	54	} // namespace librbd
	55
	56	// template definitions
	57	#include "librbd/object_map/RefreshRequest.cc"
	58	#include "librbd/object_map/LockRequest.cc"
	59
	60	namespace librbd {
	61	namespace object_map {
	62
	63	using ::testing::_;
	64	using ::testing::DoAll;
	65	using ::testing::DoDefault;
	66	using ::testing::InSequence;
	67	using ::testing::Return;
	68	using ::testing::StrEq;
	69	using ::testing::WithArg;
	70
	71	class TestMockObjectMapRefreshRequest : public TestMockFixture {
	72	public:
	73	static const uint64_t TEST_SNAP_ID = 123;
	74
	75	typedef RefreshRequest<MockObjectMapImageCtx> MockRefreshRequest;
	76	typedef LockRequest<MockObjectMapImageCtx> MockLockRequest;
	77	typedef InvalidateRequest<MockObjectMapImageCtx> MockInvalidateRequest;
	78
	79	void expect_object_map_lock(MockObjectMapImageCtx &mock_image_ctx,
	80	MockLockRequest &mock_lock_request) {
	81	EXPECT_CALL(mock_lock_request, send())
	82	.WillOnce(FinishRequest(&mock_lock_request, 0,
	83	&mock_image_ctx));
	84	}
	85
	86	void expect_object_map_load(MockObjectMapImageCtx &mock_image_ctx,
	87	ceph::BitVector<2> *object_map, uint64_t snap_id,
	88	int r) {
	89	std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id, snap_id));
	90	auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
	91	exec(oid, _, StrEq("rbd"), StrEq("object_map_load"), _, _, _));
	92	if (r < 0) {
	93	expect.WillOnce(Return(r));
	94	} else {
11fdf7f2	95	ceph_assert(object_map);
7c673cae FG	96	object_map->set_crc_enabled(false);
	97
	98	bufferlist bl;
11fdf7f2	99	encode(*object_map, bl);
7c673cae FG	100
	101	std::string str(bl.c_str(), bl.length());
	102	expect.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(str)), Return(0)));
	103	}
	104	}
	105
	106	void expect_get_image_size(MockObjectMapImageCtx &mock_image_ctx, uint64_t snap_id,
	107	uint64_t size) {
	108	EXPECT_CALL(mock_image_ctx, get_image_size(snap_id))
	109	.WillOnce(Return(size));
	110	}
	111
	112	void expect_invalidate_request(MockObjectMapImageCtx &mock_image_ctx,
11fdf7f2 TL	113	MockInvalidateRequest &invalidate_request,
11fdf7f2 TL	114	int r) {
7c673cae	115	EXPECT_CALL(invalidate_request, send())
11fdf7f2	116	.WillOnce(FinishRequest(&invalidate_request, r,
7c673cae FG	117	&mock_image_ctx));
	118	}
	119
	120	void expect_truncate_request(MockObjectMapImageCtx &mock_image_ctx) {
	121	std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
	122	TEST_SNAP_ID));
	123	EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), truncate(oid, 0, _))
	124	.WillOnce(Return(0));
	125	}
	126
	127	void expect_object_map_resize(MockObjectMapImageCtx &mock_image_ctx,
	128	uint64_t num_objects, int r) {
	129	std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
	130	TEST_SNAP_ID));
	131	auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
	132	exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _, _));
	133	expect.WillOnce(Return(r));
	134	}
	135
	136	void init_object_map(MockObjectMapImageCtx &mock_image_ctx,
	137	ceph::BitVector<2> *object_map) {
	138	uint64_t num_objs = Striper::get_num_objects(
	139	mock_image_ctx.layout, mock_image_ctx.image_ctx->size);
	140	object_map->resize(num_objs);
	141	for (uint64_t i = 0; i < num_objs; ++i) {
	142	(*object_map)[i] = rand() % 3;
	143	}
	144	}
	145	};
	146
	147	TEST_F(TestMockObjectMapRefreshRequest, SuccessHead) {
	148	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	149
	150	librbd::ImageCtx *ictx;
	151	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	152
	153	MockObjectMapImageCtx mock_image_ctx(*ictx);
	154
	155	ceph::BitVector<2> on_disk_object_map;
	156	init_object_map(mock_image_ctx, &on_disk_object_map);
	157
	158	C_SaferCond ctx;
9f95a23c	159	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae FG	160	ceph::BitVector<2> object_map;
7c673cae FG	161	MockLockRequest mock_lock_request;
9f95a23c TL	162	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	163	mock_image_ctx, &object_map_lock, &object_map, CEPH_NOSNAP, &ctx);
7c673cae FG	164
	165	InSequence seq;
	166	expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
	167	mock_image_ctx.image_ctx->size);
	168	expect_object_map_lock(mock_image_ctx, mock_lock_request);
	169	expect_object_map_load(mock_image_ctx, &on_disk_object_map, CEPH_NOSNAP, 0);
	170	expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
	171	mock_image_ctx.image_ctx->size);
	172	req->send();
	173	ASSERT_EQ(0, ctx.wait());
	174
	175	ASSERT_EQ(on_disk_object_map, object_map);
	176	}
	177
	178	TEST_F(TestMockObjectMapRefreshRequest, SuccessSnapshot) {
	179	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	180
	181	librbd::ImageCtx *ictx;
	182	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	183
	184	MockObjectMapImageCtx mock_image_ctx(*ictx);
	185
	186	ceph::BitVector<2> on_disk_object_map;
	187	init_object_map(mock_image_ctx, &on_disk_object_map);
	188
	189	C_SaferCond ctx;
9f95a23c	190	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	191	ceph::BitVector<2> object_map;
9f95a23c TL	192	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	193	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	194
	195	InSequence seq;
	196	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	197	mock_image_ctx.image_ctx->size);
	198	expect_object_map_load(mock_image_ctx, &on_disk_object_map, TEST_SNAP_ID, 0);
	199	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	200	mock_image_ctx.image_ctx->size);
	201	req->send();
	202	ASSERT_EQ(0, ctx.wait());
	203
	204	ASSERT_EQ(on_disk_object_map, object_map);
	205	}
	206
	207	TEST_F(TestMockObjectMapRefreshRequest, LoadError) {
	208	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	209
	210	librbd::ImageCtx *ictx;
	211	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	212
	213	MockObjectMapImageCtx mock_image_ctx(*ictx);
	214
	215	ceph::BitVector<2> on_disk_object_map;
	216	init_object_map(mock_image_ctx, &on_disk_object_map);
	217
	218	C_SaferCond ctx;
9f95a23c	219	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	220	ceph::BitVector<2> object_map;
9f95a23c TL	221	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	222	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	223
	224	InSequence seq;
	225	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	226	mock_image_ctx.image_ctx->size);
	227	expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -ENOENT);
	228
	229	MockInvalidateRequest invalidate_request;
11fdf7f2	230	expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
7c673cae FG	231	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	232	mock_image_ctx.image_ctx->size);
	233
	234	req->send();
	235	ASSERT_EQ(0, ctx.wait());
	236	}
	237
11fdf7f2 TL	238	TEST_F(TestMockObjectMapRefreshRequest, LoadInvalidateError) {
	239	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	240
	241	librbd::ImageCtx *ictx;
	242	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	243
	244	MockObjectMapImageCtx mock_image_ctx(*ictx);
	245
	246	ceph::BitVector<2> on_disk_object_map;
	247	init_object_map(mock_image_ctx, &on_disk_object_map);
	248
	249	C_SaferCond ctx;
9f95a23c	250	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
11fdf7f2	251	ceph::BitVector<2> object_map;
9f95a23c TL	252	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	253	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
11fdf7f2 TL	254
	255	InSequence seq;
	256	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	257	mock_image_ctx.image_ctx->size);
	258	expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -ENOENT);
	259
	260	MockInvalidateRequest invalidate_request;
	261	expect_invalidate_request(mock_image_ctx, invalidate_request, -EPERM);
	262	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	263	mock_image_ctx.image_ctx->size);
	264
	265	req->send();
	266	ASSERT_EQ(-EPERM, ctx.wait());
	267	}
	268
7c673cae FG	269	TEST_F(TestMockObjectMapRefreshRequest, LoadCorrupt) {
	270	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	271
	272	librbd::ImageCtx *ictx;
	273	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	274
	275	MockObjectMapImageCtx mock_image_ctx(*ictx);
	276
	277	ceph::BitVector<2> on_disk_object_map;
	278	init_object_map(mock_image_ctx, &on_disk_object_map);
	279
	280	C_SaferCond ctx;
9f95a23c	281	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	282	ceph::BitVector<2> object_map;
9f95a23c TL	283	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	284	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	285
	286	InSequence seq;
	287	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	288	mock_image_ctx.image_ctx->size);
	289	expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -EINVAL);
	290
	291	MockInvalidateRequest invalidate_request;
11fdf7f2	292	expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
7c673cae FG	293	expect_truncate_request(mock_image_ctx);
	294	expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
	295	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	296	mock_image_ctx.image_ctx->size);
	297
	298	req->send();
	299	ASSERT_EQ(0, ctx.wait());
	300	}
	301
	302	TEST_F(TestMockObjectMapRefreshRequest, TooSmall) {
	303	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	304
	305	librbd::ImageCtx *ictx;
	306	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	307
	308	MockObjectMapImageCtx mock_image_ctx(*ictx);
	309
	310	ceph::BitVector<2> on_disk_object_map;
	311	init_object_map(mock_image_ctx, &on_disk_object_map);
	312
	313	ceph::BitVector<2> small_object_map;
	314
	315	C_SaferCond ctx;
9f95a23c	316	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	317	ceph::BitVector<2> object_map;
9f95a23c TL	318	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	319	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	320
	321	InSequence seq;
	322	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	323	mock_image_ctx.image_ctx->size);
	324	expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);
	325
	326	MockInvalidateRequest invalidate_request;
11fdf7f2	327	expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
7c673cae FG	328	expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
	329	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	330	mock_image_ctx.image_ctx->size);
	331
	332	req->send();
	333	ASSERT_EQ(0, ctx.wait());
	334	}
	335
11fdf7f2 TL	336	TEST_F(TestMockObjectMapRefreshRequest, TooSmallInvalidateError) {
	337	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	338
	339	librbd::ImageCtx *ictx;
	340	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	341
	342	MockObjectMapImageCtx mock_image_ctx(*ictx);
	343
	344	ceph::BitVector<2> on_disk_object_map;
	345	init_object_map(mock_image_ctx, &on_disk_object_map);
	346
	347	ceph::BitVector<2> small_object_map;
	348
	349	C_SaferCond ctx;
9f95a23c	350	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
11fdf7f2	351	ceph::BitVector<2> object_map;
9f95a23c TL	352	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	353	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
11fdf7f2 TL	354
	355	InSequence seq;
	356	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	357	mock_image_ctx.image_ctx->size);
	358	expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);
	359
	360	MockInvalidateRequest invalidate_request;
	361	expect_invalidate_request(mock_image_ctx, invalidate_request, -EPERM);
	362	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	363	mock_image_ctx.image_ctx->size);
	364
	365	req->send();
	366	ASSERT_EQ(-EPERM, ctx.wait());
	367	}
	368
7c673cae FG	369	TEST_F(TestMockObjectMapRefreshRequest, TooLarge) {
	370	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	371
	372	librbd::ImageCtx *ictx;
	373	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	374
	375	MockObjectMapImageCtx mock_image_ctx(*ictx);
	376
	377	ceph::BitVector<2> on_disk_object_map;
	378	init_object_map(mock_image_ctx, &on_disk_object_map);
	379
	380	ceph::BitVector<2> large_object_map;
	381	large_object_map.resize(on_disk_object_map.size() * 2);
	382
	383	C_SaferCond ctx;
9f95a23c	384	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	385	ceph::BitVector<2> object_map;
9f95a23c TL	386	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	387	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	388
	389	InSequence seq;
	390	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	391	mock_image_ctx.image_ctx->size);
	392	expect_object_map_load(mock_image_ctx, &large_object_map, TEST_SNAP_ID, 0);
	393	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	394	mock_image_ctx.image_ctx->size);
	395	req->send();
	396	ASSERT_EQ(0, ctx.wait());
	397	}
	398
	399	TEST_F(TestMockObjectMapRefreshRequest, ResizeError) {
	400	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	401
	402	librbd::ImageCtx *ictx;
	403	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	404
	405	MockObjectMapImageCtx mock_image_ctx(*ictx);
	406
	407	ceph::BitVector<2> on_disk_object_map;
	408	init_object_map(mock_image_ctx, &on_disk_object_map);
	409
	410	ceph::BitVector<2> small_object_map;
	411
	412	C_SaferCond ctx;
9f95a23c	413	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	414	ceph::BitVector<2> object_map;
9f95a23c TL	415	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	416	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	417
	418	InSequence seq;
	419	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	420	mock_image_ctx.image_ctx->size);
	421	expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);
	422
	423	MockInvalidateRequest invalidate_request;
11fdf7f2	424	expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
7c673cae FG	425	expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), -ESTALE);
	426	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	427	mock_image_ctx.image_ctx->size);
	428
	429	req->send();
	430	ASSERT_EQ(0, ctx.wait());
	431	}
	432
	433	TEST_F(TestMockObjectMapRefreshRequest, LargeImageError) {
	434	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	435
	436	librbd::ImageCtx *ictx;
	437	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	438
	439	MockObjectMapImageCtx mock_image_ctx(*ictx);
	440
	441	ceph::BitVector<2> on_disk_object_map;
	442	init_object_map(mock_image_ctx, &on_disk_object_map);
	443
	444	C_SaferCond ctx;
9f95a23c	445	ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
7c673cae	446	ceph::BitVector<2> object_map;
9f95a23c TL	447	MockRefreshRequest *req = new MockRefreshRequest(
9f95a23c TL	448	mock_image_ctx, &object_map_lock, &object_map, TEST_SNAP_ID, &ctx);
7c673cae FG	449
	450	InSequence seq;
	451	expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
	452	std::numeric_limits<int64_t>::max());
	453
	454	MockInvalidateRequest invalidate_request;
11fdf7f2	455	expect_invalidate_request(mock_image_ctx, invalidate_request, 0);
7c673cae FG	456
	457	req->send();
	458	ASSERT_EQ(-EFBIG, ctx.wait());
	459	}
	460
	461	} // namespace object_map
	462	} // namespace librbd
	463