ceph/src/test/librbd/object_map/test_mock_SnapshotRemoveRequest.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/object_map/SnapshotRemoveRequest.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 TestMockObjectMapSnapshotRemoveRequest : public TestMockFixture {
  24 public:
  25   void expect_load_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
  26     std::string snap_oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
  27     if (r < 0) {
  28       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  29                   exec(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
  30                        _, _, _))
  31                     .WillOnce(Return(r));
  32     } else {
  33       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  34                   exec(snap_oid, _, StrEq("rbd"), StrEq("object_map_load"), _,
  35                        _, _, _))
  36                     .WillOnce(DoDefault());
  37     }
  38   }
  39
  40   void expect_remove_snapshot(librbd::ImageCtx *ictx, int r) {
  41     std::string oid(ObjectMap<>::object_map_name(ictx->id, CEPH_NOSNAP));
  42     if (r < 0) {
  43       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  44                   exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
  45                        _))
  46                     .WillOnce(Return(r));
  47     } else {
  48       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  49                   exec(oid, _, StrEq("lock"), StrEq("assert_locked"), _, _, _,
  50                        _))
  51                     .WillOnce(DoDefault());
  52       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  53                   exec(oid, _, StrEq("rbd"), StrEq("object_map_snap_remove"), _,
  54                        _, _, _))
  55                     .WillOnce(DoDefault());
  56     }
  57   }
  58
  59   void expect_remove_map(librbd::ImageCtx *ictx, uint64_t snap_id, int r) {
  60     std::string snap_oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
  61     if (r < 0) {
  62       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx), remove(snap_oid, _))
  63                     .WillOnce(Return(r));
  64     } else {
  65       EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx), remove(snap_oid, _))
  66                     .WillOnce(DoDefault());
  67     }
  68   }
  69
  70   void expect_invalidate(librbd::ImageCtx *ictx) {
  71     EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  72                 exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _,
  73                      _, _, _))
  74                   .WillOnce(DoDefault());
  75   }
  76 };
  77
  78 TEST_F(TestMockObjectMapSnapshotRemoveRequest, Success) {
  79   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
  80
  81   librbd::ImageCtx *ictx;
  82   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  83   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
  84   ASSERT_EQ(0, ictx->state->refresh_if_required());
  85
  86   uint64_t snap_id = ictx->snap_info.rbegin()->first;
  87   if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
  88     expect_load_map(ictx, snap_id, 0);
  89     expect_remove_snapshot(ictx, 0);
  90   }
  91   expect_remove_map(ictx, snap_id, 0);
  92
  93   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
  94   ceph::BitVector<2> object_map;
  95   C_SaferCond cond_ctx;
  96   AsyncRequest<> *request = new SnapshotRemoveRequest(
  97     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
  98   {
  99     std::shared_lock owner_locker{ictx->owner_lock};
 100     std::unique_lock image_locker{ictx->image_lock};
 101     request->send();
 102   }
 103   ASSERT_EQ(0, cond_ctx.wait());
 104
 105   expect_unlock_exclusive_lock(*ictx);
 106 }
 107
 108 TEST_F(TestMockObjectMapSnapshotRemoveRequest, LoadMapMissing) {
 109   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 110
 111   librbd::ImageCtx *ictx;
 112   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 113   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 114   ASSERT_EQ(0, ictx->state->refresh_if_required());
 115
 116   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 117   auto snap_it = ictx->snap_info.find(snap_id);
 118   ASSERT_NE(ictx->snap_info.end(), snap_it);
 119   snap_it->second.flags |= RBD_FLAG_OBJECT_MAP_INVALID;
 120
 121   expect_load_map(ictx, snap_id, -ENOENT);
 122
 123   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 124   ceph::BitVector<2> object_map;
 125   C_SaferCond cond_ctx;
 126   AsyncRequest<> *request = new SnapshotRemoveRequest(
 127     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 128   {
 129     std::shared_lock owner_locker{ictx->owner_lock};
 130     std::unique_lock image_locker{ictx->image_lock};
 131     request->send();
 132   }
 133   ASSERT_EQ(0, cond_ctx.wait());
 134
 135   {
 136     // shouldn't invalidate the HEAD revision when we fail to load
 137     // the already deleted snapshot
 138     std::shared_lock image_locker{ictx->image_lock};
 139     uint64_t flags;
 140     ASSERT_EQ(0, ictx->get_flags(CEPH_NOSNAP, &flags));
 141     ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
 142   }
 143
 144   expect_unlock_exclusive_lock(*ictx);
 145 }
 146
 147 TEST_F(TestMockObjectMapSnapshotRemoveRequest, LoadMapError) {
 148   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 149
 150   librbd::ImageCtx *ictx;
 151   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 152   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 153   ASSERT_EQ(0, ictx->state->refresh_if_required());
 154
 155   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 156   expect_load_map(ictx, snap_id, -EINVAL);
 157   expect_invalidate(ictx);
 158   expect_remove_map(ictx, snap_id, 0);
 159
 160   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 161   ceph::BitVector<2> object_map;
 162   C_SaferCond cond_ctx;
 163   AsyncRequest<> *request = new SnapshotRemoveRequest(
 164     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 165   {
 166     std::shared_lock owner_locker{ictx->owner_lock};
 167     std::unique_lock image_locker{ictx->image_lock};
 168     request->send();
 169   }
 170   ASSERT_EQ(0, cond_ctx.wait());
 171
 172   expect_unlock_exclusive_lock(*ictx);
 173 }
 174
 175 TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveSnapshotMissing) {
 176   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 177
 178   librbd::ImageCtx *ictx;
 179   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 180   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 181   ASSERT_EQ(0, ictx->state->refresh_if_required());
 182
 183   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 184   expect_load_map(ictx, snap_id, 0);
 185   expect_remove_snapshot(ictx, -ENOENT);
 186   expect_remove_map(ictx, snap_id, 0);
 187
 188   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 189   ceph::BitVector<2> object_map;
 190   C_SaferCond cond_ctx;
 191   AsyncRequest<> *request = new SnapshotRemoveRequest(
 192     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 193   {
 194     std::shared_lock owner_locker{ictx->owner_lock};
 195     std::unique_lock image_locker{ictx->image_lock};
 196     request->send();
 197   }
 198   ASSERT_EQ(0, cond_ctx.wait());
 199
 200   expect_unlock_exclusive_lock(*ictx);
 201 }
 202
 203 TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveSnapshotError) {
 204   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 205
 206   librbd::ImageCtx *ictx;
 207   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 208   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 209   ASSERT_EQ(0, ictx->state->refresh_if_required());
 210
 211   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 212   expect_load_map(ictx, snap_id, 0);
 213   expect_remove_snapshot(ictx, -EINVAL);
 214   expect_invalidate(ictx);
 215   expect_remove_map(ictx, snap_id, 0);
 216
 217   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 218   ceph::BitVector<2> object_map;
 219   C_SaferCond cond_ctx;
 220   AsyncRequest<> *request = new SnapshotRemoveRequest(
 221     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 222   {
 223     std::shared_lock owner_locker{ictx->owner_lock};
 224     std::unique_lock image_locker{ictx->image_lock};
 225     request->send();
 226   }
 227   ASSERT_EQ(0, cond_ctx.wait());
 228
 229   expect_unlock_exclusive_lock(*ictx);
 230 }
 231
 232 TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveMapMissing) {
 233   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 234
 235   librbd::ImageCtx *ictx;
 236   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 237   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 238   ASSERT_EQ(0, ictx->state->refresh_if_required());
 239
 240   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 241   if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
 242     expect_load_map(ictx, snap_id, 0);
 243     expect_remove_snapshot(ictx, 0);
 244   }
 245   expect_remove_map(ictx, snap_id, -ENOENT);
 246
 247   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 248   ceph::BitVector<2> object_map;
 249   C_SaferCond cond_ctx;
 250   AsyncRequest<> *request = new SnapshotRemoveRequest(
 251     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 252   {
 253     std::shared_lock owner_locker{ictx->owner_lock};
 254     std::unique_lock image_locker{ictx->image_lock};
 255     request->send();
 256   }
 257   ASSERT_EQ(0, cond_ctx.wait());
 258
 259   expect_unlock_exclusive_lock(*ictx);
 260 }
 261
 262 TEST_F(TestMockObjectMapSnapshotRemoveRequest, RemoveMapError) {
 263   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 264
 265   librbd::ImageCtx *ictx;
 266   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 267   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 268   ASSERT_EQ(0, ictx->state->refresh_if_required());
 269
 270   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 271   if (ictx->test_features(RBD_FEATURE_FAST_DIFF)) {
 272     expect_load_map(ictx, snap_id, 0);
 273     expect_remove_snapshot(ictx, 0);
 274   }
 275   expect_remove_map(ictx, snap_id, -EINVAL);
 276
 277   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 278   ceph::BitVector<2> object_map;
 279   C_SaferCond cond_ctx;
 280   AsyncRequest<> *request = new SnapshotRemoveRequest(
 281     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx);
 282   {
 283     std::shared_lock owner_locker{ictx->owner_lock};
 284     std::unique_lock image_locker{ictx->image_lock};
 285     request->send();
 286   }
 287   ASSERT_EQ(-EINVAL, cond_ctx.wait());
 288
 289   expect_unlock_exclusive_lock(*ictx);
 290 }
 291
 292 TEST_F(TestMockObjectMapSnapshotRemoveRequest, ScrubCleanObjects) {
 293   REQUIRE_FEATURE(RBD_FEATURE_FAST_DIFF);
 294
 295   librbd::ImageCtx *ictx;
 296   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 297   librbd::NoOpProgressContext prog_ctx;
 298   uint64_t size = 4294967296; // 4GB = 1024 * 4MB
 299   ASSERT_EQ(0, resize(ictx, size));
 300
 301   // update image objectmap for snap inherit
 302   ceph::shared_mutex object_map_lock = ceph::make_shared_mutex("lock");
 303   ceph::BitVector<2> object_map;
 304   object_map.resize(1024);
 305   for (uint64_t i = 512; i < object_map.size(); ++i) {
 306     object_map[i] = i % 2 == 0 ? OBJECT_EXISTS : OBJECT_NONEXISTENT;
 307   }
 308
 309   C_SaferCond cond_ctx1;
 310   {
 311     librbd::ObjectMap<> *om = new librbd::ObjectMap<>(*ictx, ictx->snap_id);
 312     std::shared_lock owner_locker{ictx->owner_lock};
 313     std::unique_lock image_locker{ictx->image_lock};
 314     om->set_object_map(object_map);
 315     om->aio_save(&cond_ctx1);
 316     om->put();
 317   }
 318   ASSERT_EQ(0, cond_ctx1.wait());
 319   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
 320   ASSERT_EQ(0, ictx->state->refresh_if_required());
 321
 322   // simutate the image objectmap state after creating snap
 323   for (uint64_t i = 512; i < object_map.size(); ++i) {
 324     object_map[i] = i % 2 == 0 ? OBJECT_EXISTS_CLEAN : OBJECT_NONEXISTENT;
 325   }
 326
 327   C_SaferCond cond_ctx2;
 328   uint64_t snap_id = ictx->snap_info.rbegin()->first;
 329   AsyncRequest<> *request = new SnapshotRemoveRequest(
 330     *ictx, &object_map_lock, &object_map, snap_id, &cond_ctx2);
 331   {
 332     std::shared_lock owner_locker{ictx->owner_lock};
 333     std::unique_lock image_locker{ictx->image_lock};
 334     request->send();
 335   }
 336   ASSERT_EQ(0, cond_ctx2.wait());
 337
 338   for (uint64_t i = 512; i < object_map.size(); ++i) {
 339     ASSERT_EQ(i % 2 == 0 ? OBJECT_EXISTS : OBJECT_NONEXISTENT,
 340               object_map[i]);
 341   }
 342 }
 343
 344 } // namespace object_map
 345 } // namespace librbd