ceph/src/test/librbd/object_map/test_mock_RefreshRequest.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/librbd/mock/MockImageCtx.h"
   7 #include "test/librbd/object_map/mock/MockInvalidateRequest.h"
   8 #include "test/librados_test_stub/MockTestMemIoCtxImpl.h"
   9 #include "common/bit_vector.hpp"
  10 #include "librbd/ObjectMap.h"
  11 #include "librbd/object_map/RefreshRequest.h"
  12 #include "librbd/object_map/LockRequest.h"
  13
  14 namespace librbd {
  15
  16 namespace {
  17
  18 struct MockObjectMapImageCtx : public MockImageCtx {
  19   MockObjectMapImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) {
  20   }
  21 };
  22
  23 } // anonymous namespace
  24
  25 namespace object_map {
  26
  27 template <>
  28 class LockRequest<MockObjectMapImageCtx> {
  29 public:
  30   static LockRequest *s_instance;
  31   static LockRequest *create(MockObjectMapImageCtx &image_ctx, Context *on_finish) {
  32     assert(s_instance != nullptr);
  33     s_instance->on_finish = on_finish;
  34     return s_instance;
  35   }
  36
  37   Context *on_finish = nullptr;
  38
  39   LockRequest() {
  40     s_instance = this;
  41   }
  42
  43   MOCK_METHOD0(send, void());
  44 };
  45
  46 template<>
  47 struct InvalidateRequest<MockObjectMapImageCtx> :
  48     public MockInvalidateRequestBase<MockObjectMapImageCtx> {
  49 };
  50
  51 LockRequest<MockObjectMapImageCtx> *LockRequest<MockObjectMapImageCtx>::s_instance = nullptr;
  52
  53 } // namespace object_map
  54 } // namespace librbd
  55
  56 // template definitions
  57 #include "librbd/object_map/RefreshRequest.cc"
  58 #include "librbd/object_map/LockRequest.cc"
  59
  60 namespace librbd {
  61 namespace object_map {
  62
  63 using ::testing::_;
  64 using ::testing::DoAll;
  65 using ::testing::DoDefault;
  66 using ::testing::InSequence;
  67 using ::testing::Return;
  68 using ::testing::StrEq;
  69 using ::testing::WithArg;
  70
  71 class TestMockObjectMapRefreshRequest : public TestMockFixture {
  72 public:
  73   static const uint64_t TEST_SNAP_ID = 123;
  74
  75   typedef RefreshRequest<MockObjectMapImageCtx> MockRefreshRequest;
  76   typedef LockRequest<MockObjectMapImageCtx> MockLockRequest;
  77   typedef InvalidateRequest<MockObjectMapImageCtx> MockInvalidateRequest;
  78
  79   void expect_object_map_lock(MockObjectMapImageCtx &mock_image_ctx,
  80                               MockLockRequest &mock_lock_request) {
  81     EXPECT_CALL(mock_lock_request, send())
  82                   .WillOnce(FinishRequest(&mock_lock_request, 0,
  83                                           &mock_image_ctx));
  84   }
  85
  86   void expect_object_map_load(MockObjectMapImageCtx &mock_image_ctx,
  87                               ceph::BitVector<2> *object_map, uint64_t snap_id,
  88                               int r) {
  89     std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id, snap_id));
  90     auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
  91                                exec(oid, _, StrEq("rbd"), StrEq("object_map_load"), _, _, _));
  92     if (r < 0) {
  93       expect.WillOnce(Return(r));
  94     } else {
  95       assert(object_map);
  96       object_map->set_crc_enabled(false);
  97
  98       bufferlist bl;
  99       ::encode(*object_map, bl);
 100
 101       std::string str(bl.c_str(), bl.length());
 102       expect.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(str)), Return(0)));
 103     }
 104   }
 105
 106   void expect_get_image_size(MockObjectMapImageCtx &mock_image_ctx, uint64_t snap_id,
 107                              uint64_t size) {
 108     EXPECT_CALL(mock_image_ctx, get_image_size(snap_id))
 109                   .WillOnce(Return(size));
 110   }
 111
 112   void expect_invalidate_request(MockObjectMapImageCtx &mock_image_ctx,
 113                                  MockInvalidateRequest &invalidate_request) {
 114     EXPECT_CALL(invalidate_request, send())
 115                   .WillOnce(FinishRequest(&invalidate_request, 0,
 116                                           &mock_image_ctx));
 117   }
 118
 119   void expect_truncate_request(MockObjectMapImageCtx &mock_image_ctx) {
 120     std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
 121                                                  TEST_SNAP_ID));
 122     EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), truncate(oid, 0, _))
 123                   .WillOnce(Return(0));
 124   }
 125
 126   void expect_object_map_resize(MockObjectMapImageCtx &mock_image_ctx,
 127                                 uint64_t num_objects, int r) {
 128     std::string oid(ObjectMap<>::object_map_name(mock_image_ctx.id,
 129                                                  TEST_SNAP_ID));
 130     auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
 131                                exec(oid, _, StrEq("rbd"), StrEq("object_map_resize"), _, _, _));
 132     expect.WillOnce(Return(r));
 133   }
 134
 135   void init_object_map(MockObjectMapImageCtx &mock_image_ctx,
 136                        ceph::BitVector<2> *object_map) {
 137     uint64_t num_objs = Striper::get_num_objects(
 138       mock_image_ctx.layout, mock_image_ctx.image_ctx->size);
 139     object_map->resize(num_objs);
 140     for (uint64_t i = 0; i < num_objs; ++i) {
 141       (*object_map)[i] = rand() % 3;
 142     }
 143   }
 144 };
 145
 146 TEST_F(TestMockObjectMapRefreshRequest, SuccessHead) {
 147   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 148
 149   librbd::ImageCtx *ictx;
 150   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 151
 152   MockObjectMapImageCtx mock_image_ctx(*ictx);
 153
 154   ceph::BitVector<2> on_disk_object_map;
 155   init_object_map(mock_image_ctx, &on_disk_object_map);
 156
 157   C_SaferCond ctx;
 158   ceph::BitVector<2> object_map;
 159   MockLockRequest mock_lock_request;
 160   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 161                                                    CEPH_NOSNAP, &ctx);
 162
 163   InSequence seq;
 164   expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
 165                         mock_image_ctx.image_ctx->size);
 166   expect_object_map_lock(mock_image_ctx, mock_lock_request);
 167   expect_object_map_load(mock_image_ctx, &on_disk_object_map, CEPH_NOSNAP, 0);
 168   expect_get_image_size(mock_image_ctx, CEPH_NOSNAP,
 169                         mock_image_ctx.image_ctx->size);
 170   req->send();
 171   ASSERT_EQ(0, ctx.wait());
 172
 173   ASSERT_EQ(on_disk_object_map, object_map);
 174 }
 175
 176 TEST_F(TestMockObjectMapRefreshRequest, SuccessSnapshot) {
 177   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 178
 179   librbd::ImageCtx *ictx;
 180   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 181
 182   MockObjectMapImageCtx mock_image_ctx(*ictx);
 183
 184   ceph::BitVector<2> on_disk_object_map;
 185   init_object_map(mock_image_ctx, &on_disk_object_map);
 186
 187   C_SaferCond ctx;
 188   ceph::BitVector<2> object_map;
 189   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 190                                                    TEST_SNAP_ID, &ctx);
 191
 192   InSequence seq;
 193   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 194                         mock_image_ctx.image_ctx->size);
 195   expect_object_map_load(mock_image_ctx, &on_disk_object_map, TEST_SNAP_ID, 0);
 196   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 197                         mock_image_ctx.image_ctx->size);
 198   req->send();
 199   ASSERT_EQ(0, ctx.wait());
 200
 201   ASSERT_EQ(on_disk_object_map, object_map);
 202 }
 203
 204 TEST_F(TestMockObjectMapRefreshRequest, LoadError) {
 205   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 206
 207   librbd::ImageCtx *ictx;
 208   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 209
 210   MockObjectMapImageCtx mock_image_ctx(*ictx);
 211
 212   ceph::BitVector<2> on_disk_object_map;
 213   init_object_map(mock_image_ctx, &on_disk_object_map);
 214
 215   C_SaferCond ctx;
 216   ceph::BitVector<2> object_map;
 217   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 218                                                    TEST_SNAP_ID, &ctx);
 219
 220   InSequence seq;
 221   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 222                         mock_image_ctx.image_ctx->size);
 223   expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -ENOENT);
 224
 225   MockInvalidateRequest invalidate_request;
 226   expect_invalidate_request(mock_image_ctx, invalidate_request);
 227   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 228                         mock_image_ctx.image_ctx->size);
 229
 230   req->send();
 231   ASSERT_EQ(0, ctx.wait());
 232 }
 233
 234 TEST_F(TestMockObjectMapRefreshRequest, LoadCorrupt) {
 235   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 236
 237   librbd::ImageCtx *ictx;
 238   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 239
 240   MockObjectMapImageCtx mock_image_ctx(*ictx);
 241
 242   ceph::BitVector<2> on_disk_object_map;
 243   init_object_map(mock_image_ctx, &on_disk_object_map);
 244
 245   C_SaferCond ctx;
 246   ceph::BitVector<2> object_map;
 247   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 248                                                    TEST_SNAP_ID, &ctx);
 249
 250   InSequence seq;
 251   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 252                         mock_image_ctx.image_ctx->size);
 253   expect_object_map_load(mock_image_ctx, nullptr, TEST_SNAP_ID, -EINVAL);
 254
 255   MockInvalidateRequest invalidate_request;
 256   expect_invalidate_request(mock_image_ctx, invalidate_request);
 257   expect_truncate_request(mock_image_ctx);
 258   expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
 259   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 260                         mock_image_ctx.image_ctx->size);
 261
 262   req->send();
 263   ASSERT_EQ(0, ctx.wait());
 264 }
 265
 266 TEST_F(TestMockObjectMapRefreshRequest, TooSmall) {
 267   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 268
 269   librbd::ImageCtx *ictx;
 270   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 271
 272   MockObjectMapImageCtx mock_image_ctx(*ictx);
 273
 274   ceph::BitVector<2> on_disk_object_map;
 275   init_object_map(mock_image_ctx, &on_disk_object_map);
 276
 277   ceph::BitVector<2> small_object_map;
 278
 279   C_SaferCond ctx;
 280   ceph::BitVector<2> object_map;
 281   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 282                                                    TEST_SNAP_ID, &ctx);
 283
 284   InSequence seq;
 285   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 286                         mock_image_ctx.image_ctx->size);
 287   expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);
 288
 289   MockInvalidateRequest invalidate_request;
 290   expect_invalidate_request(mock_image_ctx, invalidate_request);
 291   expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), 0);
 292   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 293                         mock_image_ctx.image_ctx->size);
 294
 295   req->send();
 296   ASSERT_EQ(0, ctx.wait());
 297 }
 298
 299 TEST_F(TestMockObjectMapRefreshRequest, TooLarge) {
 300   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 301
 302   librbd::ImageCtx *ictx;
 303   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 304
 305   MockObjectMapImageCtx mock_image_ctx(*ictx);
 306
 307   ceph::BitVector<2> on_disk_object_map;
 308   init_object_map(mock_image_ctx, &on_disk_object_map);
 309
 310   ceph::BitVector<2> large_object_map;
 311   large_object_map.resize(on_disk_object_map.size() * 2);
 312
 313   C_SaferCond ctx;
 314   ceph::BitVector<2> object_map;
 315   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 316                                                    TEST_SNAP_ID, &ctx);
 317
 318   InSequence seq;
 319   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 320                         mock_image_ctx.image_ctx->size);
 321   expect_object_map_load(mock_image_ctx, &large_object_map, TEST_SNAP_ID, 0);
 322   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 323                         mock_image_ctx.image_ctx->size);
 324   req->send();
 325   ASSERT_EQ(0, ctx.wait());
 326 }
 327
 328 TEST_F(TestMockObjectMapRefreshRequest, ResizeError) {
 329   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 330
 331   librbd::ImageCtx *ictx;
 332   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 333
 334   MockObjectMapImageCtx mock_image_ctx(*ictx);
 335
 336   ceph::BitVector<2> on_disk_object_map;
 337   init_object_map(mock_image_ctx, &on_disk_object_map);
 338
 339   ceph::BitVector<2> small_object_map;
 340
 341   C_SaferCond ctx;
 342   ceph::BitVector<2> object_map;
 343   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 344                                                    TEST_SNAP_ID, &ctx);
 345
 346   InSequence seq;
 347   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 348                         mock_image_ctx.image_ctx->size);
 349   expect_object_map_load(mock_image_ctx, &small_object_map, TEST_SNAP_ID, 0);
 350
 351   MockInvalidateRequest invalidate_request;
 352   expect_invalidate_request(mock_image_ctx, invalidate_request);
 353   expect_object_map_resize(mock_image_ctx, on_disk_object_map.size(), -ESTALE);
 354   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 355                         mock_image_ctx.image_ctx->size);
 356
 357   req->send();
 358   ASSERT_EQ(0, ctx.wait());
 359 }
 360
 361 TEST_F(TestMockObjectMapRefreshRequest, LargeImageError) {
 362   REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
 363
 364   librbd::ImageCtx *ictx;
 365   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 366
 367   MockObjectMapImageCtx mock_image_ctx(*ictx);
 368
 369   ceph::BitVector<2> on_disk_object_map;
 370   init_object_map(mock_image_ctx, &on_disk_object_map);
 371
 372   C_SaferCond ctx;
 373   ceph::BitVector<2> object_map;
 374   MockRefreshRequest *req = new MockRefreshRequest(mock_image_ctx, &object_map,
 375                                                    TEST_SNAP_ID, &ctx);
 376
 377   InSequence seq;
 378   expect_get_image_size(mock_image_ctx, TEST_SNAP_ID,
 379                         std::numeric_limits<int64_t>::max());
 380
 381   MockInvalidateRequest invalidate_request;
 382   expect_invalidate_request(mock_image_ctx, invalidate_request);
 383
 384   req->send();
 385   ASSERT_EQ(-EFBIG, ctx.wait());
 386 }
 387
 388 } // namespace object_map
 389 } // namespace librbd
 390