mirror of
https://github.com/systemd/systemd.git
synced 2026-07-12 10:34:12 +00:00
04499a70fb
In general we almost never hit those asserts in production code, so users see them very rarely, if ever. But either way, we just need something that users can pass to the developers. We have quite a few of those asserts, and some have fairly nice messages, but many are like "WTF?" or "???" or "unexpected something". The error that is printed includes the file location, and function name. In almost all functions there's at most one assert, so the function name alone is enough to identify the failure for a developer. So we don't get much extra from the message, and we might just as well drop them. Dropping them makes our code a tiny bit smaller, and most importantly, improves development experience by making it easy to insert such an assert in the code without thinking how to phrase the argument.
346 lines
13 KiB
C
346 lines
13 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
#pragma once
|
|
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <syslog.h>
|
|
|
|
#include "macro.h"
|
|
|
|
/* Some structures we reference but don't want to pull in headers for */
|
|
struct iovec;
|
|
struct signalfd_siginfo;
|
|
|
|
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 not journal, JOURNAL_OR_KMSG otherwise */
|
|
LOG_TARGET_NULL,
|
|
_LOG_TARGET_MAX,
|
|
_LOG_TARGET_INVALID = -EINVAL,
|
|
} LogTarget;
|
|
|
|
/* Note to readers: << and >> have lower precedence than & and | */
|
|
#define SYNTHETIC_ERRNO(num) (1 << 30 | (num))
|
|
#define IS_SYNTHETIC_ERRNO(val) ((val) >> 30 & 1)
|
|
#define ERRNO_VALUE(val) (abs(val) & 255)
|
|
|
|
const char *log_target_to_string(LogTarget target) _const_;
|
|
LogTarget log_target_from_string(const char *s) _pure_;
|
|
void log_set_target(LogTarget target);
|
|
int log_set_target_from_string(const char *e);
|
|
LogTarget log_get_target(void) _pure_;
|
|
|
|
void log_set_max_level(int level);
|
|
int log_set_max_level_from_string(const char *e);
|
|
int log_get_max_level(void) _pure_;
|
|
|
|
void log_set_facility(int facility);
|
|
|
|
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_;
|
|
void log_show_time(bool b);
|
|
bool log_get_show_time(void) _pure_;
|
|
void log_show_tid(bool b);
|
|
bool log_get_show_tid(void) _pure_;
|
|
|
|
int log_show_color_from_string(const char *e);
|
|
int log_show_location_from_string(const char *e);
|
|
int log_show_time_from_string(const char *e);
|
|
int log_show_tid_from_string(const char *e);
|
|
|
|
/* Functions below that open and close logs or configure logging based on the
|
|
* environment should not be called from library code — this is always a job
|
|
* for the application itself. */
|
|
|
|
assert_cc(STRLEN(__FILE__) > STRLEN(RELATIVE_SOURCE_PATH) + 1);
|
|
#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1])
|
|
|
|
int log_open(void);
|
|
void log_close(void);
|
|
void log_forget_fds(void);
|
|
|
|
void log_parse_environment(void);
|
|
|
|
int log_dispatch_internal(
|
|
int level,
|
|
int error,
|
|
const char *file,
|
|
int line,
|
|
const char *func,
|
|
const char *object_field,
|
|
const char *object,
|
|
const char *extra,
|
|
const char *extra_field,
|
|
char *buffer);
|
|
|
|
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_internalv(
|
|
int level,
|
|
int error,
|
|
const char *file,
|
|
int line,
|
|
const char *func,
|
|
const char *object_field,
|
|
const char *object,
|
|
const char *extra_field,
|
|
const char *extra,
|
|
const char *format,
|
|
va_list ap) _printf_(10,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 *extra_field,
|
|
const char *extra,
|
|
const char *format, ...) _printf_(10,11);
|
|
|
|
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(
|
|
int level,
|
|
const char *file,
|
|
int line,
|
|
const char *func);
|
|
|
|
int log_format_iovec(
|
|
struct iovec *iovec,
|
|
size_t iovec_len,
|
|
size_t *n,
|
|
bool newline_separator,
|
|
int error,
|
|
const char *format,
|
|
va_list ap) _printf_(6, 0);
|
|
|
|
int log_struct_iovec_internal(
|
|
int level,
|
|
int error,
|
|
const char *file,
|
|
int line,
|
|
const char *func,
|
|
const struct iovec *input_iovec,
|
|
size_t n_input_iovec);
|
|
|
|
/* 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 *file,
|
|
int line,
|
|
const char *func);
|
|
|
|
void log_assert_failed_return(
|
|
const char *text,
|
|
const char *file,
|
|
int line,
|
|
const char *func);
|
|
|
|
#define log_dispatch(level, error, buffer) \
|
|
log_dispatch_internal(level, error, PROJECT_FILE, __LINE__, __func__, NULL, NULL, NULL, NULL, buffer)
|
|
|
|
/* Logging with level */
|
|
#define log_full_errno_zerook(level, error, ...) \
|
|
({ \
|
|
int _level = (level), _e = (error); \
|
|
_e = (log_get_max_level() >= LOG_PRI(_level)) \
|
|
? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
|
|
: -ERRNO_VALUE(_e); \
|
|
_e < 0 ? _e : -ESTRPIPE; \
|
|
})
|
|
|
|
#if BUILD_MODE_DEVELOPER && !defined(TEST_CODE)
|
|
# define ASSERT_NON_ZERO(x) assert((x) != 0)
|
|
#else
|
|
# define ASSERT_NON_ZERO(x)
|
|
#endif
|
|
|
|
#define log_full_errno(level, error, ...) \
|
|
({ \
|
|
int _error = (error); \
|
|
ASSERT_NON_ZERO(_error); \
|
|
log_full_errno_zerook(level, _error, __VA_ARGS__); \
|
|
})
|
|
|
|
#define log_full(level, fmt, ...) \
|
|
({ \
|
|
if (BUILD_MODE_DEVELOPER) \
|
|
assert(!strstr(fmt, "%m")); \
|
|
(void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \
|
|
})
|
|
|
|
int log_emergency_level(void);
|
|
|
|
/* 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(log_emergency_level(), __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(log_emergency_level(), error, __VA_ARGS__)
|
|
|
|
/* This logs at the specified level the first time it is called, and then
|
|
* logs at debug. If the specified level is debug, this logs only the first
|
|
* time it is called. */
|
|
#define log_once(level, ...) \
|
|
({ \
|
|
if (ONCE) \
|
|
log_full(level, __VA_ARGS__); \
|
|
else if (LOG_PRI(level) != LOG_DEBUG) \
|
|
log_debug(__VA_ARGS__); \
|
|
})
|
|
|
|
#define log_once_errno(level, error, ...) \
|
|
({ \
|
|
int _err = (error); \
|
|
if (ONCE) \
|
|
_err = log_full_errno(level, _err, __VA_ARGS__); \
|
|
else if (LOG_PRI(level) != LOG_DEBUG) \
|
|
_err = log_debug_errno(_err, __VA_ARGS__); \
|
|
else \
|
|
_err = -ERRNO_VALUE(_err); \
|
|
_err; \
|
|
})
|
|
|
|
#if LOG_TRACE
|
|
# define log_trace(...) log_debug(__VA_ARGS__)
|
|
#else
|
|
# define log_trace(...) do {} while (0)
|
|
#endif
|
|
|
|
/* Structured logging */
|
|
#define log_struct_errno(level, error, ...) \
|
|
log_struct_internal(level, error, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__, NULL)
|
|
#define log_struct(level, ...) log_struct_errno(level, 0, __VA_ARGS__)
|
|
|
|
#define log_struct_iovec_errno(level, error, iovec, n_iovec) \
|
|
log_struct_iovec_internal(level, error, PROJECT_FILE, __LINE__, __func__, iovec, n_iovec)
|
|
#define log_struct_iovec(level, iovec, n_iovec) log_struct_iovec_errno(level, 0, iovec, n_iovec)
|
|
|
|
/* This modifies the buffer passed! */
|
|
#define log_dump(level, buffer) \
|
|
log_dump_internal(level, 0, PROJECT_FILE, __LINE__, __func__, buffer)
|
|
|
|
#define log_oom() log_oom_internal(LOG_ERR, PROJECT_FILE, __LINE__, __func__)
|
|
#define log_oom_debug() log_oom_internal(LOG_DEBUG, PROJECT_FILE, __LINE__, __func__)
|
|
|
|
bool log_on_console(void) _pure_;
|
|
|
|
/* Helper to prepare various field for structured logging */
|
|
#define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
|
|
|
|
void log_received_signal(int level, const struct signalfd_siginfo *si);
|
|
|
|
/* If turned on, any requests for a log target involving "syslog" will be implicitly upgraded to the equivalent journal target */
|
|
void log_set_upgrade_syslog_to_journal(bool b);
|
|
|
|
/* If turned on, and log_open() is called, we'll not use STDERR_FILENO for logging ever, but rather open /dev/console */
|
|
void log_set_always_reopen_console(bool b);
|
|
|
|
/* If turned on, we'll open the log stream implicitly if needed on each individual log call. This is normally not
|
|
* desired as we want to reuse our logging streams. It is useful however */
|
|
void log_set_open_when_needed(bool b);
|
|
|
|
/* If turned on, then we'll never use IPC-based logging, i.e. never log to syslog or the journal. We'll only log to
|
|
* stderr, the console or kmsg */
|
|
void log_set_prohibit_ipc(bool b);
|
|
|
|
int log_dup_console(void);
|
|
|
|
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);
|
|
|
|
int log_syntax_invalid_utf8_internal(
|
|
const char *unit,
|
|
int level,
|
|
const char *config_file,
|
|
unsigned config_line,
|
|
const char *file,
|
|
int line,
|
|
const char *func,
|
|
const char *rvalue);
|
|
|
|
#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, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
|
|
: -ERRNO_VALUE(_e); \
|
|
})
|
|
|
|
#define log_syntax_invalid_utf8(unit, level, config_file, config_line, rvalue) \
|
|
({ \
|
|
int _level = (level); \
|
|
(log_get_max_level() >= LOG_PRI(_level)) \
|
|
? log_syntax_invalid_utf8_internal(unit, _level, config_file, config_line, PROJECT_FILE, __LINE__, __func__, rvalue) \
|
|
: -EINVAL; \
|
|
})
|
|
|
|
#define DEBUG_LOGGING _unlikely_(log_get_max_level() >= LOG_DEBUG)
|
|
|
|
void log_setup(void);
|