client: switch to use shared_ptr for mds_sessions

To break the `client_lock`, when we need to unlock it and lock it
later, during the gap we must make sure that the `session` won't
be released.

Signed-off-by: Xiubo Li <xiubli@redhat.com>

diff --git a/src/client/Client.cc b/src/client/Client.cc
index dad50d2cb0df3c12a769f49456d6d82d8402c244..00f38421f4b034e435481e9608b8fbb9f7b30282 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -1652,7 +1652,7 @@ void Client::dump_mds_sessions(Formatter *f, bool cap_dump)
   f->open_array_section("sessions");
   for (const auto &p : mds_sessions) {
     f->open_object_section("session");
-    p.second.dump(f, cap_dump);
+    p.second->dump(f, cap_dump);
     f->close_section();
   }
   f->close_section();
@@ -1808,7 +1808,7 @@ int Client::make_request(MetaRequest *request,
   if (use_mds >= 0)
     request->resend_mds = use_mds;
 
-  MetaSession *session = NULL;
+  MetaSessionRef session = NULL;
   while (1) {
     if (request->aborted())
       break;
@@ -1859,11 +1859,11 @@ int Client::make_request(MetaRequest *request,
       if (!have_open_session(mds))
        continue;
     } else {
-      session = &mds_sessions.at(mds);
+      session = mds_sessions.at(mds);
     }
 
     // send request.
-    send_request(request, session);
+    send_request(request, session.get());
 
     // wait for signal
     ldout(cct, 20) << "awaiting reply|forward|kick on " << &caller_cond << dendl;
@@ -1905,7 +1905,7 @@ int Client::make_request(MetaRequest *request,
   request->dispatch_cond = 0;
   
   if (r >= 0 && ptarget)
-    r = verify_reply_trace(r, session, request, reply, ptarget, pcreated, perms);
+    r = verify_reply_trace(r, session.get(), request, reply, ptarget, pcreated, perms);
 
   if (pdirbl)
     *pdirbl = reply->get_extra_bl();
@@ -2069,24 +2069,24 @@ bool Client::have_open_session(mds_rank_t mds)
 {
   const auto &it = mds_sessions.find(mds);
   return it != mds_sessions.end() &&
-    (it->second.state == MetaSession::STATE_OPEN ||
-     it->second.state == MetaSession::STATE_STALE);
+    (it->second->state == MetaSession::STATE_OPEN ||
+     it->second->state == MetaSession::STATE_STALE);
 }
 
-MetaSession *Client::_get_mds_session(mds_rank_t mds, Connection *con)
+MetaSessionRef Client::_get_mds_session(mds_rank_t mds, Connection *con)
 {
   const auto &it = mds_sessions.find(mds);
-  if (it == mds_sessions.end() || it->second.con != con) {
+  if (it == mds_sessions.end() || it->second->con != con) {
     return NULL;
   } else {
-    return &it->second;
+    return it->second;
   }
 }
 
-MetaSession *Client::_get_or_open_mds_session(mds_rank_t mds)
+MetaSessionRef Client::_get_or_open_mds_session(mds_rank_t mds)
 {
   auto it = mds_sessions.find(mds);
-  return it == mds_sessions.end() ? _open_mds_session(mds) : &it->second;
+  return it == mds_sessions.end() ? _open_mds_session(mds) : it->second;
 }
 
 /**
@@ -2160,15 +2160,15 @@ void Client::update_metadata(std::string const &k, std::string const &v)
   metadata[k] = v;
 }
 
-MetaSession *Client::_open_mds_session(mds_rank_t mds)
+MetaSessionRef Client::_open_mds_session(mds_rank_t mds)
 {
   ldout(cct, 10) << __func__ << " mds." << mds << dendl;
   auto addrs = mdsmap->get_addrs(mds);
   auto em = mds_sessions.emplace(std::piecewise_construct,
       std::forward_as_tuple(mds),
-      std::forward_as_tuple(mds, messenger->connect_to_mds(addrs), addrs));
+      std::forward_as_tuple(new MetaSession(mds, messenger->connect_to_mds(addrs), addrs)));
   ceph_assert(em.second); /* not already present */
-  MetaSession *session = &em.first->second;
+  auto session = em.first->second;
 
   auto m = make_message<MClientSession>(CEPH_SESSION_REQUEST_OPEN);
   m->metadata = metadata;
@@ -2208,7 +2208,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
   ldout(cct, 10) << __func__ << " " << *m << " from mds." << from << dendl;
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(from, m->get_connection().get());
+  auto 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;
     return;
@@ -2222,13 +2222,13 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
       if (!missing_features.empty()) {
        lderr(cct) << "mds." << from << " lacks required features '"
                   << missing_features << "', closing session " << dendl;
-       _close_mds_session(session);
-       _closed_mds_session(session, -CEPHFS_EPERM, true);
+       _close_mds_session(session.get());
+       _closed_mds_session(session.get(), -CEPHFS_EPERM, true);
        break;
       }
       session->mds_features = std::move(m->supported_features);
 
-      renew_caps(session);
+      renew_caps(session.get());
       session->state = MetaSession::STATE_OPEN;
       if (is_unmounting())
        mount_cond.notify_all();
@@ -2239,7 +2239,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
     }
 
   case CEPH_SESSION_CLOSE:
-    _closed_mds_session(session);
+    _closed_mds_session(session.get());
     break;
 
   case CEPH_SESSION_RENEWCAPS:
@@ -2248,7 +2248,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
       session->cap_ttl =
        session->last_cap_renew_request + mdsmap->get_session_timeout();
       if (was_stale)
-       wake_up_session_caps(session, false);
+       wake_up_session_caps(session.get(), false);
     }
     break;
 
@@ -2257,7 +2257,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
     session->cap_gen++;
     session->cap_ttl = ceph_clock_now();
     session->cap_ttl -= 1;
-    renew_caps(session);
+    renew_caps(session.get());
     break;
 
   case CEPH_SESSION_RECALL_STATE:
@@ -2273,7 +2273,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
      * by tick().
      */
     renew_and_flush_cap_releases();
-    trim_caps(session, m->get_max_caps());
+    trim_caps(session.get(), m->get_max_caps());
     break;
 
   case CEPH_SESSION_FLUSHMSG:
@@ -2285,7 +2285,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
     break;
 
   case CEPH_SESSION_FORCE_RO:
-    force_session_readonly(session);
+    force_session_readonly(session.get());
     break;
 
   case CEPH_SESSION_REJECT:
@@ -2298,7 +2298,7 @@ void Client::handle_client_session(const MConstRef<MClientSession>& m)
        error_str = "unknown error";
       lderr(cct) << "mds." << from << " rejected us (" << error_str << ")" << dendl;
 
-      _closed_mds_session(session, -CEPHFS_EPERM, true);
+      _closed_mds_session(session.get(), -CEPHFS_EPERM, true);
     }
     break;
 
@@ -2312,7 +2312,7 @@ bool Client::_any_stale_sessions() const
   ceph_assert(ceph_mutex_is_locked_by_me(client_lock));
 
   for (const auto &p : mds_sessions) {
-    if (p.second.state == MetaSession::STATE_STALE) {
+    if (p.second->state == MetaSession::STATE_STALE) {
       return true;
     }
   }
@@ -2325,14 +2325,13 @@ void Client::_kick_stale_sessions()
   ldout(cct, 1) << __func__ << dendl;
 
   for (auto it = mds_sessions.begin(); it != mds_sessions.end(); ) {
-    MetaSession &s = it->second;
-    if (s.state == MetaSession::STATE_REJECTED) {
-      mds_sessions.erase(it++);
+    auto s = it->second;
+    if (s->state == MetaSession::STATE_REJECTED) {
+      mds_sessions.erase(it->first);
       continue;
     }
-    ++it;
-    if (s.state == MetaSession::STATE_STALE)
-      _closed_mds_session(&s);
+    if (s->state == MetaSession::STATE_STALE)
+      _closed_mds_session(s.get());
   }
 }
 
@@ -2431,7 +2430,7 @@ void Client::handle_client_request_forward(const MConstRef<MClientRequestForward
   mds_rank_t mds = mds_rank_t(fwd->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds, fwd->get_connection().get());
+  auto session = _get_mds_session(mds, fwd->get_connection().get());
   if (!session) {
     return;
   }
@@ -2479,7 +2478,7 @@ void Client::handle_client_reply(const MConstRef<MClientReply>& reply)
   mds_rank_t mds_num = mds_rank_t(reply->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds_num, reply->get_connection().get());
+  auto session = _get_mds_session(mds_num, reply->get_connection().get());
   if (!session) {
     return;
   }
@@ -2525,7 +2524,7 @@ void Client::handle_client_reply(const MConstRef<MClientReply>& reply)
   
   ceph_assert(!request->reply);
   request->reply = reply;
-  insert_trace(request, session);
+  insert_trace(request, session.get());
 
   // Handle unsafe reply
   if (!is_safe) {
@@ -2867,10 +2866,9 @@ void Client::handle_mds_map(const MConstRef<MMDSMap>& m)
   _mdsmap.swap(mdsmap);
 
   // reset session
-  for (auto p = mds_sessions.begin(); p != mds_sessions.end(); ) {
-    mds_rank_t mds = p->first;
-    MetaSession *session = &p->second;
-    ++p;
+  for (auto &p : mds_sessions) {
+    mds_rank_t mds = p.first;
+    auto session = p.second;
 
     int oldstate = _mdsmap->get_state(mds);
     int newstate = mdsmap->get_state(mds);
@@ -2889,33 +2887,33 @@ void Client::handle_mds_map(const MConstRef<MMDSMap>& m)
       // When new MDS starts to take over, notify kernel to trim unused entries
       // in its dcache/icache. Hopefully, the kernel will release some unused
       // inodes before the new MDS enters reconnect state.
-      trim_cache_for_reconnect(session);
+      trim_cache_for_reconnect(session.get());
     } else if (oldstate == newstate)
       continue;  // no change
 
     session->mds_state = newstate;
     if (newstate == MDSMap::STATE_RECONNECT) {
       session->con = messenger->connect_to_mds(session->addrs);
-      send_reconnect(session);
+      send_reconnect(session.get());
     } else if (newstate > MDSMap::STATE_RECONNECT) {
       if (oldstate < MDSMap::STATE_RECONNECT) {
        ldout(cct, 1) << "we may miss the MDSMap::RECONNECT, close mds session ... " << dendl;
-       _closed_mds_session(session);
+       _closed_mds_session(session.get());
        continue;
       }
       if (newstate >= MDSMap::STATE_ACTIVE) {
        if (oldstate < MDSMap::STATE_ACTIVE) {
          // kick new requests
-         kick_requests(session);
-         kick_flushing_caps(session);
+         kick_requests(session.get());
+         kick_flushing_caps(session.get());
          signal_context_list(session->waiting_for_open);
-         wake_up_session_caps(session, true);
+         wake_up_session_caps(session.get(), true);
        }
        connect_mds_targets(mds);
       }
     } else if (newstate == MDSMap::STATE_NULL &&
               mds >= mdsmap->get_max_mds()) {
-      _closed_mds_session(session);
+      _closed_mds_session(session.get());
     }
   }
 
@@ -3072,9 +3070,9 @@ void Client::wait_unsafe_requests()
 {
   list<MetaRequest*> last_unsafe_reqs;
   for (const auto &p : mds_sessions) {
-    const MetaSession &s = p.second;
-    if (!s.unsafe_requests.empty()) {
-      MetaRequest *req = s.unsafe_requests.back();
+    const auto s = p.second;
+    if (!s->unsafe_requests.empty()) {
+      MetaRequest *req = s->unsafe_requests.back();
       req->get();
       last_unsafe_reqs.push_back(req);
     }
@@ -3154,12 +3152,12 @@ void Client::handle_lease(const MConstRef<MClientLease>& m)
   mds_rank_t mds = mds_rank_t(m->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds, m->get_connection().get());
+  auto session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
     return;
   }
 
-  got_mds_push(session);
+  got_mds_push(session.get());
 
   ceph_seq_t seq = m->get_seq();
 
@@ -3762,7 +3760,7 @@ void Client::check_caps(Inode *in, unsigned flags)
   }
 
   for (auto &[mds, cap] : in->caps) {
-    MetaSession *session = &mds_sessions.at(mds);
+    auto session = mds_sessions.at(mds);
 
     cap_used = used;
     if (in->auth_cap && &cap != in->auth_cap)
@@ -3817,7 +3815,7 @@ void Client::check_caps(Inode *in, unsigned flags)
       if (in->flags & I_KICK_FLUSH) {
        ldout(cct, 20) << " reflushing caps (check_caps) on " << *in
                       << " to mds." << mds << dendl;
-       kick_flushing_caps(in, session);
+       kick_flushing_caps(in, session.get());
       }
       if (!in->cap_snaps.empty() &&
          in->cap_snaps.rbegin()->second.flush_tid == 0)
@@ -3836,7 +3834,7 @@ void Client::check_caps(Inode *in, unsigned flags)
       flush_tid = 0;
     }
 
-    send_cap(in, session, &cap, msg_flags, cap_used, wanted, retain,
+    send_cap(in, session.get(), &cap, msg_flags, cap_used, wanted, retain,
             flushing, flush_tid);
   }
 }
@@ -4704,7 +4702,7 @@ void Client::wait_sync_caps(ceph_tid_t want)
   ldout(cct, 10) << __func__ << " want " << want  << " (last is " << last_flush_tid << ", "
           << num_flushing_caps << " total flushing)" << dendl;
   for (auto &p : mds_sessions) {
-    MetaSession *s = &p.second;
+    auto s = p.second;
     if (s->flushing_caps_tids.empty())
        continue;
     ceph_tid_t oldest_tid = *s->flushing_caps_tids.begin();
@@ -4967,12 +4965,12 @@ void Client::handle_snap(const MConstRef<MClientSnap>& m)
   mds_rank_t mds = mds_rank_t(m->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds, m->get_connection().get());
+  auto session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
     return;
   }
 
-  got_mds_push(session);
+  got_mds_push(session.get());
 
   map<Inode*, SnapContext> to_move;
   SnapRealm *realm = 0;
@@ -5039,12 +5037,12 @@ void Client::handle_quota(const MConstRef<MClientQuota>& m)
   mds_rank_t mds = mds_rank_t(m->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds, m->get_connection().get());
+  auto session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
     return;
   }
 
-  got_mds_push(session);
+  got_mds_push(session.get());
 
   ldout(cct, 10) << __func__ << " " << *m << " from mds." << mds << dendl;
 
@@ -5065,7 +5063,7 @@ void Client::handle_caps(const MConstRef<MClientCaps>& m)
   mds_rank_t mds = mds_rank_t(m->get_source().num());
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(mds, m->get_connection().get());
+  auto session = _get_mds_session(mds, m->get_connection().get());
   if (!session) {
     return;
   }
@@ -5080,7 +5078,7 @@ void Client::handle_caps(const MConstRef<MClientCaps>& m)
     set_cap_epoch_barrier(m->osd_epoch_barrier);
   }
 
-  got_mds_push(session);
+  got_mds_push(session.get());
 
   Inode *in;
   vinodeno_t vino(m->get_ino(), CEPH_NOSNAP);
@@ -5105,20 +5103,20 @@ void Client::handle_caps(const MConstRef<MClientCaps>& m)
   }
 
   switch (m->get_op()) {
-    case CEPH_CAP_OP_EXPORT: return handle_cap_export(session, in, m);
-    case CEPH_CAP_OP_FLUSHSNAP_ACK: return handle_cap_flushsnap_ack(session, in, m);
-    case CEPH_CAP_OP_IMPORT: /* no return */ handle_cap_import(session, in, m);
+    case CEPH_CAP_OP_EXPORT: return handle_cap_export(session.get(), in, m);
+    case CEPH_CAP_OP_FLUSHSNAP_ACK: return handle_cap_flushsnap_ack(session.get(), in, m);
+    case CEPH_CAP_OP_IMPORT: /* no return */ handle_cap_import(session.get(), in, m);
   }
 
   if (auto it = in->caps.find(mds); it != in->caps.end()) {
     Cap &cap = in->caps.at(mds);
 
     switch (m->get_op()) {
-      case CEPH_CAP_OP_TRUNC: return handle_cap_trunc(session, in, m);
+      case CEPH_CAP_OP_TRUNC: return handle_cap_trunc(session.get(), in, m);
       case CEPH_CAP_OP_IMPORT:
       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);
+      case CEPH_CAP_OP_GRANT: return handle_cap_grant(session.get(), in, &cap, m);
+      case CEPH_CAP_OP_FLUSH_ACK: return handle_cap_flush_ack(session.get(), in, &cap, m);
     }
   } else {
     ldout(cct, 5) << __func__ << " don't have " << *in << " cap on mds." << mds << dendl;
@@ -5182,7 +5180,7 @@ void Client::handle_cap_export(MetaSession *session, Inode *in, const MConstRef<
     if (cap.cap_id == m->get_cap_id()) {
       if (m->peer.cap_id) {
        const auto peer_mds = mds_rank_t(m->peer.mds);
-        MetaSession *tsession = _get_or_open_mds_session(peer_mds);
+        auto tsession = _get_or_open_mds_session(peer_mds);
         auto it = in->caps.find(peer_mds);
         if (it != in->caps.end()) {
          Cap &tcap = it->second;
@@ -5196,10 +5194,10 @@ void Client::handle_cap_export(MetaSession *session, Inode *in, const MConstRef<
            if (&cap == in->auth_cap)
              in->auth_cap = &tcap;
            if (in->auth_cap == &tcap && in->flushing_cap_item.is_on_list())
-             adjust_session_flushing_caps(in, session, tsession);
+             adjust_session_flushing_caps(in, session, tsession.get());
          }
         } else {
-         add_update_cap(in, tsession, m->peer.cap_id, cap.issued, 0,
+         add_update_cap(in, tsession.get(), m->peer.cap_id, cap.issued, 0,
                         m->peer.seq - 1, m->peer.mseq, (uint64_t)-1,
                         &cap == in->auth_cap ? CEPH_CAP_FLAG_AUTH : 0,
                         cap.latest_perms);
@@ -6253,7 +6251,7 @@ int Client::mount(const std::string &mount_root, const UserPerm& perms,
 void Client::_close_sessions()
 {
   for (auto it = mds_sessions.begin(); it != mds_sessions.end(); ) {
-    if (it->second.state == MetaSession::STATE_REJECTED)
+    if (it->second->state == MetaSession::STATE_REJECTED)
       mds_sessions.erase(it++);
     else
       ++it;
@@ -6262,8 +6260,8 @@ void Client::_close_sessions()
   while (!mds_sessions.empty()) {
     // send session closes!
     for (auto &p : mds_sessions) {
-      if (p.second.state != MetaSession::STATE_CLOSING) {
-       _close_mds_session(&p.second);
+      if (p.second->state != MetaSession::STATE_CLOSING) {
+       _close_mds_session(p.second.get());
        mds_ranks_closing.insert(p.first);
       }
     }
@@ -6280,7 +6278,7 @@ void Client::_close_sessions()
       while (!mds_ranks_closing.empty()) {
         auto session = mds_sessions.at(*mds_ranks_closing.begin());
         // this prunes entry from mds_sessions and mds_ranks_closing
-        _closed_mds_session(&session, -CEPHFS_ETIMEDOUT);
+        _closed_mds_session(session.get(), -CEPHFS_ETIMEDOUT);
       }
     }
 
@@ -6305,7 +6303,7 @@ void Client::flush_mdlog_sync(Inode *in)
 
   for (auto &rank : anchor) {
     auto session = &mds_sessions.at(rank);
-    flush_mdlog(session);
+    flush_mdlog(session->get());
   }
 }
 
@@ -6314,7 +6312,7 @@ void Client::flush_mdlog_sync()
   if (mds_requests.empty())
     return;
   for (auto &p : mds_sessions) {
-    flush_mdlog(&p.second);
+    flush_mdlog(p.second.get());
   }
 }
 
@@ -6353,8 +6351,8 @@ void Client::_abort_mds_sessions(int err)
 
   // Force-close all sessions
   while(!mds_sessions.empty()) {
-    auto& session = mds_sessions.begin()->second;
-    _closed_mds_session(&session, err);
+    auto session = mds_sessions.begin()->second;
+    _closed_mds_session(session.get(), err);
   }
 }
 
@@ -6518,16 +6516,16 @@ void Client::flush_cap_releases()
 
   // send any cap releases
   for (auto &p : mds_sessions) {
-    auto &session = p.second;
-    if (session.release && mdsmap->is_clientreplay_or_active_or_stopping(
+    auto session = p.second;
+    if (session->release && mdsmap->is_clientreplay_or_active_or_stopping(
           p.first)) {
-      nr_caps += session.release->caps.size();
+      nr_caps += session->release->caps.size();
       if (cct->_conf->client_inject_release_failure) {
         ldout(cct, 20) << __func__ << " injecting failure to send cap release message" << dendl;
       } else {
-        session.con->send_message2(std::move(session.release));
+        session->con->send_message2(std::move(session->release));
       }
-      session.release.reset();
+      session->release.reset();
     }
   }
 
@@ -6570,7 +6568,7 @@ void Client::tick()
       }
       signal_cond_list(waiting_for_mdsmap);
       for (auto &p : mds_sessions) {
-        signal_context_list(p.second.waiting_for_open);
+        signal_context_list(p.second->waiting_for_open);
       }
     }
   }
@@ -6719,7 +6717,7 @@ void Client::renew_caps()
   for (auto &p : mds_sessions) {
     ldout(cct, 15) << "renew_caps requesting from mds." << p.first << dendl;
     if (mdsmap->get_state(p.first) >= MDSMap::STATE_REJOIN)
-      renew_caps(&p.second);
+      renew_caps(p.second.get());
   }
 }
 
@@ -6764,13 +6762,13 @@ bool Client::_dentry_valid(const Dentry *dn)
   utime_t now = ceph_clock_now();
   if (dn->lease_mds >= 0 && dn->lease_ttl > now &&
       mds_sessions.count(dn->lease_mds)) {
-    MetaSession &s = mds_sessions.at(dn->lease_mds);
-    if (s.cap_ttl > now && s.cap_gen == dn->lease_gen) {
+    auto s = mds_sessions.at(dn->lease_mds);
+    if (s->cap_ttl > now && s->cap_gen == dn->lease_gen) {
       dlease_hit();
       return true;
     }
 
-    ldout(cct, 20) << " bad lease, cap_ttl " << s.cap_ttl << ", cap_gen " << s.cap_gen
+    ldout(cct, 20) << " bad lease, cap_ttl " << s->cap_ttl << ", cap_gen " << s->cap_gen
                    << " vs lease_gen " << dn->lease_gen << dendl;
   }
 
@@ -14995,11 +14993,11 @@ void Client::ms_handle_remote_reset(Connection *con)
     {
       // kludge to figure out which mds this is; fixme with a Connection* state
       mds_rank_t mds = MDS_RANK_NONE;
-      MetaSession *s = NULL;
+      MetaSessionRef s = NULL;
       for (auto &p : mds_sessions) {
        if (mdsmap->have_inst(p.first) && mdsmap->get_addrs(p.first) == con->get_peer_addrs()) {
          mds = p.first;
-         s = &p.second;
+         s = p.second;
        }
       }
       if (mds >= 0) {
@@ -15007,7 +15005,7 @@ void Client::ms_handle_remote_reset(Connection *con)
        switch (s->state) {
        case MetaSession::STATE_CLOSING:
          ldout(cct, 1) << "reset from mds we were closing; we'll call that closed" << dendl;
-         _closed_mds_session(s);
+         _closed_mds_session(s.get());
          break;
 
        case MetaSession::STATE_OPENING:
@@ -15015,8 +15013,8 @@ void Client::ms_handle_remote_reset(Connection *con)
            ldout(cct, 1) << "reset from mds we were opening; retrying" << dendl;
            list<Context*> waiters;
            waiters.swap(s->waiting_for_open);
-           _closed_mds_session(s);
-           MetaSession *news = _get_or_open_mds_session(mds);
+           _closed_mds_session(s.get());
+           auto news = _get_or_open_mds_session(mds);
            news->waiting_for_open.swap(waiters);
          }
          break;
@@ -15026,7 +15024,7 @@ void Client::ms_handle_remote_reset(Connection *con)
            objecter->maybe_request_map(); /* to check if we are blocklisted */
            if (cct->_conf.get_val<bool>("client_reconnect_stale")) {
              ldout(cct, 1) << "reset from mds we were open; close mds session for reconnect" << dendl;
-             _closed_mds_session(s);
+             _closed_mds_session(s.get());
            } else {
              ldout(cct, 1) << "reset from mds we were open; mark session as stale" << dendl;
              s->state = MetaSession::STATE_STALE;
@@ -15414,7 +15412,7 @@ int Client::start_reclaim(const std::string& uuid, unsigned flags,
       continue;
     }
 
-    MetaSession *session;
+    MetaSessionRef session;
     if (!have_open_session(mds)) {
       session = _get_or_open_mds_session(mds);
       if (session->state == MetaSession::STATE_REJECTED)
@@ -15428,7 +15426,7 @@ int Client::start_reclaim(const std::string& uuid, unsigned flags,
       continue;
     }
 
-    session = &mds_sessions.at(mds);
+    session = mds_sessions.at(mds);
     if (!session->mds_features.test(CEPHFS_FEATURE_RECLAIM_CLIENT))
       return -CEPHFS_EOPNOTSUPP;
 
@@ -15482,14 +15480,14 @@ void Client::finish_reclaim()
   auto it = metadata.find("reclaiming_uuid");
   if (it == metadata.end()) {
     for (auto &p : mds_sessions)
-      p.second.reclaim_state = MetaSession::RECLAIM_NULL;
+      p.second->reclaim_state = MetaSession::RECLAIM_NULL;
     return;
   }
 
   for (auto &p : mds_sessions) {
-    p.second.reclaim_state = MetaSession::RECLAIM_NULL;
+    p.second->reclaim_state = MetaSession::RECLAIM_NULL;
     auto m = make_message<MClientReclaim>("", MClientReclaim::FLAG_FINISH);
-    p.second.con->send_message2(std::move(m));
+    p.second->con->send_message2(std::move(m));
   }
 
   metadata["uuid"] = it->second;
@@ -15502,7 +15500,7 @@ void Client::handle_client_reclaim_reply(const MConstRef<MClientReclaimReply>& r
   ldout(cct, 10) << __func__ << " " << *reply << " from mds." << from << dendl;
 
   std::scoped_lock cl(client_lock);
-  MetaSession *session = _get_mds_session(from, reply->get_connection().get());
+  auto session = _get_mds_session(from, reply->get_connection().get());
   if (!session) {
     ldout(cct, 10) << " discarding reclaim reply from sessionless mds." <<  from << dendl;
     return;

diff --git a/src/client/Client.h b/src/client/Client.h
index bbf1619fedfddf804f151a50993861b2b62f0206..b6a76faca508373987d2e89858f5d6c5a6d877af 100644 (file)
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -901,9 +901,9 @@ protected:
   void get_session_metadata(std::map<std::string, std::string> *meta) const;
   bool have_open_session(mds_rank_t mds);
   void got_mds_push(MetaSession *s);
-  MetaSession *_get_mds_session(mds_rank_t mds, Connection *con);  ///< return session for mds *and* con; null otherwise
-  MetaSession *_get_or_open_mds_session(mds_rank_t mds);
-  MetaSession *_open_mds_session(mds_rank_t mds);
+  MetaSessionRef _get_mds_session(mds_rank_t mds, Connection *con);  ///< return session for mds *and* con; null otherwise
+  MetaSessionRef _get_or_open_mds_session(mds_rank_t mds);
+  MetaSessionRef _open_mds_session(mds_rank_t mds);
   void _close_mds_session(MetaSession *s);
   void _closed_mds_session(MetaSession *s, int err=0, bool rejected=false);
   bool _any_stale_sessions() const;
@@ -1476,7 +1476,7 @@ private:
   epoch_t cap_epoch_barrier = 0;
 
   // mds sessions
-  map<mds_rank_t, MetaSession> mds_sessions;  // mds -> push seq
+  map<mds_rank_t, MetaSessionRef> mds_sessions;  // mds -> push seq
   std::set<mds_rank_t> mds_ranks_closing;  // mds ranks currently tearing down sessions
   std::list<ceph::condition_variable*> waiting_for_mdsmap;
 

diff --git a/src/client/MetaSession.h b/src/client/MetaSession.h
index 775912b53a1a29261cb54edfe1c9043ed12eb889..cfeb26a471c90032f8ae938481a7c3cf67838075 100644 (file)
--- a/src/client/MetaSession.h
+++ b/src/client/MetaSession.h
@@ -68,4 +68,5 @@ struct MetaSession {
       ceph_seq_t mseq, epoch_t osd_barrier);
 };
 
+using MetaSessionRef = std::shared_ptr<MetaSession>;
 #endif