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)
363 if (blackbox_file_prefix == NULL) {
364 pid_t
pid = getpid();
366 blackbox_file_prefix = malloc(
NAME_MAX);
370 if (enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
371 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 5 * 1024 * 1024);
372 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
375 for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
376 qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_TRUE);
379 crm_notice(
"Initiated blackbox recorder: %s", blackbox_file_prefix);
389 blackbox_trigger = qb_log_custom_open(blackbox_logger, NULL, NULL, NULL);
390 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_ENABLED, QB_TRUE);
391 crm_trace(
"Trigger: %d is %d %d", blackbox_trigger,
392 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_STATE_GET, 0), QB_LOG_STATE_ENABLED);
396 }
else if (!enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
397 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
400 for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
401 qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_FALSE);
409 crm_control_blackbox(nsig, TRUE);
415 crm_control_blackbox(nsig, FALSE);
422 static time_t last = 0;
425 time_t now = time(NULL);
427 if (blackbox_file_prefix == NULL) {
436 if (nsig == 0 && now == last) {
441 snprintf(buffer,
NAME_MAX,
"%s.%d", blackbox_file_prefix, counter++);
442 if (nsig == SIGTRAP) {
443 crm_notice(
"Blackbox dump requested, please see %s for contents", buffer);
447 "Problem detected at %s:%d (%s), please see %s for additional details",
448 cs->function, cs->lineno, cs->filename, buffer);
450 crm_notice(
"Problem detected, please see %s for additional details", buffer);
454 qb_log_blackbox_write_to_file(buffer);
459 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
460 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
468 qb_log_blackbox_write_to_file(blackbox_file_prefix);
469 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
478 return crm_log_init(entity, LOG_ERR, FALSE, FALSE, 0, NULL, TRUE);
484 const char *text = g_quark_to_string(tag);
493 crm_log_filter_source(
int source,
const char *trace_files,
const char *trace_fns,
494 const char *trace_fmts,
const char *trace_tags,
const char *trace_blackbox,
495 struct qb_log_callsite *cs)
497 if (qb_log_ctl(source, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
501 qb_bit_set(cs->targets, source);
503 }
else if (source == blackbox_trigger && blackbox_trigger > 0) {
505 if (cs->priority <= LOG_ERR) {
506 qb_bit_set(cs->targets, source);
508 }
else if (trace_blackbox) {
511 if (strstr(trace_blackbox, key) != NULL) {
512 qb_bit_set(cs->targets, source);
517 }
else if (source == QB_LOG_SYSLOG) {
519 qb_bit_set(cs->targets, source);
523 qb_bit_set(cs->targets, source);
524 }
else if (trace_files && strstr(trace_files, cs->filename) != NULL) {
525 qb_bit_set(cs->targets, source);
526 }
else if (trace_fns && strstr(trace_fns, cs->function) != NULL) {
527 qb_bit_set(cs->targets, source);
528 }
else if (trace_fmts && strstr(trace_fmts, cs->format) != NULL) {
529 qb_bit_set(cs->targets, source);
530 }
else if (trace_tags
533 qb_bit_set(cs->targets, source);
538 crm_log_filter(
struct qb_log_callsite *cs)
541 static int need_init = 1;
542 static const char *trace_fns = NULL;
543 static const char *trace_tags = NULL;
544 static const char *trace_fmts = NULL;
545 static const char *trace_files = NULL;
546 static const char *trace_blackbox = NULL;
550 trace_fns = getenv(
"PCMK_trace_functions");
551 trace_fmts = getenv(
"PCMK_trace_formats");
552 trace_tags = getenv(
"PCMK_trace_tags");
553 trace_files = getenv(
"PCMK_trace_files");
554 trace_blackbox = getenv(
"PCMK_trace_blackbox");
556 if (trace_tags != NULL) {
559 const char *offset = NULL;
560 const char *next = trace_tags;
565 snprintf(token, 499,
"%.*s", (
int)(next - offset), offset);
567 tag = g_quark_from_string(token);
568 crm_info(
"Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);
574 }
while (next != NULL && next[0] != 0);
579 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
580 crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
588 gboolean refilter = FALSE;
594 if (cs->priority != level) {
595 cs->priority = level;
599 if (cs->tags != tags) {
608 if (cs->targets == 0) {
617 static gboolean log = TRUE;
622 (
"Enabling callsites based on priority=%d, files=%s, functions=%s, formats=%s, tags=%s",
623 crm_log_level, getenv(
"PCMK_trace_files"), getenv(
"PCMK_trace_functions"),
624 getenv(
"PCMK_trace_formats"), getenv(
"PCMK_trace_tags"));
626 qb_log_filter_fn_set(crm_log_filter);
630 crm_tracing_enabled(
void)
634 }
else if (getenv(
"PCMK_trace_files") || getenv(
"PCMK_trace_functions")
635 || getenv(
"PCMK_trace_formats") || getenv(
"PCMK_trace_tags")) {
642 crm_priority2int(
const char *name)
644 struct syslog_names {
648 static struct syslog_names p_names[] = {
649 {
"emerg", LOG_EMERG},
650 {
"alert", LOG_ALERT},
653 {
"warning", LOG_WARNING},
654 {
"notice", LOG_NOTICE},
656 {
"debug", LOG_DEBUG},
661 for (lpc = 0; name != NULL && p_names[lpc].name != NULL; lpc++) {
662 if (
crm_str_eq(p_names[lpc].name, name, TRUE)) {
663 return p_names[lpc].priority;
671 crm_identity(
const char *entity,
int argc,
char **argv)
680 }
else if (argc > 0 && argv != NULL) {
681 char *
mutable = strdup(argv[0]);
682 char *modified = basename(
mutable);
684 if (strstr(modified,
"lt-") == modified) {
708 static bool have_logging = FALSE;
710 if(have_logging == FALSE) {
716 crm_trace_nonlog = g_quark_from_static_string(
"Pacemaker non-logging tracepoint");
719 umask(S_IWGRP | S_IWOTH | S_IROTH);
722 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
723 glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
727 g_log_set_always_fatal((GLogLevelFlags) 0);
730 crm_identity(entity, argc, argv);
732 qb_facility = qb_log_facility2int(
"local0");
737 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
742 qb_log_tags_stringify_fn_set(crm_quark_to_string);
743 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
744 qb_log_ctl(lpc, QB_LOG_CONF_THREADED, QB_FALSE);
752 int argc,
char **argv, gboolean quiet)
754 const char *syslog_priority = NULL;
757 const char *f_copy = facility;
767 if (facility == NULL) {
781 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_FACILITY, qb_log_facility2int(facility));
791 if(syslog_priority) {
792 int priority = crm_priority2int(syslog_priority);
794 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", priority);
796 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", LOG_NOTICE);
801 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);
826 crm_trace(
"Quiet: %d, facility %s", quiet, f_copy);
838 const char *user = getenv(
"USER");
841 crm_trace(
"Not switching to corefile directory for %s", user);
849 struct passwd *pwent = getpwuid(user);
852 crm_perror(LOG_ERR,
"Cannot get name for uid: %d", user);
856 crm_trace(
"Don't change active directory for regular user: %s", pwent->pw_name);
858 }
else if (chdir(base) < 0) {
859 crm_perror(LOG_INFO,
"Cannot change active directory to %s", base);
862 crm_info(
"Changed active directory to %s", base);
870 crm_info(
"Changed active directory to %s/%s/%s", base, pwent->pw_name, path);
907 if (enable && qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
908 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
911 }
else if (enable == FALSE) {
912 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
919 static int args = TRUE;
922 if (args && argc > 1) {
926 if (qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
940 #define ARGS_FMT "Invoked: %s"
946 int existing_len = 0;
948 static int logged = 0;
950 char *arg_string = NULL;
952 if (argc == 0 || argv == NULL || logged) {
958 for (; lpc < argc; lpc++) {
959 if (argv[lpc] == NULL) {
963 len = 2 + strlen(argv[lpc]);
964 arg_string = realloc_safe(arg_string, len + existing_len);
965 existing_len += sprintf(arg_string + existing_len,
"%s ", argv[lpc]);
968 qb_log_from_external_source(__func__, __FILE__,
ARGS_FMT, LOG_NOTICE, line, 0, arg_string);
979 case E2BIG:
return "E2BIG";
980 case EACCES:
return "EACCES";
981 case EADDRINUSE:
return "EADDRINUSE";
982 case EADDRNOTAVAIL:
return "EADDRNOTAVAIL";
983 case EAFNOSUPPORT:
return "EAFNOSUPPORT";
984 case EAGAIN:
return "EAGAIN";
985 case EALREADY:
return "EALREADY";
986 case EBADF:
return "EBADF";
987 case EBADMSG:
return "EBADMSG";
988 case EBUSY:
return "EBUSY";
989 case ECANCELED:
return "ECANCELED";
990 case ECHILD:
return "ECHILD";
991 case ECOMM:
return "ECOMM";
992 case ECONNABORTED:
return "ECONNABORTED";
993 case ECONNREFUSED:
return "ECONNREFUSED";
994 case ECONNRESET:
return "ECONNRESET";
996 case EDESTADDRREQ:
return "EDESTADDRREQ";
997 case EDOM:
return "EDOM";
998 case EDQUOT:
return "EDQUOT";
999 case EEXIST:
return "EEXIST";
1000 case EFAULT:
return "EFAULT";
1001 case EFBIG:
return "EFBIG";
1002 case EHOSTDOWN:
return "EHOSTDOWN";
1003 case EHOSTUNREACH:
return "EHOSTUNREACH";
1004 case EIDRM:
return "EIDRM";
1005 case EILSEQ:
return "EILSEQ";
1006 case EINPROGRESS:
return "EINPROGRESS";
1007 case EINTR:
return "EINTR";
1008 case EINVAL:
return "EINVAL";
1009 case EIO:
return "EIO";
1010 case EISCONN:
return "EISCONN";
1011 case EISDIR:
return "EISDIR";
1012 case ELIBACC:
return "ELIBACC";
1013 case ELOOP:
return "ELOOP";
1014 case EMFILE:
return "EMFILE";
1015 case EMLINK:
return "EMLINK";
1016 case EMSGSIZE:
return "EMSGSIZE";
1017 case EMULTIHOP:
return "EMULTIHOP";
1018 case ENAMETOOLONG:
return "ENAMETOOLONG";
1019 case ENETDOWN:
return "ENETDOWN";
1020 case ENETRESET:
return "ENETRESET";
1021 case ENETUNREACH:
return "ENETUNREACH";
1022 case ENFILE:
return "ENFILE";
1023 case ENOBUFS:
return "ENOBUFS";
1024 case ENODATA:
return "ENODATA";
1025 case ENODEV:
return "ENODEV";
1026 case ENOENT:
return "ENOENT";
1027 case ENOEXEC:
return "ENOEXEC";
1028 case ENOKEY:
return "ENOKEY";
1029 case ENOLCK:
return "ENOLCK";
1030 case ENOLINK:
return "ENOLINK";
1031 case ENOMEM:
return "ENOMEM";
1032 case ENOMSG:
return "ENOMSG";
1033 case ENOPROTOOPT:
return "ENOPROTOOPT";
1034 case ENOSPC:
return "ENOSPC";
1035 case ENOSR:
return "ENOSR";
1036 case ENOSTR:
return "ENOSTR";
1037 case ENOSYS:
return "ENOSYS";
1038 case ENOTBLK:
return "ENOTBLK";
1039 case ENOTCONN:
return "ENOTCONN";
1040 case ENOTDIR:
return "ENOTDIR";
1041 case ENOTEMPTY:
return "ENOTEMPTY";
1042 case ENOTSOCK:
return "ENOTSOCK";
1044 case ENOTTY:
return "ENOTTY";
1046 case ENXIO:
return "ENXIO";
1047 case EOPNOTSUPP:
return "EOPNOTSUPP";
1048 case EOVERFLOW:
return "EOVERFLOW";
1049 case EPERM:
return "EPERM";
1050 case EPFNOSUPPORT:
return "EPFNOSUPPORT";
1051 case EPIPE:
return "EPIPE";
1052 case EPROTO:
return "EPROTO";
1053 case EPROTONOSUPPORT:
return "EPROTONOSUPPORT";
1054 case EPROTOTYPE:
return "EPROTOTYPE";
1055 case ERANGE:
return "ERANGE";
1056 case EREMOTE:
return "EREMOTE";
1059 case EROFS:
return "EROFS";
1060 case ESHUTDOWN:
return "ESHUTDOWN";
1061 case ESPIPE:
return "ESPIPE";
1062 case ESOCKTNOSUPPORT:
return "ESOCKTNOSUPPORT";
1063 case ESRCH:
return "ESRCH";
1064 case ESTALE:
return "ESTALE";
1065 case ETIME:
return "ETIME";
1066 case ETIMEDOUT:
return "ETIMEDOUT";
1067 case ETXTBSY:
return "ETXTBSY";
1068 case EUNATCH:
return "EUNATCH";
1069 case EUSERS:
return "EUSERS";
1071 case EXDEV:
return "EXDEV";
1075 case EBADE:
return "EBADE";
1076 case EBADFD:
return "EBADFD";
1077 case EBADSLT:
return "EBADSLT";
1078 case EDEADLOCK:
return "EDEADLOCK";
1079 case EBADR:
return "EBADR";
1080 case EBADRQC:
return "EBADRQC";
1081 case ECHRNG:
return "ECHRNG";
1083 case EISNAM:
return "EISNAM";
1084 case EKEYEXPIRED:
return "EKEYEXPIRED";
1085 case EKEYREJECTED:
return "EKEYREJECTED";
1086 case EKEYREVOKED:
return "EKEYREVOKED";
1088 case EL2HLT:
return "EL2HLT";
1089 case EL2NSYNC:
return "EL2NSYNC";
1090 case EL3HLT:
return "EL3HLT";
1091 case EL3RST:
return "EL3RST";
1092 case ELIBBAD:
return "ELIBBAD";
1093 case ELIBMAX:
return "ELIBMAX";
1094 case ELIBSCN:
return "ELIBSCN";
1095 case ELIBEXEC:
return "ELIBEXEC";
1097 case ENOMEDIUM:
return "ENOMEDIUM";
1098 case EMEDIUMTYPE:
return "EMEDIUMTYPE";
1100 case ENONET:
return "ENONET";
1101 case ENOPKG:
return "ENOPKG";
1102 case EREMCHG:
return "EREMCHG";
1103 case ERESTART:
return "ERESTART";
1104 case ESTRPIPE:
return "ESTRPIPE";
1106 case EUCLEAN:
return "EUCLEAN";
1108 case EXFULL:
return "EXFULL";
1130 int error = abs(rc);
1140 return "Generic Pacemaker error";
1142 return "Operation requires quorum";
1144 return "Update does not conform to the configured schema";
1146 return "Schema transform failed";
1148 return "Update was older than existing configuration";
1150 return "Application of an update diff failed";
1152 return "Application of an update diff failed, requesting a full refresh";
1154 return "The on-disk configuration was manually modified";
1156 return "Could not archive the previous configuration";
1158 return "Could not save the new configuration to disk";
1160 return "Could not parse on-disk configuration";
1163 return "Schema is already the latest available";
1168 return "Name not unique on network";
1171 return "Communication error on send";
1174 return "Can not access a needed shared library";
1177 return "Remote I/O error";
1180 return "Protocol driver not attached";
1183 return "Required key not available";
1186 crm_err(
"Unknown error code: %d", rc);
1187 return "Unknown error";
1201 case BZ_CONFIG_ERROR:
1202 return "libbz2 has been improperly compiled on your platform";
1203 case BZ_SEQUENCE_ERROR:
1204 return "library functions called in the wrong order";
1205 case BZ_PARAM_ERROR:
1206 return "parameter is out of range or otherwise incorrect";
1208 return "memory allocation failed";
1210 return "data integrity error is detected during decompression";
1211 case BZ_DATA_ERROR_MAGIC:
1212 return "the compressed stream does not start with the correct magic bytes";
1214 return "error reading or writing in the compressed file";
1215 case BZ_UNEXPECTED_EOF:
1216 return "compressed file finishes before the logical end of stream is detected";
1217 case BZ_OUTBUFF_FULL:
1218 return "output data will not fit into the buffer provided";
1220 return "Unknown error";
1227 const char *next = NULL;
1228 const char *offset = NULL;
1230 if (output == NULL) {
1232 output =
"-- empty --";
1240 (
int)(next - offset), offset);
1245 }
while (next != NULL && next[0] != 0);
1253 char *
string = NULL;
1255 va_start(ap, format);
1257 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)