pacemaker  1.1.17-b36b869ca8
Scalable High-Availability cluster resource manager
logging.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <crm_internal.h>
20 
21 #include <sys/param.h>
22 #include <sys/types.h>
23 #include <sys/wait.h>
24 #include <sys/stat.h>
25 #include <sys/utsname.h>
26 
27 #include <stdio.h>
28 #include <unistd.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <limits.h>
32 #include <ctype.h>
33 #include <pwd.h>
34 #include <grp.h>
35 #include <time.h>
36 #include <libgen.h>
37 #include <signal.h>
38 #include <bzlib.h>
39 
40 #include <qb/qbdefs.h>
41 
42 #include <crm/crm.h>
43 #include <crm/common/mainloop.h>
44 
45 unsigned int crm_log_priority = LOG_NOTICE;
46 unsigned int crm_log_level = LOG_INFO;
47 static gboolean crm_tracing_enabled(void);
48 unsigned int crm_trace_nonlog = 0;
49 bool crm_is_daemon = 0;
50 
51 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
52 GLogFunc glib_log_default;
53 
54 static void
55 crm_glib_handler(const gchar * log_domain, GLogLevelFlags flags, const gchar * message,
56  gpointer user_data)
57 {
58  int log_level = LOG_WARNING;
59  GLogLevelFlags msg_level = (flags & G_LOG_LEVEL_MASK);
60  static struct qb_log_callsite *glib_cs = NULL;
61 
62  if (glib_cs == NULL) {
63  glib_cs = qb_log_callsite_get(__FUNCTION__, __FILE__, "glib-handler", LOG_DEBUG, __LINE__, crm_trace_nonlog);
64  }
65 
66 
67  switch (msg_level) {
68  case G_LOG_LEVEL_CRITICAL:
69  log_level = LOG_CRIT;
70 
71  if (crm_is_callsite_active(glib_cs, LOG_DEBUG, 0) == FALSE) {
72  /* log and record how we got here */
73  crm_abort(__FILE__, __FUNCTION__, __LINE__, message, TRUE, TRUE);
74  }
75  break;
76 
77  case G_LOG_LEVEL_ERROR:
78  log_level = LOG_ERR;
79  break;
80  case G_LOG_LEVEL_MESSAGE:
81  log_level = LOG_NOTICE;
82  break;
83  case G_LOG_LEVEL_INFO:
84  log_level = LOG_INFO;
85  break;
86  case G_LOG_LEVEL_DEBUG:
87  log_level = LOG_DEBUG;
88  break;
89 
90  case G_LOG_LEVEL_WARNING:
91  case G_LOG_FLAG_RECURSION:
92  case G_LOG_FLAG_FATAL:
93  case G_LOG_LEVEL_MASK:
94  log_level = LOG_WARNING;
95  break;
96  }
97 
98  do_crm_log(log_level, "%s: %s", log_domain, message);
99 }
100 #endif
101 
102 #ifndef NAME_MAX
103 # define NAME_MAX 256
104 #endif
105 
106 static void
107 crm_trigger_blackbox(int nsig)
108 {
109  if(nsig == SIGTRAP) {
110  /* Turn it on if it wasn't already */
111  crm_enable_blackbox(nsig);
112  }
113  crm_write_blackbox(nsig, NULL);
114 }
115 
116 const char *
117 daemon_option(const char *option)
118 {
119  char env_name[NAME_MAX];
120  const char *value = NULL;
121 
122  snprintf(env_name, NAME_MAX, "PCMK_%s", option);
123  value = getenv(env_name);
124  if (value != NULL) {
125  crm_trace("Found %s = %s", env_name, value);
126  return value;
127  }
128 
129  snprintf(env_name, NAME_MAX, "HA_%s", option);
130  value = getenv(env_name);
131  if (value != NULL) {
132  crm_trace("Found %s = %s", env_name, value);
133  return value;
134  }
135 
136  crm_trace("Nothing found for %s", option);
137  return NULL;
138 }
139 
140 void
141 set_daemon_option(const char *option, const char *value)
142 {
143  char env_name[NAME_MAX];
144 
145  snprintf(env_name, NAME_MAX, "PCMK_%s", option);
146  if (value) {
147  crm_trace("Setting %s to %s", env_name, value);
148  setenv(env_name, value, 1);
149  } else {
150  crm_trace("Unsetting %s", env_name);
151  unsetenv(env_name);
152  }
153 
154  snprintf(env_name, NAME_MAX, "HA_%s", option);
155  if (value) {
156  crm_trace("Setting %s to %s", env_name, value);
157  setenv(env_name, value, 1);
158  } else {
159  crm_trace("Unsetting %s", env_name);
160  unsetenv(env_name);
161  }
162 }
163 
164 gboolean
165 daemon_option_enabled(const char *daemon, const char *option)
166 {
167  const char *value = daemon_option(option);
168 
169  if (value != NULL && crm_is_true(value)) {
170  return TRUE;
171 
172  } else if (value != NULL && strstr(value, daemon)) {
173  return TRUE;
174  }
175 
176  return FALSE;
177 }
178 
179 void
181 {
182 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
183  g_log_set_default_handler(glib_log_default, NULL);
184 #endif
185 }
186 
187 #define FMT_MAX 256
188 static void
189 set_format_string(int method, const char *daemon)
190 {
191  int offset = 0;
192  char fmt[FMT_MAX];
193 
194  if (method > QB_LOG_STDERR) {
195  /* When logging to a file */
196  struct utsname res;
197 
198  if (uname(&res) == 0) {
199  offset +=
200  snprintf(fmt + offset, FMT_MAX - offset, "%%t [%d] %s %10s: ", getpid(),
201  res.nodename, daemon);
202  } else {
203  offset += snprintf(fmt + offset, FMT_MAX - offset, "%%t [%d] %10s: ", getpid(), daemon);
204  }
205  }
206 
207  if (method == QB_LOG_SYSLOG) {
208  offset += snprintf(fmt + offset, FMT_MAX - offset, "%%g %%-7p: %%b");
209  crm_extended_logging(method, QB_FALSE);
210  } else if (crm_tracing_enabled()) {
211  offset += snprintf(fmt + offset, FMT_MAX - offset, "(%%-12f:%%5l %%g) %%-7p: %%n:\t%%b");
212  } else {
213  offset += snprintf(fmt + offset, FMT_MAX - offset, "%%g %%-7p: %%n:\t%%b");
214  }
215 
216  CRM_LOG_ASSERT(offset > 0);
217  qb_log_format_set(method, fmt);
218 }
219 
220 gboolean
221 crm_add_logfile(const char *filename)
222 {
223  bool is_default = false;
224  static int default_fd = -1;
225  static gboolean have_logfile = FALSE;
226 
227  /* @COMPAT This should be CRM_LOG_DIR "/pacemaker.log". We aren't changing
228  * it yet because it will be a significant user-visible change to publicize.
229  */
230  const char *default_logfile = "/var/log/pacemaker.log";
231 
232  struct stat parent;
233  int fd = 0, rc = 0;
234  FILE *logfile = NULL;
235  char *parent_dir = NULL;
236  char *filename_cp;
237 
238  if (filename == NULL && have_logfile == FALSE) {
239  filename = default_logfile;
240  }
241 
242  if (filename == NULL) {
243  return FALSE; /* Nothing to do */
244  } else if(safe_str_eq(filename, "none")) {
245  return FALSE; /* Nothing to do */
246  } else if(safe_str_eq(filename, "/dev/null")) {
247  return FALSE; /* Nothing to do */
248  } else if(safe_str_eq(filename, default_logfile)) {
249  is_default = TRUE;
250  }
251 
252  if(is_default && default_fd >= 0) {
253  return TRUE; /* Nothing to do */
254  }
255 
256  /* Check the parent directory */
257  filename_cp = strdup(filename);
258  parent_dir = dirname(filename_cp);
259  rc = stat(parent_dir, &parent);
260 
261  if (rc != 0) {
262  crm_err("Directory '%s' does not exist: logging to '%s' is disabled", parent_dir, filename);
263  free(filename_cp);
264  return FALSE;
265  }
266  free(filename_cp);
267 
268  errno = 0;
269  logfile = fopen(filename, "a");
270  if(logfile == NULL) {
271  crm_err("%s (%d): Logging to '%s' as uid=%u, gid=%u is disabled",
272  pcmk_strerror(errno), errno, filename, geteuid(), getegid());
273  return FALSE;
274  }
275 
276  /* Check/Set permissions if we're root */
277  if (geteuid() == 0) {
278  struct stat st;
279  uid_t pcmk_uid = 0;
280  gid_t pcmk_gid = 0;
281  gboolean fix = FALSE;
282  int logfd = fileno(logfile);
283 
284  rc = fstat(logfd, &st);
285  if (rc < 0) {
286  crm_perror(LOG_WARNING, "Cannot stat %s", filename);
287  fclose(logfile);
288  return FALSE;
289  }
290 
291  if(crm_user_lookup(CRM_DAEMON_USER, &pcmk_uid, &pcmk_gid) == 0) {
292  if (st.st_gid != pcmk_gid) {
293  /* Wrong group */
294  fix = TRUE;
295  } else if ((st.st_mode & S_IRWXG) != (S_IRGRP | S_IWGRP)) {
296  /* Not read/writable by the correct group */
297  fix = TRUE;
298  }
299  }
300 
301  if (fix) {
302  rc = fchown(logfd, pcmk_uid, pcmk_gid);
303  if (rc < 0) {
304  crm_warn("Cannot change the ownership of %s to user %s and gid %d",
305  filename, CRM_DAEMON_USER, pcmk_gid);
306  }
307 
308  rc = fchmod(logfd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
309  if (rc < 0) {
310  crm_warn("Cannot change the mode of %s to rw-rw----", filename);
311  }
312 
313  fprintf(logfile, "Set r/w permissions for uid=%d, gid=%d on %s\n",
314  pcmk_uid, pcmk_gid, filename);
315  if (fflush(logfile) < 0 || fsync(logfd) < 0) {
316  crm_err("Couldn't write out logfile: %s", filename);
317  }
318  }
319  }
320 
321  /* Close and reopen with libqb */
322  fclose(logfile);
323  fd = qb_log_file_open(filename);
324 
325  if (fd < 0) {
326  crm_perror(LOG_WARNING, "Couldn't send additional logging to %s", filename);
327  return FALSE;
328  }
329 
330  if(is_default) {
331  default_fd = fd;
332 
333  } else if(default_fd >= 0) {
334  crm_notice("Switching to %s", filename);
335  qb_log_ctl(default_fd, QB_LOG_CONF_ENABLED, QB_FALSE);
336  }
337 
338  crm_notice("Additional logging available in %s", filename);
339  qb_log_ctl(fd, QB_LOG_CONF_ENABLED, QB_TRUE);
340  /* qb_log_ctl(fd, QB_LOG_CONF_FILE_SYNC, 1); Turn on synchronous writes */
341 
342  /* Enable callsites */
344  have_logfile = TRUE;
345 
346  return TRUE;
347 }
348 
349 static int blackbox_trigger = 0;
350 static char *blackbox_file_prefix = NULL;
351 
352 static void
353 blackbox_logger(int32_t t, struct qb_log_callsite *cs, time_t timestamp, const char *msg)
354 {
355  if(cs && cs->priority < LOG_ERR) {
356  crm_write_blackbox(SIGTRAP, cs); /* Bypass the over-dumping logic */
357  } else {
358  crm_write_blackbox(0, cs);
359  }
360 }
361 
362 static void
363 crm_control_blackbox(int nsig, bool enable)
364 {
365  int lpc = 0;
366 
367  if (blackbox_file_prefix == NULL) {
368  pid_t pid = getpid();
369 
370  blackbox_file_prefix = malloc(NAME_MAX);
371  snprintf(blackbox_file_prefix, NAME_MAX, "%s/%s-%d", CRM_BLACKBOX_DIR, crm_system_name, pid);
372  }
373 
374  if (enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
375  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 5 * 1024 * 1024); /* Any size change drops existing entries */
376  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE); /* Setting the size seems to disable it */
377 
378  /* Enable synchronous logging */
379  for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
380  qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_TRUE);
381  }
382 
383  crm_notice("Initiated blackbox recorder: %s", blackbox_file_prefix);
384 
385  /* Save to disk on abnormal termination */
386  crm_signal(SIGSEGV, crm_trigger_blackbox);
387  crm_signal(SIGABRT, crm_trigger_blackbox);
388  crm_signal(SIGILL, crm_trigger_blackbox);
389  crm_signal(SIGBUS, crm_trigger_blackbox);
390 
392 
393  blackbox_trigger = qb_log_custom_open(blackbox_logger, NULL, NULL, NULL);
394  qb_log_ctl(blackbox_trigger, QB_LOG_CONF_ENABLED, QB_TRUE);
395  crm_trace("Trigger: %d is %d %d", blackbox_trigger,
396  qb_log_ctl(blackbox_trigger, QB_LOG_CONF_STATE_GET, 0), QB_LOG_STATE_ENABLED);
397 
399 
400  } else if (!enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
401  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
402 
403  /* Disable synchronous logging again when the blackbox is disabled */
404  for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
405  qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_FALSE);
406  }
407  }
408 }
409 
410 void
412 {
413  crm_control_blackbox(nsig, TRUE);
414 }
415 
416 void
418 {
419  crm_control_blackbox(nsig, FALSE);
420 }
421 
422 void
423 crm_write_blackbox(int nsig, struct qb_log_callsite *cs)
424 {
425  static int counter = 1;
426  static time_t last = 0;
427 
428  char buffer[NAME_MAX];
429  time_t now = time(NULL);
430 
431  if (blackbox_file_prefix == NULL) {
432  return;
433  }
434 
435  switch (nsig) {
436  case 0:
437  case SIGTRAP:
438  /* The graceful case - such as assertion failure or user request */
439 
440  if (nsig == 0 && now == last) {
441  /* Prevent over-dumping */
442  return;
443  }
444 
445  snprintf(buffer, NAME_MAX, "%s.%d", blackbox_file_prefix, counter++);
446  if (nsig == SIGTRAP) {
447  crm_notice("Blackbox dump requested, please see %s for contents", buffer);
448 
449  } else if (cs) {
450  syslog(LOG_NOTICE,
451  "Problem detected at %s:%d (%s), please see %s for additional details",
452  cs->function, cs->lineno, cs->filename, buffer);
453  } else {
454  crm_notice("Problem detected, please see %s for additional details", buffer);
455  }
456 
457  last = now;
458  qb_log_blackbox_write_to_file(buffer);
459 
460  /* Flush the existing contents
461  * A size change would also work
462  */
463  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
464  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
465  break;
466 
467  default:
468  /* Do as little as possible, just try to get what we have out
469  * We logged the filename when the blackbox was enabled
470  */
471  crm_signal(nsig, SIG_DFL);
472  qb_log_blackbox_write_to_file(blackbox_file_prefix);
473  qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
474  raise(nsig);
475  break;
476  }
477 }
478 
479 gboolean
480 crm_log_cli_init(const char *entity)
481 {
482  return crm_log_init(entity, LOG_ERR, FALSE, FALSE, 0, NULL, TRUE);
483 }
484 
485 static const char *
486 crm_quark_to_string(uint32_t tag)
487 {
488  const char *text = g_quark_to_string(tag);
489 
490  if (text) {
491  return text;
492  }
493  return "";
494 }
495 
496 static void
497 crm_log_filter_source(int source, const char *trace_files, const char *trace_fns,
498  const char *trace_fmts, const char *trace_tags, const char *trace_blackbox,
499  struct qb_log_callsite *cs)
500 {
501  if (qb_log_ctl(source, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
502  return;
503  } else if (cs->tags != crm_trace_nonlog && source == QB_LOG_BLACKBOX) {
504  /* Blackbox gets everything if enabled */
505  qb_bit_set(cs->targets, source);
506 
507  } else if (source == blackbox_trigger && blackbox_trigger > 0) {
508  /* Should this log message result in the blackbox being dumped */
509  if (cs->priority <= LOG_ERR) {
510  qb_bit_set(cs->targets, source);
511 
512  } else if (trace_blackbox) {
513  char *key = crm_strdup_printf("%s:%d", cs->function, cs->lineno);
514 
515  if (strstr(trace_blackbox, key) != NULL) {
516  qb_bit_set(cs->targets, source);
517  }
518  free(key);
519  }
520 
521  } else if (source == QB_LOG_SYSLOG) { /* No tracing to syslog */
522  if (cs->priority <= crm_log_priority && cs->priority <= crm_log_level) {
523  qb_bit_set(cs->targets, source);
524  }
525  /* Log file tracing options... */
526  } else if (cs->priority <= crm_log_level) {
527  qb_bit_set(cs->targets, source);
528  } else if (trace_files && strstr(trace_files, cs->filename) != NULL) {
529  qb_bit_set(cs->targets, source);
530  } else if (trace_fns && strstr(trace_fns, cs->function) != NULL) {
531  qb_bit_set(cs->targets, source);
532  } else if (trace_fmts && strstr(trace_fmts, cs->format) != NULL) {
533  qb_bit_set(cs->targets, source);
534  } else if (trace_tags
535  && cs->tags != 0
536  && cs->tags != crm_trace_nonlog && g_quark_to_string(cs->tags) != NULL) {
537  qb_bit_set(cs->targets, source);
538  }
539 }
540 
541 static void
542 crm_log_filter(struct qb_log_callsite *cs)
543 {
544  int lpc = 0;
545  static int need_init = 1;
546  static const char *trace_fns = NULL;
547  static const char *trace_tags = NULL;
548  static const char *trace_fmts = NULL;
549  static const char *trace_files = NULL;
550  static const char *trace_blackbox = NULL;
551 
552  if (need_init) {
553  need_init = 0;
554  trace_fns = getenv("PCMK_trace_functions");
555  trace_fmts = getenv("PCMK_trace_formats");
556  trace_tags = getenv("PCMK_trace_tags");
557  trace_files = getenv("PCMK_trace_files");
558  trace_blackbox = getenv("PCMK_trace_blackbox");
559 
560  if (trace_tags != NULL) {
561  uint32_t tag;
562  char token[500];
563  const char *offset = NULL;
564  const char *next = trace_tags;
565 
566  do {
567  offset = next;
568  next = strchrnul(offset, ',');
569  snprintf(token, 499, "%.*s", (int)(next - offset), offset);
570 
571  tag = g_quark_from_string(token);
572  crm_info("Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);
573 
574  if (next[0] != 0) {
575  next++;
576  }
577 
578  } while (next != NULL && next[0] != 0);
579  }
580  }
581 
582  cs->targets = 0; /* Reset then find targets to enable */
583  for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
584  crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
585  cs);
586  }
587 }
588 
589 gboolean
590 crm_is_callsite_active(struct qb_log_callsite *cs, uint8_t level, uint32_t tags)
591 {
592  gboolean refilter = FALSE;
593 
594  if (cs == NULL) {
595  return FALSE;
596  }
597 
598  if (cs->priority != level) {
599  cs->priority = level;
600  refilter = TRUE;
601  }
602 
603  if (cs->tags != tags) {
604  cs->tags = tags;
605  refilter = TRUE;
606  }
607 
608  if (refilter) {
609  crm_log_filter(cs);
610  }
611 
612  if (cs->targets == 0) {
613  return FALSE;
614  }
615  return TRUE;
616 }
617 
618 void
620 {
621  static gboolean log = TRUE;
622 
623  if (log) {
624  log = FALSE;
625  crm_debug
626  ("Enabling callsites based on priority=%d, files=%s, functions=%s, formats=%s, tags=%s",
627  crm_log_level, getenv("PCMK_trace_files"), getenv("PCMK_trace_functions"),
628  getenv("PCMK_trace_formats"), getenv("PCMK_trace_tags"));
629  }
630  qb_log_filter_fn_set(crm_log_filter);
631 }
632 
633 static gboolean
634 crm_tracing_enabled(void)
635 {
636  if (crm_log_level >= LOG_TRACE) {
637  return TRUE;
638  } else if (getenv("PCMK_trace_files") || getenv("PCMK_trace_functions")
639  || getenv("PCMK_trace_formats") || getenv("PCMK_trace_tags")) {
640  return TRUE;
641  }
642  return FALSE;
643 }
644 
645 static int
646 crm_priority2int(const char *name)
647 {
648  struct syslog_names {
649  const char *name;
650  int priority;
651  };
652  static struct syslog_names p_names[] = {
653  {"emerg", LOG_EMERG},
654  {"alert", LOG_ALERT},
655  {"crit", LOG_CRIT},
656  {"error", LOG_ERR},
657  {"warning", LOG_WARNING},
658  {"notice", LOG_NOTICE},
659  {"info", LOG_INFO},
660  {"debug", LOG_DEBUG},
661  {NULL, -1}
662  };
663  int lpc;
664 
665  for (lpc = 0; name != NULL && p_names[lpc].name != NULL; lpc++) {
666  if (crm_str_eq(p_names[lpc].name, name, TRUE)) {
667  return p_names[lpc].priority;
668  }
669  }
670  return crm_log_priority;
671 }
672 
673 
674 static void
675 crm_identity(const char *entity, int argc, char **argv)
676 {
677  if(crm_system_name != NULL) {
678  /* Nothing to do */
679 
680  } else if (entity) {
681  free(crm_system_name);
682  crm_system_name = strdup(entity);
683 
684  } else if (argc > 0 && argv != NULL) {
685  char *mutable = strdup(argv[0]);
686  char *modified = basename(mutable);
687 
688  if (strstr(modified, "lt-") == modified) {
689  modified += 3;
690  }
691 
692  free(crm_system_name);
693  crm_system_name = strdup(modified);
694  free(mutable);
695 
696  } else if (crm_system_name == NULL) {
697  crm_system_name = strdup("Unknown");
698  }
699 
700  setenv("PCMK_service", crm_system_name, 1);
701 }
702 
703 
704 void
705 crm_log_preinit(const char *entity, int argc, char **argv)
706 {
707  /* Configure libqb logging with nothing turned on */
708 
709  int lpc = 0;
710  int32_t qb_facility = 0;
711 
712  static bool have_logging = FALSE;
713 
714  if(have_logging == FALSE) {
715  have_logging = TRUE;
716 
717  crm_xml_init(); /* Sets buffer allocation strategy */
718 
719  if (crm_trace_nonlog == 0) {
720  crm_trace_nonlog = g_quark_from_static_string("Pacemaker non-logging tracepoint");
721  }
722 
723  umask(S_IWGRP | S_IWOTH | S_IROTH);
724 
725  /* Redirect messages from glib functions to our handler */
726 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
727  glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
728 #endif
729 
730  /* and for good measure... - this enum is a bit field (!) */
731  g_log_set_always_fatal((GLogLevelFlags) 0); /*value out of range */
732 
733  /* Who do we log as */
734  crm_identity(entity, argc, argv);
735 
736  qb_facility = qb_log_facility2int("local0");
737  qb_log_init(crm_system_name, qb_facility, LOG_ERR);
738  crm_log_level = LOG_CRIT;
739 
740  /* Nuke any syslog activity until it's asked for */
741  qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
742 
743  /* Set format strings and disable threading
744  * Pacemaker and threads do not mix well (due to the amount of forking)
745  */
746  qb_log_tags_stringify_fn_set(crm_quark_to_string);
747  for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
748  qb_log_ctl(lpc, QB_LOG_CONF_THREADED, QB_FALSE);
749  set_format_string(lpc, crm_system_name);
750  }
751  }
752 }
753 
754 gboolean
755 crm_log_init(const char *entity, uint8_t level, gboolean daemon, gboolean to_stderr,
756  int argc, char **argv, gboolean quiet)
757 {
758  const char *syslog_priority = NULL;
759  const char *logfile = daemon_option("logfile");
760  const char *facility = daemon_option("logfacility");
761  const char *f_copy = facility;
762 
764  crm_log_preinit(entity, argc, argv);
765 
766  if(level > crm_log_level) {
767  crm_log_level = level;
768  }
769 
770  /* Should we log to syslog */
771  if (facility == NULL) {
772  if(crm_is_daemon) {
773  facility = "daemon";
774  } else {
775  facility = "none";
776  }
777  set_daemon_option("logfacility", facility);
778  }
779 
780  if (safe_str_eq(facility, "none")) {
781  quiet = TRUE;
782 
783 
784  } else {
785  qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_FACILITY, qb_log_facility2int(facility));
786  }
787 
788  if (daemon_option_enabled(crm_system_name, "debug")) {
789  /* Override the default setting */
790  crm_log_level = LOG_DEBUG;
791  }
792 
793  /* What lower threshold do we have for sending to syslog */
794  syslog_priority = daemon_option("logpriority");
795  if(syslog_priority) {
796  int priority = crm_priority2int(syslog_priority);
797  crm_log_priority = priority;
798  qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE, "*", priority);
799  } else {
800  qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE, "*", LOG_NOTICE);
801  }
802 
803  if (!quiet) {
804  /* Nuke any syslog activity */
805  qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);
806  }
807 
808  /* Should we log to stderr */
809  if (daemon_option_enabled(crm_system_name, "stderr")) {
810  /* Override the default setting */
811  to_stderr = TRUE;
812  }
813  crm_enable_stderr(to_stderr);
814 
815  /* Should we log to a file */
816  if (safe_str_eq("none", logfile)) {
817  /* No soup^Hlogs for you! */
818  } else if(crm_is_daemon) {
819  /* The daemons always get a log file, unless explicitly set to configured 'none' */
820  crm_add_logfile(logfile);
821  } else if(logfile) {
822  crm_add_logfile(logfile);
823  }
824 
827  }
828 
829  /* Summary */
830  crm_trace("Quiet: %d, facility %s", quiet, f_copy);
831  daemon_option("logfile");
832  daemon_option("logfacility");
833 
835 
836  /* Ok, now we can start logging... */
837  if (quiet == FALSE && crm_is_daemon == FALSE) {
838  crm_log_args(argc, argv);
839  }
840 
841  if (crm_is_daemon) {
842  const char *user = getenv("USER");
843 
844  if (user != NULL && safe_str_neq(user, "root") && safe_str_neq(user, CRM_DAEMON_USER)) {
845  crm_trace("Not switching to corefile directory for %s", user);
846  crm_is_daemon = FALSE;
847  }
848  }
849 
850  if (crm_is_daemon) {
851  int user = getuid();
852  const char *base = CRM_CORE_DIR;
853  struct passwd *pwent = getpwuid(user);
854 
855  if (pwent == NULL) {
856  crm_perror(LOG_ERR, "Cannot get name for uid: %d", user);
857 
858  } else if (safe_str_neq(pwent->pw_name, "root")
859  && safe_str_neq(pwent->pw_name, CRM_DAEMON_USER)) {
860  crm_trace("Don't change active directory for regular user: %s", pwent->pw_name);
861 
862  } else if (chdir(base) < 0) {
863  crm_perror(LOG_INFO, "Cannot change active directory to %s", base);
864 
865  } else {
866  crm_info("Changed active directory to %s", base);
867 #if 0
868  {
869  char path[512];
870 
871  snprintf(path, 512, "%s-%d", crm_system_name, getpid());
872  mkdir(path, 0750);
873  chdir(path);
874  crm_info("Changed active directory to %s/%s/%s", base, pwent->pw_name, path);
875  }
876 #endif
877  }
878 
879  /* Original meanings from signal(7)
880  *
881  * Signal Value Action Comment
882  * SIGTRAP 5 Core Trace/breakpoint trap
883  * SIGUSR1 30,10,16 Term User-defined signal 1
884  * SIGUSR2 31,12,17 Term User-defined signal 2
885  *
886  * Our usage is as similar as possible
887  */
890  mainloop_add_signal(SIGTRAP, crm_trigger_blackbox);
891  }
892 
893  return TRUE;
894 }
895 
896 /* returns the old value */
897 unsigned int
898 set_crm_log_level(unsigned int level)
899 {
900  unsigned int old = crm_log_level;
901 
902  crm_log_level = level;
904  crm_trace("New log level: %d", level);
905  return old;
906 }
907 
908 void
909 crm_enable_stderr(int enable)
910 {
911  if (enable && qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
912  qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
914 
915  } else if (enable == FALSE) {
916  qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
917  }
918 }
919 
920 void
921 crm_bump_log_level(int argc, char **argv)
922 {
923  static int args = TRUE;
924  int level = crm_log_level;
925 
926  if (args && argc > 1) {
927  crm_log_args(argc, argv);
928  }
929 
930  if (qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
931  set_crm_log_level(level + 1);
932  }
933 
934  /* Enable after potentially logging the argstring, not before */
935  crm_enable_stderr(TRUE);
936 }
937 
938 unsigned int
940 {
941  return crm_log_level;
942 }
943 
944 #define ARGS_FMT "Invoked: %s"
945 void
946 crm_log_args(int argc, char **argv)
947 {
948  int lpc = 0;
949  int len = 0;
950  int existing_len = 0;
951  int line = __LINE__;
952  static int logged = 0;
953 
954  char *arg_string = NULL;
955 
956  if (argc == 0 || argv == NULL || logged) {
957  return;
958  }
959 
960  logged = 1;
961 
962  for (; lpc < argc; lpc++) {
963  if (argv[lpc] == NULL) {
964  break;
965  }
966 
967  len = 2 + strlen(argv[lpc]); /* +1 space, +1 EOS */
968  arg_string = realloc_safe(arg_string, len + existing_len);
969  existing_len += sprintf(arg_string + existing_len, "%s ", argv[lpc]);
970  }
971 
972  qb_log_from_external_source(__func__, __FILE__, ARGS_FMT, LOG_NOTICE, line, 0, arg_string);
973 
974  free(arg_string);
975 }
976 
977 const char *
979 {
980  int error = ABS(rc);
981 
982  switch (error) {
983  case E2BIG: return "E2BIG";
984  case EACCES: return "EACCES";
985  case EADDRINUSE: return "EADDRINUSE";
986  case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
987  case EAFNOSUPPORT: return "EAFNOSUPPORT";
988  case EAGAIN: return "EAGAIN";
989  case EALREADY: return "EALREADY";
990  case EBADF: return "EBADF";
991  case EBADMSG: return "EBADMSG";
992  case EBUSY: return "EBUSY";
993  case ECANCELED: return "ECANCELED";
994  case ECHILD: return "ECHILD";
995  case ECOMM: return "ECOMM";
996  case ECONNABORTED: return "ECONNABORTED";
997  case ECONNREFUSED: return "ECONNREFUSED";
998  case ECONNRESET: return "ECONNRESET";
999  /* case EDEADLK: return "EDEADLK"; */
1000  case EDESTADDRREQ: return "EDESTADDRREQ";
1001  case EDOM: return "EDOM";
1002  case EDQUOT: return "EDQUOT";
1003  case EEXIST: return "EEXIST";
1004  case EFAULT: return "EFAULT";
1005  case EFBIG: return "EFBIG";
1006  case EHOSTDOWN: return "EHOSTDOWN";
1007  case EHOSTUNREACH: return "EHOSTUNREACH";
1008  case EIDRM: return "EIDRM";
1009  case EILSEQ: return "EILSEQ";
1010  case EINPROGRESS: return "EINPROGRESS";
1011  case EINTR: return "EINTR";
1012  case EINVAL: return "EINVAL";
1013  case EIO: return "EIO";
1014  case EISCONN: return "EISCONN";
1015  case EISDIR: return "EISDIR";
1016  case ELIBACC: return "ELIBACC";
1017  case ELOOP: return "ELOOP";
1018  case EMFILE: return "EMFILE";
1019  case EMLINK: return "EMLINK";
1020  case EMSGSIZE: return "EMSGSIZE";
1021  case EMULTIHOP: return "EMULTIHOP";
1022  case ENAMETOOLONG: return "ENAMETOOLONG";
1023  case ENETDOWN: return "ENETDOWN";
1024  case ENETRESET: return "ENETRESET";
1025  case ENETUNREACH: return "ENETUNREACH";
1026  case ENFILE: return "ENFILE";
1027  case ENOBUFS: return "ENOBUFS";
1028  case ENODATA: return "ENODATA";
1029  case ENODEV: return "ENODEV";
1030  case ENOENT: return "ENOENT";
1031  case ENOEXEC: return "ENOEXEC";
1032  case ENOKEY: return "ENOKEY";
1033  case ENOLCK: return "ENOLCK";
1034  case ENOLINK: return "ENOLINK";
1035  case ENOMEM: return "ENOMEM";
1036  case ENOMSG: return "ENOMSG";
1037  case ENOPROTOOPT: return "ENOPROTOOPT";
1038  case ENOSPC: return "ENOSPC";
1039  case ENOSR: return "ENOSR";
1040  case ENOSTR: return "ENOSTR";
1041  case ENOSYS: return "ENOSYS";
1042  case ENOTBLK: return "ENOTBLK";
1043  case ENOTCONN: return "ENOTCONN";
1044  case ENOTDIR: return "ENOTDIR";
1045  case ENOTEMPTY: return "ENOTEMPTY";
1046  case ENOTSOCK: return "ENOTSOCK";
1047  /* case ENOTSUP: return "ENOTSUP"; */
1048  case ENOTTY: return "ENOTTY";
1049  case ENOTUNIQ: return "ENOTUNIQ";
1050  case ENXIO: return "ENXIO";
1051  case EOPNOTSUPP: return "EOPNOTSUPP";
1052  case EOVERFLOW: return "EOVERFLOW";
1053  case EPERM: return "EPERM";
1054  case EPFNOSUPPORT: return "EPFNOSUPPORT";
1055  case EPIPE: return "EPIPE";
1056  case EPROTO: return "EPROTO";
1057  case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
1058  case EPROTOTYPE: return "EPROTOTYPE";
1059  case ERANGE: return "ERANGE";
1060  case EREMOTE: return "EREMOTE";
1061  case EREMOTEIO: return "EREMOTEIO";
1062 
1063  case EROFS: return "EROFS";
1064  case ESHUTDOWN: return "ESHUTDOWN";
1065  case ESPIPE: return "ESPIPE";
1066  case ESOCKTNOSUPPORT: return "ESOCKTNOSUPPORT";
1067  case ESRCH: return "ESRCH";
1068  case ESTALE: return "ESTALE";
1069  case ETIME: return "ETIME";
1070  case ETIMEDOUT: return "ETIMEDOUT";
1071  case ETXTBSY: return "ETXTBSY";
1072  case EUNATCH: return "EUNATCH";
1073  case EUSERS: return "EUSERS";
1074  /* case EWOULDBLOCK: return "EWOULDBLOCK"; */
1075  case EXDEV: return "EXDEV";
1076 
1077 #ifdef EBADE
1078  /* Not available on OSX */
1079  case EBADE: return "EBADE";
1080  case EBADFD: return "EBADFD";
1081  case EBADSLT: return "EBADSLT";
1082  case EDEADLOCK: return "EDEADLOCK";
1083  case EBADR: return "EBADR";
1084  case EBADRQC: return "EBADRQC";
1085  case ECHRNG: return "ECHRNG";
1086 #ifdef EISNAM /* Not available on Illumos/Solaris */
1087  case EISNAM: return "EISNAM";
1088  case EKEYEXPIRED: return "EKEYEXPIRED";
1089  case EKEYREJECTED: return "EKEYREJECTED";
1090  case EKEYREVOKED: return "EKEYREVOKED";
1091 #endif
1092  case EL2HLT: return "EL2HLT";
1093  case EL2NSYNC: return "EL2NSYNC";
1094  case EL3HLT: return "EL3HLT";
1095  case EL3RST: return "EL3RST";
1096  case ELIBBAD: return "ELIBBAD";
1097  case ELIBMAX: return "ELIBMAX";
1098  case ELIBSCN: return "ELIBSCN";
1099  case ELIBEXEC: return "ELIBEXEC";
1100 #ifdef ENOMEDIUM /* Not available on Illumos/Solaris */
1101  case ENOMEDIUM: return "ENOMEDIUM";
1102  case EMEDIUMTYPE: return "EMEDIUMTYPE";
1103 #endif
1104  case ENONET: return "ENONET";
1105  case ENOPKG: return "ENOPKG";
1106  case EREMCHG: return "EREMCHG";
1107  case ERESTART: return "ERESTART";
1108  case ESTRPIPE: return "ESTRPIPE";
1109 #ifdef EUCLEAN /* Not available on Illumos/Solaris */
1110  case EUCLEAN: return "EUCLEAN";
1111 #endif
1112  case EXFULL: return "EXFULL";
1113 #endif
1114 
1115  case pcmk_err_generic: return "pcmk_err_generic";
1116  case pcmk_err_no_quorum: return "pcmk_err_no_quorum";
1117  case pcmk_err_schema_validation: return "pcmk_err_schema_validation";
1118  case pcmk_err_transform_failed: return "pcmk_err_transform_failed";
1119  case pcmk_err_old_data: return "pcmk_err_old_data";
1120  case pcmk_err_diff_failed: return "pcmk_err_diff_failed";
1121  case pcmk_err_diff_resync: return "pcmk_err_diff_resync";
1122  case pcmk_err_cib_modified: return "pcmk_err_cib_modified";
1123  case pcmk_err_cib_backup: return "pcmk_err_cib_backup";
1124  case pcmk_err_cib_save: return "pcmk_err_cib_save";
1125  case pcmk_err_cib_corrupt: return "pcmk_err_cib_corrupt";
1126  }
1127  return "Unknown";
1128 }
1129 
1130 
1131 const char *
1133 {
1134  int error = abs(rc);
1135 
1136  if (error == 0) {
1137  return "OK";
1138  } else if (error < PCMK_ERROR_OFFSET) {
1139  return strerror(error);
1140  }
1141 
1142  switch (error) {
1143  case pcmk_err_generic:
1144  return "Generic Pacemaker error";
1145  case pcmk_err_no_quorum:
1146  return "Operation requires quorum";
1148  return "Update does not conform to the configured schema";
1150  return "Schema transform failed";
1151  case pcmk_err_old_data:
1152  return "Update was older than existing configuration";
1153  case pcmk_err_diff_failed:
1154  return "Application of an update diff failed";
1155  case pcmk_err_diff_resync:
1156  return "Application of an update diff failed, requesting a full refresh";
1157  case pcmk_err_cib_modified:
1158  return "The on-disk configuration was manually modified";
1159  case pcmk_err_cib_backup:
1160  return "Could not archive the previous configuration";
1161  case pcmk_err_cib_save:
1162  return "Could not save the new configuration to disk";
1163  case pcmk_err_cib_corrupt:
1164  return "Could not parse on-disk configuration";
1165 
1167  return "Schema is already the latest available";
1168 
1169  /* The following cases will only be hit on systems for which they are non-standard */
1170  /* coverity[dead_error_condition] False positive on non-Linux */
1171  case ENOTUNIQ:
1172  return "Name not unique on network";
1173  /* coverity[dead_error_condition] False positive on non-Linux */
1174  case ECOMM:
1175  return "Communication error on send";
1176  /* coverity[dead_error_condition] False positive on non-Linux */
1177  case ELIBACC:
1178  return "Can not access a needed shared library";
1179  /* coverity[dead_error_condition] False positive on non-Linux */
1180  case EREMOTEIO:
1181  return "Remote I/O error";
1182  /* coverity[dead_error_condition] False positive on non-Linux */
1183  case EUNATCH:
1184  return "Protocol driver not attached";
1185  /* coverity[dead_error_condition] False positive on non-Linux */
1186  case ENOKEY:
1187  return "Required key not available";
1188  }
1189 
1190  crm_err("Unknown error code: %d", rc);
1191  return "Unknown error";
1192 }
1193 
1194 const char *
1196 {
1197  /* http://www.bzip.org/1.0.3/html/err-handling.html */
1198  switch (rc) {
1199  case BZ_OK:
1200  case BZ_RUN_OK:
1201  case BZ_FLUSH_OK:
1202  case BZ_FINISH_OK:
1203  case BZ_STREAM_END:
1204  return "Ok";
1205  case BZ_CONFIG_ERROR:
1206  return "libbz2 has been improperly compiled on your platform";
1207  case BZ_SEQUENCE_ERROR:
1208  return "library functions called in the wrong order";
1209  case BZ_PARAM_ERROR:
1210  return "parameter is out of range or otherwise incorrect";
1211  case BZ_MEM_ERROR:
1212  return "memory allocation failed";
1213  case BZ_DATA_ERROR:
1214  return "data integrity error is detected during decompression";
1215  case BZ_DATA_ERROR_MAGIC:
1216  return "the compressed stream does not start with the correct magic bytes";
1217  case BZ_IO_ERROR:
1218  return "error reading or writing in the compressed file";
1219  case BZ_UNEXPECTED_EOF:
1220  return "compressed file finishes before the logical end of stream is detected";
1221  case BZ_OUTBUFF_FULL:
1222  return "output data will not fit into the buffer provided";
1223  }
1224  return "Unknown error";
1225 }
1226 
1227 void
1228 crm_log_output_fn(const char *file, const char *function, int line, int level, const char *prefix,
1229  const char *output)
1230 {
1231  const char *next = NULL;
1232  const char *offset = NULL;
1233 
1234  if (output == NULL) {
1235  level = LOG_DEBUG;
1236  output = "-- empty --";
1237  }
1238 
1239  next = output;
1240  do {
1241  offset = next;
1242  next = strchrnul(offset, '\n');
1243  do_crm_log_alias(level, file, function, line, "%s [ %.*s ]", prefix,
1244  (int)(next - offset), offset);
1245  if (next[0] != 0) {
1246  next++;
1247  }
1248 
1249  } while (next != NULL && next[0] != 0);
1250 }
1251 
1252 char *
1253 crm_strdup_printf (char const *format, ...)
1254 {
1255  va_list ap;
1256  int len = 0;
1257  char *string = NULL;
1258 
1259  va_start(ap, format);
1260 
1261  len = vasprintf (&string, format, ap);
1262  CRM_ASSERT(len > 0);
1263 
1264  va_end(ap);
1265  return string;
1266 }
#define CRM_CORE_DIR
Definition: config.h:38
#define LOG_TRACE
Definition: logging.h:29
A dumping ground.
#define crm_notice(fmt, args...)
Definition: logging.h:250
void crm_log_preinit(const char *entity, int argc, char **argv)
Definition: logging.c:705
#define ETIME
Definition: portability.h:255
gboolean safe_str_neq(const char *a, const char *b)
Definition: strings.c:150
gboolean mainloop_add_signal(int sig, void(*dispatch)(int sig))
Definition: mainloop.c:327
void crm_enable_blackbox(int nsig)
Definition: logging.c:411
unsigned int get_crm_log_level(void)
Definition: logging.c:939
void crm_disable_blackbox(int nsig)
Definition: logging.c:417
#define ENOSTR
Definition: portability.h:263
char * crm_strdup_printf(char const *format,...)
Definition: logging.c:1253
#define ARGS_FMT
Definition: logging.c:944
#define pcmk_err_old_data
Definition: error.h:49
#define pcmk_err_schema_unchanged
Definition: error.h:55
#define EREMOTEIO
Definition: portability.h:239
void crm_xml_init(void)
Definition: xml.c:5064
char * crm_system_name
Definition: utils.c:73
gboolean crm_is_callsite_active(struct qb_log_callsite *cs, uint8_t level, uint32_t tags)
Definition: logging.c:590
int crm_user_lookup(const char *name, uid_t *uid, gid_t *gid)
Definition: utils.c:421
#define CRM_LOG_ASSERT(expr)
Definition: logging.h:150
void crm_write_blackbox(int nsig, struct qb_log_callsite *cs)
Definition: logging.c:423
#define do_crm_log_alias(level, file, function, line, fmt, args...)
Log a message as if it came from a different code location.
Definition: logging.h:196
const char * daemon_option(const char *option)
Definition: logging.c:117
uint32_t pid
Definition: internal.h:49
char * strerror(int errnum)
Wrappers for and extensions to glib mainloop.
#define FMT_MAX
Definition: logging.c:187
gboolean crm_add_logfile(const char *filename)
Definition: logging.c:221
void crm_log_args(int argc, char **argv)
Definition: logging.c:946
const char * pcmk_errorname(int rc)
Definition: logging.c:978
#define pcmk_err_diff_failed
Definition: error.h:50
char uname[MAX_NAME]
Definition: internal.h:53
#define pcmk_err_diff_resync
Definition: error.h:51
#define crm_warn(fmt, args...)
Definition: logging.h:249
gboolean crm_log_init(const char *entity, uint8_t level, gboolean daemon, gboolean to_stderr, int argc, char **argv, gboolean quiet)
Definition: logging.c:755
int daemon(int nochdir, int noclose)
#define crm_debug(fmt, args...)
Definition: logging.h:253
gboolean crm_signal(int sig, void(*dispatch)(int sig))
Definition: mainloop.c:302
unsigned int crm_log_level
Definition: logging.c:46
void crm_enable_stderr(int enable)
Definition: logging.c:909
#define pcmk_err_no_quorum
Definition: error.h:46
#define pcmk_err_schema_validation
Definition: error.h:47
#define crm_trace(fmt, args...)
Definition: logging.h:254
#define do_crm_log(level, fmt, args...)
Log a message.
Definition: logging.h:129
int setenv(const char *name, const char *value, int why)
#define CRM_BLACKBOX_DIR
Definition: config.h:29
#define pcmk_err_cib_save
Definition: error.h:54
unsigned int crm_trace_nonlog
Definition: logging.c:48
void crm_update_callsites(void)
Definition: logging.c:619
#define pcmk_err_cib_backup
Definition: error.h:53
const char * pcmk_strerror(int rc)
Definition: logging.c:1132
#define pcmk_err_generic
Definition: error.h:45
#define CRM_DAEMON_USER
Definition: config.h:47
#define ECOMM
Definition: portability.h:231
#define PCMK_ERROR_OFFSET
Definition: error.h:43
#define ENOSR
Definition: portability.h:259
gboolean crm_str_eq(const char *a, const char *b, gboolean use_case)
Definition: strings.c:213
#define pcmk_err_transform_failed
Definition: error.h:48
uint32_t counter
Definition: internal.h:50
#define ENOKEY
Definition: portability.h:247
void crm_log_output_fn(const char *file, const char *function, int line, int level, const char *prefix, const char *output)
Definition: logging.c:1228
#define ELIBACC
Definition: portability.h:235
#define EUNATCH
Definition: portability.h:243
#define ENODATA
Definition: portability.h:251
#define crm_perror(level, fmt, args...)
Log a system error message.
Definition: logging.h:226
gboolean crm_log_cli_init(const char *entity)
Definition: logging.c:480
#define crm_err(fmt, args...)
Definition: logging.h:248
#define ENOTUNIQ
Definition: portability.h:227
#define NAME_MAX
Definition: logging.c:103
gboolean daemon_option_enabled(const char *daemon, const char *option)
Definition: logging.c:165
#define pcmk_err_cib_modified
Definition: error.h:52
#define uint32_t
Definition: stdint.in.h:158
void set_daemon_option(const char *option, const char *value)
Definition: logging.c:141
#define CRM_ASSERT(expr)
Definition: error.h:35
#define uint8_t
Definition: stdint.in.h:144
char * strchrnul(const char *s, int c_in)
unsigned int set_crm_log_level(unsigned int level)
Definition: logging.c:898
gboolean crm_is_true(const char *s)
Definition: strings.c:165
bool crm_is_daemon
Definition: logging.c:49
unsigned int crm_log_priority
Definition: logging.c:45
#define safe_str_eq(a, b)
Definition: util.h:64
void crm_abort(const char *file, const char *function, int line, const char *condition, gboolean do_core, gboolean do_fork)
Definition: utils.c:970
#define pcmk_err_cib_corrupt
Definition: error.h:56
void crm_bump_log_level(int argc, char **argv)
Definition: logging.c:921
#define crm_info(fmt, args...)
Definition: logging.h:251
void crm_log_deinit(void)
Definition: logging.c:180
uint64_t flags
Definition: remote.c:156
const char * bz2_strerror(int rc)
Definition: logging.c:1195
#define int32_t
Definition: stdint.in.h:157