No OneTemporary
Actions

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/util.h b/include/crm/common/util.h
	index 26e8c164bf..3a708b58b9 100644
	--- a/include/crm/common/util.h
	+++ b/include/crm/common/util.h
	@@ -1,374 +1,386 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef CRM_COMMON_UTIL__H
	#define CRM_COMMON_UTIL__H

	#include <clplumbing/lsb_exitcodes.h>
	#include <crm/common/mainloop.h>

	#include <lrm/lrm_api.h>

	#include <sys/types.h>
	#include <stdlib.h>
	#include <limits.h>
	#include <signal.h>

	#if SUPPORT_HEARTBEAT
	# include <heartbeat.h>
	#else
	# define NORMALNODE "normal"
	# define ACTIVESTATUS "active" /* fully functional, and all links are up */
	# define DEADSTATUS "dead" /* Status of non-working link or machine */
	# define PINGSTATUS "ping" /* Status of a working ping node */
	# define JOINSTATUS "join" /* Status when an api client joins */
	# define LEAVESTATUS "leave" /* Status when an api client leaves */
	# define ONLINESTATUS "online" /* Status of an online client */
	# define OFFLINESTATUS "offline" /* Status of an offline client */
	#endif

	#define DEBUG_INC SIGUSR1
	#define DEBUG_DEC SIGUSR2

	extern unsigned int crm_log_level;
	extern gboolean crm_config_error;
	extern gboolean crm_config_warning;

	#ifdef HAVE_GETOPT_H
	# include <getopt.h>
	#else
	#define no_argument 0
	#define required_argument 1
	#endif

	#define pcmk_option_default 0x00000
	#define pcmk_option_hidden 0x00001
	#define pcmk_option_paragraph 0x00002
	#define pcmk_option_example 0x00004

	struct crm_option
	{
	/* Fields from 'struct option' in getopt.h */
	/* name of long option */
	const char *name;
	/*
	* one of no_argument, required_argument, and optional_argument:
	* whether option takes an argument
	*/
	int has_arg;
	/* if not NULL, set flag to val when option found /
	int *flag;
	/* if flag not NULL, value to set flag to; else return value /
	int val;

	/* Custom fields */
	const char *desc;
	long flags;
	};


	#define crm_config_err(fmt...) { crm_config_error = TRUE; crm_err(fmt); }
	#define crm_config_warn(fmt...) { crm_config_warning = TRUE; crm_warn(fmt); }


	extern void crm_log_deinit(void);

	extern gboolean crm_log_init(
	const char *entity, int level, gboolean coredir, gboolean to_stderr,
	int argc, char **argv);

	extern gboolean crm_log_init_quiet(
	const char *entity, int level, gboolean coredir, gboolean to_stderr,
	int argc, char **argv);

	extern gboolean crm_log_init_worker(
	const char *entity, int level, gboolean coredir, gboolean to_stderr,
	int argc, char **argv, gboolean quiet);

	/* returns the old value */
	extern unsigned int set_crm_log_level(unsigned int level);

	extern unsigned int get_crm_log_level(void);

	extern char *crm_itoa(int an_int);

	extern char crm_strdup_fn(const char a, const char file, const char fn, int line);

	extern char generate_hash_key(const char crm_msg_reference, const char *sys);

	extern char generate_hash_value(const char src_node, const char *src_subsys);

	extern gboolean decodeNVpair(const char *srcstring,
	char separator, char name, char value);

	extern int compare_version(const char version1, const char version2);


	extern char generateReference(const char custom1, const char *custom2);

	extern void alter_debug(int nsig);

	extern void g_hash_destroy_str(gpointer data);

	extern gboolean crm_is_true(const char * s);

	extern int crm_str_to_boolean(const char * s, int * ret);

	extern long long crm_get_msec(const char * input);
	extern unsigned long long crm_get_interval(const char * input);

	extern const char *op_status2text(op_status_t status);

	extern char *generate_op_key(
	const char rsc_id, const char op_type, int interval);

	extern gboolean parse_op_key(
	const char key, char rsc_id, char op_type, int interval);

	extern char *generate_notify_key(
	const char rsc_id, const char notify_type, const char *op_type);

	extern char *generate_transition_magic_v202(
	const char *transition_key, int op_status);

	extern char *generate_transition_magic(
	const char *transition_key, int op_status, int op_rc);

	extern gboolean decode_transition_magic(
	const char magic, char *uuid,
	int transition_id, int action_id, int op_status, int op_rc, int *target_rc);

	extern char generate_transition_key(int action, int transition_id, int target_rc, const char node);

	extern gboolean decode_transition_key(
	const char key, char uuid, int action, int transition_id, int target_rc);

	extern char crm_concat(const char prefix, const char *suffix, char join);

	extern gboolean decode_op_key(
	const char key, char rsc_id, char op_type, int interval);

	extern void filter_action_parameters(xmlNode param_set, const char version);
	extern void filter_reload_parameters(xmlNode param_set, const char restart_string);

	#define safe_str_eq(a, b) crm_str_eq(a, b, FALSE)

	extern gboolean crm_str_eq(const char a, const char b, gboolean use_case);

	extern gboolean safe_str_neq(const char a, const char b);
	extern int crm_parse_int(const char text, const char default_text);
	extern long long crm_int_helper(const char text, char *end_text);
	#define crm_atoi(text, default_text) crm_parse_int(text, default_text)

	extern void crm_abort(const char file, const char function, int line,
	const char *condition, gboolean do_core, gboolean do_fork);

	extern char *generate_series_filename(
	const char directory, const char series, int sequence, gboolean bzip);

	extern int get_last_sequence(const char directory, const char series);

	extern void write_last_sequence(
	const char directory, const char series, int sequence, int max);

	extern int crm_pid_active(long pid);
	extern int crm_read_pidfile(const char *filename);
	extern int crm_lock_pidfile(const char *filename);
	extern void crm_make_daemon(
	const char name, gboolean daemonize, const char pidfile);

	typedef struct pe_cluster_option_s {
	const char *name;
	const char *alt_name;
	const char *type;
	const char *values;
	const char *default_value;

	gboolean (is_valid)(const char );

	const char *description_short;
	const char *description_long;

	} pe_cluster_option;

	extern const char *cluster_option(
	GHashTable* options, gboolean(validate)(const char),
	const char name, const char old_name, const char *def_value);

	extern const char *get_cluster_pref(
	GHashTable options, pe_cluster_option option_list, int len, const char *name);

	extern void config_metadata(
	const char name, const char version, const char desc_short, const char desc_long,
	pe_cluster_option *option_list, int len);

	extern void verify_all_options(GHashTable options, pe_cluster_option option_list, int len);
	extern gboolean check_time(const char *value);
	extern gboolean check_timer(const char *value);
	extern gboolean check_boolean(const char *value);
	extern gboolean check_number(const char *value);

	extern int char2score(const char *score);
	extern char *score2char(int score);

	extern gboolean crm_is_writable(
	const char dir, const char file,
	const char user, const char group, gboolean need_both);

	extern long long crm_set_bit(const char *function, long long word, long long bit);
	extern long long crm_clear_bit(const char *function, long long word, long long bit);


	#define set_bit(word, bit) word = crm_set_bit(__PRETTY_FUNCTION__, word, bit)
	#define clear_bit(word, bit) word = crm_clear_bit(__PRETTY_FUNCTION__, word, bit)

	#define set_bit_inplace(word, bit) word \|= bit
	#define clear_bit_inplace(word, bit) word &= ~bit

	static inline gboolean
	is_not_set(long long word, long long bit)
	{
	return ((word & bit) == 0);
	}

	static inline gboolean
	is_set(long long word, long long bit)
	{
	return ((word & bit) == bit);
	}

	static inline gboolean
	is_set_any(long long word, long long bit)
	{
	return ((word & bit) != 0);
	}

	enum cluster_type_e
	{
	pcmk_cluster_unknown = 0x0001,
	pcmk_cluster_invalid = 0x0002,
	pcmk_cluster_heartbeat = 0x0004,
	pcmk_cluster_classic_ais = 0x0010,
	pcmk_cluster_corosync = 0x0020,
	pcmk_cluster_cman = 0x0040,
	};

	extern enum cluster_type_e get_cluster_type(void);
	extern const char *name_for_cluster_type(enum cluster_type_e type);

	extern gboolean is_corosync_cluster(void);
	extern gboolean is_cman_cluster(void);
	extern gboolean is_openais_cluster(void);
	extern gboolean is_classic_ais_cluster(void);
	extern gboolean is_heartbeat_cluster(void);

	extern xmlNode cib_recv_remote_msg(void session, gboolean encrypted);
	extern void cib_send_remote_msg(void session, xmlNode msg, gboolean encrypted);
	extern char crm_meta_name(const char field);
	extern const char crm_meta_value(GHashTable hash, const char *field);

	extern void crm_set_options(const char short_options, const char usage, struct crm_option long_options, const char app_desc);
	extern int crm_get_option(int argc, char *argv, int index);
	extern void crm_help(char cmd, int exit_code);

	extern gboolean attrd_update_delegate(IPC_Channel cluster, char command, const char host, const char name, const char value, const char section, const char set, const char dampen, const char user_name);

	static inline gboolean
	attrd_update(IPC_Channel cluster, char command, const char host, const char name, const char value, const char section, const char set, const char *dampen)
	{
	return attrd_update_delegate(cluster, command, host, name, value, section, set, dampen, NULL);
	}

	extern gboolean attrd_lazy_update(char command, const char host, const char name, const char value, const char section, const char set, const char dampen);
	extern gboolean attrd_update_no_mainloop(int connection, char command, const char host, const char name, const char value, const char section, const char set, const char *dampen);

	extern int node_score_red;
	extern int node_score_green;
	extern int node_score_yellow;
	extern int node_score_infinity;

	#include <lrm/lrm_api.h>
	extern xmlNode create_operation_update(xmlNode parent, lrm_op_t op, const char caller_version, int target_rc, const char *origin, int level);
	extern void free_lrm_op(lrm_op_t *op);

	#if USE_GHASH_COMPAT

	typedef struct fake_ghi
	{
	GHashTable *hash;
	int nth; /* current index over the iteration */
	int lpc; /* internal loop counter inside g_hash_table_find */
	gpointer key;
	gpointer value;
	} GHashTableIter;

	static inline void g_hash_prepend_value(gpointer key, gpointer value, gpointer user_data)
	{
	GList values = (GList )user_data;
	values = g_list_prepend(values, value);
	}

	static inline GList g_hash_table_get_values(GHashTable hash_table)
	{
	GList *values = NULL;
	g_hash_table_foreach(hash_table, g_hash_prepend_value, &values);
	return values;
	}


	static inline gboolean g_hash_table_nth_data(gpointer key, gpointer value, gpointer user_data)
	{
	GHashTableIter iter = (GHashTableIter )user_data;
	if (iter->lpc++ == iter->nth) {
	iter->key = key;
	iter->value = value;
	return TRUE;
	}
	return FALSE;
	}

	static inline void g_hash_table_iter_init(GHashTableIter iter, GHashTable hash_table)
	{
	iter->hash = hash_table;
	iter->nth = 0;
	iter->lpc = 0;
	iter->key = NULL;
	iter->value = NULL;
	}

	static inline gboolean g_hash_table_iter_next(GHashTableIter iter, gpointer key, gpointer *value)
	{
	gboolean found = FALSE;
	iter->lpc = 0;
	iter->key = NULL;
	iter->value = NULL;
	if (iter->nth < g_hash_table_size(iter->hash)) {
	found = !!g_hash_table_find(iter->hash, g_hash_table_nth_data, iter);
	iter->nth++;
	}
	if (key) *key = iter->key;
	if (value) *value = iter->value;
	return found;
	}

	#endif /* USE_GHASH_COMPAT */

	#endif

	#if ENABLE_ACL
	-void determine_request_user(char *user, IPC_Channel client_channel, xmlNode request, const char user_field);
	+static inline gboolean is_privileged(const chatr *user)
	+{
	+ if (user == NULL) {
	+ return FALSE;
	+ } else if(strcmp(user, CRM_DAEMON_USER) == 0) {
	+ return TRUE;
	+ } else if(strcmp(user, "root") == 0) {
	+ return TRUE;
	+ }
	+ return FALSE;
	+}
	+
	+extern void determine_request_user(char *user, IPC_Channel channel, xmlNode request, const char field);
	#endif
	diff --git a/include/crm/crm.h b/include/crm/crm.h
	index dd92df2349..af7dfbff61 100644
	--- a/include/crm/crm.h
	+++ b/include/crm/crm.h
	@@ -1,459 +1,455 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef CRM__H
	#define CRM__H

	#include <crm_config.h>
	#include <stdlib.h>
	#include <glib.h>

	#undef MIN
	#undef MAX
	#include <string.h>

	#include <clplumbing/cl_log.h>

	#include <libxml/tree.h>

	extern int log_data_element(
	int log_level, const char file, const char function, int line,
	const char prefix, xmlNode data, int depth, gboolean formatted);

	#define CRM_FEATURE_SET "3.0.5"
	#define MINIMUM_SCHEMA_VERSION "pacemaker-1.0"
	#define LATEST_SCHEMA_VERSION "pacemaker-"CRM_DTD_VERSION

	#define EOS '\0'
	#define DIMOF(a) ((int) (sizeof(a)/sizeof(a[0])) )

	#ifndef __GNUC__
	# define __builtin_expect(expr, result) (expr)
	#endif

	/* Some handy macros used by the Linux kernel */
	#define __likely(expr) __builtin_expect(expr, 1)
	#define __unlikely(expr) __builtin_expect(expr, 0)

	#define CRM_DEPRECATED_SINCE_2_0_1 0
	#define CRM_DEPRECATED_SINCE_2_0_2 0
	#define CRM_DEPRECATED_SINCE_2_0_3 0
	#define CRM_DEPRECATED_SINCE_2_0_4 0
	#define CRM_DEPRECATED_SINCE_2_0_5 0
	#define CRM_DEPRECATED_SINCE_2_0_6 1
	#define CRM_DEPRECATED_SINCE_2_0_7 1
	#define CRM_DEPRECATED_SINCE_2_0_8 1
	#define CRM_DEPRECATED_SINCE_2_1_0 1

	#define CRM_META "CRM_meta"

	#define CRM_ASSERT(expr) do { \
	if(__unlikely((expr) == FALSE)) { \
	crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, #expr, TRUE, FALSE); \
	} \
	} while(0)

	#define CRM_LOG_ASSERT(expr) do { \
	if(__unlikely((expr) == FALSE)) { \
	crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, #expr, FALSE, TRUE); \
	} \
	} while(0)

	extern const char *crm_system_name;

	/* Clean these up at some point, some probably should be runtime options */
	#define SOCKET_LEN 1024
	#define APPNAME_LEN 256
	#define MAX_IPC_FAIL 5
	#define MAX_IPC_DELAY 120

	#define MSG_LOG 1
	#define DOT_FSA_ACTIONS 1
	#define DOT_ALL_FSA_INPUTS 1
	/* #define FSA_TRACE 1 */

	#define INFINITY_S "INFINITY"
	#define MINUS_INFINITY_S "-INFINITY"

	#define INFINITY 1000000

	/* Sub-systems */
	#define CRM_SYSTEM_DC "dc"
	#define CRM_SYSTEM_DCIB "dcib" /* The master CIB */
	#define CRM_SYSTEM_CIB "cib"
	#define CRM_SYSTEM_CRMD "crmd"
	#define CRM_SYSTEM_LRMD "lrmd"
	#define CRM_SYSTEM_PENGINE "pengine"
	#define CRM_SYSTEM_TENGINE "tengine"
	#define CRM_SYSTEM_STONITHD "stonithd"

	/* Valid operations */
	#define CRM_OP_NOOP "noop"

	#define CRM_OP_JOIN_ANNOUNCE "join_announce"
	#define CRM_OP_JOIN_OFFER "join_offer"
	#define CRM_OP_JOIN_REQUEST "join_request"
	#define CRM_OP_JOIN_ACKNAK "join_ack_nack"
	#define CRM_OP_JOIN_CONFIRM "join_confirm"

	#define CRM_OP_DIE "die_no_respawn"
	#define CRM_OP_RETRIVE_CIB "retrieve_cib"
	#define CRM_OP_PING "ping"
	#define CRM_OP_VOTE "vote"
	#define CRM_OP_NOVOTE "no-vote"
	#define CRM_OP_HELLO "hello"
	#define CRM_OP_HBEAT "dc_beat"
	#define CRM_OP_PECALC "pe_calc"
	#define CRM_OP_ABORT "abort"
	#define CRM_OP_QUIT "quit"
	#define CRM_OP_LOCAL_SHUTDOWN "start_shutdown"
	#define CRM_OP_SHUTDOWN_REQ "req_shutdown"
	#define CRM_OP_SHUTDOWN "do_shutdown"
	#define CRM_OP_FENCE "stonith"
	#define CRM_OP_EVENTCC "event_cc"
	#define CRM_OP_TEABORT "te_abort"
	#define CRM_OP_TEABORTED "te_abort_confirmed" /* we asked */
	#define CRM_OP_TE_HALT "te_halt"
	#define CRM_OP_TECOMPLETE "te_complete"
	#define CRM_OP_TETIMEOUT "te_timeout"
	#define CRM_OP_TRANSITION "transition"
	#define CRM_OP_REGISTER "register"
	#define CRM_OP_DEBUG_UP "debug_inc"
	#define CRM_OP_DEBUG_DOWN "debug_dec"
	#define CRM_OP_INVOKE_LRM "lrm_invoke"
	#define CRM_OP_LRM_REFRESH "lrm_refresh"
	#define CRM_OP_LRM_QUERY "lrm_query"
	#define CRM_OP_LRM_DELETE "lrm_delete"
	#define CRM_OP_LRM_FAIL "lrm_fail"
	#define CRM_OP_PROBED "probe_complete"
	#define CRM_OP_REPROBE "probe_again"
	#define CRM_OP_CLEAR_FAILCOUNT "clear_failcount"

	#define CRMD_STATE_ACTIVE "member"
	#define CRMD_STATE_INACTIVE "down"

	#define CRMD_JOINSTATE_DOWN CRMD_STATE_INACTIVE
	#define CRMD_JOINSTATE_PENDING "pending"
	#define CRMD_JOINSTATE_MEMBER CRMD_STATE_ACTIVE
	#define CRMD_JOINSTATE_NACK "banned"

	#define CRMD_ACTION_DELETE "delete"
	#define CRMD_ACTION_CANCEL "cancel"

	#define CRMD_ACTION_MIGRATE "migrate_to"
	#define CRMD_ACTION_MIGRATED "migrate_from"

	#define CRMD_ACTION_START "start"
	#define CRMD_ACTION_STARTED "running"

	#define CRMD_ACTION_STOP "stop"
	#define CRMD_ACTION_STOPPED "stopped"

	#define CRMD_ACTION_PROMOTE "promote"
	#define CRMD_ACTION_PROMOTED "promoted"
	#define CRMD_ACTION_DEMOTE "demote"
	#define CRMD_ACTION_DEMOTED "demoted"

	#define CRMD_ACTION_NOTIFY "notify"
	#define CRMD_ACTION_NOTIFIED "notified"

	#define CRMD_ACTION_STATUS "monitor"

	/* short names */
	#define RSC_DELETE CRMD_ACTION_DELETE
	#define RSC_CANCEL CRMD_ACTION_CANCEL

	#define RSC_MIGRATE CRMD_ACTION_MIGRATE
	#define RSC_MIGRATED CRMD_ACTION_MIGRATED

	#define RSC_START CRMD_ACTION_START
	#define RSC_STARTED CRMD_ACTION_STARTED

	#define RSC_STOP CRMD_ACTION_STOP
	#define RSC_STOPPED CRMD_ACTION_STOPPED

	#define RSC_PROMOTE CRMD_ACTION_PROMOTE
	#define RSC_PROMOTED CRMD_ACTION_PROMOTED
	#define RSC_DEMOTE CRMD_ACTION_DEMOTE
	#define RSC_DEMOTED CRMD_ACTION_DEMOTED

	#define RSC_NOTIFY CRMD_ACTION_NOTIFY
	#define RSC_NOTIFIED CRMD_ACTION_NOTIFIED

	#define RSC_STATUS CRMD_ACTION_STATUS

	typedef GList* GListPtr;

	/* LOG_DEBUG = 7, make LOG_TRACE ::= -VVVVV */
	#define LOG_TRACE 12
	#define LOG_DEBUG_2 LOG_TRACE
	#define LOG_DEBUG_3 LOG_TRACE
	#define LOG_DEBUG_4 LOG_TRACE
	#define LOG_DEBUG_5 LOG_TRACE
	#define LOG_DEBUG_6 LOG_TRACE

	#define LOG_MSG LOG_TRACE

	#if SUPPORT_TRACING
	struct _pcmk_ddebug_query {
	const char *files;
	const char *formats;
	const char *functions;
	unsigned long long total;
	unsigned long long matches;
	};

	/*
	* An instance of this structure is created in a special
	* ELF section at every dynamic debug callsite. At runtime,
	* the special section is treated as an array of these.
	*/
	struct _pcmk_ddebug {
	/*
	* These fields are used to drive the user interface
	* for selecting and displaying debug callsites.
	*/
	const char *function;
	const char *filename;
	const char *format;
	unsigned int lineno:24;
	/*
	* The bump field will add to the level at the callsite.
	* The value here are changed dynamically when the user
	* writes commands to FIXME ;-)
	*/
	int bump;
	} __attribute__((aligned(8)));

	/* will be assigned by ld linker magic */
	extern struct _pcmk_ddebug __start___verbose[];
	extern struct _pcmk_ddebug __stop___verbose[];

	# define CRM_TRACE_INIT_DATA(name) \
	void name(void); \
	void name(void) { CRM_ASSERT(__start___verbose != __stop___verbose); } \
	void __attribute__ ((constructor)) name(void);

	#define CRM_CHECK(expr, failure_action) do { \
	static struct _pcmk_ddebug descriptor \
	__attribute__((section("__verbose"), aligned(8))) = \
	{ __func__, __FILE__, #expr, __LINE__, LOG_TRACE}; \
	\
	if(__unlikely((expr) == FALSE)) { \
	crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, #expr, \
	descriptor.bump != LOG_TRACE, TRUE); \
	failure_action; \
	} \
	} while(0)

	/*
	* Throughout the macros below, note the leading, pre-comma, space in the
	* various ' , ##args' occurences to aid portability across versions of 'gcc'.
	* http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html#Variadic-Macros
	*/
	# define do_crm_log(level, fmt, args...) do { \
	static struct _pcmk_ddebug descriptor \
	__attribute__((section("__verbose"), aligned(8))) = \
	{ __func__, __FILE__, fmt, __LINE__, LOG_TRACE}; \
	\
	if(__likely((level) <= crm_log_level)) { \
	cl_log((level), "%s: " fmt, __PRETTY_FUNCTION__ , ##args); \
	\
	} else if(__unlikely(descriptor.bump != LOG_TRACE)) { \
	cl_log(descriptor.bump, "TRACE: %s: %s:%d " fmt, __PRETTY_FUNCTION__ , __FILE__, __LINE__, ##args); \
	} \
	} while(0)

	# define do_crm_log_unlikely(level, fmt, args...) do { \
	static struct _pcmk_ddebug descriptor \
	__attribute__((section("__verbose"), aligned(8))) = \
	{ __func__, __FILE__, fmt, __LINE__, LOG_TRACE }; \
	\
	if(__unlikely((level) <= crm_log_level)) { \
	cl_log((level), "%s: " fmt, __PRETTY_FUNCTION__ , ##args); \
	\
	} else if(__unlikely(descriptor.bump != LOG_TRACE)) { \
	cl_log(descriptor.bump, "TRACE: %s: %s:%d " fmt, __PRETTY_FUNCTION__ , __FILE__, __LINE__, ##args); \
	} \
	} while(0)

	# define do_crm_log_xml(level, text, xml) do { \
	static struct _pcmk_ddebug descriptor \
	__attribute__((section("__verbose"), aligned(8))) = \
	{ __func__, __FILE__, __PRETTY_FUNCTION__, __LINE__, LOG_TRACE }; \
	\
	if(xml == NULL) { \
	} else if(__likely((level) <= crm_log_level)) { \
	log_data_element(level, __FILE__, __PRETTY_FUNCTION__, 0, text, xml, 0, TRUE); \
	\
	} else if(__unlikely(descriptor.bump != LOG_TRACE)) { \
	log_data_element(descriptor.bump, __FILE__, __PRETTY_FUNCTION__, __LINE__, text, xml, 0, TRUE); \
	} \
	} while(0)

	# define do_crm_log_alias(level, file, function, line, fmt, args...) do { \
	if(line) { \
	cl_log(level, "TRACE: %s %s:%d "fmt, function, file, line, ##args); \
	} else { \
	cl_log(level, "%s "fmt, function, ##args); \
	} \
	} while(0)

	#else

	# define CRM_TRACE_INIT_DATA(name)

	#define CRM_CHECK(expr, failure_action) do { \
	if(__unlikely((expr) == FALSE)) { \
	crm_abort(__FILE__,__PRETTY_FUNCTION__,__LINE__, #expr, FALSE, TRUE); \
	failure_action; \
	} \
	} while(0)

	# define do_crm_log(level, fmt, args...) do { \
	if(__likely((level) <= crm_log_level)) { \
	cl_log((level), "%s: " fmt, __PRETTY_FUNCTION__ , ##args); \
	} \
	} while(0)

	# define do_crm_log_unlikely(level, fmt, args...) do { \
	if(__unlikely((level) <= crm_log_level)) { \
	cl_log((level), "%s: " fmt, __PRETTY_FUNCTION__ , ##args); \
	} \
	} while(0)

	# define do_crm_log_xml(level, text, xml) do { \
	if(xml == NULL) { \
	} else if(__unlikely((level) <= crm_log_level)) { \
	log_data_element(level, __FILE__, __PRETTY_FUNCTION__, 0, text, xml, 0, TRUE); \
	} \
	} while(0)

	# define do_crm_log_alias(level, file, function, line, fmt, args...) do { \
	cl_log(level, "%s"fmt, function, ##args); \
	} while(0)

	#endif

	#define do_crm_log_always(level, fmt, args...) cl_log(level, "%s: " fmt, __PRETTY_FUNCTION__ , ##args)

	#define crm_crit(fmt, args...) do_crm_log_always(LOG_CRIT, fmt , ##args)
	#define crm_err(fmt, args...) do_crm_log(LOG_ERR, fmt , ##args)
	#define crm_warn(fmt, args...) do_crm_log(LOG_WARNING, fmt , ##args)
	#define crm_notice(fmt, args...) do_crm_log(LOG_NOTICE, fmt , ##args)
	#define crm_info(fmt, args...) do_crm_log(LOG_INFO, fmt , ##args)
	#define crm_debug(fmt, args...) do_crm_log_unlikely(LOG_DEBUG, fmt , ##args)
	#define crm_trace(fmt, args...) do_crm_log_unlikely(LOG_TRACE, fmt , ##args)
	#define crm_debug_2 crm_trace
	#define crm_debug_3 crm_trace
	#define crm_debug_4 crm_trace
	#define crm_debug_5 crm_trace
	#define crm_debug_6 crm_trace

	#define crm_perror(level, fmt, args...) do { \
	const char *err = strerror(errno); \
	fprintf(stderr, fmt ": %s (%d)\n", ##args, err, errno); \
	do_crm_log(level, fmt ": %s (%d)", ##args, err, errno); \
	} while(0)

	#include <crm/common/util.h>

	#define crm_log_xml_crit(xml, text) do_crm_log_xml(LOG_CRIT, text, xml)
	#define crm_log_xml_err(xml, text) do_crm_log_xml(LOG_ERR, text, xml)
	#define crm_log_xml_warn(xml, text) do_crm_log_xml(LOG_WARNING, text, xml)
	#define crm_log_xml_notice(xml, text) do_crm_log_xml(LOG_NOTICE, text, xml)
	#define crm_log_xml_info(xml, text) do_crm_log_xml(LOG_INFO, text, xml)
	#define crm_log_xml_debug(xml, text) do_crm_log_xml(LOG_DEBUG, text, xml)
	#define crm_log_xml_trace(xml, text) do_crm_log_xml(LOG_TRACE, text, xml)

	#define crm_log_xml do_crm_log_xml
	#define crm_log_xml_debug_2 crm_log_xml_trace
	#define crm_log_xml_debug_3 crm_log_xml_trace
	#define crm_log_xml_debug_4 crm_log_xml_trace
	#define crm_log_xml_debug_5 crm_log_xml_trace

	#define crm_str(x) (const char*)(x?x:"<null>")

	#define crm_malloc0(malloc_obj, length) do { \
	malloc_obj = malloc(length); \
	if(malloc_obj == NULL) { \
	crm_err("Failed allocation of %lu bytes", (unsigned long)length); \
	CRM_ASSERT(malloc_obj != NULL); \
	} \
	memset(malloc_obj, 0, length); \
	} while(0)

	#define crm_malloc(malloc_obj, length) do { \
	malloc_obj = malloc(length); \
	if(malloc_obj == NULL) { \
	crm_err("Failed allocation of %lu bytes", (unsigned long)length); \
	CRM_ASSERT(malloc_obj != NULL); \
	} \
	} while(0)

	#define crm_realloc(realloc_obj, length) do { \
	realloc_obj = realloc(realloc_obj, length); \
	CRM_ASSERT(realloc_obj != NULL); \
	} while(0)

	#define crm_free(free_obj) do { free(free_obj); free_obj=NULL; } while(0)
	#define crm_msg_del(msg) do { if(msg != NULL) { ha_msg_del(msg); msg = NULL; } } while(0)

	#define crm_strdup(str) crm_strdup_fn(str, __FILE__, __PRETTY_FUNCTION__, __LINE__)

	extern void update_all_trace_data(void);

	-#define is_privileged(user) (user && \
	- (strcmp(user, CRM_DAEMON_USER) == 0 \
	- \|\| strcmp(user, "root") == 0))
	-
	static inline void slist_basic_destroy(GListPtr list)
	{
	GListPtr gIter = NULL;
	for(gIter = list; gIter != NULL; gIter = gIter->next) {
	free(gIter->data);
	}
	g_list_free(list);
	}

	/* These two macros are no longer to be used
	* They exist for compatability reasons and will be removed in a
	* future release
	*/
	#define slist_destroy(child_type, child, parent, a) do { \
	GListPtr __crm_iter_head = parent; \
	child_type *child = NULL; \
	while(__crm_iter_head != NULL) { \
	child = (child_type *) __crm_iter_head->data; \
	__crm_iter_head = __crm_iter_head->next; \
	{ a; } \
	} \
	g_list_free(parent); \
	} while(0)

	#define slist_iter(child, child_type, parent, counter, a) do { \
	GListPtr __crm_iter_head = parent; \
	child_type *child = NULL; \
	int counter = 0; \
	for(; __crm_iter_head != NULL; counter++) { \
	child = (child_type *) __crm_iter_head->data; \
	__crm_iter_head = __crm_iter_head->next; \
	{ a; } \
	} \
	} while(0)

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:39 PM (6 h, 43 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002725
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions