diff --git a/exec/logconfig.c b/exec/logconfig.c index e80b4ae0..b37622ec 100644 --- a/exec/logconfig.c +++ b/exec/logconfig.c @@ -1,754 +1,753 @@ /* * Copyright (c) 2002-2005 MontaVista Software, Inc. * Copyright (c) 2006-2011 Red Hat, Inc. * * All rights reserved. * * Author: Steven Dake (sdake@redhat.com) * Jan Friesse (jfriesse@redhat.com) * * This software licensed under BSD license, the text of which follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name of the MontaVista Software, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #include #include #ifdef LOGCONFIG_USE_ICMAP #include #define MAP_KEYNAME_MAXLEN ICMAP_KEYNAME_MAXLEN #define map_get_string(key_name, value) icmap_get_string(key_name, value) #else #include static cmap_handle_t cmap_handle; static const char *main_logfile; #define MAP_KEYNAME_MAXLEN CMAP_KEYNAME_MAXLEN #define map_get_string(key_name, value) cmap_get_string(cmap_handle, key_name, value) #endif #include "util.h" #include "logconfig.h" static char error_string_response[512]; /** * insert_into_buffer * @target_buffer: a buffer where to write results * @bufferlen: tell us the size of the buffer to avoid overflows * @entry: entry that needs to be added to the buffer * @after: can either be NULL or set to a string. * if NULL, @entry is prependend to logsys_format_get buffer. * if set, @entry is added immediately after @after. * * Since the function is specific to logsys_format_get handling, it is implicit * that source is logsys_format_get(); * * In case of failure, target_buffer could be left dirty. So don't trust * any data leftover in it. * * Searching for "after" assumes that there is only entry of "after" * in the source. Afterall we control the string here and for logging format * it makes little to no sense to have duplicate format entries. * * Returns: 0 on success, -1 on failure **/ static int insert_into_buffer( char *target_buffer, size_t bufferlen, const char *entry, const char *after) { const char *current_format = NULL; current_format = logsys_format_get(); /* if the entry is already in the format we don't add it again */ if (strstr(current_format, entry) != NULL) { return -1; } /* if there is no "after", simply prepend the requested entry * otherwise go for beautiful string manipulation.... */ if (!after) { if (snprintf(target_buffer, bufferlen - 1, "%s%s", entry, current_format) >= bufferlen - 1) { return -1; } } else { const char *afterpos; size_t afterlen; size_t templen; /* check if after is contained in the format * and afterlen has a meaning or return an error */ afterpos = strstr(current_format, after); afterlen = strlen(after); if ((!afterpos) || (!afterlen)) { return -1; } templen = afterpos - current_format + afterlen; if (snprintf(target_buffer, templen + 1, "%s", current_format) >= bufferlen - 1) { return -1; } if (snprintf(target_buffer + templen, bufferlen - ( templen + 1 ), "%s%s", entry, current_format + templen) >= bufferlen - ( templen + 1 )) { return -1; } } return 0; } /* * format set is global specific option that * doesn't apply at system/subsystem level. */ static int corosync_main_config_format_set ( const char **error_string) { const char *error_reason; char new_format_buffer[PATH_MAX]; char *value = NULL; int err = 0; char timestamp_str_to_add[8]; if (map_get_string("logging.fileline", &value) == CS_OK) { if (strcmp (value, "on") == 0) { if (!insert_into_buffer(new_format_buffer, sizeof(new_format_buffer), " %f:%l", "g]")) { err = logsys_format_set(new_format_buffer); } else if (!insert_into_buffer(new_format_buffer, sizeof(new_format_buffer), "%f:%l", NULL)) { err = logsys_format_set(new_format_buffer); } } else if (strcmp (value, "off") == 0) { /* nothing to do here */ } else { error_reason = "unknown value for fileline"; free(value); goto parse_error; } free(value); } if (err) { error_reason = "not enough memory to set logging format buffer"; goto parse_error; } if (map_get_string("logging.function_name", &value) == CS_OK) { if (strcmp (value, "on") == 0) { if (!insert_into_buffer(new_format_buffer, sizeof(new_format_buffer), "%n:", "f:")) { err = logsys_format_set(new_format_buffer); } else if (!insert_into_buffer(new_format_buffer, sizeof(new_format_buffer), " %n", "g]")) { err = logsys_format_set(new_format_buffer); } } else if (strcmp (value, "off") == 0) { /* nothing to do here */ } else { error_reason = "unknown value for function_name"; free(value); goto parse_error; } free(value); } if (err) { error_reason = "not enough memory to set logging format buffer"; goto parse_error; } memset(timestamp_str_to_add, 0, sizeof(timestamp_str_to_add)); if (map_get_string("logging.timestamp", &value) == CS_OK) { if (strcmp (value, "on") == 0) { strcpy(timestamp_str_to_add, "%t"); #ifdef QB_FEATURE_LOG_HIRES_TIMESTAMPS } else if (strcmp (value, "hires") == 0) { strcpy(timestamp_str_to_add, "%T"); #endif } else if (strcmp (value, "off") == 0) { /* nothing to do here */ } else { error_reason = "unknown value for timestamp"; free(value); goto parse_error; } free(value); } else { /* * Display hires timestamp by default, otherwise standard timestamp */ #ifdef QB_FEATURE_LOG_HIRES_TIMESTAMPS strcpy(timestamp_str_to_add, "%T"); #else strcpy(timestamp_str_to_add, "%t"); #endif } if(strcmp(timestamp_str_to_add, "") != 0) { strcat(timestamp_str_to_add, " "); if (insert_into_buffer(new_format_buffer, sizeof(new_format_buffer), timestamp_str_to_add, NULL) == 0) { err = logsys_format_set(new_format_buffer); } } if (err) { error_reason = "not enough memory to set logging format buffer"; goto parse_error; } return (0); parse_error: *error_string = error_reason; return (-1); } /* * blackbox is another global specific option that * doesn't apply at system/subsystem level. */ static int corosync_main_config_blackbox_set ( const char **error_string) { const char *error_reason; char *value = NULL; if (map_get_string("logging.blackbox", &value) == CS_OK) { if (strcmp (value, "on") == 0) { (void)logsys_blackbox_set(QB_TRUE); } else if (strcmp (value, "off") == 0) { (void)logsys_blackbox_set(QB_FALSE); } else { error_reason = "unknown value for blackbox"; free(value); goto parse_error; } free(value); } else { (void)logsys_blackbox_set(QB_TRUE); } return (0); parse_error: *error_string = error_reason; return (-1); } static int corosync_main_config_log_destination_set ( const char *path, const char *key, const char *subsys, const char **error_string, unsigned int mode_mask, char deprecated, char default_value, const char *replacement) { static char formatted_error_reason[128]; char *value = NULL; unsigned int mode; char key_name[MAP_KEYNAME_MAXLEN]; snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, key); if (map_get_string(key_name, &value) == CS_OK) { if (deprecated) { log_printf(LOGSYS_LEVEL_WARNING, "Warning: the %s config parameter has been obsoleted." " See corosync.conf man page %s directive.", key, replacement); } mode = logsys_config_mode_get (subsys); if (strcmp (value, "yes") == 0 || strcmp (value, "on") == 0) { mode |= mode_mask; if (logsys_config_mode_set(subsys, mode) < 0) { sprintf (formatted_error_reason, "unable to set mode %s", key); goto parse_error; } } else if (strcmp (value, "no") == 0 || strcmp (value, "off") == 0) { mode &= ~mode_mask; if (logsys_config_mode_set(subsys, mode) < 0) { sprintf (formatted_error_reason, "unable to unset mode %s", key); goto parse_error; } } else { sprintf (formatted_error_reason, "unknown value for %s", key); goto parse_error; } } /* Set to default if we are the top-level logger */ else if (!subsys && !deprecated) { mode = logsys_config_mode_get (subsys); if (default_value) { mode |= mode_mask; } else { mode &= ~mode_mask; } if (logsys_config_mode_set(subsys, mode) < 0) { sprintf (formatted_error_reason, "unable to change mode %s", key); goto parse_error; } } free(value); return (0); parse_error: *error_string = formatted_error_reason; free(value); return (-1); } static int corosync_main_config_set ( const char *path, const char *subsys, const char **error_string) { const char *error_reason = error_string_response; char *value = NULL; int mode; char key_name[MAP_KEYNAME_MAXLEN]; /* * this bit abuses the internal logsys exported API * to guarantee that all configured subsystems are * initialized too. * * using this approach avoids some headaches caused * by IPC and TOTEM that have a special logging * handling requirements */ if (subsys != NULL) { if (_logsys_subsys_create(subsys, NULL) < 0) { error_reason = "unable to create new logging subsystem"; goto parse_error; } } mode = logsys_config_mode_get(subsys); if (mode < 0) { error_reason = "unable to get mode"; goto parse_error; } if (corosync_main_config_log_destination_set (path, "to_stderr", subsys, &error_reason, LOGSYS_MODE_OUTPUT_STDERR, 0, 1, NULL) != 0) goto parse_error; if (corosync_main_config_log_destination_set (path, "to_syslog", subsys, &error_reason, LOGSYS_MODE_OUTPUT_SYSLOG, 0, 1, NULL) != 0) goto parse_error; snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "syslog_facility"); if (map_get_string(key_name, &value) == CS_OK) { int syslog_facility; syslog_facility = qb_log_facility2int(value); if (syslog_facility < 0) { error_reason = "unknown syslog facility specified"; goto parse_error; } if (logsys_config_syslog_facility_set(subsys, syslog_facility) < 0) { error_reason = "unable to set syslog facility"; goto parse_error; } free(value); } else { /* Set default here in case of a reload */ if (logsys_config_syslog_facility_set(subsys, qb_log_facility2int("daemon")) < 0) { error_reason = "unable to set syslog facility"; goto parse_error; } } snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "syslog_level"); if (map_get_string(key_name, &value) == CS_OK) { int syslog_priority; log_printf(LOGSYS_LEVEL_WARNING, "Warning: the syslog_level config parameter has been obsoleted." " See corosync.conf man page syslog_priority directive."); syslog_priority = logsys_priority_id_get(value); free(value); if (syslog_priority < 0) { error_reason = "unknown syslog level specified"; goto parse_error; } if (logsys_config_syslog_priority_set(subsys, syslog_priority) < 0) { error_reason = "unable to set syslog level"; goto parse_error; } } snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "syslog_priority"); if (map_get_string(key_name, &value) == CS_OK) { int syslog_priority; syslog_priority = logsys_priority_id_get(value); free(value); if (syslog_priority < 0) { error_reason = "unknown syslog priority specified"; goto parse_error; } if (logsys_config_syslog_priority_set(subsys, syslog_priority) < 0) { error_reason = "unable to set syslog priority"; goto parse_error; } } else if(strcmp(key_name, "logging.syslog_priority") == 0){ if (logsys_config_syslog_priority_set(subsys, logsys_priority_id_get("info")) < 0) { error_reason = "unable to set syslog level"; goto parse_error; } } #ifdef LOGCONFIG_USE_ICMAP snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "logfile"); if (map_get_string(key_name, &value) == CS_OK) { if (logsys_config_file_set (subsys, &error_reason, value) < 0) { goto parse_error; } free(value); } #else if (!subsys) { if (logsys_config_file_set (subsys, &error_reason, main_logfile) < 0) { goto parse_error; } } #endif if (corosync_main_config_log_destination_set (path, "to_file", subsys, &error_reason, LOGSYS_MODE_OUTPUT_FILE, 1, 0, "to_logfile") != 0) goto parse_error; if (corosync_main_config_log_destination_set (path, "to_logfile", subsys, &error_reason, LOGSYS_MODE_OUTPUT_FILE, 0, 0, NULL) != 0) goto parse_error; snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "logfile_priority"); if (map_get_string(key_name, &value) == CS_OK) { int logfile_priority; logfile_priority = logsys_priority_id_get(value); free(value); if (logfile_priority < 0) { error_reason = "unknown logfile priority specified"; goto parse_error; } if (logsys_config_logfile_priority_set(subsys, logfile_priority) < 0) { error_reason = "unable to set logfile priority"; goto parse_error; } } else if(strcmp(key_name,"logging.logfile_priority") == 0){ if (logsys_config_logfile_priority_set(subsys, logsys_priority_id_get("info")) < 0) { error_reason = "unable to set syslog level"; goto parse_error; } } snprintf(key_name, MAP_KEYNAME_MAXLEN, "%s.%s", path, "debug"); if (map_get_string(key_name, &value) == CS_OK) { if (strcmp (value, "trace") == 0) { if (logsys_config_debug_set (subsys, LOGSYS_DEBUG_TRACE) < 0) { error_reason = "unable to set debug trace"; free(value); goto parse_error; } } else if (strcmp (value, "on") == 0) { if (logsys_config_debug_set (subsys, LOGSYS_DEBUG_ON) < 0) { error_reason = "unable to set debug on"; free(value); goto parse_error; } } else if (strcmp (value, "off") == 0) { if (logsys_config_debug_set (subsys, LOGSYS_DEBUG_OFF) < 0) { error_reason = "unable to set debug off"; free(value); goto parse_error; } } else { error_reason = "unknown value for debug"; free(value); goto parse_error; } free(value); } else { if (logsys_config_debug_set (subsys, LOGSYS_DEBUG_OFF) < 0) { error_reason = "unable to set debug off"; - free(value); goto parse_error; } } return (0); parse_error: *error_string = error_reason; return (-1); } static int corosync_main_config_read_logging ( const char **error_string) { const char *error_reason; #ifdef LOGCONFIG_USE_ICMAP icmap_iter_t iter; const char *key_name; #else cmap_iter_handle_t iter; char key_name[CMAP_KEYNAME_MAXLEN]; #endif char key_subsys[MAP_KEYNAME_MAXLEN]; char key_item[MAP_KEYNAME_MAXLEN]; int res; /* format set is supported only for toplevel */ if (corosync_main_config_format_set(&error_reason) < 0) { goto parse_error; } if (corosync_main_config_blackbox_set(&error_reason) < 0) { goto parse_error; } if (corosync_main_config_set ("logging", NULL, &error_reason) < 0) { goto parse_error; } /* * we will need 2 of these to compensate for new logging * config format */ #ifdef LOGCONFIG_USE_ICMAP iter = icmap_iter_init("logging.logger_subsys."); while ((key_name = icmap_iter_next(iter, NULL, NULL)) != NULL) { #else cmap_iter_init(cmap_handle, "logging.logger_subsys.", &iter); while ((cmap_iter_next(cmap_handle, iter, key_name, NULL, NULL)) == CS_OK) { #endif res = sscanf(key_name, "logging.logger_subsys.%[^.].%s", key_subsys, key_item); if (res != 2) { continue ; } if (strcmp(key_item, "subsys") != 0) { continue ; } if (snprintf(key_item, MAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s", key_subsys) >= MAP_KEYNAME_MAXLEN) { /* * This should never happen */ error_reason = "Can't snprintf logger_subsys key_item"; goto parse_error; } if (corosync_main_config_set(key_item, key_subsys, &error_reason) < 0) { goto parse_error; } } #ifdef LOGCONFIG_USE_ICMAP icmap_iter_finalize(iter); #else cmap_iter_finalize(cmap_handle, iter); #endif logsys_config_apply(); return 0; parse_error: *error_string = error_reason; return (-1); } #ifdef LOGCONFIG_USE_ICMAP static void main_logging_notify( int32_t event, const char *key_name, struct icmap_notify_value new_val, struct icmap_notify_value old_val, void *user_data) #else static void main_logging_notify( cmap_handle_t cmap_handle_unused, cmap_handle_t cmap_track_handle_unused, int32_t event, const char *key_name, struct cmap_notify_value new_val, struct cmap_notify_value old_val, void *user_data) #endif { const char *error_string; static int reload_in_progress = 0; /* If a full reload happens then suspend updates for individual keys until * it's all completed */ if (strcmp(key_name, "config.reload_in_progress") == 0) { if (*(uint8_t *)new_val.data == 1) { reload_in_progress = 1; } else { reload_in_progress = 0; } } if (reload_in_progress) { log_printf(LOGSYS_LEVEL_DEBUG, "Ignoring key change, reload in progress. %s\n", key_name); return; } /* * Reload the logsys configuration */ if (logsys_format_set(NULL) == -1) { fprintf (stderr, "Unable to setup logging format.\n"); } corosync_main_config_read_logging(&error_string); } #ifdef LOGCONFIG_USE_ICMAP static void add_logsys_config_notification(void) { icmap_track_t icmap_track = NULL; icmap_track_add("logging.", ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX, main_logging_notify, NULL, &icmap_track); icmap_track_add("config.reload_in_progress", ICMAP_TRACK_ADD | ICMAP_TRACK_MODIFY, main_logging_notify, NULL, &icmap_track); } #else static void add_logsys_config_notification(void) { cmap_track_handle_t cmap_track; cmap_track_add(cmap_handle, "logging.", CMAP_TRACK_ADD | CMAP_TRACK_DELETE | CMAP_TRACK_MODIFY | CMAP_TRACK_PREFIX, main_logging_notify, NULL, &cmap_track); cmap_track_add(cmap_handle, "config.reload_in_progress", CMAP_TRACK_ADD | CMAP_TRACK_MODIFY, main_logging_notify, NULL, &cmap_track); } #endif int corosync_log_config_read ( #ifndef LOGCONFIG_USE_ICMAP cmap_handle_t cmap_h, const char *default_logfile, #endif const char **error_string) { const char *error_reason = error_string_response; #ifndef LOGCONFIG_USE_ICMAP if (!cmap_h) { error_reason = "No cmap handle"; return (-1); } if (!default_logfile) { error_reason = "No default logfile"; return (-1); } cmap_handle = cmap_h; main_logfile = default_logfile; #endif if (corosync_main_config_read_logging(error_string) < 0) { error_reason = *error_string; goto parse_error; } add_logsys_config_notification(); return 0; parse_error: snprintf (error_string_response, sizeof(error_string_response), "parse error in config: %s.\n", error_reason); *error_string = error_string_response; return (-1); }