diff options
Diffstat (limited to 'exec/logconfig.c')
| -rw-r--r-- | exec/logconfig.c | 757 |
1 files changed, 757 insertions, 0 deletions
diff --git a/exec/logconfig.c b/exec/logconfig.c new file mode 100644 index 0000000..350d8a9 --- /dev/null +++ b/exec/logconfig.c @@ -0,0 +1,757 @@ +/* + * 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 <corosync/totem/totem.h> +#include <corosync/logsys.h> +#ifdef LOGCONFIG_USE_ICMAP +#include <corosync/icmap.h> +#define MAP_KEYNAME_MAXLEN ICMAP_KEYNAME_MAXLEN +#define map_get_string(key_name, value) icmap_get_string(key_name, value) +#else +#include <corosync/cmap.h> +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" +#include "totemknet.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.... </sarcasm> */ + 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"; + 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(); + + /* Reconfigure knet logging */ + totemknet_configure_log_level(); + 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); +} |