This is the mail archive of the
cluster-cvs@sourceware.org
mailing list for the cluster.
fence: master - fenced: replace cman with votequorum and cfg
- From: David Teigland <teigland at fedoraproject dot org>
- To: cluster-cvs-relay at redhat dot com
- Date: Wed, 11 Feb 2009 20:43:52 +0000 (UTC)
- Subject: fence: master - fenced: replace cman with votequorum and cfg
Gitweb: http://git.fedorahosted.org/git/fence.git?p=fence.git;a=commitdiff;h=27ef61602c6de5d04ddecc008af7be57c2763609
Commit: 27ef61602c6de5d04ddecc008af7be57c2763609
Parent: 3475b9604598d73241e9b5bf7bc3ae6e0229eb2a
Author: David Teigland <teigland@redhat.com>
AuthorDate: Wed Feb 11 14:34:26 2009 -0600
Committer: David Teigland <teigland@redhat.com>
CommitterDate: Wed Feb 11 14:34:26 2009 -0600
fenced: replace cman with votequorum and cfg
libcman calls have been replaced with libvotequorum
and libcfg calls, which are corosync libs.
A new approach to doing mappings between nodeid and name was
required, based on mappings created from ccs, because node
names are not available from votequorum or cfg.
Signed-off-by: David Teigland <teigland@redhat.com>
---
fence/fenced/Makefile | 8 +-
fence/fenced/config.c | 188 +++++++++++++++++++------
fence/fenced/cpg.c | 12 +-
fence/fenced/fd.h | 23 ++--
fence/fenced/main.c | 30 +++--
fence/fenced/member_cman.c | 336 +++++++++++++++++--------------------------
fence/fenced/recover.c | 43 ++++---
7 files changed, 344 insertions(+), 296 deletions(-)
diff --git a/fence/fenced/Makefile b/fence/fenced/Makefile
index 17b8663..a999993 100644
--- a/fence/fenced/Makefile
+++ b/fence/fenced/Makefile
@@ -18,14 +18,14 @@ OBJS= config.o \
logging.o
CFLAGS += -D_FILE_OFFSET_BITS=64
-CFLAGS += -I${ccsincdir} -I${cmanincdir} -I${logtincdir} -I${corosyncincdir}
-CFLAGS += -I${fenceincdir}
CFLAGS += -I$(S) -I$(S)/../include -I$(S)/../libfenced
+CFLAGS += -I${ccsincdir} -I${logtincdir} -I${corosyncincdir}
+CFLAGS += -I${fenceincdir}
CFLAGS += -I${incdir}
-LDFLAGS += -L${ccslibdir} -L${cmanlibdir} -L${logtlibdir} -lccs -lcman -llogthread
+LDFLAGS += -L${ccslibdir} -L${logtlibdir} -lccs -llogthread
LDFLAGS += -L${fencelibdir} -lfence
-LDFLAGS += -L${corosynclibdir} -lcpg -lpthread
+LDFLAGS += -L${corosynclibdir} -lcpg -lcfg -lvotequorum -lpthread
LDFLAGS += -L${libdir}
${TARGET}: ${OBJS} ${LDDEPS}
diff --git a/fence/fenced/config.c b/fence/fenced/config.c
index 5f93b42..ce016cb 100644
--- a/fence/fenced/config.c
+++ b/fence/fenced/config.c
@@ -24,10 +24,138 @@ int cfgd_post_fail_delay = DEFAULT_POST_FAIL_DELAY;
int cfgd_override_time = DEFAULT_OVERRIDE_TIME;
char *cfgd_override_path = DEFAULT_OVERRIDE_PATH;
+#define BUFLEN MAX_NODENAME_LEN+1
+
+static struct list_head node_names;
+
+static int name_equal(char *name1, char *name2)
+{
+ char name3[BUFLEN], name4[BUFLEN];
+ int i, len1, len2;
+
+ len1 = strlen(name1);
+ len2 = strlen(name2);
+
+ if (len1 == len2 && !strncmp(name1, name2, len1))
+ return 1;
+
+ memset(name3, 0, BUFLEN);
+ memset(name4, 0, BUFLEN);
+
+ for (i = 0; i < BUFLEN && i < len1; i++) {
+ if (name1[i] != '.')
+ name3[i] = name1[i];
+ else
+ break;
+ }
+
+ for (i = 0; i < BUFLEN && i < len2; i++) {
+ if (name2[i] != '.')
+ name4[i] = name2[i];
+ else
+ break;
+ }
+
+ len1 = strlen(name3);
+ len2 = strlen(name4);
+
+ if (len1 == len2 && !strncmp(name3, name4, len1))
+ return 1;
+
+ return 0;
+}
+
+
+int name_to_nodeid(char *name, int *nodeid)
+{
+ struct node *node;
+
+ list_for_each_entry(node, &node_names, list) {
+ if (name_equal(node->name, name)) {
+ *nodeid = node->nodeid;
+ return 0;
+ }
+ }
+ return -1;
+}
+
+int nodeid_to_name(int nodeid, char *name)
+{
+ struct node *node;
+
+ list_for_each_entry(node, &node_names, list) {
+ if (node->nodeid == nodeid) {
+ strncpy(name, node->name, MAX_NODENAME_LEN);
+ return 0;
+ }
+ }
+ return -1;
+}
+
+static void add_node_name(int nodeid, char *name)
+{
+ struct node *node;
+ char nm[BUFLEN];
+ int id;
+
+ if (!nodeid_to_name(nodeid, nm) ||
+ !name_to_nodeid(name, &id))
+ return;
+
+ node = malloc(sizeof(struct node));
+ if (!node)
+ return;
+ memset(node, 0, sizeof(struct node));
+
+ node->nodeid = nodeid;
+ strncpy(node->name, name, MAX_NODENAME_LEN);
+
+ list_add(&node->list, &node_names);
+}
+
+/* Note: this scheme breaks if node "foo" with nodeid 5 is removed and
+ later node "bar" with nodeid 5 is added. */
+
+static void read_ccs_nodes(void)
+{
+ char path[PATH_MAX];
+ char *str, *name;
+ int i, error;
+
+ for (i = 1; ; i++) {
+ str = NULL;
+ memset(path, 0, sizeof(path));
+ sprintf(path, "/cluster/clusternodes/clusternode[%d]/@nodeid", i);
+
+ error = ccs_get(ccs_handle, path, &str);
+ if (error || !str)
+ break;
+
+ name = NULL;
+ memset(path, 0, sizeof(path));
+ sprintf(path, "/cluster/clusternodes/clusternode[%d]/@name", i);
+
+ error = ccs_get(ccs_handle, path, &name);
+ if (error || !name) {
+ log_error("node name query failed for num %d nodeid %s",
+ i, str);
+ free(str);
+ break;
+ }
+
+ add_node_name(atoi(str), name);
+
+ free(str);
+ free(name);
+ }
+}
+
int setup_ccs(void)
{
int cd;
+ INIT_LIST_HEAD(&node_names);
+
cd = ccs_connect();
if (cd < 0) {
log_error("ccs_connect error %d %d", cd, errno);
@@ -35,6 +163,8 @@ int setup_ccs(void)
}
ccs_handle = cd;
+ read_ccs_nodes();
+
return 0;
}
@@ -135,37 +265,24 @@ void reread_ccs(void)
read_ccs_int(POST_FAIL_DELAY_PATH, &cfgd_post_fail_delay);
if (!optd_override_time)
read_ccs_int(OVERRIDE_TIME_PATH, &cfgd_override_time);
+
+ /* add any new nodes to the name/nodeid list */
+ read_ccs_nodes();
}
int read_ccs(struct fd *fd)
{
char path[PATH_MAX];
- char *str, *name;
- int error, i = 0, count = 0;
+ char *str;
+ int error, count = 0;
int num_methods;
+ struct node *node;
- /* Our own nodename must be in cluster.conf before we're allowed to
- join the fence domain and then mount gfs; other nodes need this to
- fence us. */
-
- str = NULL;
- memset(path, 0, sizeof(path));
- snprintf(path, sizeof(path), OUR_NAME_PATH, our_name);
-
- error = ccs_get(ccs_handle, path, &str);
- if (error || !str) {
- log_error("local cman node name \"%s\" not found in the "
- "configuration", our_name);
- return error;
- }
- if (str)
- free(str);
+ reread_ccs();
if (!optd_clean_start)
read_ccs_int(CLEAN_START_PATH, &cfgd_clean_start);
- reread_ccs();
-
if (!optd_override_path) {
str = NULL;
memset(path, 0, sizeof(path));
@@ -183,39 +300,18 @@ int read_ccs(struct fd *fd)
goto out;
}
- for (i = 1; ; i++) {
- str = NULL;
- memset(path, 0, sizeof(path));
- sprintf(path, "/cluster/clusternodes/clusternode[%d]/@nodeid", i);
-
- error = ccs_get(ccs_handle, path, &str);
- if (error || !str)
- break;
-
- name = NULL;
- memset(path, 0, sizeof(path));
- sprintf(path, "/cluster/clusternodes/clusternode[%d]/@name", i);
-
- error = ccs_get(ccs_handle, path, &name);
- if (error || !name) {
- log_error("node name query failed for num %d nodeid %s",
- i, str);
- break;
- }
-
- num_methods = count_methods(name);
+ list_for_each_entry(node, &node_names, list) {
+ num_methods = count_methods(node->name);
/* the libcpg code only uses the fd->complete list for
- determining initial victims; the libgroup code uses
+ determining initial victims; the libgroup code used
fd->complete more extensively */
if (cfgd_skip_undefined && !num_methods)
- log_debug("skip %s with zero methods", name);
+ log_debug("skip %s with zero methods", node->name);
else
- add_complete_node(fd, atoi(str));
+ add_complete_node(fd, node->nodeid);
- free(str);
- free(name);
count++;
}
diff --git a/fence/fenced/cpg.c b/fence/fenced/cpg.c
index ead60dd..dc9e54c 100644
--- a/fence/fenced/cpg.c
+++ b/fence/fenced/cpg.c
@@ -541,10 +541,10 @@ static int check_quorum_done(struct fd *fd)
if (!node->check_quorum)
continue;
- if (!is_cman_member(node->nodeid)) {
+ if (!is_cluster_member(node->nodeid)) {
node->check_quorum = 0;
} else {
- log_debug("check_quorum %d is_cman_member",
+ log_debug("check_quorum %d is_cluster_member",
node->nodeid);
wait_count++;
}
@@ -553,7 +553,7 @@ static int check_quorum_done(struct fd *fd)
if (wait_count)
return 0;
- if (!cman_quorate) {
+ if (!cluster_quorate) {
log_debug("check_quorum not quorate");
return 0;
}
@@ -1055,7 +1055,9 @@ static void apply_changes(struct fd *fd)
fence_victims(fd);
send_complete(fd);
} else {
- defer_fencing(fd);
+ if (!list_empty(&fd->victims))
+ log_level(LOG_INFO, "fencing deferred "
+ "to nodeid %d", fd->master);
}
cleanup_changes(fd);
@@ -1183,7 +1185,7 @@ static void add_victims_init(struct fd *fd, struct change *cg)
list_for_each_entry_safe(node, safe, &fd->complete, list) {
list_del(&node->list);
- if (!is_cman_member(node->nodeid) &&
+ if (!is_cluster_member(node->nodeid) &&
!find_memb(cg, node->nodeid) &&
!is_victim(fd, node->nodeid)) {
node->init_victim = 1;
diff --git a/fence/fenced/fd.h b/fence/fenced/fd.h
index 2dd9418..a89b1fc 100644
--- a/fence/fenced/fd.h
+++ b/fence/fenced/fd.h
@@ -58,9 +58,8 @@ extern int daemon_debug_opt;
extern int daemon_quit;
extern int cluster_down;
extern struct list_head domains;
-extern int cman_quorate;
+extern int cluster_quorate;
extern int our_nodeid;
-extern char our_name[MAX_NODENAME_LEN+1];
extern char daemon_debug_buf[256];
extern char dump_buf[FENCED_DUMP_SIZE];
extern int dump_point;
@@ -179,6 +178,8 @@ void read_ccs_name(char *path, char *name);
void read_ccs_yesno(char *path, int *yes, int *no);
void read_ccs_int(char *path, int *config_val);
int read_ccs(struct fd *fd);
+int nodeid_to_name(int nodeid, char *name);
+int name_to_nodeid(char *name, int *nodeid);
/* cpg.c */
@@ -213,15 +214,15 @@ void cluster_dead(int ci);
/* member_cman.c */
-void process_cman(int ci);
-int setup_cman(void);
-void close_cman(void);
-int is_cman_member(int nodeid);
-char *nodeid_to_name(int nodeid);
-int name_to_nodeid(char *name);
-struct node *get_new_node(struct fd *fd, int nodeid);
+int setup_cluster(void);
+void close_cluster(void);
+void process_cluster(int ci);
+void update_cluster(void);
+int is_cluster_member(int nodeid);
+int setup_cluster_cfg(void);
+void close_cluster_cfg(void);
+void process_cluster_cfg(int ci);
void kick_node_from_cluster(int nodeid);
-void set_cman_dirty(void);
/* recover.c */
@@ -230,8 +231,8 @@ void add_complete_node(struct fd *fd, int nodeid);
int list_count(struct list_head *head);
int is_victim(struct fd *fd, int nodeid);
void delay_fencing(struct fd *fd, int node_join);
-void defer_fencing(struct fd *fd);
void fence_victims(struct fd *fd);
+struct node *get_new_node(struct fd *fd, int nodeid);
/* logging.c */
diff --git a/fence/fenced/main.c b/fence/fenced/main.c
index 411d504..451db6c 100644
--- a/fence/fenced/main.c
+++ b/fence/fenced/main.c
@@ -189,7 +189,9 @@ struct fd *find_fd(char *name)
dirty/disallowed, we'd skip fencing a node after a merge of a partition
since the merged node would be a cman member and a fenced:daemon cpg member.
By setting the dirty flag, cman won't report a dirty merged node as a
- member, so we'll continue fencing it. */
+ member, so we'll continue fencing it. Note: the prev statement is no
+ longer true since we now only skip fencing a node after it has joined the
+ cluster *and* joined the fence domain. */
static int do_join(char *name)
{
@@ -216,8 +218,6 @@ static int do_join(char *name)
}
rv = fd_join(fd);
- if (!rv)
- set_cman_dirty();
out:
return rv;
}
@@ -238,12 +238,19 @@ static int do_leave(char *name)
static int do_external(char *name, char *extra, int extra_len)
{
struct fd *fd;
+ int nodeid, rv;
fd = find_fd(name);
if (!fd)
return -EINVAL;
- send_external(fd, name_to_nodeid(extra));
+ rv = name_to_nodeid(extra, &nodeid);
+ if (rv < 0) {
+ log_error("do_external: no nodeid for %s", extra);
+ return -1;
+ }
+
+ send_external(fd, nodeid);
return 0;
}
@@ -713,10 +720,15 @@ static void loop(void)
goto out;
client_add(rv, process_listener, NULL);
- rv = setup_cman();
+ rv = setup_cluster_cfg();
+ if (rv < 0)
+ goto out;
+ client_add(rv, process_cluster_cfg, cluster_dead);
+
+ rv = setup_cluster();
if (rv < 0)
goto out;
- client_add(rv, process_cman, cluster_dead);
+ client_add(rv, process_cluster, cluster_dead);
rv = setup_ccs();
if (rv < 0)
@@ -773,7 +785,8 @@ static void loop(void)
close_cpg();
close_logging();
close_ccs();
- close_cman();
+ close_cluster();
+ close_cluster_cfg();
if (!list_empty(&domains))
log_error("domain abandoned");
@@ -997,9 +1010,8 @@ int daemon_debug_opt;
int daemon_quit;
int cluster_down;
struct list_head domains;
-int cman_quorate;
+int cluster_quorate;
int our_nodeid;
-char our_name[MAX_NODENAME_LEN+1];
char daemon_debug_buf[256];
char dump_buf[FENCED_DUMP_SIZE];
int dump_point;
diff --git a/fence/fenced/member_cman.c b/fence/fenced/member_cman.c
index fd0d9e1..9e52429 100644
--- a/fence/fenced/member_cman.c
+++ b/fence/fenced/member_cman.c
@@ -1,272 +1,202 @@
#include "fd.h"
#include "config.h"
-#include <libcman.h>
+#include <corosync/corotypes.h>
+#include <corosync/cfg.h>
+#include <corosync/votequorum.h>
-#define BUFLEN MAX_NODENAME_LEN+1
-
-static cman_handle_t ch;
-static cman_handle_t ch_admin;
-static cman_node_t cman_nodes[MAX_NODES];
-static int cman_node_count;
-
-void set_cman_dirty(void)
-{
- int rv;
-
- rv = cman_set_dirty(ch_admin);
- if (rv)
- log_error("cman_set_dirty error %d", rv);
-}
+static corosync_cfg_handle_t ch;
+static votequorum_handle_t qh;
+static votequorum_node_t quorum_nodes[MAX_NODES];
+static int quorum_node_count;
void kick_node_from_cluster(int nodeid)
{
if (!nodeid) {
- log_error("telling cman to shut down cluster locally");
- cman_shutdown(ch_admin, CMAN_SHUTDOWN_ANYWAY);
+ log_error("telling corosync to shut down cluster locally");
+ corosync_cfg_try_shutdown(ch,
+ COROSYNC_CFG_SHUTDOWN_FLAG_IMMEDIATE);
} else {
- log_error("telling cman to remove nodeid %d from cluster",
+ log_error("telling corosync to remove nodeid %d from cluster",
nodeid);
- cman_kill_node(ch_admin, nodeid);
+ corosync_cfg_kill_node(ch, nodeid, "dlm_controld");
}
}
-static int name_equal(char *name1, char *name2)
+static int is_member(votequorum_node_t *node_list, int count, int nodeid)
{
- char name3[BUFLEN], name4[BUFLEN];
- int i, len1, len2;
-
- len1 = strlen(name1);
- len2 = strlen(name2);
-
- if (len1 == len2 && !strncmp(name1, name2, len1))
- return 1;
-
- memset(name3, 0, BUFLEN);
- memset(name4, 0, BUFLEN);
-
- for (i = 0; i < BUFLEN && i < len1; i++) {
- if (name1[i] != '.')
- name3[i] = name1[i];
- else
- break;
- }
+ int i;
- for (i = 0; i < BUFLEN && i < len2; i++) {
- if (name2[i] != '.')
- name4[i] = name2[i];
- else
- break;
+ for (i = 0; i < count; i++) {
+ if (node_list[i].nodeid == nodeid)
+ return (node_list[i].state == NODESTATE_MEMBER);
}
-
- len1 = strlen(name3);
- len2 = strlen(name4);
-
- if (len1 == len2 && !strncmp(name3, name4, len1))
- return 1;
-
return 0;
}
-static cman_node_t *find_cman_node_name(char *name)
+int is_cluster_member(int nodeid)
{
- int i;
+ int rv;
- for (i = 0; i < cman_node_count; i++) {
- if (name_equal(cman_nodes[i].cn_name, name))
- return &cman_nodes[i];
- }
- return NULL;
-}
+ /* Note: in fence delay loop we aren't processing callbacks so won't
+ have dispatched any votequorum callbacks */
+ update_cluster();
-static cman_node_t *find_cman_node(int nodeid)
-{
- int i;
+ rv = is_member(quorum_nodes, quorum_node_count, nodeid);
- for (i = 0; i < cman_node_count; i++) {
- if (cman_nodes[i].cn_nodeid == nodeid)
- return &cman_nodes[i];
- }
- return NULL;
+ if (!rv)
+ log_debug("nodeid %d not a cluster member", nodeid);
+ return rv;
}
-char *nodeid_to_name(int nodeid)
+static void quorum_callback(votequorum_handle_t h, uint64_t context,
+ uint32_t quorate, uint32_t node_list_entries,
+ votequorum_node_t node_list[])
{
- cman_node_t *cn;
-
- cn = find_cman_node(nodeid);
- if (cn)
- return cn->cn_name;
+ int prev_quorate = cluster_quorate;
+ int i;
- return "unknown";
-}
+ cluster_quorate = quorate;
-int name_to_nodeid(char *name)
-{
- cman_node_t *cn;
+ quorum_node_count = 0;
+ memset(&quorum_nodes, 0, sizeof(quorum_nodes));
- cn = find_cman_node_name(name);
- if (cn)
- return cn->cn_nodeid;
+ for (i = 0; i < node_list_entries; i++) {
+ if (node_list[i].state == NODESTATE_MEMBER) {
+ memcpy(&quorum_nodes[quorum_node_count],
+ &node_list[i], sizeof(votequorum_node_t));
+ quorum_node_count++;
+ }
+ }
- return -1;
+ /* domain may have been waiting for quorum */
+ if (!prev_quorate && cluster_quorate)
+ process_fd_changes();
}
-static void statechange(void)
+static votequorum_callbacks_t quorum_callbacks =
{
- int rv;
-
- cman_quorate = cman_is_quorate(ch);
- cman_node_count = 0;
- memset(&cman_nodes, 0, sizeof(cman_nodes));
+ .votequorum_notify_fn = quorum_callback,
+};
- rv = cman_get_nodes(ch, MAX_NODES, &cman_node_count, cman_nodes);
- if (rv < 0)
- log_error("cman_get_nodes error %d %d", rv, errno);
-}
-
-static void cman_callback(cman_handle_t h, void *private, int reason, int arg)
+void process_cluster(int ci)
{
- int quorate = cman_quorate;
-
- switch (reason) {
- case CMAN_REASON_TRY_SHUTDOWN:
- if (list_empty(&domains))
- cman_replyto_shutdown(ch, 1);
- else {
- log_debug("no to cman shutdown");
- cman_replyto_shutdown(ch, 0);
- }
- break;
- case CMAN_REASON_STATECHANGE:
- statechange();
+ cs_error_t err;
- /* domain may have been waiting for quorum */
- if (!quorate && cman_quorate)
- process_fd_changes();
- break;
-
- case CMAN_REASON_CONFIG_UPDATE:
- setup_logging();
- reread_ccs();
- break;
- }
+ err = votequorum_dispatch(qh, CS_DISPATCH_ALL);
+ if (err != CS_OK)
+ cluster_dead(0);
}
-void process_cman(int ci)
+/* Force re-read of quorum nodes */
+void update_cluster(void)
{
- int rv;
+ cs_error_t err;
- rv = cman_dispatch(ch, CMAN_DISPATCH_ALL);
- if (rv == -1 && errno == EHOSTDOWN)
+ err = votequorum_dispatch(qh, CS_DISPATCH_ONE);
+ if (err != CS_OK)
cluster_dead(0);
}
-int setup_cman(void)
+int setup_cluster(void)
{
- cman_node_t node;
- int rv, fd;
- int init = 0, active = 0;
-
- retry_init:
- ch_admin = cman_admin_init(NULL);
- if (!ch_admin) {
- if (init++ < 2) {
- sleep(1);
- goto retry_init;
- }
- log_error("cman_admin_init error %d", errno);
- return -ENOTCONN;
- }
-
- ch = cman_init(NULL);
- if (!ch) {
- log_error("cman_init error %d", errno);
- return -ENOTCONN;
- }
+ struct votequorum_info qinfo;
+ cs_error_t err;
+ int fd, rv;
- retry_active:
- rv = cman_is_active(ch);
- if (!rv) {
- if (active++ < 2) {
- sleep(1);
- goto retry_active;
- }
- log_error("cman_is_active error %d", errno);
- cman_finish(ch);
- return -ENOTCONN;
- }
+ err = votequorum_initialize(&qh, &quorum_callbacks);
+ if (err != CS_OK)
+ return -1;
- rv = cman_start_notification(ch, cman_callback);
- if (rv < 0) {
- log_error("cman_start_notification error %d %d", rv, errno);
- cman_finish(ch);
- return rv;
- }
+ err = votequorum_fd_get(qh, &fd);
+ if (err != CS_OK)
+ goto fail;
- statechange();
+ err = votequorum_getinfo(qh, 0, &qinfo);
+ if (err != CS_OK)
+ goto fail;
+ our_nodeid = qinfo.node_id;
+ log_debug("our_nodeid %d", our_nodeid);
- fd = cman_get_fd(ch);
+ err = votequorum_trackstart(qh, 0, CS_TRACK_CURRENT);
+ if (err != CS_OK)
+ goto fail;
- /* FIXME: wait here for us to be a member of the cluster */
- memset(&node, 0, sizeof(node));
- rv = cman_get_node(ch, CMAN_NODEID_US, &node);
- if (rv < 0) {
- log_error("cman_get_node us error %d %d", rv, errno);
- cman_finish(ch);
- fd = rv;
- goto out;
- }
+ quorum_node_count = 0;
+ memset(&quorum_nodes, 0, sizeof(quorum_nodes));
- memset(our_name, 0, sizeof(our_name));
- strncpy(our_name, node.cn_name, CMAN_MAX_NODENAME_LEN);
- our_nodeid = node.cn_nodeid;
+ update_cluster();
- log_debug("our_nodeid %d our_name %s", our_nodeid, our_name);
- out:
return fd;
+ fail:
+ votequorum_finalize(qh);
+ return -1;
}
-void close_cman(void)
+void close_cluster(void)
{
- cman_finish(ch);
+ votequorum_trackstop(qh);
+ votequorum_finalize(qh);
}
-int is_cman_member(int nodeid)
+static void shutdown_callback(corosync_cfg_handle_t h,
+ corosync_cfg_shutdown_flags_t flags)
{
- cman_node_t *cn;
+ if (flags & COROSYNC_CFG_SHUTDOWN_FLAG_REQUEST) {
+ if (list_empty(&domains))
+ corosync_cfg_replyto_shutdown(ch,
+ COROSYNC_CFG_SHUTDOWN_FLAG_YES);
+ else {
+ log_debug("no to corosync shutdown");
+ corosync_cfg_replyto_shutdown(ch,
+ COROSYNC_CFG_SHUTDOWN_FLAG_NO);
+ }
+ }
+}
- /* Note: in fence delay loop we aren't processing callbacks so won't
- have done a statechange() in response to a cman callback */
- statechange();
+static corosync_cfg_callbacks_t cfg_callbacks =
+{
+ .corosync_cfg_shutdown_callback = shutdown_callback,
+ .corosync_cfg_state_track_callback = NULL,
+};
- cn = find_cman_node(nodeid);
- if (cn && cn->cn_member)
- return 1;
- log_debug("node %d not a cman member, cn %d", nodeid, cn ? 1 : 0);
- return 0;
+void process_cluster_cfg(int ci)
+{
+ cs_error_t err;
+
+ err = corosync_cfg_dispatch(ch, CS_DISPATCH_ALL);
+ if (err != CS_OK)
+ cluster_dead(0);
}
-struct node *get_new_node(struct fd *fd, int nodeid)
+int setup_cluster_cfg(void)
{
- cman_node_t cn;
- struct node *node;
- int rv;
+ cs_error_t err;
+ int fd;
- node = malloc(sizeof(*node));
- if (!node)
- return NULL;
- memset(node, 0, sizeof(struct node));
+ err = corosync_cfg_initialize(&ch, &cfg_callbacks);
+ if (err != CS_OK)
+ return -1;
- node->nodeid = nodeid;
+ err = corosync_cfg_fd_get(ch, &fd);
+ if (err != CS_OK) {
+ corosync_cfg_finalize(ch);
+ return -1;
+ }
- memset(&cn, 0, sizeof(cn));
- rv = cman_get_node(ch, nodeid, &cn);
- if (rv < 0)
- log_debug("get_new_node %d no cman node %d", nodeid, rv);
- else
- strncpy(node->name, cn.cn_name, MAX_NODENAME_LEN);
+ return fd;
+}
- return node;
+void close_cluster_cfg(void)
+{
+ corosync_cfg_finalize(ch);
}
+/* what replaces this? */
+#if 0
+ case CMAN_REASON_CONFIG_UPDATE:
+ setup_logging();
+ reread_ccs();
+ break;
+#endif
+
diff --git a/fence/fenced/recover.c b/fence/fenced/recover.c
index 1a628bf..4251d5e 100644
--- a/fence/fenced/recover.c
+++ b/fence/fenced/recover.c
@@ -1,6 +1,25 @@
#include "fd.h"
#include "config.h"
+struct node *get_new_node(struct fd *fd, int nodeid)
+{
+ struct node *node;
+ int rv;
+
+ node = malloc(sizeof(*node));
+ if (!node)
+ return NULL;
+ memset(node, 0, sizeof(struct node));
+
+ node->nodeid = nodeid;
+
+ rv = nodeid_to_name(nodeid, node->name);
+ if (rv < 0)
+ log_debug("get_new_node no name for nodeid %d", nodeid);
+
+ return node;
+}
+
void free_node_list(struct list_head *head)
{
struct node *node;
@@ -59,7 +78,7 @@ static int reduce_victims(struct fd *fd)
num_victims = list_count(&fd->victims);
list_for_each_entry_safe(node, safe, &fd->victims, list) {
- if (is_cman_member(node->nodeid) &&
+ if (is_cluster_member(node->nodeid) &&
in_daemon_member_list(node->nodeid)) {
log_debug("reduce victim %s", node->name);
victim_done(fd, node->nodeid, VIC_DONE_MEMBER);
@@ -227,24 +246,12 @@ void delay_fencing(struct fd *fd, int node_join)
}
}
-void defer_fencing(struct fd *fd)
-{
- char *master_name;
-
- if (list_empty(&fd->victims))
- return;
-
- master_name = nodeid_to_name(fd->master);
-
- log_level(LOG_INFO, "fencing deferred to %s", master_name);
-}
-
void fence_victims(struct fd *fd)
{
struct node *node;
int error;
int override = -1;
- int cman_member, cpg_member, ext;
+ int cluster_member, cpg_member, ext;
while (!list_empty(&fd->victims)) {
node = list_entry(fd->victims.next, struct node, list);
@@ -252,14 +259,14 @@ void fence_victims(struct fd *fd)
/* for queries */
fd->current_victim = node->nodeid;
- cman_member = is_cman_member(node->nodeid);
+ cluster_member = is_cluster_member(node->nodeid);
cpg_member = in_daemon_member_list(node->nodeid);
ext = is_fenced_external(fd, node->nodeid);
- if ((cman_member && cpg_member) || ext) {
+ if ((cluster_member && cpg_member) || ext) {
log_debug("averting fence of node %s "
- "cman member %d cpg member %d external %d",
- node->name, cman_member, cpg_member, ext);
+ "cluster member %d cpg member %d external %d",
+ node->name, cluster_member, cpg_member, ext);
victim_done(fd, node->nodeid,
ext ? VIC_DONE_EXTERNAL : VIC_DONE_MEMBER);
list_del(&node->list);