1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
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 "cls/rbd/cls_rbd_types.h"
9 #include "librbd/internal.h"
10 #include "librbd/ObjectMap.h"
11 #include "librbd/object_map/SnapshotCreateRequest.h"
12 #include "gmock/gmock.h"
13 #include "gtest/gtest.h"
16 namespace object_map {
19 using ::testing::DoDefault;
20 using ::testing::Return;
21 using ::testing::StrEq;
23 class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
25 void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) {
26 RWLock::WLocker snap_locker(ictx->snap_lock);
27 RWLock::RLocker parent_locker(ictx->parent_lock);
28 ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "snap name", snap_id,
29 ictx->size, ictx->parent_md,
30 RBD_PROTECTION_STATUS_UNPROTECTED, 0, utime_t());
33 void expect_read_map(librbd::ImageCtx *ictx, int r) {
35 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
36 read(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP),
37 0, 0, _)).WillOnce(Return(r));
39 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
40 read(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP),
41 0, 0, _)).WillOnce(DoDefault());
45 void expect_write_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
47 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
49 ObjectMap<>::object_map_name(ictx->id, snap_id), _, _))
52 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
54 ObjectMap<>::object_map_name(ictx->id, snap_id), _, _))
55 .WillOnce(DoDefault());
59 void expect_add_snapshot(librbd::ImageCtx *ictx, int r) {
60 std::string oid(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP));
62 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
63 exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _))
66 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
67 exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _))
68 .WillOnce(DoDefault());
69 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
70 exec(oid, _, StrEq("rbd"), StrEq("object_map_snap_add"), _, _, _))
71 .WillOnce(DoDefault());
75 void expect_invalidate(librbd::ImageCtx *ictx) {
76 EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
77 exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
78 .WillOnce(DoDefault());
82 TEST_F(TestMockObjectMapSnapshotCreateRequest, Success) {
83 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
85 librbd::ImageCtx *ictx;
86 ASSERT_EQ(0, open_image(m_image_name, &ictx));
87 ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
89 ceph::BitVector<2> object_map;
92 inject_snap_info(ictx, snap_id);
93 expect_read_map(ictx, 0);
94 expect_write_map(ictx, snap_id, 0);
95 if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
96 expect_add_snapshot(ictx, 0);
100 AsyncRequest<> *request = new SnapshotCreateRequest(
101 *ictx, &object_map, snap_id, &cond_ctx);
103 RWLock::RLocker snap_locker(ictx->snap_lock);
106 ASSERT_EQ(0, cond_ctx.wait());
108 expect_unlock_exclusive_lock(*ictx);
111 TEST_F(TestMockObjectMapSnapshotCreateRequest, ReadMapError) {
112 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
114 librbd::ImageCtx *ictx;
115 ASSERT_EQ(0, open_image(m_image_name, &ictx));
116 ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
118 ceph::BitVector<2> object_map;
120 uint64_t snap_id = 1;
121 inject_snap_info(ictx, snap_id);
122 expect_read_map(ictx, -ENOENT);
123 expect_invalidate(ictx);
125 C_SaferCond cond_ctx;
126 AsyncRequest<> *request = new SnapshotCreateRequest(
127 *ictx, &object_map, snap_id, &cond_ctx);
129 RWLock::RLocker snap_locker(ictx->snap_lock);
132 ASSERT_EQ(0, cond_ctx.wait());
134 expect_unlock_exclusive_lock(*ictx);
137 TEST_F(TestMockObjectMapSnapshotCreateRequest, WriteMapError) {
138 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
140 librbd::ImageCtx *ictx;
141 ASSERT_EQ(0, open_image(m_image_name, &ictx));
142 ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
144 ceph::BitVector<2> object_map;
146 uint64_t snap_id = 1;
147 inject_snap_info(ictx, snap_id);
148 expect_read_map(ictx, 0);
149 expect_write_map(ictx, snap_id, -EINVAL);
150 expect_invalidate(ictx);
152 C_SaferCond cond_ctx;
153 AsyncRequest<> *request = new SnapshotCreateRequest(
154 *ictx, &object_map, snap_id, &cond_ctx);
156 RWLock::RLocker snap_locker(ictx->snap_lock);
159 ASSERT_EQ(0, cond_ctx.wait());
161 expect_unlock_exclusive_lock(*ictx);
164 TEST_F(TestMockObjectMapSnapshotCreateRequest, AddSnapshotError) {
165 REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
167 librbd::ImageCtx *ictx;
168 ASSERT_EQ(0, open_image(m_image_name, &ictx));
169 ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
171 ceph::BitVector<2> object_map;
173 uint64_t snap_id = 1;
174 inject_snap_info(ictx, snap_id);
175 expect_read_map(ictx, 0);
176 expect_write_map(ictx, snap_id, 0);
177 expect_add_snapshot(ictx, -EINVAL);
178 expect_invalidate(ictx);
180 C_SaferCond cond_ctx;
181 AsyncRequest<> *request = new SnapshotCreateRequest(
182 *ictx, &object_map, snap_id, &cond_ctx);
184 RWLock::RLocker snap_locker(ictx->snap_lock);
187 ASSERT_EQ(0, cond_ctx.wait());
189 expect_unlock_exclusive_lock(*ictx);
192 TEST_F(TestMockObjectMapSnapshotCreateRequest, FlagCleanObjects) {
193 REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
195 librbd::ImageCtx *ictx;
196 ASSERT_EQ(0, open_image(m_image_name, &ictx));
197 ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
199 ceph::BitVector<2> object_map;
200 object_map.resize(1024);
201 for (uint64_t i = 0; i < object_map.size(); ++i) {
202 object_map[i] = i % 2 == 0 ? OBJECT_EXISTS : OBJECT_NONEXISTENT;
205 uint64_t snap_id = 1;
206 inject_snap_info(ictx, snap_id);
208 C_SaferCond cond_ctx;
209 AsyncRequest<> *request = new SnapshotCreateRequest(
210 *ictx, &object_map, snap_id, &cond_ctx);
212 RWLock::RLocker snap_locker(ictx->snap_lock);
215 ASSERT_EQ(0, cond_ctx.wait());
217 for (uint64_t i = 0; i < object_map.size(); ++i) {
218 ASSERT_EQ(i % 2 == 0 ? OBJECT_EXISTS_CLEAN : OBJECT_NONEXISTENT,
223 } // namespace object_map
224 } // namespace librbd