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 "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"
17 namespace object_map
{
20 using ::testing::DoDefault
;
21 using ::testing::InSequence
;
22 using ::testing::Return
;
23 using ::testing::StrEq
;
25 class TestMockObjectMapUpdateRequest
: public TestMockFixture
{
27 void expect_update(librbd::ImageCtx
*ictx
, uint64_t snap_id
,
28 uint64_t start_object_no
, uint64_t end_object_no
,
30 const boost::optional
<uint8_t>& current_state
, int r
) {
32 ::encode(start_object_no
, bl
);
33 ::encode(end_object_no
, bl
);
34 ::encode(new_state
, bl
);
35 ::encode(current_state
, bl
);
37 std::string
oid(ObjectMap
<>::object_map_name(ictx
->id
, snap_id
));
38 if (snap_id
== CEPH_NOSNAP
) {
39 EXPECT_CALL(get_mock_io_ctx(ictx
->md_ctx
),
40 exec(oid
, _
, StrEq("lock"), StrEq("assert_locked"), _
, _
, _
))
41 .WillOnce(DoDefault());
45 EXPECT_CALL(get_mock_io_ctx(ictx
->md_ctx
),
46 exec(oid
, _
, StrEq("rbd"), StrEq("object_map_update"),
47 ContentsEqual(bl
), _
, _
))
50 EXPECT_CALL(get_mock_io_ctx(ictx
->md_ctx
),
51 exec(oid
, _
, StrEq("rbd"), StrEq("object_map_update"),
52 ContentsEqual(bl
), _
, _
))
53 .WillOnce(DoDefault());
57 void expect_invalidate(librbd::ImageCtx
*ictx
) {
58 EXPECT_CALL(get_mock_io_ctx(ictx
->md_ctx
),
59 exec(ictx
->header_oid
, _
, StrEq("rbd"), StrEq("set_flags"), _
, _
, _
))
60 .WillOnce(DoDefault());
64 TEST_F(TestMockObjectMapUpdateRequest
, UpdateInMemory
) {
65 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
67 librbd::ImageCtx
*ictx
;
68 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
70 librbd::NoOpProgressContext no_progress
;
71 ASSERT_EQ(0, ictx
->operations
->resize(4 << ictx
->order
, true, no_progress
));
72 ASSERT_EQ(0, acquire_exclusive_lock(*ictx
));
74 ceph::BitVector
<2> object_map
;
76 for (uint64_t i
= 0; i
< object_map
.size(); ++i
) {
77 object_map
[i
] = i
% 4;
81 AsyncRequest
<> *req
= new UpdateRequest
<>(
82 *ictx
, &object_map
, CEPH_NOSNAP
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
83 OBJECT_EXISTS
, {}, false, &cond_ctx
);
85 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
86 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
89 ASSERT_EQ(0, cond_ctx
.wait());
91 for (uint64_t i
= 0; i
< object_map
.size(); ++i
) {
92 if (i
% 4 == OBJECT_EXISTS
|| i
% 4 == OBJECT_EXISTS_CLEAN
) {
93 ASSERT_EQ(OBJECT_NONEXISTENT
, object_map
[i
]);
95 ASSERT_EQ(i
% 4, object_map
[i
]);
100 TEST_F(TestMockObjectMapUpdateRequest
, UpdateHeadOnDisk
) {
101 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
103 librbd::ImageCtx
*ictx
;
104 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
105 ASSERT_EQ(0, acquire_exclusive_lock(*ictx
));
107 expect_update(ictx
, CEPH_NOSNAP
, 0, 1, OBJECT_NONEXISTENT
, OBJECT_EXISTS
, 0);
109 ceph::BitVector
<2> object_map
;
110 object_map
.resize(1);
112 C_SaferCond cond_ctx
;
113 AsyncRequest
<> *req
= new UpdateRequest
<>(
114 *ictx
, &object_map
, CEPH_NOSNAP
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
115 OBJECT_EXISTS
, {}, false, &cond_ctx
);
117 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
118 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
121 ASSERT_EQ(0, cond_ctx
.wait());
123 expect_unlock_exclusive_lock(*ictx
);
126 TEST_F(TestMockObjectMapUpdateRequest
, UpdateSnapOnDisk
) {
127 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
129 librbd::ImageCtx
*ictx
;
130 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
131 ASSERT_EQ(0, snap_create(*ictx
, "snap1"));
132 ASSERT_EQ(0, librbd::snap_set(ictx
,
133 cls::rbd::UserSnapshotNamespace(),
136 uint64_t snap_id
= ictx
->snap_id
;
137 expect_update(ictx
, snap_id
, 0, 1, OBJECT_NONEXISTENT
, OBJECT_EXISTS
, 0);
139 ceph::BitVector
<2> object_map
;
140 object_map
.resize(1);
142 C_SaferCond cond_ctx
;
143 AsyncRequest
<> *req
= new UpdateRequest
<>(
144 *ictx
, &object_map
, snap_id
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
145 OBJECT_EXISTS
, {}, false, &cond_ctx
);
147 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
148 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
151 ASSERT_EQ(0, cond_ctx
.wait());
153 expect_unlock_exclusive_lock(*ictx
);
156 TEST_F(TestMockObjectMapUpdateRequest
, UpdateOnDiskError
) {
157 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
159 librbd::ImageCtx
*ictx
;
160 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
161 ASSERT_EQ(0, acquire_exclusive_lock(*ictx
));
163 expect_update(ictx
, CEPH_NOSNAP
, 0, 1, OBJECT_NONEXISTENT
, OBJECT_EXISTS
,
165 expect_invalidate(ictx
);
167 ceph::BitVector
<2> object_map
;
168 object_map
.resize(1);
170 C_SaferCond cond_ctx
;
171 AsyncRequest
<> *req
= new UpdateRequest
<>(
172 *ictx
, &object_map
, CEPH_NOSNAP
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
173 OBJECT_EXISTS
, {}, false, &cond_ctx
);
175 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
176 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
179 ASSERT_EQ(0, cond_ctx
.wait());
181 expect_unlock_exclusive_lock(*ictx
);
184 TEST_F(TestMockObjectMapUpdateRequest
, RebuildSnapOnDisk
) {
185 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
187 librbd::ImageCtx
*ictx
;
188 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
189 ASSERT_EQ(0, snap_create(*ictx
, "snap1"));
190 ASSERT_EQ(0, ictx
->state
->refresh_if_required());
191 ASSERT_EQ(CEPH_NOSNAP
, ictx
->snap_id
);
193 uint64_t snap_id
= ictx
->snap_info
.rbegin()->first
;
194 expect_update(ictx
, snap_id
, 0, 1, OBJECT_EXISTS_CLEAN
,
195 boost::optional
<uint8_t>(), 0);
196 expect_unlock_exclusive_lock(*ictx
);
198 ceph::BitVector
<2> object_map
;
199 object_map
.resize(1);
201 C_SaferCond cond_ctx
;
202 AsyncRequest
<> *req
= new UpdateRequest
<>(
203 *ictx
, &object_map
, snap_id
, 0, object_map
.size(), OBJECT_EXISTS_CLEAN
,
204 boost::optional
<uint8_t>(), {}, false, &cond_ctx
);
206 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
207 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
210 ASSERT_EQ(0, cond_ctx
.wait());
212 // do not update the in-memory map if rebuilding a snapshot
213 ASSERT_NE(OBJECT_EXISTS_CLEAN
, object_map
[0]);
216 TEST_F(TestMockObjectMapUpdateRequest
, BatchUpdate
) {
217 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
219 librbd::ImageCtx
*ictx
;
220 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
222 librbd::NoOpProgressContext no_progress
;
223 ASSERT_EQ(0, ictx
->operations
->resize(712312 * ictx
->get_object_size(), false,
225 ASSERT_EQ(0, acquire_exclusive_lock(*ictx
));
228 expect_update(ictx
, CEPH_NOSNAP
, 0, 262144, OBJECT_NONEXISTENT
, OBJECT_EXISTS
,
230 expect_update(ictx
, CEPH_NOSNAP
, 262144, 524288, OBJECT_NONEXISTENT
,
232 expect_update(ictx
, CEPH_NOSNAP
, 524288, 712312, OBJECT_NONEXISTENT
,
234 expect_unlock_exclusive_lock(*ictx
);
236 ceph::BitVector
<2> object_map
;
237 object_map
.resize(712312);
239 C_SaferCond cond_ctx
;
240 AsyncRequest
<> *req
= new UpdateRequest
<>(
241 *ictx
, &object_map
, CEPH_NOSNAP
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
242 OBJECT_EXISTS
, {}, false, &cond_ctx
);
244 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
245 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
248 ASSERT_EQ(0, cond_ctx
.wait());
251 TEST_F(TestMockObjectMapUpdateRequest
, IgnoreMissingObjectMap
) {
252 REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP
);
254 librbd::ImageCtx
*ictx
;
255 ASSERT_EQ(0, open_image(m_image_name
, &ictx
));
256 ASSERT_EQ(0, acquire_exclusive_lock(*ictx
));
258 expect_update(ictx
, CEPH_NOSNAP
, 0, 1, OBJECT_NONEXISTENT
, OBJECT_EXISTS
,
261 ceph::BitVector
<2> object_map
;
262 object_map
.resize(1);
264 C_SaferCond cond_ctx
;
265 AsyncRequest
<> *req
= new UpdateRequest
<>(
266 *ictx
, &object_map
, CEPH_NOSNAP
, 0, object_map
.size(), OBJECT_NONEXISTENT
,
267 OBJECT_EXISTS
, {}, true, &cond_ctx
);
269 RWLock::RLocker
snap_locker(ictx
->snap_lock
);
270 RWLock::WLocker
object_map_locker(ictx
->object_map_lock
);
273 ASSERT_EQ(0, cond_ctx
.wait());
275 expect_unlock_exclusive_lock(*ictx
);
278 } // namespace object_map
279 } // namespace librbd