src/ceph/src/test/librbd/object_map/test_mock_InvalidateRequest.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 "librbd/internal.h"
   8 #include "librbd/object_map/InvalidateRequest.h"
   9 #include "gmock/gmock.h"
  10 #include "gtest/gtest.h"
  11
  12 namespace librbd {
  13 namespace object_map {
  14
  15 using ::testing::_;
  16 using ::testing::DoDefault;
  17 using ::testing::Return;
  18 using ::testing::StrEq;
  19
  20 class TestMockObjectMapInvalidateRequest : public TestMockFixture {
  21 public:
  22 };
  23
  24 TEST_F(TestMockObjectMapInvalidateRequest, UpdatesInMemoryFlag) {
  25   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
  26
  27   librbd::ImageCtx *ictx;
  28   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  29   bool flags_set;
  30   ASSERT_EQ(0, ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID, &flags_set));
  31   ASSERT_FALSE(flags_set);
  32
  33   C_SaferCond cond_ctx;
  34   AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
  35
  36   EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  37               exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
  38                 .Times(0);
  39
  40   {
  41     RWLock::RLocker owner_locker(ictx->owner_lock);
  42     RWLock::WLocker snap_locker(ictx->snap_lock);
  43     request->send();
  44   }
  45   ASSERT_EQ(0, cond_ctx.wait());
  46
  47   ASSERT_EQ(0, ictx->test_flags(RBD_FLAG_OBJECT_MAP_INVALID, &flags_set));
  48   ASSERT_TRUE(flags_set);
  49 }
  50
  51 TEST_F(TestMockObjectMapInvalidateRequest, UpdatesHeadOnDiskFlag) {
  52   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
  53
  54   librbd::ImageCtx *ictx;
  55   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  56   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
  57
  58   C_SaferCond cond_ctx;
  59   AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
  60
  61   EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  62               exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
  63                 .WillOnce(DoDefault());
  64
  65   {
  66     RWLock::RLocker owner_locker(ictx->owner_lock);
  67     RWLock::WLocker snap_locker(ictx->snap_lock);
  68     request->send();
  69   }
  70   ASSERT_EQ(0, cond_ctx.wait());
  71
  72   expect_unlock_exclusive_lock(*ictx);
  73 }
  74
  75 TEST_F(TestMockObjectMapInvalidateRequest, UpdatesSnapOnDiskFlag) {
  76   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
  77
  78   librbd::ImageCtx *ictx;
  79   ASSERT_EQ(0, open_image(m_image_name, &ictx));
  80
  81   ASSERT_EQ(0, snap_create(*ictx, "snap1"));
  82   ASSERT_EQ(0, librbd::snap_set(ictx,
  83                                 cls::rbd::UserSnapshotNamespace(),
  84                                 "snap1"));
  85
  86   C_SaferCond cond_ctx;
  87   AsyncRequest<> *request = new InvalidateRequest<>(*ictx, ictx->snap_id, false,
  88                                                 &cond_ctx);
  89
  90   EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
  91               exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
  92                 .WillOnce(DoDefault());
  93
  94   {
  95     RWLock::RLocker owner_locker(ictx->owner_lock);
  96     RWLock::WLocker snap_locker(ictx->snap_lock);
  97     request->send();
  98   }
  99   ASSERT_EQ(0, cond_ctx.wait());
 100 }
 101
 102 TEST_F(TestMockObjectMapInvalidateRequest, SkipOnDiskUpdateWithoutLock) {
 103   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 104
 105   librbd::ImageCtx *ictx;
 106   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 107
 108   C_SaferCond cond_ctx;
 109   AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
 110
 111   EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
 112               exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
 113                 .Times(0);
 114
 115   {
 116     RWLock::RLocker owner_locker(ictx->owner_lock);
 117     RWLock::WLocker snap_locker(ictx->snap_lock);
 118     request->send();
 119   }
 120   ASSERT_EQ(0, cond_ctx.wait());
 121
 122   expect_unlock_exclusive_lock(*ictx);
 123 }
 124
 125 TEST_F(TestMockObjectMapInvalidateRequest, IgnoresOnDiskUpdateFailure) {
 126   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 127
 128   librbd::ImageCtx *ictx;
 129   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 130   ASSERT_EQ(0, acquire_exclusive_lock(*ictx));
 131
 132   C_SaferCond cond_ctx;
 133   AsyncRequest<> *request = new InvalidateRequest<>(*ictx, CEPH_NOSNAP, false, &cond_ctx);
 134
 135   EXPECT_CALL(get_mock_io_ctx(ictx->md_ctx),
 136               exec(ictx->header_oid, _, StrEq("rbd"), StrEq("set_flags"), _, _, _))
 137                 .WillOnce(Return(-EINVAL));
 138
 139   {
 140     RWLock::RLocker owner_locker(ictx->owner_lock);
 141     RWLock::WLocker snap_locker(ictx->snap_lock);
 142     request->send();
 143   }
 144   ASSERT_EQ(0, cond_ctx.wait());
 145
 146   expect_unlock_exclusive_lock(*ictx);
 147 }
 148
 149 } // namespace object_map
 150 } // namespace librbd