locking: Do not use RECLOCK for tracking DB locks and latencies

RECLOCK is for recovery lock in CTDB. Do not override the meaning for
tracking locks on databases.  Database lock latency has nothing to do
with recovery lock latency.

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
(This used to be ctdb commit 54e24a151d2163954e5a2a1c0f41a2b5c19ae44b)

diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index 4ad498b687b077feac505a306940e85a6564ffe4..f06a1f15872bce8fa2197b5c8f9e2cc6f4052b04 100644 (file)
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -365,7 +365,7 @@ struct ctdb_daemon_data {
                }                                                                       \
        }
 
-#define CTDB_UPDATE_DB_RECLOCK_LATENCY(ctdb_db, name, counter, value) \
+#define CTDB_UPDATE_DB_LATENCY(ctdb_db, operation, counter, value)                     \
        {                                                                               \
                if (value > ctdb_db->statistics.counter.max)                            \
                        ctdb_db->statistics.counter.max = value;                        \
@@ -377,10 +377,10 @@ struct ctdb_daemon_data {
                ctdb_db->statistics.counter.num++;                                      \
                                                                                        \
                if (ctdb_db->ctdb->tunable.reclock_latency_ms != 0) {                   \
-                       if (value*1000 > ctdb_db->ctdb->tunable.reclock_latency_ms) {   \
+                       if (value*1000 > ctdb_db->ctdb->tunable.log_latency_ms) {       \
                                DEBUG(DEBUG_ERR,                                        \
-                                     ("High RECLOCK latency %fs for operation %s\n",   \
-                                      value, name));                                   \
+                                     ("High latency %.6fs for operation %s on database %s\n",\
+                                      value, operation, ctdb_db->db_name));            \
                        }                                                               \
                }                                                                       \
        }

diff --git a/ctdb/server/ctdb_lock.c b/ctdb/server/ctdb_lock.c
index 81f0eb3dcf7a4f93ff8682bbb2fe444f60718679..e78f3fc15fbbae18825881736626219d90f5211f 100644 (file)
--- a/ctdb/server/ctdb_lock.c
+++ b/ctdb/server/ctdb_lock.c
@@ -53,6 +53,13 @@ enum lock_type {
        LOCK_ALLDB,
 };
 
+static const char * const lock_type_str[] = {
+       "lock_record",
+       "lock_db",
+       "lock_alldb_prio",
+       "lock_db",
+};
+
 struct lock_request;
 
 /* lock_context is the common part for a lock request */
@@ -567,11 +574,10 @@ static void ctdb_lock_handler(struct tevent_context *ev,
 
        if (locked) {
                CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.num_current);
-               CTDB_UPDATE_RECLOCK_LATENCY(lock_ctx->ctdb, "lock()", locks.latency, t);
                CTDB_INCREMENT_STAT(lock_ctx->ctdb, locks.buckets[id]);
                if (lock_ctx->ctdb_db) {
                        CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.num_current);
-                       CTDB_UPDATE_DB_RECLOCK_LATENCY(lock_ctx->ctdb_db, "lock()", locks.latency, t);
+                       CTDB_UPDATE_DB_LATENCY(lock_ctx->ctdb_db, lock_type_str[lock_ctx->type], locks.latency, t);
                        CTDB_INCREMENT_DB_STAT(lock_ctx->ctdb_db, locks.buckets[id]);
                }
        } else {