No OneTemporary
Actions

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/based/pacemaker-based.c b/daemons/based/pacemaker-based.c
	index 470eaf57f5..35401ea276 100644
	--- a/daemons/based/pacemaker-based.c
	+++ b/daemons/based/pacemaker-based.c
	@@ -1,450 +1,450 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <pwd.h>
	#include <grp.h>
	#include <bzlib.h>
	#include <sys/types.h>

	#include <glib.h>
	#include <libxml/tree.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/cluster/internal.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/mainloop.h>
	#include <crm/common/output_internal.h>
	#include <crm/common/xml.h>

	#include <pacemaker-based.h>

	#define SUMMARY "daemon for managing the configuration of a Pacemaker cluster"

	extern int init_remote_listener(int port, gboolean encrypted);
	gboolean cib_shutdown_flag = FALSE;
	int cib_status = pcmk_ok;

	crm_cluster_t *crm_cluster = NULL;

	GMainLoop *mainloop = NULL;
	gchar *cib_root = NULL;
	static gboolean preserve_status = FALSE;

	gboolean cib_writes_enabled = TRUE;
	gboolean stand_alone = FALSE;

	int remote_fd = 0;
	int remote_tls_fd = 0;

	GHashTable *config_hash = NULL;
	GHashTable *local_notify_queue = NULL;

	static void cib_init(void);
	void cib_shutdown(int nsig);
	static bool startCib(const char *filename);
	extern int write_cib_contents(gpointer p);

	static crm_exit_t exit_code = CRM_EX_OK;

	static void
	cib_enable_writes(int nsig)
	{
	crm_info("(Re)enabling disk writes");
	cib_writes_enabled = TRUE;
	}

	/*!
	* \internal
	* \brief Set up options, users, and groups for stand-alone mode
	*
	* \param[out] error GLib error object
	*
	* \return Standard Pacemaker return code
	*/
	static int
	setup_stand_alone(GError **error)
	{
	int rc = 0;
	struct passwd *pwentry = NULL;

	preserve_status = TRUE;
	cib_writes_enabled = FALSE;

	errno = 0;
	pwentry = getpwnam(CRM_DAEMON_USER);
	if (pwentry == NULL) {
	exit_code = CRM_EX_FATAL;
	if (errno != 0) {
	g_set_error(error, PCMK__EXITC_ERROR, exit_code,
	"Error getting password DB entry for %s: %s",
	CRM_DAEMON_USER, strerror(errno));
	return errno;
	}
	g_set_error(error, PCMK__EXITC_ERROR, exit_code,
	"Password DB entry for '%s' not found", CRM_DAEMON_USER);
	return ENXIO;
	}

	rc = setgid(pwentry->pw_gid);
	if (rc < 0) {
	exit_code = CRM_EX_FATAL;
	g_set_error(error, PCMK__EXITC_ERROR, exit_code,
	"Could not set group to %d: %s",
	pwentry->pw_gid, strerror(errno));
	return errno;
	}

	rc = initgroups(CRM_DAEMON_USER, pwentry->pw_gid);
	if (rc < 0) {
	exit_code = CRM_EX_FATAL;
	g_set_error(error, PCMK__EXITC_ERROR, exit_code,
	"Could not setup groups for user %d: %s",
	pwentry->pw_uid, strerror(errno));
	return errno;
	}

	rc = setuid(pwentry->pw_uid);
	if (rc < 0) {
	exit_code = CRM_EX_FATAL;
	g_set_error(error, PCMK__EXITC_ERROR, exit_code,
	"Could not set user to %d: %s",
	pwentry->pw_uid, strerror(errno));
	return errno;
	}
	return pcmk_rc_ok;
	}

	-/* @COMPAT Deprecated since 2.1.8; use pcmk_cluster_list_options() or
	- * crm_attribute --list-options instead of querying daemon metadata.
	+/* @COMPAT Deprecated since 2.1.8. Use pcmk_list_cluster_options() or
	+ * crm_attribute --list-options=cluster instead of querying daemon metadata.
	*/
	static int
	based_metadata(pcmk__output_t *out)
	{
	return pcmk__daemon_metadata(out, "pacemaker-based",
	"Cluster Information Base manager options",
	"Cluster options used by Pacemaker's Cluster "
	"Information Base manager",
	pcmk__opt_based);
	}

	static GOptionEntry entries[] = {
	{ "stand-alone", 's', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, &stand_alone,
	"(Advanced use only) Run in stand-alone mode", NULL },

	{ "disk-writes", 'w', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE,
	&cib_writes_enabled,
	"(Advanced use only) Enable disk writes (enabled by default unless in "
	"stand-alone mode)", NULL },

	{ "cib-root", 'r', G_OPTION_FLAG_NONE, G_OPTION_ARG_FILENAME, &cib_root,
	"(Advanced use only) Directory where the CIB XML file should be located "
	"(default: " CRM_CONFIG_DIR ")", NULL },

	{ NULL }
	};

	static pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group)
	{
	GOptionContext *context = NULL;

	context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	pcmk__add_main_args(context, entries);
	return context;
	}

	int
	main(int argc, char **argv)
	{
	int rc = pcmk_rc_ok;
	crm_ipc_t *old_instance = NULL;

	pcmk__output_t *out = NULL;

	GError *error = NULL;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, "r");
	GOptionContext *context = build_arg_context(args, &output_group);

	crm_log_preinit(NULL, argc, argv);

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_ERROR;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Error creating output format %s: %s",
	args->output_ty, pcmk_rc_str(rc));
	goto done;
	}

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	mainloop_add_signal(SIGTERM, cib_shutdown);
	mainloop_add_signal(SIGPIPE, cib_enable_writes);

	cib_writer = mainloop_add_trigger(G_PRIORITY_LOW, write_cib_contents, NULL);

	if ((g_strv_length(processed_args) >= 2)
	&& pcmk__str_eq(processed_args[1], "metadata", pcmk__str_none)) {

	rc = based_metadata(out);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unable to display metadata: %s", pcmk_rc_str(rc));
	}
	goto done;
	}

	pcmk__cli_init_logging("pacemaker-based", args->verbosity);
	crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);
	crm_notice("Starting Pacemaker CIB manager");

	old_instance = crm_ipc_new(PCMK__SERVER_BASED_RO, 0);
	if (old_instance == NULL) {
	/* crm_ipc_new() will have already logged an error message with
	* crm_err()
	*/
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	if (pcmk__connect_generic_ipc(old_instance) == pcmk_rc_ok) {
	/* IPC end-point already up */
	crm_ipc_close(old_instance);
	crm_ipc_destroy(old_instance);
	crm_err("pacemaker-based is already active, aborting startup");
	goto done;
	} else {
	/* not up or not authentic, we'll proceed either way */
	crm_ipc_destroy(old_instance);
	old_instance = NULL;
	}

	if (stand_alone) {
	rc = setup_stand_alone(&error);
	if (rc != pcmk_rc_ok) {
	goto done;
	}
	}

	if (cib_root == NULL) {
	cib_root = g_strdup(CRM_CONFIG_DIR);
	} else {
	crm_notice("Using custom config location: %s", cib_root);
	}

	if (!pcmk__daemon_can_write(cib_root, NULL)) {
	exit_code = CRM_EX_FATAL;
	crm_err("Terminating due to bad permissions on %s", cib_root);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Bad permissions on %s (see logs for details)", cib_root);
	goto done;
	}

	crm_peer_init();

	// Read initial CIB, connect to cluster, and start IPC servers
	cib_init();

	// Run the main loop
	mainloop = g_main_loop_new(NULL, FALSE);
	crm_notice("Pacemaker CIB manager successfully started and accepting connections");
	g_main_loop_run(mainloop);

	/* If main loop returned, clean up and exit. We disconnect in case
	* terminate_cib() was called with fast=-1.
	*/
	crm_cluster_disconnect(crm_cluster);
	pcmk__stop_based_ipc(ipcs_ro, ipcs_rw, ipcs_shm);

	done:
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	crm_peer_destroy();

	if (local_notify_queue != NULL) {
	g_hash_table_destroy(local_notify_queue);
	}

	if (config_hash != NULL) {
	g_hash_table_destroy(config_hash);
	}
	pcmk__client_cleanup();
	pcmk_cluster_free(crm_cluster);
	g_free(cib_root);

	pcmk__output_and_clear_error(&error, out);

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}
	pcmk__unregister_formats();
	crm_exit(exit_code);
	}

	#if SUPPORT_COROSYNC
	static void
	cib_cs_dispatch(cpg_handle_t handle,
	const struct cpg_name *groupName,
	uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
	{
	uint32_t kind = 0;
	xmlNode *xml = NULL;
	const char *from = NULL;
	char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);

	if(data == NULL) {
	return;
	}
	if (kind == crm_class_cluster) {
	xml = pcmk__xml_parse(data);
	if (xml == NULL) {
	crm_err("Invalid XML: '%.120s'", data);
	free(data);
	return;
	}
	crm_xml_add(xml, PCMK__XA_SRC, from);
	cib_peer_callback(xml, NULL);
	}

	free_xml(xml);
	free(data);
	}

	static void
	cib_cs_destroy(gpointer user_data)
	{
	if (cib_shutdown_flag) {
	crm_info("Corosync disconnection complete");
	} else {
	crm_crit("Lost connection to cluster layer, shutting down");
	terminate_cib(__func__, CRM_EX_DISCONNECT);
	}
	}
	#endif

	static void
	cib_peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
	{
	switch (type) {
	case crm_status_processes:
	if (cib_legacy_mode()
	&& !pcmk_is_set(node->processes, crm_get_cluster_proc())) {

	uint32_t old = data? (const uint32_t )data : 0;

	if ((node->processes ^ old) & crm_proc_cpg) {
	crm_info("Attempting to disable legacy mode after %s left the cluster",
	node->uname);
	legacy_mode = FALSE;
	}
	}
	break;

	case crm_status_uname:
	case crm_status_nstate:
	if (cib_shutdown_flag && (crm_active_peers() < 2)
	&& (pcmk__ipc_client_count() == 0)) {

	crm_info("No more peers");
	terminate_cib(__func__, -1);
	}
	break;
	}
	}

	static void
	cib_init(void)
	{
	crm_cluster = pcmk_cluster_new();

	#if SUPPORT_COROSYNC
	if (is_corosync_cluster()) {
	crm_cluster->destroy = cib_cs_destroy;
	crm_cluster->cpg.cpg_deliver_fn = cib_cs_dispatch;
	crm_cluster->cpg.cpg_confchg_fn = pcmk_cpg_membership;
	}
	#endif // SUPPORT_COROSYNC

	config_hash = pcmk__strkey_table(free, free);

	if (startCib("cib.xml") == FALSE) {
	crm_crit("Cannot start CIB... terminating");
	crm_exit(CRM_EX_NOINPUT);
	}

	if (!stand_alone) {
	crm_set_status_callback(&cib_peer_update_callback);

	if (!crm_cluster_connect(crm_cluster)) {
	crm_crit("Cannot sign in to the cluster... terminating");
	crm_exit(CRM_EX_FATAL);
	}
	}

	pcmk__serve_based_ipc(&ipcs_ro, &ipcs_rw, &ipcs_shm, &ipc_ro_callbacks,
	&ipc_rw_callbacks);

	if (stand_alone) {
	based_is_primary = true;
	}
	}

	static bool
	startCib(const char *filename)
	{
	gboolean active = FALSE;
	xmlNode *cib = readCibXmlFile(cib_root, filename, !preserve_status);

	if (activateCibXml(cib, TRUE, "start") == 0) {
	int port = 0;

	active = TRUE;

	cib_read_config(config_hash, cib);

	pcmk__scan_port(crm_element_value(cib, PCMK_XA_REMOTE_TLS_PORT), &port);
	if (port >= 0) {
	remote_tls_fd = init_remote_listener(port, TRUE);
	}

	pcmk__scan_port(crm_element_value(cib, PCMK_XA_REMOTE_CLEAR_PORT),
	&port);
	if (port >= 0) {
	remote_fd = init_remote_listener(port, FALSE);
	}
	}
	return active;
	}
	diff --git a/daemons/controld/pacemaker-controld.c b/daemons/controld/pacemaker-controld.c
	index ebba4f6791..bbe6de2feb 100644
	--- a/daemons/controld/pacemaker-controld.c
	+++ b/daemons/controld/pacemaker-controld.c
	@@ -1,223 +1,223 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <sys/param.h>
	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>

	#include <crm/crm.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/ipc.h>
	#include <crm/common/output_internal.h>
	#include <crm/common/xml.h>

	#include <pacemaker-controld.h>

	#define SUMMARY "daemon for coordinating a Pacemaker cluster's response " \
	"to events"

	_Noreturn void crmd_init(void);
	extern void init_dotfile(void);

	controld_globals_t controld_globals = {
	// Automatic initialization to 0, false, or NULL is fine for most members
	.fsa_state = S_STARTING,
	.fsa_actions = A_NOTHING,
	};

	static pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	-/* @COMPAT Deprecated since 2.1.8; use pcmk_cluster_list_options() or
	- * crm_attribute --list-options instead of querying daemon metadata.
	+/* @COMPAT Deprecated since 2.1.8. Use pcmk_list_cluster_options() or
	+ * crm_attribute --list-options=cluster instead of querying daemon metadata.
	*/
	static int
	controld_metadata(pcmk__output_t *out)
	{
	return pcmk__daemon_metadata(out, "pacemaker-controld",
	"Pacemaker controller options",
	"Cluster options used by Pacemaker's "
	"controller",
	pcmk__opt_controld);
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group)
	{
	return pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	}

	int
	main(int argc, char **argv)
	{
	int rc = pcmk_rc_ok;
	crm_exit_t exit_code = CRM_EX_OK;
	bool initialize = true;

	crm_ipc_t *old_instance = NULL;

	pcmk__output_t *out = NULL;

	GError *error = NULL;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, NULL);
	GOptionContext *context = build_arg_context(args, &output_group);

	crm_log_preinit(NULL, argc, argv);

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_ERROR;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Error creating output format %s: %s",
	args->output_ty, pcmk_rc_str(rc));
	goto done;
	}

	if (args->version) {
	out->version(out, false);
	initialize = false;
	goto done;
	}

	if ((g_strv_length(processed_args) >= 2)
	&& pcmk__str_eq(processed_args[1], "metadata", pcmk__str_none)) {

	initialize = false;
	rc = controld_metadata(out);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unable to display metadata: %s", pcmk_rc_str(rc));
	}
	goto done;
	}

	pcmk__cli_init_logging("pacemaker-controld", args->verbosity);
	crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);
	crm_notice("Starting Pacemaker controller");

	old_instance = crm_ipc_new(CRM_SYSTEM_CRMD, 0);
	if (old_instance == NULL) {
	/* crm_ipc_new will have already printed an error message with crm_err. */
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	if (pcmk__connect_generic_ipc(old_instance) == pcmk_rc_ok) {
	/* IPC end-point already up */
	crm_ipc_close(old_instance);
	crm_ipc_destroy(old_instance);
	crm_err("pacemaker-controld is already active, aborting startup");
	initialize = false;
	goto done;

	} else {
	/* not up or not authentic, we'll proceed either way */
	crm_ipc_destroy(old_instance);
	old_instance = NULL;
	}

	if (pcmk__daemon_can_write(PE_STATE_DIR, NULL) == FALSE) {
	exit_code = CRM_EX_FATAL;
	crm_err("Terminating due to bad permissions on " PE_STATE_DIR);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Bad permissions on " PE_STATE_DIR
	" (see logs for details)");
	goto done;

	} else if (pcmk__daemon_can_write(CRM_CONFIG_DIR, NULL) == FALSE) {
	exit_code = CRM_EX_FATAL;
	crm_err("Terminating due to bad permissions on " CRM_CONFIG_DIR);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Bad permissions on " CRM_CONFIG_DIR
	" (see logs for details)");
	goto done;
	}

	if (pcmk__log_output_new(&(controld_globals.logger_out)) != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	pcmk__output_set_log_level(controld_globals.logger_out, LOG_TRACE);

	done:
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	pcmk__output_and_clear_error(&error, out);

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}
	pcmk__unregister_formats();

	if ((exit_code == CRM_EX_OK) && initialize) {
	// Does not return
	crmd_init();
	}
	crm_exit(exit_code);
	}

	void
	crmd_init(void)
	{
	crm_exit_t exit_code = CRM_EX_OK;
	enum crmd_fsa_state state;

	init_dotfile();
	register_fsa_input(C_STARTUP, I_STARTUP, NULL);

	crm_peer_init();
	state = s_crmd_fsa(C_STARTUP);

	if (state == S_PENDING \|\| state == S_STARTING) {
	/* Create the mainloop and run it... */
	crm_trace("Starting %s's mainloop", crm_system_name);
	controld_globals.mainloop = g_main_loop_new(NULL, FALSE);
	g_main_loop_run(controld_globals.mainloop);
	if (pcmk_is_set(controld_globals.fsa_input_register, R_STAYDOWN)) {
	crm_info("Inhibiting automated respawn");
	exit_code = CRM_EX_FATAL;
	}

	} else {
	crm_err("Startup of %s failed. Current state: %s",
	crm_system_name, fsa_state2string(state));
	exit_code = CRM_EX_ERROR;
	}

	crm_info("%s[%lu] exiting with status %d (%s)",
	crm_system_name, (unsigned long) getpid(), exit_code,
	crm_exit_str(exit_code));

	crmd_fast_exit(exit_code);
	}
	diff --git a/daemons/fenced/pacemaker-fenced.c b/daemons/fenced/pacemaker-fenced.c
	index cf2ff22cf8..d9d62f6a4f 100644
	--- a/daemons/fenced/pacemaker-fenced.c
	+++ b/daemons/fenced/pacemaker-fenced.c
	@@ -1,676 +1,678 @@
	/*
	* Copyright 2009-2024 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 <sys/param.h>
	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <sys/utsname.h>

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <inttypes.h> // PRIu32, PRIx32

	#include <crm/crm.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/ipc.h>
	#include <crm/common/ipc_internal.h>
	#include <crm/common/output_internal.h>

	#include <crm/stonith-ng.h>
	#include <crm/fencing/internal.h>
	#include <crm/common/xml.h>
	#include <crm/common/xml_internal.h>

	#include <crm/common/mainloop.h>

	#include <crm/cib/internal.h>

	#include <pacemaker-fenced.h>

	#define SUMMARY "daemon for executing fencing devices in a Pacemaker cluster"

	char *stonith_our_uname = NULL;
	long long stonith_watchdog_timeout_ms = 0;
	GList *stonith_watchdog_targets = NULL;

	static GMainLoop *mainloop = NULL;

	gboolean stand_alone = FALSE;
	gboolean stonith_shutdown_flag = FALSE;

	static qb_ipcs_service_t *ipcs = NULL;
	static pcmk__output_t *out = NULL;

	pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	static struct {
	bool no_cib_connect;
	gchar **log_files;
	} options;

	crm_exit_t exit_code = CRM_EX_OK;

	static void stonith_cleanup(void);

	static int32_t
	st_ipc_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	if (stonith_shutdown_flag) {
	crm_info("Ignoring new client [%d] during shutdown",
	pcmk__client_pid(c));
	return -ECONNREFUSED;
	}

	if (pcmk__new_client(c, uid, gid) == NULL) {
	return -ENOMEM;
	}
	return 0;
	}

	/* Exit code means? */
	static int32_t
	st_ipc_dispatch(qb_ipcs_connection_t * qbc, void *data, size_t size)
	{
	uint32_t id = 0;
	uint32_t flags = 0;
	int call_options = 0;
	xmlNode *request = NULL;
	pcmk__client_t *c = pcmk__find_client(qbc);
	const char *op = NULL;

	if (c == NULL) {
	crm_info("Invalid client: %p", qbc);
	return 0;
	}

	request = pcmk__client_data2xml(c, data, &id, &flags);
	if (request == NULL) {
	pcmk__ipc_send_ack(c, id, flags, PCMK__XE_NACK, NULL, CRM_EX_PROTOCOL);
	return 0;
	}


	op = crm_element_value(request, PCMK__XA_CRM_TASK);
	if(pcmk__str_eq(op, CRM_OP_RM_NODE_CACHE, pcmk__str_casei)) {
	crm_xml_add(request, PCMK__XA_T, PCMK__VALUE_STONITH_NG);
	crm_xml_add(request, PCMK__XA_ST_OP, op);
	crm_xml_add(request, PCMK__XA_ST_CLIENTID, c->id);
	crm_xml_add(request, PCMK__XA_ST_CLIENTNAME, pcmk__client_name(c));
	crm_xml_add(request, PCMK__XA_ST_CLIENTNODE, stonith_our_uname);

	send_cluster_message(NULL, crm_msg_stonith_ng, request, FALSE);
	free_xml(request);
	return 0;
	}

	if (c->name == NULL) {
	const char *value = crm_element_value(request, PCMK__XA_ST_CLIENTNAME);

	c->name = crm_strdup_printf("%s.%u", pcmk__s(value, "unknown"), c->pid);
	}

	crm_element_value_int(request, PCMK__XA_ST_CALLOPT, &call_options);
	crm_trace("Flags %#08" PRIx32 "/%#08x for command %" PRIu32
	" from client %s", flags, call_options, id, pcmk__client_name(c));

	if (pcmk_is_set(call_options, st_opt_sync_call)) {
	CRM_ASSERT(flags & crm_ipc_client_response);
	CRM_LOG_ASSERT(c->request_id == 0); /* This means the client has two synchronous events in-flight */
	c->request_id = id; /* Reply only to the last one */
	}

	crm_xml_add(request, PCMK__XA_ST_CLIENTID, c->id);
	crm_xml_add(request, PCMK__XA_ST_CLIENTNAME, pcmk__client_name(c));
	crm_xml_add(request, PCMK__XA_ST_CLIENTNODE, stonith_our_uname);

	crm_log_xml_trace(request, "ipc-received");
	stonith_command(c, id, flags, request, NULL);

	free_xml(request);
	return 0;
	}

	/* Error code means? */
	static int32_t
	st_ipc_closed(qb_ipcs_connection_t * c)
	{
	pcmk__client_t *client = pcmk__find_client(c);

	if (client == NULL) {
	return 0;
	}

	crm_trace("Connection %p closed", c);
	pcmk__free_client(client);

	/* 0 means: yes, go ahead and destroy the connection */
	return 0;
	}

	static void
	st_ipc_destroy(qb_ipcs_connection_t * c)
	{
	crm_trace("Connection %p destroyed", c);
	st_ipc_closed(c);
	}

	static void
	stonith_peer_callback(xmlNode * msg, void *private_data)
	{
	const char *remote_peer = crm_element_value(msg, PCMK__XA_SRC);
	const char *op = crm_element_value(msg, PCMK__XA_ST_OP);

	if (pcmk__str_eq(op, STONITH_OP_POKE, pcmk__str_none)) {
	return;
	}

	crm_log_xml_trace(msg, "Peer[inbound]");
	stonith_command(NULL, 0, 0, msg, remote_peer);
	}

	#if SUPPORT_COROSYNC
	static void
	stonith_peer_ais_callback(cpg_handle_t handle,
	const struct cpg_name *groupName,
	uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
	{
	uint32_t kind = 0;
	xmlNode *xml = NULL;
	const char *from = NULL;
	char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);

	if(data == NULL) {
	return;
	}
	if (kind == crm_class_cluster) {
	xml = pcmk__xml_parse(data);
	if (xml == NULL) {
	crm_err("Invalid XML: '%.120s'", data);
	free(data);
	return;
	}
	crm_xml_add(xml, PCMK__XA_SRC, from);
	stonith_peer_callback(xml, NULL);
	}

	free_xml(xml);
	free(data);
	return;
	}

	static void
	stonith_peer_cs_destroy(gpointer user_data)
	{
	crm_crit("Lost connection to cluster layer, shutting down");
	stonith_shutdown(0);
	}
	#endif

	void
	do_local_reply(const xmlNode notify_src, pcmk__client_t client,
	int call_options)
	{
	/* send callback to originating child */
	int local_rc = pcmk_rc_ok;
	int rid = 0;
	uint32_t ipc_flags = crm_ipc_server_event;

	if (pcmk_is_set(call_options, st_opt_sync_call)) {
	CRM_LOG_ASSERT(client->request_id);
	rid = client->request_id;
	client->request_id = 0;
	ipc_flags = crm_ipc_flags_none;
	}

	local_rc = pcmk__ipc_send_xml(client, rid, notify_src, ipc_flags);
	if (local_rc == pcmk_rc_ok) {
	crm_trace("Sent response %d to client %s",
	rid, pcmk__client_name(client));
	} else {
	crm_warn("%synchronous reply to client %s failed: %s",
	(pcmk_is_set(call_options, st_opt_sync_call)? "S" : "As"),
	pcmk__client_name(client), pcmk_rc_str(local_rc));
	}
	}

	uint64_t
	get_stonith_flag(const char *name)
	{
	if (pcmk__str_eq(name, PCMK__VALUE_ST_NOTIFY_FENCE, pcmk__str_none)) {
	return st_callback_notify_fence;

	} else if (pcmk__str_eq(name, STONITH_OP_DEVICE_ADD, pcmk__str_casei)) {
	return st_callback_device_add;

	} else if (pcmk__str_eq(name, STONITH_OP_DEVICE_DEL, pcmk__str_casei)) {
	return st_callback_device_del;

	} else if (pcmk__str_eq(name, PCMK__VALUE_ST_NOTIFY_HISTORY,
	pcmk__str_none)) {
	return st_callback_notify_history;

	} else if (pcmk__str_eq(name, PCMK__VALUE_ST_NOTIFY_HISTORY_SYNCED,
	pcmk__str_none)) {
	return st_callback_notify_history_synced;

	}
	return st_callback_unknown;
	}

	static void
	stonith_notify_client(gpointer key, gpointer value, gpointer user_data)
	{

	const xmlNode *update_msg = user_data;
	pcmk__client_t *client = value;
	const char *type = NULL;

	CRM_CHECK(client != NULL, return);
	CRM_CHECK(update_msg != NULL, return);

	type = crm_element_value(update_msg, PCMK__XA_SUBT);
	CRM_CHECK(type != NULL, crm_log_xml_err(update_msg, "notify"); return);

	if (client->ipcs == NULL) {
	crm_trace("Skipping client with NULL channel");
	return;
	}

	if (pcmk_is_set(client->flags, get_stonith_flag(type))) {
	int rc = pcmk__ipc_send_xml(client, 0, update_msg,
	crm_ipc_server_event);

	if (rc != pcmk_rc_ok) {
	crm_warn("%s notification of client %s failed: %s "
	CRM_XS " id=%.8s rc=%d", type, pcmk__client_name(client),
	pcmk_rc_str(rc), client->id, rc);
	} else {
	crm_trace("Sent %s notification to client %s",
	type, pcmk__client_name(client));
	}
	}
	}

	void
	do_stonith_async_timeout_update(const char client_id, const char call_id, int timeout)
	{
	pcmk__client_t *client = NULL;
	xmlNode *notify_data = NULL;

	if (!timeout \|\| !call_id \|\| !client_id) {
	return;
	}

	client = pcmk__find_client_by_id(client_id);
	if (!client) {
	return;
	}

	notify_data = pcmk__xe_create(NULL, PCMK__XE_ST_ASYNC_TIMEOUT_VALUE);
	crm_xml_add(notify_data, PCMK__XA_T, PCMK__VALUE_ST_ASYNC_TIMEOUT_VALUE);
	crm_xml_add(notify_data, PCMK__XA_ST_CALLID, call_id);
	crm_xml_add_int(notify_data, PCMK__XA_ST_TIMEOUT, timeout);

	crm_trace("timeout update is %d for client %s and call id %s", timeout, client_id, call_id);

	if (client) {
	pcmk__ipc_send_xml(client, 0, notify_data, crm_ipc_server_event);
	}

	free_xml(notify_data);
	}

	/*!
	* \internal
	* \brief Notify relevant IPC clients of a fencing operation result
	*
	* \param[in] type Notification type
	* \param[in] result Result of fencing operation (assume success if NULL)
	* \param[in] data If not NULL, add to notification as call data
	*/
	void
	fenced_send_notification(const char type, const pcmk__action_result_t result,
	xmlNode *data)
	{
	/* TODO: Standardize the contents of data */
	xmlNode *update_msg = pcmk__xe_create(NULL, PCMK__XE_NOTIFY);

	CRM_LOG_ASSERT(type != NULL);

	crm_xml_add(update_msg, PCMK__XA_T, PCMK__VALUE_ST_NOTIFY);
	crm_xml_add(update_msg, PCMK__XA_SUBT, type);
	crm_xml_add(update_msg, PCMK__XA_ST_OP, type);
	stonith__xe_set_result(update_msg, result);

	if (data != NULL) {
	add_message_xml(update_msg, PCMK__XA_ST_CALLDATA, data);
	}

	crm_trace("Notifying clients");
	pcmk__foreach_ipc_client(stonith_notify_client, update_msg);
	free_xml(update_msg);
	crm_trace("Notify complete");
	}

	/*!
	* \internal
	* \brief Send notifications for a configuration change to subscribed clients
	*
	* \param[in] op Notification type (\c STONITH_OP_DEVICE_ADD,
	* \c STONITH_OP_DEVICE_DEL, \c STONITH_OP_LEVEL_ADD, or
	* \c STONITH_OP_LEVEL_DEL)
	* \param[in] result Operation result
	* \param[in] desc Description of what changed (either device ID or string
	* representation of level
	* (<tt><target>[<level_index>]</tt>))
	*/
	void
	fenced_send_config_notification(const char *op,
	const pcmk__action_result_t *result,
	const char *desc)
	{
	xmlNode *notify_data = pcmk__xe_create(NULL, op);

	crm_xml_add(notify_data, PCMK__XA_ST_DEVICE_ID, desc);

	fenced_send_notification(op, result, notify_data);
	free_xml(notify_data);
	}

	/*!
	* \internal
	* \brief Check whether a node does watchdog-fencing
	*
	* \param[in] node Name of node to check
	*
	* \return TRUE if node found in stonith_watchdog_targets
	* or stonith_watchdog_targets is empty indicating
	* all nodes are doing watchdog-fencing
	*/
	gboolean
	node_does_watchdog_fencing(const char *node)
	{
	return ((stonith_watchdog_targets == NULL) \|\|
	pcmk__str_in_list(node, stonith_watchdog_targets, pcmk__str_casei));
	}

	void
	stonith_shutdown(int nsig)
	{
	crm_info("Terminating with %d clients", pcmk__ipc_client_count());
	stonith_shutdown_flag = TRUE;
	if (mainloop != NULL && g_main_loop_is_running(mainloop)) {
	g_main_loop_quit(mainloop);
	}
	}

	static void
	stonith_cleanup(void)
	{
	fenced_cib_cleanup();
	if (ipcs) {
	qb_ipcs_destroy(ipcs);
	}

	crm_peer_destroy();
	pcmk__client_cleanup();
	free_stonith_remote_op_list();
	free_topology_list();
	free_device_list();
	free_metadata_cache();
	fenced_unregister_handlers();

	free(stonith_our_uname);
	stonith_our_uname = NULL;
	}

	static gboolean
	stand_alone_cpg_cb(const gchar option_name, const gchar optarg, gpointer data,
	GError **error)
	{
	stand_alone = FALSE;
	options.no_cib_connect = true;
	return TRUE;
	}

	struct qb_ipcs_service_handlers ipc_callbacks = {
	.connection_accept = st_ipc_accept,
	.connection_created = NULL,
	.msg_process = st_ipc_dispatch,
	.connection_closed = st_ipc_closed,
	.connection_destroyed = st_ipc_destroy
	};

	/*!
	* \internal
	* \brief Callback for peer status changes
	*
	* \param[in] type What changed
	* \param[in] node What peer had the change
	* \param[in] data Previous value of what changed
	*/
	static void
	st_peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
	{
	if ((type != crm_status_processes)
	&& !pcmk_is_set(node->flags, crm_remote_node)) {
	/*
	* This is a hack until we can send to a nodeid and/or we fix node name lookups
	* These messages are ignored in stonith_peer_callback()
	*/
	xmlNode *query = pcmk__xe_create(NULL, PCMK__XE_STONITH_COMMAND);

	crm_xml_add(query, PCMK__XA_T, PCMK__VALUE_STONITH_NG);
	crm_xml_add(query, PCMK__XA_ST_OP, STONITH_OP_POKE);

	crm_debug("Broadcasting our uname because of node %u", node->id);
	send_cluster_message(NULL, crm_msg_stonith_ng, query, FALSE);

	free_xml(query);
	}
	}

	+/* @COMPAT Deprecated since 2.1.8. Use pcmk_list_fence_attrs() or
	+ * crm_resource --list-options=fencing instead of querying daemon metadata.
	+ */
	static int
	fencer_metadata(void)
	{
	const char *name = "pacemaker-fenced";
	const char *desc_short = N_("Instance attributes available for all "
	"\"stonith\"-class resources");
	const char *desc_long = N_("Instance attributes available for all "
	"\"stonith\"-class resources and used by "
	"Pacemaker's fence daemon, formerly known as "
	"stonithd");

	return pcmk__daemon_metadata(out, name, desc_short, desc_long,
	pcmk__opt_fencing);
	}

	static GOptionEntry entries[] = {
	{ "stand-alone", 's', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, &stand_alone,
	N_("Deprecated (will be removed in a future release)"), NULL },

	{ "stand-alone-w-cpg", 'c', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
	stand_alone_cpg_cb, N_("Intended for use in regression testing only"), NULL },

	{ "logfile", 'l', G_OPTION_FLAG_NONE, G_OPTION_ARG_FILENAME_ARRAY,
	&options.log_files, N_("Send logs to the additional named logfile"), NULL },

	{ NULL }
	};

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group)
	{
	GOptionContext *context = NULL;

	- context = pcmk__build_arg_context(args, "text (default), xml", group,
	- "[metadata]");
	+ context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	pcmk__add_main_args(context, entries);
	return context;
	}

	int
	main(int argc, char **argv)
	{
	int rc = pcmk_rc_ok;
	crm_cluster_t *cluster = NULL;
	crm_ipc_t *old_instance = NULL;

	GError *error = NULL;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, "l");
	GOptionContext *context = build_arg_context(args, &output_group);

	crm_log_preinit(NULL, argc, argv);

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_ERROR;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Error creating output format %s: %s",
	args->output_ty, pcmk_rc_str(rc));
	goto done;
	}

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	if ((g_strv_length(processed_args) >= 2)
	&& pcmk__str_eq(processed_args[1], "metadata", pcmk__str_none)) {

	rc = fencer_metadata();
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unable to display metadata: %s", pcmk_rc_str(rc));
	}
	goto done;
	}

	// Open additional log files
	pcmk__add_logfiles(options.log_files, out);

	crm_log_init(NULL, LOG_INFO + args->verbosity, TRUE,
	(args->verbosity > 0), argc, argv, FALSE);

	crm_notice("Starting Pacemaker fencer");

	old_instance = crm_ipc_new("stonith-ng", 0);
	if (old_instance == NULL) {
	/* crm_ipc_new() will have already logged an error message with
	* crm_err()
	*/
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	if (pcmk__connect_generic_ipc(old_instance) == pcmk_rc_ok) {
	// IPC endpoint already up
	crm_ipc_close(old_instance);
	crm_ipc_destroy(old_instance);
	crm_err("pacemaker-fenced is already active, aborting startup");
	goto done;
	} else {
	// Not up or not authentic, we'll proceed either way
	crm_ipc_destroy(old_instance);
	old_instance = NULL;
	}

	mainloop_add_signal(SIGTERM, stonith_shutdown);

	crm_peer_init();

	rc = fenced_scheduler_init();
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Error initializing scheduler data: %s", pcmk_rc_str(rc));
	goto done;
	}

	cluster = pcmk_cluster_new();

	if (!stand_alone) {
	#if SUPPORT_COROSYNC
	if (is_corosync_cluster()) {
	cluster->destroy = stonith_peer_cs_destroy;
	cluster->cpg.cpg_deliver_fn = stonith_peer_ais_callback;
	cluster->cpg.cpg_confchg_fn = pcmk_cpg_membership;
	}
	#endif // SUPPORT_COROSYNC

	crm_set_status_callback(&st_peer_update_callback);

	if (crm_cluster_connect(cluster) == FALSE) {
	exit_code = CRM_EX_FATAL;
	crm_crit("Cannot sign in to the cluster... terminating");
	goto done;
	}
	pcmk__str_update(&stonith_our_uname, cluster->uname);

	if (!options.no_cib_connect) {
	setup_cib();
	}

	} else {
	pcmk__str_update(&stonith_our_uname, "localhost");
	crm_warn("Stand-alone mode is deprecated and will be removed "
	"in a future release");
	}

	init_device_list();
	init_topology_list();

	pcmk__serve_fenced_ipc(&ipcs, &ipc_callbacks);

	// Create the mainloop and run it...
	mainloop = g_main_loop_new(NULL, FALSE);
	crm_notice("Pacemaker fencer successfully started and accepting connections");
	g_main_loop_run(mainloop);

	done:
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	g_strfreev(options.log_files);

	stonith_cleanup();
	pcmk_cluster_free(cluster);
	fenced_scheduler_cleanup();

	pcmk__output_and_clear_error(&error, out);

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}

	pcmk__unregister_formats();
	crm_exit(exit_code);
	}
	diff --git a/daemons/schedulerd/pacemaker-schedulerd.c b/daemons/schedulerd/pacemaker-schedulerd.c
	index 40a5632ffd..d1b93625f4 100644
	--- a/daemons/schedulerd/pacemaker-schedulerd.c
	+++ b/daemons/schedulerd/pacemaker-schedulerd.c
	@@ -1,199 +1,199 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <crm/crm.h>
	#include <stdio.h>
	#include <stdbool.h>

	#include <stdlib.h>
	#include <errno.h>

	#include <crm/common/cmdline_internal.h>
	#include <crm/common/ipc_internal.h>
	#include <crm/common/mainloop.h>
	#include <crm/pengine/internal.h>
	#include <pacemaker-internal.h>

	#include "pacemaker-schedulerd.h"

	#define SUMMARY "pacemaker-schedulerd - daemon for calculating a Pacemaker cluster's response to events"

	struct {
	gchar **remainder;
	} options;

	pcmk__output_t *logger_out = NULL;

	static pcmk__output_t *out = NULL;
	static GMainLoop *mainloop = NULL;
	static qb_ipcs_service_t *ipcs = NULL;
	static crm_exit_t exit_code = CRM_EX_OK;

	pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	void pengine_shutdown(int nsig);

	-/* @COMPAT Deprecated since 2.1.8; use pcmk_cluster_list_options() or
	- * crm_attribute --list-options instead of querying daemon metadata.
	+/* @COMPAT Deprecated since 2.1.8. Use pcmk_list_cluster_options() or
	+ * crm_attribute --list-options=cluster instead of querying daemon metadata.
	*/
	static int
	scheduler_metadata(pcmk__output_t *out)
	{
	return pcmk__daemon_metadata(out, "pacemaker-schedulerd",
	"Pacemaker scheduler options",
	"Cluster options used by Pacemaker's "
	"scheduler",
	pcmk__opt_schedulerd);
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group) {
	GOptionContext *context = NULL;

	GOptionEntry extra_prog_entries[] = {
	{ G_OPTION_REMAINING, 0, G_OPTION_FLAG_NONE, G_OPTION_ARG_STRING_ARRAY, &options.remainder,
	NULL,
	NULL },

	{ NULL }
	};

	context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	pcmk__add_main_args(context, extra_prog_entries);
	return context;
	}

	int
	main(int argc, char **argv)
	{
	GError *error = NULL;
	int rc = pcmk_rc_ok;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, NULL);
	GOptionContext *context = build_arg_context(args, &output_group);

	crm_log_preinit(NULL, argc, argv);
	mainloop_add_signal(SIGTERM, pengine_shutdown);

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if ((rc != pcmk_rc_ok) \|\| (out == NULL)) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Error creating output format %s: %s",
	args->output_ty, pcmk_rc_str(rc));
	goto done;
	}

	pe__register_messages(out);
	pcmk__register_lib_messages(out);

	if (options.remainder) {
	if (g_strv_length(options.remainder) == 1 &&
	pcmk__str_eq("metadata", options.remainder[0], pcmk__str_casei)) {

	rc = scheduler_metadata(out);
	if (rc != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unable to display metadata: %s", pcmk_rc_str(rc));
	}

	} else {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unsupported extra command line parameters");
	}
	goto done;
	}

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	pcmk__cli_init_logging("pacemaker-schedulerd", args->verbosity);
	crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);
	crm_notice("Starting Pacemaker scheduler");

	if (pcmk__daemon_can_write(PE_STATE_DIR, NULL) == FALSE) {
	crm_err("Terminating due to bad permissions on " PE_STATE_DIR);
	exit_code = CRM_EX_FATAL;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"ERROR: Bad permissions on %s (see logs for details)", PE_STATE_DIR);
	goto done;
	}

	ipcs = pcmk__serve_schedulerd_ipc(&ipc_callbacks);
	if (ipcs == NULL) {
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Failed to create pacemaker-schedulerd server: exiting and inhibiting respawn");
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	if (pcmk__log_output_new(&logger_out) != pcmk_rc_ok) {
	exit_code = CRM_EX_FATAL;
	goto done;
	}
	pe__register_messages(logger_out);
	pcmk__register_lib_messages(logger_out);
	pcmk__output_set_log_level(logger_out, LOG_TRACE);

	/* Create the mainloop and run it... */
	mainloop = g_main_loop_new(NULL, FALSE);
	crm_notice("Pacemaker scheduler successfully started and accepting connections");
	g_main_loop_run(mainloop);

	done:
	g_strfreev(options.remainder);
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	pcmk__output_and_clear_error(&error, out);
	pengine_shutdown(0);
	}

	void
	pengine_shutdown(int nsig)
	{
	if (ipcs != NULL) {
	crm_trace("Closing IPC server");
	mainloop_del_ipc_server(ipcs);
	ipcs = NULL;
	}

	if (logger_out != NULL) {
	logger_out->finish(logger_out, exit_code, true, NULL);
	pcmk__output_free(logger_out);
	logger_out = NULL;
	}

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	out = NULL;
	}

	pcmk__unregister_formats();
	crm_exit(exit_code);
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 29, 8:55 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 942629
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions