nodes.txt
TAGS
web/packages
+rec.lock
+test.db
common/ctdb_call.o common/ctdb_ltdb.o common/ctdb_lockwait.o \
common/ctdb_message.o common/cmdline.o common/ctdb_control.o \
lib/util/debug.o common/ctdb_recover.o common/ctdb_recoverd.o \
- common/ctdb_freeze.o common/ctdb_traverse.o common/ctdb_monitor.o
+ common/ctdb_freeze.o common/ctdb_traverse.o common/ctdb_monitor.o \
+ common/ctdb_tunables.o
CTDB_TAKEOVER_OBJ = takeover/system.o takeover/ctdb_takeover.o
return 0;
}
+
+/*
+ get a tunable
+ */
+int ctdb_ctrl_get_tunable(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ const char *name, uint32_t *value)
+{
+ struct ctdb_control_get_tunable *t;
+ TDB_DATA data, outdata;
+ int32_t res;
+ int ret;
+
+ data.dsize = offsetof(struct ctdb_control_get_tunable, name) + strlen(name) + 1;
+ data.dptr = talloc_size(ctdb, data.dsize);
+ CTDB_NO_MEMORY(ctdb, data.dptr);
+
+ t = (struct ctdb_control_get_tunable *)data.dptr;
+ t->length = strlen(name)+1;
+ memcpy(t->name, name, t->length);
+
+ ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_GET_TUNABLE, 0, data, ctdb,
+ &outdata, &res, &timeout, NULL);
+ talloc_free(data.dptr);
+ if (ret != 0 || res != 0) {
+ DEBUG(0,(__location__ " ctdb_control for get_tunable failed\n"));
+ return -1;
+ }
+
+ if (outdata.dsize != sizeof(uint32_t)) {
+ DEBUG(0,("Invalid return data in get_tunable\n"));
+ talloc_free(outdata.dptr);
+ return -1;
+ }
+
+ *value = *(uint32_t *)outdata.dptr;
+ talloc_free(outdata.dptr);
+
+ return 0;
+}
+
+/*
+ set a tunable
+ */
+int ctdb_ctrl_set_tunable(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ const char *name, uint32_t value)
+{
+ struct ctdb_control_set_tunable *t;
+ TDB_DATA data;
+ int32_t res;
+ int ret;
+
+ data.dsize = offsetof(struct ctdb_control_set_tunable, name) + strlen(name) + 1;
+ data.dptr = talloc_size(ctdb, data.dsize);
+ CTDB_NO_MEMORY(ctdb, data.dptr);
+
+ t = (struct ctdb_control_set_tunable *)data.dptr;
+ t->length = strlen(name)+1;
+ memcpy(t->name, name, t->length);
+ t->value = value;
+
+ ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_SET_TUNABLE, 0, data, NULL,
+ NULL, &res, &timeout, NULL);
+ talloc_free(data.dptr);
+ if (ret != 0 || res != 0) {
+ DEBUG(0,(__location__ " ctdb_control for set_tunable failed\n"));
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ list tunables
+ */
+int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ TALLOC_CTX *mem_ctx,
+ const char ***list, uint32_t *count)
+{
+ TDB_DATA outdata;
+ int32_t res;
+ int ret;
+ struct ctdb_control_list_tunable *t;
+ char *p, *s, *ptr;
+
+ ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_LIST_TUNABLES, 0, tdb_null,
+ mem_ctx, &outdata, &res, &timeout, NULL);
+ if (ret != 0 || res != 0) {
+ DEBUG(0,(__location__ " ctdb_control for list_tunables failed\n"));
+ return -1;
+ }
+
+ t = (struct ctdb_control_list_tunable *)outdata.dptr;
+ if (outdata.dsize < offsetof(struct ctdb_control_list_tunable, data) ||
+ t->length > outdata.dsize-offsetof(struct ctdb_control_list_tunable, data)) {
+ DEBUG(0,("Invalid data in list_tunables reply\n"));
+ talloc_free(outdata.dptr);
+ return -1;
+ }
+
+ p = talloc_strndup(mem_ctx, (char *)t->data, t->length);
+ CTDB_NO_MEMORY(ctdb, p);
+
+ talloc_free(outdata.dptr);
+
+ (*list) = NULL;
+ (*count) = 0;
+
+ for (s=strtok_r(p, ":", &ptr); s; s=strtok_r(NULL, ":", &ptr)) {
+ (*list) = talloc_realloc(mem_ctx, *list, const char *, 1+(*count));
+ CTDB_NO_MEMORY(ctdb, *list);
+ (*list)[*count] = talloc_strdup(*list, s);
+ CTDB_NO_MEMORY(ctdb, (*list)[*count]);
+ (*count)++;
+ }
+
+ talloc_free(p);
+
+ return 0;
+}
CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_control_tcp_vnn));
return ctdb_control_tcp_remove(ctdb, indata);
+ case CTDB_CONTROL_SET_TUNABLE:
+ return ctdb_control_set_tunable(ctdb, indata);
+
+ case CTDB_CONTROL_GET_TUNABLE:
+ return ctdb_control_get_tunable(ctdb, indata, outdata);
+
+ case CTDB_CONTROL_LIST_TUNABLES:
+ return ctdb_control_list_tunables(ctdb, outdata);
+
default:
DEBUG(0,(__location__ " Unknown CTDB control opcode %u\n", opcode));
return -1;
--- /dev/null
+/*
+ ctdb tunables code
+
+ Copyright (C) Andrew Tridgell 2007
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#include "includes.h"
+#include "../include/ctdb_private.h"
+
+static const struct {
+ const char *name;
+ size_t offset;
+} tunable_map[] = {
+ { "MaxRedirectCount", offsetof(struct ctdb_tunable, max_redirect_count) },
+ { "SeqnumFrequency", offsetof(struct ctdb_tunable, seqnum_frequency) },
+ { "ControlTimeout", offsetof(struct ctdb_tunable, control_timeout) },
+ { "TraverseTimeout", offsetof(struct ctdb_tunable, traverse_timeout) },
+ { "MonitoringTimeout", offsetof(struct ctdb_tunable, monitoring_timeout) },
+ { "MonitoringLimit", offsetof(struct ctdb_tunable, monitoring_limit) },
+ { "MaxLACount", offsetof(struct ctdb_tunable, max_lacount) },
+};
+
+
+/*
+ get a tunable
+ */
+int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata,
+ TDB_DATA *outdata)
+{
+ struct ctdb_control_get_tunable *t =
+ (struct ctdb_control_get_tunable *)indata.dptr;
+ char *name;
+ uint32_t val;
+ int i;
+
+ if (indata.dsize < sizeof(*t) ||
+ t->length > indata.dsize - offsetof(struct ctdb_control_get_tunable, name)) {
+ DEBUG(0,("Bad indata in ctdb_control_get_tunable\n"));
+ return -1;
+ }
+
+ name = talloc_strndup(ctdb, (char*)t->name, t->length);
+ CTDB_NO_MEMORY(ctdb, name);
+
+ for (i=0;i<ARRAY_SIZE(tunable_map);i++) {
+ if (strcasecmp(name, tunable_map[i].name) == 0) break;
+ }
+ talloc_free(name);
+
+ if (i == ARRAY_SIZE(tunable_map)) {
+ return -1;
+ }
+
+ val = *(uint32_t *)(tunable_map[i].offset + (uint8_t*)&ctdb->tunable);
+
+ outdata->dptr = (uint8_t *)talloc(outdata, uint32_t);
+ CTDB_NO_MEMORY(ctdb, outdata->dptr);
+
+ *(uint32_t *)outdata->dptr = val;
+ outdata->dsize = sizeof(uint32_t);
+
+ return 0;
+}
+
+
+/*
+ set a tunable
+ */
+int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata)
+{
+ struct ctdb_control_set_tunable *t =
+ (struct ctdb_control_set_tunable *)indata.dptr;
+ char *name;
+ int i;
+
+ if (indata.dsize < sizeof(*t) ||
+ t->length > indata.dsize - offsetof(struct ctdb_control_set_tunable, name)) {
+ DEBUG(0,("Bad indata in ctdb_control_set_tunable\n"));
+ return -1;
+ }
+
+ name = talloc_strndup(ctdb, (char *)t->name, t->length);
+ CTDB_NO_MEMORY(ctdb, name);
+
+ for (i=0;i<ARRAY_SIZE(tunable_map);i++) {
+ if (strcasecmp(name, tunable_map[i].name) == 0) break;
+ }
+
+ 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;
+}
+
+/*
+ list tunables
+ */
+int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb, TDB_DATA *outdata)
+{
+ char *list = NULL;
+ int i;
+ struct ctdb_control_list_tunable *t;
+
+ list = talloc_strdup(outdata, tunable_map[0].name);
+ CTDB_NO_MEMORY(ctdb, list);
+
+ for (i=1;i<ARRAY_SIZE(tunable_map);i++) {
+ list = talloc_asprintf_append(list, ":%s", tunable_map[i].name);
+ CTDB_NO_MEMORY(ctdb, list);
+ }
+
+ outdata->dsize = offsetof(struct ctdb_control_list_tunable, data) +
+ strlen(list) + 1;
+ outdata->dptr = talloc_size(outdata, outdata->dsize);
+ CTDB_NO_MEMORY(ctdb, outdata->dptr);
+
+ t = (struct ctdb_control_list_tunable *)outdata->dptr;
+ t->length = strlen(list)+1;
+
+ memcpy(t->data, list, t->length);
+ talloc_free(list);
+
+ return 0;
+}
--- /dev/null
+This directory is where you should put any local or application
+specific event scripts for ctdb to call.
+
+
int ctdb_ctrl_getvnn(struct ctdb_context *ctdb, struct timeval timeout, uint32_t destnode);
+int ctdb_ctrl_get_tunable(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ const char *name, uint32_t *value);
+
+int ctdb_ctrl_set_tunable(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ const char *name, uint32_t value);
+
+int ctdb_ctrl_list_tunables(struct ctdb_context *ctdb,
+ struct timeval timeout,
+ uint32_t destnode,
+ TALLOC_CTX *mem_ctx,
+ const char ***list, uint32_t *count);
+
+
+
#endif
CTDB_CONTROL_TCP_ADD = 45,
CTDB_CONTROL_TCP_REMOVE = 46,
CTDB_CONTROL_STARTUP = 47,
+ CTDB_CONTROL_SET_TUNABLE = 48,
+ CTDB_CONTROL_GET_TUNABLE = 49,
+ CTDB_CONTROL_LIST_TUNABLES = 50,
};
/*
uint32_t dmaster;
};
+/*
+ structure for setting a tunable
+ */
+struct ctdb_control_set_tunable {
+ uint32_t value;
+ uint32_t length;
+ uint8_t name[1];
+};
+
+/*
+ structure for getting a tunable
+ */
+struct ctdb_control_get_tunable {
+ uint32_t length;
+ uint8_t name[1];
+};
+
+/*
+ structure for listing tunables
+ */
+struct ctdb_control_list_tunable {
+ uint32_t length;
+ /* returns a : separated list of tunable names */
+ uint8_t data[1];
+};
+
+
/* table that contains a list of all nodes a ctdb knows about and their
status
*/
int ctdb_set_recovery_lock_file(struct ctdb_context *ctdb, const char *file);
+int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata,
+ TDB_DATA *outdata);
+int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata);
+int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb, TDB_DATA *outdata);
+
#endif
echo "Testing status"
$VALGRIND bin/ctdb status || exit 1
+echo "Testing variables"
+$VALGRIND bin/ctdb listvars || exit 1
+$VALGRIND bin/ctdb getvar TraverseTimeout || exit 1
+$VALGRIND bin/ctdb setvar TraverseTimeout 10 || exit 1
+$VALGRIND bin/ctdb getvar TraverseTimeout || exit 1
+
sleep 1
echo "Testing shutdown"
NUMNODES="$1"
NODES=$2
-pkill -f ctdbd
+killall -q ctdbd
echo "Starting $NUMNODES ctdb daemons"
for i in `seq 1 $NUMNODES`; do
$VALGRIND bin/ctdbd --reclock=rec.lock --nlist $NODES --event-script=tests/events --logfile=- --socket=sock.$i --dbdir=test.db || exit 1
done
-ln -sf sock.1 /tmp/ctdb.socket || exit 1
+ln -sf $PWD/sock.1 /tmp/ctdb.socket || exit 1
while bin/ctdb status | grep RECOVERY > /dev/null; do
echo "`date` Waiting for recovery"
sleep 1;
done
+echo "$NUMNODES daemons started"
+
exit 0
}
+/*
+ get a tunable
+ */
+static int control_getvar(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ const char *name;
+ uint32_t value;
+ int ret;
+
+ if (argc < 1) {
+ usage();
+ }
+
+ name = argv[0];
+ ret = ctdb_ctrl_get_tunable(ctdb, TIMELIMIT(), options.vnn, name, &value);
+ if (ret == -1) {
+ printf("Unable to get tunable variable '%s'\n", name);
+ return -1;
+ }
+
+ printf("%-17s = %u\n", name, value);
+ return 0;
+}
+
+/*
+ set a tunable
+ */
+static int control_setvar(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ const char *name;
+ uint32_t value;
+ int ret;
+
+ if (argc < 2) {
+ usage();
+ }
+
+ name = argv[0];
+ value = strtoul(argv[1], NULL, 0);
+
+ ret = ctdb_ctrl_set_tunable(ctdb, TIMELIMIT(), options.vnn, name, value);
+ if (ret == -1) {
+ printf("Unable to set tunable variable '%s'\n", name);
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ list all tunables
+ */
+static int control_listvars(struct ctdb_context *ctdb, int argc, const char **argv)
+{
+ uint32_t count;
+ const char **list;
+ int ret, i;
+
+ ret = ctdb_ctrl_list_tunables(ctdb, TIMELIMIT(), options.vnn, ctdb, &list, &count);
+ if (ret == -1) {
+ printf("Unable to list tunable variables\n");
+ return -1;
+ }
+
+ for (i=0;i<count;i++) {
+ control_getvar(ctdb, 1, &list[i]);
+ }
+
+ talloc_free(list);
+
+ return 0;
+}
+
/*
display debug level on a node
*/
} ctdb_commands[] = {
{ "status", control_status, "show node status" },
{ "ping", control_ping, "ping all nodes" },
+ { "getvar", control_getvar, "get a tunable variable", "<name>"},
+ { "setvar", control_setvar, "set a tunable variable", "<name> <value>"},
+ { "listvars", control_listvars, "list tunable variables"},
{ "statistics", control_statistics, "show statistics" },
{ "statisticsreset", control_statistics_reset, "reset statistics"},
{ "process-exists", control_process_exists, "check if a process exists on a node", "<pid>"},
projects / thirdparty / samba.git / commitdiff
