fuzz-bus-label.c:freep: 78| 494|static inline void freep(void *p) { 79| 494| *(void**)p = mfree(*(void**) p); ------------------ | | 404| 494| ({ \ | | 405| 494| free(memory); \ | | 406| 494| (typeof(memory)) NULL; \ | | 407| 494| }) ------------------ 80| 494|} bus-label.c:malloc_multiply: 88| 489|_malloc_ _alloc_(1, 2) static inline void *malloc_multiply(size_t need, size_t size) { 89| 489| if (size_multiply_overflow(size, need)) ------------------ | Branch (89:13): [True: 0, False: 489] ------------------ 90| 0| return NULL; 91| | 92| 489| return malloc(size * need ?: 1); ------------------ | Branch (92:23): [True: 489, False: 0] ------------------ 93| 489|} bus-label.c:size_multiply_overflow: 84| 489|static inline bool size_multiply_overflow(size_t size, size_t need) { 85| 489| return _unlikely_(need != 0 && size > (SIZE_MAX / need)); ------------------ | | 95| 978|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | ------------------ | | | Branch (95:44): [True: 489, False: 0] | | | Branch (95:44): [True: 0, False: 489] | | ------------------ ------------------ 86| 489|} log.c:freep: 78| 247|static inline void freep(void *p) { 79| 247| *(void**)p = mfree(*(void**) p); ------------------ | | 404| 247| ({ \ | | 405| 247| free(memory); \ | | 406| 247| (typeof(memory)) NULL; \ | | 407| 247| }) ------------------ 80| 247|} invoked_by_systemd: 41| 247|bool invoked_by_systemd(void) { 42| 247| int r; 43| | 44| | /* If the process is directly executed by PID1 (e.g. ExecStart= or generator), systemd-importd, 45| | * or systemd-homed, then $SYSTEMD_EXEC_PID= is set, and read the command line. */ 46| 247| const char *e = getenv("SYSTEMD_EXEC_PID"); 47| 247| if (!e) ------------------ | Branch (47:13): [True: 247, False: 0] ------------------ 48| 247| return false; 49| | 50| 0| if (streq(e, "*")) ------------------ | | 46| 0|#define streq(a,b) (strcmp((a),(b)) == 0) | | ------------------ | | | Branch (46:20): [True: 0, False: 0] | | ------------------ ------------------ 51| | /* For testing. */ 52| 0| return true; 53| | 54| 0| pid_t p; 55| 0| r = parse_pid(e, &p); 56| 0| if (r < 0) { ------------------ | Branch (56:13): [True: 0, False: 0] ------------------ 57| | /* We know that systemd sets the variable correctly. Something else must have set it. */ 58| 0| log_debug_errno(r, "Failed to parse \"SYSTEMD_EXEC_PID=%s\", ignoring: %m", e); ------------------ | | 228| 0|#define log_debug_errno(error, ...) log_full_errno(LOG_DEBUG, error, __VA_ARGS__) | | ------------------ | | | | 204| 0| ({ \ | | | | 205| 0| int _error = (error); \ | | | | 206| 0| ASSERT_NON_ZERO(_error); \ | | | | ------------------ | | | | | | 198| 0|# define ASSERT_NON_ZERO(x) assert((x) != 0) | | | | | | ------------------ | | | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | | | ------------------ | | | | | | | | | | 58| 0| do { \ | | | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 61| 0| } while (false) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 207| 0| log_full_errno_zerook(level, _error, __VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 208| 0| }) | | ------------------ ------------------ 59| 0| return false; 60| 0| } 61| | 62| 0| return getpid_cached() == p; 63| 0|} log_set_assert_return_is_critical: 16| 247|void log_set_assert_return_is_critical(bool b) { 17| 247| assert_return_is_critical = b; 18| 247|} bus_label_escape: 10| 247|char* bus_label_escape(const char *s) { 11| 247| char *r, *t; 12| 247| const char *f; 13| | 14| 247| assert_return(s, NULL); ------------------ | | 18| 247| do { \ | | 19| 247| if (!assert_log(expr, #expr)) \ | | ------------------ | | | | 13| 247|#define assert_log(expr, message) ((_likely_(expr)) \ | | | | ------------------ | | | | | | 83| 247|#define _likely_(x) (__builtin_expect(!!(x), 1)) | | | | ------------------ | | | | | Branch (13:36): [True: 247, False: 0] | | | | ------------------ | | | | 14| 247| ? (true) \ | | | | 15| 247| : (log_assert_failed_return(message, PROJECT_FILE, __LINE__, __func__), false)) | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (19:21): [True: 0, False: 247] | | ------------------ | | 20| 247| return (r); \ | | 21| 247| } while (false) ------------------ 15| | 16| | /* Escapes all chars that D-Bus' object path cannot deal 17| | * with. Can be reversed with bus_path_unescape(). We special 18| | * case the empty string. */ 19| | 20| 247| if (*s == 0) ------------------ | Branch (20:13): [True: 4, False: 243] ------------------ 21| 4| return strdup("_"); 22| | 23| 243| r = new(char, strlen(s)*3 + 1); ------------------ | | 17| 243|#define new(t, n) ((t*) malloc_multiply(n, sizeof(t))) ------------------ 24| 243| if (!r) ------------------ | Branch (24:13): [True: 0, False: 243] ------------------ 25| 0| return NULL; 26| | 27| 2.49M| for (f = s, t = r; *f; f++) { ------------------ | Branch (27:28): [True: 2.49M, False: 243] ------------------ 28| | 29| | /* Escape everything that is not a-zA-Z0-9. We also escape 0-9 if it's the first character */ 30| | 31| 2.49M| if (!ascii_isalpha(*f) && ------------------ | Branch (31:21): [True: 2.28M, False: 208k] ------------------ 32| 2.49M| !(f > s && ascii_isdigit(*f))) { ------------------ | Branch (32:23): [True: 2.28M, False: 216] | Branch (32:32): [True: 1.33k, False: 2.28M] ------------------ 33| 2.28M| *(t++) = '_'; 34| 2.28M| *(t++) = hexchar(*f >> 4); 35| 2.28M| *(t++) = hexchar(*f); 36| 2.28M| } else 37| 209k| *(t++) = *f; 38| 2.49M| } 39| | 40| 243| *t = 0; 41| | 42| 243| return r; 43| 243|} bus_label_unescape_n: 45| 247|char* bus_label_unescape_n(const char *f, size_t l) { 46| 247| char *r, *t; 47| 247| size_t i; 48| | 49| 247| assert_return(f, NULL); ------------------ | | 18| 247| do { \ | | 19| 247| if (!assert_log(expr, #expr)) \ | | ------------------ | | | | 13| 247|#define assert_log(expr, message) ((_likely_(expr)) \ | | | | ------------------ | | | | | | 83| 247|#define _likely_(x) (__builtin_expect(!!(x), 1)) | | | | ------------------ | | | | | Branch (13:36): [True: 247, False: 0] | | | | ------------------ | | | | 14| 247| ? (true) \ | | | | 15| 247| : (log_assert_failed_return(message, PROJECT_FILE, __LINE__, __func__), false)) | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (19:21): [True: 0, False: 247] | | ------------------ | | 20| 247| return (r); \ | | 21| 247| } while (false) ------------------ 50| | 51| 247| if (l == SIZE_MAX) ------------------ | Branch (51:13): [True: 0, False: 247] ------------------ 52| 0| l = strlen(f); 53| | 54| | /* Special case for the empty string */ 55| 247| if (l == 1 && *f == '_') ------------------ | Branch (55:13): [True: 32, False: 215] | Branch (55:23): [True: 1, False: 31] ------------------ 56| 1| return strdup(""); 57| | 58| 246| r = new(char, l + 1); ------------------ | | 17| 246|#define new(t, n) ((t*) malloc_multiply(n, sizeof(t))) ------------------ 59| 246| if (!r) ------------------ | Branch (59:13): [True: 0, False: 246] ------------------ 60| 0| return NULL; 61| | 62| 13.7M| for (i = 0, t = r; i < l; ++i) { ------------------ | Branch (62:28): [True: 13.7M, False: 246] ------------------ 63| 13.7M| if (f[i] == '_') { ------------------ | Branch (63:21): [True: 1.70M, False: 12.0M] ------------------ 64| 1.70M| int a, b; 65| | 66| 1.70M| if (l - i < 3 || ------------------ | Branch (66:29): [True: 72, False: 1.70M] ------------------ 67| 1.70M| (a = unhexchar(f[i + 1])) < 0 || ------------------ | Branch (67:29): [True: 1.66M, False: 37.7k] ------------------ 68| 1.70M| (b = unhexchar(f[i + 2])) < 0) { ------------------ | Branch (68:29): [True: 36.1k, False: 1.58k] ------------------ 69| | /* Invalid escape code, let's take it literal then */ 70| 1.70M| *(t++) = '_'; 71| 1.70M| } else { 72| 1.58k| *(t++) = (char) ((a << 4) | b); 73| 1.58k| i += 2; 74| 1.58k| } 75| 1.70M| } else 76| 12.0M| *(t++) = f[i]; 77| 13.7M| } 78| | 79| 246| *t = 0; 80| | 81| 246| return r; 82| 246|} getenv_bool: 991| 247|int getenv_bool(const char *p) { 992| 247| const char *e; 993| | 994| 247| e = getenv(p); 995| 247| if (!e) ------------------ | Branch (995:13): [True: 247, False: 0] ------------------ 996| 247| return -ENXIO; 997| | 998| 0| return parse_boolean(e); 999| 247|} log.c:_reset_errno_: 23| 247|static inline void _reset_errno_(int *saved_errno) { 24| 247| if (*saved_errno < 0) /* Invalidated by UNPROTECT_ERRNO? */ ------------------ | Branch (24:13): [True: 0, False: 247] ------------------ 25| 0| return; 26| | 27| 247| errno = *saved_errno; 28| 247|} safe_close: 56| 494|int safe_close(int fd) { 57| | /* 58| | * Like close_nointr() but cannot fail. Guarantees errno is unchanged. Is a noop for negative fds, 59| | * and returns -EBADF, so that it can be used in this syntax: 60| | * 61| | * fd = safe_close(fd); 62| | */ 63| | 64| 494| if (fd >= 0) { ------------------ | Branch (64:13): [True: 0, False: 494] ------------------ 65| 0| PROTECT_ERRNO; ------------------ | | 31| 0| _cleanup_(_reset_errno_) _unused_ int _saved_errno_ = errno | | ------------------ | | | | 78| 0|#define _cleanup_(x) __attribute__((__cleanup__(x))) | | ------------------ ------------------ 66| | 67| | /* The kernel might return pretty much any error code 68| | * via close(), but the fd will be closed anyway. The 69| | * only condition we want to check for here is whether 70| | * the fd was invalid at all... */ 71| | 72| 0| assert_se(close_nointr(fd) != -EBADF); ------------------ | | 65| 0|#define assert_se(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 0| do { \ | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 0| } while (false) | | ------------------ ------------------ 73| 0| } 74| | 75| 494| return -EBADF; 76| 494|} hexchar: 35| 4.56M|char hexchar(int x) { 36| 4.56M| static const char table[] = "0123456789abcdef"; 37| | 38| 4.56M| return table[x & 15]; 39| 4.56M|} unhexchar: 41| 1.74M|int unhexchar(char c) { 42| | 43| 1.74M| if (c >= '0' && c <= '9') ------------------ | Branch (43:13): [True: 1.72M, False: 17.5k] | Branch (43:25): [True: 1.43k, False: 1.72M] ------------------ 44| 1.43k| return c - '0'; 45| | 46| 1.73M| if (c >= 'a' && c <= 'f') ------------------ | Branch (46:13): [True: 1.60M, False: 133k] | Branch (46:25): [True: 2.42k, False: 1.60M] ------------------ 47| 2.42k| return c - 'a' + 10; 48| | 49| 1.73M| if (c >= 'A' && c <= 'F') ------------------ | Branch (49:13): [True: 1.71M, False: 18.2k] | Branch (49:25): [True: 35.4k, False: 1.68M] ------------------ 50| 35.4k| return c - 'A' + 10; 51| | 52| 1.70M| return -EINVAL; 53| 1.73M|} stderr_is_journal: 233| 247|bool stderr_is_journal(void) { 234| 247| _cleanup_free_ char *w = NULL; ------------------ | | 82| 247|#define _cleanup_free_ _cleanup_(freep) | | ------------------ | | | | 78| 247|#define _cleanup_(x) __attribute__((__cleanup__(x))) | | ------------------ ------------------ 235| 247| const char *e; 236| 247| uint64_t dev, ino; 237| 247| struct stat st; 238| | 239| 247| e = getenv("JOURNAL_STREAM"); 240| 247| if (!e) ------------------ | Branch (240:13): [True: 247, False: 0] ------------------ 241| 247| return false; 242| | 243| 0| if (extract_first_word(&e, &w, ":", EXTRACT_DONT_COALESCE_SEPARATORS) <= 0) ------------------ | Branch (243:13): [True: 0, False: 0] ------------------ 244| 0| return false; 245| 0| if (!e) ------------------ | Branch (245:13): [True: 0, False: 0] ------------------ 246| 0| return false; 247| | 248| 0| if (safe_atou64(w, &dev) < 0) ------------------ | Branch (248:13): [True: 0, False: 0] ------------------ 249| 0| return false; 250| 0| if (safe_atou64(e, &ino) < 0) ------------------ | Branch (250:13): [True: 0, False: 0] ------------------ 251| 0| return false; 252| | 253| 0| if (fstat(STDERR_FILENO, &st) < 0) ------------------ | Branch (253:13): [True: 0, False: 0] ------------------ 254| 0| return false; 255| | 256| 0| return st.st_dev == dev && st.st_ino == ino; ------------------ | Branch (256:16): [True: 0, False: 0] | Branch (256:36): [True: 0, False: 0] ------------------ 257| 0|} log_open: 259| 247|int log_open(void) { 260| 247| int r; 261| | 262| | /* Do not call from library code. */ 263| | 264| | /* This function is often called in preparation for logging. Let's make sure we don't clobber errno, 265| | * so that a call to a logging function immediately following a log_open() call can still easily 266| | * reference an error that happened immediately before the log_open() call. */ 267| 247| PROTECT_ERRNO; ------------------ | | 31| 247| _cleanup_(_reset_errno_) _unused_ int _saved_errno_ = errno | | ------------------ | | | | 78| 247|#define _cleanup_(x) __attribute__((__cleanup__(x))) | | ------------------ ------------------ 268| | 269| | /* If we don't use the console, we close it here to not get killed by SAK. If we don't use syslog, we 270| | * close it here too, so that we are not confused by somebody deleting the socket in the fs, and to 271| | * make sure we don't use it if prohibit_ipc is set. If we don't use /dev/kmsg we still keep it open, 272| | * because there is no reason to close it. */ 273| | 274| 247| if (log_target == LOG_TARGET_NULL) { ------------------ | Branch (274:13): [True: 0, False: 247] ------------------ 275| 0| log_close_journal(); 276| 0| log_close_syslog(); 277| 0| log_close_console(); 278| 0| return 0; 279| 0| } 280| | 281| 247| if (getpid_cached() == 1 || ------------------ | Branch (281:13): [True: 0, False: 247] ------------------ 282| 247| stderr_is_journal() || ------------------ | Branch (282:13): [True: 0, False: 247] ------------------ 283| 247| IN_SET(log_target, ------------------ | | 361| 247| ({ \ | | ------------------ | | | Branch (361:9): [True: 0, False: 247] | | ------------------ | | 362| 247| bool _found = false; \ | | 363| 247| /* If the build breaks in the line below, you need to extend the case macros. We use typeof(+x) \ | | 364| 247| * here to widen the type of x if it is a bit-field as this would otherwise be illegal. */ \ | | 365| 247| static const typeof(+x) __assert_in_set[] _unused_ = { first, __VA_ARGS__ }; \ | | 366| 247| assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ | | ------------------ | | | | 142| 247|#define assert_cc(expr) _Static_assert(expr, #expr) | | ------------------ | | 367| 247| switch (x) { \ | | 368| 0| FOR_EACH_MAKE_CASE(first, __VA_ARGS__) \ | | ------------------ | | | | 356| 0| GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ | | | | ------------------ | | | | | | 354| 0|#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME | | | | | | ------------------ | | | | | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | | | | | ------------------ | | | | | | | | | | 337| 0|#define CASE_F_5(X, ...) case X: CASE_F_4( __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 336| 0|#define CASE_F_4(X, ...) case X: CASE_F_3( __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 335| 0|#define CASE_F_3(X, ...) case X: CASE_F_2( __VA_ARGS__) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 334| 0|#define CASE_F_2(X, ...) case X: CASE_F_1( __VA_ARGS__) | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | 333| 0|#define CASE_F_1(X) case X: | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | | | Branch (333:27): [True: 0, False: 247] | | | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | Branch (334:27): [True: 0, False: 247] | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (335:27): [True: 0, False: 247] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (336:27): [True: 0, False: 247] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (337:27): [True: 0, False: 247] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | 358| 0| (__VA_ARGS__) | | ------------------ | | 369| 0| _found = true; \ | | 370| 0| break; \ | | 371| 247| default: \ | | ------------------ | | | Branch (371:17): [True: 247, False: 0] | | ------------------ | | 372| 247| ; \ | | 373| 247| } \ | | 374| 247| _found; \ | | 375| 247| }) ------------------ 284| 247| LOG_TARGET_KMSG, 285| 247| LOG_TARGET_JOURNAL, 286| 247| LOG_TARGET_JOURNAL_OR_KMSG, 287| 247| LOG_TARGET_SYSLOG, 288| 247| LOG_TARGET_SYSLOG_OR_KMSG)) { 289| | 290| 0| if (!prohibit_ipc) { ------------------ | Branch (290:21): [True: 0, False: 0] ------------------ 291| 0| if (IN_SET(log_target, ------------------ | | 361| 0| ({ \ | | ------------------ | | | Branch (361:9): [True: 0, False: 0] | | ------------------ | | 362| 0| bool _found = false; \ | | 363| 0| /* If the build breaks in the line below, you need to extend the case macros. We use typeof(+x) \ | | 364| 0| * here to widen the type of x if it is a bit-field as this would otherwise be illegal. */ \ | | 365| 0| static const typeof(+x) __assert_in_set[] _unused_ = { first, __VA_ARGS__ }; \ | | 366| 0| assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ | | ------------------ | | | | 142| 0|#define assert_cc(expr) _Static_assert(expr, #expr) | | ------------------ | | 367| 0| switch (x) { \ | | 368| 0| FOR_EACH_MAKE_CASE(first, __VA_ARGS__) \ | | ------------------ | | | | 356| 0| GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ | | | | ------------------ | | | | | | 354| 0|#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME | | | | | | ------------------ | | | | | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | | | | | ------------------ | | | | | | | | | | 335| 0|#define CASE_F_3(X, ...) case X: CASE_F_2( __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 334| 0|#define CASE_F_2(X, ...) case X: CASE_F_1( __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 333| 0|#define CASE_F_1(X) case X: | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (333:27): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (334:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (335:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | 358| 0| (__VA_ARGS__) | | ------------------ | | 369| 0| _found = true; \ | | 370| 0| break; \ | | 371| 0| default: \ | | ------------------ | | | Branch (371:17): [True: 0, False: 0] | | ------------------ | | 372| 0| ; \ | | 373| 0| } \ | | 374| 0| _found; \ | | 375| 0| }) ------------------ 292| 0| LOG_TARGET_AUTO, 293| 0| LOG_TARGET_JOURNAL_OR_KMSG, 294| 0| LOG_TARGET_JOURNAL)) { 295| | 296| 0| r = log_open_journal(); 297| 0| if (r >= 0) { ------------------ | Branch (297:37): [True: 0, False: 0] ------------------ 298| 0| log_close_syslog(); 299| 0| log_close_console(); 300| 0| return r; 301| 0| } 302| 0| } 303| | 304| 0| if (IN_SET(log_target, ------------------ | | 361| 0| ({ \ | | ------------------ | | | Branch (361:9): [True: 0, False: 0] | | ------------------ | | 362| 0| bool _found = false; \ | | 363| 0| /* If the build breaks in the line below, you need to extend the case macros. We use typeof(+x) \ | | 364| 0| * here to widen the type of x if it is a bit-field as this would otherwise be illegal. */ \ | | 365| 0| static const typeof(+x) __assert_in_set[] _unused_ = { first, __VA_ARGS__ }; \ | | 366| 0| assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ | | ------------------ | | | | 142| 0|#define assert_cc(expr) _Static_assert(expr, #expr) | | ------------------ | | 367| 0| switch (x) { \ | | 368| 0| FOR_EACH_MAKE_CASE(first, __VA_ARGS__) \ | | ------------------ | | | | 356| 0| GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ | | | | ------------------ | | | | | | 354| 0|#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME | | | | | | ------------------ | | | | | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | | | | | ------------------ | | | | | | | | | | 334| 0|#define CASE_F_2(X, ...) case X: CASE_F_1( __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 333| 0|#define CASE_F_1(X) case X: | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (333:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (334:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | 358| 0| (__VA_ARGS__) | | ------------------ | | 369| 0| _found = true; \ | | 370| 0| break; \ | | 371| 0| default: \ | | ------------------ | | | Branch (371:17): [True: 0, False: 0] | | ------------------ | | 372| 0| ; \ | | 373| 0| } \ | | 374| 0| _found; \ | | 375| 0| }) ------------------ 305| 0| LOG_TARGET_SYSLOG_OR_KMSG, 306| 0| LOG_TARGET_SYSLOG)) { 307| | 308| 0| r = log_open_syslog(); 309| 0| if (r >= 0) { ------------------ | Branch (309:37): [True: 0, False: 0] ------------------ 310| 0| log_close_journal(); 311| 0| log_close_console(); 312| 0| return r; 313| 0| } 314| 0| } 315| 0| } 316| | 317| 0| if (IN_SET(log_target, LOG_TARGET_AUTO, ------------------ | | 361| 0| ({ \ | | ------------------ | | | Branch (361:9): [True: 0, False: 0] | | ------------------ | | 362| 0| bool _found = false; \ | | 363| 0| /* If the build breaks in the line below, you need to extend the case macros. We use typeof(+x) \ | | 364| 0| * here to widen the type of x if it is a bit-field as this would otherwise be illegal. */ \ | | 365| 0| static const typeof(+x) __assert_in_set[] _unused_ = { first, __VA_ARGS__ }; \ | | 366| 0| assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ | | ------------------ | | | | 142| 0|#define assert_cc(expr) _Static_assert(expr, #expr) | | ------------------ | | 367| 0| switch (x) { \ | | 368| 0| FOR_EACH_MAKE_CASE(first, __VA_ARGS__) \ | | ------------------ | | | | 356| 0| GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ | | | | ------------------ | | | | | | 354| 0|#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME | | | | | | ------------------ | | | | | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | | | | | ------------------ | | | | | | | | | | 336| 0|#define CASE_F_4(X, ...) case X: CASE_F_3( __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 335| 0|#define CASE_F_3(X, ...) case X: CASE_F_2( __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 334| 0|#define CASE_F_2(X, ...) case X: CASE_F_1( __VA_ARGS__) | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 333| 0|#define CASE_F_1(X) case X: | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | | Branch (333:27): [True: 0, False: 0] | | | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | Branch (334:27): [True: 0, False: 0] | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (335:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (336:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | 358| 0| (__VA_ARGS__) | | ------------------ | | 369| 0| _found = true; \ | | 370| 0| break; \ | | 371| 0| default: \ | | ------------------ | | | Branch (371:17): [True: 0, False: 0] | | ------------------ | | 372| 0| ; \ | | 373| 0| } \ | | 374| 0| _found; \ | | 375| 0| }) ------------------ 318| 0| LOG_TARGET_JOURNAL_OR_KMSG, 319| 0| LOG_TARGET_SYSLOG_OR_KMSG, 320| 0| LOG_TARGET_KMSG)) { 321| 0| r = log_open_kmsg(); 322| 0| if (r >= 0) { ------------------ | Branch (322:29): [True: 0, False: 0] ------------------ 323| 0| log_close_journal(); 324| 0| log_close_syslog(); 325| 0| log_close_console(); 326| 0| return r; 327| 0| } 328| 0| } 329| 0| } 330| | 331| 247| log_close_journal(); 332| 247| log_close_syslog(); 333| | 334| 247| return log_open_console(); 335| 247|} log_set_target: 337| 247|void log_set_target(LogTarget target) { 338| 247| assert(target >= 0); ------------------ | | 72| 247|#define assert(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 247| do { \ | | | | 59| 247| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 247|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 247] | | | | | | ------------------ | | | | ------------------ | | | | 60| 247| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 247| } while (false) | | ------------------ ------------------ 339| 247| assert(target < _LOG_TARGET_MAX); ------------------ | | 72| 247|#define assert(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 247| do { \ | | | | 59| 247| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 247|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 247] | | | | | | ------------------ | | | | ------------------ | | | | 60| 247| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 247| } while (false) | | ------------------ ------------------ 340| | 341| 247| if (upgrade_syslog_to_journal) { ------------------ | Branch (341:13): [True: 0, False: 247] ------------------ 342| 0| if (target == LOG_TARGET_SYSLOG) ------------------ | Branch (342:21): [True: 0, False: 0] ------------------ 343| 0| target = LOG_TARGET_JOURNAL; 344| 0| else if (target == LOG_TARGET_SYSLOG_OR_KMSG) ------------------ | Branch (344:26): [True: 0, False: 0] ------------------ 345| 0| target = LOG_TARGET_JOURNAL_OR_KMSG; 346| 0| } 347| | 348| 247| log_target = target; 349| 247|} log_set_max_level: 372| 247|int log_set_max_level(int level) { 373| 247| assert(level == LOG_NULL || log_level_is_valid(level)); ------------------ | | 72| 247|#define assert(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 247| do { \ | | | | 59| 247| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 494|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 247] | | | | | | | Branch (95:44): [True: 0, False: 247] | | | | | | | Branch (95:44): [True: 247, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 60| 247| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 247| } while (false) | | ------------------ ------------------ 374| | 375| 247| int old = log_max_level; 376| 247| log_max_level = level; 377| | 378| | /* Also propagate max log level to libc's syslog(), just in case some other component loaded into our 379| | * process logs directly via syslog(). You might wonder why we maintain our own log level variable if 380| | * libc has the same functionality. This has multiple reasons, first and foremost that we want to 381| | * apply this to all our log targets, not just syslog and console. Moreover, we cannot query the 382| | * current log mask from glibc without changing it, but that's useful for testing the current log 383| | * level before even entering the log functions like we do in our macros. */ 384| 247| setlogmask(LOG_UPTO(level)); 385| | 386| | /* Ensure that our own LOG_NULL define maps sanely to the log mask */ 387| 247| assert_cc(LOG_UPTO(LOG_NULL) == 0); ------------------ | | 142| 247|#define assert_cc(expr) _Static_assert(expr, #expr) ------------------ 388| | 389| 247| return old; 390| 247|} log_parse_environment_variables: 1321| 247|void log_parse_environment_variables(void) { 1322| 247| const char *e; 1323| 247| int r; 1324| | 1325| 247| e = getenv("SYSTEMD_LOG_TARGET"); 1326| 247| if (e && log_set_target_from_string(e) < 0) ------------------ | Branch (1326:13): [True: 0, False: 247] | Branch (1326:18): [True: 0, False: 0] ------------------ 1327| 247| log_warning("Failed to parse log target '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1328| | 1329| 247| e = getenv("SYSTEMD_LOG_LEVEL"); 1330| 247| if (e) { ------------------ | Branch (1330:13): [True: 0, False: 247] ------------------ 1331| 0| r = log_set_max_level_from_string(e); 1332| 0| if (r < 0) ------------------ | Branch (1332:21): [True: 0, False: 0] ------------------ 1333| 0| log_warning_errno(r, "Failed to parse log level '%s', ignoring: %m", e); ------------------ | | 231| 0|#define log_warning_errno(error, ...) log_full_errno(LOG_WARNING, error, __VA_ARGS__) | | ------------------ | | | | 204| 0| ({ \ | | | | 205| 0| int _error = (error); \ | | | | 206| 0| ASSERT_NON_ZERO(_error); \ | | | | ------------------ | | | | | | 198| 0|# define ASSERT_NON_ZERO(x) assert((x) != 0) | | | | | | ------------------ | | | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | | | ------------------ | | | | | | | | | | 58| 0| do { \ | | | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 61| 0| } while (false) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 207| 0| log_full_errno_zerook(level, _error, __VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 208| 0| }) | | ------------------ ------------------ 1334| 247| } else { 1335| | /* If no explicit log level is specified then let's see if this is a debug invocation, and if 1336| | * so raise the log level to debug too. Note that this is not symmetric: just because 1337| | * DEBUG_INVOCATION is explicitly set to 0 we won't lower the log level below debug. This 1338| | * follows the logic that debug logging is an opt-in thing anyway, and if there's any reason 1339| | * to enable it we should not disable it here automatically. */ 1340| 247| r = getenv_bool("DEBUG_INVOCATION"); 1341| 247| if (r < 0 && r != -ENXIO) ------------------ | Branch (1341:21): [True: 247, False: 0] | Branch (1341:30): [True: 0, False: 247] ------------------ 1342| 247| log_warning_errno(r, "Failed to parse $DEBUG_INVOCATION value, ignoring: %m"); ------------------ | | 231| 0|#define log_warning_errno(error, ...) log_full_errno(LOG_WARNING, error, __VA_ARGS__) | | ------------------ | | | | 204| 0| ({ \ | | | | 205| 0| int _error = (error); \ | | | | 206| 0| ASSERT_NON_ZERO(_error); \ | | | | ------------------ | | | | | | 198| 0|# define ASSERT_NON_ZERO(x) assert((x) != 0) | | | | | | ------------------ | | | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | | | ------------------ | | | | | | | | | | 58| 0| do { \ | | | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 61| 0| } while (false) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 207| 0| log_full_errno_zerook(level, _error, __VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 208| 0| }) | | ------------------ ------------------ 1343| 247| else if (r > 0) ------------------ | Branch (1343:26): [True: 0, False: 247] ------------------ 1344| 0| log_set_max_level(LOG_DEBUG); 1345| 247| } 1346| | 1347| 247| e = getenv("SYSTEMD_LOG_COLOR"); 1348| 247| if (e && log_show_color_from_string(e) < 0) ------------------ | Branch (1348:13): [True: 0, False: 247] | Branch (1348:18): [True: 0, False: 0] ------------------ 1349| 247| log_warning("Failed to parse log color '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1350| | 1351| 247| e = getenv("SYSTEMD_LOG_LOCATION"); 1352| 247| if (e && log_show_location_from_string(e) < 0) ------------------ | Branch (1352:13): [True: 0, False: 247] | Branch (1352:18): [True: 0, False: 0] ------------------ 1353| 247| log_warning("Failed to parse log location '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1354| | 1355| 247| e = getenv("SYSTEMD_LOG_TIME"); 1356| 247| if (e && log_show_time_from_string(e) < 0) ------------------ | Branch (1356:13): [True: 0, False: 247] | Branch (1356:18): [True: 0, False: 0] ------------------ 1357| 247| log_warning("Failed to parse log time '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1358| | 1359| 247| e = getenv("SYSTEMD_LOG_TID"); 1360| 247| if (e && log_show_tid_from_string(e) < 0) ------------------ | Branch (1360:13): [True: 0, False: 247] | Branch (1360:18): [True: 0, False: 0] ------------------ 1361| 247| log_warning("Failed to parse log tid '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1362| | 1363| 247| e = getenv("SYSTEMD_LOG_RATELIMIT_KMSG"); 1364| 247| if (e && log_set_ratelimit_kmsg_from_string(e) < 0) ------------------ | Branch (1364:13): [True: 0, False: 247] | Branch (1364:18): [True: 0, False: 0] ------------------ 1365| 247| log_warning("Failed to parse log ratelimit kmsg boolean '%s', ignoring.", e); ------------------ | | 223| 0|#define log_warning(...) log_full(LOG_WARNING, __VA_ARGS__) | | ------------------ | | | | 211| 0| ({ \ | | | | 212| 0| if (BUILD_MODE_DEVELOPER) \ | | | | ------------------ | | | | | | 23| 0|#define BUILD_MODE_DEVELOPER 1 | | | | | | ------------------ | | | | | | | Branch (23:30): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 213| 0| assert(!strstr(fmt, "%m")); \ | | | | ------------------ | | | | | | 72| 0|#define assert(expr) assert_message_se(expr, #expr) | | | | | | ------------------ | | | | | | | | 58| 0| do { \ | | | | | | | | 59| 0| if (_unlikely_(!(expr))) \ | | | | | | | | ------------------ | | | | | | | | | | 95| 0|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (95:23): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 60| 0| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | | | | | ------------------ | | | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | | | ------------------ | | | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 61| 0| } while (false) | | | | | | ------------------ | | | | ------------------ | | | | 214| 0| (void) log_full_errno_zerook(level, 0, fmt, ##__VA_ARGS__); \ | | | | ------------------ | | | | | | 189| 0| ({ \ | | | | | | 190| 0| int _level = (level), _e = (error); \ | | | | | | 191| 0| _e = (log_get_max_level() >= LOG_PRI(_level)) \ | | | | | | ------------------ | | | | | | | Branch (191:22): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 192| 0| ? log_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \ | | | | | | ------------------ | | | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | | | ------------------ | | | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 193| 0| : -ERRNO_VALUE(_e); \ | | | | | | ------------------ | | | | | | | | 36| 0|#define ERRNO_VALUE(val) (ABS(val) & ~(1 << 30)) | | | | | | | | ------------------ | | | | | | | | | | 172| 0|# define ABS(a) __builtin_llabs(a) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 194| 0| _e < 0 ? _e : -ESTRPIPE; \ | | | | | | ------------------ | | | | | | | Branch (194:17): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 195| 0| }) | | | | ------------------ | | | | 215| 0| }) | | ------------------ ------------------ 1366| 247|} log_parse_environment: 1368| 247|void log_parse_environment(void) { 1369| | /* Do not call from library code. */ 1370| | 1371| 247| if (should_parse_proc_cmdline()) ------------------ | Branch (1371:13): [True: 0, False: 247] ------------------ 1372| 0| (void) proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX); 1373| | 1374| 247| log_parse_environment_variables(); 1375| 247|} log_show_color: 1409| 1|void log_show_color(bool b) { 1410| 1| show_color = b; 1411| 1|} log_on_console: 1485| 247|bool log_on_console(void) { 1486| 247| if (IN_SET(log_target, LOG_TARGET_CONSOLE, ------------------ | | 361| 247| ({ \ | | ------------------ | | | Branch (361:9): [True: 0, False: 247] | | ------------------ | | 362| 247| bool _found = false; \ | | 363| 247| /* If the build breaks in the line below, you need to extend the case macros. We use typeof(+x) \ | | 364| 247| * here to widen the type of x if it is a bit-field as this would otherwise be illegal. */ \ | | 365| 247| static const typeof(+x) __assert_in_set[] _unused_ = { first, __VA_ARGS__ }; \ | | 366| 247| assert_cc(ELEMENTSOF(__assert_in_set) <= 20); \ | | ------------------ | | | | 142| 247|#define assert_cc(expr) _Static_assert(expr, #expr) | | ------------------ | | 367| 247| switch (x) { \ | | 368| 0| FOR_EACH_MAKE_CASE(first, __VA_ARGS__) \ | | ------------------ | | | | 356| 0| GET_CASE_F(__VA_ARGS__,CASE_F_20,CASE_F_19,CASE_F_18,CASE_F_17,CASE_F_16,CASE_F_15,CASE_F_14,CASE_F_13,CASE_F_12,CASE_F_11, \ | | | | ------------------ | | | | | | 354| 0|#define GET_CASE_F(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME | | | | | | ------------------ | | | | | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | | | | | ------------------ | | | | | | | | | | 334| 0|#define CASE_F_2(X, ...) case X: CASE_F_1( __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 333| 0|#define CASE_F_1(X) case X: | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (333:27): [True: 0, False: 247] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (334:27): [True: 0, False: 247] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 357| 0| CASE_F_10,CASE_F_9,CASE_F_8,CASE_F_7,CASE_F_6,CASE_F_5,CASE_F_4,CASE_F_3,CASE_F_2,CASE_F_1) \ | | | | 358| 0| (__VA_ARGS__) | | ------------------ | | 369| 0| _found = true; \ | | 370| 0| break; \ | | 371| 247| default: \ | | ------------------ | | | Branch (371:17): [True: 247, False: 0] | | ------------------ | | 372| 247| ; \ | | 373| 247| } \ | | 374| 247| _found; \ | | 375| 247| }) ------------------ 1487| 247| LOG_TARGET_CONSOLE_PREFIXED)) 1488| 0| return true; 1489| | 1490| 247| return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0; ------------------ | Branch (1490:16): [True: 247, False: 0] | Branch (1490:33): [True: 247, False: 0] | Branch (1490:48): [True: 247, False: 0] ------------------ 1491| 247|} log_setup: 1714| 247|void log_setup(void) { 1715| 247| log_set_target(LOG_TARGET_AUTO); 1716| 247| log_parse_environment(); 1717| 247| (void) log_open(); 1718| 247| if (log_on_console() && show_color < 0) ------------------ | Branch (1718:13): [True: 247, False: 0] | Branch (1718:33): [True: 1, False: 246] ------------------ 1719| 1| log_show_color(true); 1720| 247|} log.c:log_close_journal: 202| 247|static void log_close_journal(void) { 203| | /* If the journal FD is bad, safe_close will fail, and will try to log, which will fail, so we'll 204| | * try to close the journal FD, which is bad, so safe_close will fail... Whether we can close it 205| | * or not, invalidate it immediately so that we don't get in a recursive loop until we run out of 206| | * stack. */ 207| 247| (void) safe_close(TAKE_FD(journal_fd)); ------------------ | | 99| 247|#define TAKE_FD(fd) TAKE_GENERIC(fd, int, -EBADF) | | ------------------ | | | | 380| 247| ({ \ | | | | 381| 247| type *_pvar_ = &(var); \ | | | | 382| 247| type _var_ = *_pvar_; \ | | | | 383| 247| type _nullvalue_ = nullvalue; \ | | | | 384| 247| *_pvar_ = _nullvalue_; \ | | | | 385| 247| _var_; \ | | | | 386| 247| }) | | ------------------ ------------------ 208| 247|} log.c:log_close_syslog: 136| 247|static void log_close_syslog(void) { 137| | /* See comment in log_close_journal() */ 138| 247| (void) safe_close(TAKE_FD(syslog_fd)); ------------------ | | 99| 247|#define TAKE_FD(fd) TAKE_GENERIC(fd, int, -EBADF) | | ------------------ | | | | 380| 247| ({ \ | | | | 381| 247| type *_pvar_ = &(var); \ | | | | 382| 247| type _var_ = *_pvar_; \ | | | | 383| 247| type _nullvalue_ = nullvalue; \ | | | | 384| 247| *_pvar_ = _nullvalue_; \ | | | | 385| 247| _var_; \ | | | | 386| 247| }) | | ------------------ ------------------ 139| 247|} log.c:log_open_console: 96| 247|static int log_open_console(void) { 97| | 98| 247| if (!always_reopen_console) { ------------------ | Branch (98:13): [True: 247, False: 0] ------------------ 99| 247| console_fd = STDERR_FILENO; 100| 247| console_fd_is_tty = -1; 101| 247| return 0; 102| 247| } 103| | 104| 0| if (console_fd < 3) { ------------------ | Branch (104:13): [True: 0, False: 0] ------------------ 105| 0| int fd; 106| | 107| 0| fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC); 108| 0| if (fd < 0) ------------------ | Branch (108:21): [True: 0, False: 0] ------------------ 109| 0| return fd; 110| | 111| 0| console_fd = fd_move_above_stdio(fd); 112| 0| console_fd_is_tty = true; 113| 0| } 114| | 115| 0| return 0; 116| 0|} log.c:should_parse_proc_cmdline: 1312| 247|static bool should_parse_proc_cmdline(void) { 1313| | /* PID1 always reads the kernel command line. */ 1314| 247| if (getpid_cached() == 1) ------------------ | Branch (1314:13): [True: 0, False: 247] ------------------ 1315| 0| return true; 1316| | 1317| | /* Otherwise, parse the command line if invoked directly by systemd. */ 1318| 247| return invoked_by_systemd(); 1319| 247|} getpid_cached: 1387| 494|pid_t getpid_cached(void) { 1388| 494| static bool installed = false; 1389| 494| pid_t current_value = CACHED_PID_UNSET; ------------------ | | 1377| 494|#define CACHED_PID_UNSET ((pid_t) 0) ------------------ 1390| | 1391| | /* getpid_cached() is much like getpid(), but caches the value in local memory, to avoid having to invoke a 1392| | * system call each time. This restores glibc behaviour from before 2.24, when getpid() was unconditionally 1393| | * cached. Starting with 2.24 getpid() started to become prohibitively expensive when used for detecting when 1394| | * objects were used across fork()s. With this caching the old behaviour is somewhat restored. 1395| | * 1396| | * https://bugzilla.redhat.com/show_bug.cgi?id=1443976 1397| | * https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=c579f48edba88380635ab98cb612030e3ed8691e 1398| | */ 1399| | 1400| 494| (void) __atomic_compare_exchange_n( 1401| 494| &cached_pid, 1402| 494| ¤t_value, 1403| 494| CACHED_PID_BUSY, ------------------ | | 1378| 494|#define CACHED_PID_BUSY ((pid_t) -1) ------------------ 1404| 494| false, 1405| 494| __ATOMIC_SEQ_CST, 1406| 494| __ATOMIC_SEQ_CST); 1407| | 1408| 494| switch (current_value) { 1409| | 1410| 1| case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */ ------------------ | | 1377| 1|#define CACHED_PID_UNSET ((pid_t) 0) ------------------ | Branch (1410:9): [True: 1, False: 493] ------------------ 1411| 1| pid_t new_pid; 1412| | 1413| 1| new_pid = getpid(); 1414| | 1415| 1| if (!installed) { ------------------ | Branch (1415:21): [True: 1, False: 0] ------------------ 1416| | /* __register_atfork() either returns 0 or -ENOMEM, in its glibc implementation. Since it's 1417| | * only half-documented (glibc doesn't document it but LSB does — though only superficially) 1418| | * we'll check for errors only in the most generic fashion possible. */ 1419| | 1420| 1| if (pthread_atfork(NULL, NULL, reset_cached_pid) != 0) { ------------------ | Branch (1420:29): [True: 0, False: 1] ------------------ 1421| | /* OOM? Let's try again later */ 1422| 0| cached_pid = CACHED_PID_UNSET; ------------------ | | 1377| 0|#define CACHED_PID_UNSET ((pid_t) 0) ------------------ 1423| 0| return new_pid; 1424| 0| } 1425| | 1426| 1| installed = true; 1427| 1| } 1428| | 1429| 1| cached_pid = new_pid; 1430| 1| return new_pid; 1431| 1| } 1432| | 1433| 0| case CACHED_PID_BUSY: /* Somebody else is currently initializing */ ------------------ | | 1378| 0|#define CACHED_PID_BUSY ((pid_t) -1) ------------------ | Branch (1433:9): [True: 0, False: 494] ------------------ 1434| 0| return getpid(); 1435| | 1436| 493| default: /* Properly initialized */ ------------------ | Branch (1436:9): [True: 493, False: 1] ------------------ 1437| 493| return current_value; 1438| 494| } 1439| 494|} log_level_is_valid: 101| 247|bool log_level_is_valid(int level) { 102| 247| return level >= 0 && level <= LOG_DEBUG; ------------------ | Branch (102:16): [True: 247, False: 0] | Branch (102:30): [True: 247, False: 0] ------------------ 103| 247|} bus-label.c:ascii_isalpha: 132| 2.49M|static inline bool ascii_isalpha(sd_char a) { 133| | /* A pure ASCII, locale independent version of isalpha() */ 134| 2.49M| return (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z'); ------------------ | Branch (134:17): [True: 1.20M, False: 1.29M] | Branch (134:29): [True: 189k, False: 1.01M] | Branch (134:43): [True: 2.24M, False: 56.2k] | Branch (134:55): [True: 18.4k, False: 2.22M] ------------------ 135| 2.49M|} bus-label.c:ascii_isdigit: 123| 2.28M|static inline bool ascii_isdigit(sd_char a) { 124| | /* A pure ASCII, locale independent version of isdigit() */ 125| 2.28M| return a >= '0' && a <= '9'; ------------------ | Branch (125:16): [True: 2.23M, False: 53.8k] | Branch (125:28): [True: 1.33k, False: 2.22M] ------------------ 126| 2.28M|} LLVMFuzzerTestOneInput: 7| 247|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 8| 247| _cleanup_free_ char *unescaped = NULL, *escaped = NULL; ------------------ | | 82| 247|#define _cleanup_free_ _cleanup_(freep) | | ------------------ | | | | 78| 247|#define _cleanup_(x) __attribute__((__cleanup__(x))) | | ------------------ ------------------ 9| | 10| 247| fuzz_setup_logging(); 11| | 12| 247| unescaped = bus_label_unescape_n((const char*)data, size); 13| 247| assert_se(unescaped != NULL); ------------------ | | 65| 247|#define assert_se(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 247| do { \ | | | | 59| 247| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 247|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 247] | | | | | | ------------------ | | | | ------------------ | | | | 60| 247| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 247| } while (false) | | ------------------ ------------------ 14| 247| escaped = bus_label_escape(unescaped); 15| 247| assert_se(escaped != NULL); ------------------ | | 65| 247|#define assert_se(expr) assert_message_se(expr, #expr) | | ------------------ | | | | 58| 247| do { \ | | | | 59| 247| if (_unlikely_(!(expr))) \ | | | | ------------------ | | | | | | 95| 247|#define _unlikely_(x) (__builtin_expect(!!(x), 0)) | | | | | | ------------------ | | | | | | | Branch (95:23): [True: 0, False: 247] | | | | | | ------------------ | | | | ------------------ | | | | 60| 247| log_assert_failed(message, PROJECT_FILE, __LINE__, __func__); \ | | | | ------------------ | | | | | | 472| 0|#define PROJECT_FILE (&__FILE__[STRLEN(RELATIVE_SOURCE_PATH) + 1]) | | | | | | ------------------ | | | | | | | | 397| 0|#define STRLEN(x) (sizeof(""x"") - sizeof(typeof(x[0]))) | | | | | | ------------------ | | | | ------------------ | | | | 61| 247| } while (false) | | ------------------ ------------------ 16| | 17| 247| return 0; 18| 247|} fuzz-bus-label.c:fuzz_setup_logging: 32| 247|static inline void fuzz_setup_logging(void) { 33| | /* We don't want to fill the logs and slow down stuff when running 34| | * in a fuzzing mode, so disable most of the logging. */ 35| 247| log_set_assert_return_is_critical(true); 36| 247| log_set_max_level(LOG_CRIT); 37| 247| log_setup(); 38| 247|}