![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * Copyright 2015-2022 the Pacemaker project contributors
3 *
4 * The version control history for this file may have further details.
5 *
6 * This source code is licensed under the GNU Lesser General Public License
7 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
8 */
9
10 #ifndef CRM_COMMON_INTERNAL__H
11 #define CRM_COMMON_INTERNAL__H
12
13 #include <unistd.h> // pid_t, getpid()
14 #include <stdbool.h> // bool
15 #include <stdint.h> // uint8_t, uint64_t
16
17 #include <glib.h> // guint, GList, GHashTable
18 #include <libxml/tree.h> // xmlNode
19
20 #include <crm/common/util.h> // crm_strdup_printf()
21 #include <crm/common/logging.h> // do_crm_log_unlikely(), etc.
22 #include <crm/common/mainloop.h> // mainloop_io_t, struct ipc_client_callbacks
23 #include <crm/common/health_internal.h>
24 #include <crm/common/io_internal.h>
25 #include <crm/common/iso8601_internal.h>
26 #include <crm/common/results_internal.h>
27 #include <crm/common/messages_internal.h>
28 #include <crm/common/strings_internal.h>
29 #include <crm/common/acl_internal.h>
30
31 /* This says whether the current application is a Pacemaker daemon or not,
32 * and is used to change default logging settings such as whether to log to
33 * stderr, etc., as well as a few other details such as whether blackbox signal
34 * handling is enabled.
35 *
36 * It is set when logging is initialized, and does not need to be set directly.
37 */
38 extern bool pcmk__is_daemon;
39
40 //! Node name of the local node
41 extern char *pcmk__our_nodename;
42
43 // Number of elements in a statically defined array
44 #define PCMK__NELEM(a) ((int) (sizeof(a)/sizeof(a[0])) )
45
46 #if SUPPORT_CIBSECRETS
47 /* internal CIB utilities (from cib_secrets.c) */
48
49 int pcmk__substitute_secrets(const char *rsc_id, GHashTable *params);
50 #endif
51
52
53 /* internal digest-related utilities (from digest.c) */
54
55 bool pcmk__verify_digest(xmlNode *input, const char *expected);
56
57
58 /* internal main loop utilities (from mainloop.c) */
59
60 int pcmk__add_mainloop_ipc(crm_ipc_t *ipc, int priority, void *userdata,
61 const struct ipc_client_callbacks *callbacks,
62 mainloop_io_t **source);
63 guint pcmk__mainloop_timer_get_period(const mainloop_timer_t *timer);
64
65
66 /* internal node-related XML utilities (from nodes.c) */
67
68 /*!
69 * \internal
70 * \brief Add local node name and ID to an XML node
71 *
72 * \param[in,out] request XML node to modify
73 * \param[in] node The local node's name
74 * \param[in] nodeid The local node's ID (can be 0)
75 */
76 void pcmk__xe_add_node(xmlNode *xml, const char *node, int nodeid);
77
78
79 /* internal name/value utilities (from nvpair.c) */
80
81 int pcmk__scan_nvpair(const char *input, char **name, char **value);
82 char *pcmk__format_nvpair(const char *name, const char *value,
83 const char *units);
84
85 /*!
86 * \internal
87 * \brief Add a boolean attribute to an XML node.
88 *
89 * \param[in,out] node XML node to add attributes to
90 * \param[in] name XML attribute to create
91 * \param[in] value Value to give to the attribute
92 */
93 void
94 pcmk__xe_set_bool_attr(xmlNodePtr node, const char *name, bool value);
95
96 /*!
97 * \internal
98 * \brief Extract a boolean attribute's value from an XML element
99 *
100 * \param[in] node XML node to get attribute from
101 * \param[in] name XML attribute to get
102 *
103 * \return True if the given \p name is an attribute on \p node and has
104 * the value "true", False in all other cases
105 */
106 bool
107 pcmk__xe_attr_is_true(const xmlNode *node, const char *name);
108
109 /*!
110 * \internal
111 * \brief Extract a boolean attribute's value from an XML element, with
112 * error checking
113 *
114 * \param[in] node XML node to get attribute from
115 * \param[in] name XML attribute to get
116 * \param[out] value Destination for the value of the attribute
117 *
118 * \return EINVAL if \p name or \p value are NULL, ENODATA if \p node is
119 * NULL or the attribute does not exist, pcmk_rc_unknown_format
120 * if the attribute is not a boolean, and pcmk_rc_ok otherwise.
121 *
122 * \note \p value only has any meaning if the return value is pcmk_rc_ok.
123 */
124 int
125 pcmk__xe_get_bool_attr(const xmlNode *node, const char *name, bool *value);
126
127
128 /* internal procfs utilities (from procfs.c) */
129
130 pid_t pcmk__procfs_pid_of(const char *name);
131 unsigned int pcmk__procfs_num_cores(void);
132 int pcmk__procfs_pid2path(pid_t pid, char path[], size_t path_size);
133 bool pcmk__procfs_has_pids(void);
134
135 /* internal XML schema functions (from xml.c) */
136
137 void crm_schema_init(void);
138 void crm_schema_cleanup(void);
139
140
141 /* internal functions related to process IDs (from pid.c) */
142
143 /*!
144 * \internal
145 * \brief Check whether process exists (by PID and optionally executable path)
146 *
147 * \param[in] pid PID of process to check
148 * \param[in] daemon If not NULL, path component to match with procfs entry
149 *
150 * \return Standard Pacemaker return code
151 * \note Particular return codes of interest include pcmk_rc_ok for alive,
152 * ESRCH for process is not alive (verified by kill and/or executable path
153 * match), EACCES for caller unable or not allowed to check. A result of
154 * "alive" is less reliable when \p daemon is not provided or procfs is
155 * not available, since there is no guarantee that the PID has not been
156 * recycled for another process.
157 * \note This function cannot be used to verify \e authenticity of the process.
158 */
159 int pcmk__pid_active(pid_t pid, const char *daemon);
160
161 int pcmk__read_pidfile(const char *filename, pid_t *pid);
162 int pcmk__pidfile_matches(const char *filename, pid_t expected_pid,
163 const char *expected_name, pid_t *pid);
164 int pcmk__lock_pidfile(const char *filename, const char *name);
165
166
167 /* internal functions related to resource operations (from operations.c) */
168
169 // printf-style format to create operation ID from resource, action, interval
170 #define PCMK__OP_FMT "%s_%s_%u"
171
172 char *pcmk__op_key(const char *rsc_id, const char *op_type, guint interval_ms);
173 char *pcmk__notify_key(const char *rsc_id, const char *notify_type,
174 const char *op_type);
175 char *pcmk__transition_key(int transition_id, int action_id, int target_rc,
176 const char *node);
177 void pcmk__filter_op_for_digest(xmlNode *param_set);
178 bool pcmk__is_fencing_action(const char *action);
179
180
181 // bitwise arithmetic utilities
182
183 /*!
184 * \internal
185 * \brief Set specified flags in a flag group
186 *
187 * \param[in] function Function name of caller
188 * \param[in] line Line number of caller
189 * \param[in] log_level Log a message at this level
190 * \param[in] flag_type Label describing this flag group (for logging)
191 * \param[in] target Name of object whose flags these are (for logging)
192 * \param[in] flag_group Flag group being manipulated
193 * \param[in] flags Which flags in the group should be set
194 * \param[in] flags_str Readable equivalent of \p flags (for logging)
195 *
196 * \return Possibly modified flag group
197 */
198 static inline uint64_t
199 pcmk__set_flags_as(const char *function, int line, uint8_t log_level,
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
200 const char *flag_type, const char *target,
201 uint64_t flag_group, uint64_t flags, const char *flags_str)
202 {
203 uint64_t result = flag_group | flags;
204
205 if (result != flag_group) {
206 do_crm_log_unlikely(log_level,
207 "%s flags %#.8llx (%s) for %s set by %s:%d",
208 ((flag_type == NULL)? "Group of" : flag_type),
209 (unsigned long long) flags,
210 ((flags_str == NULL)? "flags" : flags_str),
211 ((target == NULL)? "target" : target),
212 function, line);
213 }
214 return result;
215 }
216
217 /*!
218 * \internal
219 * \brief Clear specified flags in a flag group
220 *
221 * \param[in] function Function name of caller
222 * \param[in] line Line number of caller
223 * \param[in] log_level Log a message at this level
224 * \param[in] flag_type Label describing this flag group (for logging)
225 * \param[in] target Name of object whose flags these are (for logging)
226 * \param[in] flag_group Flag group being manipulated
227 * \param[in] flags Which flags in the group should be cleared
228 * \param[in] flags_str Readable equivalent of \p flags (for logging)
229 *
230 * \return Possibly modified flag group
231 */
232 static inline uint64_t
233 pcmk__clear_flags_as(const char *function, int line, uint8_t log_level,
/* ![[previous]](../icons/left.png)
*/
234 const char *flag_type, const char *target,
235 uint64_t flag_group, uint64_t flags, const char *flags_str)
236 {
237 uint64_t result = flag_group & ~flags;
238
239 if (result != flag_group) {
240 do_crm_log_unlikely(log_level,
241 "%s flags %#.8llx (%s) for %s cleared by %s:%d",
242 ((flag_type == NULL)? "Group of" : flag_type),
243 (unsigned long long) flags,
244 ((flags_str == NULL)? "flags" : flags_str),
245 ((target == NULL)? "target" : target),
246 function, line);
247 }
248 return result;
249 }
250
251 // miscellaneous utilities (from utils.c)
252
253 void pcmk__daemonize(const char *name, const char *pidfile);
254 void pcmk__panic(const char *origin);
255 pid_t pcmk__locate_sbd(void);
256 void pcmk__sleep_ms(unsigned int ms);
257
258 extern int pcmk__score_red;
259 extern int pcmk__score_green;
260 extern int pcmk__score_yellow;
261
262 /*!
263 * \internal
264 * \brief Resize a dynamically allocated memory block
265 *
266 * \param[in] ptr Memory block to resize (or NULL to allocate new memory)
267 * \param[in] size New size of memory block in bytes (must be > 0)
268 *
269 * \return Pointer to resized memory block
270 *
271 * \note This asserts on error, so the result is guaranteed to be non-NULL
272 * (which is the main advantage of this over directly using realloc()).
273 */
274 static inline void *
275 pcmk__realloc(void *ptr, size_t size)
/* */
276 {
277 void *new_ptr;
278
279 // realloc(p, 0) can replace free(p) but this wrapper can't
280 CRM_ASSERT(size > 0);
281
282 new_ptr = realloc(ptr, size);
283 if (new_ptr == NULL) {
284 free(ptr);
285 abort();
286 }
287 return new_ptr;
288 }
289
290
291 static inline char *
292 pcmk__getpid_s(void)
/* */
293 {
294 return crm_strdup_printf("%lu", (unsigned long) getpid());
295 }
296
297 // More efficient than g_list_length(list) == 1
298 static inline bool
299 pcmk__list_of_1(GList *list)
/* */
300 {
301 return list && (list->next == NULL);
302 }
303
304 // More efficient than g_list_length(list) > 1
305 static inline bool
306 pcmk__list_of_multiple(GList *list)
/* */
307 {
308 return list && (list->next != NULL);
309 }
310
311 /* convenience functions for failure-related node attributes */
312
313 #define PCMK__FAIL_COUNT_PREFIX "fail-count"
314 #define PCMK__LAST_FAILURE_PREFIX "last-failure"
315
316 /*!
317 * \internal
318 * \brief Generate a failure-related node attribute name for a resource
319 *
320 * \param[in] prefix Start of attribute name
321 * \param[in] rsc_id Resource name
322 * \param[in] op Operation name
323 * \param[in] interval_ms Operation interval
324 *
325 * \return Newly allocated string with attribute name
326 *
327 * \note Failure attributes are named like PREFIX-RSC#OP_INTERVAL (for example,
328 * "fail-count-myrsc#monitor_30000"). The '#' is used because it is not
329 * a valid character in a resource ID, to reliably distinguish where the
330 * operation name begins. The '_' is used simply to be more comparable to
331 * action labels like "myrsc_monitor_30000".
332 */
333 static inline char *
334 pcmk__fail_attr_name(const char *prefix, const char *rsc_id, const char *op,
/* */
335 guint interval_ms)
336 {
337 CRM_CHECK(prefix && rsc_id && op, return NULL);
338 return crm_strdup_printf("%s-%s#%s_%u", prefix, rsc_id, op, interval_ms);
339 }
340
341 static inline char *
342 pcmk__failcount_name(const char *rsc_id, const char *op, guint interval_ms)
/* */
343 {
344 return pcmk__fail_attr_name(PCMK__FAIL_COUNT_PREFIX, rsc_id, op,
345 interval_ms);
346 }
347
348 static inline char *
349 pcmk__lastfailure_name(const char *rsc_id, const char *op, guint interval_ms)
/* ![[last]](../icons/n_last.png)
*/
350 {
351 return pcmk__fail_attr_name(PCMK__LAST_FAILURE_PREFIX, rsc_id, op,
352 interval_ms);
353 }
354
355 // internal resource agent functions (from agents.c)
356 int pcmk__effective_rc(int rc);
357
358 #endif /* CRM_COMMON_INTERNAL__H */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/