[ceph.git] / ceph / src / test / librbd / object_map / test_mock_UpdateRequest.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/librados_test_stub/MockTestMemIoCtxImpl.h"
#include "common/bit_vector.hpp"
#include "librbd/ImageState.h"
#include "librbd/internal.h"
#include "librbd/ObjectMap.h"
#include "librbd/Operations.h"
#include "librbd/object_map/UpdateRequest.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

namespace librbd {
namespace object_map {

using ::testing::_;
using ::testing::DoDefault;
using ::testing::Return;
using ::testing::StrEq;

class TestMockObjectMapUpdateRequest : public TestMockFixture {
public:
  void expect_update(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
    std::string oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
    if (snap_id == CEPH_NOSNAP) {
      EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
                  exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _))
                    .WillOnce(DoDefault());
    }

    if (r < 0) {
      EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
                  exec(oid, _, StrEq("rbd"), StrEq("object_map_update"), _, _, _))
                    .WillOnce(Return(r));
    } else {
      EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
                  exec(oid, _, StrEq("rbd"), StrEq("object_map_update"), _, _, _))
                    .WillOnce(DoDefault());
    }
  }

  void expect_invalidate(librbd::ImageCtx *ictx) {
    EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
                exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
                  .WillOnce(DoDefault());
  }
};

TEST_F(TestMockObjectMapUpdateRequest, UpdateInMemory) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

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

  librbd::NoOpProgressContext no_progress;
  ASSERT_EQ(0, ictx->operations->resize(4 << ictx->order, true, no_progress));
  ASSERT_EQ(0, acquire_exclusive_lock(*ictx));

  ceph::BitVector<2> object_map;
  object_map.resize(4);
  for (uint64_t i = 0; i < object_map.size(); ++i) {
    object_map[i] = i % 4;
  }

  C_SaferCond cond_ctx;
  AsyncRequest<> *req = new UpdateRequest<>(
    *ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
    OBJECT_EXISTS, {}, &cond_ctx);
  {
    RWLock::RLocker snap_locker(ictx->snap_lock);
    RWLock::WLocker object_map_locker(ictx->object_map_lock);
    req->send();
  }
  ASSERT_EQ(0, cond_ctx.wait());

  for (uint64_t i = 0; i < object_map.size(); ++i) {
    if (i % 4 == OBJECT_EXISTS || i % 4 == OBJECT_EXISTS_CLEAN) {
      ASSERT_EQ(OBJECT_NONEXISTENT, object_map[i]);
    } else {
      ASSERT_EQ(i % 4, object_map[i]);
    }
  }
}

TEST_F(TestMockObjectMapUpdateRequest, UpdateHeadOnDisk) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

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

  expect_update(ictx, CEPH_NOSNAP, 0);

  ceph::BitVector<2> object_map;
  object_map.resize(1);

  C_SaferCond cond_ctx;
  AsyncRequest<> *req = new UpdateRequest<>(
    *ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
    OBJECT_EXISTS, {}, &cond_ctx);
  {
    RWLock::RLocker snap_locker(ictx->snap_lock);
    RWLock::WLocker object_map_locker(ictx->object_map_lock);
    req->send();
  }
  ASSERT_EQ(0, cond_ctx.wait());

  expect_unlock_exclusive_lock(*ictx);
}

TEST_F(TestMockObjectMapUpdateRequest, UpdateSnapOnDisk) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));
  ASSERT_EQ(0, snap_create(*ictx, "snap1"));
  ASSERT_EQ(0, librbd::snap_set(ictx,
				cls::rbd::UserSnapshotNamespace(),
				"snap1"));

  uint64_t snap_id = ictx->snap_id;
  expect_update(ictx, snap_id, 0);

  ceph::BitVector<2> object_map;
  object_map.resize(1);

  C_SaferCond cond_ctx;
  AsyncRequest<> *req = new UpdateRequest<>(
    *ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_NONEXISTENT,
    OBJECT_EXISTS, {}, &cond_ctx);
  {
    RWLock::RLocker snap_locker(ictx->snap_lock);
    RWLock::WLocker object_map_locker(ictx->object_map_lock);
    req->send();
  }
  ASSERT_EQ(0, cond_ctx.wait());

  expect_unlock_exclusive_lock(*ictx);
}

TEST_F(TestMockObjectMapUpdateRequest, UpdateOnDiskError) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

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

  expect_update(ictx, CEPH_NOSNAP, -EINVAL);
  expect_invalidate(ictx);

  ceph::BitVector<2> object_map;
  object_map.resize(1);

  C_SaferCond cond_ctx;
  AsyncRequest<> *req = new UpdateRequest<>(
    *ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
    OBJECT_EXISTS, {}, &cond_ctx);
  {
    RWLock::RLocker snap_locker(ictx->snap_lock);
    RWLock::WLocker object_map_locker(ictx->object_map_lock);
    req->send();
  }
  ASSERT_EQ(0, cond_ctx.wait());

  expect_unlock_exclusive_lock(*ictx);
}

TEST_F(TestMockObjectMapUpdateRequest, RebuildSnapOnDisk) {
  REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);

  librbd::ImageCtx *ictx;
  ASSERT_EQ(0, open_image(m_image_name, &ictx));
  ASSERT_EQ(0, snap_create(*ictx, "snap1"));
  ASSERT_EQ(0, ictx->state->refresh_if_required());
  ASSERT_EQ(CEPH_NOSNAP, ictx->snap_id);

  uint64_t snap_id = ictx->snap_info.rbegin()->first;
  expect_update(ictx, snap_id, 0);
  expect_unlock_exclusive_lock(*ictx);

  ceph::BitVector<2> object_map;
  object_map.resize(1);

  C_SaferCond cond_ctx;
  AsyncRequest<> *req = new UpdateRequest<>(
    *ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_EXISTS_CLEAN,
    boost::optional<uint8_t>(), {}, &cond_ctx);
  {
    RWLock::RLocker snap_locker(ictx->snap_lock);
    RWLock::WLocker object_map_locker(ictx->object_map_lock);
    req->send();
  }
  ASSERT_EQ(0, cond_ctx.wait());

  // do not update the in-memory map if rebuilding a snapshot
  ASSERT_NE(OBJECT_EXISTS_CLEAN, object_map[0]);
}

} // 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/librados_test_stub/MockTestMemIoCtxImpl.h"
	7	#include "common/bit_vector.hpp"
	8	#include "librbd/ImageState.h"
	9	#include "librbd/internal.h"
	10	#include "librbd/ObjectMap.h"
	11	#include "librbd/Operations.h"
	12	#include "librbd/object_map/UpdateRequest.h"
	13	#include "gmock/gmock.h"
	14	#include "gtest/gtest.h"
	15
	16	namespace librbd {
	17	namespace object_map {
	18
	19	using ::testing::_;
	20	using ::testing::DoDefault;
	21	using ::testing::Return;
	22	using ::testing::StrEq;
	23
	24	class TestMockObjectMapUpdateRequest : public TestMockFixture {
	25	public:
	26	void expect_update(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
	27	std::string oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
	28	if (snap_id == CEPH_NOSNAP) {
	29	EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
	30	exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _))
	31	.WillOnce(DoDefault());
	32	}
	33
	34	if (r < 0) {
	35	EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
	36	exec(oid, _, StrEq("rbd"), StrEq("object_map_update"), _, _, _))
	37	.WillOnce(Return(r));
	38	} else {
	39	EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
	40	exec(oid, _, StrEq("rbd"), StrEq("object_map_update"), _, _, _))
	41	.WillOnce(DoDefault());
	42	}
	43	}
	44
	45	void expect_invalidate(librbd::ImageCtx *ictx) {
	46	EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
	47	exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
	48	.WillOnce(DoDefault());
	49	}
	50	};
	51
	52	TEST_F(TestMockObjectMapUpdateRequest, UpdateInMemory) {
	53	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	54
	55	librbd::ImageCtx *ictx;
	56	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	57
	58	librbd::NoOpProgressContext no_progress;
	59	ASSERT_EQ(0, ictx->operations->resize(4 << ictx->order, true, no_progress));
	60	ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
	61
	62	ceph::BitVector<2> object_map;
	63	object_map.resize(4);
	64	for (uint64_t i = 0; i < object_map.size(); ++i) {
65	object_map[i] = i % 4;
66	}
67
68	C_SaferCond cond_ctx;
69	AsyncRequest<> *req = new UpdateRequest<>(
70	*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
31f18b77	71	OBJECT_EXISTS, {}, &cond_ctx);
7c673cae FG	72	{
	73	RWLock::RLocker snap_locker(ictx->snap_lock);
	74	RWLock::WLocker object_map_locker(ictx->object_map_lock);
	75	req->send();
	76	}
	77	ASSERT_EQ(0, cond_ctx.wait());
	78
	79	for (uint64_t i = 0; i < object_map.size(); ++i) {
	80	if (i % 4 == OBJECT_EXISTS \|\| i % 4 == OBJECT_EXISTS_CLEAN) {
	81	ASSERT_EQ(OBJECT_NONEXISTENT, object_map[i]);
	82	} else {
	83	ASSERT_EQ(i % 4, object_map[i]);
	84	}
	85	}
	86	}
	87
	88	TEST_F(TestMockObjectMapUpdateRequest, UpdateHeadOnDisk) {
	89	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	90
	91	librbd::ImageCtx *ictx;
	92	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	93	ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
	94
	95	expect_update(ictx, CEPH_NOSNAP, 0);
	96
	97	ceph::BitVector<2> object_map;
	98	object_map.resize(1);
	99
	100	C_SaferCond cond_ctx;
	101	AsyncRequest<> *req = new UpdateRequest<>(
	102	*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
31f18b77	103	OBJECT_EXISTS, {}, &cond_ctx);
7c673cae FG	104	{
	105	RWLock::RLocker snap_locker(ictx->snap_lock);
	106	RWLock::WLocker object_map_locker(ictx->object_map_lock);
	107	req->send();
	108	}
	109	ASSERT_EQ(0, cond_ctx.wait());
	110
	111	expect_unlock_exclusive_lock(*ictx);
	112	}
	113
	114	TEST_F(TestMockObjectMapUpdateRequest, UpdateSnapOnDisk) {
	115	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	116
	117	librbd::ImageCtx *ictx;
	118	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	119	ASSERT_EQ(0, snap_create(*ictx, "snap1"));
	120	ASSERT_EQ(0, librbd::snap_set(ictx,
	121	cls::rbd::UserSnapshotNamespace(),
	122	"snap1"));
	123
	124	uint64_t snap_id = ictx->snap_id;
	125	expect_update(ictx, snap_id, 0);
	126
	127	ceph::BitVector<2> object_map;
	128	object_map.resize(1);
	129
	130	C_SaferCond cond_ctx;
	131	AsyncRequest<> *req = new UpdateRequest<>(
	132	*ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_NONEXISTENT,
31f18b77	133	OBJECT_EXISTS, {}, &cond_ctx);
7c673cae FG	134	{
	135	RWLock::RLocker snap_locker(ictx->snap_lock);
	136	RWLock::WLocker object_map_locker(ictx->object_map_lock);
	137	req->send();
	138	}
	139	ASSERT_EQ(0, cond_ctx.wait());
	140
	141	expect_unlock_exclusive_lock(*ictx);
	142	}
	143
	144	TEST_F(TestMockObjectMapUpdateRequest, UpdateOnDiskError) {
	145	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	146
	147	librbd::ImageCtx *ictx;
	148	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	149	ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
	150
	151	expect_update(ictx, CEPH_NOSNAP, -EINVAL);
	152	expect_invalidate(ictx);
	153
	154	ceph::BitVector<2> object_map;
	155	object_map.resize(1);
	156
	157	C_SaferCond cond_ctx;
	158	AsyncRequest<> *req = new UpdateRequest<>(
	159	*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
31f18b77	160	OBJECT_EXISTS, {}, &cond_ctx);
7c673cae FG	161	{
	162	RWLock::RLocker snap_locker(ictx->snap_lock);
	163	RWLock::WLocker object_map_locker(ictx->object_map_lock);
	164	req->send();
	165	}
	166	ASSERT_EQ(0, cond_ctx.wait());
	167
	168	expect_unlock_exclusive_lock(*ictx);
	169	}
	170
	171	TEST_F(TestMockObjectMapUpdateRequest, RebuildSnapOnDisk) {
	172	REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
	173
	174	librbd::ImageCtx *ictx;
	175	ASSERT_EQ(0, open_image(m_image_name, &ictx));
	176	ASSERT_EQ(0, snap_create(*ictx, "snap1"));
	177	ASSERT_EQ(0, ictx->state->refresh_if_required());
	178	ASSERT_EQ(CEPH_NOSNAP, ictx->snap_id);
	179
	180	uint64_t snap_id = ictx->snap_info.rbegin()->first;
	181	expect_update(ictx, snap_id, 0);
	182	expect_unlock_exclusive_lock(*ictx);
	183
	184	ceph::BitVector<2> object_map;
	185	object_map.resize(1);
	186
	187	C_SaferCond cond_ctx;
	188	AsyncRequest<> *req = new UpdateRequest<>(
	189	*ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_EXISTS_CLEAN,
31f18b77	190	boost::optional<uint8_t>(), {}, &cond_ctx);
7c673cae FG	191	{
	192	RWLock::RLocker snap_locker(ictx->snap_lock);
	193	RWLock::WLocker object_map_locker(ictx->object_map_lock);
	194	req->send();
	195	}
	196	ASSERT_EQ(0, cond_ctx.wait());
	197
	198	// do not update the in-memory map if rebuilding a snapshot
	199	ASSERT_NE(OBJECT_EXISTS_CLEAN, object_map[0]);
	200	}
	201
	202	} // namespace object_map
	203	} // namespace librbd