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

/*
 * lxc: linux Container library
 *
 * (C) Copyright IBM Corp. 2007, 2008
 *
 * Authors:
 * Daniel Lezcano <dlezcano at fr.ibm.com>
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
#ifndef _log_h
#define _log_h

#include <stdarg.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.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	512

/* predefined priorities. */
enum {
	LXC_LOG_PRIORITY_TRACE,
	LXC_LOG_PRIORITY_DEBUG,
	LXC_LOG_PRIORITY_INFO,
	LXC_LOG_PRIORITY_NOTICE,
	LXC_LOG_PRIORITY_WARN,
	LXC_LOG_PRIORITY_ERROR,
	LXC_LOG_PRIORITY_CRIT,
	LXC_LOG_PRIORITY_ALERT,
	LXC_LOG_PRIORITY_FATAL,
	LXC_LOG_PRIORITY_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 timeval		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;
};

/*
 * 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_PRIORITY_NOTSET &&
	       category->parent)
		category = category->parent;

	return priority >= category->priority;
}

/*
 * converts a priority to a literal string
 */
static inline const char* lxc_log_priority_to_string(int priority)
{
	switch (priority) {
	case LXC_LOG_PRIORITY_TRACE:	return "TRACE";
	case LXC_LOG_PRIORITY_DEBUG:	return "DEBUG";
	case LXC_LOG_PRIORITY_INFO:	return "INFO";
	case LXC_LOG_PRIORITY_NOTICE:	return "NOTICE";
	case LXC_LOG_PRIORITY_WARN:	return "WARN";
	case LXC_LOG_PRIORITY_ERROR:	return "ERROR";
	case LXC_LOG_PRIORITY_CRIT:	return "CRIT";
	case LXC_LOG_PRIORITY_ALERT:	return "ALERT";
	case LXC_LOG_PRIORITY_FATAL:	return "FATAL";
	default:
		return "NOTSET";
	}
}
/*
 * converts a literal priority to an int
 */
static inline int lxc_log_priority_to_int(const char* name)
{
	if (!strcasecmp("TRACE",  name)) return LXC_LOG_PRIORITY_TRACE;
	if (!strcasecmp("DEBUG",  name)) return LXC_LOG_PRIORITY_DEBUG;
	if (!strcasecmp("INFO",   name)) return LXC_LOG_PRIORITY_INFO;
	if (!strcasecmp("NOTICE", name)) return LXC_LOG_PRIORITY_NOTICE;
	if (!strcasecmp("WARN",   name)) return LXC_LOG_PRIORITY_WARN;
	if (!strcasecmp("ERROR",  name)) return LXC_LOG_PRIORITY_ERROR;
	if (!strcasecmp("CRIT",   name)) return LXC_LOG_PRIORITY_CRIT;
	if (!strcasecmp("ALERT",  name)) return LXC_LOG_PRIORITY_ALERT;
	if (!strcasecmp("FATAL",  name)) return LXC_LOG_PRIORITY_FATAL;

	return LXC_LOG_PRIORITY_NOTSET;
}

static inline void
__lxc_log_append(const struct lxc_log_appender *appender,
		struct lxc_log_event* event)
{
	va_list va, *va_keep;
	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 fonctions.
 */
#define lxc_log_priority_define(acategory, PRIORITY)			\
									\
static inline void LXC_##PRIORITY(struct lxc_log_locinfo *,		\
	const char *, ...) __attribute__ ((format (printf, 2, 3)));	\
									\
static inline void LXC_##PRIORITY(struct lxc_log_locinfo* locinfo,	\
				  const char* format, ...)		\
{									\
	if (lxc_log_priority_is_enabled(acategory, 			\
					LXC_LOG_PRIORITY_##PRIORITY)) {	\
		struct lxc_log_event evt = {				\
			.category	= (acategory)->name,		\
			.priority	= LXC_LOG_PRIORITY_##PRIORITY,	\
			.fmt		= format,			\
			.locinfo	= locinfo			\
		};							\
		va_list va_ref;						\
									\
		gettimeofday(&evt.timestamp, NULL);			\
									\
		va_start(va_ref, format);				\
		evt.vap = &va_ref;					\
		__lxc_log(acategory, &evt);				\
		va_end(va_ref);						\
	}								\
}

/*
 * 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_PRIORITY_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))

/*
 * top categories
 */
extern struct lxc_log_category lxc_log_category_lxc;

#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)


#define SYSERROR(format, ...) do {				    	\
	ERROR("%s - " format, strerror(errno), ##__VA_ARGS__);		\
} while (0)

extern int lxc_log_fd;

extern int lxc_log_init(const char *file, const char *priority,
			const char *prefix, int quiet);

extern void lxc_log_setprefix(const char *a_prefix);
#endif
Commit	Line	Data
e0b4037d DL	1	/*
	2	* lxc: linux Container library
	3	*
	4	* (C) Copyright IBM Corp. 2007, 2008
	5	*
	6	* Authors:
	7	* Daniel Lezcano <dlezcano at fr.ibm.com>
	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
	22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	23	*/
0ad19a3f	24	#ifndef _log_h
	25	#define _log_h
	26
cb8c5720 CLG	27	#include <stdarg.h>
	28	#include <stdio.h>
	29	#include <sys/time.h>
	30	#include <string.h>
	31
eabbb2f0 MN	32	#ifndef O_CLOEXEC
	33	#define O_CLOEXEC 02000000
	34	#endif
	35
	36	#ifndef F_DUPFD_CLOEXEC
	37	#define F_DUPFD_CLOEXEC 1030
	38	#endif
	39
	40	#define LXC_LOG_PREFIX_SIZE 32
	41	#define LXC_LOG_BUFFER_SIZE 512
	42
cb8c5720 CLG	43	/* predefined priorities. */
	44	enum {
	45	LXC_LOG_PRIORITY_TRACE,
	46	LXC_LOG_PRIORITY_DEBUG,
	47	LXC_LOG_PRIORITY_INFO,
	48	LXC_LOG_PRIORITY_NOTICE,
	49	LXC_LOG_PRIORITY_WARN,
	50	LXC_LOG_PRIORITY_ERROR,
	51	LXC_LOG_PRIORITY_CRIT,
	52	LXC_LOG_PRIORITY_ALERT,
	53	LXC_LOG_PRIORITY_FATAL,
	54	LXC_LOG_PRIORITY_NOTSET,
	55	};
	56
	57	/* location information of the logging event */
	58	struct lxc_log_locinfo {
	59	const char *file;
	60	const char *func;
	61	int line;
	62	};
	63
	64	#define LXC_LOG_LOCINFO_INIT \
	65	{ .file = __FILE__, .func = __func__, .line = __LINE__ }
	66
	67	/* brief logging event object */
	68	struct lxc_log_event {
	69	const char* category;
	70	int priority;
	71	struct timeval timestamp;
	72	struct lxc_log_locinfo *locinfo;
	73	const char *fmt;
5fd8380b	74	va_list *vap;
cb8c5720 CLG	75	};
	76
	77	/* log appender object */
	78	struct lxc_log_appender {
	79	const char* name;
5fd8380b	80	int (append)(const struct lxc_log_appender , struct lxc_log_event *);
cb8c5720 CLG	81
	82	/*
	83	* appenders can be stacked
	84	*/
	85	struct lxc_log_appender *next;
	86	};
	87
	88	/* log category object */
	89	struct lxc_log_category {
	90	const char *name;
	91	int priority;
	92	struct lxc_log_appender *appender;
	93	const struct lxc_log_category *parent;
	94	};
	95
	96	/*
	97	* Returns true if the chained priority is equal to or higher than
	98	* given priority.
	99	*/
	100	static inline int
	101	lxc_log_priority_is_enabled(const struct lxc_log_category* category,
	102	int priority)
	103	{
	104	while (category->priority == LXC_LOG_PRIORITY_NOTSET &&
	105	category->parent)
	106	category = category->parent;
	107
	108	return priority >= category->priority;
	109	}
	110
	111	/*
	112	* converts a priority to a literal string
	113	*/
	114	static inline const char* lxc_log_priority_to_string(int priority)
	115	{
	116	switch (priority) {
	117	case LXC_LOG_PRIORITY_TRACE: return "TRACE";
	118	case LXC_LOG_PRIORITY_DEBUG: return "DEBUG";
	119	case LXC_LOG_PRIORITY_INFO: return "INFO";
	120	case LXC_LOG_PRIORITY_NOTICE: return "NOTICE";
	121	case LXC_LOG_PRIORITY_WARN: return "WARN";
	122	case LXC_LOG_PRIORITY_ERROR: return "ERROR";
	123	case LXC_LOG_PRIORITY_CRIT: return "CRIT";
	124	case LXC_LOG_PRIORITY_ALERT: return "ALERT";
	125	case LXC_LOG_PRIORITY_FATAL: return "FATAL";
	126	default:
	127	return "NOTSET";
	128	}
	129	}
	130	/*
	131	* converts a literal priority to an int
	132	*/
	133	static inline int lxc_log_priority_to_int(const char* name)
	134	{
	135	if (!strcasecmp("TRACE", name)) return LXC_LOG_PRIORITY_TRACE;
	136	if (!strcasecmp("DEBUG", name)) return LXC_LOG_PRIORITY_DEBUG;
	137	if (!strcasecmp("INFO", name)) return LXC_LOG_PRIORITY_INFO;
	138	if (!strcasecmp("NOTICE", name)) return LXC_LOG_PRIORITY_NOTICE;
	139	if (!strcasecmp("WARN", name)) return LXC_LOG_PRIORITY_WARN;
	140	if (!strcasecmp("ERROR", name)) return LXC_LOG_PRIORITY_ERROR;
	141	if (!strcasecmp("CRIT", name)) return LXC_LOG_PRIORITY_CRIT;
	142	if (!strcasecmp("ALERT", name)) return LXC_LOG_PRIORITY_ALERT;
	143	if (!strcasecmp("FATAL", name)) return LXC_LOG_PRIORITY_FATAL;
	144
145	return LXC_LOG_PRIORITY_NOTSET;
146	}
147
148	static inline void
149	__lxc_log_append(const struct lxc_log_appender *appender,
5fd8380b	150	struct lxc_log_event* event)
cb8c5720	151	{
5fd8380b MN	152	va_list va, *va_keep;
	153	va_keep = event->vap;
	154
cb8c5720	155	while (appender) {
5fd8380b MN	156	va_copy(va, *va_keep);
5fd8380b MN	157	event->vap = &va;
cb8c5720 CLG	158	appender->append(appender, event);
cb8c5720 CLG	159	appender = appender->next;
5fd8380b	160	va_end(va);
cb8c5720 CLG	161	}
	162	}
	163
	164	static inline void
	165	__lxc_log(const struct lxc_log_category* category,
5fd8380b	166	struct lxc_log_event* event)
cb8c5720 CLG	167	{
	168	while (category) {
	169	__lxc_log_append(category->appender, event);
	170	category = category->parent;
	171	}
	172	}
	173
	174	/*
	175	* Helper macro to define log fonctions.
	176	*/
	177	#define lxc_log_priority_define(acategory, PRIORITY) \
	178	\
	179	static inline void LXC_##PRIORITY(struct lxc_log_locinfo *, \
	180	const char *, ...) __attribute__ ((format (printf, 2, 3))); \
	181	\
	182	static inline void LXC_##PRIORITY(struct lxc_log_locinfo* locinfo, \
	183	const char* format, ...) \
	184	{ \
	185	if (lxc_log_priority_is_enabled(acategory, \
	186	LXC_LOG_PRIORITY_##PRIORITY)) { \
	187	struct lxc_log_event evt = { \
	188	.category = (acategory)->name, \
	189	.priority = LXC_LOG_PRIORITY_##PRIORITY, \
	190	.fmt = format, \
	191	.locinfo = locinfo \
	192	}; \
5fd8380b	193	va_list va_ref; \
cb8c5720 CLG	194	\
	195	gettimeofday(&evt.timestamp, NULL); \
	196	\
5fd8380b MN	197	va_start(va_ref, format); \
5fd8380b MN	198	evt.vap = &va_ref; \
cb8c5720	199	__lxc_log(acategory, &evt); \
5fd8380b	200	va_end(va_ref); \
cb8c5720 CLG	201	} \
	202	}
	203
	204	/*
	205	* Helper macro to define and use static categories.
	206	*/
	207	#define lxc_log_category_define(name, parent) \
	208	extern struct lxc_log_category lxc_log_category_##parent; \
	209	struct lxc_log_category lxc_log_category_##name = { \
	210	#name, \
	211	LXC_LOG_PRIORITY_NOTSET, \
	212	NULL, \
	213	&lxc_log_category_##parent \
	214	};
	215
	216	#define lxc_log_define(name, parent) \
	217	lxc_log_category_define(name, parent) \
	218	\
	219	lxc_log_priority_define(&lxc_log_category_##name, TRACE) \
	220	lxc_log_priority_define(&lxc_log_category_##name, DEBUG) \
	221	lxc_log_priority_define(&lxc_log_category_##name, INFO) \
	222	lxc_log_priority_define(&lxc_log_category_##name, NOTICE) \
	223	lxc_log_priority_define(&lxc_log_category_##name, WARN) \
	224	lxc_log_priority_define(&lxc_log_category_##name, ERROR) \
	225	lxc_log_priority_define(&lxc_log_category_##name, CRIT) \
	226	lxc_log_priority_define(&lxc_log_category_##name, ALERT) \
	227	lxc_log_priority_define(&lxc_log_category_##name, FATAL)
	228
	229	#define lxc_log_category_priority(name) \
	230	(lxc_log_priority_to_string(lxc_log_category_##name.priority))
	231
	232	/*
	233	* top categories
	234	*/
	235	extern struct lxc_log_category lxc_log_category_lxc;
	236
	237	#define TRACE(format, ...) do { \
	238	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	239	LXC_TRACE(&locinfo, format, ##__VA_ARGS__); \
	240	} while (0)
	241
	242	#define DEBUG(format, ...) do { \
	243	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	244	LXC_DEBUG(&locinfo, format, ##__VA_ARGS__); \
	245	} while (0)
	246
	247	#define INFO(format, ...) do { \
	248	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	249	LXC_INFO(&locinfo, format, ##__VA_ARGS__); \
	250	} while (0)
	251
	252	#define NOTICE(format, ...) do { \
	253	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	254	LXC_NOTICE(&locinfo, format, ##__VA_ARGS__); \
	255	} while (0)
	256
	257	#define WARN(format, ...) do { \
	258	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	259	LXC_WARN(&locinfo, format, ##__VA_ARGS__); \
	260	} while (0)
	261
	262	#define ERROR(format, ...) do { \
	263	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
	264	LXC_ERROR(&locinfo, format, ##__VA_ARGS__); \
265	} while (0)
266
267	#define CRIT(format, ...) do { \
268	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
269	LXC_CRIT(&locinfo, format, ##__VA_ARGS__); \
270	} while (0)
271
272	#define ALERT(format, ...) do { \
273	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
274	LXC_ALERT(&locinfo, format, ##__VA_ARGS__); \
275	} while (0)
276
277	#define FATAL(format, ...) do { \
278	struct lxc_log_locinfo locinfo = LXC_LOG_LOCINFO_INIT; \
279	LXC_FATAL(&locinfo, format, ##__VA_ARGS__); \
280	} while (0)
281
282
283
284	#define SYSERROR(format, ...) do { \
69c3910d	285	ERROR("%s - " format, strerror(errno), ##__VA_ARGS__); \
cb8c5720 CLG	286	} while (0)
cb8c5720 CLG	287
641c20a6 CLG	288	extern int lxc_log_fd;
641c20a6 CLG	289
51cab631	290	extern int lxc_log_init(const char file, const char priority,
441e4963	291	const char *prefix, int quiet);
641c20a6 CLG	292
641c20a6 CLG	293	extern void lxc_log_setprefix(const char *a_prefix);
0ad19a3f	294	#endif