import 15.2.0 Octopus source

[ceph.git] / ceph / src / librados / IoCtxImpl.cc

diff --git a/ceph/src/librados/IoCtxImpl.cc b/ceph/src/librados/IoCtxImpl.cc
index 472d16fdea123aa69c42deca2fce8a8c23f1e2a2..900628bbdc4fb8d6bf5e335144b8747e578c5302 100644 (file)
--- a/ceph/src/librados/IoCtxImpl.cc
+++ b/ceph/src/librados/IoCtxImpl.cc
@@ -107,10 +107,10 @@ struct C_aio_linger_Complete : public Context {
       c->io->client->finisher.queue(new C_aio_linger_cancel(c->io->objecter,
                                                             linger_op));
 
-    c->lock.Lock();
+    c->lock.lock();
     c->rval = r;
     c->complete = true;
-    c->cond.Signal();
+    c->cond.notify_all();
 
     if (c->callback_complete ||
        c->callback_safe) {
@@ -121,26 +121,25 @@ struct C_aio_linger_Complete : public Context {
 };
 
 struct C_aio_notify_Complete : public C_aio_linger_Complete {
-  Mutex lock;
+  ceph::mutex lock = ceph::make_mutex("C_aio_notify_Complete::lock");
   bool acked = false;
   bool finished = false;
   int ret_val = 0;
 
   C_aio_notify_Complete(AioCompletionImpl *_c, Objecter::LingerOp *_linger_op)
-    : C_aio_linger_Complete(_c, _linger_op, false),
-      lock("C_aio_notify_Complete::lock") {
+    : C_aio_linger_Complete(_c, _linger_op, false) {
   }
 
   void handle_ack(int r) {
     // invoked by C_aio_notify_Ack
-    lock.Lock();
+    lock.lock();
     acked = true;
     complete_unlock(r);
   }
 
   void complete(int r) override {
     // invoked by C_notify_Finish
-    lock.Lock();
+    lock.lock();
     finished = true;
     complete_unlock(r);
   }
@@ -151,11 +150,11 @@ struct C_aio_notify_Complete : public C_aio_linger_Complete {
     }
 
     if (acked && finished) {
-      lock.Unlock();
+      lock.unlock();
       cancel = true;
       C_aio_linger_Complete::complete(ret_val);
     } else {
-      lock.Unlock();
+      lock.unlock();
     }
   }
 };
@@ -190,10 +189,10 @@ struct C_aio_selfmanaged_snap_op_Complete : public Context {
   }
 
   void finish(int r) override {
-    c->lock.Lock();
+    c->lock.lock();
     c->rval = r;
     c->complete = true;
-    c->cond.Signal();
+    c->cond.notify_all();
 
     if (c->callback_complete || c->callback_safe) {
       client->finisher.queue(new librados::C_AioComplete(c));
@@ -224,19 +223,13 @@ struct C_aio_selfmanaged_snap_create_Complete : public C_aio_selfmanaged_snap_op
 } // anonymous namespace
 } // namespace librados
 
-librados::IoCtxImpl::IoCtxImpl() :
-  ref_cnt(0), client(NULL), poolid(0), assert_ver(0), last_objver(0),
-  notify_timeout(30), aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock"),
-  aio_write_seq(0), objecter(NULL)
-{
-}
+librados::IoCtxImpl::IoCtxImpl() = default;
 
 librados::IoCtxImpl::IoCtxImpl(RadosClient *c, Objecter *objecter,
                               int64_t poolid, snapid_t s)
-  : ref_cnt(0), client(c), poolid(poolid), snap_seq(s),
-    assert_ver(0), last_objver(0),
+  : client(c), poolid(poolid), snap_seq(s),
     notify_timeout(c->cct->_conf->client_notify_timeout),
-    oloc(poolid), aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock"),
+    oloc(poolid),
     aio_write_seq(0), objecter(objecter)
 {
 }
@@ -285,19 +278,18 @@ int librados::IoCtxImpl::get_object_pg_hash_position(
 void librados::IoCtxImpl::queue_aio_write(AioCompletionImpl *c)
 {
   get();
-  aio_write_list_lock.Lock();
+  std::scoped_lock l{aio_write_list_lock};
   ceph_assert(c->io == this);
   c->aio_write_seq = ++aio_write_seq;
   ldout(client->cct, 20) << "queue_aio_write " << this << " completion " << c
                         << " write_seq " << aio_write_seq << dendl;
   aio_write_list.push_back(&c->aio_write_list_item);
-  aio_write_list_lock.Unlock();
 }
 
 void librados::IoCtxImpl::complete_aio_write(AioCompletionImpl *c)
 {
   ldout(client->cct, 20) << "complete_aio_write " << c << dendl;
-  aio_write_list_lock.Lock();
+  aio_write_list_lock.lock();
   ceph_assert(c->io == this);
   c->aio_write_list_item.remove_myself();
 
@@ -319,8 +311,8 @@ void librados::IoCtxImpl::complete_aio_write(AioCompletionImpl *c)
     aio_write_waiters.erase(waiters++);
   }
 
-  aio_write_cond.Signal();
-  aio_write_list_lock.Unlock();
+  aio_write_cond.notify_all();
+  aio_write_list_lock.unlock();
   put();
 }
 
@@ -345,12 +337,11 @@ void librados::IoCtxImpl::flush_aio_writes_async(AioCompletionImpl *c)
 void librados::IoCtxImpl::flush_aio_writes()
 {
   ldout(client->cct, 20) << "flush_aio_writes" << dendl;
-  aio_write_list_lock.Lock();
-  ceph_tid_t seq = aio_write_seq;
-  while (!aio_write_list.empty() &&
-        aio_write_list.front()->aio_write_seq <= seq)
-    aio_write_cond.Wait(aio_write_list_lock);
-  aio_write_list_lock.Unlock();
+  std::unique_lock l{aio_write_list_lock};
+  aio_write_cond.wait(l, [seq=aio_write_seq, this] {
+    return (aio_write_list.empty() ||
+           aio_write_list.front()->aio_write_seq > seq);
+  });
 }
 
 string librados::IoCtxImpl::get_cached_pool_name()
@@ -367,19 +358,17 @@ int librados::IoCtxImpl::snap_create(const char *snapName)
   int reply;
   string sName(snapName);
 
-  Mutex mylock ("IoCtxImpl::snap_create::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_create::mylock");
+  ceph::condition_variable cond;
   bool done;
-  Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply);
+  Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply);
   reply = objecter->create_pool_snap(poolid, sName, onfinish);
 
   if (reply < 0) {
     delete onfinish;
   } else {
-    mylock.Lock();
-    while (!done)
-      cond.Wait(mylock);
-    mylock.Unlock();
+    std::unique_lock l{mylock};
+    cond.wait(l, [&done] { return done; });
   }
   return reply;
 }
@@ -388,20 +377,20 @@ int librados::IoCtxImpl::selfmanaged_snap_create(uint64_t *psnapid)
 {
   int reply;
 
-  Mutex mylock("IoCtxImpl::selfmanaged_snap_create::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::selfmanaged_snap_create::mylock");
+  ceph::condition_variable cond;
   bool done;
-  Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply);
+  Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply);
   snapid_t snapid;
   reply = objecter->allocate_selfmanaged_snap(poolid, &snapid, onfinish);
 
   if (reply < 0) {
     delete onfinish;
   } else {
-    mylock.Lock();
-    while (!done)
-      cond.Wait(mylock);
-    mylock.Unlock();
+    {
+      std::unique_lock l{mylock};
+      cond.wait(l, [&done] { return done; });
+    }
     if (reply == 0)
       *psnapid = snapid;
   }
@@ -425,19 +414,17 @@ int librados::IoCtxImpl::snap_remove(const char *snapName)
   int reply;
   string sName(snapName);
 
-  Mutex mylock ("IoCtxImpl::snap_remove::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_remove::mylock");
+  ceph::condition_variable cond;
   bool done;
-  Context *onfinish = new C_SafeCond(&mylock, &cond, &done, &reply);
+  Context *onfinish = new C_SafeCond(mylock, cond, &done, &reply);
   reply = objecter->delete_pool_snap(poolid, sName, onfinish);
 
   if (reply < 0) {
     delete onfinish; 
   } else {
-    mylock.Lock();
-    while(!done)
-      cond.Wait(mylock);
-    mylock.Unlock();
+    unique_lock l{mylock};
+    cond.wait(l, [&done] { return done; });
   }
   return reply;
 }
@@ -448,10 +435,10 @@ int librados::IoCtxImpl::selfmanaged_snap_rollback_object(const object_t& oid,
 {
   int reply;
 
-  Mutex mylock("IoCtxImpl::snap_rollback::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::snap_rollback::mylock");
+  ceph::condition_variable cond;
   bool done;
-  Context *onack = new C_SafeCond(&mylock, &cond, &done, &reply);
+  Context *onack = new C_SafeCond(mylock, cond, &done, &reply);
 
   ::ObjectOperation op;
   prepare_assert_ops(&op);
@@ -460,9 +447,8 @@ int librados::IoCtxImpl::selfmanaged_snap_rollback_object(const object_t& oid,
                   op, snapc, ceph::real_clock::now(), 0,
                   onack, NULL);
 
-  mylock.Lock();
-  while (!done) cond.Wait(mylock);
-  mylock.Unlock();
+  std::unique_lock l{mylock};
+  cond.wait(l, [&done] { return done; });
   return reply;
 }
 
@@ -482,15 +468,14 @@ int librados::IoCtxImpl::selfmanaged_snap_remove(uint64_t snapid)
 {
   int reply;
 
-  Mutex mylock("IoCtxImpl::selfmanaged_snap_remove::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::selfmanaged_snap_remove::mylock");
+  ceph::condition_variable cond;
   bool done;
   objecter->delete_selfmanaged_snap(poolid, snapid_t(snapid),
-                                   new C_SafeCond(&mylock, &cond, &done, &reply));
+                                   new C_SafeCond(mylock, cond, &done, &reply));
 
-  mylock.Lock();
-  while (!done) cond.Wait(mylock);
-  mylock.Unlock();
+  std::unique_lock l{mylock};
+  cond.wait(l, [&done] { return done; });
   return (int)reply;
 }
 
@@ -538,10 +523,10 @@ int librados::IoCtxImpl::snap_get_stamp(uint64_t snapid, time_t *t)
 
 int librados::IoCtxImpl::nlist(Objecter::NListContext *context, int max_entries)
 {
-  Cond cond;
   bool done;
   int r = 0;
-  Mutex mylock("IoCtxImpl::nlist::mylock");
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::nlist::mylock");
+  ceph::condition_variable cond;
 
   if (context->at_end())
     return 0;
@@ -549,13 +534,10 @@ int librados::IoCtxImpl::nlist(Objecter::NListContext *context, int max_entries)
   context->max_entries = max_entries;
   context->nspace = oloc.nspace;
 
-  objecter->list_nobjects(context, new C_SafeCond(&mylock, &cond, &done, &r));
-
-  mylock.Lock();
-  while(!done)
-    cond.Wait(mylock);
-  mylock.Unlock();
+  objecter->list_nobjects(context, new C_SafeCond(mylock, cond, &done, &r));
 
+  std::unique_lock l{mylock};
+  cond.wait(l, [&done] { return done; });
   return r;
 }
 
@@ -673,13 +655,13 @@ int librados::IoCtxImpl::operate(const object_t& oid, ::ObjectOperation *o,
   if (!o->size())
     return 0;
 
-  Mutex mylock("IoCtxImpl::operate::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::operate::mylock");
+  ceph::condition_variable cond;
   bool done;
   int r;
   version_t ver;
 
-  Context *oncommit = new C_SafeCond(&mylock, &cond, &done, &r);
+  Context *oncommit = new C_SafeCond(mylock, cond, &done, &r);
 
   int op = o->ops[0].op.op;
   ldout(client->cct, 10) << ceph_osd_op_name(op) << " oid=" << oid
@@ -689,10 +671,10 @@ int librados::IoCtxImpl::operate(const object_t& oid, ::ObjectOperation *o,
                                                          oncommit, &ver);
   objecter->op_submit(objecter_op);
 
-  mylock.Lock();
-  while (!done)
-    cond.Wait(mylock);
-  mylock.Unlock();
+  {
+    std::unique_lock l{mylock};
+    cond.wait(l, [&done] { return done;});
+  }
   ldout(client->cct, 10) << "Objecter returned from "
        << ceph_osd_op_name(op) << " r=" << r << dendl;
 
@@ -709,13 +691,13 @@ int librados::IoCtxImpl::operate_read(const object_t& oid,
   if (!o->size())
     return 0;
 
-  Mutex mylock("IoCtxImpl::operate_read::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::operate_read::mylock");
+  ceph::condition_variable cond;
   bool done;
   int r;
   version_t ver;
 
-  Context *onack = new C_SafeCond(&mylock, &cond, &done, &r);
+  Context *onack = new C_SafeCond(mylock, cond, &done, &r);
 
   int op = o->ops[0].op.op;
   ldout(client->cct, 10) << ceph_osd_op_name(op) << " oid=" << oid << " nspace=" << oloc.nspace << dendl;
@@ -724,10 +706,10 @@ int librados::IoCtxImpl::operate_read(const object_t& oid,
                                              onack, &ver);
   objecter->op_submit(objecter_op);
 
-  mylock.Lock();
-  while (!done)
-    cond.Wait(mylock);
-  mylock.Unlock();
+  {
+    std::unique_lock l{mylock};
+    cond.wait(l, [&done] { return done; });
+  }
   ldout(client->cct, 10) << "Objecter returned from "
        << ceph_osd_op_name(op) << " r=" << r << dendl;
 
@@ -746,7 +728,7 @@ int librados::IoCtxImpl::aio_operate_read(const object_t &oid,
   FUNCTRACE(client->cct);
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->is_read = true;
@@ -781,7 +763,7 @@ int librados::IoCtxImpl::aio_operate(const object_t& oid,
     return -EROFS;
 
   Context *oncomplete = new C_aio_Complete(c);
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
 
@@ -815,7 +797,7 @@ int librados::IoCtxImpl::aio_read(const object_t oid, AioCompletionImpl *c,
   OID_EVENT_TRACE(oid.name.c_str(), "RADOS_READ_OP_BEGIN");
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->is_read = true;
@@ -845,7 +827,7 @@ int librados::IoCtxImpl::aio_read(const object_t oid, AioCompletionImpl *c,
   OID_EVENT_TRACE(oid.name.c_str(), "RADOS_READ_OP_BEGIN");
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->is_read = true;
@@ -891,7 +873,7 @@ int librados::IoCtxImpl::aio_sparse_read(const object_t oid,
   Context *nested = new C_aio_Complete(c);
   C_ObjectOperation *onack = new C_ObjectOperation(nested);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) nested)->oid = oid;
 #endif
   c->is_read = true;
@@ -972,7 +954,7 @@ int librados::IoCtxImpl::aio_write(const object_t &oid, AioCompletionImpl *c,
 
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   ZTracer::Trace trace;
@@ -1004,7 +986,7 @@ int librados::IoCtxImpl::aio_append(const object_t &oid, AioCompletionImpl *c,
     return -EROFS;
 
   Context *oncomplete = new C_aio_Complete(c);
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
 
@@ -1034,7 +1016,7 @@ int librados::IoCtxImpl::aio_write_full(const object_t &oid,
     return -EROFS;
 
   Context *oncomplete = new C_aio_Complete(c);
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
 
@@ -1069,7 +1051,7 @@ int librados::IoCtxImpl::aio_writesame(const object_t &oid,
 
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->io = this;
@@ -1096,7 +1078,7 @@ int librados::IoCtxImpl::aio_remove(const object_t &oid, AioCompletionImpl *c, i
 
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->io = this;
@@ -1339,7 +1321,7 @@ int librados::IoCtxImpl::aio_exec(const object_t& oid, AioCompletionImpl *c,
   FUNCTRACE(client->cct);
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->is_read = true;
@@ -1361,7 +1343,7 @@ int librados::IoCtxImpl::aio_exec(const object_t& oid, AioCompletionImpl *c,
   FUNCTRACE(client->cct);
   Context *oncomplete = new C_aio_Complete(c);
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   ((C_aio_Complete *) oncomplete)->oid = oid;
 #endif
   c->is_read = true;
@@ -1420,20 +1402,20 @@ int librados::IoCtxImpl::mapext(const object_t& oid,
 {
   bufferlist bl;
 
-  Mutex mylock("IoCtxImpl::read::mylock");
-  Cond cond;
+  ceph::mutex mylock = ceph::make_mutex("IoCtxImpl::read::mylock");
+  ceph::condition_variable cond;
   bool done;
   int r;
-  Context *onack = new C_SafeCond(&mylock, &cond, &done, &r);
+  Context *onack = new C_SafeCond(mylock, cond, &done, &r);
 
   objecter->mapext(oid, oloc,
                   off, len, snap_seq, &bl, 0,
                   onack);
 
-  mylock.Lock();
-  while (!done)
-    cond.Wait(mylock);
-  mylock.Unlock();
+  {
+    unique_lock l{mylock};
+    cond.wait(l, [&done] { return done;});
+  }
   ldout(client->cct, 10) << "Objecter returned from read r=" << r << dendl;
 
   if (r < 0)
@@ -1908,10 +1890,10 @@ librados::IoCtxImpl::C_aio_stat_Ack::C_aio_stat_Ack(AioCompletionImpl *_c,
 
 void librados::IoCtxImpl::C_aio_stat_Ack::finish(int r)
 {
-  c->lock.Lock();
+  c->lock.lock();
   c->rval = r;
   c->complete = true;
-  c->cond.Signal();
+  c->cond.notify_all();
 
   if (r >= 0 && pmtime) {
     *pmtime = real_clock::to_time_t(mtime);
@@ -1936,10 +1918,10 @@ librados::IoCtxImpl::C_aio_stat2_Ack::C_aio_stat2_Ack(AioCompletionImpl *_c,
 
 void librados::IoCtxImpl::C_aio_stat2_Ack::finish(int r)
 {
-  c->lock.Lock();
+  c->lock.lock();
   c->rval = r;
   c->complete = true;
-  c->cond.Signal();
+  c->cond.notify_all();
 
   if (r >= 0 && pts) {
     *pts = real_clock::to_timespec(mtime);
@@ -1962,19 +1944,19 @@ librados::IoCtxImpl::C_aio_Complete::C_aio_Complete(AioCompletionImpl *_c)
 
 void librados::IoCtxImpl::C_aio_Complete::finish(int r)
 {
-  c->lock.Lock();
+  c->lock.lock();
   // Leave an existing rval unless r != 0
   if (r)
     c->rval = r; // This clears the error set in C_ObjectOperation_scrub_ls::finish()
   c->complete = true;
-  c->cond.Signal();
+  c->cond.notify_all();
 
   if (r == 0 && c->blp && c->blp->length() > 0) {
     if (c->out_buf && !c->blp->is_contiguous()) {
       c->rval = -ERANGE;
     } else {
       if (c->out_buf && !c->blp->is_provided_buffer(c->out_buf))
-        c->blp->copy(0, c->blp->length(), c->out_buf);
+        c->blp->begin().copy(c->blp->length(), c->out_buf);
 
       c->rval = c->blp->length();
     }
@@ -1989,7 +1971,7 @@ void librados::IoCtxImpl::C_aio_Complete::finish(int r)
     c->io->complete_aio_write(c);
   }
 
-#if defined(WITH_LTTNG) && defined(WITH_EVENTTRACE)
+#if defined(WITH_EVENTTRACE)
   OID_EVENT_TRACE(oid.name.c_str(), "RADOS_OP_COMPLETE");
 #endif
   c->put_unlock();