cls,rados,rbd,mds,common: Avoid name collision with Windows headers

There are a few name collisions between Windows headers and ceph.
Where possible, we'll update Ceph code to avoid redefinitions.

The following names overlap with Windows headers:
* ERROR, NO_ERROR
* DELETE
* LocalLock
* LOCK_SHARED, LOCK_EXCLUSIVE

Signed-off-by: Lucian Petrut <lpetrut@cloudbasesolutions.com>

diff --git a/src/cls/lock/cls_lock_client.cc b/src/cls/lock/cls_lock_client.cc
index ce979b6cd5372ce8a092e46e285012c8e41b54b2..30565986799346d1d7db8a8a013afd76e03813e8 100644 (file)
--- a/src/cls/lock/cls_lock_client.cc
+++ b/src/cls/lock/cls_lock_client.cc
@@ -213,52 +213,52 @@ namespace rados {
 
       void Lock::assert_locked_shared(ObjectOperation *op)
       {
-        assert_locked(op, name, LOCK_SHARED, cookie, tag);
+        assert_locked(op, name, ClsLockType::SHARED, cookie, tag);
       }
 
       void Lock::assert_locked_exclusive(ObjectOperation *op)
       {
-        assert_locked(op, name, LOCK_EXCLUSIVE, cookie, tag);
+        assert_locked(op, name, ClsLockType::EXCLUSIVE, cookie, tag);
       }
 
       void Lock::assert_locked_exclusive_ephemeral(ObjectOperation *op)
       {
-        assert_locked(op, name, LOCK_EXCLUSIVE_EPHEMERAL, cookie, tag);
+        assert_locked(op, name, ClsLockType::EXCLUSIVE_EPHEMERAL, cookie, tag);
       }
 
       void Lock::lock_shared(ObjectWriteOperation *op)
       {
-        lock(op, name, LOCK_SHARED,
+        lock(op, name, ClsLockType::SHARED,
              cookie, tag, description, duration, flags);
       }
 
       int Lock::lock_shared(IoCtx *ioctx, const std::string& oid)
       {
-        return lock(ioctx, oid, name, LOCK_SHARED,
+        return lock(ioctx, oid, name, ClsLockType::SHARED,
                     cookie, tag, description, duration, flags);
       }
 
       void Lock::lock_exclusive(ObjectWriteOperation *op)
       {
-        lock(op, name, LOCK_EXCLUSIVE,
+        lock(op, name, ClsLockType::EXCLUSIVE,
              cookie, tag, description, duration, flags);
       }
 
       int Lock::lock_exclusive(IoCtx *ioctx, const std::string& oid)
       {
-        return lock(ioctx, oid, name, LOCK_EXCLUSIVE,
+        return lock(ioctx, oid, name, ClsLockType::EXCLUSIVE,
                     cookie, tag, description, duration, flags);
       }
 
       void Lock::lock_exclusive_ephemeral(ObjectWriteOperation *op)
       {
-        lock(op, name, LOCK_EXCLUSIVE_EPHEMERAL,
+        lock(op, name, ClsLockType::EXCLUSIVE_EPHEMERAL,
              cookie, tag, description, duration, flags);
       }
 
       int Lock::lock_exclusive_ephemeral(IoCtx *ioctx, const std::string& oid)
       {
-        return lock(ioctx, oid, name, LOCK_EXCLUSIVE_EPHEMERAL,
+        return lock(ioctx, oid, name, ClsLockType::EXCLUSIVE_EPHEMERAL,
                     cookie, tag, description, duration, flags);
       }
 

diff --git a/src/cls/lock/cls_lock_ops.cc b/src/cls/lock/cls_lock_ops.cc
index aa5f8245d2fad9f6ca6b9a5d236ae4d2dbe99666..ef4190c0a3c79b46bdf3b4b88c212c3d24dbf274 100644 (file)
--- a/src/cls/lock/cls_lock_ops.cc
+++ b/src/cls/lock/cls_lock_ops.cc
@@ -40,7 +40,7 @@ void cls_lock_lock_op::generate_test_instances(list<cls_lock_lock_op*>& o)
 {
   cls_lock_lock_op *i = new cls_lock_lock_op;
   i->name = "name";
-  i->type = LOCK_SHARED;
+  i->type = ClsLockType::SHARED;
   i->cookie = "cookie";
   i->tag = "tag";
   i->description = "description";
@@ -130,7 +130,7 @@ void cls_lock_get_info_reply::dump(Formatter *f) const
 void cls_lock_get_info_reply::generate_test_instances(list<cls_lock_get_info_reply*>& o)
 {
   cls_lock_get_info_reply *i = new cls_lock_get_info_reply;
-  i->lock_type = LOCK_SHARED;
+  i->lock_type = ClsLockType::SHARED;
   i->tag = "tag";
   locker_id_t id1, id2;
   entity_addr_t addr1, addr2;
@@ -180,7 +180,7 @@ void cls_lock_assert_op::generate_test_instances(list<cls_lock_assert_op*>& o)
 {
   cls_lock_assert_op *i = new cls_lock_assert_op;
   i->name = "name";
-  i->type = LOCK_SHARED;
+  i->type = ClsLockType::SHARED;
   i->cookie = "cookie";
   i->tag = "tag";
   o.push_back(i);
@@ -200,7 +200,7 @@ void cls_lock_set_cookie_op::generate_test_instances(list<cls_lock_set_cookie_op
 {
   cls_lock_set_cookie_op *i = new cls_lock_set_cookie_op;
   i->name = "name";
-  i->type = LOCK_SHARED;
+  i->type = ClsLockType::SHARED;
   i->cookie = "cookie";
   i->tag = "tag";
   i->new_cookie = "new cookie";

diff --git a/src/cls/lock/cls_lock_ops.h b/src/cls/lock/cls_lock_ops.h
index 3df75f22ed1ec2037e2b02c541e6569f2e3faf91..4de050f186b916ceaf49cbc0a098961194c4f1d8 100644 (file)
--- a/src/cls/lock/cls_lock_ops.h
+++ b/src/cls/lock/cls_lock_ops.h
@@ -18,7 +18,7 @@ struct cls_lock_lock_op
   utime_t duration;
   uint8_t flags;
 
-  cls_lock_lock_op() : type(LOCK_NONE), flags(0) {}
+  cls_lock_lock_op() : type(ClsLockType::NONE), flags(0) {}
 
   void encode(ceph::buffer::list &bl) const {
     ENCODE_START(1, 1, bl);
@@ -128,7 +128,7 @@ struct cls_lock_get_info_reply
   ClsLockType lock_type;
   std::string tag;
 
-  cls_lock_get_info_reply() : lock_type(LOCK_NONE) {}
+  cls_lock_get_info_reply() : lock_type(ClsLockType::NONE) {}
 
   void encode(ceph::buffer::list &bl, uint64_t features) const {
     ENCODE_START(1, 1, bl);
@@ -180,7 +180,7 @@ struct cls_lock_assert_op
   std::string cookie;
   std::string tag;
 
-  cls_lock_assert_op() : type(LOCK_NONE) {}
+  cls_lock_assert_op() : type(ClsLockType::NONE) {}
 
   void encode(ceph::buffer::list &bl) const {
     ENCODE_START(1, 1, bl);
@@ -214,7 +214,7 @@ struct cls_lock_set_cookie_op
   std::string tag;
   std::string new_cookie;
 
-  cls_lock_set_cookie_op() : type(LOCK_NONE) {}
+  cls_lock_set_cookie_op() : type(ClsLockType::NONE) {}
 
   void encode(ceph::buffer::list &bl) const {
     ENCODE_START(1, 1, bl);

diff --git a/src/cls/lock/cls_lock_types.cc b/src/cls/lock/cls_lock_types.cc
index 9a9a510f3df5bb992cc3f0c4bfe77267920371dc..904ed268eaf15fa09561a0cd52ecbe351e9e7a30 100644 (file)
--- a/src/cls/lock/cls_lock_types.cc
+++ b/src/cls/lock/cls_lock_types.cc
@@ -69,7 +69,7 @@ void locker_info_t::generate_test_instances(std::list<locker_info_t*>& o)
 
 void lock_info_t::dump(ceph::Formatter *f) const
 {
-  f->dump_int("lock_type", lock_type);
+  f->dump_int("lock_type", static_cast<int>(lock_type));
   f->dump_string("tag", tag);
   f->open_array_section("lockers");
   for (auto &i : lockers) {
@@ -91,7 +91,7 @@ void lock_info_t::generate_test_instances(std::list<lock_info_t *>& o)
   generate_test_addr(info.addr, 1, 2);
   info.description = "description";
   i->lockers[id] = info;
-  i->lock_type = LOCK_EXCLUSIVE;
+  i->lock_type = ClsLockType::EXCLUSIVE;
   i->tag = "tag";
   o.push_back(i);
   o.push_back(new lock_info_t);

diff --git a/src/cls/lock/cls_lock_types.h b/src/cls/lock/cls_lock_types.h
index df05c69c24a14cf032d16251225aed9da0b9853a..13f3e147810845ff6522d687b6d91bd895806cd7 100644 (file)
--- a/src/cls/lock/cls_lock_types.h
+++ b/src/cls/lock/cls_lock_types.h
@@ -13,23 +13,23 @@
 #define LOCK_FLAG_MAY_RENEW 0x1    /* idempotent lock acquire */
 #define LOCK_FLAG_MUST_RENEW 0x2   /* lock must already be acquired */
 
-enum ClsLockType {
-  LOCK_NONE                = 0,
-  LOCK_EXCLUSIVE           = 1,
-  LOCK_SHARED              = 2,
-  LOCK_EXCLUSIVE_EPHEMERAL = 3, /* lock object is removed @ unlock */
+enum class ClsLockType {
+  NONE                = 0,
+  EXCLUSIVE           = 1,
+  SHARED              = 2,
+  EXCLUSIVE_EPHEMERAL = 3, /* lock object is removed @ unlock */
 };
 
 inline const char *cls_lock_type_str(ClsLockType type)
 {
     switch (type) {
-      case LOCK_NONE:
+      case ClsLockType::NONE:
        return "none";
-      case LOCK_EXCLUSIVE:
+      case ClsLockType::EXCLUSIVE:
        return "exclusive";
-      case LOCK_SHARED:
+      case ClsLockType::SHARED:
        return "shared";
-      case LOCK_EXCLUSIVE_EPHEMERAL:
+      case ClsLockType::EXCLUSIVE_EPHEMERAL:
        return "exclusive-ephemeral";
       default:
        return "<unknown>";
@@ -37,17 +37,17 @@ inline const char *cls_lock_type_str(ClsLockType type)
 }
 
 inline bool cls_lock_is_exclusive(ClsLockType type) {
-  return LOCK_EXCLUSIVE == type || LOCK_EXCLUSIVE_EPHEMERAL == type;
+  return ClsLockType::EXCLUSIVE == type || ClsLockType::EXCLUSIVE_EPHEMERAL == type;
 }
 
 inline bool cls_lock_is_ephemeral(ClsLockType type) {
-  return LOCK_EXCLUSIVE_EPHEMERAL == type;
+  return ClsLockType::EXCLUSIVE_EPHEMERAL == type;
 }
 
 inline bool cls_lock_is_valid(ClsLockType type) {
-  return LOCK_SHARED == type ||
-    LOCK_EXCLUSIVE == type ||
-    LOCK_EXCLUSIVE_EPHEMERAL == type;
+  return ClsLockType::SHARED == type ||
+    ClsLockType::EXCLUSIVE == type ||
+    ClsLockType::EXCLUSIVE_EPHEMERAL == type;
 }
 
 namespace rados {
@@ -161,7 +161,8 @@ namespace rados {
           decode(tag, bl);
           DECODE_FINISH(bl);
         }
-        lock_info_t() : lock_type(LOCK_NONE) {}
+
+        lock_info_t() : lock_type(ClsLockType::NONE) {}
         void dump(ceph::Formatter *f) const;
         static void generate_test_instances(std::list<lock_info_t *>& o);
       };

diff --git a/src/include/compat.h b/src/include/compat.h
index 8a855c188110cff8c4d2ba5a961bc8363054d49a..d91cd108d10e1ef1ebb07bcc84b3775f7e5d31a2 100644 (file)
--- a/src/include/compat.h
+++ b/src/include/compat.h
@@ -208,6 +208,18 @@ char *ceph_strerror_r(int errnum, char *buf, size_t buflen);
 
 #include "include/win32/winsock_compat.h"
 
+#include <windows.h>
+
+// There are a few name collisions between Windows headers and Ceph.
+// Updating Ceph definitions would be the prefferable fix in order to avoid
+// confussion, unless it requires too many changes, in which case we're going
+// to redefine Windows values by adding the "WIN32_" prefix.
+#define WIN32_DELETE 0x00010000L
+#undef DELETE
+
+#define WIN32_ERROR 0
+#undef ERROR
+
 typedef _sigset_t sigset_t;
 
 typedef int uid_t;

diff --git a/src/librados/librados_cxx.cc b/src/librados/librados_cxx.cc
index bc399ea82e51ab48432eadd3f90f2c78095d952d..9fb8168ba05ac0022e93a04a072e2838d7721c98 100644 (file)
--- a/src/librados/librados_cxx.cc
+++ b/src/librados/librados_cxx.cc
@@ -1756,7 +1756,7 @@ int librados::IoCtx::lock_exclusive(const std::string &oid, const std::string &n
   if (duration)
     dur.set_from_timeval(duration);
 
-  return rados::cls::lock::lock(this, oid, name, LOCK_EXCLUSIVE, cookie, "",
+  return rados::cls::lock::lock(this, oid, name, ClsLockType::EXCLUSIVE, cookie, "",
                                description, dur, flags);
 }
 
@@ -1769,7 +1769,7 @@ int librados::IoCtx::lock_shared(const std::string &oid, const std::string &name
   if (duration)
     dur.set_from_timeval(duration);
 
-  return rados::cls::lock::lock(this, oid, name, LOCK_SHARED, cookie, tag,
+  return rados::cls::lock::lock(this, oid, name, ClsLockType::SHARED, cookie, tag,
                                description, dur, flags);
 }
 
@@ -1837,7 +1837,7 @@ int librados::IoCtx::list_lockers(const std::string &oid, const std::string &nam
   if (tag)
     *tag = tmp_tag;
   if (exclusive) {
-    if (tmp_type == LOCK_EXCLUSIVE)
+    if (tmp_type == ClsLockType::EXCLUSIVE)
       *exclusive = 1;
     else
       *exclusive = 0;

diff --git a/src/libradosstriper/RadosStriperImpl.cc b/src/libradosstriper/RadosStriperImpl.cc
index c484482caccbac62c1c8a83607c60f05bfd2716f..60fafd463960f9df9367990d322392943eece7bb 100644 (file)
--- a/src/libradosstriper/RadosStriperImpl.cc
+++ b/src/libradosstriper/RadosStriperImpl.cc
@@ -1069,7 +1069,7 @@ int libradosstriper::RadosStriperImpl::trunc(const std::string& soid, uint64_t s
   op.assert_exists();
   std::string lockCookie = RadosStriperImpl::getUUID();
   utime_t dur = utime_t();
-  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, LOCK_EXCLUSIVE, lockCookie, "", "", dur, 0);
+  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, ClsLockType::EXCLUSIVE, lockCookie, "", "", dur, 0);
   int rc = m_ioCtx.operate(firstObjOid, &op);
   if (rc) return rc;
   // load layout and size
@@ -1342,7 +1342,7 @@ int libradosstriper::RadosStriperImpl::openStripedObjectForRead(
   op.assert_exists();
   *lockCookie = getUUID();
   utime_t dur = utime_t();
-  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, LOCK_SHARED, *lockCookie, "Tag", "", dur, 0);
+  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, ClsLockType::SHARED, *lockCookie, "Tag", "", dur, 0);
   std::string firstObjOid = getObjectId(soid, 0);
   int rc = m_ioCtx.operate(firstObjOid, &op);
   if (rc) {
@@ -1371,7 +1371,7 @@ int libradosstriper::RadosStriperImpl::openStripedObjectForWrite(const std::stri
   op.assert_exists();
   *lockCookie = getUUID();
   utime_t dur = utime_t();
-  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, LOCK_SHARED, *lockCookie, "Tag", "", dur, 0);
+  rados::cls::lock::lock(&op, RADOS_LOCK_NAME, ClsLockType::SHARED, *lockCookie, "Tag", "", dur, 0);
   std::string firstObjOid = getObjectId(soid, 0);
   int rc = m_ioCtx.operate(firstObjOid, &op);
   if (rc) {

diff --git a/src/librbd/ManagedLock.cc b/src/librbd/ManagedLock.cc
index 870139f761dc6cc65a26bc5c062636934db024f9..27514a9a09fa5249c201ee4ec7ee5ea6a18b8d11 100644 (file)
--- a/src/librbd/ManagedLock.cc
+++ b/src/librbd/ManagedLock.cc
@@ -286,8 +286,8 @@ int ManagedLock<I>::assert_header_locked() {
   {
     std::lock_guard locker{m_lock};
     rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME,
-                                    (m_mode == EXCLUSIVE ? LOCK_EXCLUSIVE :
-                                                           LOCK_SHARED),
+                                    (m_mode == EXCLUSIVE ? ClsLockType::EXCLUSIVE :
+                                                           ClsLockType::SHARED),
                                     m_cookie,
                                     managed_lock::util::get_watcher_lock_tag());
   }

diff --git a/src/librbd/ObjectMap.cc b/src/librbd/ObjectMap.cc
index 8f998da11034c65efbeba01583522aad7e407ad8..65e3fc4a4c247441af7acfb75fc0e8090f2fa7c9 100644 (file)
--- a/src/librbd/ObjectMap.cc
+++ b/src/librbd/ObjectMap.cc
@@ -234,7 +234,7 @@ void ObjectMap<I>::aio_save(Context *on_finish) {
 
   librados::ObjectWriteOperation op;
   if (m_snap_id == CEPH_NOSNAP) {
-    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   }
   cls_client::object_map_save(&op, m_object_map);
 

diff --git a/src/librbd/image/RefreshRequest.cc b/src/librbd/image/RefreshRequest.cc
index 2ced9c8b1af2a4cf8cfd05811ead4eeddcc6374f..d70e026e36acb98ef36c55205117f0269db92ff1 100644 (file)
--- a/src/librbd/image/RefreshRequest.cc
+++ b/src/librbd/image/RefreshRequest.cc
@@ -295,7 +295,7 @@ Context *RefreshRequest<I>::handle_v1_get_locks(int *result) {
     *result = rados::cls::lock::get_lock_info_finish(&it, &m_lockers,
                                                      &lock_type, &m_lock_tag);
     if (*result == 0) {
-      m_exclusive_locked = (lock_type == LOCK_EXCLUSIVE);
+      m_exclusive_locked = (lock_type == ClsLockType::EXCLUSIVE);
     }
   }
   if (*result < 0) {
@@ -389,11 +389,11 @@ Context *RefreshRequest<I>::handle_v2_get_mutable_metadata(int *result) {
   }
 
   if (*result >= 0) {
-    ClsLockType lock_type = LOCK_NONE;
+    ClsLockType lock_type = ClsLockType::NONE;
     *result = rados::cls::lock::get_lock_info_finish(&it, &m_lockers,
                                                      &lock_type, &m_lock_tag);
     if (*result == 0) {
-      m_exclusive_locked = (lock_type == LOCK_EXCLUSIVE);
+      m_exclusive_locked = (lock_type == ClsLockType::EXCLUSIVE);
     }
   }
 

diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index 62c911ae5f2f16727c1c4ca3c84406a8c277e4d3..e3b9bc9ba909de8755ba797d19cd0ffe8e568ebf 100644 (file)
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -1394,7 +1394,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
     {
       std::shared_lock locker{ictx->image_lock};
       r = rados::cls::lock::lock(&ictx->md_ctx, ictx->header_oid, RBD_LOCK_NAME,
-                                exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED,
+                                exclusive ? ClsLockType::EXCLUSIVE : ClsLockType::SHARED,
                                 cookie, tag, "", utime_t(), 0);
       if (r < 0) {
         return r;

diff --git a/src/librbd/managed_lock/AcquireRequest.cc b/src/librbd/managed_lock/AcquireRequest.cc
index f1c2bbd50a27aebb1ac8a1edc98b300af4ff89bd..c0078b966aa6bd9c4ff27f0706bc2e8ddf301c1b 100644 (file)
--- a/src/librbd/managed_lock/AcquireRequest.cc
+++ b/src/librbd/managed_lock/AcquireRequest.cc
@@ -109,7 +109,7 @@ void AcquireRequest<I>::send_lock() {
 
   librados::ObjectWriteOperation op;
   rados::cls::lock::lock(&op, RBD_LOCK_NAME,
-                         m_exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED, m_cookie,
+                         m_exclusive ? ClsLockType::EXCLUSIVE : ClsLockType::SHARED, m_cookie,
                          util::get_watcher_lock_tag(), "", utime_t(), 0);
 
   using klass = AcquireRequest;

diff --git a/src/librbd/managed_lock/GetLockerRequest.cc b/src/librbd/managed_lock/GetLockerRequest.cc
index fb5bb32273120e0fd28b3f18aed6583ece58f355..6b2c27342bff1a912639ee9ca0cae8db1bf21e61 100644 (file)
--- a/src/librbd/managed_lock/GetLockerRequest.cc
+++ b/src/librbd/managed_lock/GetLockerRequest.cc
@@ -58,7 +58,7 @@ void GetLockerRequest<I>::handle_get_lockers(int r) {
 
   std::map<rados::cls::lock::locker_id_t,
            rados::cls::lock::locker_info_t> lockers;
-  ClsLockType lock_type = LOCK_NONE;
+  ClsLockType lock_type = ClsLockType::NONE;
   std::string lock_tag;
   if (r == 0) {
     auto it = m_out_bl.cbegin();
@@ -84,11 +84,11 @@ void GetLockerRequest<I>::handle_get_lockers(int r) {
     return;
   }
 
-  if (m_exclusive && lock_type == LOCK_SHARED) {
+  if (m_exclusive && lock_type == ClsLockType::SHARED) {
     ldout(m_cct, 5) << "incompatible shared lock type detected" << dendl;
     finish(-EBUSY);
     return;
-  } else if (!m_exclusive && lock_type == LOCK_EXCLUSIVE) {
+  } else if (!m_exclusive && lock_type == ClsLockType::EXCLUSIVE) {
     ldout(m_cct, 5) << "incompatible exclusive lock type detected" << dendl;
     finish(-EBUSY);
     return;

diff --git a/src/librbd/managed_lock/ReacquireRequest.cc b/src/librbd/managed_lock/ReacquireRequest.cc
index dc5624d44108f6a99bac5a0b60e573d0372f04e6..9eaa5156997a48c73b9ef524df406f054fb065a7 100644 (file)
--- a/src/librbd/managed_lock/ReacquireRequest.cc
+++ b/src/librbd/managed_lock/ReacquireRequest.cc
@@ -47,7 +47,7 @@ void ReacquireRequest<I>::set_cookie() {
 
   librados::ObjectWriteOperation op;
   rados::cls::lock::set_cookie(&op, RBD_LOCK_NAME,
-                               m_exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED,
+                               m_exclusive ? ClsLockType::EXCLUSIVE : ClsLockType::SHARED,
                                m_old_cookie, util::get_watcher_lock_tag(),
                                m_new_cookie);
 

diff --git a/src/librbd/object_map/LockRequest.cc b/src/librbd/object_map/LockRequest.cc
index 4ed4fa1b823077329f6477d7861c88bb7a3d0efe..b9dc3c42e5465b01673f51b05fc968bc71621f83 100644 (file)
--- a/src/librbd/object_map/LockRequest.cc
+++ b/src/librbd/object_map/LockRequest.cc
@@ -35,7 +35,7 @@ void LockRequest<I>::send_lock() {
   ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
 
   librados::ObjectWriteOperation op;
-  rados::cls::lock::lock(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "", "",
+  rados::cls::lock::lock(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "", "",
                            utime_t(), 0);
 
   using klass = LockRequest<I>;

diff --git a/src/librbd/object_map/RefreshRequest.cc b/src/librbd/object_map/RefreshRequest.cc
index 1af868d287343feadc7013f373a7d622b526f476..d9febda66daaa82179f1e17209a1afd0a7ccebb2 100644 (file)
--- a/src/librbd/object_map/RefreshRequest.cc
+++ b/src/librbd/object_map/RefreshRequest.cc
@@ -236,7 +236,7 @@ void RefreshRequest<I>::send_resize() {
 
   librados::ObjectWriteOperation op;
   if (m_snap_id == CEPH_NOSNAP) {
-    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   }
   if (m_truncate_on_disk_object_map) {
     op.truncate(0);

diff --git a/src/librbd/object_map/ResizeRequest.cc b/src/librbd/object_map/ResizeRequest.cc
index 89e39b670d8a5f8301df7c3ac2144d61e39b19bb..91a3140ed52fd7e8394329d6df78db1eb13b4efc 100644 (file)
--- a/src/librbd/object_map/ResizeRequest.cc
+++ b/src/librbd/object_map/ResizeRequest.cc
@@ -42,7 +42,7 @@ void ResizeRequest::send() {
 
   librados::ObjectWriteOperation op;
   if (m_snap_id == CEPH_NOSNAP) {
-    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   }
   cls_client::object_map_resize(&op, m_num_objs, m_default_object_state);
 

diff --git a/src/librbd/object_map/SnapshotCreateRequest.cc b/src/librbd/object_map/SnapshotCreateRequest.cc
index 729af867fd20af600100dc3d5ba850ce6267535d..3b2e7ee82966664e259ad08d80f64e0b46e03217 100644 (file)
--- a/src/librbd/object_map/SnapshotCreateRequest.cc
+++ b/src/librbd/object_map/SnapshotCreateRequest.cc
@@ -121,7 +121,7 @@ bool SnapshotCreateRequest::send_add_snapshot() {
   m_state = STATE_ADD_SNAPSHOT;
 
   librados::ObjectWriteOperation op;
-  rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+  rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   cls_client::object_map_snap_add(&op);
 
   librados::AioCompletion *rados_completion = create_callback_completion();

diff --git a/src/librbd/object_map/SnapshotRemoveRequest.cc b/src/librbd/object_map/SnapshotRemoveRequest.cc
index a29d78f74c72484513c98e494b23b29857c0c75b..1c2ffc753f275a7866c35cee5a9884e3ae6fd9bd 100644 (file)
--- a/src/librbd/object_map/SnapshotRemoveRequest.cc
+++ b/src/librbd/object_map/SnapshotRemoveRequest.cc
@@ -91,7 +91,7 @@ void SnapshotRemoveRequest::remove_snapshot() {
 
   librados::ObjectWriteOperation op;
   if (m_next_snap_id == CEPH_NOSNAP) {
-    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   }
   cls_client::object_map_snap_remove(&op, m_snap_object_map);
 

diff --git a/src/librbd/object_map/SnapshotRollbackRequest.cc b/src/librbd/object_map/SnapshotRollbackRequest.cc
index 476a33b2e1acc9a527da4bf560bff4b554b6822f..7c2f441cc3ac99e63ab547a1d727f3a0d05bc0d9 100644 (file)
--- a/src/librbd/object_map/SnapshotRollbackRequest.cc
+++ b/src/librbd/object_map/SnapshotRollbackRequest.cc
@@ -104,7 +104,7 @@ void SnapshotRollbackRequest::send_write_map() {
   m_state = STATE_WRITE_MAP;
 
   librados::ObjectWriteOperation op;
-  rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+  rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   op.write_full(m_read_bl);
 
   librados::AioCompletion *rados_completion = create_callback_completion();

diff --git a/src/librbd/object_map/UpdateRequest.cc b/src/librbd/object_map/UpdateRequest.cc
index 53a604bcf248e46aaacf458d41824ea41900b223..30a1f2121bd1ba2c35d87fdcb0b4e344be10535d 100644 (file)
--- a/src/librbd/object_map/UpdateRequest.cc
+++ b/src/librbd/object_map/UpdateRequest.cc
@@ -52,7 +52,7 @@ void UpdateRequest<I>::update_object_map() {
 
   librados::ObjectWriteOperation op;
   if (m_snap_id == CEPH_NOSNAP) {
-    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, LOCK_EXCLUSIVE, "", "");
+    rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
   }
   cls_client::object_map_update(&op, m_update_start_object_no,
                                 m_update_end_object_no, m_new_state,

diff --git a/src/mds/CDentry.h b/src/mds/CDentry.h
index 8bfdf0009b315893036fa5a277414d9377111391..98c37ca2f323465ee61dc133b5dac7c65f0bdd98 100644 (file)
--- a/src/mds/CDentry.h
+++ b/src/mds/CDentry.h
@@ -30,7 +30,7 @@
 #include "MDSCacheObject.h"
 #include "MDSContext.h"
 #include "SimpleLock.h"
-#include "LocalLock.h"
+#include "LocalLockC.h"
 #include "ScrubHeader.h"
 
 class CInode;
@@ -344,7 +344,7 @@ public:
   static LockType versionlock_type;
 
   SimpleLock lock; // FIXME referenced containers not in mempool
-  LocalLock versionlock; // FIXME referenced containers not in mempool
+  LocalLockC versionlock; // FIXME referenced containers not in mempool
 
   mempool::mds_co::map<client_t,ClientLease*> client_lease_map;
   std::map<int, std::unique_ptr<BatchOp>> batch_ops;

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index 5c84c533f6bd72d0e89ea73a7519cfd53d0a48c0..23bad93ee5041de3f6a9c9b703dac394240d1b78 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -35,7 +35,7 @@
 #include "CDentry.h"
 #include "SimpleLock.h"
 #include "ScatterLock.h"
-#include "LocalLock.h"
+#include "LocalLockC.h"
 #include "Capability.h"
 #include "SnapRealm.h"
 #include "Mutation.h"
@@ -985,7 +985,7 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   static LockType policylock_type;
 
   // FIXME not part of mempool
-  LocalLock  versionlock;
+  LocalLockC  versionlock;
   SimpleLock authlock;
   SimpleLock linklock;
   ScatterLock dirfragtreelock;

diff --git a/src/mds/LocalLock.h b/src/mds/LocalLock.h
deleted file mode 100644 (file)
index ed401ea..0000000
--- a/src/mds/LocalLock.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
-// vim: ts=8 sw=2 smarttab
-/*
- * Ceph - scalable distributed file system
- *
- * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
- *
- * This is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software 
- * Foundation.  See file COPYING.
- * 
- */
-
-
-#ifndef CEPH_LOCALLOCK_H
-#define CEPH_LOCALLOCK_H
-
-#include "SimpleLock.h"
-
-class LocalLock : public SimpleLock {
-public:
-  LocalLock(MDSCacheObject *o, LockType *t) : 
-    SimpleLock(o, t) {
-    set_state(LOCK_LOCK); // always.
-  }
-
-  bool is_locallock() const override {
-    return true;
-  }
-
-  bool can_xlock_local() const {
-    return !is_wrlocked() && (get_xlock_by() == MutationRef());
-  }
-
-  bool can_wrlock() const {
-    return !is_xlocked();
-  }
-  void get_wrlock(client_t client) {
-    ceph_assert(can_wrlock());
-    SimpleLock::get_wrlock();
-    last_wrlock_client = client;
-  }
-  void put_wrlock() {
-    SimpleLock::put_wrlock();
-    if (get_num_wrlocks() == 0)
-      last_wrlock_client = client_t();
-  }
-  client_t get_last_wrlock_client() const {
-    return last_wrlock_client;
-  }
-
-  void print(std::ostream& out) const override {
-    out << "(";
-    _print(out);
-    if (last_wrlock_client >= 0)
-      out << " last_client=" << last_wrlock_client;
-    out << ")";
-  }
-
-private:
-  client_t last_wrlock_client;
-};
-#endif

diff --git a/src/mds/LocalLockC.h b/src/mds/LocalLockC.h
new file mode 100644 (file)
index 0000000..96cea93
--- /dev/null
+++ b/src/mds/LocalLockC.h
@@ -0,0 +1,64 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software 
+ * Foundation.  See file COPYING.
+ * 
+ */
+
+
+#ifndef CEPH_LOCALLOCK_H
+#define CEPH_LOCALLOCK_H
+
+#include "SimpleLock.h"
+
+class LocalLockC : public SimpleLock {
+public:
+  LocalLockC(MDSCacheObject *o, LockType *t) : 
+    SimpleLock(o, t) {
+    set_state(LOCK_LOCK); // always.
+  }
+
+  bool is_locallock() const override {
+    return true;
+  }
+
+  bool can_xlock_local() const {
+    return !is_wrlocked() && (get_xlock_by() == MutationRef());
+  }
+
+  bool can_wrlock() const {
+    return !is_xlocked();
+  }
+  void get_wrlock(client_t client) {
+    ceph_assert(can_wrlock());
+    SimpleLock::get_wrlock();
+    last_wrlock_client = client;
+  }
+  void put_wrlock() {
+    SimpleLock::put_wrlock();
+    if (get_num_wrlocks() == 0)
+      last_wrlock_client = client_t();
+  }
+  client_t get_last_wrlock_client() const {
+    return last_wrlock_client;
+  }
+
+  void print(std::ostream& out) const override {
+    out << "(";
+    _print(out);
+    if (last_wrlock_client >= 0)
+      out << " last_client=" << last_wrlock_client;
+    out << ")";
+  }
+
+private:
+  client_t last_wrlock_client;
+};
+#endif

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index 9a249555da4e7e57ebbd45a45c1882548497c430..07ec858a4af4e956d9f38df3dfdf254c23a6d71a 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -1703,7 +1703,7 @@ void Locker::wrlock_force(SimpleLock *lock, MutationRef& mut)
 {
   if (lock->get_type() == CEPH_LOCK_IVERSION ||
       lock->get_type() == CEPH_LOCK_DVERSION)
-    return local_wrlock_grab(static_cast<LocalLock*>(lock), mut);
+    return local_wrlock_grab(static_cast<LocalLockC*>(lock), mut);
 
   dout(7) << "wrlock_force  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
@@ -1750,7 +1750,7 @@ bool Locker::wrlock_start(const MutationImpl::LockOp &op, MDRequestRef& mut)
   SimpleLock *lock = op.lock;
   if (lock->get_type() == CEPH_LOCK_IVERSION ||
       lock->get_type() == CEPH_LOCK_DVERSION)
-    return local_wrlock_start(static_cast<LocalLock*>(lock), mut);
+    return local_wrlock_start(static_cast<LocalLockC*>(lock), mut);
 
   dout(10) << "wrlock_start " << *lock << " on " << *lock->get_parent() << dendl;
 
@@ -1893,7 +1893,7 @@ bool Locker::xlock_start(SimpleLock *lock, MDRequestRef& mut)
 {
   if (lock->get_type() == CEPH_LOCK_IVERSION ||
       lock->get_type() == CEPH_LOCK_DVERSION)
-    return local_xlock_start(static_cast<LocalLock*>(lock), mut);
+    return local_xlock_start(static_cast<LocalLockC*>(lock), mut);
 
   dout(7) << "xlock_start on " << *lock << " on " << *lock->get_parent() << dendl;
   client_t client = mut->get_client();
@@ -5194,7 +5194,7 @@ void Locker::scatter_tempsync(ScatterLock *lock, bool *need_issue)
 // ==========================================================================
 // local lock
 
-void Locker::local_wrlock_grab(LocalLock *lock, MutationRef& mut)
+void Locker::local_wrlock_grab(LocalLockC *lock, MutationRef& mut)
 {
   dout(7) << "local_wrlock_grab  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
@@ -5207,7 +5207,7 @@ void Locker::local_wrlock_grab(LocalLock *lock, MutationRef& mut)
   ceph_assert(it->is_wrlock());
 }
 
-bool Locker::local_wrlock_start(LocalLock *lock, MDRequestRef& mut)
+bool Locker::local_wrlock_start(LocalLockC *lock, MDRequestRef& mut)
 {
   dout(7) << "local_wrlock_start  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
@@ -5227,7 +5227,7 @@ bool Locker::local_wrlock_start(LocalLock *lock, MDRequestRef& mut)
 void Locker::local_wrlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut)
 {
   ceph_assert(it->is_wrlock());
-  LocalLock *lock = static_cast<LocalLock*>(it->lock);
+  LocalLockC *lock = static_cast<LocalLockC*>(it->lock);
   dout(7) << "local_wrlock_finish  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
   lock->put_wrlock();
@@ -5239,7 +5239,7 @@ void Locker::local_wrlock_finish(const MutationImpl::lock_iterator& it, Mutation
   }
 }
 
-bool Locker::local_xlock_start(LocalLock *lock, MDRequestRef& mut)
+bool Locker::local_xlock_start(LocalLockC *lock, MDRequestRef& mut)
 {
   dout(7) << "local_xlock_start  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
@@ -5258,7 +5258,7 @@ bool Locker::local_xlock_start(LocalLock *lock, MDRequestRef& mut)
 void Locker::local_xlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut)
 {
   ceph_assert(it->is_xlock());
-  LocalLock *lock = static_cast<LocalLock*>(it->lock);
+  LocalLockC *lock = static_cast<LocalLockC*>(it->lock);
   dout(7) << "local_xlock_finish  on " << *lock
          << " on " << *lock->get_parent() << dendl;  
   lock->put_xlock();

diff --git a/src/mds/Locker.h b/src/mds/Locker.h
index a3d3ec6a6ec5d1cd6d4c52168e5ab20f26c8ff9f..e7b0688aa547704f014b05fdec88063b4d5faaf7 100644 (file)
--- a/src/mds/Locker.h
+++ b/src/mds/Locker.h
@@ -36,7 +36,7 @@ class CDentry;
 class Capability;
 class SimpleLock;
 class ScatterLock;
-class LocalLock;
+class LocalLockC;
 
 class Locker {
 public:
@@ -153,7 +153,7 @@ public:
   bool is_revoking_any_caps_from(client_t client);
 
   // local
-  void local_wrlock_grab(LocalLock *lock, MutationRef& mut);
+  void local_wrlock_grab(LocalLockC *lock, MutationRef& mut);
 
   // file
   void file_eval(ScatterLock *lock, bool *need_issue);
@@ -224,9 +224,9 @@ protected:
   void _do_cap_release(client_t client, inodeno_t ino, uint64_t cap_id, ceph_seq_t mseq, ceph_seq_t seq);
   void caps_tick();
 
-  bool local_wrlock_start(LocalLock *lock, MDRequestRef& mut);
+  bool local_wrlock_start(LocalLockC *lock, MDRequestRef& mut);
   void local_wrlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut);
-  bool local_xlock_start(LocalLock *lock, MDRequestRef& mut);
+  bool local_xlock_start(LocalLockC *lock, MDRequestRef& mut);
   void local_xlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut);
 
   void handle_file_lock(ScatterLock *lock, const cref_t<MLock> &m);

diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index 630ff3d07aa0e5c21125dad22339a3c40f891104..b2a374e8a3ae75adf3b71137d5228d4c7557ec22 100644 (file)
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -33,6 +33,7 @@
 #include "include/mempool.h"
 
 #include "msg/msg_types.h"
+#include "include/compat.h"
 #include "include/types.h"
 #include "include/utime.h"
 #include "include/CompatSet.h"

diff --git a/src/test/cls_lock/test_cls_lock.cc b/src/test/cls_lock/test_cls_lock.cc
index 3ecd20ccfdbc308622a2f3175cd523d0ebde0791..405befa033543b6f2f77edc59f70a77248b79a77 100644 (file)
--- a/src/test/cls_lock/test_cls_lock.cc
+++ b/src/test/cls_lock/test_cls_lock.cc
@@ -33,7 +33,7 @@ using namespace rados::cls::lock;
 void lock_info(IoCtx *ioctx, string& oid, string& name, map<locker_id_t, locker_info_t>& lockers,
               ClsLockType *assert_type, string *assert_tag)
 {
-  ClsLockType lock_type = LOCK_NONE;
+  ClsLockType lock_type = ClsLockType::NONE;
   string tag;
   lockers.clear();
   ASSERT_EQ(0, get_lock_info(ioctx, oid, name, &lockers, &lock_type, &tag));
@@ -69,8 +69,8 @@ TEST(ClsLock, TestMultiLocking) {
   ASSERT_EQ("", create_one_pool_pp(pool_name, cluster));
   IoCtx ioctx;
   cluster.ioctx_create(pool_name.c_str(), ioctx);
-  ClsLockType lock_type_shared = LOCK_SHARED;
-  ClsLockType lock_type_exclusive = LOCK_EXCLUSIVE;
+  ClsLockType lock_type_shared = ClsLockType::SHARED;
+  ClsLockType lock_type_exclusive = ClsLockType::EXCLUSIVE;
 
 
   Rados cluster2;
@@ -357,39 +357,39 @@ TEST(ClsLock, TestSetCookie) {
   string cookie = "cookie";
   string new_cookie = "new cookie";
   librados::ObjectWriteOperation op1;
-  set_cookie(&op1, name, LOCK_SHARED, cookie, tag, new_cookie);
+  set_cookie(&op1, name, ClsLockType::SHARED, cookie, tag, new_cookie);
   ASSERT_EQ(-ENOENT, ioctx.operate(oid, &op1));
 
   librados::ObjectWriteOperation op2;
-  lock(&op2, name, LOCK_SHARED, cookie, tag, "", utime_t{}, 0);
+  lock(&op2, name, ClsLockType::SHARED, cookie, tag, "", utime_t{}, 0);
   ASSERT_EQ(0, ioctx.operate(oid, &op2));
 
   librados::ObjectWriteOperation op3;
-  lock(&op3, name, LOCK_SHARED, "cookie 2", tag, "", utime_t{}, 0);
+  lock(&op3, name, ClsLockType::SHARED, "cookie 2", tag, "", utime_t{}, 0);
   ASSERT_EQ(0, ioctx.operate(oid, &op3));
 
   librados::ObjectWriteOperation op4;
-  set_cookie(&op4, name, LOCK_SHARED, cookie, tag, cookie);
+  set_cookie(&op4, name, ClsLockType::SHARED, cookie, tag, cookie);
   ASSERT_EQ(-EBUSY, ioctx.operate(oid, &op4));
 
   librados::ObjectWriteOperation op5;
-  set_cookie(&op5, name, LOCK_SHARED, cookie, "wrong tag", new_cookie);
+  set_cookie(&op5, name, ClsLockType::SHARED, cookie, "wrong tag", new_cookie);
   ASSERT_EQ(-EBUSY, ioctx.operate(oid, &op5));
 
   librados::ObjectWriteOperation op6;
-  set_cookie(&op6, name, LOCK_SHARED, "wrong cookie", tag, new_cookie);
+  set_cookie(&op6, name, ClsLockType::SHARED, "wrong cookie", tag, new_cookie);
   ASSERT_EQ(-EBUSY, ioctx.operate(oid, &op6));
 
   librados::ObjectWriteOperation op7;
-  set_cookie(&op7, name, LOCK_EXCLUSIVE, cookie, tag, new_cookie);
+  set_cookie(&op7, name, ClsLockType::EXCLUSIVE, cookie, tag, new_cookie);
   ASSERT_EQ(-EBUSY, ioctx.operate(oid, &op7));
 
   librados::ObjectWriteOperation op8;
-  set_cookie(&op8, name, LOCK_SHARED, cookie, tag, "cookie 2");
+  set_cookie(&op8, name, ClsLockType::SHARED, cookie, tag, "cookie 2");
   ASSERT_EQ(-EBUSY, ioctx.operate(oid, &op8));
 
   librados::ObjectWriteOperation op9;
-  set_cookie(&op9, name, LOCK_SHARED, cookie, tag, new_cookie);
+  set_cookie(&op9, name, ClsLockType::SHARED, cookie, tag, new_cookie);
   ASSERT_EQ(0, ioctx.operate(oid, &op9));
 
   ASSERT_EQ(0, destroy_one_pool_pp(pool_name, cluster));

diff --git a/src/test/librbd/managed_lock/test_mock_AcquireRequest.cc b/src/test/librbd/managed_lock/test_mock_AcquireRequest.cc
index 279a8182631faab146372a846d57d85ead53adb2..6e42d95bb7e27e344b8afa890af759e363ca48d4 100644 (file)
--- a/src/test/librbd/managed_lock/test_mock_AcquireRequest.cc
+++ b/src/test/librbd/managed_lock/test_mock_AcquireRequest.cc
@@ -91,7 +91,7 @@ MATCHER_P(IsLockType, exclusive, "") {
   bl.share(arg);
   auto iter = bl.cbegin();
   decode(op, iter);
-  return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
+  return op.type == (exclusive ? ClsLockType::EXCLUSIVE : ClsLockType::SHARED);
 }
 
 } // anonymous namespace

diff --git a/src/test/librbd/managed_lock/test_mock_GetLockerRequest.cc b/src/test/librbd/managed_lock/test_mock_GetLockerRequest.cc
index 69e987e4d09be831cdaf91878803c8b275b3c675..1850526a7fc2ae43ad2c9e87f5b0e535ce51920e 100644 (file)
--- a/src/test/librbd/managed_lock/test_mock_GetLockerRequest.cc
+++ b/src/test/librbd/managed_lock/test_mock_GetLockerRequest.cc
@@ -90,7 +90,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, SuccessExclusive) {
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
                        "auto 123", util::get_watcher_lock_tag(),
-                       LOCK_EXCLUSIVE);
+                       ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;
@@ -117,7 +117,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, SuccessShared) {
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
                        "auto 123", util::get_watcher_lock_tag(),
-                       LOCK_SHARED);
+                       ClsLockType::SHARED);
 
   C_SaferCond ctx;
   Locker locker;
@@ -143,7 +143,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoError) {
 
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, -EINVAL, entity_name_t::CLIENT(1), "",
-                       "", "", LOCK_EXCLUSIVE);
+                       "", "", ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;
@@ -164,7 +164,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoEmpty) {
 
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, -ENOENT, entity_name_t::CLIENT(1), "",
-                       "", "", LOCK_EXCLUSIVE);
+                       "", "", ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;
@@ -185,7 +185,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoExternalTag) {
 
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
-                       "auto 123", "external tag", LOCK_EXCLUSIVE);
+                       "auto 123", "external tag", ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;
@@ -207,7 +207,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoIncompatibleShared) {
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
                        "auto 123", util::get_watcher_lock_tag(),
-                       LOCK_SHARED);
+                       ClsLockType::SHARED);
 
   C_SaferCond ctx;
   Locker locker;
@@ -229,7 +229,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoIncompatibleExclusive) {
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
                        "auto 123", util::get_watcher_lock_tag(),
-                       LOCK_EXCLUSIVE);
+                       ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;
@@ -251,7 +251,7 @@ TEST_F(TestMockManagedLockGetLockerRequest, GetLockInfoExternalCookie) {
   InSequence seq;
   expect_get_lock_info(mock_image_ctx, 0, entity_name_t::CLIENT(1), "1.2.3.4",
                        "external cookie", util::get_watcher_lock_tag(),
-                       LOCK_EXCLUSIVE);
+                       ClsLockType::EXCLUSIVE);
 
   C_SaferCond ctx;
   Locker locker;

diff --git a/src/test/librbd/managed_lock/test_mock_ReacquireRequest.cc b/src/test/librbd/managed_lock/test_mock_ReacquireRequest.cc
index 993be5aabdcc1e85173185db1bfe3ed3c8ff8f93..e295f8fc3d962136618deee1cccb3691cdfe08a8 100644 (file)
--- a/src/test/librbd/managed_lock/test_mock_ReacquireRequest.cc
+++ b/src/test/librbd/managed_lock/test_mock_ReacquireRequest.cc
@@ -24,7 +24,7 @@ MATCHER_P(IsLockType, exclusive, "") {
   bl.share(arg);
   auto iter = bl.cbegin();
   decode(op, iter);
-  return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
+  return op.type == (exclusive ? ClsLockType::EXCLUSIVE : ClsLockType::SHARED);
 }
 
 } // anonymous namespace

diff --git a/src/test/librbd/test_ImageWatcher.cc b/src/test/librbd/test_ImageWatcher.cc
index 22bf95e1e24668233ed8f0d0f1b744217edf306e..209133e9ec662eecb69307f51b610c0ce8bd6372 100644 (file)
--- a/src/test/librbd/test_ImageWatcher.cc
+++ b/src/test/librbd/test_ImageWatcher.cc
@@ -339,7 +339,7 @@ TEST_F(TestImageWatcher, NotifyFlatten) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_FLATTEN, create_response_message(0)}};
@@ -373,7 +373,7 @@ TEST_F(TestImageWatcher, NotifyResize) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_RESIZE, create_response_message(0)}};
@@ -407,7 +407,7 @@ TEST_F(TestImageWatcher, NotifyRebuildObjectMap) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_REBUILD_OBJECT_MAP, create_response_message(0)}};
@@ -442,7 +442,7 @@ TEST_F(TestImageWatcher, NotifySnapCreate) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_CREATE, create_response_message(0)}};
@@ -477,7 +477,7 @@ TEST_F(TestImageWatcher, NotifySnapCreateError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_CREATE, create_response_message(-EEXIST)}};
@@ -501,7 +501,7 @@ TEST_F(TestImageWatcher, NotifySnapRename) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_RENAME, create_response_message(0)}};
@@ -523,7 +523,7 @@ TEST_F(TestImageWatcher, NotifySnapRenameError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_RENAME, create_response_message(-EEXIST)}};
@@ -545,7 +545,7 @@ TEST_F(TestImageWatcher, NotifySnapRemove) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_REMOVE, create_response_message(0)}};
@@ -569,7 +569,7 @@ TEST_F(TestImageWatcher, NotifySnapProtect) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_PROTECT, create_response_message(0)}};
@@ -593,7 +593,7 @@ TEST_F(TestImageWatcher, NotifySnapUnprotect) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_SNAP_UNPROTECT, create_response_message(0)}};
@@ -617,7 +617,7 @@ TEST_F(TestImageWatcher, NotifyRename) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_RENAME, create_response_message(0)}};
@@ -639,7 +639,7 @@ TEST_F(TestImageWatcher, NotifyAsyncTimedOut) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_FLATTEN, {}}};
@@ -659,7 +659,7 @@ TEST_F(TestImageWatcher, NotifyAsyncError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_FLATTEN, create_response_message(-EIO)}};
@@ -679,7 +679,7 @@ TEST_F(TestImageWatcher, NotifyAsyncCompleteError) {
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
         "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_FLATTEN, create_response_message(0)}};
@@ -712,7 +712,7 @@ TEST_F(TestImageWatcher, NotifyAsyncRequestTimedOut) {
   ictx->config.set_val("rbd_request_timed_out_seconds", "0");
 
   ASSERT_EQ(0, register_image_watch(*ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE,
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE,
                          "auto " + stringify(m_watch_ctx->get_handle())));
 
   m_notify_acks = {{NOTIFY_OP_FLATTEN, create_response_message(0)}};

diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc
index ce6e939f8a83e6ddceebef1ff9126394ec4745e5..283fd7c55923052d9fbbd1f1c236a4198fd071e7 100644 (file)
--- a/src/test/librbd/test_internal.cc
+++ b/src/test/librbd/test_internal.cc
@@ -229,7 +229,7 @@ TEST_F(TestInternal, ResizeFailsToLockImage) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE, "manually locked"));
 
   librbd::NoOpProgressContext no_op;
   ASSERT_EQ(-EROFS, ictx->operations->resize(m_image_size >> 1, true, no_op));
@@ -258,7 +258,7 @@ TEST_F(TestInternal, SnapCreateFailsToLockImage) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE, "manually locked"));
 
   ASSERT_EQ(-EROFS, snap_create(*ictx, "snap1"));
 }
@@ -289,7 +289,7 @@ TEST_F(TestInternal, SnapRollbackFailsToLockImage) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE, "manually locked"));
 
   librbd::NoOpProgressContext no_op;
   ASSERT_EQ(-EROFS,
@@ -368,7 +368,7 @@ TEST_F(TestInternal, FlattenFailsToLockImage) {
   } BOOST_SCOPE_EXIT_END;
 
   ASSERT_EQ(0, open_image(clone_name, &ictx2));
-  ASSERT_EQ(0, lock_image(*ictx2, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx2, ClsLockType::EXCLUSIVE, "manually locked"));
 
   librbd::NoOpProgressContext no_op;
   ASSERT_EQ(-EROFS, ictx2->operations->flatten(no_op));
@@ -379,7 +379,7 @@ TEST_F(TestInternal, AioWriteRequestsLock) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE, "manually locked"));
 
   std::string buffer(256, '1');
   Context *ctx = new DummyContext();
@@ -405,7 +405,7 @@ TEST_F(TestInternal, AioDiscardRequestsLock) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
-  ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked"));
+  ASSERT_EQ(0, lock_image(*ictx, ClsLockType::EXCLUSIVE, "manually locked"));
 
   Context *ctx = new DummyContext();
   auto c = librbd::io::AioCompletion::create(ctx);

diff --git a/src/tools/rados/rados.cc b/src/tools/rados/rados.cc
index 9af05cfdf6d5b8cb41afd808f3551065aad48aad..bc040526125855870a2be927d48e16f821fed0c9 100644 (file)
--- a/src/tools/rados/rados.cc
+++ b/src/tools/rados/rados.cc
@@ -1179,7 +1179,7 @@ static int do_lock_cmd(std::vector<const char*> &nargs,
   string lock_cookie;
   string lock_description;
   int lock_duration = 0;
-  ClsLockType lock_type = LOCK_EXCLUSIVE;
+  ClsLockType lock_type = ClsLockType::EXCLUSIVE;
 
   map<string, string>::const_iterator i;
   i = opts.find("lock-tag");
@@ -1204,9 +1204,9 @@ static int do_lock_cmd(std::vector<const char*> &nargs,
   if (i != opts.end()) {
     const string& type_str = i->second;
     if (type_str.compare("exclusive") == 0) {
-      lock_type = LOCK_EXCLUSIVE;
+      lock_type = ClsLockType::EXCLUSIVE;
     } else if (type_str.compare("shared") == 0) {
-      lock_type = LOCK_SHARED;
+      lock_type = ClsLockType::SHARED;
     } else {
       cerr << "unknown lock type was specified, aborting" << std::endl;
       return -EINVAL;
@@ -1243,7 +1243,7 @@ static int do_lock_cmd(std::vector<const char*> &nargs,
 
   if (cmd.compare("info") == 0) {
     map<rados::cls::lock::locker_id_t, rados::cls::lock::locker_info_t> lockers;
-    ClsLockType type = LOCK_NONE;
+    ClsLockType type = ClsLockType::NONE;
     string tag;
     int ret = rados::cls::lock::get_lock_info(ioctx, oid, lock_name, &lockers, &type, &tag);
     if (ret < 0) {
@@ -1281,7 +1281,7 @@ static int do_lock_cmd(std::vector<const char*> &nargs,
     l.set_description(lock_description);
     int ret;
     switch (lock_type) {
-    case LOCK_SHARED:
+    case ClsLockType::SHARED:
       ret = l.lock_shared(ioctx, oid);
       break;
     default:

diff --git a/src/tools/rbd/ArgumentTypes.cc b/src/tools/rbd/ArgumentTypes.cc
index 05c4f4af28baad0abf0108d6dd8b97f6e2ca238d..b9eb6f5340f9e6f61dd4cc3af18c9a438f895768 100644 (file)
--- a/src/tools/rbd/ArgumentTypes.cc
+++ b/src/tools/rbd/ArgumentTypes.cc
@@ -307,7 +307,7 @@ void add_verbose_option(boost::program_options::options_description *opt) {
 
 void add_no_error_option(boost::program_options::options_description *opt) {
   opt->add_options()
-    (NO_ERROR.c_str(), po::bool_switch(), "continue after error");
+    (NO_ERR.c_str(), po::bool_switch(), "continue after error");
 }
 
 void add_export_format_option(boost::program_options::options_description *opt) {

diff --git a/src/tools/rbd/ArgumentTypes.h b/src/tools/rbd/ArgumentTypes.h
index 793f12bbdb08a7131bf98da24a072cbbacd46913..5f500e52072c47c51beeb1f8102a8e5cbfa65a20 100644 (file)
--- a/src/tools/rbd/ArgumentTypes.h
+++ b/src/tools/rbd/ArgumentTypes.h
@@ -79,7 +79,7 @@ static const std::string NO_PROGRESS("no-progress");
 static const std::string FORMAT("format");
 static const std::string PRETTY_FORMAT("pretty-format");
 static const std::string VERBOSE("verbose");
-static const std::string NO_ERROR("no-error");
+static const std::string NO_ERR("no-error");
 
 static const std::string LIMIT("limit");
 
@@ -87,7 +87,7 @@ static const std::string SKIP_QUIESCE("skip-quiesce");
 static const std::string IGNORE_QUIESCE_ERROR("ignore-quiesce-error");
 
 static const std::set<std::string> SWITCH_ARGUMENTS = {
-  WHOLE_OBJECT, NO_PROGRESS, PRETTY_FORMAT, VERBOSE, NO_ERROR, SKIP_QUIESCE,
+  WHOLE_OBJECT, NO_PROGRESS, PRETTY_FORMAT, VERBOSE, NO_ERR, SKIP_QUIESCE,
   IGNORE_QUIESCE_ERROR
 };
 

diff --git a/src/tools/rbd/action/Journal.cc b/src/tools/rbd/action/Journal.cc
index 5d283420a5e8f8b947cf1f089ef978ccfb55b3e6..0379583264b17b5c410d5c04bfcf65b43bdfeaac 100644 (file)
--- a/src/tools/rbd/action/Journal.cc
+++ b/src/tools/rbd/action/Journal.cc
@@ -1165,7 +1165,7 @@ int execute_export(const po::variables_map &vm,
     return r;
   }
 
-  r = do_export_journal(io_ctx, journal_name, path, vm[at::NO_ERROR].as<bool>(),
+  r = do_export_journal(io_ctx, journal_name, path, vm[at::NO_ERR].as<bool>(),
                        vm[at::VERBOSE].as<bool>());
   if (r < 0) {
     std::cerr << "rbd: journal export: " << cpp_strerror(r) << std::endl;
@@ -1208,7 +1208,7 @@ int execute_import(const po::variables_map &vm,
     return r;
   }
 
-  r = do_import_journal(io_ctx, journal_name, path, vm[at::NO_ERROR].as<bool>(),
+  r = do_import_journal(io_ctx, journal_name, path, vm[at::NO_ERR].as<bool>(),
                        vm[at::VERBOSE].as<bool>());
   if (r < 0) {
     std::cerr << "rbd: journal import: " << cpp_strerror(r) << std::endl;