ctdb-daemon: Rename recovery lock file to just recovery lock

It isn't necessarily a file.

Don't bother changing the control, since it doesn't pervade the code.

Signed-off-by: Martin Schwenke <martin@meltin.net>
Reviewed-by: Amitay Isaacs <amitay@gmail.com>

diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index f19ebe33dac7095b85bea2a971ab4bf295faa7fc..8f59950616735eca607bfe74fa0125a3dd03e4fa 100644 (file)
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -310,7 +310,7 @@ struct ctdb_context {
        uint64_t db_persistent_check_errors;
        uint64_t max_persistent_check_errors;
        const char *transport;
-       const char *recovery_lock_file;
+       const char *recovery_lock;
        struct ctdb_cluster_mutex_handle *recovery_lock_handle;
        uint32_t pnn; /* our own pnn */
        uint32_t num_nodes;

diff --git a/ctdb/server/ctdb_control.c b/ctdb/server/ctdb_control.c
index 27ebe6c4449786e754d3bfa568af62c10eae7581..715ea6cfcfea04c4b55bc5ef52513b5603979bae 100644 (file)
--- a/ctdb/server/ctdb_control.c
+++ b/ctdb/server/ctdb_control.c
@@ -509,9 +509,9 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
                return 0;
        case CTDB_CONTROL_GET_RECLOCK_FILE:
                CHECK_CONTROL_DATA_SIZE(0);
-               if (ctdb->recovery_lock_file != NULL) {
-                       outdata->dptr  = discard_const(ctdb->recovery_lock_file);
-                       outdata->dsize = strlen(ctdb->recovery_lock_file) + 1;
+               if (ctdb->recovery_lock != NULL) {
+                       outdata->dptr  = discard_const(ctdb->recovery_lock);
+                       outdata->dsize = strlen(ctdb->recovery_lock) + 1;
                }
                return 0;
        case CTDB_CONTROL_SET_RECLOCK_FILE:

diff --git a/ctdb/server/ctdb_recover.c b/ctdb/server/ctdb_recover.c
index bd6607ecf691360a535e28a23107295da6fbcd4e..7d0188c7e3553310e7a82a59c35a737bbce59682 100644 (file)
--- a/ctdb/server/ctdb_recover.c
+++ b/ctdb/server/ctdb_recover.c
@@ -769,7 +769,7 @@ static void set_recmode_handler(struct ctdb_context *ctdb,
                /* Mutex taken */
                DEBUG(DEBUG_ERR,
                      ("ERROR: Daemon able to take recovery lock on \"%s\" during recovery\n",
-                      ctdb->recovery_lock_file));
+                      ctdb->recovery_lock));
                s = -1;
                err = "Took recovery lock from daemon during recovery - probably a cluster filesystem lock coherence problem";
                break;
@@ -901,14 +901,14 @@ int32_t ctdb_control_set_recmode(struct ctdb_context *ctdb,
                }
        }
 
-       if (ctdb->recovery_lock_file == NULL) {
+       if (ctdb->recovery_lock == NULL) {
                /* Not using recovery lock file */
                ctdb->recovery_mode = CTDB_RECOVERY_NORMAL;
                ctdb_process_deferred_attach(ctdb);
                return 0;
        }
 
-       h = ctdb_cluster_mutex(ctdb, ctdb->recovery_lock_file, 5);
+       h = ctdb_cluster_mutex(ctdb, ctdb->recovery_lock, 5);
        if (h == NULL) {
                return -1;
        }
@@ -1161,7 +1161,7 @@ static void start_recovery_reclock_callback(struct ctdb_context *ctdb,
 {
        struct recovery_callback_state *state = talloc_get_type_abort(
                private_data, struct recovery_callback_state);
-       const char *local = ctdb->recovery_lock_file;
+       const char *local = ctdb->recovery_lock;
        const char *remote = NULL;
 
        if (status != 0) {

diff --git a/ctdb/server/ctdb_recoverd.c b/ctdb/server/ctdb_recoverd.c
index 83f01e862b2f8af718501647ee0ad8adfc5eb617..c0adebec781b6f416bc49a419b0d62d1d931c05c 100644 (file)
--- a/ctdb/server/ctdb_recoverd.c
+++ b/ctdb/server/ctdb_recoverd.c
@@ -1590,7 +1590,7 @@ static bool ctdb_recovery_lock(struct ctdb_context *ctdb)
                .status = '0',
        };
 
-       h = ctdb_cluster_mutex(ctdb, ctdb->recovery_lock_file, 0);
+       h = ctdb_cluster_mutex(ctdb, ctdb->recovery_lock, 0);
        if (h == NULL) {
                return -1;
        }
@@ -2054,12 +2054,12 @@ static int do_recovery(struct ctdb_recoverd *rec,
                goto fail;
        }
 
-        if (ctdb->recovery_lock_file != NULL) {
+        if (ctdb->recovery_lock != NULL) {
                if (ctdb_recovery_have_lock(ctdb)) {
                        DEBUG(DEBUG_NOTICE, ("Already holding recovery lock\n"));
                } else {
                        DEBUG(DEBUG_NOTICE, ("Attempting to take recovery lock (%s)\n",
-                                            ctdb->recovery_lock_file));
+                                            ctdb->recovery_lock));
                        if (!ctdb_recovery_lock(ctdb)) {
                                if (ctdb->runstate == CTDB_RUNSTATE_FIRST_RECOVERY) {
                                        /* If ctdb is trying first recovery, it's
@@ -3562,7 +3562,7 @@ static void main_loop(struct ctdb_context *ctdb, struct ctdb_recoverd *rec,
        }
 
 
-        if (ctdb->recovery_lock_file != NULL) {
+        if (ctdb->recovery_lock != NULL) {
                /* We must already hold the recovery lock */
                if (!ctdb_recovery_have_lock(ctdb)) {
                        DEBUG(DEBUG_ERR,("Failed recovery lock sanity check.  Force a recovery\n"));

diff --git a/ctdb/server/ctdbd.c b/ctdb/server/ctdbd.c
index 67f2b8e29a1efff4fe9db08eddad7dc7c618e65e..dfe133d42fc38ede5de5e88f36a8261508fc1c2d 100644 (file)
--- a/ctdb/server/ctdbd.c
+++ b/ctdb/server/ctdbd.c
@@ -48,7 +48,7 @@ static struct {
        const char *event_script_dir;
        const char *notification_script;
        const char *logging;
-       const char *recovery_lock_file;
+       const char *recovery_lock;
        const char *db_dir;
        const char *db_dir_persistent;
        const char *db_dir_state;
@@ -129,7 +129,7 @@ int main(int argc, const char *argv[])
                { "dbdir", 0, POPT_ARG_STRING, &options.db_dir, 0, "directory for the tdb files", NULL },
                { "dbdir-persistent", 0, POPT_ARG_STRING, &options.db_dir_persistent, 0, "directory for persistent tdb files", NULL },
                { "dbdir-state", 0, POPT_ARG_STRING, &options.db_dir_state, 0, "directory for internal state tdb files", NULL },
-               { "reclock", 0, POPT_ARG_STRING, &options.recovery_lock_file, 0, "location of recovery lock file", "filename" },
+               { "reclock", 0, POPT_ARG_STRING, &options.recovery_lock, 0, "recovery lock", "lock" },
                { "pidfile", 0, POPT_ARG_STRING, &ctdbd_pidfile, 0, "location of PID file", "filename" },
                { "valgrinding", 0, POPT_ARG_NONE, &options.valgrinding, 0, "disable setscheduler SCHED_FIFO call, use mmap for tdbs", NULL },
                { "nosetsched", 0, POPT_ARG_NONE, &options.nosetsched, 0, "disable setscheduler SCHED_FIFO call, use mmap for tdbs", NULL },
@@ -196,10 +196,10 @@ int main(int argc, const char *argv[])
        ctdb->recovery_master  = (uint32_t)-1;
        ctdb->upcalls          = &ctdb_upcalls;
 
-       if (options.recovery_lock_file == NULL) {
-               DEBUG(DEBUG_WARNING, ("Recovery lock file not set\n"));
+       if (options.recovery_lock == NULL) {
+               DEBUG(DEBUG_WARNING, ("Recovery lock not set\n"));
        }
-       ctdb->recovery_lock_file = options.recovery_lock_file;
+       ctdb->recovery_lock = options.recovery_lock;
        ctdb->recovery_lock_handle = NULL;
 
        TALLOC_FREE(ctdb->idr);