From 1df9248df617d66019c982610426f8c3a8944da3 Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Wed, 17 Dec 2008 14:39:35 -0800 Subject: [PATCH] mds: rename gather lock states Easier to read: LOCK_oldstate_newstate, "oldstate->newstate" --- src/mds/FileLock.h | 118 ++++++++++++++++++++-------------------- src/mds/Locker.cc | 124 +++++++++++++++++++++--------------------- src/mds/MDCache.cc | 2 +- src/mds/ScatterLock.h | 74 ++++++++++++------------- src/mds/SimpleLock.h | 10 ++-- 5 files changed, 163 insertions(+), 165 deletions(-) diff --git a/src/mds/FileLock.h b/src/mds/FileLock.h index 100ecec106900..d9987c9eab12d 100644 --- 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 ed933379bf8d1..dc599b382578b 100644 --- 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 708f2fd358c75..7fd1f3b0328cc 100644 --- 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 8ff0f9c40cf3a..dba506eb801f7 100644 --- 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 3155fa24d576f..1f91f73901ead 100644 --- 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; } -- 2.39.5