internal.h
No OneTemporary
Actions

Size

11 KB

Referenced Files

None

Subscribers

None

internal.h
View Options

	/*
	* Copyright 2015-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 CRM_COMMON_INTERNAL__H
	#define CRM_COMMON_INTERNAL__H

	#include <unistd.h> // pid_t, getpid()
	#include <stdbool.h> // bool
	#include <stdint.h> // uint8_t, uint64_t

	#include <glib.h> // guint, GList, GHashTable
	#include <libxml/tree.h> // xmlNode

	#include <crm/common/util.h> // crm_strdup_printf()
	#include <crm/common/logging.h> // do_crm_log_unlikely(), etc.
	#include <crm/common/mainloop.h> // mainloop_io_t, struct ipc_client_callbacks
	#include <crm/common/actions_internal.h>
	#include <crm/common/digests_internal.h>
	#include <crm/common/health_internal.h>
	#include <crm/common/io_internal.h>
	#include <crm/common/iso8601_internal.h>
	#include <crm/common/results_internal.h>
	#include <crm/common/messages_internal.h>
	#include <crm/common/strings_internal.h>
	#include <crm/common/acl_internal.h>

	/* This says whether the current application is a Pacemaker daemon or not,
	* and is used to change default logging settings such as whether to log to
	* stderr, etc., as well as a few other details such as whether blackbox signal
	* handling is enabled.
	*
	* It is set when logging is initialized, and does not need to be set directly.
	*/
	extern bool pcmk__is_daemon;

	//! Node name of the local node
	extern char *pcmk__our_nodename;

	// Number of elements in a statically defined array
	#define PCMK__NELEM(a) ((int) (sizeof(a)/sizeof(a[0])) )

	#if SUPPORT_CIBSECRETS
	/* internal CIB utilities (from cib_secrets.c) */

	int pcmk__substitute_secrets(const char rsc_id, GHashTable params);
	#endif


	/* internal main loop utilities (from mainloop.c) */

	int pcmk__add_mainloop_ipc(crm_ipc_t ipc, int priority, void userdata,
	const struct ipc_client_callbacks *callbacks,
	mainloop_io_t **source);
	guint pcmk__mainloop_timer_get_period(const mainloop_timer_t *timer);


	/* internal node-related XML utilities (from nodes.c) */

	/*!
	* \internal
	* \brief Add local node name and ID to an XML node
	*
	* \param[in,out] request XML node to modify
	* \param[in] node The local node's name
	* \param[in] nodeid The local node's ID (can be 0)
	*/
	void pcmk__xe_add_node(xmlNode xml, const char node, int nodeid);


	/* internal name/value utilities (from nvpair.c) */

	int pcmk__scan_nvpair(const char input, char name, char *value);
	char pcmk__format_nvpair(const char name, const char *value,
	const char *units);

	/*!
	* \internal
	* \brief Add a boolean attribute to an XML node.
	*
	* \param[in,out] node XML node to add attributes to
	* \param[in] name XML attribute to create
	* \param[in] value Value to give to the attribute
	*/
	void
	pcmk__xe_set_bool_attr(xmlNodePtr node, const char *name, bool value);

	/*!
	* \internal
	* \brief Extract a boolean attribute's value from an XML element
	*
	* \param[in] node XML node to get attribute from
	* \param[in] name XML attribute to get
	*
	* \return True if the given \p name is an attribute on \p node and has
	* the value \c PCMK_VALUE_TRUE, False in all other cases
	*/
	bool
	pcmk__xe_attr_is_true(const xmlNode node, const char name);

	/*!
	* \internal
	* \brief Extract a boolean attribute's value from an XML element, with
	* error checking
	*
	* \param[in] node XML node to get attribute from
	* \param[in] name XML attribute to get
	* \param[out] value Destination for the value of the attribute
	*
	* \return EINVAL if \p name or \p value are NULL, ENODATA if \p node is
	* NULL or the attribute does not exist, pcmk_rc_unknown_format
	* if the attribute is not a boolean, and pcmk_rc_ok otherwise.
	*
	* \note \p value only has any meaning if the return value is pcmk_rc_ok.
	*/
	int
	pcmk__xe_get_bool_attr(const xmlNode node, const char name, bool *value);


	/* internal procfs utilities (from procfs.c) */

	pid_t pcmk__procfs_pid_of(const char *name);
	unsigned int pcmk__procfs_num_cores(void);
	int pcmk__procfs_pid2path(pid_t pid, char path[], size_t path_size);
	bool pcmk__procfs_has_pids(void);

	/* internal XML schema functions (from xml.c) */

	void crm_schema_init(void);
	void crm_schema_cleanup(void);

	void pcmk__load_schemas_from_dir(const char *dir);
	GList pcmk__schema_files_later_than(const char name);
	void pcmk__build_schema_xml_node(xmlNode parent, const char name,
	GList **already_included);


	/* internal functions related to process IDs (from pid.c) */

	/*!
	* \internal
	* \brief Check whether process exists (by PID and optionally executable path)
	*
	* \param[in] pid PID of process to check
	* \param[in] daemon If not NULL, path component to match with procfs entry
	*
	* \return Standard Pacemaker return code
	* \note Particular return codes of interest include pcmk_rc_ok for alive,
	* ESRCH for process is not alive (verified by kill and/or executable path
	* match), EACCES for caller unable or not allowed to check. A result of
	* "alive" is less reliable when \p daemon is not provided or procfs is
	* not available, since there is no guarantee that the PID has not been
	* recycled for another process.
	* \note This function cannot be used to verify \e authenticity of the process.
	*/
	int pcmk__pid_active(pid_t pid, const char *daemon);

	int pcmk__read_pidfile(const char filename, pid_t pid);
	int pcmk__pidfile_matches(const char *filename, pid_t expected_pid,
	const char expected_name, pid_t pid);
	int pcmk__lock_pidfile(const char filename, const char name);


	// bitwise arithmetic utilities

	/*!
	* \internal
	* \brief Set specified flags in a flag group
	*
	* \param[in] function Function name of caller
	* \param[in] line Line number of caller
	* \param[in] log_level Log a message at this level
	* \param[in] flag_type Label describing this flag group (for logging)
	* \param[in] target Name of object whose flags these are (for logging)
	* \param[in] flag_group Flag group being manipulated
	* \param[in] flags Which flags in the group should be set
	* \param[in] flags_str Readable equivalent of \p flags (for logging)
	*
	* \return Possibly modified flag group
	*/
	static inline uint64_t
	pcmk__set_flags_as(const char *function, int line, uint8_t log_level,
	const char flag_type, const char target,
	uint64_t flag_group, uint64_t flags, const char *flags_str)
	{
	uint64_t result = flag_group \| flags;

	if (result != flag_group) {
	do_crm_log_unlikely(log_level,
	"%s flags %#.8llx (%s) for %s set by %s:%d",
	((flag_type == NULL)? "Group of" : flag_type),
	(unsigned long long) flags,
	((flags_str == NULL)? "flags" : flags_str),
	((target == NULL)? "target" : target),
	function, line);
	}
	return result;
	}

	/*!
	* \internal
	* \brief Clear specified flags in a flag group
	*
	* \param[in] function Function name of caller
	* \param[in] line Line number of caller
	* \param[in] log_level Log a message at this level
	* \param[in] flag_type Label describing this flag group (for logging)
	* \param[in] target Name of object whose flags these are (for logging)
	* \param[in] flag_group Flag group being manipulated
	* \param[in] flags Which flags in the group should be cleared
	* \param[in] flags_str Readable equivalent of \p flags (for logging)
	*
	* \return Possibly modified flag group
	*/
	static inline uint64_t
	pcmk__clear_flags_as(const char *function, int line, uint8_t log_level,
	const char flag_type, const char target,
	uint64_t flag_group, uint64_t flags, const char *flags_str)
	{
	uint64_t result = flag_group & ~flags;

	if (result != flag_group) {
	do_crm_log_unlikely(log_level,
	"%s flags %#.8llx (%s) for %s cleared by %s:%d",
	((flag_type == NULL)? "Group of" : flag_type),
	(unsigned long long) flags,
	((flags_str == NULL)? "flags" : flags_str),
	((target == NULL)? "target" : target),
	function, line);
	}
	return result;
	}

	/*!
	* \internal
	* \brief Get readable string for whether specified flags are set
	*
	* \param[in] flag_group Group of flags to check
	* \param[in] flags Which flags in \p flag_group should be checked
	*
	* \return "true" if all \p flags are set in \p flag_group, otherwise "false"
	*/
	static inline const char *
	pcmk__flag_text(uint64_t flag_group, uint64_t flags)
	{
	return pcmk__btoa(pcmk_all_flags_set(flag_group, flags));
	}


	// miscellaneous utilities (from utils.c)

	void pcmk__daemonize(const char name, const char pidfile);
	void pcmk__panic(const char *origin);
	pid_t pcmk__locate_sbd(void);
	void pcmk__sleep_ms(unsigned int ms);

	extern int pcmk__score_red;
	extern int pcmk__score_green;
	extern int pcmk__score_yellow;

	/*!
	* \internal
	* \brief Resize a dynamically allocated memory block
	*
	* \param[in] ptr Memory block to resize (or NULL to allocate new memory)
	* \param[in] size New size of memory block in bytes (must be > 0)
	*
	* \return Pointer to resized memory block
	*
	* \note This asserts on error, so the result is guaranteed to be non-NULL
	* (which is the main advantage of this over directly using realloc()).
	*/
	static inline void *
	pcmk__realloc(void *ptr, size_t size)
	{
	void *new_ptr;

	// realloc(p, 0) can replace free(p) but this wrapper can't
	CRM_ASSERT(size > 0);

	new_ptr = realloc(ptr, size);
	if (new_ptr == NULL) {
	free(ptr);
	abort();
	}
	return new_ptr;
	}


	static inline char *
	pcmk__getpid_s(void)
	{
	return crm_strdup_printf("%lu", (unsigned long) getpid());
	}

	// More efficient than g_list_length(list) == 1
	static inline bool
	pcmk__list_of_1(GList *list)
	{
	return list && (list->next == NULL);
	}

	// More efficient than g_list_length(list) > 1
	static inline bool
	pcmk__list_of_multiple(GList *list)
	{
	return list && (list->next != NULL);
	}

	/* convenience functions for failure-related node attributes */

	#define PCMK__FAIL_COUNT_PREFIX "fail-count"
	#define PCMK__LAST_FAILURE_PREFIX "last-failure"

	/*!
	* \internal
	* \brief Generate a failure-related node attribute name for a resource
	*
	* \param[in] prefix Start of attribute name
	* \param[in] rsc_id Resource name
	* \param[in] op Operation name
	* \param[in] interval_ms Operation interval
	*
	* \return Newly allocated string with attribute name
	*
	* \note Failure attributes are named like PREFIX-RSC#OP_INTERVAL (for example,
	* "fail-count-myrsc#monitor_30000"). The '#' is used because it is not
	* a valid character in a resource ID, to reliably distinguish where the
	* operation name begins. The '_' is used simply to be more comparable to
	* action labels like "myrsc_monitor_30000".
	*/
	static inline char *
	pcmk__fail_attr_name(const char prefix, const char rsc_id, const char *op,
	guint interval_ms)
	{
	CRM_CHECK(prefix && rsc_id && op, return NULL);
	return crm_strdup_printf("%s-%s#%s_%u", prefix, rsc_id, op, interval_ms);
	}

	static inline char *
	pcmk__failcount_name(const char rsc_id, const char op, guint interval_ms)
	{
	return pcmk__fail_attr_name(PCMK__FAIL_COUNT_PREFIX, rsc_id, op,
	interval_ms);
	}

	static inline char *
	pcmk__lastfailure_name(const char rsc_id, const char op, guint interval_ms)
	{
	return pcmk__fail_attr_name(PCMK__LAST_FAILURE_PREFIX, rsc_id, op,
	interval_ms);
	}

	// internal resource agent functions (from agents.c)
	int pcmk__effective_rc(int rc);

	#endif /* CRM_COMMON_INTERNAL__H */

File Metadata

Mime Type: text/x-c
Expires: Thu, Oct 16, 3:16 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2477169
Default Alt Text: internal.h (11 KB)

internal.hNo OneTemporaryActions

internal.hView Options

File Metadata

Event Timeline

internal.h
No OneTemporary
Actions

internal.h
View Options