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, {}, &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, {}, &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, {}, &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, {}, &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>(), {}, &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, {}, &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 } // namespace object_map
252 } // namespace librbd