[systemd.git] / src / basic / log.h

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

#pragma once

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd 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.

  systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdbool.h>
#include <stdarg.h>
#include <stdlib.h>
#include <syslog.h>
#include <sys/signalfd.h>
#include <errno.h>

#include "sd-id128.h"
#include "macro.h"

typedef enum LogTarget{
        LOG_TARGET_CONSOLE,
        LOG_TARGET_CONSOLE_PREFIXED,
        LOG_TARGET_KMSG,
        LOG_TARGET_JOURNAL,
        LOG_TARGET_JOURNAL_OR_KMSG,
        LOG_TARGET_SYSLOG,
        LOG_TARGET_SYSLOG_OR_KMSG,
        LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG otherwise */
        LOG_TARGET_SAFE, /* console if stderr is tty, KMSG otherwise */
        LOG_TARGET_NULL,
        _LOG_TARGET_MAX,
        _LOG_TARGET_INVALID = -1
}  LogTarget;

void log_set_target(LogTarget target);
void log_set_max_level(int level);
void log_set_facility(int facility);

int log_set_target_from_string(const char *e);
int log_set_max_level_from_string(const char *e);

void log_show_color(bool b);
bool log_get_show_color(void) _pure_;
void log_show_location(bool b);
bool log_get_show_location(void) _pure_;

int log_show_color_from_string(const char *e);
int log_show_location_from_string(const char *e);

LogTarget log_get_target(void) _pure_;
int log_get_max_level(void) _pure_;

int log_open(void);
void log_close(void);
void log_forget_fds(void);

void log_close_syslog(void);
void log_close_journal(void);
void log_close_kmsg(void);
void log_close_console(void);

void log_parse_environment(void);

int log_internal(
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *format, ...) _printf_(6,7);

int log_internalv(
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *format,
                va_list ap) _printf_(6,0);

int log_object_internal(
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *object_field,
                const char *object,
                const char *format, ...) _printf_(8,9);

int log_object_internalv(
                int level,
                int error,
                const char*file,
                int line,
                const char *func,
                const char *object_field,
                const char *object,
                const char *format,
                va_list ap) _printf_(8,0);

int log_struct_internal(
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *format, ...) _printf_(6,0) _sentinel_;

int log_oom_internal(
                const char *file,
                int line,
                const char *func);

/* This modifies the buffer passed! */
int log_dump_internal(
                int level,
                int error,
                const char *file,
                int line,
                const char *func,
                char *buffer);

/* Logging for various assertions */
noreturn void log_assert_failed(
                const char *text,
                const char *file,
                int line,
                const char *func);

noreturn void log_assert_failed_unreachable(
                const char *text,
                const char *file,
                int line,
                const char *func);

void log_assert_failed_return(
                const char *text,
                const char *file,
                int line,
                const char *func);

/* Logging with level */
#define log_full_errno(level, error, ...)                               \
        ({                                                              \
                int _level = (level), _e = (error);                     \
                (log_get_max_level() >= LOG_PRI(_level))                \
                        ? log_internal(_level, _e, __FILE__, __LINE__, __func__, __VA_ARGS__) \
                        : -abs(_e);                                     \
        })

#define log_full(level, ...) log_full_errno(level, 0, __VA_ARGS__)

/* Normal logging */
#define log_debug(...)     log_full(LOG_DEBUG,   __VA_ARGS__)
#define log_info(...)      log_full(LOG_INFO,    __VA_ARGS__)
#define log_notice(...)    log_full(LOG_NOTICE,  __VA_ARGS__)
#define log_warning(...)   log_full(LOG_WARNING, __VA_ARGS__)
#define log_error(...)     log_full(LOG_ERR,     __VA_ARGS__)
#define log_emergency(...) log_full(getpid() == 1 ? LOG_EMERG : LOG_ERR, __VA_ARGS__)

/* Logging triggered by an errno-like error */
#define log_debug_errno(error, ...)     log_full_errno(LOG_DEBUG,   error, __VA_ARGS__)
#define log_info_errno(error, ...)      log_full_errno(LOG_INFO,    error, __VA_ARGS__)
#define log_notice_errno(error, ...)    log_full_errno(LOG_NOTICE,  error, __VA_ARGS__)
#define log_warning_errno(error, ...)   log_full_errno(LOG_WARNING, error, __VA_ARGS__)
#define log_error_errno(error, ...)     log_full_errno(LOG_ERR,     error, __VA_ARGS__)
#define log_emergency_errno(error, ...) log_full_errno(getpid() == 1 ? LOG_EMERG : LOG_ERR, error, __VA_ARGS__)

#ifdef LOG_TRACE
#  define log_trace(...) log_debug(__VA_ARGS__)
#else
#  define log_trace(...) do {} while(0)
#endif

/* Structured logging */
#define log_struct(level, ...) log_struct_internal(level, 0, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define log_struct_errno(level, error, ...) log_struct_internal(level, error, __FILE__, __LINE__, __func__, __VA_ARGS__)

/* This modifies the buffer passed! */
#define log_dump(level, buffer) log_dump_internal(level, 0, __FILE__, __LINE__, __func__, buffer)

#define log_oom() log_oom_internal(__FILE__, __LINE__, __func__)

bool log_on_console(void) _pure_;

const char *log_target_to_string(LogTarget target) _const_;
LogTarget log_target_from_string(const char *s) _pure_;

/* Helpers to prepare various fields for structured logging */
#define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
#define LOG_MESSAGE_ID(x) "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(x)

void log_received_signal(int level, const struct signalfd_siginfo *si);

void log_set_upgrade_syslog_to_journal(bool b);

int log_syntax_internal(
                const char *unit,
                int level,
                const char *config_file,
                unsigned config_line,
                int error,
                const char *file,
                int line,
                const char *func,
                const char *format, ...) _printf_(9, 10);

#define log_syntax(unit, level, config_file, config_line, error, ...)   \
        ({                                                              \
                int _level = (level), _e = (error);                     \
                (log_get_max_level() >= LOG_PRI(_level))                \
                        ? log_syntax_internal(unit, _level, config_file, config_line, _e, __FILE__, __LINE__, __func__, __VA_ARGS__) \
                        : -abs(_e);                                     \
        })

#define log_syntax_invalid_utf8(unit, level, config_file, config_line, rvalue) \
        ({                                                              \
                int _level = (level);                                   \
                if (log_get_max_level() >= LOG_PRI(_level)) {           \
                        _cleanup_free_ char *_p = NULL;                 \
                        _p = utf8_escape_invalid(rvalue);               \
                        log_syntax_internal(unit, _level, config_file, config_line, 0, __FILE__, __LINE__, __func__, \
                                            "String is not UTF-8 clean, ignoring assignment: %s", strna(_p)); \
                }                                                       \
                -EINVAL;                                                \
        })
Commit	Line	Data
663996b3 MS	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	#pragma once
	4
	5	/***
	6	This file is part of systemd.
	7
	8	Copyright 2010 Lennart Poettering
	9
	10	systemd is free software; you can redistribute it and/or modify it
	11	under the terms of the GNU Lesser General Public License as published by
	12	the Free Software Foundation; either version 2.1 of the License, or
	13	(at your option) any later version.
	14
	15	systemd is distributed in the hope that it will be useful, but
	16	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 License
	21	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	22	***/
	23
663996b3 MS	24	#include <stdbool.h>
663996b3 MS	25	#include <stdarg.h>
e3bff60a	26	#include <stdlib.h>
60f067b4 JS	27	#include <syslog.h>
60f067b4 JS	28	#include <sys/signalfd.h>
663996b3 MS	29	#include <errno.h>
663996b3 MS	30
663996b3	31	#include "sd-id128.h"
e3bff60a	32	#include "macro.h"
663996b3 MS	33
	34	typedef enum LogTarget{
	35	LOG_TARGET_CONSOLE,
e735f4d4	36	LOG_TARGET_CONSOLE_PREFIXED,
663996b3 MS	37	LOG_TARGET_KMSG,
	38	LOG_TARGET_JOURNAL,
	39	LOG_TARGET_JOURNAL_OR_KMSG,
	40	LOG_TARGET_SYSLOG,
	41	LOG_TARGET_SYSLOG_OR_KMSG,
	42	LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG otherwise */
	43	LOG_TARGET_SAFE, /* console if stderr is tty, KMSG otherwise */
	44	LOG_TARGET_NULL,
	45	_LOG_TARGET_MAX,
	46	_LOG_TARGET_INVALID = -1
	47	} LogTarget;
	48
	49	void log_set_target(LogTarget target);
	50	void log_set_max_level(int level);
	51	void log_set_facility(int facility);
	52
	53	int log_set_target_from_string(const char *e);
	54	int log_set_max_level_from_string(const char *e);
	55
	56	void log_show_color(bool b);
60f067b4	57	bool log_get_show_color(void) _pure_;
663996b3	58	void log_show_location(bool b);
60f067b4	59	bool log_get_show_location(void) _pure_;
663996b3 MS	60
	61	int log_show_color_from_string(const char *e);
	62	int log_show_location_from_string(const char *e);
	63
	64	LogTarget log_get_target(void) _pure_;
	65	int log_get_max_level(void) _pure_;
	66
	67	int log_open(void);
	68	void log_close(void);
	69	void log_forget_fds(void);
	70
	71	void log_close_syslog(void);
	72	void log_close_journal(void);
	73	void log_close_kmsg(void);
	74	void log_close_console(void);
	75
	76	void log_parse_environment(void);
	77
f47781d8	78	int log_internal(
663996b3	79	int level,
f47781d8 MP	80	int error,
f47781d8 MP	81	const char *file,
663996b3 MS	82	int line,
663996b3 MS	83	const char *func,
f47781d8	84	const char *format, ...) _printf_(6,7);
663996b3	85
f47781d8	86	int log_internalv(
663996b3	87	int level,
f47781d8 MP	88	int error,
f47781d8 MP	89	const char *file,
663996b3 MS	90	int line,
	91	const char *func,
	92	const char *format,
f47781d8	93	va_list ap) _printf_(6,0);
663996b3	94
f47781d8	95	int log_object_internal(
663996b3	96	int level,
f47781d8 MP	97	int error,
f47781d8 MP	98	const char *file,
663996b3 MS	99	int line,
663996b3 MS	100	const char *func,
f47781d8	101	const char *object_field,
663996b3	102	const char *object,
f47781d8	103	const char *format, ...) _printf_(8,9);
663996b3	104
f47781d8	105	int log_object_internalv(
663996b3	106	int level,
f47781d8	107	int error,
663996b3 MS	108	const char*file,
	109	int line,
	110	const char *func,
f47781d8	111	const char *object_field,
663996b3 MS	112	const char *object,
663996b3 MS	113	const char *format,
f47781d8	114	va_list ap) _printf_(8,0);
663996b3 MS	115
	116	int log_struct_internal(
	117	int level,
f47781d8	118	int error,
663996b3 MS	119	const char *file,
	120	int line,
	121	const char *func,
f47781d8	122	const char *format, ...) _printf_(6,0) _sentinel_;
663996b3 MS	123
	124	int log_oom_internal(
	125	const char *file,
	126	int line,
	127	const char *func);
	128
	129	/* This modifies the buffer passed! */
	130	int log_dump_internal(
	131	int level,
f47781d8 MP	132	int error,
f47781d8 MP	133	const char *file,
663996b3 MS	134	int line,
	135	const char *func,
	136	char *buffer);
	137
f47781d8	138	/* Logging for various assertions */
60f067b4 JS	139	noreturn void log_assert_failed(
	140	const char *text,
	141	const char *file,
	142	int line,
	143	const char *func);
	144
	145	noreturn void log_assert_failed_unreachable(
663996b3 MS	146	const char *text,
	147	const char *file,
	148	int line,
	149	const char *func);
	150
60f067b4	151	void log_assert_failed_return(
663996b3 MS	152	const char *text,
	153	const char *file,
	154	int line,
	155	const char *func);
	156
f47781d8	157	/* Logging with level */
e3bff60a MP	158	#define log_full_errno(level, error, ...) \
	159	({ \
	160	int _level = (level), _e = (error); \
	161	(log_get_max_level() >= LOG_PRI(_level)) \
	162	? log_internal(_level, _e, __FILE__, __LINE__, __func__, __VA_ARGS__) \
	163	: -abs(_e); \
f47781d8 MP	164	})
	165
	166	#define log_full(level, ...) log_full_errno(level, 0, __VA_ARGS__)
	167
	168	/* Normal logging */
	169	#define log_debug(...) log_full(LOG_DEBUG, __VA_ARGS__)
	170	#define log_info(...) log_full(LOG_INFO, __VA_ARGS__)
	171	#define log_notice(...) log_full(LOG_NOTICE, __VA_ARGS__)
	172	#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__)
	173	#define log_error(...) log_full(LOG_ERR, __VA_ARGS__)
	174	#define log_emergency(...) log_full(getpid() == 1 ? LOG_EMERG : LOG_ERR, __VA_ARGS__)
	175
	176	/* Logging triggered by an errno-like error */
	177	#define log_debug_errno(error, ...) log_full_errno(LOG_DEBUG, error, __VA_ARGS__)
	178	#define log_info_errno(error, ...) log_full_errno(LOG_INFO, error, __VA_ARGS__)
	179	#define log_notice_errno(error, ...) log_full_errno(LOG_NOTICE, error, __VA_ARGS__)
	180	#define log_warning_errno(error, ...) log_full_errno(LOG_WARNING, error, __VA_ARGS__)
	181	#define log_error_errno(error, ...) log_full_errno(LOG_ERR, error, __VA_ARGS__)
	182	#define log_emergency_errno(error, ...) log_full_errno(getpid() == 1 ? LOG_EMERG : LOG_ERR, error, __VA_ARGS__)
663996b3	183
5eef597e MP	184	#ifdef LOG_TRACE
	185	# define log_trace(...) log_debug(__VA_ARGS__)
	186	#else
	187	# define log_trace(...) do {} while(0)
	188	#endif
	189
f47781d8 MP	190	/* Structured logging */
	191	#define log_struct(level, ...) log_struct_internal(level, 0, __FILE__, __LINE__, __func__, __VA_ARGS__)
	192	#define log_struct_errno(level, error, ...) log_struct_internal(level, error, __FILE__, __LINE__, __func__, __VA_ARGS__)
663996b3 MS	193
663996b3 MS	194	/* This modifies the buffer passed! */
f47781d8 MP	195	#define log_dump(level, buffer) log_dump_internal(level, 0, __FILE__, __LINE__, __func__, buffer)
	196
	197	#define log_oom() log_oom_internal(__FILE__, __LINE__, __func__)
663996b3 MS	198
	199	bool log_on_console(void) _pure_;
	200
	201	const char *log_target_to_string(LogTarget target) _const_;
	202	LogTarget log_target_from_string(const char *s) _pure_;
	203
f47781d8 MP	204	/* Helpers to prepare various fields for structured logging */
	205	#define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
	206	#define LOG_MESSAGE_ID(x) "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(x)
60f067b4 JS	207
60f067b4 JS	208	void log_received_signal(int level, const struct signalfd_siginfo *si);
5eef597e MP	209
5eef597e MP	210	void log_set_upgrade_syslog_to_journal(bool b);
e3bff60a MP	211
	212	int log_syntax_internal(
	213	const char *unit,
	214	int level,
	215	const char *config_file,
	216	unsigned config_line,
	217	int error,
	218	const char *file,
	219	int line,
	220	const char *func,
	221	const char *format, ...) _printf_(9, 10);
	222
	223	#define log_syntax(unit, level, config_file, config_line, error, ...) \
	224	({ \
	225	int _level = (level), _e = (error); \
	226	(log_get_max_level() >= LOG_PRI(_level)) \
	227	? log_syntax_internal(unit, _level, config_file, config_line, _e, __FILE__, __LINE__, __func__, __VA_ARGS__) \
	228	: -abs(_e); \
	229	})
6300502b MP	230
	231	#define log_syntax_invalid_utf8(unit, level, config_file, config_line, rvalue) \
	232	({ \
	233	int _level = (level); \
	234	if (log_get_max_level() >= LOG_PRI(_level)) { \
	235	_cleanup_free_ char *_p = NULL; \
	236	_p = utf8_escape_invalid(rvalue); \
	237	log_syntax_internal(unit, _level, config_file, config_line, 0, __FILE__, __LINE__, __func__, \
	238	"String is not UTF-8 clean, ignoring assignment: %s", strna(_p)); \
	239	} \
	240	-EINVAL; \
	241	})