No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/pacemakerd/pcmkd_corosync.c b/daemons/pacemakerd/pcmkd_corosync.c
	index fd5ffecaf8..b7e527d014 100644
	--- a/daemons/pacemakerd/pcmkd_corosync.c
	+++ b/daemons/pacemakerd/pcmkd_corosync.c
	@@ -1,377 +1,377 @@
	/*
	* Copyright 2010-2023 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>
	#include "pacemakerd.h"
	#include "pcmkd_corosync.h"

	#include <sys/utsname.h>
	#include <sys/stat.h> /* for calls to stat() */
	#include <libgen.h> /* For basename() and dirname() */

	#include <sys/types.h>
	#include <pwd.h> /* For getpwname() */

	#include <corosync/hdb.h>
	#include <corosync/cfg.h>
	#include <corosync/cpg.h>
	#include <corosync/cmap.h>

	#include <crm/cluster/internal.h>
	#include <crm/common/ipc.h> /* for crm_ipc_is_authentic_process */
	#include <crm/common/mainloop.h>

	#include <crm/common/ipc_internal.h> /* PCMK__SPECIAL_PID* */

	static corosync_cfg_handle_t cfg_handle = 0;
	static mainloop_timer_t *reconnect_timer = NULL;

	/* =::=::=::= CFG - Shutdown stuff =::=::=::= */

	static void
	cfg_shutdown_callback(corosync_cfg_handle_t h, corosync_cfg_shutdown_flags_t flags)
	{
	crm_info("Corosync wants to shut down: %s",
	(flags == COROSYNC_CFG_SHUTDOWN_FLAG_IMMEDIATE) ? "immediate" :
	(flags == COROSYNC_CFG_SHUTDOWN_FLAG_REGARDLESS) ? "forced" : "optional");

	/* Never allow corosync to shut down while we're running */
	corosync_cfg_replyto_shutdown(h, COROSYNC_CFG_SHUTDOWN_FLAG_NO);
	}

	static corosync_cfg_callbacks_t cfg_callbacks = {
	.corosync_cfg_shutdown_callback = cfg_shutdown_callback,
	};

	static int
	pcmk_cfg_dispatch(gpointer user_data)
	{
	corosync_cfg_handle_t handle = (corosync_cfg_handle_t ) user_data;
	cs_error_t rc = corosync_cfg_dispatch(*handle, CS_DISPATCH_ALL);

	if (rc != CS_OK) {
	return -1;
	}
	return 0;
	}

	static void
	close_cfg(void)
	{
	if (cfg_handle != 0) {
	#ifdef HAVE_COROSYNC_CFG_TRACKSTART
	/* Ideally, we would call corosync_cfg_trackstop(cfg_handle) here, but a
	* bug in corosync 3.1.1 and 3.1.2 makes it hang forever. Thankfully,
	* it's not necessary since we exit immediately after this.
	*/
	#endif
	corosync_cfg_finalize(cfg_handle);
	cfg_handle = 0;
	}
	}

	static gboolean
	cluster_reconnect_cb(gpointer data)
	{
	if (cluster_connect_cfg()) {
	mainloop_timer_del(reconnect_timer);
	reconnect_timer = NULL;
	crm_notice("Cluster reconnect succeeded");
	pacemakerd_read_config();
	restart_cluster_subdaemons();
	return G_SOURCE_REMOVE;
	} else {
	crm_info("Cluster reconnect failed "
	"(connection will be reattempted once per second)");
	}
	/*
	* In theory this will continue forever. In practice the CIB connection from
	* attrd will timeout and shut down Pacemaker when it gets bored.
	*/
	return G_SOURCE_CONTINUE;
	}


	static void
	cfg_connection_destroy(gpointer user_data)
	{
	crm_warn("Lost connection to cluster layer "
	"(connection will be reattempted once per second)");
	corosync_cfg_finalize(cfg_handle);
	cfg_handle = 0;
	reconnect_timer = mainloop_timer_add("corosync reconnect", 1000, TRUE, cluster_reconnect_cb, NULL);
	mainloop_timer_start(reconnect_timer);
	}

	void
	cluster_disconnect_cfg(void)
	{
	close_cfg();
	if (reconnect_timer != NULL) {
	/* The mainloop should be gone by this point, so this isn't necessary,
	* but cleaning up memory should make valgrind happier.
	*/
	mainloop_timer_del(reconnect_timer);
	reconnect_timer = NULL;
	}
	}

	#define cs_repeat(counter, max, code) do { \
	code; \
	if(rc == CS_ERR_TRY_AGAIN \|\| rc == CS_ERR_QUEUE_FULL) { \
	counter++; \
	crm_debug("Retrying Corosync operation after %ds", counter); \
	sleep(counter); \
	} else { \
	break; \
	} \
	} while(counter < max)

	gboolean
	cluster_connect_cfg(void)
	{
	cs_error_t rc;
	int fd = -1, retries = 0, rv;
	uid_t found_uid = 0;
	gid_t found_gid = 0;
	pid_t found_pid = 0;
	uint32_t nodeid;

	static struct mainloop_fd_callbacks cfg_fd_callbacks = {
	.dispatch = pcmk_cfg_dispatch,
	.destroy = cfg_connection_destroy,
	};

	cs_repeat(retries, 30, rc = corosync_cfg_initialize(&cfg_handle, &cfg_callbacks));

	if (rc != CS_OK) {
	crm_crit("Could not connect to Corosync CFG: %s " CRM_XS " rc=%d",
	cs_strerror(rc), rc);
	return FALSE;
	}

	rc = corosync_cfg_fd_get(cfg_handle, &fd);
	if (rc != CS_OK) {
	crm_crit("Could not get Corosync CFG descriptor: %s " CRM_XS " rc=%d",
	cs_strerror(rc), rc);
	goto bail;
	}

	/* CFG 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_crit("Rejecting Corosync CFG provider because process %lld "
	"is running as uid %lld gid %lld, not root",
	(long long) PCMK__SPECIAL_PID_AS_0(found_pid),
	(long long) found_uid, (long long) found_gid);
	goto bail;
	} else if (rv < 0) {
	crm_crit("Could not authenticate Corosync CFG provider: %s "
	CRM_XS " rc=%d", strerror(-rv), -rv);
	goto bail;
	}

	retries = 0;
	cs_repeat(retries, 30, rc = corosync_cfg_local_get(cfg_handle, &nodeid));
	if (rc != CS_OK) {
	crm_crit("Could not get local node ID from Corosync: %s "
	CRM_XS " rc=%d", cs_strerror(rc), rc);
	goto bail;
	}
	crm_debug("Corosync reports local node ID is %lu", (unsigned long) nodeid);

	#ifdef HAVE_COROSYNC_CFG_TRACKSTART
	retries = 0;
	cs_repeat(retries, 30, rc = corosync_cfg_trackstart(cfg_handle, 0));
	if (rc != CS_OK) {
	crm_crit("Could not enable Corosync CFG shutdown tracker: %s " CRM_XS " rc=%d",
	cs_strerror(rc), rc);
	goto bail;
	}
	#endif

	mainloop_add_fd("corosync-cfg", G_PRIORITY_DEFAULT, fd, &cfg_handle, &cfg_fd_callbacks);
	return TRUE;

	bail:
	corosync_cfg_finalize(cfg_handle);
	return FALSE;
	}

	void
	pcmkd_shutdown_corosync(void)
	{
	cs_error_t rc;

	if (cfg_handle == 0) {
	crm_warn("Unable to shut down Corosync: No connection");
	return;
	}
	crm_info("Asking Corosync to shut down");
	rc = corosync_cfg_try_shutdown(cfg_handle,
	COROSYNC_CFG_SHUTDOWN_FLAG_IMMEDIATE);
	if (rc == CS_OK) {
	close_cfg();
	} else {
	crm_warn("Corosync shutdown failed: %s " CRM_XS " rc=%d",
	cs_strerror(rc), rc);
	}
	}

	bool
	pcmkd_corosync_connected(void)
	{
	cpg_handle_t local_handle = 0;
	cpg_model_v1_data_t cpg_model_info = {CPG_MODEL_V1, NULL, NULL, NULL, 0};
	int fd = -1;

	if (cpg_model_initialize(&local_handle, CPG_MODEL_V1, (cpg_model_data_t *) &cpg_model_info, NULL) != CS_OK) {
	return false;
	}

	if (cpg_fd_get(local_handle, &fd) != CS_OK) {
	return false;
	}

	cpg_finalize(local_handle);

	return true;
	}

	/* =::=::=::= Configuration =::=::=::= */
	static int
	get_config_opt(uint64_t unused, cmap_handle_t object_handle, const char key, char *value,
	const char *fallback)
	{
	int rc = 0, retries = 0;

	cs_repeat(retries, 5, rc = cmap_get_string(object_handle, key, value));
	if (rc != CS_OK) {
	crm_trace("Search for %s failed %d, defaulting to %s", key, rc, fallback);
	pcmk__str_update(value, fallback);
	}
	crm_trace("%s: %s", key, *value);
	return rc;
	}

	gboolean
	pacemakerd_read_config(void)
	{
	cs_error_t rc = CS_OK;
	int retries = 0;
	cmap_handle_t local_handle;
	uint64_t config = 0;
	int fd = -1;
	uid_t found_uid = 0;
	gid_t found_gid = 0;
	pid_t found_pid = 0;
	int rv;
	enum pcmk_cluster_layer cluster_layer = pcmk_cluster_layer_unknown;
	const char *cluster_layer_s = NULL;

	// There can be only one possibility
	do {
	rc = pcmk__init_cmap(&local_handle);
	if (rc != CS_OK) {
	retries++;
	crm_info("Could not connect to Corosync CMAP: %s (retrying in %ds) "
	CRM_XS " rc=%d", cs_strerror(rc), retries, rc);
	sleep(retries);

	} else {
	break;
	}

	} while (retries < 5);

	if (rc != CS_OK) {
	crm_crit("Could not connect to Corosync CMAP: %s "
	CRM_XS " rc=%d", cs_strerror(rc), rc);
	return FALSE;
	}

	rc = cmap_fd_get(local_handle, &fd);
	if (rc != CS_OK) {
	crm_crit("Could not get Corosync CMAP descriptor: %s " CRM_XS " rc=%d",
	cs_strerror(rc), rc);
	cmap_finalize(local_handle);
	return FALSE;
	}

	/* CMAP 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_crit("Rejecting Corosync CMAP provider because process %lld "
	"is running as uid %lld gid %lld, not root",
	(long long) PCMK__SPECIAL_PID_AS_0(found_pid),
	(long long) found_uid, (long long) found_gid);
	cmap_finalize(local_handle);
	return FALSE;
	} else if (rv < 0) {
	crm_crit("Could not authenticate Corosync CMAP provider: %s "
	CRM_XS " rc=%d", strerror(-rv), -rv);
	cmap_finalize(local_handle);
	return FALSE;
	}

	cluster_layer = (enum pcmk_cluster_layer) get_cluster_type();
	cluster_layer_s = pcmk_cluster_layer_text(cluster_layer);

	if (cluster_layer != pcmk_cluster_layer_corosync) {
	crm_crit("Expected Corosync cluster layer but detected %s "
	CRM_XS " cluster_layer=%d",
	cluster_layer_s, cluster_layer);
	return FALSE;
	}

	crm_info("Reading configuration for %s cluster layer", cluster_layer_s);
	- pcmk__set_env_option(PCMK__ENV_CLUSTER_TYPE, "corosync", true);
	+ pcmk__set_env_option(PCMK__ENV_CLUSTER_TYPE, PCMK_VALUE_COROSYNC, true);

	// @COMPAT Drop at 3.0.0; added unused in 1.1.9
	- pcmk__set_env_option(PCMK__ENV_QUORUM_TYPE, "corosync", true);
	+ pcmk__set_env_option(PCMK__ENV_QUORUM_TYPE, PCMK_VALUE_COROSYNC, true);

	// If debug logging is not configured, check whether corosync has it
	if (pcmk__env_option(PCMK__ENV_DEBUG) == NULL) {
	char *debug_enabled = NULL;

	get_config_opt(config, local_handle, "logging.debug", &debug_enabled, "off");

	if (crm_is_true(debug_enabled)) {
	pcmk__set_env_option(PCMK__ENV_DEBUG, "1", true);
	if (get_crm_log_level() < LOG_DEBUG) {
	set_crm_log_level(LOG_DEBUG);
	}

	} else {
	pcmk__set_env_option(PCMK__ENV_DEBUG, "0", true);
	}

	free(debug_enabled);
	}

	if(local_handle){
	gid_t gid = 0;
	if (pcmk_daemon_user(NULL, &gid) < 0) {
	crm_warn("Could not authorize group with Corosync " CRM_XS
	" No group found for user %s", CRM_DAEMON_USER);

	} else {
	char key[PATH_MAX];
	snprintf(key, PATH_MAX, "uidgid.gid.%u", gid);
	rc = cmap_set_uint8(local_handle, key, 1);
	if (rc != CS_OK) {
	crm_warn("Could not authorize group with Corosync: %s " CRM_XS
	" group=%u rc=%d", pcmk__cs_err_str(rc), gid, rc);
	}
	}
	}
	cmap_finalize(local_handle);

	return TRUE;
	}
	diff --git a/include/crm/common/options.h b/include/crm/common/options.h
	index 2c2fac24a2..c4d93c12d1 100644
	--- a/include/crm/common/options.h
	+++ b/include/crm/common/options.h
	@@ -1,230 +1,231 @@
	/*
	* Copyright 2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__CRM_COMMON_OPTIONS__H
	# define PCMK__CRM_COMMON_OPTIONS__H

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief API related to options
	* \ingroup core
	*/

	/*
	* Cluster options
	*/

	#define PCMK_OPT_BATCH_LIMIT "batch-limit"
	#define PCMK_OPT_CLUSTER_DELAY "cluster-delay"
	#define PCMK_OPT_CLUSTER_INFRASTRUCTURE "cluster-infrastructure"
	#define PCMK_OPT_CLUSTER_IPC_LIMIT "cluster-ipc-limit"
	#define PCMK_OPT_CLUSTER_NAME "cluster-name"
	#define PCMK_OPT_CLUSTER_RECHECK_INTERVAL "cluster-recheck-interval"
	#define PCMK_OPT_CONCURRENT_FENCING "concurrent-fencing"
	#define PCMK_OPT_DC_DEADTIME "dc-deadtime"
	#define PCMK_OPT_DC_VERSION "dc-version"
	#define PCMK_OPT_ELECTION_TIMEOUT "election-timeout"
	#define PCMK_OPT_ENABLE_ACL "enable-acl"
	#define PCMK_OPT_ENABLE_STARTUP_PROBES "enable-startup-probes"
	#define PCMK_OPT_FENCE_REACTION "fence-reaction"
	#define PCMK_OPT_HAVE_WATCHDOG "have-watchdog"
	#define PCMK_OPT_JOIN_FINALIZATION_TIMEOUT "join-finalization-timeout"
	#define PCMK_OPT_JOIN_INTEGRATION_TIMEOUT "join-integration-timeout"
	#define PCMK_OPT_LOAD_THRESHOLD "load-threshold"
	#define PCMK_OPT_MAINTENANCE_MODE "maintenance-mode"
	#define PCMK_OPT_MIGRATION_LIMIT "migration-limit"
	#define PCMK_OPT_NO_QUORUM_POLICY "no-quorum-policy"
	#define PCMK_OPT_NODE_ACTION_LIMIT "node-action-limit"
	#define PCMK_OPT_NODE_HEALTH_BASE "node-health-base"
	#define PCMK_OPT_NODE_HEALTH_GREEN "node-health-green"
	#define PCMK_OPT_NODE_HEALTH_RED "node-health-red"
	#define PCMK_OPT_NODE_HEALTH_STRATEGY "node-health-strategy"
	#define PCMK_OPT_NODE_HEALTH_YELLOW "node-health-yellow"
	#define PCMK_OPT_NODE_PENDING_TIMEOUT "node-pending-timeout"
	#define PCMK_OPT_PE_ERROR_SERIES_MAX "pe-error-series-max"
	#define PCMK_OPT_PE_INPUT_SERIES_MAX "pe-input-series-max"
	#define PCMK_OPT_PE_WARN_SERIES_MAX "pe-warn-series-max"
	#define PCMK_OPT_PLACEMENT_STRATEGY "placement-strategy"
	#define PCMK_OPT_PRIORITY_FENCING_DELAY "priority-fencing-delay"
	#define PCMK_OPT_SHUTDOWN_ESCALATION "shutdown-escalation"
	#define PCMK_OPT_SHUTDOWN_LOCK "shutdown-lock"
	#define PCMK_OPT_SHUTDOWN_LOCK_LIMIT "shutdown-lock-limit"
	#define PCMK_OPT_START_FAILURE_IS_FATAL "start-failure-is-fatal"
	#define PCMK_OPT_STARTUP_FENCING "startup-fencing"
	#define PCMK_OPT_STONITH_ACTION "stonith-action"
	#define PCMK_OPT_STONITH_ENABLED "stonith-enabled"
	#define PCMK_OPT_STONITH_MAX_ATTEMPTS "stonith-max-attempts"
	#define PCMK_OPT_STONITH_TIMEOUT "stonith-timeout"
	#define PCMK_OPT_STONITH_WATCHDOG_TIMEOUT "stonith-watchdog-timeout"
	#define PCMK_OPT_STOP_ALL_RESOURCES "stop-all-resources"
	#define PCMK_OPT_STOP_ORPHAN_ACTIONS "stop-orphan-actions"
	#define PCMK_OPT_STOP_ORPHAN_RESOURCES "stop-orphan-resources"
	#define PCMK_OPT_SYMMETRIC_CLUSTER "symmetric-cluster"
	#define PCMK_OPT_TRANSITION_DELAY "transition-delay"


	/*
	* Meta-attributes
	*/

	#define PCMK_META_ALLOW_MIGRATE "allow-migrate"
	#define PCMK_META_ALLOW_UNHEALTHY_NODES "allow-unhealthy-nodes"
	#define PCMK_META_CLONE_MAX "clone-max"
	#define PCMK_META_CLONE_MIN "clone-min"
	#define PCMK_META_CLONE_NODE_MAX "clone-node-max"
	#define PCMK_META_CONTAINER_ATTRIBUTE_TARGET "container-attribute-target"
	#define PCMK_META_CRITICAL "critical"
	#define PCMK_META_ENABLED "enabled"
	#define PCMK_META_FAILURE_TIMEOUT "failure-timeout"
	#define PCMK_META_GLOBALLY_UNIQUE "globally-unique"
	#define PCMK_META_INTERLEAVE "interleave"
	#define PCMK_META_INTERVAL "interval"
	#define PCMK_META_IS_MANAGED "is-managed"
	#define PCMK_META_INTERVAL_ORIGIN "interval-origin"
	#define PCMK_META_MAINTENANCE "maintenance"
	#define PCMK_META_MIGRATION_THRESHOLD "migration-threshold"
	#define PCMK_META_MULTIPLE_ACTIVE "multiple-active"
	#define PCMK_META_NOTIFY "notify"
	#define PCMK_META_ON_FAIL "on-fail"
	#define PCMK_META_ORDERED "ordered"
	#define PCMK_META_PRIORITY "priority"
	#define PCMK_META_PROMOTABLE "promotable"
	#define PCMK_META_PROMOTED_MAX "promoted-max"
	#define PCMK_META_PROMOTED_NODE_MAX "promoted-node-max"
	#define PCMK_META_RECORD_PENDING "record-pending"
	#define PCMK_META_REMOTE_ADDR "remote-addr"
	#define PCMK_META_REMOTE_ALLOW_MIGRATE "remote-allow-migrate"
	#define PCMK_META_REMOTE_CONNECT_TIMEOUT "remote-connect-timeout"
	#define PCMK_META_REMOTE_NODE "remote-node"
	#define PCMK_META_REMOTE_PORT "remote-port"
	#define PCMK_META_REQUIRES "requires"
	#define PCMK_META_RESOURCE_STICKINESS "resource-stickiness"
	#define PCMK_META_START_DELAY "start-delay"
	#define PCMK_META_TARGET_ROLE "target-role"
	#define PCMK_META_TIMEOUT "timeout"
	#define PCMK_META_TIMESTAMP_FORMAT "timestamp-format"


	/*
	* Remote resource instance attributes
	*/

	#define PCMK_REMOTE_RA_ADDR "addr"
	#define PCMK_REMOTE_RA_PORT "port"
	#define PCMK_REMOTE_RA_RECONNECT_INTERVAL "reconnect_interval"
	#define PCMK_REMOTE_RA_SERVER "server"


	/*
	* Enumerated values
	*/

	#define PCMK_VALUE_ALWAYS "always"
	#define PCMK_VALUE_AND "and"
	#define PCMK_VALUE_BALANCED "balanced"
	#define PCMK_VALUE_BLOCK "block"
	#define PCMK_VALUE_BOOLEAN "boolean"
	#define PCMK_VALUE_CIB_BOOTSTRAP_OPTIONS "cib-bootstrap-options"
	+#define PCMK_VALUE_COROSYNC "corosync"
	#define PCMK_VALUE_CREATE "create"
	#define PCMK_VALUE_CUSTOM "custom"
	#define PCMK_VALUE_DATE_SPEC "date_spec"
	#define PCMK_VALUE_DEFAULT "default"
	#define PCMK_VALUE_DEFINED "defined"
	#define PCMK_VALUE_DELETE "delete"
	#define PCMK_VALUE_DEMOTE "demote"
	#define PCMK_VALUE_DENY "deny"
	#define PCMK_VALUE_DURATION "duration"
	#define PCMK_VALUE_DYNAMIC_LIST "dynamic-list"
	#define PCMK_VALUE_EQ "eq"
	#define PCMK_VALUE_EXCLUSIVE "exclusive"
	#define PCMK_VALUE_FAILED "failed"
	#define PCMK_VALUE_FALSE "false"
	#define PCMK_VALUE_FENCE "fence"
	#define PCMK_VALUE_FENCING "fencing"
	#define PCMK_VALUE_FREEZE "freeze"
	#define PCMK_VALUE_GRANTED "granted"
	#define PCMK_VALUE_GREEN "green"
	#define PCMK_VALUE_GT "gt"
	#define PCMK_VALUE_GTE "gte"
	#define PCMK_VALUE_HOST "host"
	#define PCMK_VALUE_IGNORE "ignore"
	#define PCMK_VALUE_IN_RANGE "in_range"
	#define PCMK_VALUE_INFINITY "INFINITY"
	#define PCMK_VALUE_INTEGER "integer"
	#define PCMK_VALUE_LITERAL "literal"
	#define PCMK_VALUE_LT "lt"
	#define PCMK_VALUE_LTE "lte"
	#define PCMK_VALUE_MANDATORY "Mandatory"
	#define PCMK_VALUE_MEMBER "member"
	#define PCMK_VALUE_META "meta"
	#define PCMK_VALUE_MIGRATE_ON_RED "migrate-on-red"
	#define PCMK_VALUE_MINIMAL "minimal"
	#define PCMK_VALUE_MINUS_INFINITY "-" PCMK_VALUE_INFINITY
	#define PCMK_VALUE_MODIFY "modify"
	#define PCMK_VALUE_MOVE "move"
	#define PCMK_VALUE_NE "ne"
	#define PCMK_VALUE_NEVER "never"
	#define PCMK_VALUE_NONE "none"
	#define PCMK_VALUE_NONNEGATIVE_INTEGER "nonnegative_integer"
	#define PCMK_VALUE_NOT_DEFINED "not_defined"
	#define PCMK_VALUE_NOTHING "nothing"
	#define PCMK_VALUE_NUMBER "number"
	#define PCMK_VALUE_OFFLINE "offline"
	#define PCMK_VALUE_ONLINE "online"
	#define PCMK_VALUE_ONLY_GREEN "only-green"
	#define PCMK_VALUE_OPTIONAL "Optional"
	#define PCMK_VALUE_OR "or"
	#define PCMK_VALUE_PANIC "panic"
	#define PCMK_VALUE_PARAM "param"
	#define PCMK_VALUE_PENDING "pending"
	#define PCMK_VALUE_PERCENTAGE "percentage"
	#define PCMK_VALUE_PLUS_INFINITY "+" PCMK_VALUE_INFINITY
	#define PCMK_VALUE_PORT "port"
	#define PCMK_VALUE_PROGRESSIVE "progressive"
	#define PCMK_VALUE_QUORUM "quorum"
	#define PCMK_VALUE_READ "read"
	#define PCMK_VALUE_RED "red"
	#define PCMK_VALUE_REMOTE "remote"
	#define PCMK_VALUE_RESTART "restart"
	#define PCMK_VALUE_RESTART_CONTAINER "restart-container"
	#define PCMK_VALUE_REVOKED "revoked"
	#define PCMK_VALUE_SCORE "score"
	#define PCMK_VALUE_SELECT "select"
	#define PCMK_VALUE_SERIALIZE "Serialize"
	#define PCMK_VALUE_STANDBY "standby"
	#define PCMK_VALUE_STATIC_LIST "static-list"
	#define PCMK_VALUE_STATUS "status"
	#define PCMK_VALUE_STRING "string"
	#define PCMK_VALUE_STOP "stop"
	#define PCMK_VALUE_STOP_ONLY "stop_only"
	#define PCMK_VALUE_STOP_START "stop_start"
	#define PCMK_VALUE_STOP_UNEXPECTED "stop_unexpected"
	#define PCMK_VALUE_SUCCESS "success"
	#define PCMK_VALUE_TIMEOUT "timeout"
	#define PCMK_VALUE_TRUE "true"
	#define PCMK_VALUE_UNFENCING "unfencing"
	#define PCMK_VALUE_UNKNOWN "unknown"
	#define PCMK_VALUE_UTILIZATION "utilization"
	#define PCMK_VALUE_VERSION "version"
	#define PCMK_VALUE_WRITE "write"
	#define PCMK_VALUE_YELLOW "yellow"

	// @COMPAT This will become a deprecated alias for PCMK_VALUE_FENCE (see T279)
	#define PCMK_VALUE_FENCE_LEGACY "suicide"


	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_COMMON_OPTIONS__H
	diff --git a/lib/cluster/cluster.c b/lib/cluster/cluster.c
	index 7f73098be8..f66e2952b8 100644
	--- a/lib/cluster/cluster.c
	+++ b/lib/cluster/cluster.c
	@@ -1,454 +1,454 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>
	#include <dlfcn.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <string.h>
	#include <stdlib.h>
	#include <time.h>
	#include <sys/param.h>
	#include <sys/types.h>

	#include <crm/crm.h>

	#include <crm/common/ipc.h>
	#include <crm/common/xml.h>
	#include <crm/cluster/internal.h>
	#include "crmcluster_private.h"

	CRM_TRACE_INIT_DATA(cluster);

	/*!
	* \brief Get (and set if needed) a node's UUID
	*
	* \param[in,out] peer Node to check
	*
	* \return Node UUID of \p peer, or NULL if unknown
	*/
	const char *
	crm_peer_uuid(crm_node_t *peer)
	{
	char *uuid = NULL;

	// Check simple cases first, to avoid any calls that might block
	if (peer == NULL) {
	return NULL;
	}
	if (peer->uuid != NULL) {
	return peer->uuid;
	}

	switch (get_cluster_type()) {
	case pcmk_cluster_corosync:
	#if SUPPORT_COROSYNC
	uuid = pcmk__corosync_uuid(peer);
	#endif
	break;

	case pcmk_cluster_unknown:
	case pcmk_cluster_invalid:
	crm_err("Unsupported cluster type");
	break;
	}

	peer->uuid = uuid;
	return peer->uuid;
	}

	/*!
	* \internal
	* \brief Connect to the cluster layer
	*
	* \param[in,out] cluster Initialized cluster object to connect
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk_cluster_connect(crm_cluster_t *cluster)
	{
	const enum pcmk_cluster_layer cluster_layer =
	(enum pcmk_cluster_layer) get_cluster_type();
	const char *cluster_layer_s = pcmk_cluster_layer_text(cluster_layer);

	crm_notice("Connecting to %s cluster layer", cluster_layer_s);

	switch (cluster_layer) {
	case pcmk_cluster_layer_corosync:
	#if SUPPORT_COROSYNC
	crm_peer_init();
	return pcmk__corosync_connect(cluster);
	#else
	break;
	#endif // SUPPORT_COROSYNC
	default:
	break;
	}

	crm_err("Failed to connect to unsupported cluster layer %s",
	cluster_layer_s);
	return EPROTONOSUPPORT;
	}

	/*!
	* \brief Disconnect from the cluster layer
	*
	* \param[in,out] cluster Cluster object to disconnect
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk_cluster_disconnect(crm_cluster_t *cluster)
	{
	const enum pcmk_cluster_layer cluster_layer =
	(enum pcmk_cluster_layer) get_cluster_type();
	const char *cluster_layer_s = pcmk_cluster_layer_text(cluster_layer);

	crm_info("Disconnecting from %s cluster layer", cluster_layer_s);

	switch (cluster_layer) {
	case pcmk_cluster_layer_corosync:
	#if SUPPORT_COROSYNC
	crm_peer_destroy();
	pcmk__corosync_disconnect(cluster);
	return pcmk_rc_ok;
	#else
	break;
	#endif // SUPPORT_COROSYNC
	default:
	break;
	}

	crm_err("Failed to disconnect from unsupported cluster layer %s",
	cluster_layer_s);
	return EPROTONOSUPPORT;
	}

	/*!
	* \brief Allocate a new \p crm_cluster_t object
	*
	* \return A newly allocated \p crm_cluster_t object (guaranteed not \c NULL)
	* \note The caller is responsible for freeing the return value using
	* \p pcmk_cluster_free().
	*/
	crm_cluster_t *
	pcmk_cluster_new(void)
	{
	return (crm_cluster_t *) pcmk__assert_alloc(1, sizeof(crm_cluster_t));
	}

	/*!
	* \brief Free a \p crm_cluster_t object and its dynamically allocated members
	*
	* \param[in,out] cluster Cluster object to free
	*/
	void
	pcmk_cluster_free(crm_cluster_t *cluster)
	{
	if (cluster == NULL) {
	return;
	}
	free(cluster->uuid);
	free(cluster->uname);
	free(cluster);
	}

	/*!
	* \brief Send an XML message via the cluster messaging layer
	*
	* \param[in] node Cluster node to send message to
	* \param[in] service Message type to use in message host info
	* \param[in] data XML message to send
	* \param[in] ordered Ignored for currently supported messaging layers
	*
	* \return TRUE on success, otherwise FALSE
	*/
	gboolean
	send_cluster_message(const crm_node_t *node, enum crm_ais_msg_types service,
	const xmlNode *data, gboolean ordered)
	{
	switch (get_cluster_type()) {
	case pcmk_cluster_corosync:
	#if SUPPORT_COROSYNC
	return pcmk__cpg_send_xml(data, node, service);
	#endif
	break;
	default:
	break;
	}
	return FALSE;
	}

	/*!
	* \brief Get the local node's name
	*
	* \return Local node's name
	* \note This will fatally exit if local node name cannot be known.
	*/
	const char *
	get_local_node_name(void)
	{
	static char *name = NULL;

	if (name == NULL) {
	name = get_node_name(0);
	}
	return name;
	}

	/*!
	* \brief Get the node name corresponding to a cluster node ID
	*
	* \param[in] nodeid Node ID to check (or 0 for local node)
	*
	* \return Node name corresponding to \p nodeid
	* \note This will fatally exit if \p nodeid is 0 and local node name cannot be
	* known.
	*/
	char *
	get_node_name(uint32_t nodeid)
	{
	char *name = NULL;
	const enum pcmk_cluster_layer cluster_layer =
	(enum pcmk_cluster_layer) get_cluster_type();
	const char *cluster_layer_s = pcmk_cluster_layer_text(cluster_layer);

	switch (cluster_layer) {
	case pcmk_cluster_layer_corosync:
	#if SUPPORT_COROSYNC
	name = pcmk__corosync_name(0, nodeid);
	break;
	#endif // SUPPORT_COROSYNC

	default:
	crm_err("Unknown cluster type: %s (%d)",
	cluster_layer_s, cluster_layer);
	}

	if ((name == NULL) && (nodeid == 0)) {
	name = pcmk_hostname();
	if (name == NULL) {
	// @TODO Maybe let the caller decide what to do
	crm_err("Could not obtain the local %s node name", cluster_layer_s);
	crm_exit(CRM_EX_FATAL);
	}
	crm_notice("Defaulting to uname -n for the local %s node name",
	cluster_layer_s);
	}

	if (name == NULL) {
	crm_notice("Could not obtain a node name for %s node with "
	PCMK_XA_ID " %u",
	cluster_layer_s, nodeid);
	}
	return name;
	}

	/*!
	* \brief Get the node name corresponding to a node UUID
	*
	* \param[in] uuid UUID of desired node
	*
	* \return name of desired node
	*
	* \note This relies on the remote peer cache being populated with all
	* remote nodes in the cluster, so callers should maintain that cache.
	*/
	const char *
	crm_peer_uname(const char *uuid)
	{
	GHashTableIter iter;
	crm_node_t *node = NULL;

	CRM_CHECK(uuid != NULL, return NULL);

	/* remote nodes have the same uname and uuid */
	if (g_hash_table_lookup(crm_remote_peer_cache, uuid)) {
	return uuid;
	}

	/* avoid blocking calls where possible */
	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
	if (pcmk__str_eq(node->uuid, uuid, pcmk__str_casei)) {
	if (node->uname != NULL) {
	return node->uname;
	}
	break;
	}
	}
	node = NULL;

	if (is_corosync_cluster()) {
	long long id;

	if ((pcmk__scan_ll(uuid, &id, 0LL) != pcmk_rc_ok)
	\|\| (id < 1LL) \|\| (id > UINT32_MAX)) {
	crm_err("Invalid Corosync node ID '%s'", uuid);
	return NULL;
	}

	node = pcmk__search_node_caches((uint32_t) id, NULL,
	pcmk__node_search_cluster);
	if (node != NULL) {
	crm_info("Setting uuid for node %s[%u] to %s",
	node->uname, node->id, uuid);
	node->uuid = strdup(uuid);
	return node->uname;
	}
	return NULL;
	}

	return NULL;
	}

	/*!
	* \brief Get a log-friendly string equivalent of a cluster layer
	*
	* \param[in] layer Cluster layer
	*
	* \return Log-friendly string corresponding to \p layer
	*/
	const char *
	pcmk_cluster_layer_text(enum pcmk_cluster_layer layer)
	{
	switch (layer) {
	case pcmk_cluster_layer_corosync:
	return "corosync";
	case pcmk_cluster_layer_unknown:
	return "unknown";
	case pcmk_cluster_layer_invalid:
	return "invalid";
	default:
	crm_err("Invalid cluster layer: %d", layer);
	return "invalid";
	}
	}

	/*!
	* \brief Get (and validate) the local cluster type
	*
	* \return Local cluster type
	* \note This will fatally exit if the local cluster type is invalid.
	*/
	enum cluster_type_e
	get_cluster_type(void)
	{
	bool detected = false;
	const char *cluster = NULL;
	static enum cluster_type_e cluster_type = pcmk_cluster_unknown;

	/* Return the previous calculation, if any */
	if (cluster_type != pcmk_cluster_unknown) {
	return cluster_type;
	}

	cluster = pcmk__env_option(PCMK__ENV_CLUSTER_TYPE);

	#if SUPPORT_COROSYNC
	/* If nothing is defined in the environment, try corosync (if supported) */
	if (cluster == NULL) {
	crm_debug("Testing with Corosync");
	cluster_type = pcmk__corosync_detect();
	if (cluster_type != pcmk_cluster_unknown) {
	detected = true;
	goto done;
	}
	}
	#endif

	/* Something was defined in the environment, test it against what we support */
	crm_info("Verifying cluster type: '%s'",
	((cluster == NULL)? "-unspecified-" : cluster));
	if (cluster == NULL) {

	#if SUPPORT_COROSYNC
	- } else if (pcmk__str_eq(cluster, "corosync", pcmk__str_casei)) {
	+ } else if (pcmk__str_eq(cluster, PCMK_VALUE_COROSYNC, pcmk__str_casei)) {
	cluster_type = pcmk_cluster_corosync;
	#endif

	} else {
	cluster_type = pcmk_cluster_invalid;
	goto done; /* Keep the compiler happy when no stacks are supported */
	}

	done:
	if (cluster_type == pcmk_cluster_unknown) {
	crm_notice("Could not determine the current cluster type");

	} else if (cluster_type == pcmk_cluster_invalid) {
	crm_notice("This installation does not support the '%s' cluster infrastructure: terminating.",
	cluster);
	crm_exit(CRM_EX_FATAL);

	} else {
	const enum pcmk_cluster_layer cluster_layer =
	(enum pcmk_cluster_layer) cluster_type;

	crm_info("%s an active '%s' cluster",
	(detected? "Detected" : "Assuming"),
	pcmk_cluster_layer_text(cluster_layer));
	}

	return cluster_type;
	}

	/*!
	* \brief Check whether the local cluster is a Corosync cluster
	*
	* \return TRUE if the local cluster is a Corosync cluster, otherwise FALSE
	*/
	gboolean
	is_corosync_cluster(void)
	{
	return get_cluster_type() == pcmk_cluster_corosync;
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/cluster/compat.h>

	void
	set_uuid(xmlNode xml, const char attr, crm_node_t *node)
	{
	crm_xml_add(xml, attr, crm_peer_uuid(node));
	}

	gboolean
	crm_cluster_connect(crm_cluster_t *cluster)
	{
	return pcmk_cluster_connect(cluster) == pcmk_rc_ok;
	}

	void
	crm_cluster_disconnect(crm_cluster_t *cluster)
	{
	pcmk_cluster_disconnect(cluster);
	}

	const char *
	name_for_cluster_type(enum cluster_type_e type)
	{
	switch (type) {
	case pcmk_cluster_corosync:
	return "corosync";
	case pcmk_cluster_unknown:
	return "unknown";
	case pcmk_cluster_invalid:
	return "invalid";
	}
	crm_err("Invalid cluster type: %d", type);
	return "invalid";
	}

	// LCOV_EXCL_STOP
	// End deprecated API

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:41 PM (2 h, 4 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1988922
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions