client: use message smart ptr instead of raw ptr

Fixes: http://tracker.ceph.com/issues/37864
Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>

diff --git a/src/client/Client.cc b/src/client/Client.cc
index 21085d963af06cfcb543efd1e03f283bd113adbb..bb9ef28c9858fd7a85b6d93db12f93abb409ef04 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -45,26 +45,11 @@
 #include "common/config.h"
 #include "common/version.h"
 
-// ceph stuff
-#include "messages/MClientSession.h"
-#include "messages/MClientReconnect.h"
-#include "messages/MClientRequest.h"
-#include "messages/MClientRequestForward.h"
-#include "messages/MClientReply.h"
-#include "messages/MClientCaps.h"
-#include "messages/MClientLease.h"
-#include "messages/MClientSnap.h"
-#include "messages/MClientReclaim.h"
-#include "messages/MClientReclaimReply.h"
-#include "messages/MCommandReply.h"
-#include "messages/MOSDMap.h"
-#include "messages/MClientQuota.h"
-#include "messages/MMDSMap.h"
-#include "messages/MFSMap.h"
-#include "messages/MFSMapUser.h"
-
 #include "mon/MonClient.h"
 
+#include "messages/MClientReclaim.h"
+#include "messages/MClientReconnect.h"
+
 #include "mds/flock.h"
 #include "mds/cephfs_features.h"
 #include "osd/OSDMap.h"
@@ -1088,7 +1073,7 @@ void Client::clear_dir_complete_and_ordered(Inode *diri, bool complete)
  */
 void Client::insert_readdir_results(MetaRequest *request, MetaSession *session, Inode *diri) {
 
-  MClientReply *reply = request->reply;
+  auto& reply = request->reply;
   ConnectionRef con = request->reply->get_connection();
   uint64_t features;
   if(session->mds_features.test(CEPHFS_FEATURE_REPLY_ENCODING)) {
@@ -1251,7 +1236,7 @@ void Client::insert_readdir_results(MetaRequest *request, MetaSession *session,
  */
 Inode* Client::insert_trace(MetaRequest *request, MetaSession *session)
 {
-  MClientReply *reply = request->reply;
+  auto& reply = request->reply;
   int op = request->get_op();
 
   ldout(cct, 10) << "insert_trace from " << request->sent_stamp << " mds." << session->mds_num
@@ -1572,7 +1557,7 @@ void Client::dump_mds_requests(Formatter *f)
 }
 
 int Client::verify_reply_trace(int r,
-                              MetaRequest *request, MClientReply *reply,
+                              MetaRequest *request, const MClientReply::const_ref& reply,
                               InodeRef *ptarget, bool *pcreated,
                               const UserPerm& perms)
 {
@@ -1582,7 +1567,7 @@ int Client::verify_reply_trace(int r,
   bool got_created_ino = false;
   ceph::unordered_map<vinodeno_t, Inode*>::iterator p;
 
-  extra_bl.claim(reply->get_extra_bl());
+  extra_bl = reply->get_extra_bl();
   if (extra_bl.length() >= 8) {
     // if the extra bufferlist has a buffer, we assume its the created inode
     // and that this request to create succeeded in actually creating
@@ -1781,8 +1766,7 @@ int Client::make_request(MetaRequest *request,
   }
 
   // got it!
-  MClientReply *reply = request->reply;
-  request->reply = NULL;
+  auto reply = std::move(request->reply);
   r = reply->get_result();
   if (r >= 0)
     request->success = true;
@@ -1797,7 +1781,7 @@ int Client::make_request(MetaRequest *request,
     r = verify_reply_trace(r, request, reply, ptarget, pcreated, perms);
 
   if (pdirbl)
-    pdirbl->claim(reply->get_extra_bl());
+    *pdirbl = reply->get_extra_bl();
 
   // -- log times --
   utime_t lat = ceph_clock_now();
@@ -1807,8 +1791,6 @@ int Client::make_request(MetaRequest *request,
   logger->tinc(l_c_reply, lat);
 
   put_request(request);
-
-  reply->put();
   return r;
 }
 
@@ -1903,7 +1885,7 @@ void Client::encode_dentry_release(Dentry *dn, MetaRequest *req,
                                    mds, drop, unless, 1);
   if (released && dn->lease_mds == mds) {
     ldout(cct, 25) << "preemptively releasing dn to mds" << dendl;
-    MClientRequest::Release& rel = req->cap_releases.back();
+    auto& rel = req->cap_releases.back();
     rel.item.dname_len = dn->name.length();
     rel.item.dname_seq = dn->lease_seq;
     rel.dname = dn->name;
@@ -2062,7 +2044,7 @@ MetaSession *Client::_open_mds_session(mds_rank_t mds)
   auto m = MClientSession::create(CEPH_SESSION_REQUEST_OPEN);
   m->metadata = metadata;
   m->supported_features = feature_bitset_t(CEPHFS_FEATURES_CLIENT_SUPPORTED);
-  session->con->send_message2(m);
+  session->con->send_message2(std::move(m));
   return session;
 }
 
@@ -2085,7 +2067,7 @@ void Client::_closed_mds_session(MetaSession *s)
   mds_sessions.erase(s->mds_num);
 }
 
-void Client::handle_client_session(MClientSession *m) 
+void Client::handle_client_session(const MClientSession::const_ref& m)
 {
   mds_rank_t from = mds_rank_t(m->get_source().num());
   ldout(cct, 10) << __func__ << " " << *m << " from mds." << from << dendl;
@@ -2093,7 +2075,6 @@ void Client::handle_client_session(MClientSession *m)
   MetaSession *session = _get_mds_session(from, m->get_connection().get());
   if (!session) {
     ldout(cct, 10) << " discarding session message from sessionless mds " << m->get_source_inst() << dendl;
-    m->put();
     return;
   }
 
@@ -2172,8 +2153,6 @@ void Client::handle_client_session(MClientSession *m)
   default:
     ceph_abort();
   }
-
-  m->put();
 }
 
 bool Client::_any_stale_sessions() const
@@ -2208,7 +2187,7 @@ void Client::send_request(MetaRequest *request, MetaSession *session,
   mds_rank_t mds = session->mds_num;
   ldout(cct, 10) << __func__ << " rebuilding request " << request->get_tid()
                 << " for mds." << mds << dendl;
-  MClientRequest *r = build_client_request(request);
+  auto r = build_client_request(request);
   if (request->dentry()) {
     r->set_dentry_wanted();
   }
@@ -2247,10 +2226,10 @@ void Client::send_request(MetaRequest *request, MetaSession *session,
   session->requests.push_back(&request->item);
 
   ldout(cct, 10) << __func__ << " " << *r << " to mds." << mds << dendl;
-  session->con->send_message(r);
+  session->con->send_message2(std::move(r));
 }
 
-MClientRequest* Client::build_client_request(MetaRequest *request)
+MClientRequest::ref Client::build_client_request(MetaRequest *request)
 {
   auto req = MClientRequest::create(request->get_op());
   req->set_tid(request->tid);
@@ -2285,24 +2264,22 @@ MClientRequest* Client::build_client_request(MetaRequest *request)
   const gid_t *_gids;
   int gid_count = request->perms.get_gids(&_gids);
   req->set_gid_list(gid_count, _gids);
-  return req.detach();
+  return req;
 }
 
 
 
-void Client::handle_client_request_forward(MClientRequestForward *fwd)
+void Client::handle_client_request_forward(const MClientRequestForward::const_ref& fwd)
 {
   mds_rank_t mds = mds_rank_t(fwd->get_source().num());
   MetaSession *session = _get_mds_session(mds, fwd->get_connection().get());
   if (!session) {
-    fwd->put();
     return;
   }
   ceph_tid_t tid = fwd->get_tid();
 
   if (mds_requests.count(tid) == 0) {
     ldout(cct, 10) << __func__ << " no pending request on tid " << tid << dendl;
-    fwd->put();
     return;
   }
 
@@ -2325,8 +2302,6 @@ void Client::handle_client_request_forward(MClientRequestForward *fwd)
   request->num_fwd = fwd->get_num_fwd();
   request->resend_mds = fwd->get_dest_mds();
   request->caller_cond->Signal();
-
-  fwd->put();
 }
 
 bool Client::is_dir_operation(MetaRequest *req)
@@ -2340,12 +2315,11 @@ bool Client::is_dir_operation(MetaRequest *req)
   return false;
 }
 
-void Client::handle_client_reply(MClientReply *reply)
+void Client::handle_client_reply(const MClientReply::const_ref& reply)
 {
   mds_rank_t mds_num = mds_rank_t(reply->get_source().num());
   MetaSession *session = _get_mds_session(mds_num, reply->get_connection().get());
   if (!session) {
-    reply->put();
     return;
   }
 
@@ -2355,7 +2329,6 @@ void Client::handle_client_reply(MClientReply *reply)
   if (mds_requests.count(tid) == 0) {
     lderr(cct) << __func__ << " no pending request on tid " << tid
               << " safe is:" << is_safe << dendl;
-    reply->put();
     return;
   }
   MetaRequest *request = mds_requests.at(tid);
@@ -2367,7 +2340,6 @@ void Client::handle_client_reply(MClientReply *reply)
     //duplicate response
     ldout(cct, 0) << "got a duplicate reply on tid " << tid << " from mds "
            << mds_num << " safe:" << is_safe << dendl;
-    reply->put();
     return;
   }
 
@@ -2386,12 +2358,11 @@ void Client::handle_client_reply(MClientReply *reply)
       ldout(cct, 20) << "have to return ESTALE" << dendl;
     } else {
       request->caller_cond->Signal();
-      reply->put();
       return;
     }
   }
   
-  ceph_assert(request->reply == NULL);
+  ceph_assert(!request->reply);
   request->reply = reply;
   insert_trace(request, session);
 
@@ -2482,7 +2453,7 @@ void Client::_handle_full_flag(int64_t pool)
   }
 }
 
-void Client::handle_osd_map(MOSDMap *m)
+void Client::handle_osd_map(const MOSDMap::const_ref& m)
 {
   std::set<entity_addr_t> new_blacklists;
   objecter->consume_blacklist_events(&new_blacklists);
@@ -2564,8 +2535,6 @@ void Client::handle_osd_map(MOSDMap *m)
       objecter->maybe_request_map();
     }
   }
-
-  m->put();
 }
 
 
@@ -2573,65 +2542,64 @@ void Client::handle_osd_map(MOSDMap *m)
 // incoming messages
 
 
-bool Client::ms_dispatch(Message *m)
+bool Client::ms_dispatch2(const Message::ref &m)
 {
   std::lock_guard l(client_lock);
   if (!initialized) {
     ldout(cct, 10) << "inactive, discarding " << *m << dendl;
-    m->put();
     return true;
   }
 
   switch (m->get_type()) {
     // mounting and mds sessions
   case CEPH_MSG_MDS_MAP:
-    handle_mds_map(static_cast<MMDSMap*>(m));
+    handle_mds_map(MMDSMap::msgref_cast(m));
     break;
   case CEPH_MSG_FS_MAP:
-    handle_fs_map(static_cast<MFSMap*>(m));
+    handle_fs_map(MFSMap::msgref_cast(m));
     break;
   case CEPH_MSG_FS_MAP_USER:
-    handle_fs_map_user(static_cast<MFSMapUser*>(m));
+    handle_fs_map_user(MFSMapUser::msgref_cast(m));
     break;
   case CEPH_MSG_CLIENT_SESSION:
-    handle_client_session(static_cast<MClientSession*>(m));
+    handle_client_session(MClientSession::msgref_cast(m));
     break;
 
   case CEPH_MSG_OSD_MAP:
-    handle_osd_map(static_cast<MOSDMap*>(m));
+    handle_osd_map(MOSDMap::msgref_cast(m));
     break;
 
     // requests
   case CEPH_MSG_CLIENT_REQUEST_FORWARD:
-    handle_client_request_forward(static_cast<MClientRequestForward*>(m));
+    handle_client_request_forward(MClientRequestForward::msgref_cast(m));
     break;
   case CEPH_MSG_CLIENT_REPLY:
-    handle_client_reply(static_cast<MClientReply*>(m));
+    handle_client_reply(MClientReply::msgref_cast(m));
     break;
 
   // reclaim reply
   case CEPH_MSG_CLIENT_RECLAIM_REPLY:
-    handle_client_reclaim_reply(static_cast<MClientReclaimReply*>(m));
+    handle_client_reclaim_reply(MClientReclaimReply::msgref_cast(m));
     break;
 
   case CEPH_MSG_CLIENT_SNAP:
-    handle_snap(static_cast<MClientSnap*>(m));
+    handle_snap(MClientSnap::msgref_cast(m));
     break;
   case CEPH_MSG_CLIENT_CAPS:
-    handle_caps(static_cast<MClientCaps*>(m));
+    handle_caps(MClientCaps::msgref_cast(m));
     break;
   case CEPH_MSG_CLIENT_LEASE:
-    handle_lease(static_cast<MClientLease*>(m));
+    handle_lease(MClientLease::msgref_cast(m));
     break;
   case MSG_COMMAND_REPLY:
     if (m->get_source().type() == CEPH_ENTITY_TYPE_MDS) {
-      handle_command_reply(static_cast<MCommandReply*>(m));
+      handle_command_reply(MCommandReply::msgref_cast(m));
     } else {
       return false;
     }
     break;
   case CEPH_MSG_CLIENT_QUOTA:
-    handle_quota(static_cast<MClientQuota*>(m));
+    handle_quota(MClientQuota::msgref_cast(m));
     break;
 
   default:
@@ -2656,34 +2624,31 @@ bool Client::ms_dispatch(Message *m)
   return true;
 }
 
-void Client::handle_fs_map(MFSMap *m)
+void Client::handle_fs_map(const MFSMap::const_ref& m)
 {
   fsmap.reset(new FSMap(m->get_fsmap()));
-  m->put();
 
   signal_cond_list(waiting_for_fsmap);
 
   monclient->sub_got("fsmap", fsmap->get_epoch());
 }
 
-void Client::handle_fs_map_user(MFSMapUser *m)
+void Client::handle_fs_map_user(const MFSMapUser::const_ref& m)
 {
   fsmap_user.reset(new FSMapUser);
   *fsmap_user = m->get_fsmap();
-  m->put();
 
   monclient->sub_got("fsmap.user", fsmap_user->get_epoch());
   signal_cond_list(waiting_for_fsmap);
 }
 
-void Client::handle_mds_map(MMDSMap* m)
+void Client::handle_mds_map(const MMDSMap::const_ref& m)
 {
   mds_gid_t old_inc, new_inc;
   if (m->get_epoch() <= mdsmap->get_epoch()) {
     ldout(cct, 1) << __func__ << " epoch " << m->get_epoch()
                   << " is identical to or older than our "
                   << mdsmap->get_epoch() << dendl;
-    m->put();
     return;
   }
 
@@ -2775,8 +2740,6 @@ void Client::handle_mds_map(MMDSMap* m)
   // kick any waiting threads
   signal_cond_list(waiting_for_mdsmap);
 
-  m->put();
-
   monclient->sub_got("mdsmap", mdsmap->get_epoch());
 }
 
@@ -2799,7 +2762,7 @@ void Client::send_reconnect(MetaSession *session)
   //make sure unsafe requests get saved
   resend_unsafe_requests(session);
 
-  MClientReconnect *m = new MClientReconnect;
+  auto m = MClientReconnect::create();
 
   // i have an open session.
   ceph::unordered_set<inodeno_t> did_snaprealm;
@@ -2854,7 +2817,7 @@ void Client::send_reconnect(MetaSession *session)
 
   early_kick_flushing_caps(session);
 
-  session->con->send_message(m);
+  session->con->send_message2(std::move(m));
 
   mount_cond.Signal();
 
@@ -2976,7 +2939,7 @@ void Client::got_mds_push(MetaSession *s)
   }
 }
 
-void Client::handle_lease(MClientLease *m)
+void Client::handle_lease(const MClientLease::const_ref& m)
 {
   ldout(cct, 10) << __func__ << " " << *m << dendl;
 
@@ -2985,7 +2948,6 @@ void Client::handle_lease(MClientLease *m)
   mds_rank_t mds = mds_rank_t(m->get_source().num());
   MetaSession *session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
-    m->put();
     return;
   }
 
@@ -3014,9 +2976,8 @@ void Client::handle_lease(MClientLease *m)
  revoke:
   {
     auto reply = MClientLease::create(CEPH_MDS_LEASE_RELEASE, seq, m->get_mask(), m->get_ino(), m->get_first(), m->get_last(), m->dname);
-    m->get_connection()->send_message2(reply);
+    m->get_connection()->send_message2(std::move(reply));
   }
-  m->put();
 }
 
 void Client::put_inode(Inode *in, int n)
@@ -3428,7 +3389,7 @@ void Client::send_cap(Inode *in, MetaSession *session, Cap *cap,
   if (!session->flushing_caps_tids.empty())
     m->set_oldest_flush_tid(*session->flushing_caps_tids.begin());
 
-  session->con->send_message2(m);
+  session->con->send_message2(std::move(m));
 }
 
 static bool is_max_size_approaching(Inode *in)
@@ -3769,7 +3730,7 @@ void Client::flush_snaps(Inode *in, bool all_again)
     ceph_assert(!session->flushing_caps_tids.empty());
     m->set_oldest_flush_tid(*session->flushing_caps_tids.begin());
 
-    session->con->send_message2(m);
+    session->con->send_message2(std::move(m));
   }
 }
 
@@ -4598,7 +4559,7 @@ static bool has_new_snaps(const SnapContext& old_snapc,
 }
 
 
-void Client::update_snap_trace(bufferlist& bl, SnapRealm **realm_ret, bool flush)
+void Client::update_snap_trace(const bufferlist& bl, SnapRealm **realm_ret, bool flush)
 {
   SnapRealm *first_realm = NULL;
   ldout(cct, 10) << __func__ << " len " << bl.length() << dendl;
@@ -4691,13 +4652,12 @@ void Client::update_snap_trace(bufferlist& bl, SnapRealm **realm_ret, bool flush
     put_snap_realm(first_realm);
 }
 
-void Client::handle_snap(MClientSnap *m)
+void Client::handle_snap(const MClientSnap::const_ref& m)
 {
   ldout(cct, 10) << __func__ << " " << *m << dendl;
   mds_rank_t mds = mds_rank_t(m->get_source().num());
   MetaSession *session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
-    m->put();
     return;
   }
 
@@ -4716,10 +4676,8 @@ void Client::handle_snap(MClientSnap *m)
     // flush, then move, ino's.
     realm = get_snap_realm(info.ino());
     ldout(cct, 10) << " splitting off " << *realm << dendl;
-    for (vector<inodeno_t>::iterator p = m->split_inos.begin();
-        p != m->split_inos.end();
-        ++p) {
-      vinodeno_t vino(*p, CEPH_NOSNAP);
+    for (auto& ino : m->split_inos) {
+      vinodeno_t vino(ino, CEPH_NOSNAP);
       if (inode_map.count(vino)) {
        Inode *in = inode_map[vino];
        if (!in->snaprealm || in->snaprealm == realm)
@@ -4739,11 +4697,9 @@ void Client::handle_snap(MClientSnap *m)
     }
 
     // move child snaprealms, too
-    for (vector<inodeno_t>::iterator p = m->split_realms.begin();
-        p != m->split_realms.end();
-        ++p) {
-      ldout(cct, 10) << "adjusting snaprealm " << *p << " parent" << dendl;
-      SnapRealm *child = get_snap_realm_maybe(*p);
+    for (auto& child_realm : m->split_realms) {
+      ldout(cct, 10) << "adjusting snaprealm " << child_realm << " parent" << dendl;
+      SnapRealm *child = get_snap_realm_maybe(child_realm);
       if (!child)
        continue;
       adjust_realm_parent(child, realm->ino);
@@ -4765,16 +4721,13 @@ void Client::handle_snap(MClientSnap *m)
     }
     put_snap_realm(realm);
   }
-
-  m->put();
 }
 
-void Client::handle_quota(MClientQuota *m)
+void Client::handle_quota(const MClientQuota::const_ref& m)
 {
   mds_rank_t mds = mds_rank_t(m->get_source().num());
   MetaSession *session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
-    m->put();
     return;
   }
 
@@ -4792,16 +4745,13 @@ void Client::handle_quota(MClientQuota *m)
       in->rstat = m->rstat;
     }
   }
-
-  m->put();
 }
 
-void Client::handle_caps(MClientCaps *m)
+void Client::handle_caps(const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = mds_rank_t(m->get_source().num());
   MetaSession *session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
-    m->put();
     return;
   }
 
@@ -4833,7 +4783,6 @@ void Client::handle_caps(MClientCaps *m)
     } else {
       ldout(cct, 5) << __func__ << " don't have vino " << vino << ", dropping" << dendl;
     }
-    m->put();
 
     // in case the mds is waiting on e.g. a revocation
     flush_cap_releases();
@@ -4855,17 +4804,14 @@ void Client::handle_caps(MClientCaps *m)
       case CEPH_CAP_OP_REVOKE:
       case CEPH_CAP_OP_GRANT: return handle_cap_grant(session, in, &cap, m);
       case CEPH_CAP_OP_FLUSH_ACK: return handle_cap_flush_ack(session, in, &cap, m);
-      default:
-        m->put();
     }
   } else {
     ldout(cct, 5) << __func__ << " don't have " << *in << " cap on mds." << mds << dendl;
-    m->put();
     return;
   }
 }
 
-void Client::handle_cap_import(MetaSession *session, Inode *in, MClientCaps *m)
+void Client::handle_cap_import(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = session->mds_num;
 
@@ -4904,7 +4850,7 @@ void Client::handle_cap_import(MetaSession *session, Inode *in, MClientCaps *m)
   }
 }
 
-void Client::handle_cap_export(MetaSession *session, Inode *in, MClientCaps *m)
+void Client::handle_cap_export(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = session->mds_num;
 
@@ -4948,11 +4894,9 @@ void Client::handle_cap_export(MetaSession *session, Inode *in, MClientCaps *m)
       remove_cap(&cap, false);
     }
   }
-
-  m->put();
 }
 
-void Client::handle_cap_trunc(MetaSession *session, Inode *in, MClientCaps *m)
+void Client::handle_cap_trunc(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = session->mds_num;
   ceph_assert(in->caps.count(mds));
@@ -4966,10 +4910,9 @@ void Client::handle_cap_trunc(MetaSession *session, Inode *in, MClientCaps *m)
   issued |= in->caps_dirty();
   update_inode_file_size(in, issued, m->get_size(),
                         m->get_truncate_seq(), m->get_truncate_size());
-  m->put();
 }
 
-void Client::handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, MClientCaps *m)
+void Client::handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m)
 {
   ceph_tid_t flush_ack_tid = m->get_client_tid();
   int dirty = m->get_dirty();
@@ -5030,12 +4973,10 @@ void Client::handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, MCl
        put_inode(in);
     }
   }
-  
-  m->put();
 }
 
 
-void Client::handle_cap_flushsnap_ack(MetaSession *session, Inode *in, MClientCaps *m)
+void Client::handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = session->mds_num;
   ceph_assert(in->caps.count(mds));
@@ -5061,8 +5002,6 @@ void Client::handle_cap_flushsnap_ack(MetaSession *session, Inode *in, MClientCa
            << " on " << *in << dendl;
     // we may not have it if we send multiple FLUSHSNAP requests and (got multiple FLUSHEDSNAPs back)
   }
-
-  m->put();
 }
 
 class C_Client_DentryInvalidate : public Context  {
@@ -5152,7 +5091,7 @@ void Client::_try_to_trim_inode(Inode *in, bool sched_inval)
   }
 }
 
-void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, MClientCaps *m)
+void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m)
 {
   mds_rank_t mds = session->mds_num;
   int used = get_caps_used(in);
@@ -5292,8 +5231,6 @@ void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, MClient
   // may drop inode's last ref
   if (deleted_inode)
     _try_to_trim_inode(in, true);
-
-  m->put();
 }
 
 int Client::inode_permission(Inode *in, const UserPerm& perms, unsigned want)
@@ -5747,15 +5684,15 @@ int Client::mds_command(
       << " tid=" << op.tid << cmd << dendl;
 
     // Construct and send MCommand
-    MCommand *m = op.get_message(monclient->get_fsid());
-    conn->send_message(m);
+    auto m = op.get_message(monclient->get_fsid());
+    conn->send_message2(std::move(m));
   }
   gather.activate();
 
   return 0;
 }
 
-void Client::handle_command_reply(MCommandReply *m)
+void Client::handle_command_reply(const MCommandReply::const_ref& m)
 {
   ceph_tid_t const tid = m->get_tid();
 
@@ -5763,13 +5700,12 @@ void Client::handle_command_reply(MCommandReply *m)
 
   if (!command_table.exists(tid)) {
     ldout(cct, 1) << __func__ << ": unknown tid " << tid << ", dropping" << dendl;
-    m->put();
     return;
   }
 
   auto &op = command_table.get_command(tid);
   if (op.outbl) {
-    op.outbl->claim(m->get_data());
+    *op.outbl = m->get_data();
   }
   if (op.outs) {
     *op.outs = m->rs;
@@ -5780,8 +5716,6 @@ void Client::handle_command_reply(MCommandReply *m)
   }
 
   command_table.erase(tid);
-
-  m->put();
 }
 
 // -------------------
@@ -5952,7 +5886,7 @@ void Client::flush_mdlog(MetaSession *session)
   const uint64_t features = session->con->get_features();
   if (HAVE_FEATURE(features, SERVER_LUMINOUS)) {
     auto m = MClientSession::create(CEPH_SESSION_REQUEST_FLUSH_MDLOG);
-    session->con->send_message2(m);
+    session->con->send_message2(std::move(m));
   }
 }
 
@@ -6139,7 +6073,7 @@ void Client::flush_cap_releases()
       if (cct->_conf->client_inject_release_failure) {
         ldout(cct, 20) << __func__ << " injecting failure to send cap release message" << dendl;
       } else {
-        session.con->send_message2(session.release);
+        session.con->send_message2(std::move(session.release));
       }
       session.release.reset();
     }
@@ -14370,7 +14304,7 @@ int Client::start_reclaim(const std::string& uuid, unsigned flags,
        session->reclaim_state == MetaSession::RECLAIMING) {
       session->reclaim_state = MetaSession::RECLAIMING;
       auto m = MClientReclaim::create(uuid, flags);
-      session->con->send_message2(m);
+      session->con->send_message2(std::move(m));
       wait_on_list(waiting_for_reclaim);
     } else if (session->reclaim_state == MetaSession::RECLAIM_FAIL) {
       return reclaim_errno ? : -ENOTRECOVERABLE;
@@ -14422,14 +14356,14 @@ void Client::finish_reclaim()
   for (auto &p : mds_sessions) {
     p.second.reclaim_state = MetaSession::RECLAIM_NULL;
     auto m = MClientReclaim::create("", MClientReclaim::FLAG_FINISH);
-    p.second.con->send_message2(m);
+    p.second.con->send_message2(std::move(m));
   }
 
   metadata["uuid"] = it->second;
   metadata.erase(it);
 }
 
-void Client::handle_client_reclaim_reply(MClientReclaimReply *reply)
+void Client::handle_client_reclaim_reply(const MClientReclaimReply::const_ref& reply)
 {
   mds_rank_t from = mds_rank_t(reply->get_source().num());
   ldout(cct, 10) << __func__ << " " << *reply << " from mds." << from << dendl;
@@ -14437,7 +14371,6 @@ void Client::handle_client_reclaim_reply(MClientReclaimReply *reply)
   MetaSession *session = _get_mds_session(from, reply->get_connection().get());
   if (!session) {
     ldout(cct, 10) << " discarding reclaim reply from sessionless mds." <<  from << dendl;
-    reply->put();
     return;
   }
 
@@ -14453,7 +14386,6 @@ void Client::handle_client_reclaim_reply(MClientReclaimReply *reply)
   }
 
   signal_cond_list(waiting_for_reclaim);
-  reply->put();
 }
 
 /**

diff --git a/src/client/Client.h b/src/client/Client.h
index cc9816689e8f5266aa4dacba3ed93ce9ab8c32ef..4baa931c9cc823891ef30051c3bf14dbd81d2a20 100644 (file)
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -34,6 +34,21 @@
 #include "msg/Messenger.h"
 #include "osdc/ObjectCacher.h"
 
+#include "messages/MClientCaps.h"
+#include "messages/MClientLease.h"
+#include "messages/MClientQuota.h"
+#include "messages/MClientReclaimReply.h"
+#include "messages/MClientReply.h"
+#include "messages/MClientRequest.h"
+#include "messages/MClientRequestForward.h"
+#include "messages/MClientSession.h"
+#include "messages/MClientSnap.h"
+#include "messages/MCommandReply.h"
+#include "messages/MFSMap.h"
+#include "messages/MFSMapUser.h"
+#include "messages/MMDSMap.h"
+#include "messages/MOSDMap.h"
+
 #include "InodeRef.h"
 #include "MetaSession.h"
 #include "UserPerm.h"
@@ -53,14 +68,6 @@ class FSMapUser;
 class MonClient;
 
 class CephContext;
-class MClientReply;
-class MClientRequest;
-class MClientSession;
-class MClientRequest;
-class MClientRequestForward;
-class MClientLease;
-class MClientCaps;
-class MClientReclaimReply;
 
 struct DirStat;
 struct LeaseStat;
@@ -638,12 +645,12 @@ public:
   virtual void shutdown();
 
   // messaging
-  void handle_mds_map(class MMDSMap *m);
-  void handle_fs_map(class MFSMap *m);
-  void handle_fs_map_user(class MFSMapUser *m);
-  void handle_osd_map(class MOSDMap *m);
+  void handle_mds_map(const MMDSMap::const_ref& m);
+  void handle_fs_map(const MFSMap::const_ref& m);
+  void handle_fs_map_user(const MFSMapUser::const_ref& m);
+  void handle_osd_map(const MOSDMap::const_ref& m);
 
-  void handle_lease(MClientLease *m);
+  void handle_lease(const MClientLease::const_ref& m);
 
   // inline data
   int uninline_data(Inode *in, Context *onfinish);
@@ -669,15 +676,15 @@ public:
   void maybe_update_snaprealm(SnapRealm *realm, snapid_t snap_created, snapid_t snap_highwater,
                              vector<snapid_t>& snaps);
 
-  void handle_quota(struct MClientQuota *m);
-  void handle_snap(struct MClientSnap *m);
-  void handle_caps(class MClientCaps *m);
-  void handle_cap_import(MetaSession *session, Inode *in, class MClientCaps *m);
-  void handle_cap_export(MetaSession *session, Inode *in, class MClientCaps *m);
-  void handle_cap_trunc(MetaSession *session, Inode *in, class MClientCaps *m);
-  void handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, class MClientCaps *m);
-  void handle_cap_flushsnap_ack(MetaSession *session, Inode *in, class MClientCaps *m);
-  void handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, class MClientCaps *m);
+  void handle_quota(const MClientQuota::const_ref& m);
+  void handle_snap(const MClientSnap::const_ref& m);
+  void handle_caps(const MClientCaps::const_ref& m);
+  void handle_cap_import(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
+  void handle_cap_export(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
+  void handle_cap_trunc(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
+  void handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m);
+  void handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
+  void handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m);
   void cap_delay_requeue(Inode *in);
   void send_cap(Inode *in, MetaSession *session, Cap *cap, bool sync,
                int used, int want, int retain, int flush,
@@ -774,7 +781,7 @@ protected:
 
   void set_cap_epoch_barrier(epoch_t e);
 
-  void handle_command_reply(MCommandReply *m);
+  void handle_command_reply(const MCommandReply::const_ref& m);
   int fetch_fsmap(bool user);
   int resolve_mds(
       const std::string &mds_spec,
@@ -790,7 +797,7 @@ protected:
   void _closed_mds_session(MetaSession *s);
   bool _any_stale_sessions() const;
   void _kick_stale_sessions();
-  void handle_client_session(MClientSession *m);
+  void handle_client_session(const MClientSession::const_ref& m);
   void send_reconnect(MetaSession *s);
   void resend_unsafe_requests(MetaSession *s);
   void wait_unsafe_requests();
@@ -806,7 +813,7 @@ protected:
   void put_request(MetaRequest *request);
   void unregister_request(MetaRequest *request);
 
-  int verify_reply_trace(int r, MetaRequest *request, MClientReply *reply,
+  int verify_reply_trace(int r, MetaRequest *request, const MClientReply::const_ref& reply,
                         InodeRef *ptarget, bool *pcreated,
                         const UserPerm& perms);
   void encode_cap_releases(MetaRequest *request, mds_rank_t mds);
@@ -819,11 +826,11 @@ protected:
   void connect_mds_targets(mds_rank_t mds);
   void send_request(MetaRequest *request, MetaSession *session,
                    bool drop_cap_releases=false);
-  MClientRequest *build_client_request(MetaRequest *request);
+  MClientRequest::ref build_client_request(MetaRequest *request);
   void kick_requests(MetaSession *session);
   void kick_requests_closed(MetaSession *session);
-  void handle_client_request_forward(MClientRequestForward *reply);
-  void handle_client_reply(MClientReply *reply);
+  void handle_client_request_forward(const MClientRequestForward::const_ref& reply);
+  void handle_client_reply(const MClientReply::const_ref& reply);
   bool is_dir_operation(MetaRequest *request);
 
   // fake inode number for 32-bits ino_t
@@ -840,7 +847,7 @@ protected:
   SnapRealm *get_snap_realm_maybe(inodeno_t r);
   void put_snap_realm(SnapRealm *realm);
   bool adjust_realm_parent(SnapRealm *realm, inodeno_t parent);
-  void update_snap_trace(bufferlist& bl, SnapRealm **realm_ret, bool must_flush=true);
+  void update_snap_trace(const bufferlist& bl, SnapRealm **realm_ret, bool must_flush=true);
   void invalidate_snaprealm_and_children(SnapRealm *realm);
 
   Inode *open_snapdir(Inode *diri);
@@ -925,7 +932,7 @@ protected:
 
   void dump_status(Formatter *f);  // debug
 
-  bool ms_dispatch(Message *m) override;
+  bool ms_dispatch2(const Message::ref &m) override;
 
   void ms_handle_connect(Connection *con) override;
   bool ms_handle_reset(Connection *con) override;
@@ -945,7 +952,7 @@ protected:
 
   int check_pool_perm(Inode *in, int need);
 
-  void handle_client_reclaim_reply(MClientReclaimReply *reply);
+  void handle_client_reclaim_reply(const MClientReclaimReply::const_ref& reply);
 
   /**
    * Call this when an OSDMap is seen with a full flag (global or per pool)

diff --git a/src/client/MetaRequest.cc b/src/client/MetaRequest.cc
index 8a71b2753d7e35d30164d38c97e04723e9c7d970..828ce7b87238c57b7785b23ea10727352a615223 100644 (file)
--- a/src/client/MetaRequest.cc
+++ b/src/client/MetaRequest.cc
@@ -56,8 +56,6 @@ MetaRequest::~MetaRequest()
     _dentry->put();
   if (_old_dentry)
     _old_dentry->put();
-  if (reply)
-    reply->put();
 }
 
 void MetaRequest::set_dentry(Dentry *d) {

diff --git a/src/client/MetaRequest.h b/src/client/MetaRequest.h
index d7eb374cadd873fef4e48180b8ff1bba708479a8..f9dfe9824265a26aa501f180cc6e59ea3e382e56 100644 (file)
--- a/src/client/MetaRequest.h
+++ b/src/client/MetaRequest.h
@@ -13,8 +13,8 @@
 #include "UserPerm.h"
 
 #include "messages/MClientRequest.h"
+#include "messages/MClientReply.h"
 
-class MClientReply;
 class Dentry;
 class dir_result_t;
 
@@ -49,7 +49,7 @@ public:
   int      retry_attempt;
   std::atomic<uint64_t> ref = { 1 };
   
-  MClientReply *reply;         // the reply
+  MClientReply::const_ref reply;         // the reply
   bool kick;
   bool success;
   

diff --git a/src/common/CommandTable.h b/src/common/CommandTable.h
index ed34488d1dff74b9972d47c15e2c02e735aace07..3fea9a03c73c56b5e9b0dab6e8feb775d23ade02 100644 (file)
--- a/src/common/CommandTable.h
+++ b/src/common/CommandTable.h
@@ -29,9 +29,9 @@ class CommandOp
   bufferlist   *outbl;
   std::string  *outs;
 
-  MCommand *get_message(const uuid_d &fsid) const
+  MCommand::ref get_message(const uuid_d &fsid) const
   {
-    MCommand *m = new MCommand(fsid);
+    auto m = MCommand::create(fsid);
     m->cmd = cmd;
     m->set_data(inbl);
     m->set_tid(tid);

diff --git a/src/messages/MClientReply.h b/src/messages/MClientReply.h
index c946d8d61f10f8a9f7c64ae8e0c4c60a5854913b..4b10128154c0207dfe3a6a4d4133b87047561b0e 100644 (file)
--- a/src/messages/MClientReply.h
+++ b/src/messages/MClientReply.h
@@ -336,7 +336,10 @@ public:
   void set_extra_bl(bufferlist& bl) {
     extra_bl.claim(bl);
   }
-  bufferlist &get_extra_bl() {
+  bufferlist& get_extra_bl() {
+    return extra_bl;
+  }
+  const bufferlist& get_extra_bl() const {
     return extra_bl;
   }
 
@@ -347,6 +350,9 @@ public:
   bufferlist& get_trace_bl() {
     return trace_bl;
   }
+  const bufferlist& get_trace_bl() const {
+    return trace_bl;
+  }
 };
 
 #endif

diff --git a/src/messages/MClientRequestForward.h b/src/messages/MClientRequestForward.h
index d25860422c0436a1ce89a5dad0e88d875f6f9864..e3dc8071767f0097f96712093bb58b8fba524f42 100644 (file)
--- a/src/messages/MClientRequestForward.h
+++ b/src/messages/MClientRequestForward.h
@@ -39,9 +39,9 @@ protected:
   ~MClientRequestForward() override {}
 
 public:
-  int get_dest_mds() { return dest_mds; }
-  int get_num_fwd() { return num_fwd; }
-  bool must_resend() { return client_must_resend; }
+  int get_dest_mds() const { return dest_mds; }
+  int get_num_fwd() const { return num_fwd; }
+  bool must_resend() const { return client_must_resend; }
 
   std::string_view get_type_name() const override { return "client_request_forward"; }
   void print(ostream& o) const override {

diff --git a/src/messages/MFSMap.h b/src/messages/MFSMap.h
index 7115ba117850bc4ddd28f4a10ca8850031817fce..99f241d53aeef844851d132cefb789c67d6517fa 100644 (file)
--- a/src/messages/MFSMap.h
+++ b/src/messages/MFSMap.h
@@ -28,7 +28,7 @@ public:
   bufferlist encoded;
 
   version_t get_epoch() const { return epoch; }
-  const FSMap & get_fsmap() {return fsmap;}
+  const FSMap& get_fsmap() const {return fsmap;}
 
   MFSMap() : 
     MessageInstance(CEPH_MSG_FS_MAP), epoch(0) {}

diff --git a/src/messages/MFSMapUser.h b/src/messages/MFSMapUser.h
index bf2f6f629e7d4a6659b49eda0127f34cb6dbfe59..215b121164250a33d2d5364059240f28c607cea2 100644 (file)
--- a/src/messages/MFSMapUser.h
+++ b/src/messages/MFSMapUser.h
@@ -26,7 +26,7 @@ public:
   epoch_t epoch;
 
   version_t get_epoch() const { return epoch; }
-  const FSMapUser & get_fsmap() { return fsmap; }
+  const FSMapUser& get_fsmap() const { return fsmap; }
 
   MFSMapUser() :
     MessageInstance(CEPH_MSG_FS_MAP_USER), epoch(0) {}

diff --git a/src/mgr/MgrClient.cc b/src/mgr/MgrClient.cc
index 162854a2eca15ff21e955841d2ce0e796ac1bd5c..5a9541d32aacadcbc4ed754ebb984c3b408f05ed 100644 (file)
--- a/src/mgr/MgrClient.cc
+++ b/src/mgr/MgrClient.cc
@@ -169,10 +169,10 @@ void MgrClient::reconnect()
 
   // resend any pending commands
   for (const auto &p : command_table.get_commands()) {
-    MCommand *m = p.second.get_message({});
+    auto m = p.second.get_message({});
     ceph_assert(session);
     ceph_assert(session->con);
-    session->con->send_message(m);
+    session->con->send_message2(std::move(m));
   }
 }
 
@@ -433,8 +433,8 @@ int MgrClient::start_command(const vector<string>& cmd, const bufferlist& inbl,
 
   if (session && session->con) {
     // Leaving fsid argument null because it isn't used.
-    MCommand *m = op.get_message({});
-    session->con->send_message(m);
+    auto m = op.get_message({});
+    session->con->send_message2(std::move(m));
   } else {
     ldout(cct, 0) << "no mgr session (no running mgr daemon?), waiting" << dendl;
   }