Rewrote threaded log code to be more idiomatic.

[invirt/third/libt4.git] / lock_server.cc

diff --git a/lock_server.cc b/lock_server.cc
index 90ad5b2..a4d5881 100644 (file)
--- a/lock_server.cc
+++ b/lock_server.cc
@@ -42,7 +42,7 @@ void lock_server::revoker () {
     while (1) {
         lock_protocol::lockid_t lid;
         revoke_fifo.deq(&lid);
     while (1) {
         lock_protocol::lockid_t lid;
         revoke_fifo.deq(&lid);

-        LOG("Revoking " << lid);
+        LOG << "Revoking " << lid;

         if (rsm_ && !rsm_->amiprimary())
             continue;
 
         if (rsm_ && !rsm_->amiprimary())
             continue;
 

@@ -61,7 +61,7 @@ void lock_server::revoker () {
         if (proxy) {
             int r;
             auto ret = (rlock_protocol::status)proxy->call(rlock_protocol::revoke, r, lid, held_by.second);
         if (proxy) {
             int r;
             auto ret = (rlock_protocol::status)proxy->call(rlock_protocol::revoke, r, lid, held_by.second);

-            LOG("Revoke returned " << ret);
+            LOG << "Revoke returned " << ret;

         }
     }
 }
         }
     }
 }

@@ -73,7 +73,7 @@ void lock_server::retryer() {
         if (rsm_ && !rsm_->amiprimary())
             continue;
 
         if (rsm_ && !rsm_->amiprimary())
             continue;
 

-        LOG("Sending retry for " << lid);
+        LOG << "Sending retry for " << lid;

         lock_state & st = get_lock_state(lid);
         holder_t front;
         {
         lock_state & st = get_lock_state(lid);
         holder_t front;
         {

@@ -91,13 +91,13 @@ void lock_server::retryer() {
         if (proxy) {
             int r;
             auto ret = (rlock_protocol::status)proxy->call(rlock_protocol::retry, r, lid, front.second);
         if (proxy) {
             int r;
             auto ret = (rlock_protocol::status)proxy->call(rlock_protocol::retry, r, lid, front.second);

-            LOG("Retry returned " << ret);
+            LOG << "Retry returned " << ret;

         }
     }
 }
 
 lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, const callback_t & id, lock_protocol::xid_t xid) {
         }
     }
 }
 
 lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, const callback_t & id, lock_protocol::xid_t xid) {

-    LOG("lid=" << lid << " client=" << id << "," << xid);
+    LOG << "lid=" << lid << " client=" << id << "," << xid;

     holder_t h = holder_t(id, xid);
     lock_state & st = get_lock_state(lid);
     lock sl(st.m);
     holder_t h = holder_t(id, xid);
     lock_state & st = get_lock_state(lid);
     lock sl(st.m);

@@ -109,7 +109,7 @@ lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, c
             return lock_protocol::RPCERR;
         else if (old_xid == xid) {
             if (st.held && st.held_by == h) {
             return lock_protocol::RPCERR;
         else if (old_xid == xid) {
             if (st.held && st.held_by == h) {

-                LOG("Client " << id << " sent duplicate acquire xid=" << xid);
+                LOG << "Client " << id << " sent duplicate acquire xid=" << xid;

                 return lock_protocol::OK;
             }
         }
                 return lock_protocol::OK;
             }
         }

@@ -123,7 +123,7 @@ lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, c
 
         st.held = true;
         st.held_by = h;
 
         st.held = true;
         st.held_by = h;

-        LOG("Lock " << lid << " held by " << h.first);
+        LOG << "Lock " << lid << " held by " << h.first;

         if (st.wanted_by.size())
             revoke_fifo.enq(lid);
         return lock_protocol::OK;
         if (st.wanted_by.size())
             revoke_fifo.enq(lid);
         return lock_protocol::OK;

@@ -135,7 +135,7 @@ lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, c
         if (p.first == id) {
             // make sure client is obeying serialization
             if (p.second != xid) {
         if (p.first == id) {
             // make sure client is obeying serialization
             if (p.second != xid) {

-                LOG("Client " << id << " sent acquire xid=" << xid << " with in-progress xid=" << p.second);
+                LOG << "Client " << id << " sent acquire xid=" << xid << " with in-progress xid=" << p.second;

                 return lock_protocol::RPCERR;
             }
             found = true;
                 return lock_protocol::RPCERR;
             }
             found = true;

@@ -145,7 +145,7 @@ lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, c
     if (!found)
         st.wanted_by.push_back(h);
 
     if (!found)
         st.wanted_by.push_back(h);
 

-    LOG("wanted_by=" << st.wanted_by);
+    LOG << "wanted_by=" << st.wanted_by;

 
     // send revoke if we're first in line
     if (st.wanted_by.front() == h)
 
     // send revoke if we're first in line
     if (st.wanted_by.front() == h)

@@ -155,12 +155,12 @@ lock_protocol::status lock_server::acquire(int &, lock_protocol::lockid_t lid, c
 }
 
 lock_protocol::status lock_server::release(int &, lock_protocol::lockid_t lid, const callback_t & id, lock_protocol::xid_t xid) {
 }
 
 lock_protocol::status lock_server::release(int &, lock_protocol::lockid_t lid, const callback_t & id, lock_protocol::xid_t xid) {

-    LOG("lid=" << lid << " client=" << id << "," << xid);
+    LOG << "lid=" << lid << " client=" << id << "," << xid;

     lock_state & st = get_lock_state(lid);
     lock sl(st.m);
     if (st.held && st.held_by == holder_t(id, xid)) {
         st.held = false;
     lock_state & st = get_lock_state(lid);
     lock sl(st.m);
     if (st.held && st.held_by == holder_t(id, xid)) {
         st.held = false;

-        LOG("Lock " << lid << " not held");
+        LOG << "Lock " << lid << " not held";

     }
     if (st.wanted_by.size())
         retry_fifo.enq(lid);
     }
     if (st.wanted_by.size())
         retry_fifo.enq(lid);

@@ -178,7 +178,7 @@ void lock_server::unmarshal_state(const string & state) {
 }
 
 lock_protocol::status lock_server::stat(int & r, lock_protocol::lockid_t lid, const callback_t &) {
 }
 
 lock_protocol::status lock_server::stat(int & r, lock_protocol::lockid_t lid, const callback_t &) {

-    LOG("stat request for " << lid);
+    LOG << "stat request for " << lid;

     VERIFY(0);
     r = nacquire;
     return lock_protocol::OK;
     VERIFY(0);
     r = nacquire;
     return lock_protocol::OK;