[mirror_lxc.git] / src / lxc / log.h

/*
 * lxc: linux Container library
 *
 * (C) Copyright IBM Corp. 2007, 2008
 *
 * Authors:
 * Daniel Lezcano <daniel.lezcano at free.fr>
 * Cedric Le Goater <legoater@free.fr>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#ifndef __LXC_LOG_H
#define __LXC_LOG_H

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#include <strings.h>
#include <stdbool.h>
#include <syslog.h>
#include <time.h>

#include "conf.h"

#ifndef O_CLOEXEC
#define O_CLOEXEC 02000000
#endif

#ifndef F_DUPFD_CLOEXEC
#define F_DUPFD_CLOEXEC 1030
#endif

#define LXC_LOG_PREFIX_SIZE	32
#define LXC_LOG_BUFFER_SIZE	4096

/* This attribute is required to silence clang warnings */
#if defined(__GNUC__)
#define ATTR_UNUSED __attribute__ ((unused))
#else
#define ATTR_UNUSED
#endif

/* predefined lxc log priorities. */
enum lxc_loglevel {
	LXC_LOG_LEVEL_TRACE,
	LXC_LOG_LEVEL_DEBUG,
	LXC_LOG_LEVEL_INFO,
	LXC_LOG_LEVEL_NOTICE,
	LXC_LOG_LEVEL_WARN,
	LXC_LOG_LEVEL_ERROR,
	LXC_LOG_LEVEL_CRIT,
	LXC_LOG_LEVEL_ALERT,
	LXC_LOG_LEVEL_FATAL,
	LXC_LOG_LEVEL_NOTSET,
};

/* location information of the logging event */
struct lxc_log_locinfo {
	const char *file;
	const char *func;
	int line;
};

#define LXC_LOG_LOCINFO_INIT						\
	{ .file = __FILE__, .func = __func__, .line = __LINE__	}

/* brief logging event object */
struct lxc_log_event {
	const char *category;
	int priority;
	struct timespec timestamp;
	struct lxc_log_locinfo *locinfo;
	const char *fmt;
	va_list *vap;
};

/* log appender object */
struct lxc_log_appender {
	const char *name;
	int (*append)(const struct lxc_log_appender *, struct lxc_log_event *);

	/*
	 * appenders can be stacked
	 */
	struct lxc_log_appender *next;
};

/* log category object */
struct lxc_log_category {
	const char *name;
	int priority;
	struct lxc_log_appender *appender;
	const struct lxc_log_category *parent;
};

#ifndef NO_LXC_CONF
extern int lxc_log_use_global_fd;
#endif

/*
 * Returns true if the chained priority is equal to or higher than
 * given priority.
 */
static inline int lxc_log_priority_is_enabled(const struct lxc_log_category *category,
					      int priority)
{
	while (category->priority == LXC_LOG_LEVEL_NOTSET && category->parent)
		category = category->parent;

	int cmp_prio = category->priority;
#ifndef NO_LXC_CONF
	if (!lxc_log_use_global_fd && current_config &&
	    current_config->loglevel != LXC_LOG_LEVEL_NOTSET)
		cmp_prio = current_config->loglevel;
#endif

	return priority >= cmp_prio;
}

/*
 * converts a priority to a literal string
 */
static inline const char *lxc_log_priority_to_string(int priority)
{
	switch (priority) {
	case LXC_LOG_LEVEL_TRACE:
		return "TRACE";
	case LXC_LOG_LEVEL_DEBUG:
		return "DEBUG";
	case LXC_LOG_LEVEL_INFO:
		return "INFO";
	case LXC_LOG_LEVEL_NOTICE:
		return "NOTICE";
	case LXC_LOG_LEVEL_WARN:
		return "WARN";
	case LXC_LOG_LEVEL_ERROR:
		return "ERROR";
	case LXC_LOG_LEVEL_CRIT:
		return "CRIT";
	case LXC_LOG_LEVEL_ALERT:
		return "ALERT";
	case LXC_LOG_LEVEL_FATAL:
		return "FATAL";
	}

	return "NOTSET";
}

static inline const char *lxc_syslog_priority_to_string(int priority)
{
	switch (priority) {
	case LOG_DAEMON:
		return "daemon";
	case LOG_LOCAL0:
		return "local0";
	case LOG_LOCAL1:
		return "local1";
	case LOG_LOCAL2:
		return "local2";
	case LOG_LOCAL3:
		return "local3";
	case LOG_LOCAL4:
		return "local4";
	case LOG_LOCAL5:
		return "local5";
	case LOG_LOCAL6:
		return "local6";
	case LOG_LOCAL7:
		return "local7";
	}

	return "NOTSET";
}

/*
 * converts a literal priority to an int
 */
static inline int lxc_log_priority_to_int(const char *name)
{
	if (strcasecmp("TRACE", name) == 0)
		return LXC_LOG_LEVEL_TRACE;
	if (strcasecmp("DEBUG", name) == 0)
		return LXC_LOG_LEVEL_DEBUG;
	if (strcasecmp("INFO", name) == 0)
		return LXC_LOG_LEVEL_INFO;
	if (strcasecmp("NOTICE", name) == 0)
		return LXC_LOG_LEVEL_NOTICE;
	if (strcasecmp("WARN", name) == 0)
		return LXC_LOG_LEVEL_WARN;
	if (strcasecmp("ERROR", name) == 0)
		return LXC_LOG_LEVEL_ERROR;
	if (strcasecmp("CRIT", name) == 0)
		return LXC_LOG_LEVEL_CRIT;
	if (strcasecmp("ALERT", name) == 0)
		return LXC_LOG_LEVEL_ALERT;
	if (strcasecmp("FATAL", name) == 0)
		return LXC_LOG_LEVEL_FATAL;

	return LXC_LOG_LEVEL_NOTSET;
}

static inline int lxc_syslog_priority_to_int(const char *name)
{
	if (strcasecmp("daemon", name) == 0)
		return LOG_DAEMON;
	if (strcasecmp("local0", name) == 0)
		return LOG_LOCAL0;
	if (strcasecmp("local1", name) == 0)
		return LOG_LOCAL1;
	if (strcasecmp("local2", name) == 0)
		return LOG_LOCAL2;
	if (strcasecmp("local3", name) == 0)
		return LOG_LOCAL3;
	if (strcasecmp("local4", name) == 0)
		return LOG_LOCAL4;
	if (strcasecmp("local5", name) == 0)
		return LOG_LOCAL5;
	if (strcasecmp("local6", name) == 0)
		return LOG_LOCAL6;
	if (strcasecmp("local7", name) == 0)
		return LOG_LOCAL7;

	return -EINVAL;
}

static inline void __lxc_log_append(const struct lxc_log_appender *appender,
				    struct lxc_log_event *event)
{
	va_list va;
	va_list *va_keep = event->vap;

	while (appender) {
		va_copy(va, *va_keep);
		event->vap = &va;
		appender->append(appender, event);
		appender = appender->next;
		va_end(va);
	}
}

static inline void __lxc_log(const struct lxc_log_category *category,
			     struct lxc_log_event *event)
{
	while (category) {
		__lxc_log_append(category->appender, event);
		category = category->parent;
	}
}

/*
 * Helper macro to define log functions.
 */
#define lxc_log_priority_define(acategory, LEVEL)				\
										\
ATTR_UNUSED __attribute__ ((format (printf, 2, 3)))				\
static inline void LXC_##LEVEL(struct lxc_log_locinfo *, const char *, ...);	\
										\
ATTR_UNUSED static inline void LXC_##LEVEL(struct lxc_log_locinfo* locinfo,	\
					   const char* format, ...)		\
{										\
	if (lxc_log_priority_is_enabled(acategory, LXC_LOG_LEVEL_##LEVEL)) {	\
		va_list va_ref;							\
		int saved_errno;						\
		struct lxc_log_event evt = {					\
			.category	= (acategory)->name,			\
			.priority	= LXC_LOG_LEVEL_##LEVEL,		\
			.fmt		= format,				\
			.locinfo	= locinfo				\
		};								\
										\
		/* clock_gettime() is explicitly marked as MT-Safe		\
		 * without restrictions. So let's use it for our		\
		 * logging stamps.						\
		 */								\
		saved_errno = errno;						\
		(void)clock_gettime(CLOCK_REALTIME, &evt.timestamp);		\
										\
		va_start(va_ref, format);					\
		evt.vap = &va_ref;						\
		__lxc_log(acategory, &evt);					\
		va_end(va_ref);							\
		errno = saved_errno;						\
	}									\
}

/*
 * Helper macro to define and use static categories.
 */
#define lxc_log_category_define(name, parent)				\
	extern struct lxc_log_category lxc_log_category_##parent;	\
	struct lxc_log_category lxc_log_category_##name = {		\
		#name,							\
		LXC_LOG_LEVEL_NOTSET,					\
		NULL,							\
		&lxc_log_category_##parent				\
	};

#define lxc_log_define(name, parent)					\
	lxc_log_category_define(name, parent)				\
									\
	lxc_log_priority_define(&lxc_log_category_##name, TRACE)	\
	lxc_log_priority_define(&lxc_log_category_##name, DEBUG)	\
	lxc_log_priority_define(&lxc_log_category_##name, INFO)		\
	lxc_log_priority_define(&lxc_log_category_##name, NOTICE)	\
	lxc_log_priority_define(&lxc_log_category_##name, WARN)		\
	lxc_log_priority_define(&lxc_log_category_##name, ERROR)	\
	lxc_log_priority_define(&lxc_log_category_##name, CRIT)		\
	lxc_log_priority_define(&lxc_log_category_##name, ALERT)	\
	lxc_log_priority_define(&lxc_log_category_##name, FATAL)

#define lxc_log_category_priority(name) 				\
	(lxc_log_priority_to_string(lxc_log_category_##name.priority))

/*
 * Helper macro to define errno string.
 */
#if HAVE_STRERROR_R
	#ifndef HAVE_DECL_STRERROR_R
		#ifdef STRERROR_R_CHAR_P
			char *strerror_r(int errnum, char *buf, size_t buflen);
		#else
			int strerror_r(int errnum, char *buf, size_t buflen);
		#endif
	#endif

	#ifdef STRERROR_R_CHAR_P
		#define lxc_log_strerror_r                                               \
			char errno_buf[PATH_MAX / 2] = {"Failed to get errno string"};   \
			char *ptr = NULL;                                                \
			{                                                                \
				int __saved_errno = errno;				 \
				ptr = strerror_r(errno, errno_buf, sizeof(errno_buf));   \
				errno = __saved_errno;					 \
				if (!ptr)                                                \
					ptr = errno_buf;                                 \
			}
	#else
		#define lxc_log_strerror_r                                               \
			char errno_buf[PATH_MAX / 2] = {"Failed to get errno string"};   \
			char *ptr = errno_buf;                                           \
			{                                                                \
				int __saved_errno = errno;				 \
				(void)strerror_r(errno, errno_buf, sizeof(errno_buf));   \
				errno = __saved_errno;					 \
			}
	#endif
#elif ENFORCE_THREAD_SAFETY
	#error ENFORCE_THREAD_SAFETY was set but cannot be guaranteed
#else
	#define lxc_log_strerror_r							 \
		char *ptr = NULL;              						 \
		{                              						 \
			ptr = strerror(errno); 						 \
		}
#endif

/*
 * top categories
 */
#define TRACE(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_TRACE(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define DEBUG(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_DEBUG(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define INFO(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_INFO(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define NOTICE(format, ...) do {					\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_NOTICE(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define WARN(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_WARN(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define ERROR(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_ERROR(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define CRIT(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_CRIT(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define ALERT(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_ALERT(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#define FATAL(format, ...) do {						\
	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT;		\
	LXC_FATAL(&locinfo, format, ##__VA_ARGS__);			\
} while (0)

#if HAVE_M_FORMAT
#define SYSTRACE(format, ...)                              \
		TRACE("%m - " format, ##__VA_ARGS__)
#else
#define SYSTRACE(format, ...)                              \
	do {                                               \
		lxc_log_strerror_r;                        \
		TRACE("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define SYSDEBUG(format, ...)                              \
                DEBUG("%m - " format, ##__VA_ARGS__)
#else
#define SYSDEBUG(format, ...)                              \
	do {                                               \
		lxc_log_strerror_r;                        \
		DEBUG("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif


#if HAVE_M_FORMAT
#define SYSINFO(format, ...)                              \
                INFO("%m - " format, ##__VA_ARGS__)
#else
#define SYSINFO(format, ...)                              \
	do {                                              \
		lxc_log_strerror_r;                       \
		INFO("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define SYSNOTICE(format, ...)                              \
		NOTICE("%m - " format, ##__VA_ARGS__)
#else
#define SYSNOTICE(format, ...)                              \
	do {                                                \
		lxc_log_strerror_r;                         \
		NOTICE("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define SYSWARN(format, ...)                              \
		WARN("%m - " format, ##__VA_ARGS__)
#else
#define SYSWARN(format, ...)                              \
	do {                                              \
		lxc_log_strerror_r;                       \
		WARN("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define SYSERROR(format, ...)                              \
		ERROR("%m - " format, ##__VA_ARGS__)
#else
#define SYSERROR(format, ...)                              \
	do {                                               \
		lxc_log_strerror_r;                        \
		ERROR("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define CMD_SYSERROR(format, ...)                                    \
		fprintf(stderr, "%m - " format, ##__VA_ARGS__)
#else
#define CMD_SYSERROR(format, ...)                                    \
	do {                                                         \
		lxc_log_strerror_r;                                  \
		fprintf(stderr, "%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

#if HAVE_M_FORMAT
#define CMD_SYSINFO(format, ...)                            \
		printf("%m - " format, ##__VA_ARGS__)
#else
#define CMD_SYSINFO(format, ...)                            \
	do {                                                \
		lxc_log_strerror_r;                         \
		printf("%s - " format, ptr, ##__VA_ARGS__); \
	} while (0)
#endif

extern int lxc_log_fd;

extern int lxc_log_syslog(int facility);
extern void lxc_log_enable_syslog(void);
extern int lxc_log_set_level(int *dest, int level);
extern int lxc_log_get_level(void);
extern bool lxc_log_has_valid_level(void);
extern int lxc_log_set_file(int *fd, const char *fname);
extern const char *lxc_log_get_file(void);
extern void lxc_log_set_prefix(const char *prefix);
extern const char *lxc_log_get_prefix(void);
extern void lxc_log_options_no_override(void);
#endif
Commit	Line	Data
e0b4037d DL	1	/*
	2	* lxc: linux Container library
	3	*
	4	* (C) Copyright IBM Corp. 2007, 2008
	5	*
	6	* Authors:
9afe19d6	7	* Daniel Lezcano <daniel.lezcano at free.fr>
e0b4037d DL	8	* Cedric Le Goater <legoater@free.fr>
	9	*
	10	* This library is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU Lesser General Public
	12	* License as published by the Free Software Foundation; either
	13	* version 2.1 of the License, or (at your option) any later version.
	14	*
	15	* This library is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* Lesser General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU Lesser General Public
	21	* License along with this library; if not, write to the Free Software
250b1eec	22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
e0b4037d	23	*/
f1a4a029 ÇO	24	#ifndef __LXC_LOG_H
f1a4a029 ÇO	25	#define __LXC_LOG_H
0ad19a3f	26
76d0127f	27	#include <errno.h>
cb8c5720 CLG	28	#include <stdarg.h>
	29	#include <stdio.h>
	30	#include <sys/time.h>
	31	#include <string.h>
65441ac9	32	#include <strings.h>
fabf7361	33	#include <stdbool.h>
76d0127f	34	#include <syslog.h>
c57dbb96	35	#include <time.h>
cb8c5720	36
858377e4 SH	37	#include "conf.h"
858377e4 SH	38
eabbb2f0 MN	39	#ifndef O_CLOEXEC
	40	#define O_CLOEXEC 02000000
	41	#endif
	42
	43	#ifndef F_DUPFD_CLOEXEC
	44	#define F_DUPFD_CLOEXEC 1030
	45	#endif
	46
	47	#define LXC_LOG_PREFIX_SIZE 32
ed408e66	48	#define LXC_LOG_BUFFER_SIZE 4096
eabbb2f0	49
13aad0ae SG	50	/* This attribute is required to silence clang warnings */
	51	#if defined(__GNUC__)
	52	#define ATTR_UNUSED __attribute__ ((unused))
	53	#else
	54	#define ATTR_UNUSED
	55	#endif
	56
76d0127f	57	/* predefined lxc log priorities. */
4a85ce2a	58	enum lxc_loglevel {
4b73005c CB	59	LXC_LOG_LEVEL_TRACE,
	60	LXC_LOG_LEVEL_DEBUG,
	61	LXC_LOG_LEVEL_INFO,
	62	LXC_LOG_LEVEL_NOTICE,
	63	LXC_LOG_LEVEL_WARN,
	64	LXC_LOG_LEVEL_ERROR,
	65	LXC_LOG_LEVEL_CRIT,
	66	LXC_LOG_LEVEL_ALERT,
	67	LXC_LOG_LEVEL_FATAL,
	68	LXC_LOG_LEVEL_NOTSET,
cb8c5720 CLG	69	};
	70
	71	/* location information of the logging event */
	72	struct lxc_log_locinfo {
eba1ae76 CB	73	const char *file;
	74	const char *func;
	75	int line;
cb8c5720 CLG	76	};
	77
	78	#define LXC_LOG_LOCINFO_INIT \
	79	{ .file = __FILE__, .func = __func__, .line = __LINE__ }
	80
	81	/* brief logging event object */
	82	struct lxc_log_event {
eba1ae76 CB	83	const char *category;
	84	int priority;
	85	struct timespec timestamp;
	86	struct lxc_log_locinfo *locinfo;
	87	const char *fmt;
	88	va_list *vap;
cb8c5720 CLG	89	};
	90
	91	/* log appender object */
	92	struct lxc_log_appender {
eba1ae76	93	const char *name;
5fd8380b	94	int (append)(const struct lxc_log_appender , struct lxc_log_event *);
cb8c5720 CLG	95
	96	/*
	97	* appenders can be stacked
	98	*/
eba1ae76	99	struct lxc_log_appender *next;
cb8c5720 CLG	100	};
	101
	102	/* log category object */
	103	struct lxc_log_category {
eba1ae76 CB	104	const char *name;
	105	int priority;
	106	struct lxc_log_appender *appender;
	107	const struct lxc_log_category *parent;
cb8c5720 CLG	108	};
cb8c5720 CLG	109
858377e4 SH	110	#ifndef NO_LXC_CONF
	111	extern int lxc_log_use_global_fd;
	112	#endif
	113
cb8c5720 CLG	114	/*
	115	* Returns true if the chained priority is equal to or higher than
	116	* given priority.
	117	*/
eba1ae76 CB	118	static inline int lxc_log_priority_is_enabled(const struct lxc_log_category *category,
eba1ae76 CB	119	int priority)
cb8c5720	120	{
eba1ae76	121	while (category->priority == LXC_LOG_LEVEL_NOTSET && category->parent)
cb8c5720 CLG	122	category = category->parent;
cb8c5720 CLG	123
858377e4 SH	124	int cmp_prio = category->priority;
	125	#ifndef NO_LXC_CONF
	126	if (!lxc_log_use_global_fd && current_config &&
eba1ae76	127	current_config->loglevel != LXC_LOG_LEVEL_NOTSET)
858377e4 SH	128	cmp_prio = current_config->loglevel;
	129	#endif
	130
	131	return priority >= cmp_prio;
cb8c5720 CLG	132	}
	133
	134	/*
	135	* converts a priority to a literal string
	136	*/
eba1ae76	137	static inline const char *lxc_log_priority_to_string(int priority)
cb8c5720 CLG	138	{
cb8c5720 CLG	139	switch (priority) {
eba1ae76 CB	140	case LXC_LOG_LEVEL_TRACE:
	141	return "TRACE";
	142	case LXC_LOG_LEVEL_DEBUG:
	143	return "DEBUG";
	144	case LXC_LOG_LEVEL_INFO:
	145	return "INFO";
	146	case LXC_LOG_LEVEL_NOTICE:
	147	return "NOTICE";
	148	case LXC_LOG_LEVEL_WARN:
	149	return "WARN";
	150	case LXC_LOG_LEVEL_ERROR:
	151	return "ERROR";
	152	case LXC_LOG_LEVEL_CRIT:
	153	return "CRIT";
	154	case LXC_LOG_LEVEL_ALERT:
	155	return "ALERT";
	156	case LXC_LOG_LEVEL_FATAL:
	157	return "FATAL";
cb8c5720	158	}
eba1ae76 CB	159
eba1ae76 CB	160	return "NOTSET";
cb8c5720	161	}
76d0127f	162
eba1ae76	163	static inline const char *lxc_syslog_priority_to_string(int priority)
76d0127f CB	164	{
76d0127f CB	165	switch (priority) {
eba1ae76 CB	166	case LOG_DAEMON:
	167	return "daemon";
	168	case LOG_LOCAL0:
	169	return "local0";
	170	case LOG_LOCAL1:
	171	return "local1";
	172	case LOG_LOCAL2:
	173	return "local2";
	174	case LOG_LOCAL3:
	175	return "local3";
	176	case LOG_LOCAL4:
	177	return "local4";
	178	case LOG_LOCAL5:
	179	return "local5";
	180	case LOG_LOCAL6:
	181	return "local6";
	182	case LOG_LOCAL7:
	183	return "local7";
76d0127f	184	}
eba1ae76 CB	185
eba1ae76 CB	186	return "NOTSET";
76d0127f CB	187	}
76d0127f CB	188
cb8c5720 CLG	189	/*
	190	* converts a literal priority to an int
	191	*/
eba1ae76	192	static inline int lxc_log_priority_to_int(const char *name)
cb8c5720	193	{
eba1ae76 CB	194	if (strcasecmp("TRACE", name) == 0)
	195	return LXC_LOG_LEVEL_TRACE;
	196	if (strcasecmp("DEBUG", name) == 0)
	197	return LXC_LOG_LEVEL_DEBUG;
	198	if (strcasecmp("INFO", name) == 0)
	199	return LXC_LOG_LEVEL_INFO;
	200	if (strcasecmp("NOTICE", name) == 0)
	201	return LXC_LOG_LEVEL_NOTICE;
	202	if (strcasecmp("WARN", name) == 0)
	203	return LXC_LOG_LEVEL_WARN;
	204	if (strcasecmp("ERROR", name) == 0)
	205	return LXC_LOG_LEVEL_ERROR;
	206	if (strcasecmp("CRIT", name) == 0)
	207	return LXC_LOG_LEVEL_CRIT;
	208	if (strcasecmp("ALERT", name) == 0)
	209	return LXC_LOG_LEVEL_ALERT;
	210	if (strcasecmp("FATAL", name) == 0)
	211	return LXC_LOG_LEVEL_FATAL;
4b73005c CB	212
4b73005c CB	213	return LXC_LOG_LEVEL_NOTSET;
cb8c5720 CLG	214	}
cb8c5720 CLG	215
eba1ae76	216	static inline int lxc_syslog_priority_to_int(const char *name)
76d0127f	217	{
eba1ae76 CB	218	if (strcasecmp("daemon", name) == 0)
	219	return LOG_DAEMON;
	220	if (strcasecmp("local0", name) == 0)
	221	return LOG_LOCAL0;
	222	if (strcasecmp("local1", name) == 0)
	223	return LOG_LOCAL1;
	224	if (strcasecmp("local2", name) == 0)
	225	return LOG_LOCAL2;
	226	if (strcasecmp("local3", name) == 0)
	227	return LOG_LOCAL3;
	228	if (strcasecmp("local4", name) == 0)
	229	return LOG_LOCAL4;
	230	if (strcasecmp("local5", name) == 0)
	231	return LOG_LOCAL5;
	232	if (strcasecmp("local6", name) == 0)
	233	return LOG_LOCAL6;
	234	if (strcasecmp("local7", name) == 0)
	235	return LOG_LOCAL7;
76d0127f CB	236
	237	return -EINVAL;
	238	}
	239
eba1ae76 CB	240	static inline void __lxc_log_append(const struct lxc_log_appender *appender,
eba1ae76 CB	241	struct lxc_log_event *event)
cb8c5720	242	{
eba1ae76 CB	243	va_list va;
eba1ae76 CB	244	va_list *va_keep = event->vap;
5fd8380b	245
cb8c5720	246	while (appender) {
5fd8380b MN	247	va_copy(va, *va_keep);
5fd8380b MN	248	event->vap = &va;
cb8c5720 CLG	249	appender->append(appender, event);
cb8c5720 CLG	250	appender = appender->next;
5fd8380b	251	va_end(va);
cb8c5720 CLG	252	}
	253	}
	254
eba1ae76 CB	255	static inline void __lxc_log(const struct lxc_log_category *category,
eba1ae76 CB	256	struct lxc_log_event *event)
cb8c5720 CLG	257	{
	258	while (category) {
	259	__lxc_log_append(category->appender, event);
	260	category = category->parent;
	261	}
	262	}
	263
	264	/*
e6a19d26	265	* Helper macro to define log functions.
cb8c5720	266	*/
eba1ae76 CB	267	#define lxc_log_priority_define(acategory, LEVEL) \
	268	\
	269	ATTR_UNUSED __attribute__ ((format (printf, 2, 3))) \
	270	static inline void LXC_##LEVEL(struct lxc_log_locinfo , const char , ...); \
	271	\
4b73005c	272	ATTR_UNUSED static inline void LXC_##LEVEL(struct lxc_log_locinfo* locinfo, \
eba1ae76 CB	273	const char* format, ...) \
	274	{ \
	275	if (lxc_log_priority_is_enabled(acategory, LXC_LOG_LEVEL_##LEVEL)) { \
	276	va_list va_ref; \
b7051eb7	277	int saved_errno; \
eba1ae76 CB	278	struct lxc_log_event evt = { \
	279	.category = (acategory)->name, \
	280	.priority = LXC_LOG_LEVEL_##LEVEL, \
	281	.fmt = format, \
	282	.locinfo = locinfo \
	283	}; \
	284	\
	285	/* clock_gettime() is explicitly marked as MT-Safe \
	286	* without restrictions. So let's use it for our \
	287	* logging stamps. \
	288	*/ \
b7051eb7	289	saved_errno = errno; \
eba1ae76 CB	290	(void)clock_gettime(CLOCK_REALTIME, &evt.timestamp); \
	291	\
	292	va_start(va_ref, format); \
	293	evt.vap = &va_ref; \
	294	__lxc_log(acategory, &evt); \
	295	va_end(va_ref); \
b7051eb7	296	errno = saved_errno; \
eba1ae76	297	} \
cb8c5720 CLG	298	}
	299
	300	/*
	301	* Helper macro to define and use static categories.
	302	*/
	303	#define lxc_log_category_define(name, parent) \
	304	extern struct lxc_log_category lxc_log_category_##parent; \
	305	struct lxc_log_category lxc_log_category_##name = { \
	306	#name, \
eba1ae76	307	LXC_LOG_LEVEL_NOTSET, \
cb8c5720 CLG	308	NULL, \
	309	&lxc_log_category_##parent \
	310	};
	311
	312	#define lxc_log_define(name, parent) \
	313	lxc_log_category_define(name, parent) \
	314	\
	315	lxc_log_priority_define(&lxc_log_category_##name, TRACE) \
	316	lxc_log_priority_define(&lxc_log_category_##name, DEBUG) \
	317	lxc_log_priority_define(&lxc_log_category_##name, INFO) \
	318	lxc_log_priority_define(&lxc_log_category_##name, NOTICE) \
	319	lxc_log_priority_define(&lxc_log_category_##name, WARN) \
	320	lxc_log_priority_define(&lxc_log_category_##name, ERROR) \
	321	lxc_log_priority_define(&lxc_log_category_##name, CRIT) \
	322	lxc_log_priority_define(&lxc_log_category_##name, ALERT) \
	323	lxc_log_priority_define(&lxc_log_category_##name, FATAL)
	324
	325	#define lxc_log_category_priority(name) \
	326	(lxc_log_priority_to_string(lxc_log_category_##name.priority))
	327
9d465140	328	/*
	329	* Helper macro to define errno string.
	330	*/
607e3fca CB	331	#if HAVE_STRERROR_R
	332	#ifndef HAVE_DECL_STRERROR_R
	333	#ifdef STRERROR_R_CHAR_P
	334	char strerror_r(int errnum, char buf, size_t buflen);
	335	#else
	336	int strerror_r(int errnum, char *buf, size_t buflen);
	337	#endif
	338	#endif
	339
	340	#ifdef STRERROR_R_CHAR_P
	341	#define lxc_log_strerror_r \
52539fcc	342	char errno_buf[PATH_MAX / 2] = {"Failed to get errno string"}; \
607e3fca CB	343	char *ptr = NULL; \
607e3fca CB	344	{ \
a7547c5c	345	int __saved_errno = errno; \
607e3fca	346	ptr = strerror_r(errno, errno_buf, sizeof(errno_buf)); \
a7547c5c	347	errno = __saved_errno; \
607e3fca CB	348	if (!ptr) \
	349	ptr = errno_buf; \
	350	}
	351	#else
	352	#define lxc_log_strerror_r \
52539fcc	353	char errno_buf[PATH_MAX / 2] = {"Failed to get errno string"}; \
607e3fca CB	354	char *ptr = errno_buf; \
607e3fca CB	355	{ \
a7547c5c	356	int __saved_errno = errno; \
607e3fca	357	(void)strerror_r(errno, errno_buf, sizeof(errno_buf)); \
a7547c5c	358	errno = __saved_errno; \
607e3fca CB	359	}
607e3fca CB	360	#endif
d6457631 CB	361	#elif ENFORCE_THREAD_SAFETY
d6457631 CB	362	#error ENFORCE_THREAD_SAFETY was set but cannot be guaranteed
9d465140	363	#else
52539fcc CB	364	#define lxc_log_strerror_r \
	365	char *ptr = NULL; \
	366	{ \
	367	ptr = strerror(errno); \
607e3fca	368	}
9d465140	369	#endif
9d465140	370
cb8c5720 CLG	371	/*
	372	* top categories
	373	*/
cb8c5720 CLG	374	#define TRACE(format, ...) do { \
	375	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	376	LXC_TRACE(&locinfo, format, ##__VA_ARGS__); \
	377	} while (0)
	378
	379	#define DEBUG(format, ...) do { \
	380	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	381	LXC_DEBUG(&locinfo, format, ##__VA_ARGS__); \
	382	} while (0)
	383
	384	#define INFO(format, ...) do { \
	385	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	386	LXC_INFO(&locinfo, format, ##__VA_ARGS__); \
	387	} while (0)
	388
	389	#define NOTICE(format, ...) do { \
	390	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	391	LXC_NOTICE(&locinfo, format, ##__VA_ARGS__); \
	392	} while (0)
	393
	394	#define WARN(format, ...) do { \
	395	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	396	LXC_WARN(&locinfo, format, ##__VA_ARGS__); \
	397	} while (0)
	398
	399	#define ERROR(format, ...) do { \
	400	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	401	LXC_ERROR(&locinfo, format, ##__VA_ARGS__); \
	402	} while (0)
	403
	404	#define CRIT(format, ...) do { \
	405	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	406	LXC_CRIT(&locinfo, format, ##__VA_ARGS__); \
	407	} while (0)
	408
	409	#define ALERT(format, ...) do { \
	410	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	411	LXC_ALERT(&locinfo, format, ##__VA_ARGS__); \
	412	} while (0)
	413
	414	#define FATAL(format, ...) do { \
	415	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	416	LXC_FATAL(&locinfo, format, ##__VA_ARGS__); \
	417	} while (0)
	418
a1d652c2 RK	419	#if HAVE_M_FORMAT
a1d652c2 RK	420	#define SYSTRACE(format, ...) \
9a719a64	421	TRACE("%m - " format, ##__VA_ARGS__)
a1d652c2	422	#else
9d465140	423	#define SYSTRACE(format, ...) \
	424	do { \
	425	lxc_log_strerror_r; \
	426	TRACE("%s - " format, ptr, ##__VA_ARGS__); \
	427	} while (0)
a1d652c2	428	#endif
9d465140	429
a1d652c2 RK	430	#if HAVE_M_FORMAT
	431	#define SYSDEBUG(format, ...) \
	432	DEBUG("%m - " format, ##__VA_ARGS__)
	433	#else
9d465140	434	#define SYSDEBUG(format, ...) \
	435	do { \
	436	lxc_log_strerror_r; \
	437	DEBUG("%s - " format, ptr, ##__VA_ARGS__); \
	438	} while (0)
a1d652c2 RK	439	#endif
a1d652c2 RK	440
9d465140	441
a1d652c2 RK	442	#if HAVE_M_FORMAT
	443	#define SYSINFO(format, ...) \
	444	INFO("%m - " format, ##__VA_ARGS__)
	445	#else
9d465140	446	#define SYSINFO(format, ...) \
	447	do { \
	448	lxc_log_strerror_r; \
	449	INFO("%s - " format, ptr, ##__VA_ARGS__); \
	450	} while (0)
a1d652c2	451	#endif
9d465140	452
a1d652c2 RK	453	#if HAVE_M_FORMAT
	454	#define SYSNOTICE(format, ...) \
	455	NOTICE("%m - " format, ##__VA_ARGS__)
	456	#else
9d465140	457	#define SYSNOTICE(format, ...) \
	458	do { \
	459	lxc_log_strerror_r; \
	460	NOTICE("%s - " format, ptr, ##__VA_ARGS__); \
	461	} while (0)
a1d652c2	462	#endif
9d465140	463
a1d652c2 RK	464	#if HAVE_M_FORMAT
	465	#define SYSWARN(format, ...) \
	466	WARN("%m - " format, ##__VA_ARGS__)
	467	#else
9d465140	468	#define SYSWARN(format, ...) \
	469	do { \
	470	lxc_log_strerror_r; \
	471	WARN("%s - " format, ptr, ##__VA_ARGS__); \
	472	} while (0)
a1d652c2	473	#endif
9d465140	474
a1d652c2 RK	475	#if HAVE_M_FORMAT
	476	#define SYSERROR(format, ...) \
	477	ERROR("%m - " format, ##__VA_ARGS__)
	478	#else
9d465140	479	#define SYSERROR(format, ...) \
	480	do { \
	481	lxc_log_strerror_r; \
	482	ERROR("%s - " format, ptr, ##__VA_ARGS__); \
	483	} while (0)
a1d652c2	484	#endif
cb8c5720	485
a1d652c2 RK	486	#if HAVE_M_FORMAT
	487	#define CMD_SYSERROR(format, ...) \
	488	fprintf(stderr, "%m - " format, ##__VA_ARGS__)
	489	#else
bb9623e7 CB	490	#define CMD_SYSERROR(format, ...) \
	491	do { \
	492	lxc_log_strerror_r; \
	493	fprintf(stderr, "%s - " format, ptr, ##__VA_ARGS__); \
	494	} while (0)
a1d652c2	495	#endif
bb9623e7	496
a1d652c2 RK	497	#if HAVE_M_FORMAT
	498	#define CMD_SYSINFO(format, ...) \
	499	printf("%m - " format, ##__VA_ARGS__)
	500	#else
20029ee3 CB	501	#define CMD_SYSINFO(format, ...) \
	502	do { \
	503	lxc_log_strerror_r; \
	504	printf("%s - " format, ptr, ##__VA_ARGS__); \
	505	} while (0)
a1d652c2	506	#endif
20029ee3	507
641c20a6 CLG	508	extern int lxc_log_fd;
641c20a6 CLG	509
64c57ea1 BD	510	extern int lxc_log_syslog(int facility);
64c57ea1 BD	511	extern void lxc_log_enable_syslog(void);
858377e4	512	extern int lxc_log_set_level(int *dest, int level);
ab1bf971	513	extern int lxc_log_get_level(void);
fabf7361	514	extern bool lxc_log_has_valid_level(void);
8273ba47	515	extern int lxc_log_set_file(int fd, const char fname);
	516	extern const char *lxc_log_get_file(void);
	517	extern void lxc_log_set_prefix(const char *prefix);
ab1bf971	518	extern const char *lxc_log_get_prefix(void);
246736be	519	extern void lxc_log_options_no_override(void);
0ad19a3f	520	#endif