Adding upstream version 3.1.8.upstream/3.1.8upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 952 insertions, 0 deletions

diff --git a/exec/logsys.c b/exec/logsys.c
new file mode 100644
index 0000000..30a4ee6
--- /dev/null
+++ b/exec/logsys.c
@@ -0,0 +1,952 @@
+/*
+ * Copyright (c) 2002-2004 MontaVista Software, Inc.
+ * Copyright (c) 2006-2012 Red Hat, Inc.
+ *
+ * Author: Steven Dake (sdake@redhat.com)
+ * Author: Lon Hohberger (lhh@redhat.com)
+ * Author: Fabio M. Di Nitto (fdinitto@redhat.com)
+ *
+ * All rights reserved.
+ *
+ * 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 <stdint.h>
+#include <ctype.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <qb/qbdefs.h>
+#include <qb/qbutil.h>
+#include <qb/qblog.h>
+
+#include <corosync/logsys.h>
+
+/*
+ * syslog prioritynames, facility names to value mapping
+ * Some C libraries build this in to their headers, but it is non-portable
+ * so logsys supplies its own version.
+ */
+struct syslog_names {
+	const char *c_name;
+	int c_val;
+};
+
+static struct syslog_names prioritynames[] =
+{
+	{ "alert", LOG_ALERT },
+	{ "crit", LOG_CRIT },
+	{ "debug", LOG_DEBUG },
+	{ "emerg", LOG_EMERG },
+	{ "err", LOG_ERR },
+	{ "error", LOG_ERR },
+	{ "info", LOG_INFO },
+	{ "notice", LOG_NOTICE },
+	{ "warning", LOG_WARNING },
+	{ NULL, -1 }
+};
+
+#define MAX_FILES_PER_SUBSYS 32
+#ifdef HAVE_SMALL_MEMORY_FOOTPRINT
+#define IPC_LOGSYS_SIZE			8192*64
+#else
+#define IPC_LOGSYS_SIZE			8192*1024
+#endif
+
+/*
+ * need unlogical order to preserve 64bit alignment
+ */
+struct logsys_logger {
+	char subsys[LOGSYS_MAX_SUBSYS_NAMELEN];	/* subsystem name */
+	char *logfile;				/* log to file */
+	unsigned int mode;			/* subsystem mode */
+	unsigned int debug;			/* debug on|off|trace */
+	int syslog_priority;			/* priority */
+	int logfile_priority;			/* priority to file */
+	int init_status;			/* internal field to handle init queues
+						   for subsystems */
+	int32_t target_id;
+	char *files[MAX_FILES_PER_SUBSYS];
+	int32_t file_idx;
+	int32_t dirty;
+};
+
+/* values for logsys_logger init_status */
+#define LOGSYS_LOGGER_INIT_DONE		0
+#define LOGSYS_LOGGER_NEEDS_INIT	1
+
+static int logsys_system_needs_init = LOGSYS_LOGGER_NEEDS_INIT;
+
+static struct logsys_logger logsys_loggers[LOGSYS_MAX_SUBSYS_COUNT + 1];
+
+static pthread_mutex_t logsys_config_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int32_t _logsys_config_mode_set_unlocked(int32_t subsysid, uint32_t new_mode);
+static void _logsys_config_apply_per_file(int32_t s, const char *filename);
+static void _logsys_config_apply_per_subsys(int32_t s);
+static void _logsys_subsys_filename_add (int32_t s, const char *filename);
+static void logsys_file_format_get(char* file_format, int buf_len);
+
+static char *format_buffer=NULL;
+
+static int logsys_thread_started = 0;
+
+static int logsys_blackbox_enabled = 1;
+
+static int _logsys_config_subsys_get_unlocked (const char *subsys)
+{
+	unsigned int i;
+
+	if (!subsys) {
+		return LOGSYS_MAX_SUBSYS_COUNT;
+	}
+
+	for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if (strcmp (logsys_loggers[i].subsys, subsys) == 0) {
+			return i;
+		}
+	}
+
+	return (-1);
+}
+
+
+/*
+ * we need a version that can work when somebody else is already
+ * holding a config mutex lock or we will never get out of here
+ */
+static int logsys_config_file_set_unlocked (
+		int subsysid,
+		const char **error_string,
+		const char *file)
+{
+	static char error_string_response[512];
+	int i;
+	char file_format[128];
+
+	if (logsys_loggers[subsysid].target_id > 0) {
+		int32_t f;
+		for (f = 0; f < logsys_loggers[subsysid].file_idx; f++) {
+			qb_log_filter_ctl(logsys_loggers[subsysid].target_id,
+				QB_LOG_FILTER_REMOVE,
+				QB_LOG_FILTER_FILE,
+				logsys_loggers[subsysid].files[f],
+				LOG_TRACE);
+		}
+	}
+
+	logsys_loggers[subsysid].dirty = QB_TRUE;
+	if (file == NULL) {
+		return (0);
+	}
+
+	if (logsys_loggers[subsysid].target_id > 0 &&
+	    logsys_loggers[subsysid].logfile != NULL &&
+	    strcmp(file, logsys_loggers[subsysid].logfile) == 0) {
+		return (0);
+	}
+
+	if (strlen(file) >= PATH_MAX) {
+		snprintf (error_string_response,
+			sizeof(error_string_response),
+			"%s: logfile name exceed maximum system filename length",
+			logsys_loggers[subsysid].subsys);
+		*error_string = error_string_response;
+		return (-1);
+	}
+
+	if (logsys_loggers[subsysid].logfile != NULL) {
+		free(logsys_loggers[subsysid].logfile);
+		logsys_loggers[subsysid].logfile = NULL;
+	}
+
+	logsys_loggers[subsysid].logfile = strdup(file);
+
+	if (logsys_loggers[subsysid].logfile == NULL) {
+		snprintf (error_string_response,
+			sizeof(error_string_response),
+			"Unable to allocate memory for logfile '%s'",
+			file);
+		*error_string = error_string_response;
+		return (-1);
+	}
+
+	for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if ((logsys_loggers[i].logfile != NULL) &&
+		    (strcmp (logsys_loggers[i].logfile, file) == 0) &&
+		    (i != subsysid)) {
+			/* we have found another subsys with this config file
+			 * so add a filter
+			 */
+			logsys_loggers[subsysid].target_id = logsys_loggers[i].target_id;
+			return (0);
+		}
+	}
+
+	if (logsys_loggers[subsysid].target_id > 0) {
+		int num_using_current = 0;
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			if (logsys_loggers[subsysid].target_id ==
+				logsys_loggers[i].target_id) {
+				num_using_current++;
+			}
+		}
+		if (num_using_current == 1) {
+			/* no one else is using this close it */
+			qb_log_file_close(logsys_loggers[subsysid].target_id);
+		}
+	}
+
+	logsys_loggers[subsysid].target_id = qb_log_file_open(file);
+	if (logsys_loggers[subsysid].target_id < 0) {
+		int err = -logsys_loggers[subsysid].target_id;
+		char error_str[LOGSYS_MAX_PERROR_MSG_LEN];
+		const char *error_ptr;
+		error_ptr = qb_strerror_r(err, error_str, sizeof(error_str));
+
+		free(logsys_loggers[subsysid].logfile);
+		logsys_loggers[subsysid].logfile = NULL;
+		snprintf (error_string_response,
+			sizeof(error_string_response),
+			"Can't open logfile '%s' for reason: %s (%d)",
+			 file, error_ptr, err);
+		*error_string = error_string_response;
+		return (-1);
+	}
+	logsys_file_format_get(file_format, 128);
+	qb_log_format_set(logsys_loggers[subsysid].target_id, file_format);
+
+	qb_log_ctl(logsys_loggers[subsysid].target_id,
+		   QB_LOG_CONF_ENABLED,
+		   (logsys_loggers[subsysid].mode & LOGSYS_MODE_OUTPUT_FILE));
+	if (logsys_thread_started) {
+		qb_log_ctl(logsys_loggers[subsysid].target_id, QB_LOG_CONF_THREADED, QB_TRUE);
+	}
+
+	return (0);
+}
+
+static void logsys_subsys_init (
+		const char *subsys,
+		int subsysid)
+{
+	if (logsys_system_needs_init == LOGSYS_LOGGER_NEEDS_INIT) {
+		logsys_loggers[subsysid].init_status =
+			LOGSYS_LOGGER_NEEDS_INIT;
+	} else {
+		logsys_loggers[subsysid].mode = logsys_loggers[LOGSYS_MAX_SUBSYS_COUNT].mode;
+		logsys_loggers[subsysid].debug = logsys_loggers[LOGSYS_MAX_SUBSYS_COUNT].debug;
+		logsys_loggers[subsysid].syslog_priority = logsys_loggers[LOGSYS_MAX_SUBSYS_COUNT].syslog_priority;
+		logsys_loggers[subsysid].logfile_priority = logsys_loggers[LOGSYS_MAX_SUBSYS_COUNT].logfile_priority;
+		logsys_loggers[subsysid].init_status = LOGSYS_LOGGER_INIT_DONE;
+	}
+	strncpy (logsys_loggers[subsysid].subsys, subsys,
+		sizeof (logsys_loggers[subsysid].subsys));
+	logsys_loggers[subsysid].subsys[
+		sizeof (logsys_loggers[subsysid].subsys) - 1] = '\0';
+	logsys_loggers[subsysid].file_idx = 0;
+}
+
+static const char *_logsys_tags_stringify(uint32_t tags)
+{
+	if (tags == QB_LOG_TAG_LIBQB_MSG) {
+		return "QB";
+	} else {
+		return logsys_loggers[tags].subsys;
+	}
+}
+
+void logsys_system_fini (void)
+{
+	int i;
+	int f;
+	for (i = 0; i < LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		free(logsys_loggers[i].logfile);
+		for (f = 0; f < logsys_loggers[i].file_idx; f++) {
+			free(logsys_loggers[i].files[f]);
+		}
+	}
+
+	qb_log_fini ();
+}
+
+/*
+ * Internal API - exported
+ */
+
+int _logsys_system_setup(
+	const char *mainsystem,
+	unsigned int mode,
+	int syslog_facility,
+	int syslog_priority)
+{
+	int i;
+	int32_t fidx;
+	char tempsubsys[LOGSYS_MAX_SUBSYS_NAMELEN];
+
+	if ((mainsystem == NULL) ||
+	    (strlen(mainsystem) >= LOGSYS_MAX_SUBSYS_NAMELEN)) {
+		return -1;
+	}
+
+	/*
+	 * Setup libqb as a subsys
+	 */
+	i = _logsys_subsys_create ("QB", "array.c,log.c,log_syslog.c,log_blackbox.c,log_format.c,"
+		"log_file.c,log_dcs.c,log_thread.c,ipc_shm.c,ipcs.c,ipc_us.c,loop.c,"
+		"loop_poll_epoll.c,loop_job.c,loop_poll_poll.c,loop_poll_kqueue.c,"
+		"loop_timerlist.c,loop_poll.c,ringbuffer.c,ringbuffer_helper.c,trie.c,"
+		"map.c,skiplist.c,rpl_sem.c,hdb.c,unix.c,hashtable.c,strlcpy.c,ipc_socket.c,"
+		"strchrnul.c,ipc_setup.c,strlcat.c");
+	if (i < 0) {
+		return -1;
+	}
+
+	/*
+	 * name clash
+	 * _logsys_subsys_filename_add (i, "util.c");
+	 */
+
+	/*
+	 * This file (logsys.c) is not exactly QB. We need tag for logsys.c if flightrecorder init
+	 * fails, and QB seems to be closest.
+	 */
+	_logsys_subsys_filename_add (i, "logsys.c");
+
+	i = LOGSYS_MAX_SUBSYS_COUNT;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	snprintf(logsys_loggers[i].subsys,
+		 LOGSYS_MAX_SUBSYS_NAMELEN,
+		"%s", mainsystem);
+
+	logsys_loggers[i].mode = mode;
+	logsys_loggers[i].debug = LOGSYS_DEBUG_OFF;
+	logsys_loggers[i].file_idx = 0;
+	logsys_loggers[i].logfile_priority = syslog_priority;
+	logsys_loggers[i].syslog_priority = syslog_priority;
+
+	qb_log_init(mainsystem, syslog_facility, syslog_priority);
+	if (logsys_loggers[i].mode & LOGSYS_MODE_OUTPUT_STDERR) {
+		qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
+	} else {
+		qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
+	}
+	if (logsys_loggers[i].mode & LOGSYS_MODE_OUTPUT_SYSLOG) {
+		qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_TRUE);
+	} else {
+		qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
+	}
+	qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_PRIORITY_BUMP, LOG_INFO - LOG_DEBUG);
+
+	qb_log_filter_ctl(QB_LOG_BLACKBOX, QB_LOG_FILTER_ADD,
+			  QB_LOG_FILTER_FILE, "*", LOG_TRACE);
+	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_SIZE, IPC_LOGSYS_SIZE);
+	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_THREADED, QB_FALSE);
+
+	/*
+	 * Blackbox is disabled at the init and enabled later based
+	 * on config (logging.blackbox) value.
+	 */
+	qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
+
+	if (logsys_format_set(NULL) == -1) {
+		pthread_mutex_unlock (&logsys_config_mutex);
+
+		return -1;
+	}
+
+	qb_log_tags_stringify_fn_set(_logsys_tags_stringify);
+
+	logsys_loggers[i].init_status = LOGSYS_LOGGER_INIT_DONE;
+	logsys_system_needs_init = LOGSYS_LOGGER_INIT_DONE;
+
+	for (i = 0; i < LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if ((strcmp (logsys_loggers[i].subsys, "") != 0) &&
+		    (logsys_loggers[i].init_status ==
+		     LOGSYS_LOGGER_NEEDS_INIT)) {
+			fidx = logsys_loggers[i].file_idx;
+			strncpy (tempsubsys, logsys_loggers[i].subsys,
+				 sizeof (tempsubsys));
+			tempsubsys[sizeof (tempsubsys) - 1] = '\0';
+			logsys_subsys_init(tempsubsys, i);
+			logsys_loggers[i].file_idx = fidx;
+			_logsys_config_mode_set_unlocked(i, logsys_loggers[i].mode);
+			_logsys_config_apply_per_subsys(i);
+		}
+	}
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return (0);
+}
+
+
+static void _logsys_subsys_filename_add (int32_t s, const char *filename)
+{
+	int i;
+
+	if (filename == NULL) {
+		return;
+	}
+	assert(logsys_loggers[s].file_idx < MAX_FILES_PER_SUBSYS);
+	assert(logsys_loggers[s].file_idx >= 0);
+
+	for (i = 0; i < logsys_loggers[s].file_idx; i++) {
+		if (strcmp(logsys_loggers[s].files[i], filename) == 0) {
+			return;
+		}
+	}
+	logsys_loggers[s].files[logsys_loggers[s].file_idx++] = strdup(filename);
+
+	if (logsys_system_needs_init == LOGSYS_LOGGER_INIT_DONE) {
+		_logsys_config_apply_per_file(s, filename);
+	}
+}
+
+int _logsys_subsys_create (const char *subsys, const char *filename)
+{
+	int i;
+
+	if ((subsys == NULL) ||
+	    (strlen(subsys) >= LOGSYS_MAX_SUBSYS_NAMELEN)) {
+		return -1;
+	}
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	i = _logsys_config_subsys_get_unlocked (subsys);
+	if ((i > -1) && (i < LOGSYS_MAX_SUBSYS_COUNT)) {
+		_logsys_subsys_filename_add(i, filename);
+		pthread_mutex_unlock (&logsys_config_mutex);
+		return i;
+	}
+
+	for (i = 0; i < LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if (strcmp (logsys_loggers[i].subsys, "") == 0) {
+			logsys_subsys_init(subsys, i);
+			_logsys_subsys_filename_add(i, filename);
+			break;
+		}
+	}
+
+	if (i >= LOGSYS_MAX_SUBSYS_COUNT) {
+		i = -1;
+	}
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+	return i;
+}
+
+int _logsys_config_subsys_get (const char *subsys)
+{
+	unsigned int i;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	i = _logsys_config_subsys_get_unlocked (subsys);
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return i;
+}
+
+static int32_t _logsys_config_mode_set_unlocked(int32_t subsysid, uint32_t new_mode)
+{
+	if ( logsys_loggers[subsysid].mode == new_mode) {
+		return 0;
+	}
+	if (logsys_loggers[subsysid].target_id > 0) {
+		qb_log_ctl(logsys_loggers[subsysid].target_id,
+			   QB_LOG_CONF_ENABLED,
+			   (new_mode & LOGSYS_MODE_OUTPUT_FILE));
+	}
+
+	if (subsysid == LOGSYS_MAX_SUBSYS_COUNT) {
+		qb_log_ctl(QB_LOG_STDERR,
+			   QB_LOG_CONF_ENABLED,
+			   (new_mode & LOGSYS_MODE_OUTPUT_STDERR));
+		qb_log_ctl(QB_LOG_SYSLOG,
+			   QB_LOG_CONF_ENABLED,
+			   (new_mode & LOGSYS_MODE_OUTPUT_SYSLOG));
+	}
+	logsys_loggers[subsysid].mode = new_mode;
+	return 0;
+}
+
+int logsys_config_mode_set (const char *subsys, unsigned int mode)
+{
+	int i;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+	if (subsys != NULL) {
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i >= 0) {
+			i = _logsys_config_mode_set_unlocked(i, mode);
+		}
+	} else {
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			_logsys_config_mode_set_unlocked(i, mode);
+		}
+		i = 0;
+	}
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return i;
+}
+
+unsigned int logsys_config_mode_get (const char *subsys)
+{
+	int i;
+
+	i = _logsys_config_subsys_get (subsys);
+	if (i < 0) {
+		return i;
+	}
+
+	return logsys_loggers[i].mode;
+}
+
+int logsys_config_file_set (
+		const char *subsys,
+		const char **error_string,
+		const char *file)
+{
+	int i;
+	int res;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	if (subsys != NULL) {
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i < 0) {
+			res = i;
+		} else {
+			res = logsys_config_file_set_unlocked(i, error_string, file);
+		}
+	} else {
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			res = logsys_config_file_set_unlocked(i, error_string, file);
+			if (res < 0) {
+				break;
+			}
+		}
+	}
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+	return res;
+}
+
+static void
+logsys_file_format_get(char* file_format, int buf_len)
+{
+	char *format_buffer_start;
+	char *str_pos;
+
+	file_format[0] = '\0';
+
+	format_buffer_start = format_buffer;
+
+	if ((str_pos = strstr(format_buffer, "%t"))) {
+		strcpy(file_format, "%t ");
+		format_buffer_start = str_pos + 2;
+	}
+
+	if ((str_pos = strstr(format_buffer, "%T"))) {
+		strcpy(file_format, "%T ");
+		format_buffer_start = str_pos + 2;
+	}
+
+	strcat(file_format, "[%P] %H %N");
+	strncat(file_format, format_buffer_start, buf_len - strlen(file_format));
+}
+
+int logsys_format_set (const char *format)
+{
+	int i;
+	int c;
+	int w;
+	int reminder;
+	char syslog_format[128];
+	char file_format[128];
+
+	if (format_buffer) {
+		free(format_buffer);
+		format_buffer = NULL;
+	}
+
+	format_buffer = strdup(format ? format : "%7p [%6g] %b");
+	if (format_buffer == NULL) {
+		return -1;
+	}
+
+	qb_log_format_set(QB_LOG_STDERR, format_buffer);
+
+	logsys_file_format_get(file_format, 128);
+	for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if (logsys_loggers[i].target_id > 0) {
+			qb_log_format_set(logsys_loggers[i].target_id, file_format);
+		}
+	}
+
+	/*
+	 * This just goes through and remove %t, %T and %p from
+	 * the format string for syslog.
+	 */
+	w = 0;
+	memset(syslog_format, '\0', sizeof(syslog_format));
+	for (c = 0; c < strlen(format_buffer); c++) {
+		if (format_buffer[c] == '%') {
+			reminder = c;
+			for (c++; c < strlen(format_buffer); c++) {
+				if (isdigit(format_buffer[c])) {
+					continue;
+				}
+				if (format_buffer[c] == 't' ||
+				    format_buffer[c] == 'p' ||
+				    format_buffer[c] == 'T') {
+					c++;
+				} else {
+					c = reminder;
+				}
+				break;
+			}
+		}
+		syslog_format[w] = format_buffer[c];
+		w++;
+	}
+	qb_log_format_set(QB_LOG_SYSLOG, syslog_format);
+
+	return 0;
+}
+
+char *logsys_format_get (void)
+{
+	return format_buffer;
+}
+
+int logsys_config_syslog_facility_set (
+	const char *subsys,
+	unsigned int facility)
+{
+	return qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_FACILITY, facility);
+}
+
+int logsys_config_syslog_priority_set (
+	const char *subsys,
+	unsigned int priority)
+{
+	int i;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+	if (subsys != NULL) {
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i >= 0) {
+			logsys_loggers[i].syslog_priority = priority;
+			logsys_loggers[i].dirty = QB_TRUE;
+
+			i = 0;
+		}
+	} else {
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			logsys_loggers[i].syslog_priority = priority;
+			logsys_loggers[i].dirty = QB_TRUE;
+		}
+		i = 0;
+	}
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return i;
+}
+
+int logsys_config_logfile_priority_set (
+	const char *subsys,
+	unsigned int priority)
+{
+	int i;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+	if (subsys != NULL) {
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i >= 0) {
+			logsys_loggers[i].logfile_priority = priority;
+			logsys_loggers[i].dirty = QB_TRUE;
+			i = 0;
+		}
+	} else {
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			logsys_loggers[i].logfile_priority = priority;
+			logsys_loggers[i].dirty = QB_TRUE;
+		}
+		i = 0;
+	}
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return i;
+}
+
+
+static void _logsys_config_apply_per_file(int32_t s, const char *filename)
+{
+	uint32_t syslog_priority = logsys_loggers[s].syslog_priority;
+	uint32_t logfile_priority = logsys_loggers[s].logfile_priority;
+
+	qb_log_filter_ctl(s, QB_LOG_TAG_SET, QB_LOG_FILTER_FILE,
+			  filename, LOG_TRACE);
+
+	qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_REMOVE,
+			  QB_LOG_FILTER_FILE, filename, LOG_TRACE);
+	qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_REMOVE,
+			  QB_LOG_FILTER_FILE, filename, LOG_TRACE);
+	if (logsys_loggers[s].target_id > 0) {
+		qb_log_filter_ctl(logsys_loggers[s].target_id,
+			QB_LOG_FILTER_REMOVE,
+			QB_LOG_FILTER_FILE, filename, LOG_TRACE);
+	}
+
+	if (logsys_loggers[s].debug != LOGSYS_DEBUG_OFF) {
+		switch (logsys_loggers[s].debug) {
+		case LOGSYS_DEBUG_ON:
+			syslog_priority = LOG_DEBUG;
+			logfile_priority = LOG_DEBUG;
+			break;
+		case LOGSYS_DEBUG_TRACE:
+			syslog_priority = LOG_TRACE;
+			logfile_priority = LOG_TRACE;
+			break;
+		default:
+			assert(0);
+		}
+	}
+	qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_ADD,
+		QB_LOG_FILTER_FILE, filename,
+		syslog_priority);
+	qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
+		QB_LOG_FILTER_FILE, filename,
+		logfile_priority);
+	if (logsys_loggers[s].target_id > 0) {
+		qb_log_filter_ctl(logsys_loggers[s].target_id,
+			QB_LOG_FILTER_ADD,
+			QB_LOG_FILTER_FILE, filename,
+			logfile_priority);
+	}
+}
+
+static void _logsys_config_apply_per_subsys(int32_t s)
+{
+	int32_t f;
+	for (f = 0; f < logsys_loggers[s].file_idx; f++) {
+		_logsys_config_apply_per_file(s, logsys_loggers[s].files[f]);
+	}
+	if (logsys_loggers[s].target_id > 0) {
+		qb_log_ctl(logsys_loggers[s].target_id,
+			QB_LOG_CONF_ENABLED,
+			(logsys_loggers[s].mode & LOGSYS_MODE_OUTPUT_FILE));
+	}
+	logsys_loggers[s].dirty = QB_FALSE;
+}
+
+static void _logsys_config_apply_blackbox(void) {
+	int blackbox_enable_res;
+
+	blackbox_enable_res = qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, logsys_blackbox_enabled);
+
+	if (blackbox_enable_res < 0) {
+		LOGSYS_PERROR (-blackbox_enable_res, LOGSYS_LEVEL_WARNING,
+		    "Unable to initialize log flight recorder. "\
+		    "The most common cause of this error is " \
+		    "not enough space on /dev/shm. Corosync will continue work, " \
+		    "but blackbox will not be available");
+	}
+}
+
+void logsys_config_apply(void)
+{
+	int32_t s;
+
+	_logsys_config_apply_blackbox();
+
+	for (s = 0; s <= LOGSYS_MAX_SUBSYS_COUNT; s++) {
+		if (strcmp(logsys_loggers[s].subsys, "") == 0) {
+			continue;
+		}
+		_logsys_config_apply_per_subsys(s);
+	}
+}
+
+extern int logsys_config_debug_get (
+	const char *subsys)
+{
+	int debug_level = logsys_loggers[0].debug;
+	int i;
+
+	if (subsys != NULL) {
+		pthread_mutex_lock (&logsys_config_mutex);
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i >= 0) {
+			debug_level = logsys_loggers[i].debug;
+		}
+		pthread_mutex_unlock (&logsys_config_mutex);
+	}
+	return debug_level;
+}
+
+int logsys_config_debug_set (
+	const char *subsys,
+	unsigned int debug)
+{
+	int i;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+	if (subsys != NULL) {
+		i = _logsys_config_subsys_get_unlocked (subsys);
+		if (i >= 0) {
+			logsys_loggers[i].dirty = QB_TRUE;
+			logsys_loggers[i].debug = debug;
+			i = 0;
+		}
+	} else {
+		for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+			logsys_loggers[i].debug = debug;
+			logsys_loggers[i].dirty = QB_TRUE;
+		}
+		i = 0;
+	}
+	pthread_mutex_unlock (&logsys_config_mutex);
+
+	return i;
+}
+
+int logsys_priority_id_get (const char *name)
+{
+	unsigned int i;
+
+	for (i = 0; prioritynames[i].c_name != NULL; i++) {
+		if (strcasecmp(name, prioritynames[i].c_name) == 0) {
+			return (prioritynames[i].c_val);
+		}
+	}
+	return (-1);
+}
+
+int logsys_thread_start (void)
+{
+	int i;
+	int err;
+
+	err = qb_log_thread_start();
+	if (err != 0) {
+		return (err);
+	}
+
+	qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_THREADED, QB_TRUE);
+	for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if (logsys_loggers[i].target_id > 0) {
+			qb_log_ctl(logsys_loggers[i].target_id, QB_LOG_CONF_THREADED, QB_TRUE);
+		}
+	}
+
+	logsys_thread_started = 1;
+
+	return (0);
+}
+
+void logsys_blackbox_set(int enable)
+{
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	logsys_blackbox_enabled = enable;
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+}
+
+/*
+ * To set correct pid to qb blackbox filename after tty dettach (fork) we have to
+ * close (this function) and (if needed) reopen blackbox (logsys_blackbox_postfork function).
+ */
+void logsys_blackbox_prefork(void)
+{
+
+	(void)qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_FALSE);
+}
+
+void logsys_blackbox_postfork(void)
+{
+
+	_logsys_config_apply_blackbox();
+}
+
+cs_error_t logsys_reopen_log_files(void)
+{
+	cs_error_t res;
+
+#ifdef HAVE_QB_LOG_FILE_REOPEN
+	int i, j;
+	int num_using_current;
+	int32_t rc;
+
+	res = CS_OK;
+
+	pthread_mutex_lock (&logsys_config_mutex);
+
+	for (i = 0; i <= LOGSYS_MAX_SUBSYS_COUNT; i++) {
+		if (logsys_loggers[i].target_id <= 0 || logsys_loggers[i].logfile == NULL) {
+			continue ;
+		}
+
+		num_using_current = 0;
+		for (j = 0; j <= i; j++) {
+			if (logsys_loggers[i].target_id == logsys_loggers[j].target_id) {
+				num_using_current++;
+			}
+		}
+		if (num_using_current == 1) {
+			/*
+			 * First instance of target file. Reopen it.
+			 */
+			rc = qb_log_file_reopen(logsys_loggers[i].target_id, NULL);
+			if (rc != 0) {
+				LOGSYS_PERROR (-rc, LOGSYS_LEVEL_WARNING,
+				    "Unable to reopen log file %s", logsys_loggers[i].logfile);
+				res = qb_to_cs_error(rc);
+			}
+		}
+	}
+
+	pthread_mutex_unlock (&logsys_config_mutex);
+#else
+	res = CS_ERR_NOT_SUPPORTED;
+#endif
+
+	return (res);
+}