test: support blacklisting within librados_test_stub

src/librbd/ManagedLock.cc

@@ -19,7 +19,8 @@
 
 #define dout_subsys ceph_subsys_rbd
 #undef dout_prefix
-#define dout_prefix *_dout << "librbd::ManagedLock: " << this << " " <<  __func__
+#define dout_prefix *_dout << "librbd::ManagedLock: " << this << " " \
+                           <<  __func__
 
 namespace librbd {
 
@@ -663,7 +664,6 @@ void ManagedLock<I>::send_shutdown() {
     return;
   }
 
-  ldout(m_cct, 10) << dendl;
   assert(m_state == STATE_LOCKED);
   m_state = STATE_PRE_SHUTTING_DOWN;
 

src/librbd/image/CreateRequest.cc

@@ -125,12 +125,11 @@ CreateRequest<I>::CreateRequest(IoCtx &ioctx, const std::string &image_name,
                                 const std::string &primary_mirror_uuid,
                                 bool skip_mirror_enable,
                                 ContextWQ *op_work_queue, Context *on_finish)
-  : m_image_name(image_name), m_image_id(image_id), m_size(size),
-    m_non_primary_global_image_id(non_primary_global_image_id),
+  : m_ioctx(ioctx), m_image_name(image_name), m_image_id(image_id),
+    m_size(size), m_non_primary_global_image_id(non_primary_global_image_id),
     m_primary_mirror_uuid(primary_mirror_uuid),
     m_skip_mirror_enable(skip_mirror_enable),
     m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
-  m_ioctx.dup(ioctx);
   m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
 
   m_id_obj = util::id_obj_name(m_image_name);
@@ -294,7 +293,8 @@ Context* CreateRequest<I>::handle_validate_pool(int *result) {
     create_id_object();
     return nullptr;
   } else if ((*result < 0) && (*result != -ENOENT)) {
-    lderr(m_cct) << "failed to stat RBD directory: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "failed to stat RBD directory: " << cpp_strerror(*result)
+                 << dendl;
     return m_on_finish;
   }
 
@@ -351,7 +351,8 @@ Context *CreateRequest<I>::handle_create_id_object(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if (*result < 0) {
-    lderr(m_cct) << "error creating RBD id object: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "error creating RBD id object: " << cpp_strerror(*result)
+                 << dendl;
     return m_on_finish;
   }
 
@@ -379,7 +380,8 @@ Context *CreateRequest<I>::handle_add_image_to_directory(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if (*result < 0) {
-    lderr(m_cct) << "error adding image to directory: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "error adding image to directory: " << cpp_strerror(*result)
+                 << dendl;
 
     m_r_saved = *result;
     remove_id_object();
@@ -503,7 +505,8 @@ Context *CreateRequest<I>::handle_set_stripe_unit_count(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if (*result < 0) {
-    lderr(m_cct) << "error setting stripe unit/count: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "error setting stripe unit/count: "
+                 << cpp_strerror(*result) << dendl;
     m_r_saved = *result;
     remove_header_object();
     return nullptr;
@@ -539,7 +542,8 @@ Context *CreateRequest<I>::handle_object_map_resize(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if (*result < 0) {
-    lderr(m_cct) << "error creating initial object map: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "error creating initial object map: "
+                 << cpp_strerror(*result) << dendl;
 
     m_r_saved = *result;
     remove_header_object();
@@ -576,7 +580,8 @@ Context *CreateRequest<I>::handle_fetch_mirror_mode(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if ((*result < 0) && (*result != -ENOENT)) {
-    lderr(m_cct) << "failed to retrieve mirror mode: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "failed to retrieve mirror mode: " << cpp_strerror(*result)
+                 << dendl;
 
     m_r_saved = *result;
     remove_object_map();
@@ -621,17 +626,18 @@ void CreateRequest<I>::journal_create() {
   ldout(m_cct, 20) << this << " " << __func__ << dendl;
 
   using klass = CreateRequest<I>;
-  Context *ctx = create_context_callback<klass, &klass::handle_journal_create>(this);
+  Context *ctx = create_context_callback<klass, &klass::handle_journal_create>(
+    this);
 
   librbd::journal::TagData tag_data;
   tag_data.mirror_uuid = (m_force_non_primary ? m_primary_mirror_uuid :
                           librbd::Journal<I>::LOCAL_MIRROR_UUID);
 
   librbd::journal::CreateRequest<I> *req =
     librbd::journal::CreateRequest<I>::create(
-      m_ioctx, m_image_id, m_journal_order, m_journal_splay_width, m_journal_pool,
-      cls::journal::Tag::TAG_CLASS_NEW, tag_data, librbd::Journal<I>::IMAGE_CLIENT_ID,
-      m_op_work_queue, ctx);
+      m_ioctx, m_image_id, m_journal_order, m_journal_splay_width,
+      m_journal_pool, cls::journal::Tag::TAG_CLASS_NEW, tag_data,
+      librbd::Journal<I>::IMAGE_CLIENT_ID, m_op_work_queue, ctx);
   req->send();
 }
 
@@ -640,7 +646,8 @@ Context* CreateRequest<I>::handle_journal_create(int *result) {
   ldout(m_cct, 20) << __func__ << ": r=" << *result << dendl;
 
   if (*result < 0) {
-    lderr(m_cct) << "error creating journal: " << cpp_strerror(*result) << dendl;
+    lderr(m_cct) << "error creating journal: " << cpp_strerror(*result)
+                 << dendl;
 
     m_r_saved = *result;
     remove_object_map();
@@ -706,11 +713,13 @@ void CreateRequest<I>::journal_remove() {
   ldout(m_cct, 20) << this << " " <<__func__ << dendl;
 
   using klass = CreateRequest<I>;
-  Context *ctx = create_context_callback<klass, &klass::handle_journal_remove>(this);
+  Context *ctx = create_context_callback<klass, &klass::handle_journal_remove>(
+    this);
 
   librbd::journal::RemoveRequest<I> *req =
     librbd::journal::RemoveRequest<I>::create(
-      m_ioctx, m_image_id, librbd::Journal<I>::IMAGE_CLIENT_ID, m_op_work_queue, ctx);
+      m_ioctx, m_image_id, librbd::Journal<I>::IMAGE_CLIENT_ID, m_op_work_queue,
+      ctx);
   req->send();
 }
 

src/librbd/image/CreateRequest.h

@@ -98,7 +98,7 @@ class CreateRequest {
                 bool skip_mirror_enable,
                 ContextWQ *op_work_queue, Context *on_finish);
 
-  IoCtx m_ioctx;
+  IoCtx &m_ioctx;
   std::string m_image_name;
   std::string m_image_id;
   uint64_t m_size;

src/librbd/journal/CreateRequest.cc

@@ -23,17 +23,16 @@ namespace journal {
 
 template<typename I>
 CreateRequest<I>::CreateRequest(IoCtx &ioctx, const std::string &imageid,
-                                              uint8_t order, uint8_t splay_width,
-                                              const std::string &object_pool,
-                                              uint64_t tag_class, TagData &tag_data,
-                                              const std::string &client_id,
-                                              ContextWQ *op_work_queue,
-                                              Context *on_finish)
-  : m_image_id(imageid), m_order(order), m_splay_width(splay_width),
-    m_object_pool(object_pool), m_tag_class(tag_class), m_tag_data(tag_data),
-    m_image_client_id(client_id), m_op_work_queue(op_work_queue),
-    m_on_finish(on_finish) {
-  m_ioctx.dup(ioctx);
+                                uint8_t order, uint8_t splay_width,
+                                const std::string &object_pool,
+                                uint64_t tag_class, TagData &tag_data,
+                                const std::string &client_id,
+                                ContextWQ *op_work_queue,
+                                Context *on_finish)
+  : m_ioctx(ioctx), m_image_id(imageid), m_order(order),
+    m_splay_width(splay_width), m_object_pool(object_pool),
+    m_tag_class(tag_class), m_tag_data(tag_data), m_image_client_id(client_id),
+    m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
   m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
 }
 

src/librbd/journal/CreateRequest.h

@@ -57,7 +57,7 @@ class CreateRequest {
                        const std::string &client_id, ContextWQ *op_work_queue,
                        Context *on_finish);
 
-  IoCtx m_ioctx;
+  IoCtx &m_ioctx;
   std::string m_image_id;
   uint8_t m_order;
   uint8_t m_splay_width;

src/librbd/journal/RemoveRequest.cc

@@ -22,12 +22,11 @@ namespace journal {
 
 template<typename I>
 RemoveRequest<I>::RemoveRequest(IoCtx &ioctx, const std::string &image_id,
-                                              const std::string &client_id,
-                                              ContextWQ *op_work_queue,
-                                              Context *on_finish)
-  : m_image_id(image_id), m_image_client_id(client_id),
+                                const std::string &client_id,
+                                ContextWQ *op_work_queue,
+                                Context *on_finish)
+  : m_ioctx(ioctx), m_image_id(image_id), m_image_client_id(client_id),
     m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
-  m_ioctx.dup(ioctx);
   m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
 }
 

src/librbd/journal/RemoveRequest.h

@@ -49,7 +49,7 @@ class RemoveRequest {
                        const std::string &client_id,
                        ContextWQ *op_work_queue, Context *on_finish);
 
-  IoCtx m_ioctx;
+  IoCtx &m_ioctx;
   std::string m_image_id;
   std::string m_image_client_id;
   ContextWQ *m_op_work_queue;

src/librbd/managed_lock/AcquireRequest.cc

@@ -103,7 +103,8 @@ void AcquireRequest<I>::handle_get_locker(int r) {
 
 template <typename I>
 void AcquireRequest<I>::send_lock() {
-  ldout(m_cct, 10) << "cookie=" << m_cookie << dendl;
+  ldout(m_cct, 10) << "entity=client." << m_ioctx.get_instance_id() << ", "
+                   << "cookie=" << m_cookie << dendl;
 
   librados::ObjectWriteOperation op;
   rados::cls::lock::lock(&op, RBD_LOCK_NAME,

src/librbd/managed_lock/BreakRequest.cc

@@ -93,21 +93,25 @@ void BreakRequest<I>::handle_get_watchers(int r) {
     return;
   }
 
+  bool found_alive_locker = false;
   for (auto &watcher : m_watchers) {
+    ldout(m_cct, 20) << "watcher=["
+                     << "addr=" << watcher.addr << ", "
+                     << "entity=client." << watcher.watcher_id << "]" << dendl;
+
     if ((strncmp(m_locker.address.c_str(),
                  watcher.addr, sizeof(watcher.addr)) == 0) &&
         (m_locker.handle == watcher.cookie)) {
       ldout(m_cct, 10) << "lock owner is still alive" << dendl;
-
-      if (m_force_break_lock) {
-        break;
-      } else {
-        finish(-EAGAIN);
-        return;
-      }
+      found_alive_locker = true;
     }
   }
 
+  if (!m_force_break_lock && found_alive_locker) {
+    finish(-EAGAIN);
+    return;
+  }
+
   send_blacklist();
 }
 

src/librbd/managed_lock/BreakRequest.h

@@ -34,7 +34,8 @@ class BreakRequest {
                               uint32_t blacklist_expire_seconds,
                               bool force_break_lock, Context *on_finish) {
     return new BreakRequest(ioctx, work_queue, oid, locker, blacklist_locker,
-                            blacklist_expire_seconds, force_break_lock, on_finish);
+                            blacklist_expire_seconds, force_break_lock,
+                            on_finish);
   }
 
   void send();

src/librbd/managed_lock/ReleaseRequest.cc

@@ -55,7 +55,8 @@ void ReleaseRequest<I>::send() {
 template <typename I>
 void ReleaseRequest<I>::send_unlock() {
   CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
-  ldout(cct, 10) << "cookie=" << m_cookie << dendl;
+  ldout(cct, 10) << "entity=client." << m_ioctx.get_instance_id() << ", "
+                 << "cookie=" << m_cookie << dendl;
 
   librados::ObjectWriteOperation op;
   rados::cls::lock::unlock(&op, RBD_LOCK_NAME, m_cookie);

src/librbd/managed_lock/Types.h

@@ -14,14 +14,24 @@ struct Locker {
   entity_name_t entity;
   std::string cookie;
   std::string address;
-  uint64_t handle;
+  uint64_t handle = 0;
+
+  Locker() {
+  }
+  Locker(const entity_name_t& entity, const std::string &cookie,
+         const std::string &address, uint64_t handle)
+    : entity(entity), cookie(cookie), address(address), handle(handle) {
+  }
 
   inline bool operator==(const Locker &rhs) const {
     return (entity == rhs.entity &&
             cookie == rhs.cookie &&
             address == rhs.address &&
             handle == rhs.handle);
   }
+  inline bool operator!=(const Locker &rhs) const {
+    return !(*this == rhs);
+  }
 };
 
 enum Mode {

src/librbd/operation/ObjectMapIterate.cc

@@ -47,6 +47,8 @@ class C_VerifyObjectCallback : public C_AsyncObjectThrottle<I> {
     if (should_complete(r)) {
       ldout(image_ctx.cct, 20) << m_oid << " C_VerifyObjectCallback completed "
 			       << dendl;
+      m_io_ctx.close();
+
       this->finish(r);
       delete this;
     }

src/librbd/watcher/Notifier.cc

@@ -16,10 +16,9 @@ namespace watcher {
 const uint64_t Notifier::NOTIFY_TIMEOUT = 5000;
 
 Notifier::Notifier(ContextWQ *work_queue, IoCtx &ioctx, const std::string &oid)
-  : m_work_queue(work_queue), m_oid(oid),
+  : m_work_queue(work_queue), m_ioctx(ioctx), m_oid(oid),
     m_aio_notify_lock(util::unique_lock_name(
       "librbd::object_watcher::Notifier::m_aio_notify_lock", this)) {
-  m_ioctx.dup(ioctx);
   m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
 }
 

src/librbd/watcher/Notifier.h

@@ -43,7 +43,7 @@ class Notifier {
   };
 
   ContextWQ *m_work_queue;
-  librados::IoCtx m_ioctx;
+  librados::IoCtx &m_ioctx;
   CephContext *m_cct;
   std::string m_oid;
 

src/test/journal/RadosTestFixture.cc

@@ -22,10 +22,10 @@ void RadosTestFixture::SetUpTestCase() {
 }
 
 void RadosTestFixture::TearDownTestCase() {
-  ASSERT_EQ(0, destroy_one_pool_pp(_pool_name, _rados));
-
   _thread_pool->stop();
   delete _thread_pool;
+
+  ASSERT_EQ(0, destroy_one_pool_pp(_pool_name, _rados));
 }
 
 std::string RadosTestFixture::get_temp_oid() {

src/test/librados_test_stub/CMakeLists.txt

@@ -2,9 +2,10 @@ set(librados_test_stub_srcs
   LibradosTestStub.cc
   TestClassHandler.cc
   TestIoCtxImpl.cc
+  TestMemCluster.cc
   TestMemIoCtxImpl.cc
   TestMemRadosClient.cc
   TestRadosClient.cc
   TestWatchNotify.cc)
 add_library(rados_test_stub STATIC ${librados_test_stub_srcs})
-  
+