X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fjournald-server.c;h=ba211b3724f99fe8518fe430472efc60419ea1c9;hp=364ab0f113f615bfc137a4723947ca67d710123c;hb=00a168618906bea43c3c57e20b9152582c324bf8;hpb=83d7d83bcc6c462ecbb4c8003e3a8b41f3b88d46 diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c index 364ab0f11..ba211b372 100644 --- a/src/journal/journald-server.c +++ b/src/journal/journald-server.c @@ -24,16 +24,13 @@ #include #include #include +#include #include #include #include #include -#ifdef HAVE_LOGIND -#include -#endif - #include "fileio.h" #include "mkdir.h" #include "hashmap.h" @@ -67,8 +64,9 @@ #define USER_JOURNALS_MAX 1024 -#define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC) -#define DEFAULT_RATE_LIMIT_BURST 200 +#define DEFAULT_SYNC_INTERVAL_USEC (5*USEC_PER_MINUTE) +#define DEFAULT_RATE_LIMIT_INTERVAL (30*USEC_PER_SEC) +#define DEFAULT_RATE_LIMIT_BURST 1000 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC) @@ -91,21 +89,22 @@ static const char* const split_mode_table[] = { DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode); DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting"); -static uint64_t available_space(Server *s) { +static uint64_t available_space(Server *s, bool verbose) { char ids[33]; - char _cleanup_free_ *p = NULL; - const char *f; + _cleanup_free_ char *p = NULL; sd_id128_t machine; struct statvfs ss; - uint64_t sum = 0, avail = 0, ss_avail = 0; + uint64_t sum = 0, ss_avail = 0, avail = 0; int r; - DIR _cleanup_closedir_ *d = NULL; + _cleanup_closedir_ DIR *d = NULL; usec_t ts; + const char *f; JournalMetrics *m; ts = now(CLOCK_MONOTONIC); - if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts) + if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts + && !verbose) return s->cached_available_space; r = sd_id128_get_machine(&machine); @@ -158,19 +157,27 @@ static uint64_t available_space(Server *s) { sum += (uint64_t) st.st_blocks * 512UL; } - avail = sum >= m->max_use ? 0 : m->max_use - sum; - ss_avail = ss.f_bsize * ss.f_bavail; + avail = ss_avail > m->keep_free ? ss_avail - m->keep_free : 0; - ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free; - - if (ss_avail < avail) - avail = ss_avail; - - s->cached_available_space = avail; + s->cached_available_space = MIN(m->max_use, avail) > sum ? MIN(m->max_use, avail) - sum : 0; s->cached_available_space_timestamp = ts; - return avail; + if (verbose) { + char fb1[FORMAT_BYTES_MAX], fb2[FORMAT_BYTES_MAX], fb3[FORMAT_BYTES_MAX], + fb4[FORMAT_BYTES_MAX], fb5[FORMAT_BYTES_MAX]; + + server_driver_message(s, SD_MESSAGE_JOURNAL_USAGE, + "%s journal is using %s (max %s, leaving %s of free %s, current limit %s).", + s->system_journal ? "Permanent" : "Runtime", + format_bytes(fb1, sizeof(fb1), sum), + format_bytes(fb2, sizeof(fb2), m->max_use), + format_bytes(fb3, sizeof(fb3), m->keep_free), + format_bytes(fb4, sizeof(fb4), ss_avail), + format_bytes(fb5, sizeof(fb5), MIN(m->max_use, avail))); + } + + return s->cached_available_space; } static void server_read_file_gid(Server *s) { @@ -229,9 +236,11 @@ void server_fix_perms(Server *s, JournalFile *f, uid_t uid) { } } + /* We do not recalculate the mask unconditionally here, + * so that the fchmod() mask above stays intact. */ if (acl_get_permset(entry, &permset) < 0 || acl_add_perm(permset, ACL_READ) < 0 || - acl_calc_mask(&acl) < 0) { + calc_acl_mask_if_needed(&acl) < 0) { log_warning("Failed to patch ACL on %s, ignoring: %m", f->path); goto finish; } @@ -245,7 +254,7 @@ finish: } static JournalFile* find_journal(Server *s, uid_t uid) { - char *p; + _cleanup_free_ char *p = NULL; int r; JournalFile *f; sd_id128_t machine; @@ -282,9 +291,7 @@ static JournalFile* find_journal(Server *s, uid_t uid) { journal_file_close(f); } - r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, s->system_journal, &f); - free(p); - + r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &f); if (r < 0) return s->system_journal; @@ -344,8 +351,33 @@ void server_rotate(Server *s) { } } +void server_sync(Server *s) { + static const struct itimerspec sync_timer_disable = {}; + JournalFile *f; + void *k; + Iterator i; + int r; + + if (s->system_journal) { + r = journal_file_set_offline(s->system_journal); + if (r < 0) + log_error("Failed to sync system journal: %s", strerror(-r)); + } + + HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) { + r = journal_file_set_offline(f); + if (r < 0) + log_error("Failed to sync user journal: %s", strerror(-r)); + } + + r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_disable, NULL); + if (r < 0) + log_error("Failed to disable max timer: %m"); + + s->sync_scheduled = false; +} + void server_vacuum(Server *s) { - char *p; char ids[33]; sd_id128_t machine; int r; @@ -363,64 +395,24 @@ void server_vacuum(Server *s) { sd_id128_to_string(machine, ids); if (s->system_journal) { - p = strappend("/var/log/journal/", ids); - if (!p) { - log_oom(); - return; - } + char *p = strappenda("/var/log/journal/", ids); r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec); if (r < 0 && r != -ENOENT) log_error("Failed to vacuum %s: %s", p, strerror(-r)); - free(p); } if (s->runtime_journal) { - p = strappend("/run/log/journal/", ids); - if (!p) { - log_oom(); - return; - } + char *p = strappenda("/run/log/journal/", ids); r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec); if (r < 0 && r != -ENOENT) log_error("Failed to vacuum %s: %s", p, strerror(-r)); - free(p); } s->cached_available_space_timestamp = 0; } -static char *shortened_cgroup_path(pid_t pid) { - int r; - char _cleanup_free_ *process_path = NULL, *init_path = NULL; - char *path; - - assert(pid > 0); - - r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path); - if (r < 0) - return NULL; - - r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path); - if (r < 0) - return NULL; - - if (endswith(init_path, "/system")) - init_path[strlen(init_path) - 7] = 0; - else if (streq(init_path, "/")) - init_path[0] = 0; - - if (startswith(process_path, init_path)) { - path = strdup(process_path + strlen(init_path)); - } else { - path = process_path; - process_path = NULL; - } - - return path; -} - bool shall_try_append_again(JournalFile *f, int r) { /* -E2BIG Hit configured limit @@ -450,7 +442,7 @@ bool shall_try_append_again(JournalFile *f, int r) { return true; } -static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) { +static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n, int priority) { JournalFile *f; bool vacuumed = false; int r; @@ -475,11 +467,18 @@ static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned } r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL); - if (r >= 0) + if (r >= 0) { + server_schedule_sync(s, priority); return; + } if (vacuumed || !shall_try_append_again(f, r)) { - log_error("Failed to write entry, ignoring: %s", strerror(-r)); + size_t size = 0; + unsigned i; + for (i = 0; i < n; i++) + size += iovec[i].iov_len; + + log_error("Failed to write entry (%d items, %zu bytes), ignoring: %s", n, size, strerror(-r)); return; } @@ -492,8 +491,15 @@ static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned log_debug("Retrying write."); r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL); - if (r < 0) - log_error("Failed to write entry, ignoring: %s", strerror(-r)); + if (r < 0) { + size_t size = 0; + unsigned i; + for (i = 0; i < n; i++) + size += iovec[i].iov_len; + + log_error("Failed to write entry (%d items, %zu bytes) despite vacuuming, ignoring: %s", n, size, strerror(-r)); + } else + server_schedule_sync(s, priority); } static void dispatch_message_real( @@ -502,165 +508,266 @@ static void dispatch_message_real( struct ucred *ucred, struct timeval *tv, const char *label, size_t label_len, - const char *unit_id) { - - char _cleanup_free_ *pid = NULL, *uid = NULL, *gid = NULL, - *source_time = NULL, *boot_id = NULL, *machine_id = NULL, - *comm = NULL, *cmdline = NULL, *hostname = NULL, - *audit_session = NULL, *audit_loginuid = NULL, - *exe = NULL, *cgroup = NULL, *session = NULL, - *owner_uid = NULL, *unit = NULL, *selinux_context = NULL; - - char idbuf[33]; + const char *unit_id, + int priority, + pid_t object_pid) { + + char pid[sizeof("_PID=") + DECIMAL_STR_MAX(pid_t)], + uid[sizeof("_UID=") + DECIMAL_STR_MAX(uid_t)], + gid[sizeof("_GID=") + DECIMAL_STR_MAX(gid_t)], + owner_uid[sizeof("_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)], + source_time[sizeof("_SOURCE_REALTIME_TIMESTAMP=") + DECIMAL_STR_MAX(usec_t)], + boot_id[sizeof("_BOOT_ID=") + 32] = "_BOOT_ID=", + machine_id[sizeof("_MACHINE_ID=") + 32] = "_MACHINE_ID=", + o_uid[sizeof("OBJECT_UID=") + DECIMAL_STR_MAX(uid_t)], + o_gid[sizeof("OBJECT_GID=") + DECIMAL_STR_MAX(gid_t)], + o_owner_uid[sizeof("OBJECT_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)]; + uid_t object_uid; + gid_t object_gid; + char *x; sd_id128_t id; int r; - char *t; + char *t, *c; uid_t realuid = 0, owner = 0, journal_uid; bool owner_valid = false; +#ifdef HAVE_AUDIT + char audit_session[sizeof("_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)], + audit_loginuid[sizeof("_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)], + o_audit_session[sizeof("OBJECT_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)], + o_audit_loginuid[sizeof("OBJECT_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)]; + + uint32_t audit; + uid_t loginuid; +#endif assert(s); assert(iovec); assert(n > 0); - assert(n + N_IOVEC_META_FIELDS <= m); + assert(n + N_IOVEC_META_FIELDS + (object_pid ? N_IOVEC_OBJECT_FIELDS : 0) <= m); if (ucred) { - uint32_t audit; - uid_t loginuid; - realuid = ucred->uid; - if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0) - IOVEC_SET_STRING(iovec[n++], pid); + sprintf(pid, "_PID=%lu", (unsigned long) ucred->pid); + IOVEC_SET_STRING(iovec[n++], pid); - if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0) - IOVEC_SET_STRING(iovec[n++], uid); + sprintf(uid, "_UID=%lu", (unsigned long) ucred->uid); + IOVEC_SET_STRING(iovec[n++], uid); - if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0) - IOVEC_SET_STRING(iovec[n++], gid); + sprintf(gid, "_GID=%lu", (unsigned long) ucred->gid); + IOVEC_SET_STRING(iovec[n++], gid); r = get_process_comm(ucred->pid, &t); if (r >= 0) { - comm = strappend("_COMM=", t); + x = strappenda("_COMM=", t); free(t); - - if (comm) - IOVEC_SET_STRING(iovec[n++], comm); + IOVEC_SET_STRING(iovec[n++], x); } r = get_process_exe(ucred->pid, &t); if (r >= 0) { - exe = strappend("_EXE=", t); + x = strappenda("_EXE=", t); free(t); - - if (exe) - IOVEC_SET_STRING(iovec[n++], exe); + IOVEC_SET_STRING(iovec[n++], x); } r = get_process_cmdline(ucred->pid, 0, false, &t); if (r >= 0) { - cmdline = strappend("_CMDLINE=", t); + x = strappenda("_CMDLINE=", t); free(t); + IOVEC_SET_STRING(iovec[n++], x); + } - if (cmdline) - IOVEC_SET_STRING(iovec[n++], cmdline); + r = get_process_capeff(ucred->pid, &t); + if (r >= 0) { + x = strappenda("_CAP_EFFECTIVE=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); } +#ifdef HAVE_AUDIT r = audit_session_from_pid(ucred->pid, &audit); - if (r >= 0) - if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0) - IOVEC_SET_STRING(iovec[n++], audit_session); + if (r >= 0) { + sprintf(audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit); + IOVEC_SET_STRING(iovec[n++], audit_session); + } r = audit_loginuid_from_pid(ucred->pid, &loginuid); - if (r >= 0) - if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0) - IOVEC_SET_STRING(iovec[n++], audit_loginuid); - - t = shortened_cgroup_path(ucred->pid); - if (t) { - cgroup = strappend("_SYSTEMD_CGROUP=", t); - free(t); - - if (cgroup) - IOVEC_SET_STRING(iovec[n++], cgroup); + if (r >= 0) { + sprintf(audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid); + IOVEC_SET_STRING(iovec[n++], audit_loginuid); } +#endif -#ifdef HAVE_LOGIND - if (sd_pid_get_session(ucred->pid, &t) >= 0) { - session = strappend("_SYSTEMD_SESSION=", t); - free(t); + r = cg_pid_get_path_shifted(ucred->pid, NULL, &c); + if (r >= 0) { + char *session = NULL; - if (session) + x = strappenda("_SYSTEMD_CGROUP=", c); + IOVEC_SET_STRING(iovec[n++], x); + + r = cg_path_get_session(c, &t); + if (r >= 0) { + session = strappenda("_SYSTEMD_SESSION=", t); + free(t); IOVEC_SET_STRING(iovec[n++], session); - } + } + + if (cg_path_get_owner_uid(c, &owner) >= 0) { + owner_valid = true; - if (sd_pid_get_owner_uid(ucred->pid, &owner) >= 0) { - owner_valid = true; - if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0) + sprintf(owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner); IOVEC_SET_STRING(iovec[n++], owner_uid); - } -#endif + } - if (cg_pid_get_unit(ucred->pid, &t) >= 0) { - unit = strappend("_SYSTEMD_UNIT=", t); - free(t); - } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) { - unit = strappend("_SYSTEMD_USER_UNIT=", t); - free(t); - } else if (unit_id) { - if (session) - unit = strappend("_SYSTEMD_USER_UNIT=", unit_id); - else - unit = strappend("_SYSTEMD_UNIT=", unit_id); - } + if (cg_path_get_unit(c, &t) >= 0) { + x = strappenda("_SYSTEMD_UNIT=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } else if (unit_id && !session) { + x = strappenda("_SYSTEMD_UNIT=", unit_id); + IOVEC_SET_STRING(iovec[n++], x); + } + + if (cg_path_get_user_unit(c, &t) >= 0) { + x = strappenda("_SYSTEMD_USER_UNIT=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } else if (unit_id && session) { + x = strappenda("_SYSTEMD_USER_UNIT=", unit_id); + IOVEC_SET_STRING(iovec[n++], x); + } - if (unit) - IOVEC_SET_STRING(iovec[n++], unit); + free(c); + } #ifdef HAVE_SELINUX if (label) { - selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len); - if (selinux_context) { - *((char*) mempcpy(stpcpy(selinux_context, "_SELINUX_CONTEXT="), label, label_len)) = 0; - IOVEC_SET_STRING(iovec[n++], selinux_context); - } + x = alloca(sizeof("_SELINUX_CONTEXT=") + label_len); + + *((char*) mempcpy(stpcpy(x, "_SELINUX_CONTEXT="), label, label_len)) = 0; + IOVEC_SET_STRING(iovec[n++], x); } else { security_context_t con; if (getpidcon(ucred->pid, &con) >= 0) { - selinux_context = strappend("_SELINUX_CONTEXT=", con); - if (selinux_context) - IOVEC_SET_STRING(iovec[n++], selinux_context); + x = strappenda("_SELINUX_CONTEXT=", con); + freecon(con); + IOVEC_SET_STRING(iovec[n++], x); } } #endif } + assert(n <= m); + + if (object_pid) { + r = get_process_uid(object_pid, &object_uid); + if (r >= 0) { + sprintf(o_uid, "OBJECT_UID=%lu", (unsigned long) object_uid); + IOVEC_SET_STRING(iovec[n++], o_uid); + } + + r = get_process_gid(object_pid, &object_gid); + if (r >= 0) { + sprintf(o_gid, "OBJECT_GID=%lu", (unsigned long) object_gid); + IOVEC_SET_STRING(iovec[n++], o_gid); + } + + r = get_process_comm(object_pid, &t); + if (r >= 0) { + x = strappenda("OBJECT_COMM=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + + r = get_process_exe(object_pid, &t); + if (r >= 0) { + x = strappenda("OBJECT_EXE=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + + r = get_process_cmdline(object_pid, 0, false, &t); + if (r >= 0) { + x = strappenda("OBJECT_CMDLINE=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + +#ifdef HAVE_AUDIT + r = audit_session_from_pid(object_pid, &audit); + if (r >= 0) { + sprintf(o_audit_session, "OBJECT_AUDIT_SESSION=%lu", (unsigned long) audit); + IOVEC_SET_STRING(iovec[n++], o_audit_session); + } + + r = audit_loginuid_from_pid(object_pid, &loginuid); + if (r >= 0) { + sprintf(o_audit_loginuid, "OBJECT_AUDIT_LOGINUID=%lu", (unsigned long) loginuid); + IOVEC_SET_STRING(iovec[n++], o_audit_loginuid); + } +#endif + + r = cg_pid_get_path_shifted(object_pid, NULL, &c); + if (r >= 0) { + x = strappenda("OBJECT_SYSTEMD_CGROUP=", c); + IOVEC_SET_STRING(iovec[n++], x); + + r = cg_path_get_session(c, &t); + if (r >= 0) { + x = strappenda("OBJECT_SYSTEMD_SESSION=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + + if (cg_path_get_owner_uid(c, &owner) >= 0) { + sprintf(o_owner_uid, "OBJECT_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner); + IOVEC_SET_STRING(iovec[n++], o_owner_uid); + } + + if (cg_path_get_unit(c, &t) >= 0) { + x = strappenda("OBJECT_SYSTEMD_UNIT=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + + if (cg_path_get_user_unit(c, &t) >= 0) { + x = strappenda("OBJECT_SYSTEMD_USER_UNIT=", t); + free(t); + IOVEC_SET_STRING(iovec[n++], x); + } + + free(c); + } + } + assert(n <= m); if (tv) { - if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu", - (unsigned long long) timeval_load(tv)) >= 0) - IOVEC_SET_STRING(iovec[n++], source_time); + sprintf(source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu", (unsigned long long) timeval_load(tv)); + IOVEC_SET_STRING(iovec[n++], source_time); } /* Note that strictly speaking storing the boot id here is * redundant since the entry includes this in-line * anyway. However, we need this indexed, too. */ r = sd_id128_get_boot(&id); - if (r >= 0) - if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0) - IOVEC_SET_STRING(iovec[n++], boot_id); + if (r >= 0) { + sd_id128_to_string(id, boot_id + strlen("_BOOT_ID=")); + IOVEC_SET_STRING(iovec[n++], boot_id); + } r = sd_id128_get_machine(&id); - if (r >= 0) - if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0) - IOVEC_SET_STRING(iovec[n++], machine_id); + if (r >= 0) { + sd_id128_to_string(id, machine_id + strlen("_MACHINE_ID=")); + IOVEC_SET_STRING(iovec[n++], machine_id); + } t = gethostname_malloc(); if (t) { - hostname = strappend("_HOSTNAME=", t); + x = strappenda("_HOSTNAME=", t); free(t); - if (hostname) - IOVEC_SET_STRING(iovec[n++], hostname); + IOVEC_SET_STRING(iovec[n++], x); } assert(n <= m); @@ -679,7 +786,7 @@ static void dispatch_message_real( else journal_uid = 0; - write_to_journal(s, journal_uid, iovec, n); + write_to_journal(s, journal_uid, iovec, n, priority); } void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) { @@ -688,7 +795,7 @@ void server_driver_message(Server *s, sd_id128_t message_id, const char *format, struct iovec iovec[N_IOVEC_META_FIELDS + 4]; int n = 0; va_list ap; - struct ucred ucred; + struct ucred ucred = {}; assert(s); assert(format); @@ -709,12 +816,11 @@ void server_driver_message(Server *s, sd_id128_t message_id, const char *format, IOVEC_SET_STRING(iovec[n++], mid); } - zero(ucred); ucred.pid = getpid(); ucred.uid = getuid(); ucred.gid = getgid(); - dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL); + dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL, LOG_INFO, 0); } void server_dispatch_message( @@ -724,10 +830,11 @@ void server_dispatch_message( struct timeval *tv, const char *label, size_t label_len, const char *unit_id, - int priority) { + int priority, + pid_t object_pid) { - int rl; - char _cleanup_free_ *path = NULL; + int rl, r; + _cleanup_free_ char *path = NULL; char *c; assert(s); @@ -739,11 +846,16 @@ void server_dispatch_message( if (LOG_PRI(priority) > s->max_level_store) return; + /* Stop early in case the information will not be stored + * in a journal. */ + if (s->storage == STORAGE_NONE) + return; + if (!ucred) goto finish; - path = shortened_cgroup_path(ucred->pid); - if (!path) + r = cg_pid_get_path_shifted(ucred->pid, NULL, &path); + if (r < 0) goto finish; /* example: /user/lennart/3/foobar @@ -763,7 +875,7 @@ void server_dispatch_message( } rl = journal_rate_limit_test(s->rate_limit, path, - priority & LOG_PRIMASK, available_space(s)); + priority & LOG_PRIMASK, available_space(s, false)); if (rl == 0) return; @@ -774,7 +886,7 @@ void server_dispatch_message( "Suppressed %u messages from %s", rl - 1, path); finish: - dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id); + dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id, priority, object_pid); } @@ -785,8 +897,10 @@ static int system_journal_open(Server *s) { char ids[33]; r = sd_id128_get_machine(&machine); - if (r < 0) + if (r < 0) { + log_error("Failed to get machine id: %s", strerror(-r)); return r; + } sd_id128_to_string(machine, ids); @@ -803,29 +917,15 @@ static int system_journal_open(Server *s) { if (s->storage == STORAGE_PERSISTENT) (void) mkdir("/var/log/journal/", 0755); - fn = strappend("/var/log/journal/", ids); - if (!fn) - return -ENOMEM; - + fn = strappenda("/var/log/journal/", ids); (void) mkdir(fn, 0755); - free(fn); - - fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL); - if (!fn) - return -ENOMEM; + fn = strappenda(fn, "/system.journal"); r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal); - free(fn); - - if (r >= 0) { - char fb[FORMAT_BYTES_MAX]; + if (r >= 0) server_fix_perms(s, s->system_journal, 0); - server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.", - format_bytes(fb, sizeof(fb), s->system_metrics.max_use)); - - } else if (r < 0) { - + else if (r < 0) { if (r != -ENOENT && r != -EROFS) log_warning("Failed to open system journal: %s", strerror(-r)); @@ -871,15 +971,12 @@ static int system_journal_open(Server *s) { } } - if (s->runtime_journal) { - char fb[FORMAT_BYTES_MAX]; - + if (s->runtime_journal) server_fix_perms(s, s->runtime_journal, 0); - server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.", - format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use)); - } } + available_space(s, true); + return r; } @@ -905,10 +1002,8 @@ int server_flush_to_var(Server *s) { log_debug("Flushing to /var..."); r = sd_id128_get_machine(&machine); - if (r < 0) { - log_error("Failed to get machine id: %s", strerror(-r)); + if (r < 0) return r; - } r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY); if (r < 0) { @@ -943,6 +1038,12 @@ int server_flush_to_var(Server *s) { server_rotate(s); server_vacuum(s); + if (!s->system_journal) { + log_notice("Didn't flush runtime journal since rotation of system journal wasn't successful."); + r = -EIO; + goto finish; + } + log_debug("Retrying write."); r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL); if (r < 0) { @@ -960,8 +1061,7 @@ finish: if (r >= 0) rm_rf("/run/log/journal", false, true, false); - if (j) - sd_journal_close(j); + sd_journal_close(j); return r; } @@ -991,22 +1091,40 @@ int process_event(Server *s, struct epoll_event *ev) { return -errno; } - log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo)); - if (sfsi.ssi_signo == SIGUSR1) { + log_info("Received request to flush runtime journal from PID %"PRIu32, + sfsi.ssi_pid); touch("/run/systemd/journal/flushed"); server_flush_to_var(s); + server_sync(s); return 1; } if (sfsi.ssi_signo == SIGUSR2) { + log_info("Received request to rotate journal from PID %"PRIu32, + sfsi.ssi_pid); server_rotate(s); server_vacuum(s); return 1; } + log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo)); + return 0; + } else if (ev->data.fd == s->sync_timer_fd) { + int r; + uint64_t t; + + log_debug("Got sync request from epoll."); + + r = read(ev->data.fd, (void *)&t, sizeof(t)); + if (r < 0) + return 0; + + server_sync(s); + return 1; + } else if (ev->data.fd == s->dev_kmsg_fd) { int r; @@ -1112,8 +1230,8 @@ int process_event(Server *s, struct epoll_event *ev) { label = (char*) CMSG_DATA(cmsg); label_len = cmsg->cmsg_len - CMSG_LEN(0); } else if (cmsg->cmsg_level == SOL_SOCKET && - cmsg->cmsg_type == SO_TIMESTAMP && - cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval))) + cmsg->cmsg_type == SO_TIMESTAMP && + cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval))) tv = (struct timeval*) CMSG_DATA(cmsg); else if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) { @@ -1123,15 +1241,8 @@ int process_event(Server *s, struct epoll_event *ev) { } if (ev->data.fd == s->syslog_fd) { - char *e; - if (n > 0 && n_fds == 0) { - e = memchr(s->buffer, '\n', n); - if (e) - *e = 0; - else - s->buffer[n] = 0; - + s->buffer[n] = 0; server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len); } else if (n_fds > 0) log_warning("Got file descriptors via syslog socket. Ignoring."); @@ -1216,7 +1327,7 @@ static int open_signalfd(Server *s) { } static int server_parse_proc_cmdline(Server *s) { - char _cleanup_free_ *line = NULL; + _cleanup_free_ char *line = NULL; char *w, *state; int r; size_t l; @@ -1231,7 +1342,7 @@ static int server_parse_proc_cmdline(Server *s) { } FOREACH_WORD_QUOTED(w, l, line, state) { - char _cleanup_free_ *word; + _cleanup_free_ char *word; word = strndup(w, l); if (!word) @@ -1263,8 +1374,8 @@ static int server_parse_proc_cmdline(Server *s) { } static int server_parse_config_file(Server *s) { - static const char *fn = "/etc/systemd/journald.conf"; - FILE _cleanup_fclose_ *f = NULL; + static const char fn[] = "/etc/systemd/journald.conf"; + _cleanup_fclose_ FILE *f = NULL; int r; assert(s); @@ -1278,24 +1389,80 @@ static int server_parse_config_file(Server *s) { return -errno; } - r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, - (void*) journald_gperf_lookup, false, s); + r = config_parse(NULL, fn, f, "Journal\0", config_item_perf_lookup, + (void*) journald_gperf_lookup, false, false, s); if (r < 0) log_warning("Failed to parse configuration file: %s", strerror(-r)); return r; } +static int server_open_sync_timer(Server *s) { + int r; + struct epoll_event ev; + + assert(s); + + s->sync_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); + if (s->sync_timer_fd < 0) + return -errno; + + zero(ev); + ev.events = EPOLLIN; + ev.data.fd = s->sync_timer_fd; + + r = epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->sync_timer_fd, &ev); + if (r < 0) { + log_error("Failed to add idle timer fd to epoll object: %m"); + return -errno; + } + + return 0; +} + +int server_schedule_sync(Server *s, int priority) { + int r; + + assert(s); + + if (priority <= LOG_CRIT) { + /* Immediately sync to disk when this is of priority CRIT, ALERT, EMERG */ + server_sync(s); + return 0; + } + + if (s->sync_scheduled) + return 0; + + if (s->sync_interval_usec) { + struct itimerspec sync_timer_enable = {}; + + timespec_store(&sync_timer_enable.it_value, s->sync_interval_usec); + + r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_enable, NULL); + if (r < 0) + return -errno; + } + + s->sync_scheduled = true; + + return 0; +} + int server_init(Server *s) { int n, r, fd; assert(s); zero(*s); - s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1; + s->sync_timer_fd = s->syslog_fd = s->native_fd = s->stdout_fd = + s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1; s->compress = true; s->seal = true; + s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC; + s->sync_scheduled = false; + s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL; s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST; @@ -1395,6 +1562,10 @@ int server_init(Server *s) { if (r < 0) return r; + r = server_open_sync_timer(s); + if (r < 0) + return r; + r = open_signalfd(s); if (r < 0) return r; @@ -1467,6 +1638,9 @@ void server_done(Server *s) { if (s->dev_kmsg_fd >= 0) close_nointr_nofail(s->dev_kmsg_fd); + if (s->sync_timer_fd >= 0) + close_nointr_nofail(s->sync_timer_fd); + if (s->rate_limit) journal_rate_limit_free(s->rate_limit);