mds: rename gather lock states

Easier to read: LOCK_oldstate_newstate, "oldstate->newstate"

diff --git a/src/mds/FileLock.h b/src/mds/FileLock.h
index 100ecec1069006d04b57fadd3947846e13493b4d..d9987c9eab12d0281ebc60a98e036e2f29819659 100644 (file)
--- a/src/mds/FileLock.h
+++ b/src/mds/FileLock.h
@@ -27,42 +27,42 @@ using namespace std;
 //  C = cache reads, R = read, W = write, A = append, B = buffer writes, L = lazyio
 
 //                               -----auth--------   ---replica-------
-#define LOCK_SYNC_    1  // AR   R . / C R . . . L   R . / C R . . . L   stat()
-#define LOCK_GSYNCL  -12 // A    . . / C r . . . L *                     loner -> sync
-#define LOCK_GSYNCM  -13 // A    . . / . R . . . L
+#define LOCK_SYNC_        1  // AR   R . / C R . . . L   R . / C R . . . L   stat()
+#define LOCK_LONER_SYNC  -12 // A    . . / C r . . . L *                     loner -> sync
+#define LOCK_MIXED_SYNC  -13 // A    . . / . R . . . L
 
-#define LOCK_LOCK_    2  // AR   R W / C . . . B .   . . / C . . . . .   truncate()
-#define LOCK_GLOCKR_ -3  // AR   R . / C . . . . .   . . / C . . . . .
-#define LOCK_GLOCKL  -4  // A    . . / C . . . B .                       loner -> lock
-#define LOCK_GLOCKM  -5  // A    . . / . . . . . .
+#define LOCK_LOCK_        2  // AR   R W / C . . . B .   . . / C . . . . .   truncate()
+#define LOCK_SYNC_LOCK_  -3  // AR   R . / C . . . . .   . . / C . . . . .
+#define LOCK_LONER_LOCK  -4  // A    . . / C . . . B .                       loner -> lock
+#define LOCK_MIXED_LOCK  -5  // A    . . / . . . . . .
 
-#define LOCK_MIXED    6  // AR   . . / . R W A . L   . . / . R . . . L
-#define LOCK_GMIXEDR -7  // AR   R . / . R . . . L   . . / . R . . . L 
-#define LOCK_GMIXEDL -8  // A    . . / . r w a . L *                     loner -> mixed
+#define LOCK_MIXED        6  // AR   . . / . R W A . L   . . / . R . . . L
+#define LOCK_SYNC_MIXED  -7  // AR   R . / . R . . . L   . . / . R . . . L 
+#define LOCK_LONER_MIXED -8  // A    . . / . r w a . L *                     loner -> mixed
 
-#define LOCK_LONER    9  // A    . . / c r w a b L *      (lock)      
-#define LOCK_GLONERR -10 // A    . . / . R . . . L 
-#define LOCK_GLONERM -11 // A    . . / . R W A . L 
-#define LOCK_GLONERL -15 // A    . . / c . . . b . *
+#define LOCK_LONER        9  // A    . . / c r w a b L *      (lock)      
+#define LOCK_SYNC_LONER  -10 // A    . . / . R . . . L 
+#define LOCK_MIXED_LONER -11 // A    . . / . R W A . L 
+#define LOCK_LOCK_LONER  -15 // A    . . / c . . . b . *
 
 //                                                 * <- varies if client is loner vs non-loner.
  
 inline const char *get_filelock_state_name(int n) {
   switch (n) {
   case LOCK_SYNC: return "sync";
-  case LOCK_GSYNCL: return "gsyncl";
-  case LOCK_GSYNCM: return "gsyncm";
+  case LOCK_LONER_SYNC: return "loner->sync";
+  case LOCK_MIXED_SYNC: return "mixed->sync";
   case LOCK_LOCK: return "lock";
-  case LOCK_GLOCKR: return "glockr";
-  case LOCK_GLOCKL: return "glockl";
-  case LOCK_GLOCKM: return "glockm";
+  case LOCK_SYNC_LOCK: return "sync->lock";
+  case LOCK_LONER_LOCK: return "loner->lock";
+  case LOCK_MIXED_LOCK: return "mixed->lock";
   case LOCK_MIXED: return "mixed";
-  case LOCK_GMIXEDR: return "gmixedr";
-  case LOCK_GMIXEDL: return "gmixedl";
+  case LOCK_SYNC_MIXED: return "sync->mixed";
+  case LOCK_LONER_MIXED: return "loner->mixed";
   case LOCK_LONER: return "loner";
-  case LOCK_GLONERR: return "glonerr";
-  case LOCK_GLONERM: return "glonerm";
-  case LOCK_GLONERL: return "glonerl";
+  case LOCK_SYNC_LONER: return "sync->loner";
+  case LOCK_MIXED_LONER: return "mixed->loner";
+  case LOCK_LOCK_LONER: return "lock->loner";
   default: assert(0); return 0;
   }
 }
@@ -102,25 +102,25 @@ class FileLock : public SimpleLock {
   int get_replica_state() const {
     switch (state) {
     case LOCK_LOCK:
-    case LOCK_GLOCKM:
-    case LOCK_GLOCKL:
-    case LOCK_GLOCKR: 
+    case LOCK_MIXED_LOCK:
+    case LOCK_LONER_LOCK:
+    case LOCK_SYNC_LOCK: 
     case LOCK_LONER:
-    case LOCK_GLONERR:
-    case LOCK_GLONERM:
-    case LOCK_GLONERL:
+    case LOCK_SYNC_LONER:
+    case LOCK_MIXED_LONER:
+    case LOCK_LOCK_LONER:
       return LOCK_LOCK;
     case LOCK_MIXED:
-    case LOCK_GMIXEDR:
+    case LOCK_SYNC_MIXED:
       return LOCK_MIXED;
     case LOCK_SYNC:
       return LOCK_SYNC;
 
       // after gather auth will bc LOCK_AC_MIXED or whatever
-    case LOCK_GSYNCM:
+    case LOCK_MIXED_SYNC:
       return LOCK_MIXED;
-    case LOCK_GSYNCL:
-    case LOCK_GMIXEDL:     // ** LOCK isn't exact right state, but works.
+    case LOCK_LONER_SYNC:
+    case LOCK_LONER_MIXED:     // ** LOCK isn't exact right state, but works.
       return LOCK_LOCK;
 
     default: 
@@ -140,21 +140,21 @@ class FileLock : public SimpleLock {
     if (state == LOCK_LOCK && !xlock_by) return true;
     return 
       (state == LOCK_SYNC) ||
-      (state == LOCK_GMIXEDR) || 
-      (state == LOCK_GLOCKR);
+      (state == LOCK_SYNC_MIXED) || 
+      (state == LOCK_SYNC_LOCK);
   }
   bool can_rdlock_soon() {
     if (parent->is_auth())
       return
-       (state == LOCK_GLOCKL) ||
+       (state == LOCK_LONER_LOCK) ||
        (state == LOCK_LOCK && xlock_by);
     else
       return false;
   }
   bool can_xlock_soon() {
     if (parent->is_auth())
-      return (state == LOCK_GLOCKR) || (state == LOCK_GLOCKL)
-        || (state == LOCK_GLOCKM);
+      return (state == LOCK_SYNC_LOCK) || (state == LOCK_LONER_LOCK)
+        || (state == LOCK_MIXED_LOCK);
     else
       return false;
   }
@@ -163,10 +163,10 @@ class FileLock : public SimpleLock {
   bool can_wrlock() {
     return 
       parent->is_auth() && 
-      (state == LOCK_LOCK || state == LOCK_GLOCKM || state == LOCK_GLOCKL ||
-       state == LOCK_MIXED || state == LOCK_GMIXEDL ||
-       state == LOCK_LONER || state == LOCK_GLONERM || state == LOCK_GLONERL ||
-       state == LOCK_GSYNCM || state == LOCK_GSYNCL);
+      (state == LOCK_LOCK || state == LOCK_MIXED_LOCK || state == LOCK_LONER_LOCK ||
+       state == LOCK_MIXED || state == LOCK_LONER_MIXED ||
+       state == LOCK_LONER || state == LOCK_MIXED_LONER || state == LOCK_LOCK_LONER ||
+       state == LOCK_MIXED_SYNC || state == LOCK_LONER_SYNC);
   }
   void get_wrlock(bool force) {
     assert(force || can_wrlock());
@@ -197,35 +197,35 @@ class FileLock : public SimpleLock {
       switch (state) {
       case LOCK_SYNC:
         return CEPH_CAP_PIN | CEPH_CAP_RDCACHE | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
-      case LOCK_GLOCKR:
+      case LOCK_SYNC_LOCK:
          return CEPH_CAP_PIN | CEPH_CAP_RDCACHE;
       case LOCK_LOCK:
-      case LOCK_GLOCKL:
+      case LOCK_LONER_LOCK:
         return CEPH_CAP_PIN | CEPH_CAP_RDCACHE | CEPH_CAP_WRBUFFER;
 
-      case LOCK_GLOCKM:
+      case LOCK_MIXED_LOCK:
         return CEPH_CAP_PIN;
 
       case LOCK_MIXED:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_WR | CEPH_CAP_WREXTEND | CEPH_CAP_LAZYIO;
-      case LOCK_GMIXEDR:
+      case LOCK_SYNC_MIXED:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
-      case LOCK_GMIXEDL:
+      case LOCK_LONER_MIXED:
         return CEPH_CAP_PIN | (loner ? (CEPH_CAP_RD | CEPH_CAP_WR | CEPH_CAP_WREXTEND) : 0);
 
       case LOCK_LONER:  // single client writer, of course.
         return CEPH_CAP_PIN | CEPH_CAP_LAZYIO |
          ( loner ? (CEPH_CAP_RDCACHE | CEPH_CAP_RD | CEPH_CAP_WR | CEPH_CAP_WREXTEND | CEPH_CAP_WRBUFFER | CEPH_CAP_EXCL) : 0 );
-      case LOCK_GLONERR:
+      case LOCK_SYNC_LONER:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
-      case LOCK_GLONERM:
+      case LOCK_MIXED_LONER:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_WR | CEPH_CAP_WREXTEND | CEPH_CAP_LAZYIO;
-      case LOCK_GLONERL:
+      case LOCK_LOCK_LONER:
         return CEPH_CAP_PIN | (loner ? (CEPH_CAP_RDCACHE | CEPH_CAP_WRBUFFER) : 0);
 
-      case LOCK_GSYNCL:
+      case LOCK_LONER_SYNC:
         return CEPH_CAP_PIN | CEPH_CAP_RDCACHE | (loner ? CEPH_CAP_RD:0) | CEPH_CAP_LAZYIO;
-      case LOCK_GSYNCM:
+      case LOCK_MIXED_SYNC:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
       }
     else
@@ -233,9 +233,9 @@ class FileLock : public SimpleLock {
       case LOCK_SYNC:
         return CEPH_CAP_PIN | CEPH_CAP_RDCACHE | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
       case LOCK_LOCK:
-      case LOCK_GLOCKR:
+      case LOCK_SYNC_LOCK:
         return CEPH_CAP_PIN | CEPH_CAP_RDCACHE;
-      case LOCK_GMIXEDR:
+      case LOCK_SYNC_MIXED:
       case LOCK_MIXED:
         return CEPH_CAP_PIN | CEPH_CAP_RD | CEPH_CAP_LAZYIO;
       }
@@ -245,11 +245,11 @@ class FileLock : public SimpleLock {
 
   // true if we are in a "loner" mode that distinguishes between a loner and everyone else
   bool is_loner_mode() {
-    return state == LOCK_GSYNCL ||
-      state == LOCK_GLOCKL ||
-      state == LOCK_GMIXEDL ||
+    return state == LOCK_LONER_SYNC ||
+      state == LOCK_LONER_LOCK ||
+      state == LOCK_LONER_MIXED ||
       state == LOCK_LONER ||
-      state == LOCK_GLONERL;
+      state == LOCK_LOCK_LONER;
   }
 
 

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index ed933379bf8d18ba4e30a938a07678391f9c80da..dc599b382578ba0f8bea7332b5cffa3dbeb437bd 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -1583,7 +1583,7 @@ void Locker::handle_simple_lock(SimpleLock *lock, MLock *m)
     
   case LOCK_AC_LOCK:
     assert(lock->get_state() == LOCK_SYNC);
-    //||           lock->get_state() == LOCK_GLOCKR);
+    //||           lock->get_state() == LOCK_SYNC_LOCK);
     
     // wait for readers to finish?
     if (lock->is_rdlocked() ||
@@ -1591,7 +1591,7 @@ void Locker::handle_simple_lock(SimpleLock *lock, MLock *m)
       dout(7) << "handle_simple_lock has reader|leases, waiting before ack on " << *lock
              << " on " << *lock->get_parent() << dendl;
       revoke_client_leases(lock);
-      lock->set_state(LOCK_GLOCKR);
+      lock->set_state(LOCK_SYNC_LOCK);
     } else {
       // update lock and reply
       lock->set_state(LOCK_LOCK);
@@ -1602,7 +1602,7 @@ void Locker::handle_simple_lock(SimpleLock *lock, MLock *m)
 
     // -- auth --
   case LOCK_AC_LOCKACK:
-    assert(lock->get_state() == LOCK_GLOCKR);
+    assert(lock->get_state() == LOCK_SYNC_LOCK);
     assert(lock->is_gathering(from));
     lock->remove_gather(from);
     
@@ -1666,7 +1666,7 @@ void Locker::simple_eval_gather(SimpleLock *lock)
   dout(10) << "simple_eval_gather " << *lock << " on " << *lock->get_parent() << dendl;
 
   // finished gathering?
-  if (lock->get_state() == LOCK_GLOCKR &&
+  if (lock->get_state() == LOCK_SYNC_LOCK &&
       !lock->is_gathering() &&
       lock->get_num_client_lease() == 0 &&
       !lock->is_rdlocked()) {
@@ -1763,7 +1763,7 @@ void Locker::simple_lock(SimpleLock *lock)
     revoke_client_leases(lock);
     
     // change lock
-    lock->set_state(LOCK_GLOCKR);
+    lock->set_state(LOCK_SYNC_LOCK);
     lock->init_gather();
     lock->get_parent()->auth_pin(lock);
   } else {
@@ -2216,7 +2216,7 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
   if (!lock->get_parent()->is_auth()) {
     // REPLICA
 
-    if (lock->get_state() == LOCK_GLOCKC &&
+    if (lock->get_state() == LOCK_SCATTER_LOCK &&
        !lock->is_wrlocked()) {
       dout(10) << "scatter_eval no wrlocks, acking lock" << dendl;
       int auth = lock->get_parent()->authority().first;
@@ -2228,7 +2228,7 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
       lock->set_state(LOCK_LOCK);
     }
 
-    if (lock->get_state() == LOCK_GLOCKS &&
+    if (lock->get_state() == LOCK_SYNC_LOCK &&
        !lock->is_rdlocked() &&
        lock->get_num_client_lease() == 0) {
       dout(10) << "scatter_eval no rdlocks|leases, acking lock" << dendl;
@@ -2245,8 +2245,8 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
     // AUTH
 
     // glocks|glockt -> lock?
-    if ((lock->get_state() == LOCK_GLOCKS || 
-        lock->get_state() == LOCK_GLOCKT) &&
+    if ((lock->get_state() == LOCK_SYNC_LOCK || 
+        lock->get_state() == LOCK_TEMPSYNC_LOCK) &&
        !lock->is_gathering() &&
        lock->get_num_client_lease() == 0 &&
        !lock->is_rdlocked()) {
@@ -2262,7 +2262,7 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
     }
     
     // glockc -> lock?
-    else if (lock->get_state() == LOCK_GLOCKC &&
+    else if (lock->get_state() == LOCK_SCATTER_LOCK &&
             !lock->is_gathering() &&
             !lock->is_wrlocked()) {
       if (lock->is_updated()) {
@@ -2277,7 +2277,7 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
     }
 
     // gSyncL -> sync?
-    else if (lock->get_state() == LOCK_GSYNCL &&
+    else if (lock->get_state() == LOCK_LONER_SYNC &&
             !lock->is_wrlocked()) {
       dout(7) << "scatter_eval finished sync un-wrlock on " << *lock
              << " on " << *lock->get_parent() << dendl;
@@ -2293,8 +2293,8 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
     }
 
     // gscattert|gscatters -> scatter?
-    else if ((lock->get_state() == LOCK_GSCATTERT ||
-             lock->get_state() == LOCK_GSCATTERS) &&
+    else if ((lock->get_state() == LOCK_TEMPSYNC_SCATTER ||
+             lock->get_state() == LOCK_SYNC_SCATTER) &&
             !lock->is_gathering() &&
             lock->get_num_client_lease() == 0 &&
             !lock->is_rdlocked()) {
@@ -2312,8 +2312,8 @@ void Locker::scatter_eval_gather(ScatterLock *lock)
     }
 
     // gTempsyncC|gTempsyncL -> tempsync
-    else if ((lock->get_state() == LOCK_GTEMPSYNCC ||
-             lock->get_state() == LOCK_GTEMPSYNCL) &&
+    else if ((lock->get_state() == LOCK_SCATTER_TEMPSYNC ||
+             lock->get_state() == LOCK_LOCK_TEMPSYNC) &&
             !lock->is_gathering() &&
             !lock->is_wrlocked()) {
       if (lock->is_updated()) {
@@ -2536,7 +2536,7 @@ void Locker::scatter_sync(ScatterLock *lock)
 
   case LOCK_LOCK:
     if (lock->is_wrlocked() || lock->is_xlocked()) {
-      lock->set_state(LOCK_GSYNCL);
+      lock->set_state(LOCK_LONER_SYNC);
       lock->get_parent()->auth_pin(lock);
       return;
     }
@@ -2547,7 +2547,7 @@ void Locker::scatter_sync(ScatterLock *lock)
        !lock->is_wrlocked())
       break; // do it now
 
-    lock->set_state(LOCK_GLOCKC);
+    lock->set_state(LOCK_SCATTER_LOCK);
     lock->get_parent()->auth_pin(lock);
 
     if (lock->get_parent()->is_replicated()) {
@@ -2620,8 +2620,8 @@ void Locker::scatter_scatter(ScatterLock *lock)
     return;  // do nothing.
 
   switch (lock->get_state()) {
-  case LOCK_SYNC: lock->set_state(LOCK_GSCATTERS); break;
-  case LOCK_TEMPSYNC: lock->set_state(LOCK_GSCATTERT); break;
+  case LOCK_SYNC: lock->set_state(LOCK_SYNC_SCATTER); break;
+  case LOCK_TEMPSYNC: lock->set_state(LOCK_TEMPSYNC_SCATTER); break;
   default: assert(0);
   }
 
@@ -2673,9 +2673,9 @@ void Locker::scatter_lock(ScatterLock *lock)
     return;
 
   switch (lock->get_state()) {
-  case LOCK_SYNC: lock->set_state(LOCK_GLOCKS); break;
-  case LOCK_SCATTER: lock->set_state(LOCK_GLOCKC); break;
-  case LOCK_TEMPSYNC: lock->set_state(LOCK_GLOCKT); break;
+  case LOCK_SYNC: lock->set_state(LOCK_SYNC_LOCK); break;
+  case LOCK_SCATTER: lock->set_state(LOCK_SCATTER_LOCK); break;
+  case LOCK_TEMPSYNC: lock->set_state(LOCK_TEMPSYNC_LOCK); break;
   default: assert(0);
   }
 
@@ -2703,7 +2703,7 @@ void Locker::scatter_tempsync(ScatterLock *lock)
   case LOCK_LOCK:
     if (lock->is_wrlocked() ||
        lock->is_xlocked()) {
-      lock->set_state(LOCK_GTEMPSYNCL);
+      lock->set_state(LOCK_LOCK_TEMPSYNC);
       lock->get_parent()->auth_pin(lock);
       return;
     }
@@ -2715,7 +2715,7 @@ void Locker::scatter_tempsync(ScatterLock *lock)
       break; // do it.
     }
     
-    lock->set_state(LOCK_GTEMPSYNCC);
+    lock->set_state(LOCK_SCATTER_TEMPSYNC);
     lock->get_parent()->auth_pin(lock);
 
     if (lock->get_parent()->is_replicated()) {
@@ -2770,14 +2770,14 @@ void Locker::handle_scatter_lock(ScatterLock *lock, MLock *m)
       assert(lock->get_state() == LOCK_SCATTER);
       dout(7) << "handle_scatter_lock has wrlocks, waiting on " << *lock
              << " on " << *lock->get_parent() << dendl;
-      lock->set_state(LOCK_GLOCKC);
+      lock->set_state(LOCK_SCATTER_LOCK);
     } else if (lock->is_rdlocked() ||
               lock->get_num_client_lease()) {
       assert(lock->get_state() == LOCK_SYNC);
       dout(7) << "handle_scatter_lock has rdlocks|leases, waiting on " << *lock
              << " on " << *lock->get_parent() << dendl;
       revoke_client_leases(lock);
-      lock->set_state(LOCK_GLOCKS);
+      lock->set_state(LOCK_SYNC_LOCK);
     } else {
       dout(7) << "handle_scatter_lock has no rd|wrlocks|leases, sending lockack for " << *lock
              << " on " << *lock->get_parent() << dendl;
@@ -2800,10 +2800,10 @@ void Locker::handle_scatter_lock(ScatterLock *lock, MLock *m)
 
     // -- for auth --
   case LOCK_AC_LOCKACK:
-    assert(lock->get_state() == LOCK_GLOCKS ||
-          lock->get_state() == LOCK_GLOCKC ||
-          lock->get_state() == LOCK_GSCATTERS ||
-          lock->get_state() == LOCK_GTEMPSYNCC);
+    assert(lock->get_state() == LOCK_SYNC_LOCK ||
+          lock->get_state() == LOCK_SCATTER_LOCK ||
+          lock->get_state() == LOCK_SYNC_SCATTER ||
+          lock->get_state() == LOCK_SCATTER_TEMPSYNC);
     assert(lock->is_gathering(from));
     lock->remove_gather(from);
     lock->decode_locked_state(m->get_data());
@@ -3230,9 +3230,9 @@ void Locker::file_eval_gather(FileLock *lock)
     
     switch (lock->get_state()) {
       // to lock
-    case LOCK_GLOCKR:
-    case LOCK_GLOCKM:
-    case LOCK_GLOCKL:
+    case LOCK_SYNC_LOCK:
+    case LOCK_MIXED_LOCK:
+    case LOCK_LONER_LOCK:
       lock->set_state(LOCK_LOCK);
       in->loner_cap = -1;
 
@@ -3244,13 +3244,13 @@ void Locker::file_eval_gather(FileLock *lock)
       break;
       
       // to mixed
-    case LOCK_GMIXEDR:
+    case LOCK_SYNC_MIXED:
       lock->set_state(LOCK_MIXED);
       lock->finish_waiters(SimpleLock::WAIT_STABLE);
       lock->get_parent()->auth_unpin(lock);
       break;
 
-    case LOCK_GMIXEDL:
+    case LOCK_LONER_MIXED:
       lock->set_state(LOCK_MIXED);
       in->loner_cap = -1;
       
@@ -3268,17 +3268,17 @@ void Locker::file_eval_gather(FileLock *lock)
       break;
 
       // to loner
-    case LOCK_GLONERR:
-    case LOCK_GLONERM:
-    case LOCK_GLONERL:
+    case LOCK_SYNC_LONER:
+    case LOCK_MIXED_LONER:
+    case LOCK_LOCK_LONER:
       lock->set_state(LOCK_LONER);
       lock->finish_waiters(SimpleLock::WAIT_STABLE);
       lock->get_parent()->auth_unpin(lock);
       break;
       
       // to sync
-    case LOCK_GSYNCL:
-    case LOCK_GSYNCM:
+    case LOCK_LONER_SYNC:
+    case LOCK_MIXED_SYNC:
       lock->set_state(LOCK_SYNC);
       in->loner_cap = -1;
       
@@ -3312,7 +3312,7 @@ void Locker::file_eval_gather(FileLock *lock)
       lock->get_num_client_lease() == 0 &&
       ((other_issued & ~other_allowed)) == 0) {
     switch (lock->get_state()) {
-    case LOCK_GMIXEDR:
+    case LOCK_SYNC_MIXED:
       { 
        lock->set_state(LOCK_MIXED);
        
@@ -3322,7 +3322,7 @@ void Locker::file_eval_gather(FileLock *lock)
       }
       break;
 
-    case LOCK_GLOCKR:
+    case LOCK_SYNC_LOCK:
       {
         lock->set_state(LOCK_LOCK);
         
@@ -3430,8 +3430,8 @@ bool Locker::file_sync(FileLock *lock)
   if (lock->get_state() != LOCK_LOCK) {
     // gather?
     switch (lock->get_state()) {
-    case LOCK_MIXED: lock->set_state(LOCK_GSYNCM); break;
-    case LOCK_LONER: lock->set_state(LOCK_GSYNCL); break;
+    case LOCK_MIXED: lock->set_state(LOCK_MIXED_SYNC); break;
+    case LOCK_LONER: lock->set_state(LOCK_LONER_SYNC); break;
     default: assert(0);
     }
 
@@ -3484,15 +3484,15 @@ void Locker::file_lock(FileLock *lock)
 
   // gather?
   switch (lock->get_state()) {
-  case LOCK_SYNC: lock->set_state(LOCK_GLOCKR); break;
-  case LOCK_MIXED: lock->set_state(LOCK_GLOCKM); break;
-  case LOCK_LONER: lock->set_state(LOCK_GLOCKL); break;
+  case LOCK_SYNC: lock->set_state(LOCK_SYNC_LOCK); break;
+  case LOCK_MIXED: lock->set_state(LOCK_MIXED_LOCK); break;
+  case LOCK_LONER: lock->set_state(LOCK_LONER_LOCK); break;
   default: assert(0);
   }
 
   int gather = 0;
   if (in->is_replicated() && 
-      lock->get_state() != LOCK_GLOCKL) {  // (replicas are LOCK when auth is LONER)
+      lock->get_state() != LOCK_LONER_LOCK) {  // (replicas are LOCK when auth is LONER)
     send_lock_message(lock, LOCK_AC_LOCK);
     lock->init_gather();
     gather++;
@@ -3547,15 +3547,15 @@ void Locker::file_mixed(FileLock *lock)
   } else {
     // gather?
     switch (lock->get_state()) {
-    case LOCK_SYNC: lock->set_state(LOCK_GMIXEDR); break;
-    case LOCK_LONER: lock->set_state(LOCK_GMIXEDL); break;
+    case LOCK_SYNC: lock->set_state(LOCK_SYNC_MIXED); break;
+    case LOCK_LONER: lock->set_state(LOCK_LONER_MIXED); break;
     default: assert(0);
     }
 
     int gather = 0;
     if (in->is_replicated()) {
       send_lock_message(lock, LOCK_AC_MIXED);
-      if (lock->get_state() != LOCK_GMIXEDL) {  // LONER replica is LOCK
+      if (lock->get_state() != LOCK_LONER_MIXED) {  // LONER replica is LOCK
        lock->init_gather();
        gather++;
       }
@@ -3599,9 +3599,9 @@ void Locker::file_loner(FileLock *lock)
   assert(in->get_loner() >= 0 && in->mds_caps_wanted.empty());
   
   switch (lock->get_state()) {
-  case LOCK_SYNC: lock->set_state(LOCK_GLONERR); break;
-  case LOCK_MIXED: lock->set_state(LOCK_GLONERM); break;
-  case LOCK_LOCK: lock->set_state(LOCK_GLONERL); break;
+  case LOCK_SYNC: lock->set_state(LOCK_SYNC_LONER); break;
+  case LOCK_MIXED: lock->set_state(LOCK_MIXED_LONER); break;
+  case LOCK_LOCK: lock->set_state(LOCK_LOCK_LONER); break;
   default: assert(0);
   }
   int gather = 0;
@@ -3681,7 +3681,7 @@ void Locker::handle_file_lock(FileLock *lock, MLock *m)
     assert(lock->get_state() == LOCK_SYNC ||
            lock->get_state() == LOCK_MIXED);
     
-    lock->set_state(LOCK_GLOCKR);
+    lock->set_state(LOCK_SYNC_LOCK);
     
     // call back caps?
     int loner_issued, other_issued;
@@ -3712,7 +3712,7 @@ void Locker::handle_file_lock(FileLock *lock, MLock *m)
     
     if (lock->get_state() == LOCK_SYNC) {
       // MIXED
-      lock->set_state(LOCK_GMIXEDR);
+      lock->set_state(LOCK_SYNC_MIXED);
       int loner_issued, other_issued;
       in->get_caps_issued(&loner_issued, &other_issued);
       if ((loner_issued & ~lock->caps_allowed(true)) ||
@@ -3746,10 +3746,10 @@ void Locker::handle_file_lock(FileLock *lock, MLock *m)
 
     // -- auth --
   case LOCK_AC_LOCKACK:
-    assert(lock->get_state() == LOCK_GLOCKR ||
-           lock->get_state() == LOCK_GLOCKM ||
-           lock->get_state() == LOCK_GLONERM ||
-           lock->get_state() == LOCK_GLONERR);
+    assert(lock->get_state() == LOCK_SYNC_LOCK ||
+           lock->get_state() == LOCK_MIXED_LOCK ||
+           lock->get_state() == LOCK_MIXED_LONER ||
+           lock->get_state() == LOCK_SYNC_LONER);
     assert(lock->is_gathering(from));
     lock->remove_gather(from);
 
@@ -3764,7 +3764,7 @@ void Locker::handle_file_lock(FileLock *lock, MLock *m)
     break;
     
   case LOCK_AC_SYNCACK:
-    assert(lock->get_state() == LOCK_GSYNCM);
+    assert(lock->get_state() == LOCK_MIXED_SYNC);
     assert(lock->is_gathering(from));
     lock->remove_gather(from);
     
@@ -3787,7 +3787,7 @@ void Locker::handle_file_lock(FileLock *lock, MLock *m)
     break;
 
   case LOCK_AC_MIXEDACK:
-    assert(lock->get_state() == LOCK_GMIXEDR);
+    assert(lock->get_state() == LOCK_SYNC_MIXED);
     assert(lock->is_gathering(from));
     lock->remove_gather(from);
     

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 708f2fd358c7543f03104d868f96b23a7932d639..7fd1f3b0328cc0f4350faa80f5b81b9648fa3c86 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -3105,7 +3105,7 @@ void MDCache::handle_cache_rejoin_strong(MMDSCacheRejoin *strong)
          
          // scatterlock?
          if (is.dirlock == LOCK_SCATTER ||
-             is.dirlock == LOCK_GLOCKC)  // replica still has wrlocks
+             is.dirlock == LOCK_SCATTER_LOCK)  // replica still has wrlocks
            in->dirlock.set_state(LOCK_SCATTER);
          
          // auth pin?

diff --git a/src/mds/ScatterLock.h b/src/mds/ScatterLock.h
index 8ff0f9c40cf3a0a6713749e1aae75df4e7bbd7ca..dba506eb801f7df73bb50a53fb973cf19684b488 100644 (file)
--- a/src/mds/ScatterLock.h
+++ b/src/mds/ScatterLock.h
@@ -23,40 +23,40 @@
 //  Sync  --  Lock  --  sCatter
 //  Tempsync _/
 //                              auth repl
-#define LOCK_SYNC__          // R .  R .  rdlocks allowed on auth and replicas
-#define LOCK_GLOCKS     -20  // r .  r .  waiting for replicas+rdlocks (auth), or rdlocks to release (replica)
-#define LOCK_GSCATTERS  -28  // r .  r .  
+#define LOCK_SYNC__                 // R .  R .  rdlocks allowed on auth and replicas
+#define LOCK_SYNC_LOCK__       -20  // r .  r .  waiting for replicas+rdlocks (auth), or rdlocks to release (replica)
+#define LOCK_SYNC_SCATTER      -28  // r .  r .  
 
-#define LOCK_GSYNCL__        // . w       LOCK on replica.
-#define LOCK_LOCK__          // . W  . .
-#define LOCK_GTEMPSYNCL -21  // . w       LOCK on replica.
+#define LOCK_LOCK_SYNC__            // . w       LOCK on replica.
+#define LOCK_LOCK__                 // . W  . .
+#define LOCK_LOCK_TEMPSYNC     -21  // . w       LOCK on replica.
 
-#define LOCK_GLOCKC     -22  // . wp . wp waiting for replicas+wrlocks (auth), or wrlocks to release (replica)
-#define LOCK_SCATTER     23  // . Wp . WP mtime updates on replicas allowed, no reads.  stable here.
-#define LOCK_GTEMPSYNCC -24  // . wp . wp GLOCKC|LOCK on replica
+#define LOCK_SCATTER_LOCK      -22  // . wp . wp waiting for replicas+wrlocks (auth), or wrlocks to release (replica)
+#define LOCK_SCATTER            23  // . Wp . WP mtime updates on replicas allowed, no reads.  stable here.
+#define LOCK_SCATTER_TEMPSYNC  -24  // . wp . wp GLOCKC|LOCK on replica
 
-#define LOCK_GSCATTERT  -25  // r .       LOCK on replica.
-#define LOCK_GLOCKT     -26  // r .       LOCK on replica.
-#define LOCK_TEMPSYNC    27  // R .       LOCK on replica.
+#define LOCK_TEMPSYNC_SCATTER  -25  // r .       LOCK on replica.
+#define LOCK_TEMPSYNC_LOCK     -26  // r .       LOCK on replica.
+#define LOCK_TEMPSYNC           27  // R .       LOCK on replica.
 
 
 inline const char *get_scatterlock_state_name(int s) {
   switch(s) {
-  case LOCK_SYNC: return "Sync";
-  case LOCK_GLOCKS: return "gLockS";
-  case LOCK_GSCATTERS: return "gScatterS";
+  case LOCK_SYNC: return "sync";
+  case LOCK_SYNC_LOCK: return "sync->lock";
+  case LOCK_SYNC_SCATTER: return "sync->scatter";
     
-  case LOCK_GSYNCL: return "gSyncL";
-  case LOCK_LOCK: return "Lock";
-  case LOCK_GTEMPSYNCL: return "gTempsyncL";
+  case LOCK_LONER_SYNC: return "loner->sync";
+  case LOCK_LOCK: return "lock";
+  case LOCK_LOCK_TEMPSYNC: return "lock->tempsync";
     
-  case LOCK_GLOCKC: return "gLockC";
-  case LOCK_SCATTER: return "sCatter";
-  case LOCK_GTEMPSYNCC: return "gTempsyncC";
+  case LOCK_SCATTER_LOCK: return "scatter->lock";
+  case LOCK_SCATTER: return "scatter";
+  case LOCK_SCATTER_TEMPSYNC: return "scatter->tempsync";
     
-  case LOCK_GSCATTERT: return "gsCatterT";
-  case LOCK_GLOCKT: return "gLockT";
-  case LOCK_TEMPSYNC: return "Tempsync";
+  case LOCK_TEMPSYNC_SCATTER: return "tempsync->scatter";
+  case LOCK_TEMPSYNC_LOCK: return "tempsync->lock";
+  case LOCK_TEMPSYNC: return "tempsync";
     
   default: assert(0); return 0;
   }
@@ -85,20 +85,20 @@ public:
     case LOCK_SYNC: 
       return LOCK_SYNC;
       
-    case LOCK_GSCATTERS:  // hrm.
-    case LOCK_GLOCKS:
-    case LOCK_GSYNCL:
+    case LOCK_SYNC_SCATTER:  // hrm.
+    case LOCK_SYNC_LOCK:
+    case LOCK_LONER_SYNC:
     case LOCK_LOCK:
-    case LOCK_GTEMPSYNCL:
-    case LOCK_GLOCKC:
+    case LOCK_LOCK_TEMPSYNC:
+    case LOCK_SCATTER_LOCK:
       return LOCK_LOCK;
 
     case LOCK_SCATTER:
       return LOCK_SCATTER;
 
-    case LOCK_GTEMPSYNCC:
-    case LOCK_GSCATTERT:
-    case LOCK_GLOCKT:
+    case LOCK_SCATTER_TEMPSYNC:
+    case LOCK_TEMPSYNC_SCATTER:
+    case LOCK_TEMPSYNC_LOCK:
     case LOCK_TEMPSYNC:
       return LOCK_LOCK;
     default:
@@ -109,8 +109,8 @@ public:
 
   // true if we are gathering and need the replica's data to be consistent
   bool must_gather() {
-    return (state == LOCK_GTEMPSYNCC ||
-           state == LOCK_GLOCKC);
+    return (state == LOCK_SCATTER_TEMPSYNC ||
+           state == LOCK_SCATTER_LOCK);
   }
 
   void set_updated() { 
@@ -144,14 +144,14 @@ public:
     return state == LOCK_SYNC || state == LOCK_TEMPSYNC;
   }
   bool can_rdlock_soon() {
-    return state == LOCK_GTEMPSYNCC;
+    return state == LOCK_SCATTER_TEMPSYNC;
   }
   
   // xlock
   bool can_xlock_soon() {
     if (parent->is_auth())
-      return (state == LOCK_GLOCKC ||
-             state == LOCK_GLOCKS);
+      return (state == LOCK_SCATTER_LOCK ||
+             state == LOCK_SYNC_LOCK);
     else
       return false;
   }

diff --git a/src/mds/SimpleLock.h b/src/mds/SimpleLock.h
index 3155fa24d576f9dae68674dbcb889054bc7a1803..1f91f73901eadf0d77330fe39792a84a2024f73f 100644 (file)
--- a/src/mds/SimpleLock.h
+++ b/src/mds/SimpleLock.h
@@ -42,18 +42,16 @@ inline const char *get_lock_type_name(int t) {
 //                               auth   rep
 #define LOCK_SYNC     1  // AR   R .    R .
 #define LOCK_LOCK     2  // AR   R W    . .
-#define LOCK_GLOCKR  -3  // AR   R .    . .
+#define LOCK_SYNC_LOCK  -3  // AR   R .    . .
 #define LOCK_REMOTEXLOCK  -50    // on NON-auth
-#define LOCK_CLIENTDEL -60
 
 inline const char *get_simplelock_state_name(int n) {
   switch (n) {
   case LOCK_UNDEF: return "UNDEF";
   case LOCK_SYNC: return "sync";
   case LOCK_LOCK: return "lock";
-  case LOCK_GLOCKR: return "glockr";
+  case LOCK_SYNC_LOCK: return "sync->lock";
   case LOCK_REMOTEXLOCK: return "remote_xlock";
-  case LOCK_CLIENTDEL: return "clientdel";
   default: assert(0); return 0;
   }
 }
@@ -269,7 +267,7 @@ public:
   virtual int get_replica_state() const {
     switch (state) {
     case LOCK_LOCK:
-    case LOCK_GLOCKR: 
+    case LOCK_SYNC_LOCK: 
       return LOCK_LOCK;
     case LOCK_SYNC:
       return LOCK_SYNC;
@@ -330,7 +328,7 @@ public:
   }
   bool can_xlock_soon() {
     if (parent->is_auth())
-      return (state == LOCK_GLOCKR);
+      return (state == LOCK_SYNC_LOCK);
     else
       return false;
   }