ceph/src/test/librbd/object_map/test_mock_UpdateRequest.cc

   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,
  71     OBJECT_EXISTS, &cond_ctx);
  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,
 103     OBJECT_EXISTS, &cond_ctx);
 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,
 133     OBJECT_EXISTS, &cond_ctx);
 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,
 160     OBJECT_EXISTS, &cond_ctx);
 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,
 190     boost::optional<uint8_t>(), &cond_ctx);
 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