2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2012-07-18 19:07:51 +02:00
|
|
|
#pragma once
|
2010-01-20 19:18:52 +01:00
|
|
|
|
2012-03-14 14:54:41 +01:00
|
|
|
#include <stdarg.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <stdbool.h>
|
2015-03-10 01:02:59 +01:00
|
|
|
#include <stdlib.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <syslog.h>
|
2010-01-20 19:18:52 +01:00
|
|
|
|
2015-04-21 17:26:04 +02:00
|
|
|
#include "macro.h"
|
2018-01-11 00:39:12 +01:00
|
|
|
|
|
|
|
/* Some structures we reference but don't want to pull in headers for */
|
|
|
|
struct iovec;
|
|
|
|
struct signalfd_siginfo;
|
2010-01-20 19:18:52 +01:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
typedef enum LogRealm {
|
|
|
|
LOG_REALM_SYSTEMD,
|
|
|
|
LOG_REALM_UDEV,
|
|
|
|
_LOG_REALM_MAX,
|
|
|
|
} LogRealm;
|
|
|
|
|
|
|
|
#ifndef LOG_REALM
|
|
|
|
# define LOG_REALM LOG_REALM_SYSTEMD
|
|
|
|
#endif
|
|
|
|
|
2010-04-06 21:57:45 +02:00
|
|
|
typedef enum LogTarget{
|
|
|
|
LOG_TARGET_CONSOLE,
|
2015-01-22 03:47:46 +01:00
|
|
|
LOG_TARGET_CONSOLE_PREFIXED,
|
2010-04-06 21:57:45 +02:00
|
|
|
LOG_TARGET_KMSG,
|
2012-01-12 04:34:31 +01:00
|
|
|
LOG_TARGET_JOURNAL,
|
|
|
|
LOG_TARGET_JOURNAL_OR_KMSG,
|
2010-05-15 17:25:08 +02:00
|
|
|
LOG_TARGET_SYSLOG,
|
|
|
|
LOG_TARGET_SYSLOG_OR_KMSG,
|
2012-01-12 04:34:31 +01:00
|
|
|
LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG otherwise */
|
2010-06-09 15:37:37 +02:00
|
|
|
LOG_TARGET_NULL,
|
2010-04-06 21:57:45 +02:00
|
|
|
_LOG_TARGET_MAX,
|
|
|
|
_LOG_TARGET_INVALID = -1
|
2017-02-23 04:57:34 +01:00
|
|
|
} LogTarget;
|
|
|
|
|
2018-11-22 10:56:43 +01:00
|
|
|
/* Note to readers: << and >> have lower precedence than & and | */
|
2018-11-20 23:03:40 +01:00
|
|
|
#define LOG_REALM_PLUS_LEVEL(realm, level) ((realm) << 10 | (level))
|
|
|
|
#define LOG_REALM_REMOVE_LEVEL(realm_level) ((realm_level) >> 10)
|
|
|
|
#define SYNTHETIC_ERRNO(num) (1 << 30 | (num))
|
|
|
|
#define IS_SYNTHETIC_ERRNO(val) ((val) >> 30 & 1)
|
|
|
|
#define ERRNO_VALUE(val) (abs(val) & 255)
|
2010-04-06 21:57:45 +02:00
|
|
|
|
|
|
|
void log_set_target(LogTarget target);
|
2017-02-23 04:57:34 +01:00
|
|
|
void log_set_max_level_realm(LogRealm realm, int level);
|
|
|
|
#define log_set_max_level(level) \
|
|
|
|
log_set_max_level_realm(LOG_REALM, (level))
|
|
|
|
|
2012-04-03 19:25:29 +02:00
|
|
|
void log_set_facility(int facility);
|
2010-04-06 21:57:45 +02:00
|
|
|
|
2010-04-06 23:38:32 +02:00
|
|
|
int log_set_target_from_string(const char *e);
|
2017-02-23 04:57:34 +01:00
|
|
|
int log_set_max_level_from_string_realm(LogRealm realm, const char *e);
|
|
|
|
#define log_set_max_level_from_string(e) \
|
|
|
|
log_set_max_level_from_string_realm(LOG_REALM, (e))
|
2010-04-06 23:38:32 +02:00
|
|
|
|
2010-06-17 22:52:55 +02:00
|
|
|
void log_show_color(bool b);
|
2014-02-16 00:13:46 +01:00
|
|
|
bool log_get_show_color(void) _pure_;
|
2010-06-17 22:52:55 +02:00
|
|
|
void log_show_location(bool b);
|
2014-02-16 00:13:46 +01:00
|
|
|
bool log_get_show_location(void) _pure_;
|
2010-06-17 22:52:55 +02:00
|
|
|
|
|
|
|
int log_show_color_from_string(const char *e);
|
|
|
|
int log_show_location_from_string(const char *e);
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
LogTarget log_get_target(void) _pure_;
|
2017-02-23 04:57:34 +01:00
|
|
|
int log_get_max_level_realm(LogRealm realm) _pure_;
|
|
|
|
#define log_get_max_level() \
|
|
|
|
log_get_max_level_realm(LOG_REALM)
|
2010-04-10 17:40:18 +02:00
|
|
|
|
2017-07-11 10:40:11 +02:00
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
2019-07-17 12:45:42 +02:00
|
|
|
assert_cc(STRLEN(__FILE__) > STRLEN(RELATIVE_SOURCE_PATH) + 1);
|
2019-06-07 14:41:36 +02:00
|
|
|
#define PROJECT_FILE (__FILE__ + STRLEN(RELATIVE_SOURCE_PATH) + 1)
|
|
|
|
|
2010-05-15 17:25:08 +02:00
|
|
|
int log_open(void);
|
2011-07-25 21:22:57 +02:00
|
|
|
void log_close(void);
|
2011-11-16 23:45:01 +01:00
|
|
|
void log_forget_fds(void);
|
2010-05-15 17:25:08 +02:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
void log_parse_environment_realm(LogRealm realm);
|
|
|
|
#define log_parse_environment() \
|
|
|
|
log_parse_environment_realm(LOG_REALM)
|
2010-04-06 23:38:32 +02:00
|
|
|
|
2017-04-21 18:52:54 +02:00
|
|
|
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);
|
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
int log_internal_realm(
|
2012-08-24 22:21:20 +02:00
|
|
|
int level,
|
2014-11-27 19:48:02 +01:00
|
|
|
int error,
|
2014-11-27 20:20:23 +01:00
|
|
|
const char *file,
|
2012-08-24 22:21:20 +02:00
|
|
|
int line,
|
|
|
|
const char *func,
|
2014-11-27 19:48:02 +01:00
|
|
|
const char *format, ...) _printf_(6,7);
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_internal(level, ...) \
|
|
|
|
log_internal_realm(LOG_REALM_PLUS_LEVEL(LOG_REALM, (level)), __VA_ARGS__)
|
2010-01-20 19:18:52 +01:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
int log_internalv_realm(
|
2012-08-24 22:21:20 +02:00
|
|
|
int level,
|
2014-11-27 19:48:02 +01:00
|
|
|
int error,
|
2014-11-27 20:20:23 +01:00
|
|
|
const char *file,
|
2012-08-24 22:21:20 +02:00
|
|
|
int line,
|
|
|
|
const char *func,
|
|
|
|
const char *format,
|
2014-11-27 19:48:02 +01:00
|
|
|
va_list ap) _printf_(6,0);
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_internalv(level, ...) \
|
|
|
|
log_internalv_realm(LOG_REALM_PLUS_LEVEL(LOG_REALM, (level)), __VA_ARGS__)
|
2012-08-24 22:21:20 +02:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
/* Realm is fixed to LOG_REALM_SYSTEMD for those */
|
2019-03-08 06:21:15 +01:00
|
|
|
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);
|
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
int log_object_internal(
|
2013-01-05 17:59:46 +01:00
|
|
|
int level,
|
2014-11-27 19:48:02 +01:00
|
|
|
int error,
|
2014-11-27 20:20:23 +01:00
|
|
|
const char *file,
|
2013-01-05 17:59:46 +01:00
|
|
|
int line,
|
|
|
|
const char *func,
|
2014-11-27 20:20:23 +01:00
|
|
|
const char *object_field,
|
2013-01-05 17:59:46 +01:00
|
|
|
const char *object,
|
2016-08-30 23:18:46 +02:00
|
|
|
const char *extra_field,
|
|
|
|
const char *extra,
|
|
|
|
const char *format, ...) _printf_(10,11);
|
2013-01-05 17:59:46 +01:00
|
|
|
|
2012-08-24 22:21:20 +02:00
|
|
|
int log_struct_internal(
|
|
|
|
int level,
|
2014-11-27 19:48:02 +01:00
|
|
|
int error,
|
2012-08-24 22:21:20 +02:00
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func,
|
2014-11-27 19:48:02 +01:00
|
|
|
const char *format, ...) _printf_(6,0) _sentinel_;
|
2012-08-24 22:21:20 +02:00
|
|
|
|
|
|
|
int log_oom_internal(
|
2017-02-23 04:57:34 +01:00
|
|
|
LogRealm realm,
|
2012-08-24 22:21:20 +02:00
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func);
|
2010-04-22 03:51:26 +02:00
|
|
|
|
2015-11-08 20:05:55 +01:00
|
|
|
int log_format_iovec(
|
|
|
|
struct iovec *iovec,
|
core: implement /run/systemd/units/-based path for passing unit info from PID 1 to journald
And let's make use of it to implement two new unit settings with it:
1. LogLevelMax= is a new per-unit setting that may be used to configure
log priority filtering: set it to LogLevelMax=notice and only
messages of level "notice" and lower (i.e. more important) will be
processed, all others are dropped.
2. LogExtraFields= is a new per-unit setting for configuring per-unit
journal fields, that are implicitly included in every log record
generated by the unit's processes. It takes field/value pairs in the
form of FOO=BAR.
Also, related to this, one exisiting unit setting is ported to this new
facility:
3. The invocation ID is now pulled from /run/systemd/units/ instead of
cgroupfs xattrs. This substantially relaxes requirements of systemd
on the kernel version and the privileges it runs with (specifically,
cgroupfs xattrs are not available in containers, since they are
stored in kernel memory, and hence are unsafe to permit to lesser
privileged code).
/run/systemd/units/ is a new directory, which contains a number of files
and symlinks encoding the above information. PID 1 creates and manages
these files, and journald reads them from there.
Note that this is supposed to be a direct path between PID 1 and the
journal only, due to the special runtime environment the journal runs
in. Normally, today we shouldn't introduce new interfaces that (mis-)use
a file system as IPC framework, and instead just an IPC system, but this
is very hard to do between the journal and PID 1, as long as the IPC
system is a subject PID 1 manages, and itself a client to the journal.
This patch cleans up a couple of types used in journal code:
specifically we switch to size_t for a couple of memory-sizing values,
as size_t is the right choice for everything that is memory.
Fixes: #4089
Fixes: #3041
Fixes: #4441
2017-11-02 19:43:32 +01:00
|
|
|
size_t iovec_len,
|
|
|
|
size_t *n,
|
2015-11-08 20:05:55 +01:00
|
|
|
bool newline_separator,
|
|
|
|
int error,
|
|
|
|
const char *format,
|
2017-04-20 20:15:28 +02:00
|
|
|
va_list ap) _printf_(6, 0);
|
2015-11-08 20:05:55 +01:00
|
|
|
|
2017-09-21 14:05:35 +02:00
|
|
|
int log_struct_iovec_internal(
|
|
|
|
int level,
|
|
|
|
int error,
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func,
|
2018-01-11 00:39:12 +01:00
|
|
|
const struct iovec *input_iovec,
|
2017-09-21 14:05:35 +02:00
|
|
|
size_t n_input_iovec);
|
|
|
|
|
2010-06-04 19:45:53 +02:00
|
|
|
/* This modifies the buffer passed! */
|
|
|
|
int log_dump_internal(
|
2012-08-24 22:21:20 +02:00
|
|
|
int level,
|
2014-11-27 19:48:02 +01:00
|
|
|
int error,
|
2014-11-27 20:20:23 +01:00
|
|
|
const char *file,
|
2012-08-24 22:21:20 +02:00
|
|
|
int line,
|
|
|
|
const char *func,
|
|
|
|
char *buffer);
|
|
|
|
|
2014-11-27 19:48:02 +01:00
|
|
|
/* Logging for various assertions */
|
2018-03-15 06:23:46 +01:00
|
|
|
_noreturn_ void log_assert_failed_realm(
|
2017-02-23 04:57:34 +01:00
|
|
|
LogRealm realm,
|
2012-08-24 22:21:20 +02:00
|
|
|
const char *text,
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func);
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_assert_failed(text, ...) \
|
|
|
|
log_assert_failed_realm(LOG_REALM, (text), __VA_ARGS__)
|
2012-08-24 22:21:20 +02:00
|
|
|
|
2018-03-15 06:23:46 +01:00
|
|
|
_noreturn_ void log_assert_failed_unreachable_realm(
|
2017-02-23 04:57:34 +01:00
|
|
|
LogRealm realm,
|
2012-08-24 22:21:20 +02:00
|
|
|
const char *text,
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func);
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_assert_failed_unreachable(text, ...) \
|
|
|
|
log_assert_failed_unreachable_realm(LOG_REALM, (text), __VA_ARGS__)
|
2013-12-10 18:01:10 +01:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
void log_assert_failed_return_realm(
|
|
|
|
LogRealm realm,
|
2013-12-10 18:01:10 +01:00
|
|
|
const char *text,
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func);
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_assert_failed_return(text, ...) \
|
|
|
|
log_assert_failed_return_realm(LOG_REALM, (text), __VA_ARGS__)
|
2010-06-04 19:45:53 +02:00
|
|
|
|
2017-04-21 18:52:54 +02:00
|
|
|
#define log_dispatch(level, error, buffer) \
|
2019-06-07 15:00:47 +02:00
|
|
|
log_dispatch_internal(level, error, PROJECT_FILE, __LINE__, __func__, NULL, NULL, NULL, NULL, buffer)
|
2017-04-21 18:52:54 +02:00
|
|
|
|
2014-11-27 19:48:02 +01:00
|
|
|
/* Logging with level */
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_full_errno_realm(realm, level, error, ...) \
|
2015-02-18 18:27:32 +01:00
|
|
|
({ \
|
2018-01-11 13:15:19 +01:00
|
|
|
int _level = (level), _e = (error), _realm = (realm); \
|
2018-11-20 23:40:44 +01:00
|
|
|
(log_get_max_level_realm(_realm) >= LOG_PRI(_level)) \
|
2018-01-11 13:15:19 +01:00
|
|
|
? log_internal_realm(LOG_REALM_PLUS_LEVEL(_realm, _level), _e, \
|
2019-06-07 15:00:47 +02:00
|
|
|
PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
|
2018-11-20 23:40:44 +01:00
|
|
|
: -ERRNO_VALUE(_e); \
|
2014-11-28 03:10:55 +01:00
|
|
|
})
|
2013-10-20 21:17:55 +02:00
|
|
|
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_full_errno(level, error, ...) \
|
|
|
|
log_full_errno_realm(LOG_REALM, (level), (error), __VA_ARGS__)
|
|
|
|
|
|
|
|
#define log_full(level, ...) log_full_errno((level), 0, __VA_ARGS__)
|
2014-11-27 19:48:02 +01:00
|
|
|
|
2018-01-11 00:39:12 +01:00
|
|
|
int log_emergency_level(void);
|
|
|
|
|
2014-11-27 19:48:02 +01:00
|
|
|
/* Normal logging */
|
2014-11-06 06:04:06 +01:00
|
|
|
#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__)
|
2018-01-11 00:39:12 +01:00
|
|
|
#define log_emergency(...) log_full(log_emergency_level(), __VA_ARGS__)
|
2010-01-20 19:18:52 +01:00
|
|
|
|
2014-11-27 19:48:02 +01:00
|
|
|
/* 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__)
|
2018-01-11 00:39:12 +01:00
|
|
|
#define log_emergency_errno(error, ...) log_full_errno(log_emergency_level(), error, __VA_ARGS__)
|
2014-11-27 19:48:02 +01:00
|
|
|
|
2014-10-23 06:27:57 +02:00
|
|
|
#ifdef LOG_TRACE
|
|
|
|
# define log_trace(...) log_debug(__VA_ARGS__)
|
|
|
|
#else
|
2016-02-23 18:52:52 +01:00
|
|
|
# define log_trace(...) do {} while (0)
|
2014-10-23 06:27:57 +02:00
|
|
|
#endif
|
|
|
|
|
2014-11-27 19:48:02 +01:00
|
|
|
/* Structured logging */
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_struct_errno(level, error, ...) \
|
|
|
|
log_struct_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
|
2019-06-07 15:00:47 +02:00
|
|
|
error, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__, NULL)
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_struct(level, ...) log_struct_errno(level, 0, __VA_ARGS__)
|
2012-07-25 23:55:59 +02:00
|
|
|
|
2017-09-21 14:05:35 +02:00
|
|
|
#define log_struct_iovec_errno(level, error, iovec, n_iovec) \
|
|
|
|
log_struct_iovec_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
|
2019-06-07 15:00:47 +02:00
|
|
|
error, PROJECT_FILE, __LINE__, __func__, iovec, n_iovec)
|
2017-09-21 14:05:35 +02:00
|
|
|
#define log_struct_iovec(level, iovec, n_iovec) log_struct_iovec_errno(level, 0, iovec, n_iovec)
|
|
|
|
|
2010-06-04 19:45:53 +02:00
|
|
|
/* This modifies the buffer passed! */
|
2017-02-23 04:57:34 +01:00
|
|
|
#define log_dump(level, buffer) \
|
|
|
|
log_dump_internal(LOG_REALM_PLUS_LEVEL(LOG_REALM, level), \
|
2019-06-07 15:00:47 +02:00
|
|
|
0, PROJECT_FILE, __LINE__, __func__, buffer)
|
2014-11-27 19:48:02 +01:00
|
|
|
|
2019-06-07 15:00:47 +02:00
|
|
|
#define log_oom() log_oom_internal(LOG_REALM, PROJECT_FILE, __LINE__, __func__)
|
2010-06-04 19:45:53 +02:00
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
bool log_on_console(void) _pure_;
|
2012-08-24 22:43:33 +02:00
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
const char *log_target_to_string(LogTarget target) _const_;
|
|
|
|
LogTarget log_target_from_string(const char *s) _pure_;
|
2012-10-16 16:26:41 +02:00
|
|
|
|
tree-wide: add SD_ID128_MAKE_STR, remove LOG_MESSAGE_ID
Embedding sd_id128_t's in constant strings was rather cumbersome. We had
SD_ID128_CONST_STR which returned a const char[], but it had two problems:
- it wasn't possible to statically concatanate this array with a normal string
- gcc wasn't really able to optimize this, and generated code to perform the
"conversion" at runtime.
Because of this, even our own code in coredumpctl wasn't using
SD_ID128_CONST_STR.
Add a new macro to generate a constant string: SD_ID128_MAKE_STR.
It is not as elegant as SD_ID128_CONST_STR, because it requires a repetition
of the numbers, but in practice it is more convenient to use, and allows gcc
to generate smarter code:
$ size .libs/systemd{,-logind,-journald}{.old,}
text data bss dec hex filename
1265204 149564 4808 1419576 15a938 .libs/systemd.old
1260268 149564 4808 1414640 1595f0 .libs/systemd
246805 13852 209 260866 3fb02 .libs/systemd-logind.old
240973 13852 209 255034 3e43a .libs/systemd-logind
146839 4984 34 151857 25131 .libs/systemd-journald.old
146391 4984 34 151409 24f71 .libs/systemd-journald
It is also much easier to check if a certain binary uses a certain MESSAGE_ID:
$ strings .libs/systemd.old|grep MESSAGE_ID
MESSAGE_ID=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x
MESSAGE_ID=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x
MESSAGE_ID=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x
MESSAGE_ID=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x
$ strings .libs/systemd|grep MESSAGE_ID
MESSAGE_ID=c7a787079b354eaaa9e77b371893cd27
MESSAGE_ID=b07a249cd024414a82dd00cd181378ff
MESSAGE_ID=641257651c1b4ec9a8624d7a40a9e1e7
MESSAGE_ID=de5b426a63be47a7b6ac3eaac82e2f6f
MESSAGE_ID=d34d037fff1847e6ae669a370e694725
MESSAGE_ID=7d4958e842da4a758f6c1cdc7b36dcc5
MESSAGE_ID=1dee0369c7fc4736b7099b38ecb46ee7
MESSAGE_ID=39f53479d3a045ac8e11786248231fbf
MESSAGE_ID=be02cf6855d2428ba40df7e9d022f03d
MESSAGE_ID=7b05ebc668384222baa8881179cfda54
MESSAGE_ID=9d1aaa27d60140bd96365438aad20286
2016-11-06 18:48:23 +01:00
|
|
|
/* Helper to prepare various field for structured logging */
|
2014-11-28 02:05:14 +01:00
|
|
|
#define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
|
2014-02-10 02:08:55 +01:00
|
|
|
|
|
|
|
void log_received_signal(int level, const struct signalfd_siginfo *si);
|
2014-08-11 20:08:08 +02:00
|
|
|
|
2018-01-24 17:33:07 +01:00
|
|
|
/* If turned on, any requests for a log target involving "syslog" will be implicitly upgraded to the equivalent journal target */
|
2014-08-11 20:08:08 +02:00
|
|
|
void log_set_upgrade_syslog_to_journal(bool b);
|
2018-01-24 17:45:14 +01:00
|
|
|
|
|
|
|
/* If turned on, and log_open() is called, we'll not use STDERR_FILENO for logging ever, but rather open /dev/console */
|
2017-02-21 17:57:55 +01:00
|
|
|
void log_set_always_reopen_console(bool b);
|
2018-01-24 17:45:14 +01:00
|
|
|
|
|
|
|
/* 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 */
|
2017-09-26 17:45:09 +02:00
|
|
|
void log_set_open_when_needed(bool b);
|
2015-04-21 17:26:04 +02:00
|
|
|
|
log: add new "prohibit_ipc" flag to logging system
If set, we'll avoid logging to any IPC log targets, i.e. syslog or the
journal, but allow stderr, kmsg, console logging.
This is useful as PID 1 wants to turn this off explicitly as long as the
journal is not up.
Previously we'd open/close the log stream to these services whenever
needed but this is incompatible with the "open_when_needed" logic
introduced in #6915, which might open the log streams whenever it likes,
including possibly inside of the child process we fork off that'll
become journald later on. Hence, let's make this all explicit, and
instead of managing when we open/close log streams add a boolean that
clearly prohibits the IPC targets when needed, so that opening can be
done at any time, but will honour this.
See: #7985
2018-01-24 17:36:25 +01:00
|
|
|
/* 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);
|
|
|
|
|
2018-05-22 16:52:50 +02:00
|
|
|
int log_dup_console(void);
|
|
|
|
|
2015-04-21 17:26:04 +02:00
|
|
|
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);
|
|
|
|
|
2018-01-11 13:13:02 +01:00
|
|
|
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);
|
|
|
|
|
2015-04-21 17:26:04 +02:00
|
|
|
#define log_syntax(unit, level, config_file, config_line, error, ...) \
|
|
|
|
({ \
|
|
|
|
int _level = (level), _e = (error); \
|
|
|
|
(log_get_max_level() >= LOG_PRI(_level)) \
|
2019-06-07 15:00:47 +02:00
|
|
|
? log_syntax_internal(unit, _level, config_file, config_line, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
|
2019-03-04 07:18:06 +01:00
|
|
|
: -ERRNO_VALUE(_e); \
|
2015-04-21 17:26:04 +02:00
|
|
|
})
|
2015-09-30 20:07:24 +02:00
|
|
|
|
|
|
|
#define log_syntax_invalid_utf8(unit, level, config_file, config_line, rvalue) \
|
|
|
|
({ \
|
|
|
|
int _level = (level); \
|
2018-01-11 13:13:02 +01:00
|
|
|
(log_get_max_level() >= LOG_PRI(_level)) \
|
2019-06-07 15:00:47 +02:00
|
|
|
? log_syntax_invalid_utf8_internal(unit, _level, config_file, config_line, PROJECT_FILE, __LINE__, __func__, rvalue) \
|
2018-01-11 13:13:02 +01:00
|
|
|
: -EINVAL; \
|
2015-09-30 20:07:24 +02:00
|
|
|
})
|
2017-12-15 11:09:00 +01:00
|
|
|
|
|
|
|
#define DEBUG_LOGGING _unlikely_(log_get_max_level() >= LOG_DEBUG)
|
2018-11-20 11:18:22 +01:00
|
|
|
|
|
|
|
void log_setup_service(void);
|