23 #include <sys/param.h> 24 #include <sys/types.h> 27 #include <sys/utsname.h> 42 #include <qb/qbdefs.h> 49 static gboolean crm_tracing_enabled(
void);
53 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER 54 GLogFunc glib_log_default;
57 crm_glib_handler(
const gchar * log_domain, GLogLevelFlags
flags,
const gchar * message,
60 int log_level = LOG_WARNING;
61 GLogLevelFlags msg_level = (flags & G_LOG_LEVEL_MASK);
62 static struct qb_log_callsite *glib_cs = NULL;
64 if (glib_cs == NULL) {
65 glib_cs = qb_log_callsite_get(__FUNCTION__, __FILE__,
"glib-handler", LOG_DEBUG, __LINE__,
crm_trace_nonlog);
70 case G_LOG_LEVEL_CRITICAL:
75 crm_abort(__FILE__, __FUNCTION__, __LINE__, message, TRUE, TRUE);
79 case G_LOG_LEVEL_ERROR:
82 case G_LOG_LEVEL_MESSAGE:
83 log_level = LOG_NOTICE;
85 case G_LOG_LEVEL_INFO:
88 case G_LOG_LEVEL_DEBUG:
89 log_level = LOG_DEBUG;
92 case G_LOG_LEVEL_WARNING:
93 case G_LOG_FLAG_RECURSION:
94 case G_LOG_FLAG_FATAL:
95 case G_LOG_LEVEL_MASK:
96 log_level = LOG_WARNING;
100 do_crm_log(log_level,
"%s: %s", log_domain, message);
105 # define NAME_MAX 256 109 crm_trigger_blackbox(
int nsig)
111 if(nsig == SIGTRAP) {
122 const char *value = NULL;
124 snprintf(env_name,
NAME_MAX,
"PCMK_%s", option);
125 value = getenv(env_name);
127 crm_trace(
"Found %s = %s", env_name, value);
131 snprintf(env_name,
NAME_MAX,
"HA_%s", option);
132 value = getenv(env_name);
134 crm_trace(
"Found %s = %s", env_name, value);
138 crm_trace(
"Nothing found for %s", option);
147 snprintf(env_name,
NAME_MAX,
"PCMK_%s", option);
149 crm_trace(
"Setting %s to %s", env_name, value);
150 setenv(env_name, value, 1);
156 snprintf(env_name,
NAME_MAX,
"HA_%s", option);
158 crm_trace(
"Setting %s to %s", env_name, value);
159 setenv(env_name, value, 1);
174 }
else if (value != NULL && strstr(value, daemon)) {
184 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER 185 g_log_set_default_handler(glib_log_default, NULL);
191 set_format_string(
int method,
const char *
daemon)
196 if (method > QB_LOG_STDERR) {
200 if (
uname(&res) == 0) {
202 snprintf(fmt + offset,
FMT_MAX - offset,
"%%t [%lu] %s %10s: ",
203 (
unsigned long) getpid(), res.nodename, daemon);
205 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"%%t [%lu] %10s: ",
206 (
unsigned long) getpid(), daemon);
210 if (method == QB_LOG_SYSLOG) {
211 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"%%g %%-7p: %%b");
212 crm_extended_logging(method, QB_FALSE);
213 }
else if (crm_tracing_enabled()) {
214 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"(%%-12f:%%5l %%g) %%-7p: %%n:\t%%b");
216 offset += snprintf(fmt + offset,
FMT_MAX - offset,
"%%g %%-7p: %%n:\t%%b");
220 qb_log_format_set(method, fmt);
226 bool is_default =
false;
227 static int default_fd = -1;
228 static gboolean have_logfile = FALSE;
233 const char *default_logfile =
"/var/log/pacemaker.log";
237 FILE *logfile = NULL;
238 char *parent_dir = NULL;
241 if (filename == NULL && have_logfile == FALSE) {
242 filename = default_logfile;
245 if (filename == NULL) {
251 }
else if(
safe_str_eq(filename, default_logfile)) {
255 if(is_default && default_fd >= 0) {
260 filename_cp = strdup(filename);
261 parent_dir = dirname(filename_cp);
262 rc = stat(parent_dir, &parent);
265 crm_err(
"Directory '%s' does not exist: logging to '%s' is disabled", parent_dir, filename);
272 logfile = fopen(filename,
"a");
273 if(logfile == NULL) {
274 crm_err(
"%s (%d): Logging to '%s' as uid=%u, gid=%u is disabled",
275 pcmk_strerror(errno), errno, filename, geteuid(), getegid());
280 if (geteuid() == 0) {
284 gboolean fix = FALSE;
285 int logfd = fileno(logfile);
287 rc = fstat(logfd, &st);
289 crm_perror(LOG_WARNING,
"Cannot stat %s", filename);
295 if (st.st_gid != pcmk_gid) {
298 }
else if ((st.st_mode & S_IRWXG) != (S_IRGRP | S_IWGRP)) {
305 rc = fchown(logfd, pcmk_uid, pcmk_gid);
307 crm_warn(
"Cannot change the ownership of %s to user %s and gid %d",
311 rc = fchmod(logfd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
313 crm_warn(
"Cannot change the mode of %s to rw-rw----", filename);
316 fprintf(logfile,
"Set r/w permissions for uid=%d, gid=%d on %s\n",
317 pcmk_uid, pcmk_gid, filename);
318 if (fflush(logfile) < 0 || fsync(logfd) < 0) {
319 crm_err(
"Couldn't write out logfile: %s", filename);
326 fd = qb_log_file_open(filename);
329 crm_perror(LOG_WARNING,
"Couldn't send additional logging to %s", filename);
336 }
else if(default_fd >= 0) {
338 qb_log_ctl(default_fd, QB_LOG_CONF_ENABLED, QB_FALSE);
341 crm_notice(
"Additional logging available in %s", filename);
342 qb_log_ctl(fd, QB_LOG_CONF_ENABLED, QB_TRUE);
352 static int blackbox_trigger = 0;
353 static char *blackbox_file_prefix = NULL;
355 #ifdef QB_FEATURE_LOG_HIRES_TIMESTAMPS 365 if(cs && cs->priority < LOG_ERR) {
373 crm_control_blackbox(
int nsig,
bool enable)
377 if (blackbox_file_prefix == NULL) {
378 pid_t
pid = getpid();
380 blackbox_file_prefix = malloc(
NAME_MAX);
381 snprintf(blackbox_file_prefix,
NAME_MAX,
"%s/%s-%lu",
385 if (enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
386 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, 5 * 1024 * 1024);
387 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
390 for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
391 qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_TRUE);
394 crm_notice(
"Initiated blackbox recorder: %s", blackbox_file_prefix);
405 blackbox_trigger = qb_log_custom_open(blackbox_logger, NULL, NULL, NULL);
406 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_ENABLED, QB_TRUE);
407 crm_trace(
"Trigger: %d is %d %d", blackbox_trigger,
408 qb_log_ctl(blackbox_trigger, QB_LOG_CONF_STATE_GET, 0), QB_LOG_STATE_ENABLED);
412 }
else if (!enable && qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
413 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
416 for (lpc = QB_LOG_BLACKBOX; lpc < QB_LOG_TARGET_MAX; lpc++) {
417 qb_log_ctl(lpc, QB_LOG_CONF_FILE_SYNC, QB_FALSE);
425 crm_control_blackbox(nsig, TRUE);
431 crm_control_blackbox(nsig, FALSE);
438 static time_t last = 0;
441 time_t now = time(NULL);
443 if (blackbox_file_prefix == NULL) {
452 if (nsig == 0 && now == last) {
457 snprintf(buffer,
NAME_MAX,
"%s.%d", blackbox_file_prefix, counter++);
458 if (nsig == SIGTRAP) {
459 crm_notice(
"Blackbox dump requested, please see %s for contents", buffer);
463 "Problem detected at %s:%d (%s), please see %s for additional details",
464 cs->function, cs->lineno, cs->filename, buffer);
466 crm_notice(
"Problem detected, please see %s for additional details", buffer);
470 qb_log_blackbox_write_to_file(buffer);
475 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
476 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);
484 qb_log_blackbox_write_to_file(blackbox_file_prefix);
485 qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
494 return crm_log_init(entity, LOG_ERR, FALSE, FALSE, 0, NULL, TRUE);
500 const char *text = g_quark_to_string(tag);
509 crm_log_filter_source(
int source,
const char *trace_files,
const char *trace_fns,
510 const char *trace_fmts,
const char *trace_tags,
const char *trace_blackbox,
511 struct qb_log_callsite *cs)
513 if (qb_log_ctl(source, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
517 qb_bit_set(cs->targets, source);
519 }
else if (source == blackbox_trigger && blackbox_trigger > 0) {
521 if (cs->priority <= LOG_ERR) {
522 qb_bit_set(cs->targets, source);
524 }
else if (trace_blackbox) {
527 if (strstr(trace_blackbox, key) != NULL) {
528 qb_bit_set(cs->targets, source);
533 }
else if (source == QB_LOG_SYSLOG) {
535 qb_bit_set(cs->targets, source);
539 qb_bit_set(cs->targets, source);
540 }
else if (trace_files && strstr(trace_files, cs->filename) != NULL) {
541 qb_bit_set(cs->targets, source);
542 }
else if (trace_fns && strstr(trace_fns, cs->function) != NULL) {
543 qb_bit_set(cs->targets, source);
544 }
else if (trace_fmts && strstr(trace_fmts, cs->format) != NULL) {
545 qb_bit_set(cs->targets, source);
546 }
else if (trace_tags
549 qb_bit_set(cs->targets, source);
554 crm_log_filter(
struct qb_log_callsite *cs)
557 static int need_init = 1;
558 static const char *trace_fns = NULL;
559 static const char *trace_tags = NULL;
560 static const char *trace_fmts = NULL;
561 static const char *trace_files = NULL;
562 static const char *trace_blackbox = NULL;
566 trace_fns = getenv(
"PCMK_trace_functions");
567 trace_fmts = getenv(
"PCMK_trace_formats");
568 trace_tags = getenv(
"PCMK_trace_tags");
569 trace_files = getenv(
"PCMK_trace_files");
570 trace_blackbox = getenv(
"PCMK_trace_blackbox");
572 if (trace_tags != NULL) {
575 const char *offset = NULL;
576 const char *next = trace_tags;
581 snprintf(token,
sizeof(token),
"%.*s", (
int)(next - offset), offset);
583 tag = g_quark_from_string(token);
584 crm_info(
"Created GQuark %u from token '%s' in '%s'", tag, token, trace_tags);
590 }
while (next != NULL && next[0] != 0);
595 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
596 crm_log_filter_source(lpc, trace_files, trace_fns, trace_fmts, trace_tags, trace_blackbox,
604 gboolean refilter = FALSE;
610 if (cs->priority != level) {
611 cs->priority = level;
615 if (cs->tags != tags) {
624 if (cs->targets == 0) {
633 static gboolean log = TRUE;
638 (
"Enabling callsites based on priority=%d, files=%s, functions=%s, formats=%s, tags=%s",
639 crm_log_level, getenv(
"PCMK_trace_files"), getenv(
"PCMK_trace_functions"),
640 getenv(
"PCMK_trace_formats"), getenv(
"PCMK_trace_tags"));
642 qb_log_filter_fn_set(crm_log_filter);
646 crm_tracing_enabled(
void)
650 }
else if (getenv(
"PCMK_trace_files") || getenv(
"PCMK_trace_functions")
651 || getenv(
"PCMK_trace_formats") || getenv(
"PCMK_trace_tags")) {
658 crm_priority2int(
const char *name)
660 struct syslog_names {
664 static struct syslog_names p_names[] = {
665 {
"emerg", LOG_EMERG},
666 {
"alert", LOG_ALERT},
669 {
"warning", LOG_WARNING},
670 {
"notice", LOG_NOTICE},
672 {
"debug", LOG_DEBUG},
677 for (lpc = 0; name != NULL && p_names[lpc].name != NULL; lpc++) {
678 if (
crm_str_eq(p_names[lpc].name, name, TRUE)) {
679 return p_names[lpc].priority;
687 crm_identity(
const char *entity,
int argc,
char **argv)
696 }
else if (argc > 0 && argv != NULL) {
697 char *
mutable = strdup(argv[0]);
698 char *modified = basename(
mutable);
700 if (strstr(modified,
"lt-") == modified) {
724 static bool have_logging = FALSE;
726 if(have_logging == FALSE) {
732 crm_trace_nonlog = g_quark_from_static_string(
"Pacemaker non-logging tracepoint");
735 umask(S_IWGRP | S_IWOTH | S_IROTH);
738 #ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER 739 glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
743 g_log_set_always_fatal((GLogLevelFlags) 0);
746 crm_identity(entity, argc, argv);
748 qb_facility = qb_log_facility2int(
"local0");
753 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
758 qb_log_tags_stringify_fn_set(crm_quark_to_string);
759 for (lpc = QB_LOG_SYSLOG; lpc < QB_LOG_TARGET_MAX; lpc++) {
760 qb_log_ctl(lpc, QB_LOG_CONF_THREADED, QB_FALSE);
768 int argc,
char **argv, gboolean quiet)
770 const char *syslog_priority = NULL;
773 const char *f_copy = facility;
783 if (facility == NULL) {
797 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_FACILITY, qb_log_facility2int(facility));
807 if(syslog_priority) {
808 int priority = crm_priority2int(syslog_priority);
810 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", priority);
812 qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD, QB_LOG_FILTER_FILE,
"*", LOG_NOTICE);
817 qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);
842 crm_trace(
"Quiet: %d, facility %s", quiet, f_copy);
854 const char *user = getenv(
"USER");
857 crm_trace(
"Not switching to corefile directory for %s", user);
865 struct passwd *pwent = getpwuid(user);
868 crm_perror(LOG_ERR,
"Cannot get name for uid: %d", user);
872 crm_trace(
"Don't change active directory for regular user: %s", pwent->pw_name);
874 }
else if (chdir(base) < 0) {
875 crm_perror(LOG_INFO,
"Cannot change active directory to %s", base);
878 crm_info(
"Changed active directory to %s", base);
883 snprintf(path, 512,
"%s-%lu",
crm_system_name, (
unsigned long) getpid());
886 crm_info(
"Changed active directory to %s/%s/%s", base, pwent->pw_name, path);
923 if (enable && qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) != QB_LOG_STATE_ENABLED) {
924 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
927 }
else if (enable == FALSE) {
928 qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
935 static int args = TRUE;
938 if (args && argc > 1) {
942 if (qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_STATE_GET, 0) == QB_LOG_STATE_ENABLED) {
956 #define ARGS_FMT "Invoked: %s" 962 int existing_len = 0;
964 static int logged = 0;
966 char *arg_string = NULL;
968 if (argc == 0 || argv == NULL || logged) {
974 for (; lpc < argc; lpc++) {
975 if (argv[lpc] == NULL) {
979 len = 2 + strlen(argv[lpc]);
980 arg_string = realloc_safe(arg_string, len + existing_len);
981 existing_len += sprintf(arg_string + existing_len,
"%s ", argv[lpc]);
984 qb_log_from_external_source(__func__, __FILE__,
ARGS_FMT, LOG_NOTICE, line, 0, arg_string);
1032 return "Generic Pacemaker error";
1034 return "Operation requires quorum";
1036 return "Update does not conform to the configured schema";
1038 return "Schema transform failed";
1040 return "Update was older than existing configuration";
1042 return "Application of an update diff failed";
1044 return "Application of an update diff failed, requesting a full refresh";
1046 return "The on-disk configuration was manually modified";
1048 return "Could not archive the previous configuration";
1050 return "Could not save the new configuration to disk";
1052 return "Could not parse on-disk configuration";
1054 return "Resource active on multiple nodes";
1056 return "Node not found";
1058 return "Situation already as requested";
1060 return "Bad name/value pair given";
1062 return "Schema is already the latest available";
1064 return "Unknown output format";
1069 return "Name not unique on network";
1072 return "Communication error on send";
1075 return "Can not access a needed shared library";
1078 return "Remote I/O error";
1081 return "Protocol driver not attached";
1084 return "Required key not available";
1086 crm_err(
"Unknown error code: %d", rc);
1087 return "Unknown error";
1096 static struct pcmk__rc_info {
1105 {
"pcmk_rc_unknown_format",
1106 "Unknown output format",
1109 {
"pcmk_rc_bad_nvpair",
1110 "Bad name/value pair given",
1113 {
"pcmk_rc_already",
1114 "Already in requested state",
1117 {
"pcmk_rc_node_unknown",
1121 {
"pcmk_rc_multiple",
1122 "Resource active on multiple nodes",
1125 {
"pcmk_rc_cib_corrupt",
1126 "Could not parse on-disk configuration",
1129 {
"pcmk_rc_cib_save",
1130 "Could not save new configuration to disk",
1133 {
"pcmk_rc_cib_backup",
1134 "Could not archive previous configuration",
1137 {
"pcmk_rc_cib_modified",
1138 "On-disk configuration was manually modified",
1141 {
"pcmk_rc_diff_resync",
1142 "Application of update diff failed, requesting full refresh",
1145 {
"pcmk_rc_diff_failed",
1146 "Application of update diff failed",
1149 {
"pcmk_rc_old_data",
1150 "Update was older than existing configuration",
1153 {
"pcmk_rc_transform_failed",
1154 "Schema transform failed",
1157 {
"pcmk_rc_schema_unchanged",
1158 "Schema is already the latest available",
1161 {
"pcmk_rc_schema_validation",
1162 "Update does not conform to the configured schema",
1165 {
"pcmk_rc_no_quorum",
1166 "Operation requires quorum",
1171 #define PCMK__N_RC (sizeof(pcmk__rcs) / sizeof(struct pcmk__rc_info)) 1188 case E2BIG:
return "E2BIG";
1189 case EACCES:
return "EACCES";
1190 case EADDRINUSE:
return "EADDRINUSE";
1191 case EADDRNOTAVAIL:
return "EADDRNOTAVAIL";
1192 case EAFNOSUPPORT:
return "EAFNOSUPPORT";
1193 case EAGAIN:
return "EAGAIN";
1194 case EALREADY:
return "EALREADY";
1195 case EBADF:
return "EBADF";
1196 case EBADMSG:
return "EBADMSG";
1197 case EBUSY:
return "EBUSY";
1198 case ECANCELED:
return "ECANCELED";
1199 case ECHILD:
return "ECHILD";
1200 case ECOMM:
return "ECOMM";
1201 case ECONNABORTED:
return "ECONNABORTED";
1202 case ECONNREFUSED:
return "ECONNREFUSED";
1203 case ECONNRESET:
return "ECONNRESET";
1205 case EDESTADDRREQ:
return "EDESTADDRREQ";
1206 case EDOM:
return "EDOM";
1207 case EDQUOT:
return "EDQUOT";
1208 case EEXIST:
return "EEXIST";
1209 case EFAULT:
return "EFAULT";
1210 case EFBIG:
return "EFBIG";
1211 case EHOSTDOWN:
return "EHOSTDOWN";
1212 case EHOSTUNREACH:
return "EHOSTUNREACH";
1213 case EIDRM:
return "EIDRM";
1214 case EILSEQ:
return "EILSEQ";
1215 case EINPROGRESS:
return "EINPROGRESS";
1216 case EINTR:
return "EINTR";
1217 case EINVAL:
return "EINVAL";
1218 case EIO:
return "EIO";
1219 case EISCONN:
return "EISCONN";
1220 case EISDIR:
return "EISDIR";
1221 case ELIBACC:
return "ELIBACC";
1222 case ELOOP:
return "ELOOP";
1223 case EMFILE:
return "EMFILE";
1224 case EMLINK:
return "EMLINK";
1225 case EMSGSIZE:
return "EMSGSIZE";
1226 #ifdef EMULTIHOP // Not available on OpenBSD 1227 case EMULTIHOP:
return "EMULTIHOP";
1229 case ENAMETOOLONG:
return "ENAMETOOLONG";
1230 case ENETDOWN:
return "ENETDOWN";
1231 case ENETRESET:
return "ENETRESET";
1232 case ENETUNREACH:
return "ENETUNREACH";
1233 case ENFILE:
return "ENFILE";
1234 case ENOBUFS:
return "ENOBUFS";
1235 case ENODATA:
return "ENODATA";
1236 case ENODEV:
return "ENODEV";
1237 case ENOENT:
return "ENOENT";
1238 case ENOEXEC:
return "ENOEXEC";
1239 case ENOKEY:
return "ENOKEY";
1240 case ENOLCK:
return "ENOLCK";
1241 #ifdef ENOLINK // Not available on OpenBSD 1242 case ENOLINK:
return "ENOLINK";
1244 case ENOMEM:
return "ENOMEM";
1245 case ENOMSG:
return "ENOMSG";
1246 case ENOPROTOOPT:
return "ENOPROTOOPT";
1247 case ENOSPC:
return "ENOSPC";
1248 case ENOSR:
return "ENOSR";
1249 case ENOSTR:
return "ENOSTR";
1250 case ENOSYS:
return "ENOSYS";
1251 case ENOTBLK:
return "ENOTBLK";
1252 case ENOTCONN:
return "ENOTCONN";
1253 case ENOTDIR:
return "ENOTDIR";
1254 case ENOTEMPTY:
return "ENOTEMPTY";
1255 case ENOTSOCK:
return "ENOTSOCK";
1256 #if ENOTSUP != EOPNOTSUPP 1257 case ENOTSUP:
return "ENOTSUP";
1259 case ENOTTY:
return "ENOTTY";
1261 case ENXIO:
return "ENXIO";
1262 case EOPNOTSUPP:
return "EOPNOTSUPP";
1263 case EOVERFLOW:
return "EOVERFLOW";
1264 case EPERM:
return "EPERM";
1265 case EPFNOSUPPORT:
return "EPFNOSUPPORT";
1266 case EPIPE:
return "EPIPE";
1267 case EPROTO:
return "EPROTO";
1268 case EPROTONOSUPPORT:
return "EPROTONOSUPPORT";
1269 case EPROTOTYPE:
return "EPROTOTYPE";
1270 case ERANGE:
return "ERANGE";
1271 case EREMOTE:
return "EREMOTE";
1273 case EROFS:
return "EROFS";
1274 case ESHUTDOWN:
return "ESHUTDOWN";
1275 case ESPIPE:
return "ESPIPE";
1276 case ESOCKTNOSUPPORT:
return "ESOCKTNOSUPPORT";
1277 case ESRCH:
return "ESRCH";
1278 case ESTALE:
return "ESTALE";
1279 case ETIME:
return "ETIME";
1280 case ETIMEDOUT:
return "ETIMEDOUT";
1281 case ETXTBSY:
return "ETXTBSY";
1282 case EUNATCH:
return "EUNATCH";
1283 case EUSERS:
return "EUSERS";
1285 case EXDEV:
return "EXDEV";
1287 #ifdef EBADE // Not available on OS X 1288 case EBADE:
return "EBADE";
1289 case EBADFD:
return "EBADFD";
1290 case EBADSLT:
return "EBADSLT";
1291 case EDEADLOCK:
return "EDEADLOCK";
1292 case EBADR:
return "EBADR";
1293 case EBADRQC:
return "EBADRQC";
1294 case ECHRNG:
return "ECHRNG";
1295 #ifdef EISNAM // Not available on OS X, Illumos, Solaris 1296 case EISNAM:
return "EISNAM";
1297 case EKEYEXPIRED:
return "EKEYEXPIRED";
1299 case EKEYREVOKED:
return "EKEYREVOKED";
1301 case EL2HLT:
return "EL2HLT";
1302 case EL2NSYNC:
return "EL2NSYNC";
1303 case EL3HLT:
return "EL3HLT";
1304 case EL3RST:
return "EL3RST";
1305 case ELIBBAD:
return "ELIBBAD";
1306 case ELIBMAX:
return "ELIBMAX";
1307 case ELIBSCN:
return "ELIBSCN";
1308 case ELIBEXEC:
return "ELIBEXEC";
1309 #ifdef ENOMEDIUM // Not available on OS X, Illumos, Solaris 1310 case ENOMEDIUM:
return "ENOMEDIUM";
1311 case EMEDIUMTYPE:
return "EMEDIUMTYPE";
1313 case ENONET:
return "ENONET";
1314 case ENOPKG:
return "ENOPKG";
1315 case EREMCHG:
return "EREMCHG";
1316 case ERESTART:
return "ERESTART";
1317 case ESTRPIPE:
return "ESTRPIPE";
1318 #ifdef EUCLEAN // Not available on OS X, Illumos, Solaris 1319 case EUCLEAN:
return "EUCLEAN";
1321 case EXFULL:
return "EXFULL";
1323 default:
return "Unknown";
1344 return "Unknown error";
1365 legacy_rc = abs(legacy_rc);
1366 switch (legacy_rc) {
1385 default:
return legacy_rc;
1400 case BZ_CONFIG_ERROR:
1401 return "libbz2 has been improperly compiled on your platform";
1402 case BZ_SEQUENCE_ERROR:
1403 return "library functions called in the wrong order";
1404 case BZ_PARAM_ERROR:
1405 return "parameter is out of range or otherwise incorrect";
1407 return "memory allocation failed";
1409 return "data integrity error is detected during decompression";
1410 case BZ_DATA_ERROR_MAGIC:
1411 return "the compressed stream does not start with the correct magic bytes";
1413 return "error reading or writing in the compressed file";
1414 case BZ_UNEXPECTED_EOF:
1415 return "compressed file finishes before the logical end of stream is detected";
1416 case BZ_OUTBUFF_FULL:
1417 return "output data will not fit into the buffer provided";
1419 return "Unknown error";
1426 const char *next = NULL;
1427 const char *offset = NULL;
1429 if (output == NULL) {
1431 output =
"-- empty --";
1439 (
int)(next - offset), offset);
1444 }
while (next != NULL && next[0] != 0);
1452 char *
string = NULL;
1454 va_start(ap, format);
1456 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_node_unknown
#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)
int pcmk_rc2legacy(int rc)
#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)
const char * pcmk_rc_name(int rc)
Get a return code constant name as a string.
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
const char * pcmk_rc_str(int rc)
Get a user-friendly description of a return code.
#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
#define pcmk_err_unknown_format
void crm_log_output_fn(const char *file, const char *function, int line, int level, const char *prefix, const char *output)
#define pcmk_err_multiple
#define crm_perror(level, fmt, args...)
Log a system error message.
gboolean crm_log_cli_init(const char *entity)
#define crm_err(fmt, args...)
int pcmk_legacy2rc(int legacy_rc)
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)
#define pcmk_err_bad_nvpair
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)