unittest_librbd_SOURCES = \
test/librbd/test_main.cc \
- test/librbd/test_mock_fixture.cc
+ test/librbd/test_mock_fixture.cc \
+ test/librbd/object_map/test_mock_InvalidateRequest.cc \
+ test/librbd/object_map/test_mock_ResizeRequest.cc \
+ test/librbd/object_map/test_mock_SnapshotCreateRequest.cc \
+ test/librbd/object_map/test_mock_SnapshotRemoveRequest.cc \
+ test/librbd/object_map/test_mock_SnapshotRollbackRequest.cc \
+ test/librbd/object_map/test_mock_UpdateRequest.cc
unittest_librbd_CXXFLAGS = $(UNITTEST_CXXFLAGS) -DTEST_LIBRBD_INTERNALS
unittest_librbd_LDADD = \
librbd_test.la librbd_api.la librbd_internal.la $(LIBRBD_TYPES) \
--- /dev/null
+// -*- 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 "librbd/internal.h"
+#include "librbd/object_map/InvalidateRequest.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace librbd {
+namespace object_map {
+
+using ::testing::_;
+using ::testing::DoDefault;
+using ::testing::Return;
+
+class TestMockObjectMapInvalidateRequest : public TestMockFixture {
+public:
+};
+
+TEST_F(TestMockObjectMapInvalidateRequest, UpdatesInMemoryFlag) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_FALSE(ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID));
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new InvalidateRequest(*ictx, CEPH_NOSNAP, false, &cond_ctx);
+
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .Times(0);
+
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ ASSERT_TRUE(ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID));
+}
+
+TEST_F(TestMockObjectMapInvalidateRequest, UpdatesHeadOnDiskFlag) {
+ 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));
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new InvalidateRequest(*ictx, CEPH_NOSNAP, false, &cond_ctx);
+
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(DoDefault());
+
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapInvalidateRequest, UpdatesSnapOnDiskFlag) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::snap_set(ictx, "snap1"));
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new InvalidateRequest(*ictx, ictx->snap_id, false,
+ &cond_ctx);
+
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .Times(0);
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(DoDefault());
+
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+}
+
+TEST_F(TestMockObjectMapInvalidateRequest, SkipOnDiskUpdateWithoutLock) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new InvalidateRequest(*ictx, CEPH_NOSNAP, false, &cond_ctx);
+
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .Times(0);
+
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapInvalidateRequest, IgnoresOnDiskUpdateFailure) {
+ 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));
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new InvalidateRequest(*ictx, CEPH_NOSNAP, false, &cond_ctx);
+
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(Return(-EINVAL));
+
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+} // namespace object_map
+} // namespace librbd
--- /dev/null
+// -*- 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/internal.h"
+#include "librbd/object_map/ResizeRequest.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace librbd {
+namespace object_map {
+
+using ::testing::_;
+using ::testing::DoDefault;
+using ::testing::Return;
+
+class TestMockObjectMapResizeRequest : public TestMockFixture {
+public:
+ void expect_resize(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, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ }
+
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_resize", _, _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_resize", _, _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_invalidate(librbd::ImageCtx *ictx) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _)).Times(0);
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(DoDefault());
+ }
+};
+
+TEST_F(TestMockObjectMapResizeRequest, UpdateInMemory) {
+ 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));
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *req = new ResizeRequest(
+ *ictx, &object_map, CEPH_NOSNAP, object_map.size(), OBJECT_EXISTS,
+ &cond_ctx);
+ req->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ for (uint64_t i = 0; i < object_map.size(); ++i) {
+ ASSERT_EQ(i == 0 ? OBJECT_NONEXISTENT : OBJECT_EXISTS,
+ object_map[i]);
+ }
+}
+
+TEST_F(TestMockObjectMapResizeRequest, 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_resize(ictx, CEPH_NOSNAP, 0);
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *req = new ResizeRequest(
+ *ictx, &object_map, CEPH_NOSNAP, object_map.size(), OBJECT_EXISTS,
+ &cond_ctx);
+ req->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapResizeRequest, UpdateSnapOnDisk) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::snap_set(ictx, "snap1"));
+
+ uint64_t snap_id = ictx->snap_id;
+ expect_resize(ictx, snap_id, 0);
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *req = new ResizeRequest(
+ *ictx, &object_map, snap_id, object_map.size(), OBJECT_EXISTS,
+ &cond_ctx);
+ req->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapResizeRequest, 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_resize(ictx, CEPH_NOSNAP, -EINVAL);
+ expect_invalidate(ictx);
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *req = new ResizeRequest(
+ *ictx, &object_map, CEPH_NOSNAP, object_map.size(), OBJECT_EXISTS,
+ &cond_ctx);
+ req->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+} // namespace object_map
+} // namespace librbd
--- /dev/null
+// -*- 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/internal.h"
+#include "librbd/object_map/SnapshotCreateRequest.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace librbd {
+namespace object_map {
+
+using ::testing::_;
+using ::testing::DoDefault;
+using ::testing::Return;
+
+class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
+public:
+ void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) {
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker parent_locker(ictx->parent_lock);
+ ictx->add_snap("snap name", snap_id, ictx->size, ictx->parent_md,
+ RBD_PROTECTION_STATUS_UNPROTECTED, 0);
+ }
+
+ void expect_read_map(librbd::ImageCtx *ictx, int r) {
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ read(ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP),
+ 0, 0, _)).WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ read(ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP),
+ 0, 0, _)).WillOnce(DoDefault());
+ }
+ }
+
+ void expect_write_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ write_full(
+ ObjectMap::object_map_name(ictx->id, snap_id), _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ write_full(
+ ObjectMap::object_map_name(ictx->id, snap_id), _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_add_snapshot(librbd::ImageCtx *ictx, int r) {
+ std::string oid(ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP));
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_snap_add", _, _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_invalidate(librbd::ImageCtx *ictx) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(DoDefault());
+ }
+};
+
+TEST_F(TestMockObjectMapSnapshotCreateRequest, Success) {
+ 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));
+
+ ceph::BitVector<2> object_map;
+
+ uint64_t snap_id = 1;
+ inject_snap_info(ictx, snap_id);
+ expect_read_map(ictx, 0);
+ expect_write_map(ictx, snap_id, 0);
+ if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
+ expect_add_snapshot(ictx, 0);
+ }
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotCreateRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotCreateRequest, ReadMapError) {
+ 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));
+
+ ceph::BitVector<2> object_map;
+
+ uint64_t snap_id = 1;
+ inject_snap_info(ictx, snap_id);
+ expect_read_map(ictx, -ENOENT);
+ expect_invalidate(ictx);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotCreateRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotCreateRequest, WriteMapError) {
+ 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));
+
+ ceph::BitVector<2> object_map;
+
+ uint64_t snap_id = 1;
+ inject_snap_info(ictx, snap_id);
+ expect_read_map(ictx, 0);
+ expect_write_map(ictx, snap_id, -EINVAL);
+ expect_invalidate(ictx);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotCreateRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotCreateRequest, AddSnapshotError) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
+
+ ceph::BitVector<2> object_map;
+
+ uint64_t snap_id = 1;
+ inject_snap_info(ictx, snap_id);
+ expect_read_map(ictx, 0);
+ expect_write_map(ictx, snap_id, 0);
+ expect_add_snapshot(ictx, -EINVAL);
+ expect_invalidate(ictx);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotCreateRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotCreateRequest, FlagCleanObjects) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1024);
+ for (uint64_t i = 0; i < object_map.size(); ++i) {
+ object_map[i] = i % 2 == 0 ? OBJECT_EXISTS : OBJECT_NONEXISTENT;
+ }
+
+ uint64_t snap_id = 1;
+ inject_snap_info(ictx, snap_id);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotCreateRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ for (uint64_t i = 0; i < object_map.size(); ++i) {
+ ASSERT_EQ(i % 2 == 0 ? OBJECT_EXISTS_CLEAN : OBJECT_NONEXISTENT,
+ object_map[i]);
+ }
+}
+
+} // namespace object_map
+} // namespace librbd
--- /dev/null
+// -*- 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/internal.h"
+#include "librbd/object_map/SnapshotRemoveRequest.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace librbd {
+namespace object_map {
+
+using ::testing::_;
+using ::testing::DoDefault;
+using ::testing::Return;
+
+class TestMockObjectMapSnapshotRemoveRequest : public TestMockFixture {
+public:
+ void expect_load_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
+ std::string snap_oid(ObjectMap::object_map_name(ictx->id, snap_id));
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(snap_oid, _, "rbd", "object_map_load", _, _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(snap_oid, _, "rbd", "object_map_load", _, _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_remove_snapshot(librbd::ImageCtx *ictx, int r) {
+ std::string oid(ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP));
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_snap_remove", _, _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_remove_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
+ std::string snap_oid(ObjectMap::object_map_name(ictx->id, snap_id));
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx), remove(snap_oid))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx), remove(snap_oid))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_invalidate(librbd::ImageCtx *ictx) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .Times(0);
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .WillOnce(DoDefault());
+ }
+};
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, Success) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
+ expect_load_map(ictx, snap_id, 0);
+ expect_remove_snapshot(ictx, 0);
+ }
+ expect_remove_map(ictx, snap_id, 0);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, LoadMapError) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_load_map(ictx, snap_id, -EINVAL);
+ expect_invalidate(ictx);
+ expect_remove_map(ictx, snap_id, 0);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveSnapshotMissing) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_load_map(ictx, snap_id, 0);
+ expect_remove_snapshot(ictx, -ENOENT);
+ expect_remove_map(ictx, snap_id, 0);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveSnapshotError) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_load_map(ictx, snap_id, 0);
+ expect_remove_snapshot(ictx, -EINVAL);
+ expect_invalidate(ictx);
+ expect_remove_map(ictx, snap_id, 0);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveMapMissing) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
+ expect_load_map(ictx, snap_id, 0);
+ expect_remove_snapshot(ictx, 0);
+ }
+ expect_remove_map(ictx, snap_id, -ENOENT);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveMapError) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
+ expect_load_map(ictx, snap_id, 0);
+ expect_remove_snapshot(ictx, 0);
+ }
+ expect_remove_map(ictx, snap_id, -EINVAL);
+
+ ceph::BitVector<2> object_map;
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(-EINVAL, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRemoveRequest, ScrubCleanObjects) {
+ REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1024);
+ for (uint64_t i = 512; i < object_map.size(); ++i) {
+ object_map[i] = i % 2 == 0 ? OBJECT_EXISTS_CLEAN : OBJECT_NONEXISTENT;
+ }
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRemoveRequest(
+ *ictx, &object_map, snap_id, &cond_ctx);
+ {
+ RWLock::RLocker owner_locker(ictx->owner_lock);
+ RWLock::WLocker snap_locker(ictx->snap_lock);
+ request->send();
+ }
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ for (uint64_t i = 512; i < object_map.size(); ++i) {
+ ASSERT_EQ(i % 2 == 0 ? OBJECT_EXISTS : OBJECT_NONEXISTENT,
+ object_map[i]);
+ }
+}
+
+} // namespace object_map
+} // namespace librbd
--- /dev/null
+// -*- 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 "librbd/internal.h"
+#include "librbd/ObjectMap.h"
+#include "librbd/object_map/SnapshotRollbackRequest.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace librbd {
+namespace object_map {
+
+using ::testing::_;
+using ::testing::DoDefault;
+using ::testing::Return;
+
+class TestMockObjectMapSnapshotRollbackRequest : public TestMockFixture {
+public:
+ void expect_read_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ read(ObjectMap::object_map_name(ictx->id, snap_id),
+ 0, 0, _)).WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ read(ObjectMap::object_map_name(ictx->id, snap_id),
+ 0, 0, _)).WillOnce(DoDefault());
+ }
+ }
+
+ void expect_write_map(librbd::ImageCtx *ictx, int r) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP), _,
+ "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ write_full(
+ ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP), _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ write_full(
+ ObjectMap::object_map_name(ictx->id, CEPH_NOSNAP), _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_invalidate(librbd::ImageCtx *ictx, uint32_t times) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .Times(0);
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "set_flags", _, _, _))
+ .Times(times)
+ .WillRepeatedly(DoDefault());
+ }
+};
+
+TEST_F(TestMockObjectMapSnapshotRollbackRequest, Success) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_read_map(ictx, snap_id, 0);
+ expect_write_map(ictx, 0);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRollbackRequest(
+ *ictx, snap_id, &cond_ctx);
+ request->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRollbackRequest, ReadMapError) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_read_map(ictx, snap_id, -ENOENT);
+ expect_invalidate(ictx, 2);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRollbackRequest(
+ *ictx, snap_id, &cond_ctx);
+ request->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ uint64_t flags;
+ ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
+ ASSERT_NE(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
+ }
+ ASSERT_TRUE(ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID));
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+TEST_F(TestMockObjectMapSnapshotRollbackRequest, WriteMapError) {
+ REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
+
+ librbd::ImageCtx *ictx;
+ ASSERT_EQ(0, open_image(m_image_name, &ictx));
+ ASSERT_EQ(0, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+
+ uint64_t snap_id = ictx->snap_info.rbegin()->first;
+ expect_read_map(ictx, snap_id, 0);
+ expect_write_map(ictx, -EINVAL);
+ expect_invalidate(ictx, 1);
+
+ C_SaferCond cond_ctx;
+ AsyncRequest<> *request = new SnapshotRollbackRequest(
+ *ictx, snap_id, &cond_ctx);
+ request->send();
+ ASSERT_EQ(0, cond_ctx.wait());
+
+ {
+ RWLock::RLocker snap_locker(ictx->snap_lock);
+ uint64_t flags;
+ ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
+ ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
+ }
+ ASSERT_TRUE(ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID));
+ expect_unlock_exclusive_lock(*ictx);
+}
+
+} // namespace object_map
+} // namespace librbd
--- /dev/null
+// -*- 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/internal.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;
+
+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, _, "lock", "assert_locked", _, _, _))
+ .WillOnce(DoDefault());
+ }
+
+ if (r < 0) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_update", _, _, _))
+ .WillOnce(Return(r));
+ } else {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(oid, _, "rbd", "object_map_update", _, _, _))
+ .WillOnce(DoDefault());
+ }
+ }
+
+ void expect_invalidate(librbd::ImageCtx *ictx) {
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "lock", "assert_locked", _, _, _))
+ .Times(0);
+ EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
+ exec(ictx->header_oid, _, "rbd", "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));
+ ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
+
+ ceph::BitVector<2> object_map;
+ object_map.resize(1024);
+ 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, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::snap_set(ictx, "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, librbd::snap_create(ictx, "snap1"));
+ ASSERT_EQ(0, librbd::ictx_check(ictx));
+ 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
#include "test/librbd/test_fixture.h"
#include "test/librbd/test_support.h"
#include "include/stringify.h"
+#include "librbd/AioImageRequestWQ.h"
+#include "librbd/ImageWatcher.h"
#include "cls/lock/cls_lock_client.h"
#include "cls/lock/cls_lock_types.h"
#include "librbd/internal.h"
}
return r;
}
+
+int TestFixture::acquire_exclusive_lock(librbd::ImageCtx &ictx) {
+ int r = ictx.aio_work_queue->write(0, 0, "", 0);
+ if (r != 0) {
+ return r;
+ }
+
+ RWLock::RLocker owner_locker(ictx.owner_lock);
+ return ictx.image_watcher->is_lock_owner() ? 0 : -EINVAL;
+}
const std::string &cookie);
int unlock_image();
+ int acquire_exclusive_lock(librbd::ImageCtx &ictx);
+
static std::string _pool_name;
static librados::Rados _rados;
static uint64_t _image_number;
projects / ceph-ci.git / commitdiff