static void
_cs_quorum_init(void)
{
cs_error_t rc;
uint32_t quorum_type;
int fd;
quorum_callbacks_t quorum_callbacks = {
.quorum_notify_fn = _cs_quorum_notification,
};
rc = quorum_initialize (&quorum_handle, &quorum_callbacks,
&quorum_type);
if (rc != CS_OK) {
qb_log(LOG_ERR, "Could not connect to corosync(quorum)");
return;
}
quorum_fd_get(quorum_handle, &fd);
qb_loop_poll_add(main_loop, QB_LOOP_MED, fd, POLLIN|POLLNVAL, NULL,
_cs_quorum_dispatch);
rc = quorum_trackstart(quorum_handle, CS_TRACK_CHANGES);
if (rc != CS_OK) {
qb_log(LOG_ERR, "Could not start tracking");
return;
}
}
int setup_cluster(void)
{
cs_error_t err;
int fd;
err = quorum_initialize(&qh, &quorum_callbacks);
if (err != CS_OK) {
log_error("quorum init error %d", err);
return -1;
}
err = quorum_fd_get(qh, &fd);
if (err != CS_OK) {
log_error("quorum fd_get error %d", err);
goto fail;
}
err = quorum_trackstart(qh, CS_TRACK_CURRENT);
if (err != CS_OK) {
log_error("quorum trackstart error %d", err);
goto fail;
}
old_node_count = 0;
memset(&old_nodes, 0, sizeof(old_nodes));
quorum_node_count = 0;
memset(&quorum_nodes, 0, sizeof(quorum_nodes));
return fd;
fail:
quorum_finalize(qh);
return -1;
}
gboolean
cluster_connect_quorum(gboolean(*dispatch) (unsigned long long, gboolean),
void (*destroy) (gpointer))
{
int rc = -1;
int fd = 0;
int quorate = 0;
uint32_t quorum_type = 0;
struct mainloop_fd_callbacks quorum_fd_callbacks;
quorum_fd_callbacks.dispatch = pcmk_quorum_dispatch;
quorum_fd_callbacks.destroy = destroy;
crm_debug("Configuring Pacemaker to obtain quorum from Corosync");
rc = quorum_initialize(&pcmk_quorum_handle, &quorum_callbacks, &quorum_type);
if (rc != CS_OK) {
crm_err("Could not connect to the Quorum API: %d\n", rc);
goto bail;
} else if (quorum_type != QUORUM_SET) {
crm_err("Corosync quorum is not configured\n");
goto bail;
}
rc = quorum_getquorate(pcmk_quorum_handle, &quorate);
if (rc != CS_OK) {
crm_err("Could not obtain the current Quorum API state: %d\n", rc);
goto bail;
}
crm_notice("Quorum %s", quorate ? "acquired" : "lost");
quorum_app_callback = dispatch;
crm_have_quorum = quorate;
rc = quorum_trackstart(pcmk_quorum_handle, CS_TRACK_CHANGES | CS_TRACK_CURRENT);
if (rc != CS_OK) {
crm_err("Could not setup Quorum API notifications: %d\n", rc);
goto bail;
}
rc = quorum_fd_get(pcmk_quorum_handle, &fd);
if (rc != CS_OK) {
crm_err("Could not obtain the Quorum API connection: %d\n", rc);
goto bail;
}
mainloop_add_fd("quorum", G_PRIORITY_HIGH, fd, dispatch, &quorum_fd_callbacks);
corosync_initialize_nodelist(NULL, FALSE, NULL);
bail:
if (rc != CS_OK) {
quorum_finalize(pcmk_quorum_handle);
return FALSE;
}
return TRUE;
}
static int q_lib_init(void)
{
votequorum_callbacks_t vq_callbacks;
quorum_callbacks_t q_callbacks;
int ret = 0;
int retry = 3;
int fd;
if (vq_handle == 0) {
qb_log (LOG_INFO, "votequorum_initialize");
vq_callbacks.votequorum_notify_fn = votequorum_notification_fn;
vq_callbacks.votequorum_expectedvotes_notify_fn = NULL;
ret = CS_ERR_NOT_EXIST;
while (ret == CS_ERR_NOT_EXIST && retry > 0) {
ret = votequorum_initialize (&vq_handle, &vq_callbacks);
if (ret == CS_ERR_NOT_EXIST) {
sleep (1);
retry--;
}
}
if (ret != CS_OK) {
qb_log (LOG_ERR, "votequorum_initialize FAILED: %d", ret);
vq_handle = 0;
}
else {
ret = votequorum_trackstart (vq_handle, vq_handle, CS_TRACK_CHANGES);
if (ret != CS_OK) {
qb_log (LOG_ERR, "votequorum_trackstart FAILED: %d", ret);
}
votequorum_fd_get (vq_handle, &fd);
qb_loop_poll_add (ta_poll_handle_get(), QB_LOOP_MED, fd,
POLLIN|POLLNVAL, NULL, vq_dispatch_wrapper_fn);
}
}
if (q_handle == 0) {
uint32_t q_type;
qb_log (LOG_INFO, "quorum_initialize");
q_callbacks.quorum_notify_fn = quorum_notification_fn;
ret = quorum_initialize (&q_handle, &q_callbacks, &q_type);
if (ret != CS_OK) {
qb_log (LOG_ERR, "quorum_initialize FAILED: %d", ret);
q_handle = 0;
}
else {
ret = quorum_trackstart (q_handle, CS_TRACK_CHANGES);
if (ret != CS_OK) {
qb_log (LOG_ERR, "quorum_trackstart FAILED: %d", ret);
}
quorum_fd_get (q_handle, &fd);
qb_loop_poll_add (ta_poll_handle_get(), QB_LOOP_MED, fd,
POLLIN|POLLNVAL, NULL, q_dispatch_wrapper_fn);
}
}
return ret;
}
cs_error_t sam_initialize (
int time_interval,
sam_recovery_policy_t recovery_policy)
{
quorum_callbacks_t quorum_callbacks;
cs_error_t err;
if (sam_internal_data.internal_status != SAM_INTERNAL_STATUS_NOT_INITIALIZED) {
return (CS_ERR_BAD_HANDLE);
}
if (SAM_RP_MASK (recovery_policy) != SAM_RECOVERY_POLICY_QUIT &&
SAM_RP_MASK (recovery_policy) != SAM_RECOVERY_POLICY_RESTART) {
return (CS_ERR_INVALID_PARAM);
}
if (recovery_policy & SAM_RECOVERY_POLICY_QUORUM) {
/*
* Initialize quorum
*/
quorum_callbacks.quorum_notify_fn = quorum_notification_fn;
if ((err = quorum_initialize (&sam_internal_data.quorum_handle, &quorum_callbacks)) != CS_OK) {
goto exit_error;
}
if ((err = quorum_trackstart (sam_internal_data.quorum_handle, CS_TRACK_CHANGES)) != CS_OK) {
goto exit_error_quorum;
}
if ((err = quorum_fd_get (sam_internal_data.quorum_handle, &sam_internal_data.quorum_fd)) != CS_OK) {
goto exit_error_quorum;
}
/*
* Dispatch initial quorate state
*/
if ((err = quorum_dispatch (sam_internal_data.quorum_handle, CS_DISPATCH_ONE)) != CS_OK) {
goto exit_error_quorum;
}
}
sam_internal_data.recovery_policy = recovery_policy;
sam_internal_data.time_interval = time_interval;
sam_internal_data.internal_status = SAM_INTERNAL_STATUS_INITIALIZED;
sam_internal_data.warn_signal = SIGTERM;
sam_internal_data.am_i_child = 0;
sam_internal_data.user_data = NULL;
sam_internal_data.user_data_size = 0;
sam_internal_data.user_data_allocated = 0;
pthread_mutex_init (&sam_internal_data.lock, NULL);
return (CS_OK);
exit_error_quorum:
quorum_finalize (sam_internal_data.quorum_handle);
exit_error:
return (err);
}
gboolean
cluster_connect_quorum(gboolean(*dispatch) (unsigned long long, gboolean),
void (*destroy) (gpointer))
{
cs_error_t rc;
int fd = 0;
int quorate = 0;
uint32_t quorum_type = 0;
struct mainloop_fd_callbacks quorum_fd_callbacks;
uid_t found_uid = 0;
gid_t found_gid = 0;
pid_t found_pid = 0;
int rv;
quorum_fd_callbacks.dispatch = pcmk_quorum_dispatch;
quorum_fd_callbacks.destroy = destroy;
crm_debug("Configuring Pacemaker to obtain quorum from Corosync");
rc = quorum_initialize(&pcmk_quorum_handle, &quorum_callbacks, &quorum_type);
if (rc != CS_OK) {
crm_err("Could not connect to the Quorum API: %s (%d)",
cs_strerror(rc), rc);
goto bail;
} else if (quorum_type != QUORUM_SET) {
crm_err("Corosync quorum is not configured");
goto bail;
}
rc = quorum_fd_get(pcmk_quorum_handle, &fd);
if (rc != CS_OK) {
crm_err("Could not obtain the Quorum API connection: %s (%d)",
strerror(rc), rc);
goto bail;
}
/* Quorum provider run as root (in given user namespace, anyway)? */
if (!(rv = crm_ipc_is_authentic_process(fd, (uid_t) 0,(gid_t) 0, &found_pid,
&found_uid, &found_gid))) {
crm_err("Quorum provider is not authentic:"
" process %lld (uid: %lld, gid: %lld)",
(long long) PCMK__SPECIAL_PID_AS_0(found_pid),
(long long) found_uid, (long long) found_gid);
rc = CS_ERR_ACCESS;
goto bail;
} else if (rv < 0) {
crm_err("Could not verify authenticity of Quorum provider: %s (%d)",
strerror(-rv), -rv);
rc = CS_ERR_ACCESS;
goto bail;
}
rc = quorum_getquorate(pcmk_quorum_handle, &quorate);
if (rc != CS_OK) {
crm_err("Could not obtain the current Quorum API state: %d", rc);
goto bail;
}
if (quorate) {
crm_notice("Quorum acquired");
} else {
crm_warn("Quorum lost");
}
quorum_app_callback = dispatch;
crm_have_quorum = quorate;
rc = quorum_trackstart(pcmk_quorum_handle, CS_TRACK_CHANGES | CS_TRACK_CURRENT);
if (rc != CS_OK) {
crm_err("Could not setup Quorum API notifications: %d", rc);
goto bail;
}
mainloop_add_fd("quorum", G_PRIORITY_HIGH, fd, dispatch, &quorum_fd_callbacks);
corosync_initialize_nodelist(NULL, FALSE, NULL);
bail:
if (rc != CS_OK) {
quorum_finalize(pcmk_quorum_handle);
return FALSE;
}
return TRUE;
}
