mds: using cap_reconnect_t to track cap recconect

Previous commit extended cap_reconnect_t to include snapflush
related information. This information are needed in various
places

Signed-off-by: Yan, Zheng <zyan@redhat.com>
(cherry picked from commit 25b6011dcf07c1fc663cbe29ffd119b66545a0ac)

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index df0b2bbeb49a6ce0c2c6c1b3499113ca5772fd05..0168b5658114272b8cc772270ee72c68517c806e 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -2817,18 +2817,18 @@ void CInode::move_to_realm(SnapRealm *realm)
   containing_realm = realm;
 }
 
-Capability *CInode::reconnect_cap(client_t client, ceph_mds_cap_reconnect& icr, Session *session)
+Capability *CInode::reconnect_cap(client_t client, const cap_reconnect_t& icr, Session *session)
 {
   Capability *cap = get_client_cap(client);
   if (cap) {
     // FIXME?
-    cap->merge(icr.wanted, icr.issued);
+    cap->merge(icr.capinfo.wanted, icr.capinfo.issued);
   } else {
     cap = add_client_cap(client, session);
-    cap->set_wanted(icr.wanted);
-    cap->issue_norevoke(icr.issued);
+    cap->set_cap_id(icr.capinfo.cap_id);
+    cap->set_wanted(icr.capinfo.wanted);
+    cap->issue_norevoke(icr.capinfo.issued);
     cap->reset_seq();
-    cap->set_cap_id(icr.cap_id);
   }
   cap->set_last_issue_stamp(ceph_clock_now(g_ceph_context));
   return cap;

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index 217257cca90fae6ecd32e4c1e461a2b66ea2cc2f..4181191341e20d2ba0fa72ed0b61b684695cc63b 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -987,7 +987,7 @@ public:
   void remove_client_cap(client_t client);
   void move_to_realm(SnapRealm *realm);
 
-  Capability *reconnect_cap(client_t client, ceph_mds_cap_reconnect& icr, Session *session);
+  Capability *reconnect_cap(client_t client, const cap_reconnect_t& icr, Session *session);
   void clear_client_caps_after_export();
   void export_client_caps(std::map<client_t,Capability::Export>& cl);
 

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 101b3820db6e4db8063fea71a4c74c98d1d79631..a8523f0b4c06754767a98a28db7205d82e4a7fd0 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -3937,17 +3937,13 @@ void MDCache::rejoin_send_rejoins()
 
   if (mds->is_rejoin()) {
     map<client_t, set<mds_rank_t> > client_exports;
-    for (map<inodeno_t,map<client_t,ceph_mds_cap_reconnect> >::iterator p = cap_exports.begin();
-         p != cap_exports.end();
-        ++p) {
+    for (auto p = cap_exports.begin(); p != cap_exports.end(); ++p) {
       assert(cap_export_targets.count(p->first));
       mds_rank_t target = cap_export_targets[p->first];
       if (rejoins.count(target) == 0)
        continue;
       rejoins[target]->cap_exports[p->first] = p->second;
-      for (map<client_t,ceph_mds_cap_reconnect>::iterator q = p->second.begin();
-          q != p->second.end();
-          ++q)
+      for (auto q = p->second.begin(); q != p->second.end(); ++q)
        client_exports[q->first].insert(target);
     }
     for (map<client_t, set<mds_rank_t> >::iterator p = client_exports.begin();
@@ -4274,14 +4270,10 @@ void MDCache::handle_cache_rejoin_weak(MMDSCacheRejoin *weak)
     map<inodeno_t,map<client_t,Capability::Import> > imported_caps;
 
     // check cap exports
-    for (map<inodeno_t,map<client_t,ceph_mds_cap_reconnect> >::iterator p = weak->cap_exports.begin();
-        p != weak->cap_exports.end();
-        ++p) {
+    for (auto p = weak->cap_exports.begin(); p != weak->cap_exports.end(); ++p) {
       CInode *in = get_inode(p->first);
       assert(!in || in->is_auth());
-      for (map<client_t,ceph_mds_cap_reconnect>::iterator q = p->second.begin();
-          q != p->second.end();
-          ++q) {
+      for (auto q = p->second.begin(); q != p->second.end(); ++q) {
        dout(10) << " claiming cap import " << p->first << " client." << q->first << " on " << *in << dendl;
        Capability *cap = rejoin_import_cap(in, q->first, q->second, from);
        Capability::Import& im = imported_caps[p->first][q->first];
@@ -4303,15 +4295,11 @@ void MDCache::handle_cache_rejoin_weak(MMDSCacheRejoin *weak)
     // check cap exports.
     rejoin_client_map.insert(weak->client_map.begin(), weak->client_map.end());
 
-    for (map<inodeno_t,map<client_t,ceph_mds_cap_reconnect> >::iterator p = weak->cap_exports.begin();
-        p != weak->cap_exports.end();
-        ++p) {
+    for (auto p = weak->cap_exports.begin(); p != weak->cap_exports.end(); ++p) {
       CInode *in = get_inode(p->first);
       assert(in && in->is_auth());
       // note
-      for (map<client_t,ceph_mds_cap_reconnect>::iterator q = p->second.begin();
-          q != p->second.end();
-          ++q) {
+      for (auto q = p->second.begin(); q != p->second.end(); ++q) {
        dout(10) << " claiming cap import " << p->first << " client." << q->first << dendl;
        cap_imports[p->first][q->first][from] = q->second;
       }
@@ -5066,7 +5054,7 @@ void MDCache::handle_cache_rejoin_ack(MMDSCacheRejoin *ack)
 
       // mark client caps stale.
       MClientCaps *m = new MClientCaps(CEPH_CAP_OP_EXPORT, p->first, 0,
-                                      cap_exports[p->first][q->first].cap_id, 0,
+                                      cap_exports[p->first][q->first].capinfo.cap_id, 0,
                                        mds->get_osd_epoch_barrier());
       m->set_cap_peer(q->second.cap_id, q->second.issue_seq, q->second.mseq, from, 0);
       mds->send_message_client_counted(m, session);
@@ -5206,12 +5194,9 @@ void MDCache::rejoin_open_ino_finish(inodeno_t ino, int ret)
   } else if (ret == mds->get_nodeid()) {
     assert(get_inode(ino));
   } else {
-    map<inodeno_t,map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> > >::iterator p;
-    p = cap_imports.find(ino);
+    auto p = cap_imports.find(ino);
     assert(p != cap_imports.end());
-    for (map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> >::iterator q = p->second.begin();
-       q != p->second.end();
-       ++q) {
+    for (auto q = p->second.begin(); q != p->second.end(); ++q) {
       assert(q->second.count(MDS_RANK_NONE));
       assert(q->second.size() == 1);
       rejoin_export_caps(p->first, q->first, q->second[MDS_RANK_NONE], ret);
@@ -5256,9 +5241,7 @@ bool MDCache::process_imported_caps()
 {
   dout(10) << "process_imported_caps" << dendl;
 
-  for (map<inodeno_t,map<client_t, map<mds_rank_t,ceph_mds_cap_reconnect> > >::iterator p = cap_imports.begin();
-       p != cap_imports.end();
-       ++p) {
+  for (auto p = cap_imports.begin(); p != cap_imports.end(); ++p) {
     CInode *in = get_inode(p->first);
     if (in) {
       assert(in->is_auth());
@@ -5325,8 +5308,7 @@ bool MDCache::process_imported_caps()
 
     // process cap imports
     //  ino -> client -> frommds -> capex
-    for (map<inodeno_t,map<client_t, map<mds_rank_t,ceph_mds_cap_reconnect> > >::iterator p = cap_imports.begin();
-        p != cap_imports.end(); ) {
+    for (auto p = cap_imports.begin(); p != cap_imports.end(); ) {
       CInode *in = get_inode(p->first);
       if (!in) {
        dout(10) << " still missing ino " << p->first
@@ -5335,20 +5317,16 @@ bool MDCache::process_imported_caps()
        continue;
       }
       assert(in->is_auth());
-      for (map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> >::iterator q = p->second.begin();
-          q != p->second.end();
-          ++q) {
+      for (auto q = p->second.begin(); q != p->second.end(); ++q) {
        Session *session = mds->sessionmap.get_session(entity_name_t::CLIENT(q->first.v));
        assert(session);
-       for (map<mds_rank_t,ceph_mds_cap_reconnect>::iterator r = q->second.begin();
-            r != q->second.end();
-            ++r) {
-         add_reconnected_cap(in, q->first, inodeno_t(r->second.snaprealm));
+       for (auto r = q->second.begin(); r != q->second.end(); ++r) {
+         add_reconnected_cap(in, q->first, inodeno_t(r->second.capinfo.snaprealm));
          Capability *cap = in->reconnect_cap(q->first, r->second, session);
          if (r->first >= 0) {
            if (cap->get_last_seq() == 0) // don't increase mseq if cap already exists
              cap->inc_mseq();
-           do_cap_import(session, in, cap, r->second.cap_id, 0, 0, r->first, 0);
+           do_cap_import(session, in, cap, r->second.capinfo.cap_id, 0, 0, r->first, 0);
 
            Capability::Import& im = rejoin_imported_caps[r->first][p->first][q->first];
            im.cap_id = cap->get_cap_id();
@@ -5522,7 +5500,7 @@ void MDCache::clean_open_file_lists()
 
 
 
-Capability* MDCache::rejoin_import_cap(CInode *in, client_t client, ceph_mds_cap_reconnect& icr, mds_rank_t frommds)
+Capability* MDCache::rejoin_import_cap(CInode *in, client_t client, const cap_reconnect_t& icr, mds_rank_t frommds)
 {
   dout(10) << "rejoin_import_cap for client." << client << " from mds." << frommds
           << " on " << *in << dendl;
@@ -5534,7 +5512,7 @@ Capability* MDCache::rejoin_import_cap(CInode *in, client_t client, ceph_mds_cap
   if (frommds >= 0) {
     if (cap->get_last_seq() == 0) // don't increase mseq if cap already exists
       cap->inc_mseq();
-    do_cap_import(session, in, cap, icr.cap_id, 0, 0, frommds, 0);
+    do_cap_import(session, in, cap, icr.capinfo.cap_id, 0, 0, frommds, 0);
   }
 
   return cap;
@@ -5546,13 +5524,9 @@ void MDCache::export_remaining_imported_caps()
 
   stringstream warn_str;
 
-  for (map<inodeno_t,map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> > >::iterator p = cap_imports.begin();
-       p != cap_imports.end();
-       ++p) {
+  for (auto p = cap_imports.begin(); p != cap_imports.end(); ++p) {
     warn_str << " ino " << p->first << "\n";
-    for (map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> >::iterator q = p->second.begin();
-       q != p->second.end();
-       ++q) {
+    for (auto q = p->second.begin(); q != p->second.end(); ++q) {
       Session *session = mds->sessionmap.get_session(entity_name_t::CLIENT(q->first.v));
       if (session) {
        // mark client caps stale.
@@ -5581,12 +5555,12 @@ void MDCache::export_remaining_imported_caps()
 void MDCache::try_reconnect_cap(CInode *in, Session *session)
 {
   client_t client = session->info.get_client();
-  ceph_mds_cap_reconnect *rc = get_replay_cap_reconnect(in->ino(), client);
+  const cap_reconnect_t *rc = get_replay_cap_reconnect(in->ino(), client);
   if (rc) {
     in->reconnect_cap(client, *rc, session);
     dout(10) << "try_reconnect_cap client." << client
-            << " reconnect wanted " << ccap_string(rc->wanted)
-            << " issue " << ccap_string(rc->issued)
+            << " reconnect wanted " << ccap_string(rc->capinfo.wanted)
+            << " issue " << ccap_string(rc->capinfo.issued)
             << " on " << *in << dendl;
     remove_replay_cap_reconnect(in->ino(), client);
 

diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index 5aadc13981ee34b7d538735c95b68f9f1b6ab27f..d60e8f35c51921d89346400bc382110bca3f778f 100644 (file)
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -490,10 +490,10 @@ protected:
   map<inodeno_t,pair<mds_rank_t,map<client_t,Capability::Export> > > rejoin_slave_exports;
   map<client_t,entity_inst_t> rejoin_client_map;
 
-  map<inodeno_t,map<client_t,ceph_mds_cap_reconnect> > cap_exports; // ino -> client -> capex
+  map<inodeno_t,map<client_t,cap_reconnect_t> > cap_exports; // ino -> client -> capex
   map<inodeno_t,mds_rank_t> cap_export_targets; // ino -> auth mds
 
-  map<inodeno_t,map<client_t,map<mds_rank_t,ceph_mds_cap_reconnect> > > cap_imports;  // ino -> client -> frommds -> capex
+  map<inodeno_t,map<client_t,map<mds_rank_t,cap_reconnect_t> > > cap_imports;  // ino -> client -> frommds -> capex
   map<inodeno_t,int> cap_imports_dirty;
   set<inodeno_t> cap_imports_missing;
   map<inodeno_t, list<MDSInternalContextBase*> > cap_reconnect_waiters;
@@ -530,16 +530,16 @@ public:
   void rejoin_start(MDSInternalContext *rejoin_done_);
   void rejoin_gather_finish();
   void rejoin_send_rejoins();
-  void rejoin_export_caps(inodeno_t ino, client_t client, ceph_mds_cap_reconnect& capinfo,
+  void rejoin_export_caps(inodeno_t ino, client_t client, const cap_reconnect_t& icr,
                          int target=-1) {
-    cap_exports[ino][client] = capinfo;
+    cap_exports[ino][client] = icr;
     cap_export_targets[ino] = target;
   }
-  void rejoin_recovered_caps(inodeno_t ino, client_t client, cap_reconnect_t& icr, 
+  void rejoin_recovered_caps(inodeno_t ino, client_t client, const cap_reconnect_t& icr, 
                             mds_rank_t frommds=MDS_RANK_NONE) {
-    cap_imports[ino][client][frommds] = icr.capinfo;
+    cap_imports[ino][client][frommds] = icr;
   }
-  ceph_mds_cap_reconnect *get_replay_cap_reconnect(inodeno_t ino, client_t client) {
+  const cap_reconnect_t *get_replay_cap_reconnect(inodeno_t ino, client_t client) {
     if (cap_imports.count(ino) &&
        cap_imports[ino].count(client) &&
        cap_imports[ino][client].count(MDS_RANK_NONE)) {
@@ -581,7 +581,7 @@ public:
                           map<client_t,MClientSnap*>& splits);
   void do_realm_invalidate_and_update_notify(CInode *in, int snapop, bool nosend=false);
   void send_snaps(map<client_t,MClientSnap*>& splits);
-  Capability* rejoin_import_cap(CInode *in, client_t client, ceph_mds_cap_reconnect& icr, mds_rank_t frommds);
+  Capability* rejoin_import_cap(CInode *in, client_t client, const cap_reconnect_t& icr, mds_rank_t frommds);
   void finish_snaprealm_reconnect(client_t client, SnapRealm *realm, snapid_t seq);
   void try_reconnect_cap(CInode *in, Session *session);
   void export_remaining_imported_caps();

diff --git a/src/mds/MDSDaemon.h b/src/mds/MDSDaemon.h
index 4d6296c5df2abed87762cf88b8f706b3b5b07aa7..b23e24a042d2f32716908d0318f35b8b50471988 100644 (file)
--- a/src/mds/MDSDaemon.h
+++ b/src/mds/MDSDaemon.h
@@ -39,7 +39,7 @@
 #include "Beacon.h"
 
 
-#define CEPH_MDS_PROTOCOL    27 /* cluster internal */
+#define CEPH_MDS_PROTOCOL    28 /* cluster internal */
 
 class filepath;
 

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index 313744718b0b18015868fa9c283ea476c5a256c8..0246833d518aa9f16e0e45fca06171fb794d62fe 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -809,7 +809,7 @@ void Server::handle_client_reconnect(MClientReconnect *m)
       // we recovered it, and it's ours.  take note.
       dout(15) << "open cap realm " << inodeno_t(p->second.capinfo.snaprealm)
               << " on " << *in << dendl;
-      in->reconnect_cap(from, p->second.capinfo, session);
+      in->reconnect_cap(from, p->second, session);
       mdcache->add_reconnected_cap(in, from, inodeno_t(p->second.capinfo.snaprealm));
       recover_filelocks(in, p->second.flockbl, m->get_orig_source().num());
       continue;
@@ -819,11 +819,13 @@ void Server::handle_client_reconnect(MClientReconnect *m)
       // not mine.
       dout(10) << "non-auth " << *in << ", will pass off to authority" << dendl;
       // add to cap export list.
-      mdcache->rejoin_export_caps(p->first, from, p->second.capinfo,
+      p->second.path.clear(); // we don't need path
+      mdcache->rejoin_export_caps(p->first, from, p->second,
                                  in->authority().first);
     } else {
       // don't know if the inode is mine
       dout(10) << "missing ino " << p->first << ", will load later" << dendl;
+      p->second.path.clear(); // we don't need path
       mdcache->rejoin_recovered_caps(p->first, from, p->second, MDS_RANK_NONE);
     }
   }

diff --git a/src/messages/MMDSCacheRejoin.h b/src/messages/MMDSCacheRejoin.h
index 111a24460176f6d0cb46eb1ddeb50192245a4c33..4bb47eb284c5475788079da1409d98dca1040ef0 100644 (file)
--- a/src/messages/MMDSCacheRejoin.h
+++ b/src/messages/MMDSCacheRejoin.h
@@ -21,6 +21,7 @@
 
 #include "mds/CInode.h"
 #include "mds/CDir.h"
+#include "mds/mdstypes.h"
 
 // sent from replica to auth
 
@@ -163,7 +164,7 @@ class MMDSCacheRejoin : public Message {
   map<vinodeno_t, inode_strong> strong_inodes;
 
   // open
-  map<inodeno_t,map<client_t, ceph_mds_cap_reconnect> > cap_exports;
+  map<inodeno_t,map<client_t, cap_reconnect_t> > cap_exports;
   map<client_t, entity_inst_t> client_map;
   bufferlist imported_caps;