src/ceph/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.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 "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"
  14
  15 namespace librbd {
  16 namespace object_map {
  17
  18 using ::testing::_;
  19 using ::testing::DoDefault;
  20 using ::testing::Return;
  21 using ::testing::StrEq;
  22
  23 class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
  24 public:
  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());
  31   }
  32
  33   void expect_read_map(librbd::ImageCtx *ictx, int r) {
  34     if (r < 0) {
  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));
  38     } else {
  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());
  42     }
  43   }
  44
  45   void expect_write_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
  46     if (r < 0) {
  47       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  48                   write_full(
  49                     ObjectMap<>::object_map_name(ictx->id, snap_id), _, _))
  50                   .WillOnce(Return(r));
  51     } else {
  52       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  53                   write_full(
  54                     ObjectMap<>::object_map_name(ictx->id, snap_id), _, _))
  55                   .WillOnce(DoDefault());
  56     }
  57   }
  58
  59   void expect_add_snapshot(librbd::ImageCtx *ictx, int r) {
  60     std::string oid(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP));
  61     if (r < 0) {
  62       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  63                   exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _))
  64                     .WillOnce(Return(r));
  65     } else {
  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());
  72     }
  73   }
  74
  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());
  79   }
  80 };
  81
  82 TEST_F(TestMockObjectMapSnapshotCreateRequest, Success) {
  83   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
  84
  85   librbd::ImageCtx *ictx;
  86   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  87   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
  88
  89   ceph::BitVector<2> object_map;
  90
  91   uint64_t snap_id = 1;
  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);
  97   }
  98
  99   C_SaferCond cond_ctx;
 100   AsyncRequest<> *request = new SnapshotCreateRequest(
 101     *ictx, &object_map, snap_id, &cond_ctx);
 102   {
 103     RWLock::RLocker snap_locker(ictx->snap_lock);
 104     request->send();
 105   }
 106   ASSERT_EQ(0, cond_ctx.wait());
 107
 108   expect_unlock_exclusive_lock(*ictx);
 109 }
 110
 111 TEST_F(TestMockObjectMapSnapshotCreateRequest, ReadMapError) {
 112   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 113
 114   librbd::ImageCtx *ictx;
 115   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 116   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
 117
 118   ceph::BitVector<2> object_map;
 119
 120   uint64_t snap_id = 1;
 121   inject_snap_info(ictx, snap_id);
 122   expect_read_map(ictx, -ENOENT);
 123   expect_invalidate(ictx);
 124
 125   C_SaferCond cond_ctx;
 126   AsyncRequest<> *request = new SnapshotCreateRequest(
 127     *ictx, &object_map, snap_id, &cond_ctx);
 128   {
 129     RWLock::RLocker snap_locker(ictx->snap_lock);
 130     request->send();
 131   }
 132   ASSERT_EQ(0, cond_ctx.wait());
 133
 134   expect_unlock_exclusive_lock(*ictx);
 135 }
 136
 137 TEST_F(TestMockObjectMapSnapshotCreateRequest, WriteMapError) {
 138   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 139
 140   librbd::ImageCtx *ictx;
 141   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 142   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
 143
 144   ceph::BitVector<2> object_map;
 145
 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);
 151
 152   C_SaferCond cond_ctx;
 153   AsyncRequest<> *request = new SnapshotCreateRequest(
 154     *ictx, &object_map, snap_id, &cond_ctx);
 155   {
 156     RWLock::RLocker snap_locker(ictx->snap_lock);
 157     request->send();
 158   }
 159   ASSERT_EQ(0, cond_ctx.wait());
 160
 161   expect_unlock_exclusive_lock(*ictx);
 162 }
 163
 164 TEST_F(TestMockObjectMapSnapshotCreateRequest, AddSnapshotError) {
 165   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 166
 167   librbd::ImageCtx *ictx;
 168   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 169   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
 170
 171   ceph::BitVector<2> object_map;
 172
 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);
 179
 180   C_SaferCond cond_ctx;
 181   AsyncRequest<> *request = new SnapshotCreateRequest(
 182     *ictx, &object_map, snap_id, &cond_ctx);
 183   {
 184     RWLock::RLocker snap_locker(ictx->snap_lock);
 185     request->send();
 186   }
 187   ASSERT_EQ(0, cond_ctx.wait());
 188
 189   expect_unlock_exclusive_lock(*ictx);
 190 }
 191
 192 TEST_F(TestMockObjectMapSnapshotCreateRequest, FlagCleanObjects) {
 193   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 194
 195   librbd::ImageCtx *ictx;
 196   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 197   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
 198
 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;
 203   }
 204
 205   uint64_t snap_id = 1;
 206   inject_snap_info(ictx, snap_id);
 207
 208   C_SaferCond cond_ctx;
 209   AsyncRequest<> *request = new SnapshotCreateRequest(
 210     *ictx, &object_map, snap_id, &cond_ctx);
 211   {
 212     RWLock::RLocker snap_locker(ictx->snap_lock);
 213     request->send();
 214   }
 215   ASSERT_EQ(0, cond_ctx.wait());
 216
 217   for (uint64_t i = 0; i < object_map.size(); ++i) {
 218     ASSERT_EQ(i % 2 == 0 ? OBJECT_EXISTS_CLEAN : OBJECT_NONEXISTENT,
 219               object_map[i]);
 220   }
 221 }
 222
 223 } // namespace object_map
 224 } // namespace librbd