static void put_nodelist_members_to_config(struct totem_config *totem_config)
{
icmap_iter_t iter, iter2;
const char *iter_key, *iter_key2;
int res = 0;
int node_pos;
char tmp_key[ICMAP_KEYNAME_MAXLEN];
char tmp_key2[ICMAP_KEYNAME_MAXLEN];
char *node_addr_str;
int member_count;
unsigned int ringnumber = 0;
iter = icmap_iter_init("nodelist.node.");
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
if (res != 2) {
continue;
}
if (strcmp(tmp_key, "ring0_addr") != 0) {
continue;
}
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.", node_pos);
iter2 = icmap_iter_init(tmp_key);
while ((iter_key2 = icmap_iter_next(iter2, NULL, NULL)) != NULL) {
res = sscanf(iter_key2, "nodelist.node.%u.ring%u%s", &node_pos, &ringnumber, tmp_key2);
if (res != 3 || strcmp(tmp_key2, "_addr") != 0) {
continue;
}
if (icmap_get_string(iter_key2, &node_addr_str) != CS_OK) {
continue;
}
member_count = totem_config->interfaces[ringnumber].member_count;
res = totemip_parse(&totem_config->interfaces[ringnumber].member_list[member_count],
node_addr_str, 0);
if (res != -1) {
totem_config->interfaces[ringnumber].member_count++;
}
free(node_addr_str);
}
icmap_iter_finalize(iter2);
}
icmap_iter_finalize(iter);
}
static int find_local_node_in_nodelist(struct totem_config *totem_config)
{
icmap_iter_t iter;
const char *iter_key;
int res = 0;
int node_pos;
int local_node_pos = -1;
struct totem_ip_address bind_addr;
int interface_up, interface_num;
char tmp_key[ICMAP_KEYNAME_MAXLEN];
char *node_addr_str;
struct totem_ip_address node_addr;
res = totemip_iface_check(&totem_config->interfaces[0].bindnet,
&bind_addr, &interface_up, &interface_num,
totem_config->clear_node_high_bit);
if (res == -1) {
return (-1);
}
iter = icmap_iter_init("nodelist.node.");
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
if (res != 2) {
continue;
}
if (strcmp(tmp_key, "ring0_addr") != 0) {
continue;
}
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", node_pos);
if (icmap_get_string(tmp_key, &node_addr_str) != CS_OK) {
continue;
}
res = totemip_parse (&node_addr, node_addr_str, 0);
free(node_addr_str);
if (res == -1) {
continue ;
}
if (totemip_equal(&bind_addr, &node_addr)) {
local_node_pos = node_pos;
}
}
icmap_iter_finalize(iter);
return (local_node_pos);
}
static void wd_scan_resources (void)
{
int res_count = 0;
icmap_track_t icmap_track = NULL;
icmap_iter_t iter;
const char *key_name;
int res;
char res_name[ICMAP_KEYNAME_MAXLEN];
char res_type[ICMAP_KEYNAME_MAXLEN];
char tmp_key[ICMAP_KEYNAME_MAXLEN];
ENTER();
iter = icmap_iter_init("resources.");
while ((key_name = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(key_name, "resources.%[^.].%[^.].%[^.]", res_type, res_name, tmp_key);
if (res != 3) {
continue ;
}
if (strcmp(tmp_key, "state") != 0) {
continue ;
}
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "resources.%s.%s.", res_type, res_name);
if (wd_resource_create (tmp_key, res_name) == 0) {
res_count++;
}
}
icmap_iter_finalize(iter);
icmap_track_add("resources.process.", ICMAP_TRACK_ADD | ICMAP_TRACK_PREFIX,
wd_resource_created_cb, NULL, &icmap_track);
icmap_track_add("resources.system.", ICMAP_TRACK_ADD | ICMAP_TRACK_PREFIX,
wd_resource_created_cb, NULL, &icmap_track);
if (res_count == 0) {
log_printf (LOGSYS_LEVEL_INFO, "no resources configured.");
}
}
/* This is different to the one in totemconfig.c in that we already
* know the 'local' node ID, so we can just search for that.
* It needs to be here rather than at main config read time as it's
* (obviously) going to be different for each instance.
*/
static void set_local_node_pos(struct corosync_api_v1 *api)
{
icmap_iter_t iter;
uint32_t node_pos;
char name_str[ICMAP_KEYNAME_MAXLEN];
uint32_t nodeid;
const char *iter_key;
int res;
int found = 0;
iter = icmap_iter_init("nodelist.node.");
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, name_str);
if (res != 2) {
continue;
}
if (strcmp(name_str, "nodeid")) {
continue;
}
res = icmap_get_uint32(iter_key, &nodeid);
if (res == CS_OK) {
if (nodeid == our_nodeid) {
found = 1;
res = icmap_set_uint32("nodelist.local_node_pos", node_pos);
}
}
}
if (!found) {
/* This probably indicates a dynamically-added node
* set the pos to zero and use the votes of the
* first node in corosync.conf
*/
res = icmap_set_uint32("nodelist.local_node_pos", 0);
}
}
static unsigned int service_unlink_and_exit (
struct corosync_api_v1 *corosync_api,
const char *service_name,
unsigned int service_ver)
{
unsigned short service_id;
char *name_sufix;
int res;
const char *iter_key_name;
icmap_iter_t iter;
char key_name[ICMAP_KEYNAME_MAXLEN];
unsigned int found_service_ver;
char *found_service_name;
int service_found;
name_sufix = strrchr (service_name, '_');
if (name_sufix)
name_sufix++;
else
name_sufix = (char*)service_name;
service_found = 0;
found_service_name = NULL;
iter = icmap_iter_init("internal_configuration.service.");
while ((iter_key_name = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key_name, "internal_configuration.service.%hu.%s", &service_id, key_name);
if (res != 2) {
continue;
}
snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "internal_configuration.service.%hu.name", service_id);
free(found_service_name);
if (icmap_get_string(key_name, &found_service_name) != CS_OK) {
continue;
}
snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "internal_configuration.service.%u.ver", service_id);
if (icmap_get_uint32(key_name, &found_service_ver) != CS_OK) {
continue;
}
if (service_ver == found_service_ver && strcmp(found_service_name, service_name) == 0) {
free(found_service_name);
service_found = 1;
break;
}
}
icmap_iter_finalize(iter);
if (service_found && service_id < SERVICES_COUNT_MAX
&& corosync_service[service_id] != NULL) {
if (corosync_service[service_id]->exec_exit_fn) {
res = corosync_service[service_id]->exec_exit_fn ();
if (res == -1) {
return (-1);
}
}
log_printf(LOGSYS_LEVEL_NOTICE,
"Service engine unloaded: %s",
corosync_service[service_id]->name);
corosync_service[service_id] = NULL;
cs_ipcs_service_destroy (service_id);
snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "internal_configuration.service.%u.handle", service_id);
icmap_delete(key_name);
snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "internal_configuration.service.%u.name", service_id);
icmap_delete(key_name);
snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "internal_configuration.service.%u.ver", service_id);
icmap_delete(key_name);
}
return (0);
}
static int corosync_main_config_read_logging (
const char **error_string)
{
const char *error_reason;
#ifdef LOGCONFIG_USE_ICMAP
icmap_iter_t iter;
const char *key_name;
#else
cmap_iter_handle_t iter;
char key_name[CMAP_KEYNAME_MAXLEN];
#endif
char key_subsys[MAP_KEYNAME_MAXLEN];
char key_item[MAP_KEYNAME_MAXLEN];
int res;
/* format set is supported only for toplevel */
if (corosync_main_config_format_set(&error_reason) < 0) {
goto parse_error;
}
if (corosync_main_config_set ("logging", NULL, &error_reason) < 0) {
goto parse_error;
}
/*
* we will need 2 of these to compensate for new logging
* config format
*/
#ifdef LOGCONFIG_USE_ICMAP
iter = icmap_iter_init("logging.logger_subsys.");
while ((key_name = icmap_iter_next(iter, NULL, NULL)) != NULL) {
#else
cmap_iter_init(cmap_handle, "logging.logger_subsys.", &iter);
while ((cmap_iter_next(cmap_handle, iter, key_name, NULL, NULL)) == CS_OK) {
#endif
res = sscanf(key_name, "logging.logger_subsys.%[^.].%s", key_subsys, key_item);
if (res != 2) {
continue ;
}
if (strcmp(key_item, "subsys") != 0) {
continue ;
}
snprintf(key_item, MAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s", key_subsys);
if (corosync_main_config_set(key_item, key_subsys, &error_reason) < 0) {
goto parse_error;
}
}
#ifdef LOGCONFIG_USE_ICMAP
icmap_iter_finalize(iter);
#else
cmap_iter_finalize(cmap_handle, iter);
#endif
logsys_config_apply();
return 0;
parse_error:
*error_string = error_reason;
return (-1);
}
#ifdef LOGCONFIG_USE_ICMAP
static void main_logging_notify(
int32_t event,
const char *key_name,
struct icmap_notify_value new_val,
struct icmap_notify_value old_val,
void *user_data)
#else
static void main_logging_notify(
cmap_handle_t cmap_handle_unused,
cmap_handle_t cmap_track_handle_unused,
int32_t event,
const char *key_name,
struct cmap_notify_value new_val,
struct cmap_notify_value old_val,
void *user_data)
#endif
{
const char *error_string;
static int reload_in_progress = 0;
/* If a full reload happens then suspend updates for individual keys until
* it's all completed
*/
if (strcmp(key_name, "config.reload_in_progress") == 0) {
if (*(uint8_t *)new_val.data == 1) {
reload_in_progress = 1;
} else {
reload_in_progress = 0;
}
}
if (reload_in_progress) {
log_printf(LOGSYS_LEVEL_DEBUG, "Ignoring key change, reload in progress. %s\n", key_name);
return;
}
/*
* Reload the logsys configuration
*/
if (logsys_format_set(NULL) == -1) {
fprintf (stderr, "Unable to setup logging format.\n");
}
corosync_main_config_read_logging(&error_string);
}
#ifdef LOGCONFIG_USE_ICMAP
static void add_logsys_config_notification(void)
{
icmap_track_t icmap_track = NULL;
icmap_track_add("logging.",
ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX,
main_logging_notify,
NULL,
&icmap_track);
icmap_track_add("config.reload_in_progress",
ICMAP_TRACK_ADD | ICMAP_TRACK_MODIFY,
main_logging_notify,
NULL,
&icmap_track);
}
extern int totem_config_read (
struct totem_config *totem_config,
const char **error_string,
uint64_t *warnings)
{
int res = 0;
char *str;
unsigned int ringnumber = 0;
int member_count = 0;
icmap_iter_t iter, member_iter;
const char *iter_key;
const char *member_iter_key;
char ringnumber_key[ICMAP_KEYNAME_MAXLEN];
char tmp_key[ICMAP_KEYNAME_MAXLEN];
uint8_t u8;
uint16_t u16;
char *cluster_name = NULL;
int i;
int local_node_pos;
int nodeid_set;
*warnings = 0;
memset (totem_config, 0, sizeof (struct totem_config));
totem_config->interfaces = malloc (sizeof (struct totem_interface) * INTERFACE_MAX);
if (totem_config->interfaces == 0) {
*error_string = "Out of memory trying to allocate ethernet interface storage area";
return -1;
}
memset (totem_config->interfaces, 0,
sizeof (struct totem_interface) * INTERFACE_MAX);
strcpy (totem_config->rrp_mode, "none");
icmap_get_uint32("totem.version", (uint32_t *)&totem_config->version);
totem_get_crypto(totem_config);
if (icmap_get_string("totem.rrp_mode", &str) == CS_OK) {
strcpy (totem_config->rrp_mode, str);
free(str);
}
icmap_get_uint32("totem.nodeid", &totem_config->node_id);
totem_config->clear_node_high_bit = 0;
if (icmap_get_string("totem.clear_node_high_bit", &str) == CS_OK) {
if (strcmp (str, "yes") == 0) {
totem_config->clear_node_high_bit = 1;
}
free(str);
}
icmap_get_uint32("totem.threads", &totem_config->threads);
icmap_get_uint32("totem.netmtu", &totem_config->net_mtu);
icmap_get_string("totem.cluster_name", &cluster_name);
/*
* Get things that might change in the future
*/
totem_volatile_config_read(totem_config);
if (icmap_get_string("totem.interface.0.bindnetaddr", &str) != CS_OK) {
/*
* We were not able to find ring 0 bindnet addr. Try to use nodelist informations
*/
config_convert_nodelist_to_interface(totem_config);
} else {
free(str);
}
iter = icmap_iter_init("totem.interface.");
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "totem.interface.%[^.].%s", ringnumber_key, tmp_key);
if (res != 2) {
continue;
}
if (strcmp(tmp_key, "bindnetaddr") != 0) {
continue;
}
member_count = 0;
ringnumber = atoi(ringnumber_key);
/*
* Get the bind net address
*/
if (icmap_get_string(iter_key, &str) == CS_OK) {
res = totemip_parse (&totem_config->interfaces[ringnumber].bindnet, str,
totem_config->interfaces[ringnumber].mcast_addr.family);
free(str);
}
/*
* Get interface multicast address
*/
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastaddr", ringnumber);
if (icmap_get_string(tmp_key, &str) == CS_OK) {
res = totemip_parse (&totem_config->interfaces[ringnumber].mcast_addr, str, 0);
free(str);
} else {
/*
* User not specified address -> autogenerate one from cluster_name key
* (if available)
*/
res = get_cluster_mcast_addr (cluster_name,
&totem_config->interfaces[ringnumber].bindnet,
ringnumber,
&totem_config->interfaces[ringnumber].mcast_addr);
}
totem_config->broadcast_use = 0;
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.broadcast", ringnumber);
if (icmap_get_string(tmp_key, &str) == CS_OK) {
if (strcmp (str, "yes") == 0) {
totem_config->broadcast_use = 1;
totemip_parse (
&totem_config->interfaces[ringnumber].mcast_addr,
"255.255.255.255", 0);
}
free(str);
}
/*
* Get mcast port
*/
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastport", ringnumber);
if (icmap_get_uint16(tmp_key, &totem_config->interfaces[ringnumber].ip_port) != CS_OK) {
if (totem_config->broadcast_use) {
totem_config->interfaces[ringnumber].ip_port = DEFAULT_PORT + (2 * ringnumber);
} else {
totem_config->interfaces[ringnumber].ip_port = DEFAULT_PORT;
}
}
/*
* Get the TTL
*/
totem_config->interfaces[ringnumber].ttl = 1;
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.ttl", ringnumber);
if (icmap_get_uint8(tmp_key, &u8) == CS_OK) {
totem_config->interfaces[ringnumber].ttl = u8;
}
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.member.", ringnumber);
member_iter = icmap_iter_init(tmp_key);
while ((member_iter_key = icmap_iter_next(member_iter, NULL, NULL)) != NULL) {
if (member_count == 0) {
if (icmap_get_string("nodelist.node.0.ring0_addr", &str) == CS_OK) {
free(str);
*warnings |= TOTEM_CONFIG_WARNING_MEMBERS_IGNORED;
break;
} else {
*warnings |= TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED;
}
}
if (icmap_get_string(member_iter_key, &str) == CS_OK) {
res = totemip_parse (&totem_config->interfaces[ringnumber].member_list[member_count++],
str, 0);
}
}
icmap_iter_finalize(member_iter);
totem_config->interfaces[ringnumber].member_count = member_count;
totem_config->interface_count++;
}
icmap_iter_finalize(iter);
/*
* Store automatically generated items back to icmap
*/
for (i = 0; i < totem_config->interface_count; i++) {
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastaddr", i);
if (icmap_get_string(tmp_key, &str) == CS_OK) {
free(str);
} else {
str = (char *)totemip_print(&totem_config->interfaces[i].mcast_addr);
icmap_set_string(tmp_key, str);
}
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.mcastport", i);
if (icmap_get_uint16(tmp_key, &u16) != CS_OK) {
icmap_set_uint16(tmp_key, totem_config->interfaces[i].ip_port);
}
}
totem_config->transport_number = TOTEM_TRANSPORT_UDP;
if (icmap_get_string("totem.transport", &str) == CS_OK) {
if (strcmp (str, "udpu") == 0) {
totem_config->transport_number = TOTEM_TRANSPORT_UDPU;
}
if (strcmp (str, "iba") == 0) {
totem_config->transport_number = TOTEM_TRANSPORT_RDMA;
}
free(str);
}
free(cluster_name);
/*
* Check existence of nodelist
*/
if (icmap_get_string("nodelist.node.0.ring0_addr", &str) == CS_OK) {
free(str);
/*
* find local node
*/
local_node_pos = find_local_node_in_nodelist(totem_config);
if (local_node_pos != -1) {
icmap_set_uint32("nodelist.local_node_pos", local_node_pos);
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.nodeid", local_node_pos);
nodeid_set = (totem_config->node_id != 0);
if (icmap_get_uint32(tmp_key, &totem_config->node_id) == CS_OK && nodeid_set) {
*warnings |= TOTEM_CONFIG_WARNING_TOTEM_NODEID_IGNORED;
}
/*
* Make localnode ring0_addr read only, so we can be sure that local
* node never changes. If rebinding to other IP would be in future
* supported, this must be changed and handled properly!
*/
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.ring0_addr", local_node_pos);
icmap_set_ro_access(tmp_key, 0, 1);
icmap_set_ro_access("nodelist.local_node_pos", 0, 1);
}
put_nodelist_members_to_config(totem_config);
}
add_totem_config_notification(totem_config);
return 0;
}
static void config_convert_nodelist_to_interface(struct totem_config *totem_config)
{
icmap_iter_t iter;
const char *iter_key;
int res = 0;
int node_pos;
char tmp_key[ICMAP_KEYNAME_MAXLEN];
char tmp_key2[ICMAP_KEYNAME_MAXLEN];
char *node_addr_str;
unsigned int ringnumber = 0;
struct list_head addrs;
struct list_head *list;
struct totem_ip_if_address *if_addr;
struct totem_ip_address node_addr;
int node_found;
if (totemip_getifaddrs(&addrs) == -1) {
return ;
}
iter = icmap_iter_init("nodelist.node.");
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "nodelist.node.%u.%s", &node_pos, tmp_key);
if (res != 2) {
continue;
}
if (strcmp(tmp_key, "ring0_addr") != 0) {
continue;
}
if (icmap_get_string(iter_key, &node_addr_str) != CS_OK) {
continue ;
}
if (totemip_parse(&node_addr, node_addr_str, 0) == -1) {
free(node_addr_str);
continue ;
}
free(node_addr_str);
/*
* Try to find node in if_addrs
*/
node_found = 0;
for (list = addrs.next; list != &addrs; list = list->next) {
if_addr = list_entry(list, struct totem_ip_if_address, list);
if (totemip_equal(&node_addr, &if_addr->ip_addr)) {
node_found = 1;
break;
}
}
if (node_found) {
break ;
}
}
icmap_iter_finalize(iter);
if (node_found) {
/*
* We found node, so create interface section
*/
snprintf(tmp_key, ICMAP_KEYNAME_MAXLEN, "nodelist.node.%u.", node_pos);
iter = icmap_iter_init(tmp_key);
while ((iter_key = icmap_iter_next(iter, NULL, NULL)) != NULL) {
res = sscanf(iter_key, "nodelist.node.%u.ring%u%s", &node_pos, &ringnumber, tmp_key2);
if (res != 3 || strcmp(tmp_key2, "_addr") != 0) {
continue ;
}
if (icmap_get_string(iter_key, &node_addr_str) != CS_OK) {
continue;
}
snprintf(tmp_key2, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.bindnetaddr", ringnumber);
icmap_set_string(tmp_key2, node_addr_str);
free(node_addr_str);
}
icmap_iter_finalize(iter);
}
}
