21 #include <sys/param.h>
22 #include <sys/types.h>
25 #include <sys/utsname.h>
40 #include <qb/qbdefs.h>
47 static gboolean crm_tracing_enabled(
void);
51 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
52 GLogFunc glib_log_default;
55 crm_glib_handler(
const gchar * log_domain, GLogLevelFlags
flags,
const gchar * message,
58 int log_level = LOG_WARNING;
59 GLogLevelFlags msg_level = (flags & G_LOG_LEVEL_MASK);
60 static struct qb_log_callsite *glib_cs = NULL;
62 if (glib_cs == NULL) {
63 glib_cs = qb_log_callsite_get(__FUNCTION__, __FILE__,
"glib-handler", LOG_DEBUG, __LINE__,
crm_trace_nonlog);
68 case G_LOG_LEVEL_CRITICAL:
73 crm_abort(__FILE__, __FUNCTION__, __LINE__, message, TRUE, TRUE);
77 case G_LOG_LEVEL_ERROR:
80 case G_LOG_LEVEL_MESSAGE:
81 log_level = LOG_NOTICE;
83 case G_LOG_LEVEL_INFO:
86 case G_LOG_LEVEL_DEBUG:
87 log_level = LOG_DEBUG;
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;
98 do_crm_log(log_level,
"%s: %s", log_domain, message);
103 # define NAME_MAX 256
107 crm_trigger_blackbox(
int nsig)
109 if(nsig == SIGTRAP) {
120 const char *value = NULL;
122 snprintf(env_name,
NAME_MAX,
"PCMK_%s", option);
123 value = getenv(env_name);
125 crm_trace(
"Found %s = %s", env_name, value);
129 snprintf(env_name,
NAME_MAX,
"HA_%s", option);
130 value = getenv(env_name);
132 crm_trace(
"Found %s = %s", env_name, value);
136 crm_trace(
"Nothing found for %s", option);
145 snprintf(env_name,
NAME_MAX,
"PCMK_%s", option);
147 crm_trace(
"Setting %s to %s", env_name, value);
148 setenv(env_name, value, 1);
154 snprintf(env_name,
NAME_MAX,
"HA_%s", option);
156 crm_trace(
"Setting %s to %s", env_name, value);
157 setenv(env_name, value, 1);
172 }
else if (value != NULL && strstr(value, daemon)) {
182 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
183 g_log_set_default_handler(glib_log_default, NULL);
189 set_format_string(
int method,
const char *
daemon)
194 if (method > QB_LOG_STDERR) {
198 if (
uname(&res) == 0) {
200 snprintf(fmt + offset,
FMT_MAX - offset,
"%%t [%d] %s %10s: ", getpid(),
201 res.nodename, daemon);
203 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"%%t [%d] %10s: ", getpid(), daemon);
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");
213 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"%%g %%-7p: %%n:\t%%b");
217 qb_log_format_set(method, fmt);
223 bool is_default =
false;
224 static int default_fd = -1;
225 static gboolean have_logfile = FALSE;
226 const char *default_logfile =
"/var/log/pacemaker.log";
230 FILE *logfile = NULL;
231 char *parent_dir = NULL;
234 if (filename == NULL && have_logfile == FALSE) {
235 filename = default_logfile;
238 if (filename == NULL) {
244 }
else if(
safe_str_eq(filename, default_logfile)) {
248 if(is_default && default_fd >= 0) {
253 filename_cp = strdup(filename);
254 parent_dir = dirname(filename_cp);
255 rc = stat(parent_dir, &parent);
258 crm_err(
"Directory '%s' does not exist: logging to '%s' is disabled", parent_dir, filename);
265 logfile = fopen(filename,
"a");
266 if(logfile == NULL) {
267 crm_err(
"%s (%d): Logging to '%s' as uid=%u, gid=%u is disabled",
268 pcmk_strerror(errno), errno, filename, geteuid(), getegid());
273 if (geteuid() == 0) {
277 gboolean fix = FALSE;
278 int logfd = fileno(logfile);
280 rc = fstat(logfd, &st);
282 crm_perror(LOG_WARNING,
"Cannot stat %s", filename);
288 if (st.st_gid != pcmk_gid) {
291 }
else if ((st.st_mode & S_IRWXG) != (S_IRGRP | S_IWGRP)) {
298 rc = fchown(logfd, pcmk_uid, pcmk_gid);
300 crm_warn(
"Cannot change the ownership of %s to user %s and gid %d",
304 rc = fchmod(logfd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
306 crm_warn(
"Cannot change the mode of %s to rw-rw----", filename);
309 fprintf(logfile,
"Set r/w permissions for uid=%d, gid=%d on %s\n",
310 pcmk_uid, pcmk_gid, filename);
311 if (fflush(logfile) < 0 || fsync(logfd) < 0) {
312 crm_err(
"Couldn't write out logfile: %s", filename);
319 fd = qb_log_file_open(filename);
322 crm_perror(LOG_WARNING,
"Couldn't send additional logging to %s", filename);
329 }
else if(default_fd >= 0) {
331 qb_log_ctl(default_fd, QB_LOG_CONF_ENABLED, QB_FALSE);
334 crm_notice(
"Additional logging available in %s", filename);
335 qb_log_ctl(fd, QB_LOG_CONF_ENABLED, QB_TRUE);
345 static int blackbox_trigger = 0;
346 static char *blackbox_file_prefix = NULL;
349 blackbox_logger(
int32_t t,
struct qb_log_callsite *cs, time_t timestamp,
const char *msg)
351 if(cs && cs->priority < LOG_ERR) {
359 crm_control_blackbox(
int nsig,
bool enable)
361 if (blackbox_file_prefix == NULL) {
362 pid_t
pid = getpid();
364 blackbox_file_prefix = malloc(
NAME_MAX);
368 if (enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
369 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 5 * 1024 * 1024);
370 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
372 crm_notice(
"Initiated blackbox recorder: %s", blackbox_file_prefix);
382 blackbox_trigger = qb_log_custom_open(blackbox_logger, NULL, NULL, NULL);
383 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_ENABLED, QB_TRUE);
384 crm_trace(
"Trigger: %d is %d %d", blackbox_trigger,
385 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_STATE_GET, 0), QB_LOG_STATE_ENABLED);
389 }
else if (!enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
390 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
397 crm_control_blackbox(nsig, TRUE);
403 crm_control_blackbox(nsig, FALSE);
410 static time_t last = 0;
413 time_t now = time(NULL);
415 if (blackbox_file_prefix == NULL) {
424 if (nsig == 0 && now == last) {
429 snprintf(buffer,
NAME_MAX,
"%s.%d", blackbox_file_prefix, counter++);
430 if (nsig == SIGTRAP) {
431 crm_notice(
"Blackbox dump requested, please see %s for contents", buffer);
435 "Problem detected at %s:%d (%s), please see %s for additional details",
436 cs->function, cs->lineno, cs->filename, buffer);
438 crm_notice(
"Problem detected, please see %s for additional details", buffer);
442 qb_log_blackbox_write_to_file(buffer);
447 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
448 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
456 qb_log_blackbox_write_to_file(blackbox_file_prefix);
457 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
466 return crm_log_init(entity, LOG_ERR, FALSE, FALSE, 0, NULL, TRUE);
472 const char *text = g_quark_to_string(tag);
481 crm_log_filter_source(
int source,
const char *trace_files,
const char *trace_fns,
482 const char *trace_fmts,
const char *trace_tags,
const char *trace_blackbox,
483 struct qb_log_callsite *cs)
485 if (qb_log_ctl(source, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
489 qb_bit_set(cs->targets, source);
491 }
else if (source == blackbox_trigger && blackbox_trigger > 0) {
493 if (cs->priority <= LOG_ERR) {
494 qb_bit_set(cs->targets, source);
496 }
else if (trace_blackbox) {
499 if (strstr(trace_blackbox, key) != NULL) {
500 qb_bit_set(cs->targets, source);
505 }
else if (source == QB_LOG_SYSLOG) {
507 qb_bit_set(cs->targets, source);
511 qb_bit_set(cs->targets, source);
512 }
else if (trace_files && strstr(trace_files, cs->filename) != NULL) {
513 qb_bit_set(cs->targets, source);
514 }
else if (trace_fns && strstr(trace_fns, cs->function) != NULL) {
515 qb_bit_set(cs->targets, source);
516 }
else if (trace_fmts && strstr(trace_fmts, cs->format) != NULL) {
517 qb_bit_set(cs->targets, source);
518 }
else if (trace_tags
521 qb_bit_set(cs->targets, source);
526 crm_log_filter(
struct qb_log_callsite *cs)
529 static int need_init = 1;
530 static const char *trace_fns = NULL;
531 static const char *trace_tags = NULL;
532 static const char *trace_fmts = NULL;
533 static const char *trace_files = NULL;
534 static const char *trace_blackbox = NULL;
538 trace_fns = getenv(
"PCMK_trace_functions");
539 trace_fmts = getenv(
"PCMK_trace_formats");
540 trace_tags = getenv(
"PCMK_trace_tags");
541 trace_files = getenv(
"PCMK_trace_files");
542 trace_blackbox = getenv(
"PCMK_trace_blackbox");
544 if (trace_tags != NULL) {
547 const char *offset = NULL;
548 const char *next = trace_tags;
553 snprintf(token, 499,
"%.*s", (
int)(next - offset), offset);
555 tag = g_quark_from_string(token);
556 crm_info(
"Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);
562 }
while (next != NULL && next[0] != 0);
567 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
568 crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
576 gboolean refilter = FALSE;
582 if (cs->priority != level) {
583 cs->priority = level;
587 if (cs->tags != tags) {
596 if (cs->targets == 0) {
605 static gboolean log = TRUE;
610 (
"Enabling callsites based on priority=%d, files=%s, functions=%s, formats=%s, tags=%s",
611 crm_log_level, getenv(
"PCMK_trace_files"), getenv(
"PCMK_trace_functions"),
612 getenv(
"PCMK_trace_formats"), getenv(
"PCMK_trace_tags"));
614 qb_log_filter_fn_set(crm_log_filter);
618 crm_tracing_enabled(
void)
622 }
else if (getenv(
"PCMK_trace_files") || getenv(
"PCMK_trace_functions")
623 || getenv(
"PCMK_trace_formats") || getenv(
"PCMK_trace_tags")) {
630 crm_priority2int(
const char *name)
632 struct syslog_names {
636 static struct syslog_names p_names[] = {
637 {
"emerg", LOG_EMERG},
638 {
"alert", LOG_ALERT},
641 {
"warning", LOG_WARNING},
642 {
"notice", LOG_NOTICE},
644 {
"debug", LOG_DEBUG},
649 for (lpc = 0; name != NULL && p_names[lpc].name != NULL; lpc++) {
650 if (
crm_str_eq(p_names[lpc].name, name, TRUE)) {
651 return p_names[lpc].priority;
659 crm_identity(
const char *entity,
int argc,
char **argv)
668 }
else if (argc > 0 && argv != NULL) {
669 char *
mutable = strdup(argv[0]);
670 char *modified = basename(
mutable);
672 if (strstr(modified,
"lt-") == modified) {
696 static bool have_logging = FALSE;
698 if(have_logging == FALSE) {
704 crm_trace_nonlog = g_quark_from_static_string(
"Pacemaker non-logging tracepoint");
707 umask(S_IWGRP | S_IWOTH | S_IROTH);
710 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
711 glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
715 g_log_set_always_fatal((GLogLevelFlags) 0);
718 crm_identity(entity, argc, argv);
720 qb_facility = qb_log_facility2int(
"local0");
725 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
728 qb_log_tags_stringify_fn_set(crm_quark_to_string);
729 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
737 int argc,
char **argv, gboolean quiet)
739 const char *syslog_priority = NULL;
742 const char *f_copy = facility;
752 if (facility == NULL) {
766 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_FACILITY, qb_log_facility2int(facility));
776 if(syslog_priority) {
777 int priority = crm_priority2int(syslog_priority);
779 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", priority);
781 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", LOG_NOTICE);
786 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);
811 crm_trace(
"Quiet: %d, facility %s", quiet, f_copy);
823 const char *user = getenv(
"USER");
826 crm_trace(
"Not switching to corefile directory for %s", user);
834 struct passwd *pwent = getpwuid(user);
837 crm_perror(LOG_ERR,
"Cannot get name for uid: %d", user);
841 crm_trace(
"Don't change active directory for regular user: %s", pwent->pw_name);
843 }
else if (chdir(base) < 0) {
844 crm_perror(LOG_INFO,
"Cannot change active directory to %s", base);
847 crm_info(
"Changed active directory to %s/%s", base, pwent->pw_name);
855 crm_info(
"Changed active directory to %s/%s/%s", base, pwent->pw_name, path);
892 if (enable && qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
893 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
896 }
else if (enable == FALSE) {
897 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
904 static int args = TRUE;
907 if (args && argc > 1) {
911 if (qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
925 #define ARGS_FMT "Invoked: %s"
931 int existing_len = 0;
933 static int logged = 0;
935 char *arg_string = NULL;
937 if (argc == 0 || argv == NULL || logged) {
943 for (; lpc < argc; lpc++) {
944 if (argv[lpc] == NULL) {
948 len = 2 + strlen(argv[lpc]);
949 arg_string = realloc_safe(arg_string, len + existing_len);
950 existing_len += sprintf(arg_string + existing_len,
"%s ", argv[lpc]);
953 qb_log_from_external_source(__func__, __FILE__,
ARGS_FMT, LOG_NOTICE, line, 0, arg_string);
964 case E2BIG:
return "E2BIG";
965 case EACCES:
return "EACCES";
966 case EADDRINUSE:
return "EADDRINUSE";
967 case EADDRNOTAVAIL:
return "EADDRNOTAVAIL";
968 case EAFNOSUPPORT:
return "EAFNOSUPPORT";
969 case EAGAIN:
return "EAGAIN";
970 case EALREADY:
return "EALREADY";
971 case EBADF:
return "EBADF";
972 case EBADMSG:
return "EBADMSG";
973 case EBUSY:
return "EBUSY";
974 case ECANCELED:
return "ECANCELED";
975 case ECHILD:
return "ECHILD";
976 case ECOMM:
return "ECOMM";
977 case ECONNABORTED:
return "ECONNABORTED";
978 case ECONNREFUSED:
return "ECONNREFUSED";
979 case ECONNRESET:
return "ECONNRESET";
981 case EDESTADDRREQ:
return "EDESTADDRREQ";
982 case EDOM:
return "EDOM";
983 case EDQUOT:
return "EDQUOT";
984 case EEXIST:
return "EEXIST";
985 case EFAULT:
return "EFAULT";
986 case EFBIG:
return "EFBIG";
987 case EHOSTDOWN:
return "EHOSTDOWN";
988 case EHOSTUNREACH:
return "EHOSTUNREACH";
989 case EIDRM:
return "EIDRM";
990 case EILSEQ:
return "EILSEQ";
991 case EINPROGRESS:
return "EINPROGRESS";
992 case EINTR:
return "EINTR";
993 case EINVAL:
return "EINVAL";
994 case EIO:
return "EIO";
995 case EISCONN:
return "EISCONN";
996 case EISDIR:
return "EISDIR";
997 case ELIBACC:
return "ELIBACC";
998 case ELOOP:
return "ELOOP";
999 case EMFILE:
return "EMFILE";
1000 case EMLINK:
return "EMLINK";
1001 case EMSGSIZE:
return "EMSGSIZE";
1002 case EMULTIHOP:
return "EMULTIHOP";
1003 case ENAMETOOLONG:
return "ENAMETOOLONG";
1004 case ENETDOWN:
return "ENETDOWN";
1005 case ENETRESET:
return "ENETRESET";
1006 case ENETUNREACH:
return "ENETUNREACH";
1007 case ENFILE:
return "ENFILE";
1008 case ENOBUFS:
return "ENOBUFS";
1009 case ENODATA:
return "ENODATA";
1010 case ENODEV:
return "ENODEV";
1011 case ENOENT:
return "ENOENT";
1012 case ENOEXEC:
return "ENOEXEC";
1013 case ENOKEY:
return "ENOKEY";
1014 case ENOLCK:
return "ENOLCK";
1015 case ENOLINK:
return "ENOLINK";
1016 case ENOMEM:
return "ENOMEM";
1017 case ENOMSG:
return "ENOMSG";
1018 case ENOPROTOOPT:
return "ENOPROTOOPT";
1019 case ENOSPC:
return "ENOSPC";
1020 case ENOSR:
return "ENOSR";
1021 case ENOSTR:
return "ENOSTR";
1022 case ENOSYS:
return "ENOSYS";
1023 case ENOTBLK:
return "ENOTBLK";
1024 case ENOTCONN:
return "ENOTCONN";
1025 case ENOTDIR:
return "ENOTDIR";
1026 case ENOTEMPTY:
return "ENOTEMPTY";
1027 case ENOTSOCK:
return "ENOTSOCK";
1029 case ENOTTY:
return "ENOTTY";
1031 case ENXIO:
return "ENXIO";
1032 case EOPNOTSUPP:
return "EOPNOTSUPP";
1033 case EOVERFLOW:
return "EOVERFLOW";
1034 case EPERM:
return "EPERM";
1035 case EPFNOSUPPORT:
return "EPFNOSUPPORT";
1036 case EPIPE:
return "EPIPE";
1037 case EPROTO:
return "EPROTO";
1038 case EPROTONOSUPPORT:
return "EPROTONOSUPPORT";
1039 case EPROTOTYPE:
return "EPROTOTYPE";
1040 case ERANGE:
return "ERANGE";
1041 case EREMOTE:
return "EREMOTE";
1044 case EROFS:
return "EROFS";
1045 case ESHUTDOWN:
return "ESHUTDOWN";
1046 case ESPIPE:
return "ESPIPE";
1047 case ESOCKTNOSUPPORT:
return "ESOCKTNOSUPPORT";
1048 case ESRCH:
return "ESRCH";
1049 case ESTALE:
return "ESTALE";
1050 case ETIME:
return "ETIME";
1051 case ETIMEDOUT:
return "ETIMEDOUT";
1052 case ETXTBSY:
return "ETXTBSY";
1053 case EUNATCH:
return "EUNATCH";
1054 case EUSERS:
return "EUSERS";
1056 case EXDEV:
return "EXDEV";
1060 case EBADE:
return "EBADE";
1061 case EBADFD:
return "EBADFD";
1062 case EBADSLT:
return "EBADSLT";
1063 case EDEADLOCK:
return "EDEADLOCK";
1064 case EBADR:
return "EBADR";
1065 case EBADRQC:
return "EBADRQC";
1066 case ECHRNG:
return "ECHRNG";
1068 case EISNAM:
return "EISNAM";
1069 case EKEYEXPIRED:
return "EKEYEXPIRED";
1070 case EKEYREJECTED:
return "EKEYREJECTED";
1071 case EKEYREVOKED:
return "EKEYREVOKED";
1073 case EL2HLT:
return "EL2HLT";
1074 case EL2NSYNC:
return "EL2NSYNC";
1075 case EL3HLT:
return "EL3HLT";
1076 case EL3RST:
return "EL3RST";
1077 case ELIBBAD:
return "ELIBBAD";
1078 case ELIBMAX:
return "ELIBMAX";
1079 case ELIBSCN:
return "ELIBSCN";
1080 case ELIBEXEC:
return "ELIBEXEC";
1082 case ENOMEDIUM:
return "ENOMEDIUM";
1083 case EMEDIUMTYPE:
return "EMEDIUMTYPE";
1085 case ENONET:
return "ENONET";
1086 case ENOPKG:
return "ENOPKG";
1087 case EREMCHG:
return "EREMCHG";
1088 case ERESTART:
return "ERESTART";
1089 case ESTRPIPE:
return "ESTRPIPE";
1091 case EUCLEAN:
return "EUCLEAN";
1093 case EXFULL:
return "EXFULL";
1115 int error = abs(rc);
1125 return "Generic Pacemaker error";
1127 return "Operation requires quorum";
1129 return "Update does not conform to the configured schema";
1131 return "Schema transform failed";
1133 return "Update was older than existing configuration";
1135 return "Application of an update diff failed";
1137 return "Application of an update diff failed, requesting a full refresh";
1139 return "The on-disk configuration was manually modified";
1141 return "Could not archive the previous configuration";
1143 return "Could not save the new configuration to disk";
1145 return "Could not parse on-disk configuration";
1148 return "Schema is already the latest available";
1153 return "Name not unique on network";
1156 return "Communication error on send";
1159 return "Can not access a needed shared library";
1162 return "Remote I/O error";
1165 return "Protocol driver not attached";
1168 return "Required key not available";
1171 crm_err(
"Unknown error code: %d", rc);
1172 return "Unknown error";
1186 case BZ_CONFIG_ERROR:
1187 return "libbz2 has been improperly compiled on your platform";
1188 case BZ_SEQUENCE_ERROR:
1189 return "library functions called in the wrong order";
1190 case BZ_PARAM_ERROR:
1191 return "parameter is out of range or otherwise incorrect";
1193 return "memory allocation failed";
1195 return "data integrity error is detected during decompression";
1196 case BZ_DATA_ERROR_MAGIC:
1197 return "the compressed stream does not start with the correct magic bytes";
1199 return "error reading or writing in the compressed file";
1200 case BZ_UNEXPECTED_EOF:
1201 return "compressed file finishes before the logical end of stream is detected";
1202 case BZ_OUTBUFF_FULL:
1203 return "output data will not fit into the buffer provided";
1205 return "Unknown error";
1212 const char *next = NULL;
1213 const char *offset = NULL;
1215 if (output == NULL) {
1217 output =
"-- empty --";
1225 (
int)(next - offset), offset);
1230 }
while (next != NULL && next[0] != 0);
1238 char *
string = NULL;
1240 va_start(ap, format);
1242 len = vasprintf (&
string, format, ap);
#define crm_notice(fmt, args...)
void crm_log_preinit(const char *entity, int argc, char **argv)
gboolean safe_str_neq(const char *a, const char *b)
gboolean mainloop_add_signal(int sig, void(*dispatch)(int sig))
void crm_enable_blackbox(int nsig)
unsigned int get_crm_log_level(void)
void crm_disable_blackbox(int nsig)
char * crm_strdup_printf(char const *format,...)
#define pcmk_err_old_data
#define pcmk_err_schema_unchanged
gboolean crm_is_callsite_active(struct qb_log_callsite *cs, uint8_t level, uint32_t tags)
int crm_user_lookup(const char *name, uid_t *uid, gid_t *gid)
#define CRM_LOG_ASSERT(expr)
void crm_write_blackbox(int nsig, struct qb_log_callsite *cs)
#define do_crm_log_alias(level, file, function, line, fmt, args...)
Log a message as if it came from a different code location.
const char * daemon_option(const char *option)
char * strerror(int errnum)
Wrappers for and extensions to glib mainloop.
gboolean crm_add_logfile(const char *filename)
void crm_log_args(int argc, char **argv)
const char * pcmk_errorname(int rc)
#define pcmk_err_diff_failed
#define pcmk_err_diff_resync
#define crm_warn(fmt, args...)
gboolean crm_log_init(const char *entity, uint8_t level, gboolean daemon, gboolean to_stderr, int argc, char **argv, gboolean quiet)
int daemon(int nochdir, int noclose)
#define crm_debug(fmt, args...)
gboolean crm_signal(int sig, void(*dispatch)(int sig))
unsigned int crm_log_level
void crm_enable_stderr(int enable)
#define pcmk_err_no_quorum
#define pcmk_err_schema_validation
#define crm_trace(fmt, args...)
#define do_crm_log(level, fmt, args...)
Log a message.
int setenv(const char *name, const char *value, int why)
#define pcmk_err_cib_save
unsigned int crm_trace_nonlog
void crm_update_callsites(void)
#define pcmk_err_cib_backup
const char * pcmk_strerror(int rc)
#define PCMK_ERROR_OFFSET
gboolean crm_str_eq(const char *a, const char *b, gboolean use_case)
#define pcmk_err_transform_failed
void crm_log_output_fn(const char *file, const char *function, int line, int level, const char *prefix, const char *output)
#define crm_perror(level, fmt, args...)
Log a system error message.
gboolean crm_log_cli_init(const char *entity)
#define crm_err(fmt, args...)
gboolean daemon_option_enabled(const char *daemon, const char *option)
#define pcmk_err_cib_modified
void set_daemon_option(const char *option, const char *value)
char * strchrnul(const char *s, int c_in)
unsigned int set_crm_log_level(unsigned int level)
gboolean crm_is_true(const char *s)
unsigned int crm_log_priority
#define safe_str_eq(a, b)
void crm_abort(const char *file, const char *function, int line, const char *condition, gboolean do_core, gboolean do_fork)
#define pcmk_err_cib_corrupt
void crm_bump_log_level(int argc, char **argv)
#define crm_info(fmt, args...)
void crm_log_deinit(void)
const char * bz2_strerror(int rc)