mds: start file recovery after sending rejoin ack

The rejoin ack intializes replica lock states correctly; we can't send any
lock messages before that.  This fixes both the check max size call (which
sends lock messages taking the wrlock) and the file_recover() call
(which does the same).

Instead, we make two lists, files to recover and those to fix up.  The lock
states for both are set to PRE_SCAN (LOCK on replica).  After the rejoin
acks go out, we either check_inode_max_size or file_recover.

If file_recover someday grows another caller, this may need something a bit
more sophisticated.

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index d3f33762df39e7102c3e20f6325e9fe281bc6934..f3dfcb0b3361f120a317e8e6779a3faf82a359ce 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -3401,17 +3401,18 @@ void Locker::file_recover(ScatterLock *lock)
   assert(in->is_auth());
   assert(lock->is_stable());
 
-  int oldstate = lock->get_state();
-  lock->set_state(LOCK_PRE_SCAN);
+  assert(lock->get_state() == LOCK_PRE_SCAN); // only called from MDCache::start_files_to_recover()
 
   int gather = 0;
   
-  if (in->is_replicated() &&
+  /*
+  if (in->is_replicated()
       lock->get_sm()->states[oldstate].replica_state != LOCK_LOCK) {
     send_lock_message(lock, LOCK_AC_LOCK);
     lock->init_gather();
     gather++;
   }
+  */
   if (in->issued_caps_need_gather(lock)) {
     issue_caps(in);
     gather++;

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 26401a594f663015fced20b2426df6081d8660ae..01171b624ae01a363ec3b3f511fc23dbe4df0f29 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -3889,8 +3889,11 @@ void MDCache::rejoin_gather_finish()
   
   process_imported_caps();
   process_reconnected_caps();
-  identify_files_to_recover();
+
+  vector<CInode*> recover_q, check_q;
+  identify_files_to_recover(recover_q, check_q);
   rejoin_send_acks();
+  start_files_to_recover(recover_q, check_q);
   
   // signal completion of fetches, rejoin_gather_finish, etc.
   assert(rejoin_ack_gather.count(mds->whoami));
@@ -4444,10 +4447,9 @@ void MDCache::unqueue_file_recover(CInode *in)
  * called after recovery to recover file sizes for previously opened (for write)
  * files.  that is, those where max_size > size.
  */
-void MDCache::identify_files_to_recover()
+void MDCache::identify_files_to_recover(vector<CInode*>& recover_q, vector<CInode*>& check_q)
 {
   dout(10) << "identify_files_to_recover" << dendl;
-  vector<CInode*> q;  // put inodes in list first: queue_file_discover modifies inode_map
   for (hash_map<vinodeno_t,CInode*>::iterator p = inode_map.begin();
        p != inode_map.end();
        ++p) {
@@ -4467,13 +4469,26 @@ void MDCache::identify_files_to_recover()
       }
     }
 
-    if (recover) 
-      q.push_back(in);
-    else
-      mds->locker->check_inode_max_size(in);
+    if (recover) {
+      in->filelock.set_state(LOCK_PRE_SCAN);
+      recover_q.push_back(in);
+    } else {
+      check_q.push_back(in);
+    }
+  }
+}
+
+void MDCache::start_files_to_recover(vector<CInode*>& recover_q, vector<CInode*>& check_q)
+{
+  for (vector<CInode*>::iterator p = check_q.begin(); p != check_q.end(); p++) {
+    CInode *in = *p;
+    in->filelock.set_state(LOCK_LOCK);
+    mds->locker->check_inode_max_size(in);
+  }
+  for (vector<CInode*>::iterator p = recover_q.begin(); p != recover_q.end(); p++) {
+    CInode *in = *p;
+    mds->locker->file_recover(&in->filelock);
   }
-  for (vector<CInode*>::iterator p = q.begin(); p != q.end(); p++)
-    mds->locker->file_recover(&(*p)->filelock);
 }
 
 struct C_MDC_Recover : public Context {

diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index 755c7116c9204863e11631be26a277955b85af4a..8deab3a870862af2013853869f74da5fbc3c9dc6 100644 (file)
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -785,7 +785,9 @@ public:
   void unqueue_file_recover(CInode *in);
   void _queued_file_recover_cow(CInode *in, Mutation *mut);
   void _queue_file_recover(CInode *in);
-  void identify_files_to_recover();
+  void identify_files_to_recover(vector<CInode*>& recover_q, vector<CInode*>& check_q);
+  void start_files_to_recover(vector<CInode*>& recover_q, vector<CInode*>& check_q);
+
   void do_file_recover();
   void _recovered(CInode *in, int r, __u64 size, utime_t mtime);