main.c
Go to the documentation of this file.
/*
* Copyright (c) 2002-2006 MontaVista Software, Inc.
* Copyright (c) 2006-2021 Red Hat, Inc.
*
* All rights reserved.
*
* Author: Steven Dake (sdake@redhat.com)
*
* This software licensed under BSD license, the text of which follows:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the MontaVista Software, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <config.h>
#include <pthread.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/poll.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <sched.h>
#include <time.h>
#include <semaphore.h>
#include <string.h>
#ifdef HAVE_LIBSYSTEMD
#include <systemd/sd-daemon.h>
#endif
#include <qb/qbdefs.h>
#include <qb/qblog.h>
#include <qb/qbloop.h>
#include <qb/qbutil.h>
#include <qb/qbipcs.h>
#include <corosync/swab.h>
#include <corosync/corotypes.h>
#include <corosync/corodefs.h>
#include <corosync/totem/totempg.h>
#include <corosync/logsys.h>
#include <corosync/icmap.h>
#include "quorum.h"
#include "totemsrp.h"
#include "logconfig.h"
#include "totemconfig.h"
#include "main.h"
#include "sync.h"
#include "timer.h"
#include "util.h"
#include "apidef.h"
#include "service.h"
#include "schedwrk.h"
#include "ipcs_stats.h"
#include "stats.h"
#ifdef HAVE_SMALL_MEMORY_FOOTPRINT
#define IPC_LOGSYS_SIZE 1024*64
#else
#define IPC_LOGSYS_SIZE 8192*128
#endif
/*
* LibQB adds default "*" syslog filter so we have to set syslog_priority as low
* as possible so filters applied later in _logsys_config_apply_per_file takes
* effect.
*/
LOGSYS_DECLARE_SYSTEM ("corosync",
LOGSYS_MODE_OUTPUT_STDERR | LOGSYS_MODE_OUTPUT_SYSLOG,
LOG_DAEMON,
LOG_EMERG);
LOGSYS_DECLARE_SUBSYS ("MAIN");
#define SERVER_BACKLOG 5
static int sched_priority = 0;
static unsigned int service_count = 32;
static struct totem_logging_configuration totem_logging_configuration;
static struct corosync_api_v1 *api = NULL;
static int sync_in_process = 1;
static qb_loop_t *corosync_poll_handle;
struct sched_param global_sched_param;
static corosync_timer_handle_t corosync_stats_timer_handle;
static const char *corosync_lock_file = LOCALSTATEDIR"/run/corosync.pid";
static char corosync_config_file[PATH_MAX + 1] = COROSYSCONFDIR "/corosync.conf";
static int lockfile_fd = -1;
enum move_to_root_cgroup_mode {
MOVE_TO_ROOT_CGROUP_MODE_OFF = 0,
MOVE_TO_ROOT_CGROUP_MODE_ON = 1,
MOVE_TO_ROOT_CGROUP_MODE_AUTO = 2,
};
qb_loop_t *cs_poll_handle_get (void)
{
return (corosync_poll_handle);
}
int cs_poll_dispatch_add (qb_loop_t * handle,
int fd,
int events,
void *data,
int (*dispatch_fn) (int fd,
int revents,
void *data))
{
return qb_loop_poll_add(handle, QB_LOOP_MED, fd, events, data,
dispatch_fn);
}
int cs_poll_dispatch_delete(qb_loop_t * handle, int fd)
{
return qb_loop_poll_del(handle, fd);
}
void corosync_state_dump (void)
{
int i;
for (i = 0; i < SERVICES_COUNT_MAX; i++) {
if (corosync_service[i] && corosync_service[i]->exec_dump_fn) {
corosync_service[i]->exec_dump_fn ();
}
}
}
const char *corosync_get_config_file(void)
{
return (corosync_config_file);
}
static void corosync_blackbox_write_to_file (void)
{
char fname[PATH_MAX];
char fdata_fname[PATH_MAX];
char time_str[PATH_MAX];
struct tm cur_time_tm;
time_t cur_time_t;
ssize_t res;
cur_time_t = time(NULL);
localtime_r(&cur_time_t, &cur_time_tm);
strftime(time_str, PATH_MAX, "%Y-%m-%dT%H:%M:%S", &cur_time_tm);
if (snprintf(fname, PATH_MAX, "%s/fdata-%s-%lld",
get_state_dir(),
time_str,
(long long int)getpid()) >= PATH_MAX) {
log_printf(LOGSYS_LEVEL_ERROR, "Can't snprintf blackbox file name");
return ;
}
if ((res = qb_log_blackbox_write_to_file(fname)) < 0) {
LOGSYS_PERROR(-res, LOGSYS_LEVEL_ERROR, "Can't store blackbox file");
return ;
}
snprintf(fdata_fname, sizeof(fdata_fname), "%s/fdata", get_state_dir());
unlink(fdata_fname);
if (symlink(fname, fdata_fname) == -1) {
log_printf(LOGSYS_LEVEL_ERROR, "Can't create symlink to '%s' for corosync blackbox file '%s'",
fname, fdata_fname);
}
}
static void unlink_all_completed (void)
{
api->timer_delete (corosync_stats_timer_handle);
qb_loop_stop (corosync_poll_handle);
icmap_fini();
}
void corosync_shutdown_request (void)
{
corosync_service_unlink_all (api, unlink_all_completed);
}
static int32_t sig_diag_handler (int num, void *data)
{
corosync_state_dump ();
return 0;
}
static int32_t sig_exit_handler (int num, void *data)
{
log_printf(LOGSYS_LEVEL_NOTICE, "Node was shut down by a signal");
corosync_service_unlink_all (api, unlink_all_completed);
return 0;
}
static void sigsegv_handler (int num)
{
(void)signal (num, SIG_DFL);
corosync_blackbox_write_to_file ();
qb_log_fini();
raise (num);
}
#define LOCALHOST_IP inet_addr("127.0.0.1")
static void *corosync_group_handle;
static struct totempg_group corosync_group = {
.group = "a",
.group_len = 1
};
static void serialize_lock (void)
{
}
static void serialize_unlock (void)
{
}
static void corosync_sync_completed (void)
{
log_printf (LOGSYS_LEVEL_NOTICE,
"Completed service synchronization, ready to provide service.");
sync_in_process = 0;
cs_ipcs_sync_state_changed(sync_in_process);
cs_ipc_allow_connections(1);
/*
* Inform totem to start using new message queue again
*/
totempg_trans_ack();
#ifdef HAVE_LIBSYSTEMD
sd_notify (0, "READY=1");
#endif
}
static int corosync_sync_callbacks_retrieve (
int service_id,
struct sync_callbacks *callbacks)
{
if (corosync_service[service_id] == NULL) {
return (-1);
}
if (callbacks == NULL) {
return (0);
}
callbacks->name = corosync_service[service_id]->name;
callbacks->sync_init = corosync_service[service_id]->sync_init;
callbacks->sync_process = corosync_service[service_id]->sync_process;
callbacks->sync_activate = corosync_service[service_id]->sync_activate;
callbacks->sync_abort = corosync_service[service_id]->sync_abort;
return (0);
}
static struct memb_ring_id corosync_ring_id;
static void member_object_joined (unsigned int nodeid)
{
char member_ip[ICMAP_KEYNAME_MAXLEN];
char member_join_count[ICMAP_KEYNAME_MAXLEN];
char member_status[ICMAP_KEYNAME_MAXLEN];
snprintf(member_ip, ICMAP_KEYNAME_MAXLEN,
"runtime.members.%u.ip", nodeid);
snprintf(member_join_count, ICMAP_KEYNAME_MAXLEN,
"runtime.members.%u.join_count", nodeid);
snprintf(member_status, ICMAP_KEYNAME_MAXLEN,
"runtime.members.%u.status", nodeid);
if (icmap_get(member_ip, NULL, NULL, NULL) == CS_OK) {
icmap_inc(member_join_count);
icmap_set_string(member_status, "joined");
} else {
icmap_set_string(member_ip, (char*)api->totem_ifaces_print (nodeid));
icmap_set_uint32(member_join_count, 1);
icmap_set_string(member_status, "joined");
}
log_printf (LOGSYS_LEVEL_DEBUG,
"Member joined: %s", api->totem_ifaces_print (nodeid));
}
static void member_object_left (unsigned int nodeid)
{
char member_status[ICMAP_KEYNAME_MAXLEN];
snprintf(member_status, ICMAP_KEYNAME_MAXLEN,
"runtime.members.%u.status", nodeid);
icmap_set_string(member_status, "left");
log_printf (LOGSYS_LEVEL_DEBUG,
"Member left: %s", api->totem_ifaces_print (nodeid));
}
static void confchg_fn (
enum totem_configuration_type configuration_type,
const unsigned int *member_list, size_t member_list_entries,
const unsigned int *left_list, size_t left_list_entries,
const unsigned int *joined_list, size_t joined_list_entries,
const struct memb_ring_id *ring_id)
{
int i;
int abort_activate = 0;
if (sync_in_process == 1) {
abort_activate = 1;
}
sync_in_process = 1;
cs_ipcs_sync_state_changed(sync_in_process);
memcpy (&corosync_ring_id, ring_id, sizeof (struct memb_ring_id));
for (i = 0; i < left_list_entries; i++) {
member_object_left (left_list[i]);
}
for (i = 0; i < joined_list_entries; i++) {
member_object_joined (joined_list[i]);
}
/*
* Call configuration change for all services
*/
for (i = 0; i < service_count; i++) {
if (corosync_service[i] && corosync_service[i]->confchg_fn) {
corosync_service[i]->confchg_fn (configuration_type,
member_list, member_list_entries,
left_list, left_list_entries,
joined_list, joined_list_entries, ring_id);
}
}
if (abort_activate) {
sync_abort ();
}
if (configuration_type == TOTEM_CONFIGURATION_TRANSITIONAL) {
sync_save_transitional (member_list, member_list_entries, ring_id);
}
if (configuration_type == TOTEM_CONFIGURATION_REGULAR) {
sync_start (member_list, member_list_entries, ring_id);
}
}
static void priv_drop (void)
{
return; /* TODO: we are still not dropping privs */
}
static void corosync_tty_detach (void)
{
int devnull;
/*
* Disconnect from TTY if this is not a debug run
*/
switch (fork ()) {
case -1:
corosync_exit_error (COROSYNC_DONE_FORK);
break;
case 0:
/*
* child which is disconnected, run this process
*/
break;
default:
exit (0);
break;
}
/* Create new session */
(void)setsid();
/*
* Map stdin/out/err to /dev/null.
*/
devnull = open("/dev/null", O_RDWR);
if (devnull == -1) {
corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR);
}
if (dup2(devnull, 0) < 0 || dup2(devnull, 1) < 0
|| dup2(devnull, 2) < 0) {
close(devnull);
corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR);
}
close(devnull);
}
static void corosync_mlockall (void)
{
int res;
struct rlimit rlimit;
rlimit.rlim_cur = RLIM_INFINITY;
rlimit.rlim_max = RLIM_INFINITY;
#ifndef RLIMIT_MEMLOCK
#define RLIMIT_MEMLOCK RLIMIT_VMEM
#endif
res = setrlimit (RLIMIT_MEMLOCK, &rlimit);
if (res == -1) {
LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING,
"Could not increase RLIMIT_MEMLOCK, not locking memory");
return;
}
res = mlockall (MCL_CURRENT | MCL_FUTURE);
if (res == -1) {
LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING,
"Could not lock memory of service to avoid page faults");
};
}
static void corosync_totem_stats_updater (void *data)
{
totempg_stats_t * stats;
uint32_t total_mtt_rx_token;
uint32_t total_backlog_calc;
uint32_t total_token_holdtime;
int t, prev;
int32_t token_count;
const char *cstr;
stats = api->totem_get_stats();
stats->srp->firewall_enabled_or_nic_failure = stats->srp->continuous_gather > MAX_NO_CONT_GATHER ? 1 : 0;
if (stats->srp->continuous_gather > MAX_NO_CONT_GATHER ||
stats->srp->continuous_sendmsg_failures > MAX_NO_CONT_SENDMSG_FAILURES) {
cstr = "";
if (stats->srp->continuous_sendmsg_failures > MAX_NO_CONT_SENDMSG_FAILURES) {
cstr = "number of multicast sendmsg failures is above threshold";
}
if (stats->srp->continuous_gather > MAX_NO_CONT_GATHER) {
cstr = "totem is continuously in gather state";
}
log_printf (LOGSYS_LEVEL_WARNING,
"Totem is unable to form a cluster because of an "
"operating system or network fault (reason: %s). The most common "
"cause of this message is that the local firewall is "
"configured improperly.", cstr);
stats->srp->firewall_enabled_or_nic_failure = 1;
} else {
stats->srp->firewall_enabled_or_nic_failure = 0;
}
total_mtt_rx_token = 0;
total_token_holdtime = 0;
total_backlog_calc = 0;
token_count = 0;
t = stats->srp->latest_token;
while (1) {
if (t == 0)
prev = TOTEM_TOKEN_STATS_MAX - 1;
else
prev = t - 1;
if (prev == stats->srp->earliest_token)
break;
/* if tx == 0, then dropped token (not ours) */
if (stats->srp->token[t].tx != 0 ||
(stats->srp->token[t].rx - stats->srp->token[prev].rx) > 0 ) {
total_mtt_rx_token += (stats->srp->token[t].rx - stats->srp->token[prev].rx);
total_token_holdtime += (stats->srp->token[t].tx - stats->srp->token[t].rx);
total_backlog_calc += stats->srp->token[t].backlog_calc;
token_count++;
}
t = prev;
}
if (token_count) {
stats->srp->mtt_rx_token = (total_mtt_rx_token / token_count);
stats->srp->avg_token_workload = (total_token_holdtime / token_count);
stats->srp->avg_backlog_calc = (total_backlog_calc / token_count);
}
stats->srp->time_since_token_last_received = qb_util_nano_current_get () / QB_TIME_NS_IN_MSEC -
stats->srp->token[stats->srp->latest_token].rx;
stats_trigger_trackers();
api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL,
corosync_totem_stats_updater,
&corosync_stats_timer_handle);
}
static void corosync_totem_stats_init (void)
{
/* start stats timer */
api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL,
corosync_totem_stats_updater,
&corosync_stats_timer_handle);
}
static void deliver_fn (
unsigned int nodeid,
const void *msg,
unsigned int msg_len,
int endian_conversion_required)
{
const struct qb_ipc_request_header *header;
int32_t service;
int32_t fn_id;
uint32_t id;
header = msg;
if (endian_conversion_required) {
id = swab32 (header->id);
} else {
id = header->id;
}
/*
* Call the proper executive handler
*/
service = id >> 16;
fn_id = id & 0xffff;
if (!corosync_service[service]) {
return;
}
if (fn_id >= corosync_service[service]->exec_engine_count) {
log_printf(LOGSYS_LEVEL_WARNING, "discarded unknown message %d for service %d (max id %d)",
fn_id, service, corosync_service[service]->exec_engine_count);
return;
}
icmap_fast_inc(service_stats_rx[service][fn_id]);
if (endian_conversion_required) {
assert(corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn != NULL);
corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn
((void *)msg);
}
corosync_service[service]->exec_engine[fn_id].exec_handler_fn
(msg, nodeid);
}
int main_mcast (
const struct iovec *iovec,
unsigned int iov_len,
unsigned int guarantee)
{
const struct qb_ipc_request_header *req = iovec->iov_base;
int32_t service;
int32_t fn_id;
service = req->id >> 16;
fn_id = req->id & 0xffff;
if (corosync_service[service]) {
icmap_fast_inc(service_stats_tx[service][fn_id]);
}
return (totempg_groups_mcast_joined (corosync_group_handle, iovec, iov_len, guarantee));
}
static void corosync_ring_id_create_or_load (
struct memb_ring_id *memb_ring_id,
unsigned int nodeid)
{
int fd;
int res = 0;
char filename[PATH_MAX];
snprintf (filename, sizeof(filename), "%s/ringid_%u",
get_state_dir(), nodeid);
fd = open (filename, O_RDONLY);
/*
* If file can be opened and read, read the ring id
*/
if (fd != -1) {
res = read (fd, &memb_ring_id->seq, sizeof (uint64_t));
close (fd);
}
/*
* If file could not be opened or read, create a new ring id
*/
if ((fd == -1) || (res != sizeof (uint64_t))) {
memb_ring_id->seq = 0;
fd = creat (filename, 0600);
if (fd != -1) {
res = write (fd, &memb_ring_id->seq, sizeof (uint64_t));
close (fd);
if (res == -1) {
LOGSYS_PERROR (errno, LOGSYS_LEVEL_ERROR,
"Couldn't write ringid file '%s'", filename);
corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
}
} else {
LOGSYS_PERROR (errno, LOGSYS_LEVEL_ERROR,
"Couldn't create ringid file '%s'", filename);
corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
}
}
memb_ring_id->rep = nodeid;
}
static void corosync_ring_id_store (
const struct memb_ring_id *memb_ring_id,
unsigned int nodeid)
{
char filename[PATH_MAX];
int fd;
int res;
snprintf (filename, sizeof(filename), "%s/ringid_%u",
get_state_dir(), nodeid);
fd = creat (filename, 0600);
if (fd == -1) {
LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR,
"Couldn't store new ring id " CS_PRI_RING_ID_SEQ " to stable storage",
memb_ring_id->seq);
corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
}
log_printf (LOGSYS_LEVEL_DEBUG,
"Storing new sequence id for ring " CS_PRI_RING_ID_SEQ, memb_ring_id->seq);
res = write (fd, &memb_ring_id->seq, sizeof(memb_ring_id->seq));
close (fd);
if (res != sizeof(memb_ring_id->seq)) {
LOGSYS_PERROR(errno, LOGSYS_LEVEL_ERROR,
"Couldn't store new ring id " CS_PRI_RING_ID_SEQ " to stable storage",
memb_ring_id->seq);
corosync_exit_error (COROSYNC_DONE_STORE_RINGID);
}
}
static qb_loop_timer_handle recheck_the_q_level_timer;
void corosync_recheck_the_q_level(void *data)
{
totempg_check_q_level(corosync_group_handle);
if (cs_ipcs_q_level_get() == TOTEM_Q_LEVEL_CRITICAL) {
qb_loop_timer_add(cs_poll_handle_get(), QB_LOOP_MED, 1*QB_TIME_NS_IN_MSEC,
NULL, corosync_recheck_the_q_level, &recheck_the_q_level_timer);
}
}
struct sending_allowed_private_data_struct {
int reserved_msgs;
};
int corosync_sending_allowed (
unsigned int service,
unsigned int id,
const void *msg,
void *sending_allowed_private_data)
{
struct sending_allowed_private_data_struct *pd =
(struct sending_allowed_private_data_struct *)sending_allowed_private_data;
struct iovec reserve_iovec;
struct qb_ipc_request_header *header = (struct qb_ipc_request_header *)msg;
int sending_allowed;
reserve_iovec.iov_base = (char *)header;
reserve_iovec.iov_len = header->size;
pd->reserved_msgs = totempg_groups_joined_reserve (
corosync_group_handle,
&reserve_iovec, 1);
if (pd->reserved_msgs == -1) {
return -EINVAL;
}
/* Message ID out of range */
if (id >= corosync_service[service]->lib_engine_count) {
return -EINVAL;
}
sending_allowed = QB_FALSE;
if (corosync_quorum_is_quorate() == 1 ||
corosync_service[service]->allow_inquorate == CS_LIB_ALLOW_INQUORATE) {
// we are quorate
// now check flow control
if (corosync_service[service]->lib_engine[id].flow_control == CS_LIB_FLOW_CONTROL_NOT_REQUIRED) {
sending_allowed = QB_TRUE;
} else if (pd->reserved_msgs && sync_in_process == 0) {
sending_allowed = QB_TRUE;
} else if (pd->reserved_msgs == 0) {
return -ENOBUFS;
} else /* (sync_in_process) */ {
return -EINPROGRESS;
}
} else {
return -EHOSTUNREACH;
}
return (sending_allowed);
}
void corosync_sending_allowed_release (void *sending_allowed_private_data)
{
struct sending_allowed_private_data_struct *pd =
(struct sending_allowed_private_data_struct *)sending_allowed_private_data;
if (pd->reserved_msgs == -1) {
return;
}
totempg_groups_joined_release (pd->reserved_msgs);
}
int message_source_is_local (const mar_message_source_t *source)
{
int ret = 0;
assert (source != NULL);
if (source->nodeid == totempg_my_nodeid_get ()) {
ret = 1;
}
return ret;
}
void message_source_set (
mar_message_source_t *source,
void *conn)
{
assert ((source != NULL) && (conn != NULL));
memset (source, 0, sizeof (mar_message_source_t));
source->nodeid = totempg_my_nodeid_get ();
source->conn = conn;
}
struct scheduler_pause_timeout_data {
struct totem_config *totem_config;
qb_loop_timer_handle handle;
unsigned long long tv_prev;
unsigned long long max_tv_diff;
};
static void timer_function_scheduler_timeout (void *data)
{
struct scheduler_pause_timeout_data *timeout_data = (struct scheduler_pause_timeout_data *)data;
unsigned long long tv_current;
unsigned long long tv_diff;
uint64_t schedmiss_event_tstamp;
tv_current = qb_util_nano_current_get ();
if (timeout_data->tv_prev == 0) {
/*
* Initial call -> just pretent everything is ok
*/
timeout_data->tv_prev = tv_current;
timeout_data->max_tv_diff = 0;
}
tv_diff = tv_current - timeout_data->tv_prev;
timeout_data->tv_prev = tv_current;
if (tv_diff > timeout_data->max_tv_diff) {
schedmiss_event_tstamp = qb_util_nano_from_epoch_get() / QB_TIME_NS_IN_MSEC;
log_printf (LOGSYS_LEVEL_WARNING, "Corosync main process was not scheduled (@%" PRIu64 ") for %0.4f ms "
"(threshold is %0.4f ms). Consider token timeout increase.",
schedmiss_event_tstamp,
(float)tv_diff / QB_TIME_NS_IN_MSEC, (float)timeout_data->max_tv_diff / QB_TIME_NS_IN_MSEC);
stats_add_schedmiss_event(schedmiss_event_tstamp, (float)tv_diff / QB_TIME_NS_IN_MSEC);
}
/*
* Set next threshold, because token_timeout can change
*/
timeout_data->max_tv_diff = timeout_data->totem_config->token_timeout * QB_TIME_NS_IN_MSEC * 0.8;
qb_loop_timer_add (corosync_poll_handle,
QB_LOOP_MED,
timeout_data->totem_config->token_timeout * QB_TIME_NS_IN_MSEC / 3,
timeout_data,
timer_function_scheduler_timeout,
&timeout_data->handle);
}
/*
* Set main pid RR scheduler.
* silent: don't log sched_get_priority_max and sched_setscheduler errors
* Returns: 0 - success, -1 failure, -2 platform doesn't support SCHED_RR
*/
static int corosync_set_rr_scheduler (int silent)
{
int ret_val = 0;
#if defined(HAVE_PTHREAD_SETSCHEDPARAM) && defined(HAVE_SCHED_GET_PRIORITY_MAX) && defined(HAVE_SCHED_SETSCHEDULER)
int res;
sched_priority = sched_get_priority_max (SCHED_RR);
if (sched_priority != -1) {
global_sched_param.sched_priority = sched_priority;
res = sched_setscheduler (0, SCHED_RR, &global_sched_param);
if (res == -1) {
if (!silent) {
LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING,
"Could not set SCHED_RR at priority %d",
global_sched_param.sched_priority);
}
global_sched_param.sched_priority = 0;
#ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET
qb_log_thread_priority_set (SCHED_OTHER, 0);
#endif
ret_val = -1;
} else {
/*
* Turn on SCHED_RR in logsys system
*/
#ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET
res = qb_log_thread_priority_set (SCHED_RR, sched_priority);
#else
res = -1;
#endif
if (res == -1) {
log_printf (LOGSYS_LEVEL_ERROR,
"Could not set logsys thread priority."
" Can't continue because of priority inversions.");
corosync_exit_error (COROSYNC_DONE_LOGSETUP);
}
}
} else {
if (!silent) {
LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING,
"Could not get maximum scheduler priority");
}
sched_priority = 0;
ret_val = -1;
}
#else
log_printf(LOGSYS_LEVEL_WARNING,
"The Platform is missing process priority setting features. Leaving at default.");
ret_val = -2;
#endif
return (ret_val);
}
/* The basename man page contains scary warnings about
thread-safety and portability, hence this */
static const char *corosync_basename(const char *file_name)
{
char *base;
base = strrchr (file_name, '/');
if (base) {
return base + 1;
}
return file_name;
}
static void
_logsys_log_printf(int level, int subsys,
const char *function_name,
const char *file_name,
int file_line,
const char *format,
...) __attribute__((format(printf, 6, 7)));
static void
_logsys_log_printf(int level, int subsys,
const char *function_name,
const char *file_name,
int file_line,
const char *format, ...)
{
va_list ap;
va_start(ap, format);
qb_log_from_external_source_va(function_name, corosync_basename(file_name),
format, level, file_line,
subsys, ap);
va_end(ap);
}
static void fplay_key_change_notify_fn (
int32_t event,
const char *key_name,
struct icmap_notify_value new_val,
struct icmap_notify_value old_val,
void *user_data)
{
if (strcmp(key_name, "runtime.blackbox.dump_flight_data") == 0) {
fprintf(stderr,"Writetofile\n");
corosync_blackbox_write_to_file ();
}
if (strcmp(key_name, "runtime.blackbox.dump_state") == 0) {
fprintf(stderr,"statefump\n");
corosync_state_dump ();
}
}
static void corosync_fplay_control_init (void)
{
icmap_track_t track = NULL;
icmap_set_string("runtime.blackbox.dump_flight_data", "no");
icmap_set_string("runtime.blackbox.dump_state", "no");
icmap_track_add("runtime.blackbox.dump_flight_data",
ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY,
fplay_key_change_notify_fn,
NULL, &track);
icmap_track_add("runtime.blackbox.dump_state",
ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY,
fplay_key_change_notify_fn,
NULL, &track);
}
static void force_gather_notify_fn(
int32_t event,
const char *key_name,
struct icmap_notify_value new_val,
struct icmap_notify_value old_val,
void *user_data)
{
char *key_val;
if (icmap_get_string(key_name, &key_val) == CS_OK && strcmp(key_val, "no") == 0)
goto out;
icmap_set_string("runtime.force_gather", "no");
if (strcmp(key_name, "runtime.force_gather") == 0) {
log_printf(LOGSYS_LEVEL_ERROR, "Forcing into GATHER state\n");
totempg_force_gather();
}
out:
free(key_val);
}
static void corosync_force_gather_init (void)
{
icmap_track_t track = NULL;
icmap_set_string("runtime.force_gather", "no");
icmap_track_add("runtime.force_gather",
ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY,
force_gather_notify_fn,
NULL, &track);
}
/*
* Set RO flag for keys, which ether doesn't make sense to change by user (statistic)
* or which when changed are not reflected by runtime (totem.crypto_cipher, ...).
*
* Also some RO keys cannot be determined in this stage, so they are set later in
* other functions (like nodelist.local_node_pos, ...)
*/
static void set_icmap_ro_keys_flag (void)
{
/*
* Set RO flag for all keys of internal configuration and runtime statistics
*/
icmap_set_ro_access("internal_configuration.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("runtime.services.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("runtime.config.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("runtime.totem.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("uidgid.config.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("system.", CS_TRUE, CS_TRUE);
icmap_set_ro_access("nodelist.", CS_TRUE, CS_TRUE);
/*
* Set RO flag for constrete keys of configuration which can't be changed
* during runtime
*/
icmap_set_ro_access("totem.crypto_cipher", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.crypto_hash", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.crypto_model", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.keyfile", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.key", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.secauth", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.ip_version", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.rrp_mode", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.transport", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.cluster_name", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.netmtu", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.threads", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.version", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.nodeid", CS_FALSE, CS_TRUE);
icmap_set_ro_access("totem.clear_node_high_bit", CS_FALSE, CS_TRUE);
icmap_set_ro_access("config.reload_in_progress", CS_FALSE, CS_TRUE);
icmap_set_ro_access("config.totemconfig_reload_in_progress", CS_FALSE, CS_TRUE);
}
static void main_service_ready (void)
{
int res;
/*
* This must occur after totempg is initialized because "this_ip" must be set
*/
res = corosync_service_defaults_link_and_init (api);
if (res == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Could not initialize default services");
corosync_exit_error (COROSYNC_DONE_INIT_SERVICES);
}
cs_ipcs_init();
corosync_totem_stats_init ();
corosync_fplay_control_init ();
corosync_force_gather_init ();
sync_init (
corosync_sync_callbacks_retrieve,
corosync_sync_completed);
}
static enum e_corosync_done corosync_flock (const char *lockfile, pid_t pid)
{
struct flock lock;
enum e_corosync_done err;
char pid_s[17];
int fd_flag;
err = COROSYNC_DONE_EXIT;
lockfile_fd = open (lockfile, O_WRONLY | O_CREAT, 0640);
if (lockfile_fd == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't create lock file.");
return (COROSYNC_DONE_ACQUIRE_LOCK);
}
retry_fcntl:
lock.l_type = F_WRLCK;
lock.l_start = 0;
lock.l_whence = SEEK_SET;
lock.l_len = 0;
if (fcntl (lockfile_fd, F_SETLK, &lock) == -1) {
switch (errno) {
case EINTR:
goto retry_fcntl;
break;
case EAGAIN:
case EACCES:
log_printf (LOGSYS_LEVEL_ERROR, "Another Corosync instance is already running.");
err = COROSYNC_DONE_ALREADY_RUNNING;
goto error_close;
break;
default:
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't acquire lock. Error was %s",
strerror(errno));
err = COROSYNC_DONE_ACQUIRE_LOCK;
goto error_close;
break;
}
}
if (ftruncate (lockfile_fd, 0) == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't truncate lock file. Error was %s",
strerror (errno));
err = COROSYNC_DONE_ACQUIRE_LOCK;
goto error_close_unlink;
}
memset (pid_s, 0, sizeof (pid_s));
snprintf (pid_s, sizeof (pid_s) - 1, "%u\n", pid);
retry_write:
if (write (lockfile_fd, pid_s, strlen (pid_s)) != strlen (pid_s)) {
if (errno == EINTR) {
goto retry_write;
} else {
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't write pid to lock file. "
"Error was %s", strerror (errno));
err = COROSYNC_DONE_ACQUIRE_LOCK;
goto error_close_unlink;
}
}
if ((fd_flag = fcntl (lockfile_fd, F_GETFD, 0)) == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't get close-on-exec flag from lock file. "
"Error was %s", strerror (errno));
err = COROSYNC_DONE_ACQUIRE_LOCK;
goto error_close_unlink;
}
fd_flag |= FD_CLOEXEC;
if (fcntl (lockfile_fd, F_SETFD, fd_flag) == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't set close-on-exec flag to lock file. "
"Error was %s", strerror (errno));
err = COROSYNC_DONE_ACQUIRE_LOCK;
goto error_close_unlink;
}
return (err);
error_close_unlink:
unlink (lockfile);
error_close:
close (lockfile_fd);
return (err);
}
static int corosync_move_to_root_cgroup(void) {
FILE *f;
int res = -1;
const char *cgroup_task_fname = NULL;
/*
* /sys/fs/cgroup is hardcoded, because most of Linux distributions are now
* using systemd and systemd uses hardcoded path of cgroup mount point.
*
* This feature is expected to be removed as soon as systemd gets support
* for managing RT configuration.
*/
f = fopen("/sys/fs/cgroup/cpu/cpu.rt_runtime_us", "rt");
if (f == NULL) {
/*
* Try cgroup v2
*/
f = fopen("/sys/fs/cgroup/cgroup.procs", "rt");
if (f == NULL) {
log_printf(LOG_DEBUG, "cpu.rt_runtime_us or cgroup.procs doesn't exist -> "
"system without cgroup or with disabled CONFIG_RT_GROUP_SCHED");
res = 0;
goto exit_res;
} else {
log_printf(LOGSYS_LEVEL_DEBUG, "Moving main pid to cgroup v2 root cgroup");
cgroup_task_fname = "/sys/fs/cgroup/cgroup.procs";
}
} else {
log_printf(LOGSYS_LEVEL_DEBUG, "Moving main pid to cgroup v1 root cgroup");
cgroup_task_fname = "/sys/fs/cgroup/cpu/tasks";
}
(void)fclose(f);
f = fopen(cgroup_task_fname, "w");
if (f == NULL) {
log_printf(LOGSYS_LEVEL_WARNING, "Can't open cgroups tasks file for writing");
goto exit_res;
}
if (fprintf(f, "%jd\n", (intmax_t)getpid()) <= 0) {
log_printf(LOGSYS_LEVEL_WARNING, "Can't write corosync pid into cgroups tasks file");
goto close_and_exit_res;
}
close_and_exit_res:
if (fclose(f) != 0) {
log_printf(LOGSYS_LEVEL_WARNING, "Can't close cgroups tasks file");
goto exit_res;
}
exit_res:
return (res);
}
static void show_version_info_crypto(void)
{
const char *error_string;
const char *list_str;
if (util_is_valid_knet_crypto_model(NULL, &list_str, 1, "", &error_string) != -1) {
printf("Available crypto models: %s\n", list_str);
} else {
perror(error_string);
}
}
static void show_version_info_compress(void)
{
const char *error_string;
const char *list_str;
if (util_is_valid_knet_compress_model(NULL, &list_str, 1, "", &error_string) != -1) {
printf("Available compression models: %s\n", list_str);
} else {
perror(error_string);
}
}
static void show_version_info(void)
{
printf ("Corosync Cluster Engine, version '%s'\n", VERSION);
printf ("Copyright (c) 2006-2021 Red Hat, Inc.\n");
printf ("\nBuilt-in features:" PACKAGE_FEATURES "\n");
show_version_info_crypto();
show_version_info_compress();
}
int main (int argc, char **argv, char **envp)
{
const char *error_string;
struct totem_config totem_config;
int res, ch;
int background, sched_rr, prio, testonly;
enum move_to_root_cgroup_mode move_to_root_cgroup;
enum e_corosync_done flock_err;
uint64_t totem_config_warnings;
struct scheduler_pause_timeout_data scheduler_pause_timeout_data;
long int tmpli;
char *ep;
char *tmp_str;
int log_subsys_id_totem;
int silent;
/* default configuration
*/
background = 1;
testonly = 0;
while ((ch = getopt (argc, argv, "c:ftv")) != EOF) {
switch (ch) {
case 'c':
res = snprintf(corosync_config_file, sizeof(corosync_config_file), "%s", optarg);
if (res >= sizeof(corosync_config_file)) {
fprintf (stderr, "Config file path too long.\n");
syslog (LOGSYS_LEVEL_ERROR, "Config file path too long.");
logsys_system_fini();
return EXIT_FAILURE;
}
break;
case 'f':
background = 0;
break;
case 't':
testonly = 1;
break;
case 'v':
show_version_info();
logsys_system_fini();
return EXIT_SUCCESS;
break;
default:
fprintf(stderr, \
"usage:\n"\
" -c : Corosync config file path.\n"\
" -f : Start application in foreground.\n"\
" -t : Test configuration and exit.\n"\
" -v : Display version, git revision and some useful information about Corosync and exit.\n");
logsys_system_fini();
return EXIT_FAILURE;
}
}
/*
* Other signals are registered later via qb_loop_signal_add
*/
(void)signal (SIGSEGV, sigsegv_handler);
(void)signal (SIGABRT, sigsegv_handler);
#if MSG_NOSIGNAL != 0
(void)signal (SIGPIPE, SIG_IGN);
#endif
if (icmap_init() != CS_OK) {
fprintf (stderr, "Corosync Executive couldn't initialize configuration component.\n");
syslog (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't initialize configuration component.");
corosync_exit_error (COROSYNC_DONE_ICMAP);
}
set_icmap_ro_keys_flag();
/*
* Initialize the corosync_api_v1 definition
*/
api = apidef_get ();
res = coroparse_configparse(icmap_get_global_map(), &error_string);
if (res == -1) {
/*
* Logsys can't log properly at this early stage, and we need to get this message out
*
*/
fprintf (stderr, "%s\n", error_string);
syslog (LOGSYS_LEVEL_ERROR, "%s", error_string);
corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
}
if (stats_map_init(api) != CS_OK) {
fprintf (stderr, "Corosync Executive couldn't initialize statistics component.\n");
syslog (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't initialize statistics component.");
corosync_exit_error (COROSYNC_DONE_STATS);
}
res = corosync_log_config_read (&error_string);
if (res == -1) {
/*
* if we are here, we _must_ flush the logsys queue
* and try to inform that we couldn't read the config.
* this is a desperate attempt before certain death
* and there is no guarantee that we can print to stderr
* nor that logsys is sending the messages where we expect.
*/
log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
fprintf(stderr, "%s", error_string);
syslog (LOGSYS_LEVEL_ERROR, "%s", error_string);
corosync_exit_error (COROSYNC_DONE_LOGCONFIGREAD);
}
if (!testonly) {
log_printf (LOGSYS_LEVEL_NOTICE, "Corosync Cluster Engine %s starting up", VERSION);
log_printf (LOGSYS_LEVEL_INFO, "Corosync built-in features:" PACKAGE_FEATURES "");
}
/*
* Create totem logsys subsys before totem_config_read so log functions can be used
*/
log_subsys_id_totem = _logsys_subsys_create("TOTEM", "totem,"
"totemip.c,totemconfig.c,totemcrypto.c,totemsrp.c,"
"totempg.c,totemudp.c,totemudpu.c,totemnet.c,totemknet.c");
res = chdir(get_state_dir());
if (res == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "Cannot chdir to state directory %s. %s", get_state_dir(), strerror(errno));
corosync_exit_error (COROSYNC_DONE_DIR_NOT_PRESENT);
}
res = totem_config_read (&totem_config, &error_string, &totem_config_warnings);
if (res == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
}
if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_IGNORED) {
log_printf (LOGSYS_LEVEL_WARNING, "member section is used together with nodelist. Members ignored.");
}
if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED) {
log_printf (LOGSYS_LEVEL_WARNING, "member section is deprecated.");
}
if (totem_config_warnings & TOTEM_CONFIG_WARNING_TOTEM_NODEID_SET) {
log_printf (LOGSYS_LEVEL_WARNING, "nodeid in totem section is deprecated and ignored. "
"Nodelist (or autogenerated) nodeid is going to be used.");
}
if (totem_config_warnings & TOTEM_CONFIG_BINDNETADDR_NODELIST_SET) {
log_printf (LOGSYS_LEVEL_WARNING, "interface section bindnetaddr is used together with nodelist. "
"Nodelist one is going to be used.");
}
if (totem_config_warnings != 0) {
log_printf (LOGSYS_LEVEL_WARNING, "Please migrate config file to nodelist.");
}
res = totem_config_validate (&totem_config, &error_string);
if (res == -1) {
log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string);
corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
}
if (testonly) {
corosync_exit_error (COROSYNC_DONE_EXIT);
}
move_to_root_cgroup = MOVE_TO_ROOT_CGROUP_MODE_AUTO;
if (icmap_get_string("system.move_to_root_cgroup", &tmp_str) == CS_OK) {
/*
* Validity of move_to_root_cgroup values checked in coroparse.c
*/
if (strcmp(tmp_str, "yes") == 0) {
move_to_root_cgroup = MOVE_TO_ROOT_CGROUP_MODE_ON;
} else if (strcmp(tmp_str, "no") == 0) {
move_to_root_cgroup = MOVE_TO_ROOT_CGROUP_MODE_OFF;
}
free(tmp_str);
}
sched_rr = 1;
if (icmap_get_string("system.sched_rr", &tmp_str) == CS_OK) {
if (strcmp(tmp_str, "yes") != 0) {
sched_rr = 0;
}
free(tmp_str);
}
prio = 0;
if (icmap_get_string("system.priority", &tmp_str) == CS_OK) {
if (strcmp(tmp_str, "max") == 0) {
prio = INT_MIN;
} else if (strcmp(tmp_str, "min") == 0) {
prio = INT_MAX;
} else {
errno = 0;
tmpli = strtol(tmp_str, &ep, 10);
if (errno != 0 || *ep != '\0' || tmpli > INT_MAX || tmpli < INT_MIN) {
log_printf (LOGSYS_LEVEL_ERROR, "Priority value %s is invalid", tmp_str);
corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD);
}
prio = tmpli;
}
free(tmp_str);
}
if (move_to_root_cgroup == MOVE_TO_ROOT_CGROUP_MODE_ON) {
/*
* Try to move corosync into root cpu cgroup. Failure is not fatal and
* error is deliberately ignored.
*/
(void)corosync_move_to_root_cgroup();
}
/*
* Set round robin realtime scheduling with priority 99
*/
if (sched_rr) {
silent = (move_to_root_cgroup == MOVE_TO_ROOT_CGROUP_MODE_AUTO);
res = corosync_set_rr_scheduler (silent);
if (res == -1 && move_to_root_cgroup == MOVE_TO_ROOT_CGROUP_MODE_AUTO) {
/*
* Try to move process to root cgroup and try set priority again
*/
(void)corosync_move_to_root_cgroup();
res = corosync_set_rr_scheduler (0);
}
if (res != 0) {
prio = INT_MIN;
} else {
prio = 0;
}
}
if (prio != 0) {
if (setpriority(PRIO_PGRP, 0, prio) != 0) {
LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING,
"Could not set priority %d", prio);
}
}
totem_config.totem_memb_ring_id_create_or_load = corosync_ring_id_create_or_load;
totem_config.totem_memb_ring_id_store = corosync_ring_id_store;
totem_config.totem_logging_configuration = totem_logging_configuration;
totem_config.totem_logging_configuration.log_subsys_id = log_subsys_id_totem;
totem_config.totem_logging_configuration.log_level_security = LOGSYS_LEVEL_WARNING;
totem_config.totem_logging_configuration.log_level_error = LOGSYS_LEVEL_ERROR;
totem_config.totem_logging_configuration.log_level_warning = LOGSYS_LEVEL_WARNING;
totem_config.totem_logging_configuration.log_level_notice = LOGSYS_LEVEL_NOTICE;
totem_config.totem_logging_configuration.log_level_debug = LOGSYS_LEVEL_DEBUG;
totem_config.totem_logging_configuration.log_level_trace = LOGSYS_LEVEL_TRACE;
totem_config.totem_logging_configuration.log_printf = _logsys_log_printf;
logsys_config_apply();
/*
* Now we are fully initialized.
*/
if (background) {
logsys_blackbox_prefork();
corosync_tty_detach ();
logsys_blackbox_postfork();
log_printf (LOGSYS_LEVEL_DEBUG, "Corosync TTY detached");
}
/*
* Lock all memory to avoid page faults which may interrupt
* application healthchecking
*/
corosync_mlockall ();
corosync_poll_handle = qb_loop_create ();
memset(&scheduler_pause_timeout_data, 0, sizeof(scheduler_pause_timeout_data));
scheduler_pause_timeout_data.totem_config = &totem_config;
timer_function_scheduler_timeout (&scheduler_pause_timeout_data);
qb_loop_signal_add(corosync_poll_handle, QB_LOOP_LOW,
SIGUSR2, NULL, sig_diag_handler, NULL);
qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
SIGINT, NULL, sig_exit_handler, NULL);
qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
SIGQUIT, NULL, sig_exit_handler, NULL);
qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH,
SIGTERM, NULL, sig_exit_handler, NULL);
if (logsys_thread_start() != 0) {
log_printf (LOGSYS_LEVEL_ERROR, "Can't initialize log thread");
corosync_exit_error (COROSYNC_DONE_LOGCONFIGREAD);
}
if ((flock_err = corosync_flock (corosync_lock_file, getpid ())) != COROSYNC_DONE_EXIT) {
corosync_exit_error (flock_err);
}
/*
* if totempg_initialize doesn't have root priveleges, it cannot
* bind to a specific interface. This only matters if
* there is more then one interface in a system, so
* in this case, only a warning is printed
*/
/*
* Join multicast group and setup delivery
* and configuration change functions
*/
if (totempg_initialize (
corosync_poll_handle,
&totem_config) != 0) {
log_printf (LOGSYS_LEVEL_ERROR, "Can't initialize TOTEM layer");
corosync_exit_error (COROSYNC_DONE_FATAL_ERR);
}
totempg_service_ready_register (
main_service_ready);
totempg_groups_initialize (
&corosync_group_handle,
deliver_fn,
confchg_fn);
totempg_groups_join (
corosync_group_handle,
&corosync_group,
1);
/*
* Drop root privleges to user 'corosync'
* TODO: Don't really need full root capabilities;
* needed capabilities are:
* CAP_NET_RAW (bindtodevice)
* CAP_SYS_NICE (setscheduler)
* CAP_IPC_LOCK (mlockall)
*/
priv_drop ();
schedwrk_init (
serialize_lock,
serialize_unlock);
/*
* Start main processing loop
*/
qb_loop_run (corosync_poll_handle);
/*
* Exit was requested
*/
totempg_finalize ();
/*
* free the loop resources
*/
qb_loop_destroy (corosync_poll_handle);
/*
* free up the icmap
*/
/*
* Remove pid lock file
*/
close (lockfile_fd);
unlink (corosync_lock_file);
corosync_exit_error (COROSYNC_DONE_EXIT);
return EXIT_SUCCESS;
}
apidef_get
struct corosync_api_v1 * apidef_get(void)
Definition: apidef.c:146
apidef.h
config.h
VERSION
#define VERSION
Definition: config.h:516
PACKAGE_FEATURES
#define PACKAGE_FEATURES
Definition: config.h:388
LOCALSTATEDIR
#define LOCALSTATEDIR
Definition: config.h:373
COROSYSCONFDIR
#define COROSYSCONFDIR
Definition: config.h:8
totem_configuration_type
totem_configuration_type
The totem_configuration_type enum.
Definition: coroapi.h:132
TOTEM_CONFIGURATION_REGULAR
@ TOTEM_CONFIGURATION_REGULAR
Definition: coroapi.h:133
TOTEM_CONFIGURATION_TRANSITIONAL
@ TOTEM_CONFIGURATION_TRANSITIONAL
Definition: coroapi.h:134
CS_LIB_ALLOW_INQUORATE
@ CS_LIB_ALLOW_INQUORATE
Definition: coroapi.h:164
corosync_timer_handle_t
qb_loop_timer_handle corosync_timer_handle_t
corosync_timer_handle_t
Definition: coroapi.h:74
nodeid
unsigned int nodeid
Definition: coroapi.h:0
CS_LIB_FLOW_CONTROL_NOT_REQUIRED
@ CS_LIB_FLOW_CONTROL_NOT_REQUIRED
Definition: coroapi.h:153
SERVICES_COUNT_MAX
#define SERVICES_COUNT_MAX
Definition: coroapi.h:462
MILLI_2_NANO_SECONDS
#define MILLI_2_NANO_SECONDS
Definition: coroapi.h:105
corodefs.h
coroparse_configparse
int coroparse_configparse(icmap_map_t config_map, const char **error_string)
Definition: coroparse.c:258
corotypes.h
CS_PRI_RING_ID_SEQ
#define CS_PRI_RING_ID_SEQ
Definition: corotypes.h:61
CS_FALSE
#define CS_FALSE
Definition: corotypes.h:53
CS_TRUE
#define CS_TRUE
Definition: corotypes.h:54
CS_OK
@ CS_OK
Definition: corotypes.h:99
corosync_quorum_is_quorate
int corosync_quorum_is_quorate(void)
Definition: exec/quorum.c:65
quorum.h
util.h
corosync_exit_error
#define corosync_exit_error(err)
Definition: exec/util.h:72
e_corosync_done
e_corosync_done
Definition: exec/util.h:47
COROSYNC_DONE_INIT_SERVICES
@ COROSYNC_DONE_INIT_SERVICES
Definition: exec/util.h:54
COROSYNC_DONE_STATS
@ COROSYNC_DONE_STATS
Definition: exec/util.h:62
COROSYNC_DONE_ICMAP
@ COROSYNC_DONE_ICMAP
Definition: exec/util.h:53
COROSYNC_DONE_ALREADY_RUNNING
@ COROSYNC_DONE_ALREADY_RUNNING
Definition: exec/util.h:58
COROSYNC_DONE_FORK
@ COROSYNC_DONE_FORK
Definition: exec/util.h:49
COROSYNC_DONE_STORE_RINGID
@ COROSYNC_DONE_STORE_RINGID
Definition: exec/util.h:61
COROSYNC_DONE_EXIT
@ COROSYNC_DONE_EXIT
Definition: exec/util.h:48
COROSYNC_DONE_LOGSETUP
@ COROSYNC_DONE_LOGSETUP
Definition: exec/util.h:52
COROSYNC_DONE_FATAL_ERR
@ COROSYNC_DONE_FATAL_ERR
Definition: exec/util.h:55
COROSYNC_DONE_LOGCONFIGREAD
@ COROSYNC_DONE_LOGCONFIGREAD
Definition: exec/util.h:50
COROSYNC_DONE_STD_TO_NULL_REDIR
@ COROSYNC_DONE_STD_TO_NULL_REDIR
Definition: exec/util.h:59
COROSYNC_DONE_MAINCONFIGREAD
@ COROSYNC_DONE_MAINCONFIGREAD
Definition: exec/util.h:51
COROSYNC_DONE_ACQUIRE_LOCK
@ COROSYNC_DONE_ACQUIRE_LOCK
Definition: exec/util.h:57
COROSYNC_DONE_DIR_NOT_PRESENT
@ COROSYNC_DONE_DIR_NOT_PRESENT
Definition: exec/util.h:56
icmap.h
ICMAP_TRACK_MODIFY
#define ICMAP_TRACK_MODIFY
Definition: icmap.h:78
icmap_set_ro_access
cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
Set read-only access for given key (key_name) or prefix, If prefix is set.
Definition: icmap.c:1225
ICMAP_TRACK_DELETE
#define ICMAP_TRACK_DELETE
Definition: icmap.h:77
icmap_track_add
cs_error_t icmap_track_add(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
Add tracking function for given key_name.
Definition: icmap.c:1159
icmap_set_string
cs_error_t icmap_set_string(const char *key_name, const char *value)
Definition: icmap.c:627
icmap_inc
cs_error_t icmap_inc(const char *key_name)
Increase stored value by one.
Definition: icmap.c:1049
icmap_fast_inc
cs_error_t icmap_fast_inc(const char *key_name)
Increase stored value by one.
Definition: icmap.c:1069
icmap_get_global_map
icmap_map_t icmap_get_global_map(void)
Return global icmap.
Definition: icmap.c:264
icmap_get
cs_error_t icmap_get(const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type)
Retrieve value of key key_name and store it in user preallocated value pointer.
Definition: icmap.c:725
icmap_init
cs_error_t icmap_init(void)
Initialize global icmap.
Definition: icmap.c:208
ICMAP_KEYNAME_MAXLEN
#define ICMAP_KEYNAME_MAXLEN
Maximum length of key in icmap.
Definition: icmap.h:48
icmap_fini
void icmap_fini(void)
Finalize global icmap.
Definition: icmap.c:247
icmap_set_uint32
cs_error_t icmap_set_uint32(const char *key_name, uint32_t value)
Definition: icmap.c:597
ICMAP_TRACK_ADD
#define ICMAP_TRACK_ADD
Definition: icmap.h:76
icmap_get_string
cs_error_t icmap_get_string(const char *key_name, char **str)
Shortcut for icmap_get for string type.
Definition: icmap.c:856
cs_ipcs_init
void cs_ipcs_init(void)
Definition: ipc_glue.c:818
cs_ipcs_sync_state_changed
void cs_ipcs_sync_state_changed(int32_t sync_in_process)
Definition: ipc_glue.c:664
cs_ipcs_q_level_get
int32_t cs_ipcs_q_level_get(void)
Definition: ipc_glue.c:601
cs_ipc_allow_connections
void cs_ipc_allow_connections(int32_t allow)
Definition: ipc_glue.c:159
ipcs_stats.h
corosync_log_config_read
int corosync_log_config_read(cmap_handle_t cmap_h, const char *default_logfile, const char **error_string)
Definition: logconfig.c:715
logconfig.h
logsys.h
LOGSYS_LEVEL_ERROR
#define LOGSYS_LEVEL_ERROR
Definition: logsys.h:72
log_printf
#define log_printf(level, format, args...)
Definition: logsys.h:323
logsys_blackbox_prefork
void logsys_blackbox_prefork(void)
Definition: logsys.c:880
logsys_system_fini
void logsys_system_fini(void)
logsys_system_fini
Definition: logsys.c:286
LOGSYS_LEVEL_INFO
#define LOGSYS_LEVEL_INFO
Definition: logsys.h:75
LOGSYS_MODE_OUTPUT_STDERR
#define LOGSYS_MODE_OUTPUT_STDERR
Definition: logsys.h:61
LOGSYS_LEVEL_NOTICE
#define LOGSYS_LEVEL_NOTICE
Definition: logsys.h:74
logsys_config_apply
void logsys_config_apply(void)
logsys_config_apply
Definition: logsys.c:792
LOGSYS_PERROR
#define LOGSYS_PERROR(err_num, level, fmt, args...)
The LOGSYS_PERROR macro.
Definition: logsys.h:317
logsys_thread_start
int logsys_thread_start(void)
logsys_thread_start
Definition: logsys.c:844
LOGSYS_LEVEL_WARNING
#define LOGSYS_LEVEL_WARNING
Definition: logsys.h:73
_logsys_subsys_create
int _logsys_subsys_create(const char *subsys, const char *filename)
_logsys_subsys_create
Definition: logsys.c:435
logsys_blackbox_postfork
void logsys_blackbox_postfork(void)
Definition: logsys.c:886
LOGSYS_LEVEL_DEBUG
#define LOGSYS_LEVEL_DEBUG
Definition: logsys.h:76
LOGSYS_MODE_OUTPUT_SYSLOG
#define LOGSYS_MODE_OUTPUT_SYSLOG
Definition: logsys.h:62
LOGSYS_LEVEL_TRACE
#define LOGSYS_LEVEL_TRACE
Definition: logsys.h:77
corosync_sending_allowed_release
void corosync_sending_allowed_release(void *sending_allowed_private_data)
Definition: main.c:785
LOGSYS_DECLARE_SYSTEM
LOGSYS_DECLARE_SYSTEM("corosync", LOGSYS_MODE_OUTPUT_STDERR|LOGSYS_MODE_OUTPUT_SYSLOG, LOG_DAEMON, LOG_EMERG)
corosync_state_dump
void corosync_state_dump(void)
Definition: main.c:201
corosync_get_config_file
const char * corosync_get_config_file(void)
Definition: main.c:212
cs_poll_dispatch_add
int cs_poll_dispatch_add(qb_loop_t *handle, int fd, int events, void *data, int(*dispatch_fn)(int fd, int revents, void *data))
Definition: main.c:183
move_to_root_cgroup_mode
move_to_root_cgroup_mode
Definition: main.c:172
MOVE_TO_ROOT_CGROUP_MODE_ON
@ MOVE_TO_ROOT_CGROUP_MODE_ON
Definition: main.c:174
MOVE_TO_ROOT_CGROUP_MODE_OFF
@ MOVE_TO_ROOT_CGROUP_MODE_OFF
Definition: main.c:173
MOVE_TO_ROOT_CGROUP_MODE_AUTO
@ MOVE_TO_ROOT_CGROUP_MODE_AUTO
Definition: main.c:175
RLIMIT_MEMLOCK
#define RLIMIT_MEMLOCK
global_sched_param
struct sched_param global_sched_param
Definition: main.c:162
message_source_set
void message_source_set(mar_message_source_t *source, void *conn)
Definition: main.c:807
main
int main(int argc, char **argv, char **envp)
Definition: main.c:1284
main_mcast
int main_mcast(const struct iovec *iovec, unsigned int iov_len, unsigned int guarantee)
Definition: main.c:627
corosync_recheck_the_q_level
void corosync_recheck_the_q_level(void *data)
Definition: main.c:723
message_source_is_local
int message_source_is_local(const mar_message_source_t *source)
Definition: main.c:796
cs_poll_handle_get
qb_loop_t * cs_poll_handle_get(void)
Definition: main.c:178
LOGSYS_DECLARE_SUBSYS
LOGSYS_DECLARE_SUBSYS("MAIN")
corosync_sending_allowed
int corosync_sending_allowed(unsigned int service, unsigned int id, const void *msg, void *sending_allowed_private_data)
Definition: main.c:737
cs_poll_dispatch_delete
int cs_poll_dispatch_delete(qb_loop_t *handle, int fd)
Definition: main.c:196
corosync_shutdown_request
void corosync_shutdown_request(void)
Definition: main.c:258
main.h
lock
pthread_mutex_t lock
Definition: sam.c:131
user_data
void * user_data
Definition: sam.c:127
schedwrk_init
void schedwrk_init(void(*serialize_lock_fn)(void), void(*serialize_unlock_fn)(void))
Definition: schedwrk.c:83
schedwrk.h
corosync_service_defaults_link_and_init
unsigned int corosync_service_defaults_link_and_init(struct corosync_api_v1 *corosync_api)
Load all of the default services.
Definition: service.c:339
corosync_service_unlink_all
void corosync_service_unlink_all(struct corosync_api_v1 *api, void(*unlink_all_complete)(void))
Unlink and exit all corosync services.
Definition: service.c:394
service_stats_rx
const char * service_stats_rx[SERVICES_COUNT_MAX][SERVICE_HANDLER_MAXIMUM_COUNT]
Definition: service.c:112
corosync_service
struct corosync_service_engine * corosync_service[SERVICES_COUNT_MAX]
Definition: service.c:110
service_stats_tx
const char * service_stats_tx[SERVICES_COUNT_MAX][SERVICE_HANDLER_MAXIMUM_COUNT]
Definition: service.c:113
service.h
stats_add_schedmiss_event
void stats_add_schedmiss_event(uint64_t timestamp, float delay)
Definition: stats.c:447
stats_trigger_trackers
void stats_trigger_trackers()
Definition: stats.c:561
stats_map_init
cs_error_t stats_map_init(const struct corosync_api_v1 *corosync_api)
Definition: stats.c:289
stats.h
corosync_api_v1
The corosync_api_v1 struct.
Definition: coroapi.h:225
corosync_api_v1::timer_add_duration
int(* timer_add_duration)(unsigned long long nanoseconds_in_future, void *data, void(*timer_nf)(void *data), corosync_timer_handle_t *handle)
Definition: coroapi.h:229
corosync_api_v1::timer_delete
void(* timer_delete)(corosync_timer_handle_t timer_handle)
Definition: coroapi.h:241
corosync_api_v1::totem_ifaces_print
const char *(* totem_ifaces_print)(unsigned int nodeid)
Definition: coroapi.h:290
corosync_api_v1::totem_get_stats
void *(* totem_get_stats)(void)
Definition: coroapi.h:435
corosync_exec_handler::exec_handler_fn
void(* exec_handler_fn)(const void *msg, unsigned int nodeid)
Definition: coroapi.h:476
corosync_exec_handler::exec_endian_convert_fn
void(* exec_endian_convert_fn)(void *msg)
Definition: coroapi.h:477
corosync_service_engine::sync_init
void(* sync_init)(const unsigned int *trans_list, size_t trans_list_entries, const unsigned int *member_list, size_t member_list_entries, const struct memb_ring_id *ring_id)
Definition: coroapi.h:515
corosync_service_engine::name
const char * name
Definition: coroapi.h:491
corosync_service_engine::sync_activate
void(* sync_activate)(void)
Definition: coroapi.h:522
corosync_service_engine::confchg_fn
void(* confchg_fn)(enum totem_configuration_type configuration_type, const unsigned int *member_list, size_t member_list_entries, const unsigned int *left_list, size_t left_list_entries, const unsigned int *joined_list, size_t joined_list_entries, const struct memb_ring_id *ring_id)
Definition: coroapi.h:509
corosync_service_engine::sync_abort
void(* sync_abort)(void)
Definition: coroapi.h:523
corosync_service_engine::exec_engine
struct corosync_exec_handler * exec_engine
Definition: coroapi.h:506
corosync_service_engine::exec_dump_fn
void(* exec_dump_fn)(void)
Definition: coroapi.h:501
corosync_service_engine::sync_process
int(* sync_process)(void)
Definition: coroapi.h:521
icmap_notify_value
Structure passed as new_value and old_value in change callback.
Definition: icmap.h:91
icmap_track
Definition: icmap.c:61
mar_message_source_t
The mar_message_source_t struct.
Definition: coroapi.h:50
memb_ring_id
The memb_ring_id struct.
Definition: coroapi.h:122
memb_ring_id::seq
unsigned long long seq
Definition: coroapi.h:124
memb_ring_id::rep
unsigned int rep
Definition: totem.h:150
scheduler_pause_timeout_data
Definition: main.c:817
scheduler_pause_timeout_data::handle
qb_loop_timer_handle handle
Definition: main.c:819
scheduler_pause_timeout_data::max_tv_diff
unsigned long long max_tv_diff
Definition: main.c:821
scheduler_pause_timeout_data::totem_config
struct totem_config * totem_config
Definition: main.c:818
scheduler_pause_timeout_data::tv_prev
unsigned long long tv_prev
Definition: main.c:820
sending_allowed_private_data_struct
Definition: main.c:732
sending_allowed_private_data_struct::reserved_msgs
int reserved_msgs
Definition: main.c:733
sync_callbacks
Definition: sync.h:38
sync_callbacks::sync_init
void(* sync_init)(const unsigned int *trans_list, size_t trans_list_entries, const unsigned int *member_list, size_t member_list_entries, const struct memb_ring_id *ring_id)
Definition: sync.h:39
sync_callbacks::name
const char * name
Definition: sync.h:48
sync_callbacks::sync_process
int(* sync_process)(void)
Definition: sync.h:45
sync_callbacks::sync_activate
void(* sync_activate)(void)
Definition: sync.h:46
sync_callbacks::sync_abort
void(* sync_abort)(void)
Definition: sync.h:47
totem_config
Definition: totem.h:159
totem_config::token_timeout
unsigned int token_timeout
Definition: totem.h:181
totem_config::totem_logging_configuration
struct totem_logging_configuration totem_logging_configuration
Definition: totem.h:207
totem_config::totem_memb_ring_id_create_or_load
void(* totem_memb_ring_id_create_or_load)(struct memb_ring_id *memb_ring_id, unsigned int nodeid)
Definition: totem.h:249
totem_config::totem_memb_ring_id_store
void(* totem_memb_ring_id_store)(const struct memb_ring_id *memb_ring_id, unsigned int nodeid)
Definition: totem.h:253
totem_logging_configuration
Definition: totem.h:100
totem_logging_configuration::log_subsys_id
int log_subsys_id
Definition: totem.h:116
totem_logging_configuration::log_level_error
int log_level_error
Definition: totem.h:111
totem_logging_configuration::log_level_notice
int log_level_notice
Definition: totem.h:113
totem_logging_configuration::log_level_debug
int log_level_debug
Definition: totem.h:114
totem_logging_configuration::log_level_warning
int log_level_warning
Definition: totem.h:112
totem_logging_configuration::log_level_trace
int log_level_trace
Definition: totem.h:115
totem_logging_configuration::log_printf
void(* log_printf)(int level, int subsys, const char *function_name, const char *file_name, int file_line, const char *format,...) __attribute__((format(printf
Definition: totem.h:101
totem_logging_configuration::log_level_security
void(*) in log_level_security)
Definition: totem.h:108
totempg_group
Definition: totempg.h:55
totempg_group::group
const void * group
Definition: totempg.h:56
totempg_stats_t
Definition: totemstats.h:94
totempg_stats_t::srp
totemsrp_stats_t * srp
Definition: totemstats.h:96
totemsrp_stats_t::continuous_gather
uint32_t continuous_gather
Definition: totemstats.h:78
totemsrp_stats_t::avg_backlog_calc
uint32_t avg_backlog_calc
Definition: totemstats.h:85
totemsrp_stats_t::continuous_sendmsg_failures
uint32_t continuous_sendmsg_failures
Definition: totemstats.h:79
totemsrp_stats_t::token
totemsrp_token_stats_t token[TOTEM_TOKEN_STATS_MAX]
Definition: totemstats.h:90
totemsrp_stats_t::earliest_token
int earliest_token
Definition: totemstats.h:87
totemsrp_stats_t::firewall_enabled_or_nic_failure
uint8_t firewall_enabled_or_nic_failure
Definition: totemstats.h:82
totemsrp_stats_t::avg_token_workload
uint32_t avg_token_workload
Definition: totemstats.h:84
totemsrp_stats_t::mtt_rx_token
uint32_t mtt_rx_token
Definition: totemstats.h:83
totemsrp_stats_t::latest_token
int latest_token
Definition: totemstats.h:88
totemsrp_stats_t::time_since_token_last_received
uint64_t time_since_token_last_received
Definition: totemstats.h:80
totemsrp_token_stats_t::tx
uint32_t tx
Definition: totemstats.h:49
totemsrp_token_stats_t::rx
uint32_t rx
Definition: totemstats.h:48
totemsrp_token_stats_t::backlog_calc
int backlog_calc
Definition: totemstats.h:50
swab.h
swab32
#define swab32(x)
The swab32 macro.
Definition: swab.h:51
sync_init
int sync_init(int(*sync_callbacks_retrieve)(int service_id, struct sync_callbacks *callbacks), void(*synchronization_completed)(void))
Definition: sync.c:158
sync_abort
void sync_abort(void)
Definition: sync.c:535
sync_save_transitional
void sync_save_transitional(const unsigned int *member_list, size_t member_list_entries, const struct memb_ring_id *ring_id)
Definition: sync.c:524
sync_start
void sync_start(const unsigned int *member_list, size_t member_list_entries, const struct memb_ring_id *ring_id)
Definition: sync.c:512
sync.h
timer.h
__attribute__
typedef __attribute__
MAX_NO_CONT_SENDMSG_FAILURES
#define MAX_NO_CONT_SENDMSG_FAILURES
Definition: totem.h:80
MAX_NO_CONT_GATHER
#define MAX_NO_CONT_GATHER
Maximum number of continuous gather states.
Definition: totem.h:76
totem_config_read
int totem_config_read(struct totem_config *totem_config, const char **error_string, uint64_t *warnings)
Definition: totemconfig.c:1780
totem_config_validate
int totem_config_validate(struct totem_config *totem_config, const char **error_string)
Definition: totemconfig.c:1997
totemconfig.h
TOTEM_CONFIG_BINDNETADDR_NODELIST_SET
#define TOTEM_CONFIG_BINDNETADDR_NODELIST_SET
Definition: totemconfig.h:48
TOTEM_CONFIG_WARNING_TOTEM_NODEID_SET
#define TOTEM_CONFIG_WARNING_TOTEM_NODEID_SET
Definition: totemconfig.h:47
TOTEM_CONFIG_WARNING_MEMBERS_IGNORED
#define TOTEM_CONFIG_WARNING_MEMBERS_IGNORED
Definition: totemconfig.h:45
TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED
#define TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED
Definition: totemconfig.h:46
totempg.h
Totem Single Ring Protocol.
totempg_my_nodeid_get
unsigned int totempg_my_nodeid_get(void)
Definition: totempg.c:1532
totempg_check_q_level
void totempg_check_q_level(void *instance)
Definition: totempg.c:1294
totempg_groups_mcast_joined
int totempg_groups_mcast_joined(void *instance, const struct iovec *iovec, unsigned int iov_len, int guarantee)
Definition: totempg.c:1232
totempg_trans_ack
void totempg_trans_ack(void)
Definition: totempg.c:1591
totempg_force_gather
void totempg_force_gather(void)
Definition: totempg.c:1596
totempg_initialize
int totempg_initialize(qb_loop_t *poll_handle, struct totem_config *totem_config)
Initialize the totem process groups abstraction.
Definition: totempg.c:802
totempg_groups_joined_release
int totempg_groups_joined_release(int msg_count)
Definition: totempg.c:1346
totempg_service_ready_register
void totempg_service_ready_register(void(*totem_service_ready)(void))
Definition: totempg.c:1541
totempg_groups_joined_reserve
int totempg_groups_joined_reserve(void *instance, const struct iovec *iovec, unsigned int iov_len)
Definition: totempg.c:1302
totempg_groups_join
int totempg_groups_join(void *instance, const struct totempg_group *groups, size_t group_cnt)
Definition: totempg.c:1182
totempg_finalize
void totempg_finalize(void)
Definition: totempg.c:855
TOTEM_Q_LEVEL_CRITICAL
@ TOTEM_Q_LEVEL_CRITICAL
Definition: totempg.h:184
totempg_groups_initialize
int totempg_groups_initialize(void **instance, void(*deliver_fn)(unsigned int nodeid, const void *msg, unsigned int msg_len, int endian_conversion_required), void(*confchg_fn)(enum totem_configuration_type configuration_type, const unsigned int *member_list, size_t member_list_entries, const unsigned int *left_list, size_t left_list_entries, const unsigned int *joined_list, size_t joined_list_entries, const struct memb_ring_id *ring_id))
Initialize a groups instance.
Definition: totempg.c:1134
guarantee
int guarantee
Definition: totemsrp.c:6
ring_id
struct memb_ring_id ring_id
Definition: totemsrp.c:4
header
struct totem_message_header header
Definition: totemsrp.c:0
totemsrp.h
Totem Single Ring Protocol.
TOTEM_TOKEN_STATS_MAX
#define TOTEM_TOKEN_STATS_MAX
Definition: totemstats.h:89
util_is_valid_knet_crypto_model
int util_is_valid_knet_crypto_model(const char *val, const char **list_str, int machine_parseable_str, const char *error_string_prefix, const char **error_string)
Definition: util.c:213
util_is_valid_knet_compress_model
int util_is_valid_knet_compress_model(const char *val, const char **list_str, int machine_parseable_str, const char *error_string_prefix, const char **error_string)
Definition: util.c:279
get_state_dir
const char * get_state_dir(void)
Definition: util.c:174