[SCM] CTDB repository - branch master updated -
ctdb-1.0.85-9-g5334e40
Ronnie Sahlberg
sahlberg at samba.org
Thu Jun 25 04:39:37 GMT 2009
The branch, master has been updated
via 5334e40978350b6b597ee020bac52e37c8f9a8ba (commit)
via d973cb6e83b2f7cc37bd39c1219dcfbd4911a8ee (commit)
via 36cc2e586f03fa497ee9b06f3e6afc80219c4aaa (commit)
via 31acc11a6389d4dd9f7b71b7cfa2f2450076f1f7 (commit)
via 6755f89f81aba63bfe00ee16d44a0201cbfa90ca (commit)
via ed6a4cbcdcbb4e0df83bec8be67c30288bf9bd41 (commit)
via 33895d217ee096b356f02b5292ba27a840c4f559 (commit)
via 07855ff5eba71e7d607d52e234a42553d9b93605 (commit)
via a25f4888689a0725971606163d87c39a41669292 (commit)
from 553a244fc8d7814634330bf4829ac127d63886be (commit)
http://gitweb.samba.org/?p=sahlberg/ctdb.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit 5334e40978350b6b597ee020bac52e37c8f9a8ba
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 14:45:17 2009 +1000
Do not allow the "VerifyRecoveryLock" tunable to be changed if there is no reclock file
commit d973cb6e83b2f7cc37bd39c1219dcfbd4911a8ee
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 14:34:21 2009 +1000
disable VerifyRecoveryLock when the user modifies the filename
commit 36cc2e586f03fa497ee9b06f3e6afc80219c4aaa
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 14:25:18 2009 +1000
add a control to set the reclock file
commit 31acc11a6389d4dd9f7b71b7cfa2f2450076f1f7
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 12:55:43 2009 +1000
update the recovery daemon to read the recovery lock file off the main daemon and handle when the file is changed/enabled/disabled
commit 6755f89f81aba63bfe00ee16d44a0201cbfa90ca
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 12:26:14 2009 +1000
return NULL and not a "" when there is no reclock file returned from the server
commit ed6a4cbcdcbb4e0df83bec8be67c30288bf9bd41
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 12:17:19 2009 +1000
add a control to read the current reclock file from a node
commit 33895d217ee096b356f02b5292ba27a840c4f559
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 11:59:21 2009 +1000
Document that you can run ctdb without a reclock file in the sysconfig file
commit 07855ff5eba71e7d607d52e234a42553d9b93605
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 11:50:45 2009 +1000
Allow setting the recovery lock file as "", which means that we do not use a file and that we implicitely also disable the recovery lock checking.
Update the init script to allow starting without a reclock file.
commit a25f4888689a0725971606163d87c39a41669292
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Thu Jun 25 11:41:18 2009 +1000
Dont access the reclock file at all if VerifyRecoveryLock is zero and also
make sure the reclock file is closed if the variable is cleared at runtime
-----------------------------------------------------------------------
Summary of changes:
client/ctdb_client.c | 56 +++++++++++++++++++++++
config/ctdb.init | 5 +-
config/ctdb.sysconfig | 11 +++--
include/ctdb.h | 3 +
include/ctdb_private.h | 2 +
server/ctdb_control.c | 17 +++++++
server/ctdb_recover.c | 2 +
server/ctdb_recoverd.c | 117 +++++++++++++++++++++++++++++++++++++++--------
server/ctdb_server.c | 11 +++++
server/ctdb_tunables.c | 9 +++-
server/ctdbd.c | 6 +--
tools/ctdb.c | 47 +++++++++++++++++++
12 files changed, 253 insertions(+), 33 deletions(-)
Changeset truncated at 500 lines:
diff --git a/client/ctdb_client.c b/client/ctdb_client.c
index 9d7ef84..2c86b3e 100644
--- a/client/ctdb_client.c
+++ b/client/ctdb_client.c
@@ -3651,3 +3651,59 @@ int ctdb_ctrl_report_recd_lock_latency(struct ctdb_context *ctdb, struct timeval
return 0;
}
+
+/*
+ get the name of the reclock file
+ */
+int ctdb_ctrl_getreclock(struct ctdb_context *ctdb, struct timeval timeout,
+ uint32_t destnode, TALLOC_CTX *mem_ctx,
+ const char **name)
+{
+ int ret;
+ int32_t res;
+ TDB_DATA data;
+
+ ret = ctdb_control(ctdb, destnode, 0,
+ CTDB_CONTROL_GET_RECLOCK_FILE, 0, tdb_null,
+ mem_ctx, &data, &res, &timeout, NULL);
+ if (ret != 0 || res != 0) {
+ return -1;
+ }
+
+ if (data.dsize == 0) {
+ *name = NULL;
+ } else {
+ *name = talloc_strdup(mem_ctx, discard_const(data.dptr));
+ }
+ talloc_free(data.dptr);
+
+ return 0;
+}
+
+/*
+ set the reclock filename for a node
+ */
+int ctdb_ctrl_setreclock(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode, const char *reclock)
+{
+ int ret;
+ TDB_DATA data;
+ int32_t res;
+
+ if (reclock == NULL) {
+ data.dsize = 0;
+ data.dptr = NULL;
+ } else {
+ data.dsize = strlen(reclock) + 1;
+ data.dptr = discard_const(reclock);
+ }
+
+ ret = ctdb_control(ctdb, destnode, 0,
+ CTDB_CONTROL_SET_RECLOCK_FILE, 0, data,
+ NULL, NULL, &res, &timeout, NULL);
+ if (ret != 0 || res != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_control for setreclock failed\n"));
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/config/ctdb.init b/config/ctdb.init
index 4076c5b..ec71361 100755
--- a/config/ctdb.init
+++ b/config/ctdb.init
@@ -47,12 +47,11 @@ loadconfig ctdb
[ "${NETWORKING}" = "no" ] && exit 0
[ -z "$CTDB_RECOVERY_LOCK" ] && {
- echo "You must configure the location of the CTDB_RECOVERY_LOCK"
- exit 1
+ echo "No recovery lock specified. Starting CTDB without split brain prevention"
}
-CTDB_OPTIONS="$CTDB_OPTIONS --reclock=$CTDB_RECOVERY_LOCK"
# build up CTDB_OPTIONS variable from optional parameters
+[ -z "$CTDB_RECOVERY_LOCK" ] || CTDB_OPTIONS="$CTDB_OPTIONS --reclock=$CTDB_RECOVERY_LOCK"
[ -z "$CTDB_LOGFILE" ] || CTDB_OPTIONS="$CTDB_OPTIONS --logfile=$CTDB_LOGFILE"
[ -z "$CTDB_NODES" ] || CTDB_OPTIONS="$CTDB_OPTIONS --nlist=$CTDB_NODES"
[ -z "$CTDB_SOCKET" ] || CTDB_OPTIONS="$CTDB_OPTIONS --socket=$CTDB_SOCKET"
diff --git a/config/ctdb.sysconfig b/config/ctdb.sysconfig
index 96823ea..3797879 100644
--- a/config/ctdb.sysconfig
+++ b/config/ctdb.sysconfig
@@ -1,9 +1,12 @@
# Options to ctdbd. This is read by /etc/init.d/ctdb
-# you must specify the location of a shared lock file across all the
-# nodes. This must be on shared storage
-# there is no default
-# CTDB_RECOVERY_LOCK="/some/place/on/shared/storage"
+# You must specify the location of a shared lock file across all the
+# nodes for split brain prevention to work.
+# This must be on shared storage.
+# CTDB can operate without a reclock file, but this means that there is no
+# protection against a split brain.
+# It is strongly suggested to NOT run ctdb without a reclock file.
+CTDB_RECOVERY_LOCK="/some/place/on/shared/storage"
# when doing IP takeover you also may specify what network interface
# to use by default for the public addresses. Otherwise you must
diff --git a/include/ctdb.h b/include/ctdb.h
index ea4bcae..fc8985b 100644
--- a/include/ctdb.h
+++ b/include/ctdb.h
@@ -569,6 +569,9 @@ int ctdb_ctrl_end_recovery(struct ctdb_context *ctdb, struct timeval timeout, ui
int ctdb_ctrl_getreclock(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
TALLOC_CTX *mem_ctx, const char **reclock);
+int ctdb_ctrl_setreclock(struct ctdb_context *ctdb,
+ struct timeval timeout, uint32_t destnode,
+ const char *reclock);
uint32_t *list_of_connected_nodes(struct ctdb_context *ctdb,
diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index 98dab07..4abe236 100644
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -567,6 +567,8 @@ enum ctdb_controls {CTDB_CONTROL_PROCESS_EXISTS = 0,
CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS = 96,
CTDB_CONTROL_TRAVERSE_KILL = 97,
CTDB_CONTROL_RECD_RECLOCK_LATENCY = 98,
+ CTDB_CONTROL_GET_RECLOCK_FILE = 99,
+ CTDB_CONTROL_SET_RECLOCK_FILE = 100,
};
/*
diff --git a/server/ctdb_control.c b/server/ctdb_control.c
index 72e60c5..4b2498f 100644
--- a/server/ctdb_control.c
+++ b/server/ctdb_control.c
@@ -445,6 +445,23 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
CHECK_CONTROL_DATA_SIZE(sizeof(double));
ctdb_reclock_latency(ctdb, "recd reclock", &ctdb->statistics.reclock.recd, *((double *)indata.dptr));
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;
+ }
+ return 0;
+ case CTDB_CONTROL_SET_RECLOCK_FILE:
+ ctdb->tunable.verify_recovery_lock = 0;
+ if (ctdb->recovery_lock_file != NULL) {
+ talloc_free(ctdb->recovery_lock_file);
+ ctdb->recovery_lock_file = NULL;
+ }
+ if (indata.dsize > 0) {
+ ctdb->recovery_lock_file = talloc_strdup(ctdb, discard_const(indata.dptr));
+ }
+ return 0;
default:
DEBUG(DEBUG_CRIT,(__location__ " Unknown CTDB control opcode %u\n", opcode));
return -1;
diff --git a/server/ctdb_recover.c b/server/ctdb_recover.c
index 526a310..16545e7 100644
--- a/server/ctdb_recover.c
+++ b/server/ctdb_recover.c
@@ -741,7 +741,9 @@ bool ctdb_recovery_lock(struct ctdb_context *ctdb, bool keep)
}
if (ctdb->recovery_lock_fd != -1) {
close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
}
+
ctdb->recovery_lock_fd = open(ctdb->recovery_lock_file, O_RDWR|O_CREAT, 0600);
if (ctdb->recovery_lock_fd == -1) {
DEBUG(DEBUG_ERR,("ctdb_recovery_lock: Unable to open %s - (%s)\n",
diff --git a/server/ctdb_recoverd.c b/server/ctdb_recoverd.c
index 3ab44a7..a367630 100644
--- a/server/ctdb_recoverd.c
+++ b/server/ctdb_recoverd.c
@@ -1346,15 +1346,18 @@ static int do_recovery(struct ctdb_recoverd *rec,
ctdb_ban_node(rec, rec->last_culprit, ctdb->tunable.recovery_ban_period);
}
- DEBUG(DEBUG_ERR,("Taking out recovery lock from recovery daemon\n"));
- start_time = timeval_current();
- if (!ctdb_recovery_lock(ctdb, true)) {
- ctdb_set_culprit(rec, pnn);
- DEBUG(DEBUG_ERR,("Unable to get recovery lock - aborting recovery\n"));
- return -1;
+
+ if (ctdb->tunable.verify_recovery_lock != 0) {
+ DEBUG(DEBUG_ERR,("Taking out recovery lock from recovery daemon\n"));
+ start_time = timeval_current();
+ if (!ctdb_recovery_lock(ctdb, true)) {
+ ctdb_set_culprit(rec, pnn);
+ DEBUG(DEBUG_ERR,("Unable to get recovery lock - aborting recovery\n"));
+ return -1;
+ }
+ ctdb_ctrl_report_recd_lock_latency(ctdb, CONTROL_TIMEOUT(), timeval_elapsed(&start_time));
+ DEBUG(DEBUG_ERR,("Recovery lock taken successfully by recovery daemon\n"));
}
- ctdb_ctrl_report_recd_lock_latency(ctdb, CONTROL_TIMEOUT(), timeval_elapsed(&start_time));
- DEBUG(DEBUG_ERR,("Recovery lock taken successfully by recovery daemon\n"));
DEBUG(DEBUG_NOTICE, (__location__ " Recovery initiated due to problem with node %u\n", culprit));
@@ -1850,12 +1853,14 @@ static void election_handler(struct ctdb_context *ctdb, uint64_t srvid,
talloc_free(rec->send_election_te);
rec->send_election_te = NULL;
- /* release the recmaster lock */
- if (em->pnn != ctdb->pnn &&
- ctdb->recovery_lock_fd != -1) {
- close(ctdb->recovery_lock_fd);
- ctdb->recovery_lock_fd = -1;
- unban_all_nodes(ctdb);
+ if (ctdb->tunable.verify_recovery_lock != 0) {
+ /* release the recmaster lock */
+ if (em->pnn != ctdb->pnn &&
+ ctdb->recovery_lock_fd != -1) {
+ close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
+ unban_all_nodes(ctdb);
+ }
}
/* ok, let that guy become recmaster then */
@@ -2501,6 +2506,60 @@ static int check_recovery_lock(struct ctdb_context *ctdb)
return 0;
}
+static int update_recovery_lock_file(struct ctdb_context *ctdb)
+{
+ TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+ const char *reclockfile;
+
+ if (ctdb_ctrl_getreclock(ctdb, CONTROL_TIMEOUT(), CTDB_CURRENT_NODE, tmp_ctx, &reclockfile) != 0) {
+ DEBUG(DEBUG_ERR,("Failed to read reclock file from daemon\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+
+ if (reclockfile == NULL) {
+ if (ctdb->recovery_lock_file != NULL) {
+ DEBUG(DEBUG_ERR,("Reclock file disabled\n"));
+ talloc_free(ctdb->recovery_lock_file);
+ ctdb->recovery_lock_file = NULL;
+ if (ctdb->recovery_lock_fd != -1) {
+ close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
+ }
+ }
+ ctdb->tunable.verify_recovery_lock = 0;
+ talloc_free(tmp_ctx);
+ return 0;
+ }
+
+ if (ctdb->recovery_lock_file == NULL) {
+ ctdb->recovery_lock_file = talloc_strdup(ctdb, reclockfile);
+ if (ctdb->recovery_lock_fd != -1) {
+ close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
+ }
+ talloc_free(tmp_ctx);
+ return 0;
+ }
+
+
+ if (!strcmp(reclockfile, ctdb->recovery_lock_file)) {
+ talloc_free(tmp_ctx);
+ return 0;
+ }
+
+ talloc_free(ctdb->recovery_lock_file);
+ ctdb->recovery_lock_file = talloc_strdup(ctdb, reclockfile);
+ ctdb->tunable.verify_recovery_lock = 0;
+ if (ctdb->recovery_lock_fd != -1) {
+ close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
+ }
+
+ talloc_free(tmp_ctx);
+ return 0;
+}
+
/*
the main monitoring loop
*/
@@ -2607,6 +2666,22 @@ again:
goto again;
}
+ /* get the current recovery lock file from the server */
+ if (update_recovery_lock_file(ctdb) != 0) {
+ DEBUG(DEBUG_ERR,("Failed to update the recovery lock file\n"));
+ goto again;
+ }
+
+ /* Make sure that if recovery lock verification becomes disabled when
+ we close the file
+ */
+ if (ctdb->tunable.verify_recovery_lock == 0) {
+ if (ctdb->recovery_lock_fd != -1) {
+ close(ctdb->recovery_lock_fd);
+ ctdb->recovery_lock_fd = -1;
+ }
+ }
+
pnn = ctdb_ctrl_getpnn(ctdb, CONTROL_TIMEOUT(), CTDB_CURRENT_NODE);
if (pnn == (uint32_t)-1) {
DEBUG(DEBUG_ERR,("Failed to get local pnn - retrying\n"));
@@ -2831,12 +2906,14 @@ again:
}
- /* we should have the reclock - check its not stale */
- ret = check_recovery_lock(ctdb);
- if (ret != 0) {
- DEBUG(DEBUG_ERR,("Failed check_recovery_lock. Force a recovery\n"));
- do_recovery(rec, mem_ctx, pnn, nodemap, vnnmap, ctdb->pnn);
- goto again;
+ if (ctdb->tunable.verify_recovery_lock != 0) {
+ /* we should have the reclock - check its not stale */
+ ret = check_recovery_lock(ctdb);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Failed check_recovery_lock. Force a recovery\n"));
+ do_recovery(rec, mem_ctx, pnn, nodemap, vnnmap, ctdb->pnn);
+ goto again;
+ }
}
/* get the nodemap for all active remote nodes
diff --git a/server/ctdb_server.c b/server/ctdb_server.c
index 59ed37c..ba156e8 100644
--- a/server/ctdb_server.c
+++ b/server/ctdb_server.c
@@ -61,6 +61,17 @@ int ctdb_ip_to_nodeid(struct ctdb_context *ctdb, const char *nodeip)
*/
int ctdb_set_recovery_lock_file(struct ctdb_context *ctdb, const char *file)
{
+ if (ctdb->recovery_lock_file != NULL) {
+ talloc_free(ctdb->recovery_lock_file);
+ ctdb->recovery_lock_file = NULL;
+ }
+
+ if (file == NULL) {
+ DEBUG(DEBUG_ALERT,("Recovery lock file set to \"\". Disabling recovery lock checking\n"));
+ ctdb->tunable.verify_recovery_lock = 0;
+ return 0;
+ }
+
ctdb->recovery_lock_file = talloc_strdup(ctdb, file);
CTDB_NO_MEMORY(ctdb, ctdb->recovery_lock_file);
diff --git a/server/ctdb_tunables.c b/server/ctdb_tunables.c
index c10dc39..8140ccf 100644
--- a/server/ctdb_tunables.c
+++ b/server/ctdb_tunables.c
@@ -135,12 +135,19 @@ int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata)
if (strcasecmp(name, tunable_map[i].name) == 0) break;
}
+ if (!strcmp(name, "VerifyRecoveryLock") && t->value != 0
+ && ctdb->recovery_lock_file == NULL) {
+ DEBUG(DEBUG_ERR,("Can not activate tunable \"VerifyRecoveryLock\" since there is no recovery lock file set.\n"));
+ talloc_free(name);
+ return -1;
+ }
+
talloc_free(name);
if (i == ARRAY_SIZE(tunable_map)) {
return -1;
}
-
+
*(uint32_t *)(tunable_map[i].offset + (uint8_t*)&ctdb->tunable) = t->value;
return 0;
diff --git a/server/ctdbd.c b/server/ctdbd.c
index de6c39f..efb3f08 100644
--- a/server/ctdbd.c
+++ b/server/ctdbd.c
@@ -160,11 +160,6 @@ int main(int argc, const char *argv[])
while (extra_argv[extra_argc]) extra_argc++;
}
- if (!options.recovery_lock_file) {
- DEBUG(DEBUG_ALERT,("You must specifiy the location of a recovery lock file with --reclock\n"));
- exit(1);
- }
-
talloc_enable_null_tracking();
ctdb_block_signal(SIGPIPE);
@@ -196,6 +191,7 @@ int main(int argc, const char *argv[])
ctdb_tunables_set_defaults(ctdb);
+
ret = ctdb_set_recovery_lock_file(ctdb, options.recovery_lock_file);
if (ret == -1) {
DEBUG(DEBUG_ALERT,("ctdb_set_recovery_lock_file failed - %s\n", ctdb_errstr(ctdb)));
diff --git a/tools/ctdb.c b/tools/ctdb.c
index 589533b..b6ca332 100644
--- a/tools/ctdb.c
+++ b/tools/ctdb.c
@@ -2248,6 +2248,51 @@ static int control_getdebug(struct ctdb_context *ctdb, int argc, const char **ar
return 0;
}
+/*
+ display reclock file of a node
+ */
+static int control_getreclock(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int ret;
+ const char *reclock;
+
+ ret = ctdb_ctrl_getreclock(ctdb, TIMELIMIT(), options.pnn, ctdb, &reclock);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get reclock file from node %u\n", options.pnn));
+ return ret;
+ } else {
+ if (reclock == NULL) {
+ printf("No reclock file used.\n");
+ } else {
+ printf("Reclock file:%s\n", reclock);
+ }
+ }
+ return 0;
+}
+
+/*
+ set the reclock file of a node
+ */
+static int control_setreclock(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ int ret;
+ const char *reclock;
+
+ if (argc == 0) {
+ reclock = NULL;
+ } else if (argc == 1) {
+ reclock = argv[0];
+ } else {
+ usage();
+ }
+
+ ret = ctdb_ctrl_setreclock(ctdb, TIMELIMIT(), options.pnn, reclock);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR, ("Unable to get reclock file from node %u\n", options.pnn));
+ return ret;
+ }
+ return 0;
+}
/*
set debug level on a node or all nodes
@@ -2991,6 +3036,8 @@ static const struct {
{ "scriptstatus", control_scriptstatus, false, false, "show the status of the monitoring scripts"},
{ "natgwlist", control_natgwlist, false, false, "show the nodes belonging to this natgw configuration"},
{ "xpnn", control_xpnn, true, true, "find the pnn of the local node without talking to the daemon (unreliable)" },
+ { "getreclock", control_getreclock, false, false, "Show the reclock file of a node"},
+ { "setreclock", control_setreclock, false, false, "Set/clear the reclock file of a node", "[filename]"},
};
/*
--
CTDB repository
More information about the samba-cvs
mailing list