From 90b059b608d6c53c8efb23b8791190dffadd1a17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Wed, 18 Sep 2019 17:52:30 +0200 Subject: [PATCH 1/6] pid1: do not warn if /run/systemd/relabel-extra.d/ doesn't exist After all, that is the expected state. --- src/core/mount-setup.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/mount-setup.c b/src/core/mount-setup.c index 72cf5a2caa..9d9263e8fa 100644 --- a/src/core/mount-setup.c +++ b/src/core/mount-setup.c @@ -469,7 +469,8 @@ static int relabel_extra(void) { } /* Remove when we complete things. */ - if (rmdir("/run/systemd/relabel-extra.d") < 0) + if (rmdir("/run/systemd/relabel-extra.d") < 0 && + errno != ENOENT) log_warning_errno(errno, "Failed to remove /run/systemd/relabel-extra.d/ directory: %m"); return c; From 8c227e7f2b0c4df0b4ab7345d6a01c589e0c21d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Thu, 19 Sep 2019 17:41:20 +0200 Subject: [PATCH 2/6] Drop RATELIMIT macros Using plain structure initialization is both shorter _and_ more clearer. We get type safety for free. --- src/basic/ratelimit.h | 32 ++++++-------------------------- src/core/manager.c | 5 ++--- src/core/unit.c | 6 +++--- src/import/export-raw.c | 3 +-- src/import/export-tar.c | 3 +-- src/import/import-fs.c | 2 +- src/import/import-raw.c | 3 +-- src/import/import-tar.c | 3 +-- src/resolve/resolved-dns-scope.c | 2 +- src/test/test-ratelimit.c | 4 ++-- src/timesync/timesyncd-manager.c | 2 +- 11 files changed, 20 insertions(+), 45 deletions(-) diff --git a/src/basic/ratelimit.h b/src/basic/ratelimit.h index de91def28d..79e33b6a62 100644 --- a/src/basic/ratelimit.h +++ b/src/basic/ratelimit.h @@ -7,34 +7,14 @@ #include "util.h" typedef struct RateLimit { - usec_t interval; - usec_t begin; - unsigned burst; + usec_t interval; /* Keep those two fields first so they can be initialized easily: */ + unsigned burst; /* RateLimit rl = { INTERVAL, BURST }; */ unsigned num; + usec_t begin; } RateLimit; -#define RATELIMIT_DEFINE(_name, _interval, _burst) \ - RateLimit _name = { \ - .interval = (_interval), \ - .burst = (_burst), \ - .num = 0, \ - .begin = 0 \ - } - -#define RATELIMIT_INIT(v, _interval, _burst) \ - do { \ - RateLimit *_r = &(v); \ - _r->interval = (_interval); \ - _r->burst = (_burst); \ - _r->num = 0; \ - _r->begin = 0; \ - } while (false) - -#define RATELIMIT_RESET(v) \ - do { \ - RateLimit *_r = &(v); \ - _r->num = 0; \ - _r->begin = 0; \ - } while (false) +static inline void ratelimit_reset(RateLimit *rl) { + rl->num = rl->begin = 0; +} bool ratelimit_below(RateLimit *r); diff --git a/src/core/manager.c b/src/core/manager.c index d9114bb0c5..dac4248356 100644 --- a/src/core/manager.c +++ b/src/core/manager.c @@ -815,7 +815,7 @@ int manager_new(UnitFileScope scope, ManagerTestRunFlags test_run_flags, Manager } /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */ - RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7); + m->ctrl_alt_del_ratelimit = (RateLimit) { .interval = 2 * USEC_PER_SEC, .burst = 7 }; r = manager_default_environment(m); if (r < 0) @@ -2855,10 +2855,9 @@ static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t use } int manager_loop(Manager *m) { + RateLimit rl = { .interval = 1*USEC_PER_SEC, .burst = 50000 }; int r; - RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000); - assert(m); assert(m->objective == MANAGER_OK); /* Ensure manager_startup() has been called */ diff --git a/src/core/unit.c b/src/core/unit.c index 87a5976dcc..7d6ee792ad 100644 --- a/src/core/unit.c +++ b/src/core/unit.c @@ -123,8 +123,8 @@ Unit *unit_new(Manager *m, size_t size) { u->last_section_private = -1; - RATELIMIT_INIT(u->start_limit, m->default_start_limit_interval, m->default_start_limit_burst); - RATELIMIT_INIT(u->auto_stop_ratelimit, 10 * USEC_PER_SEC, 16); + u->start_limit = (RateLimit) { m->default_start_limit_interval, m->default_start_limit_burst }; + u->auto_stop_ratelimit = (RateLimit) { 10 * USEC_PER_SEC, 16 }; for (CGroupIOAccountingMetric i = 0; i < _CGROUP_IO_ACCOUNTING_METRIC_MAX; i++) u->io_accounting_last[i] = UINT64_MAX; @@ -4000,7 +4000,7 @@ void unit_reset_failed(Unit *u) { if (UNIT_VTABLE(u)->reset_failed) UNIT_VTABLE(u)->reset_failed(u); - RATELIMIT_RESET(u->start_limit); + ratelimit_reset(&u->start_limit); u->start_limit_hit = false; } diff --git a/src/import/export-raw.c b/src/import/export-raw.c index c1c946cd2b..57b4334a65 100644 --- a/src/import/export-raw.c +++ b/src/import/export-raw.c @@ -96,10 +96,9 @@ int raw_export_new( .on_finished = on_finished, .userdata = userdata, .last_percent = (unsigned) -1, + .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, }; - RATELIMIT_INIT(e->progress_rate_limit, 100 * USEC_PER_MSEC, 1); - if (event) e->event = sd_event_ref(event); else { diff --git a/src/import/export-tar.c b/src/import/export-tar.c index ed546769f3..b66b5ee37c 100644 --- a/src/import/export-tar.c +++ b/src/import/export-tar.c @@ -99,10 +99,9 @@ int tar_export_new( .userdata = userdata, .quota_referenced = (uint64_t) -1, .last_percent = (unsigned) -1, + .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, }; - RATELIMIT_INIT(e->progress_rate_limit, 100 * USEC_PER_MSEC, 1); - if (event) e->event = sd_event_ref(event); else { diff --git a/src/import/import-fs.c b/src/import/import-fs.c index f8f3a23206..468303a6dc 100644 --- a/src/import/import-fs.c +++ b/src/import/import-fs.c @@ -169,7 +169,7 @@ static int import_fs(int argc, char *argv[], void *userdata) { (void) mkdir_parents_label(temp_path, 0700); - RATELIMIT_INIT(progress.limit, 200*USEC_PER_MSEC, 1); + progress.limit = (RateLimit) { 200*USEC_PER_MSEC, 1 }; /* Hook into SIGINT/SIGTERM, so that we can cancel things then */ assert(sigaction(SIGINT, &sa, &old_sigint_sa) >= 0); diff --git a/src/import/import-raw.c b/src/import/import-raw.c index b905832603..dc73387bc2 100644 --- a/src/import/import-raw.c +++ b/src/import/import-raw.c @@ -111,10 +111,9 @@ int raw_import_new( .userdata = userdata, .last_percent = (unsigned) -1, .image_root = TAKE_PTR(root), + .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, }; - RATELIMIT_INIT(i->progress_rate_limit, 100 * USEC_PER_MSEC, 1); - if (event) i->event = sd_event_ref(event); else { diff --git a/src/import/import-tar.c b/src/import/import-tar.c index f3eff82a29..c2ece7af74 100644 --- a/src/import/import-tar.c +++ b/src/import/import-tar.c @@ -119,10 +119,9 @@ int tar_import_new( .userdata = userdata, .last_percent = (unsigned) -1, .image_root = TAKE_PTR(root), + .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, }; - RATELIMIT_INIT(i->progress_rate_limit, 100 * USEC_PER_MSEC, 1); - if (event) i->event = sd_event_ref(event); else { diff --git a/src/resolve/resolved-dns-scope.c b/src/resolve/resolved-dns-scope.c index eb304e52e5..ddcf164ebd 100644 --- a/src/resolve/resolved-dns-scope.c +++ b/src/resolve/resolved-dns-scope.c @@ -70,7 +70,7 @@ int dns_scope_new(Manager *m, DnsScope **ret, Link *l, DnsProtocol protocol, int log_debug("New scope on link %s, protocol %s, family %s", l ? l->ifname : "*", dns_protocol_to_string(protocol), family == AF_UNSPEC ? "*" : af_to_name(family)); /* Enforce ratelimiting for the multicast protocols */ - RATELIMIT_INIT(s->ratelimit, MULTICAST_RATELIMIT_INTERVAL_USEC, MULTICAST_RATELIMIT_BURST); + s->ratelimit = (RateLimit) { MULTICAST_RATELIMIT_INTERVAL_USEC, MULTICAST_RATELIMIT_BURST }; *ret = s; return 0; diff --git a/src/test/test-ratelimit.c b/src/test/test-ratelimit.c index 9f344e1152..56a6fa2d76 100644 --- a/src/test/test-ratelimit.c +++ b/src/test/test-ratelimit.c @@ -8,7 +8,7 @@ static void test_ratelimit_below(void) { int i; - RATELIMIT_DEFINE(ratelimit, 1 * USEC_PER_SEC, 10); + RateLimit ratelimit = { 1 * USEC_PER_SEC, 10 }; for (i = 0; i < 10; i++) assert_se(ratelimit_below(&ratelimit)); @@ -17,7 +17,7 @@ static void test_ratelimit_below(void) { for (i = 0; i < 10; i++) assert_se(ratelimit_below(&ratelimit)); - RATELIMIT_INIT(ratelimit, 0, 10); + ratelimit = (RateLimit) { 0, 10 }; for (i = 0; i < 10000; i++) assert_se(ratelimit_below(&ratelimit)); } diff --git a/src/timesync/timesyncd-manager.c b/src/timesync/timesyncd-manager.c index 3c3a7fe69a..604c7e01be 100644 --- a/src/timesync/timesyncd-manager.c +++ b/src/timesync/timesyncd-manager.c @@ -1094,7 +1094,7 @@ int manager_new(Manager **ret) { m->server_socket = m->clock_watch_fd = -1; - RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST); + m->ratelimit = (RateLimit) { RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST }; r = sd_event_default(&m->event); if (r < 0) From 7bf081a1e59d2ac4941f24d27c6d7647c5ed703b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Thu, 19 Sep 2019 17:45:41 +0200 Subject: [PATCH 3/6] pid1: rename start_limit to start_ratelimit This way it is clearer what the type is. We also have auto_stop_ratelimit adjacent, and it feels ugly to have a different suffix for those two. --- src/core/dbus-service.c | 4 ++-- src/core/dbus-unit.c | 12 ++++++------ src/core/load-fragment-gperf.gperf.m4 | 10 +++++----- src/core/unit.c | 6 +++--- src/core/unit.h | 2 +- 5 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/core/dbus-service.c b/src/core/dbus-service.c index c401b90aaf..3a58977c38 100644 --- a/src/core/dbus-service.c +++ b/src/core/dbus-service.c @@ -145,8 +145,8 @@ const sd_bus_vtable bus_service_vtable[] = { BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStopPostEx", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION), /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */ - SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), - SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), + SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), + SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_ratelimit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), diff --git a/src/core/dbus-unit.c b/src/core/dbus-unit.c index ef434fb9f1..9722f53162 100644 --- a/src/core/dbus-unit.c +++ b/src/core/dbus-unit.c @@ -829,8 +829,8 @@ const sd_bus_vtable bus_unit_vtable[] = { SD_BUS_PROPERTY("LoadError", "(ss)", property_get_load_error, 0, SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("Transient", "b", bus_property_get_bool, offsetof(Unit, transient), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("Perpetual", "b", bus_property_get_bool, offsetof(Unit, perpetual), SD_BUS_VTABLE_PROPERTY_CONST), - SD_BUS_PROPERTY("StartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST), - SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("StartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_ratelimit.burst), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("FailureActionExitStatus", "i", bus_property_get_int, offsetof(Unit, failure_action_exit_status), SD_BUS_VTABLE_PROPERTY_CONST), @@ -862,8 +862,8 @@ const sd_bus_vtable bus_unit_vtable[] = { SD_BUS_PROPERTY("RequiredByOverridable", "as", property_get_empty_strv, 0, SD_BUS_VTABLE_HIDDEN), SD_BUS_PROPERTY("RequisiteOfOverridable", "as", property_get_empty_strv, 0, SD_BUS_VTABLE_HIDDEN), /* Obsolete alias names */ - SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), - SD_BUS_PROPERTY("StartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), + SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), + SD_BUS_PROPERTY("StartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), SD_BUS_VTABLE_END }; @@ -1825,10 +1825,10 @@ static int bus_unit_set_transient_property( return bus_set_transient_string(u, name, &u->job_timeout_reboot_arg, message, flags, error); if (streq(name, "StartLimitIntervalUSec")) - return bus_set_transient_usec(u, name, &u->start_limit.interval, message, flags, error); + return bus_set_transient_usec(u, name, &u->start_ratelimit.interval, message, flags, error); if (streq(name, "StartLimitBurst")) - return bus_set_transient_unsigned(u, name, &u->start_limit.burst, message, flags, error); + return bus_set_transient_unsigned(u, name, &u->start_ratelimit.burst, message, flags, error); if (streq(name, "StartLimitAction")) return bus_set_transient_emergency_action(u, name, &u->start_limit_action, message, flags, error); diff --git a/src/core/load-fragment-gperf.gperf.m4 b/src/core/load-fragment-gperf.gperf.m4 index 5490ae32fb..e956dff41f 100644 --- a/src/core/load-fragment-gperf.gperf.m4 +++ b/src/core/load-fragment-gperf.gperf.m4 @@ -245,10 +245,10 @@ Unit.JobTimeoutSec, config_parse_job_timeout_sec, 0, Unit.JobRunningTimeoutSec, config_parse_job_running_timeout_sec, 0, 0 Unit.JobTimeoutAction, config_parse_emergency_action, 0, offsetof(Unit, job_timeout_action) Unit.JobTimeoutRebootArgument, config_parse_unit_string_printf, 0, offsetof(Unit, job_timeout_reboot_arg) -Unit.StartLimitIntervalSec, config_parse_sec, 0, offsetof(Unit, start_limit.interval) +Unit.StartLimitIntervalSec, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval) m4_dnl The following is a legacy alias name for compatibility -Unit.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_limit.interval) -Unit.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_limit.burst) +Unit.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval) +Unit.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_ratelimit.burst) Unit.StartLimitAction, config_parse_emergency_action, 0, offsetof(Unit, start_limit_action) Unit.FailureAction, config_parse_emergency_action, 0, offsetof(Unit, failure_action) Unit.SuccessAction, config_parse_emergency_action, 0, offsetof(Unit, success_action) @@ -320,8 +320,8 @@ Service.TimeoutAbortSec, config_parse_service_timeout_abort, 0, Service.RuntimeMaxSec, config_parse_sec, 0, offsetof(Service, runtime_max_usec) Service.WatchdogSec, config_parse_sec, 0, offsetof(Service, watchdog_usec) m4_dnl The following five only exist for compatibility, they moved into Unit, see above -Service.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_limit.interval) -Service.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_limit.burst) +Service.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval) +Service.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_ratelimit.burst) Service.StartLimitAction, config_parse_emergency_action, 0, offsetof(Unit, start_limit_action) Service.FailureAction, config_parse_emergency_action, 0, offsetof(Unit, failure_action) Service.RebootArgument, config_parse_unit_string_printf, 0, offsetof(Unit, reboot_arg) diff --git a/src/core/unit.c b/src/core/unit.c index 7d6ee792ad..b186888db1 100644 --- a/src/core/unit.c +++ b/src/core/unit.c @@ -123,7 +123,7 @@ Unit *unit_new(Manager *m, size_t size) { u->last_section_private = -1; - u->start_limit = (RateLimit) { m->default_start_limit_interval, m->default_start_limit_burst }; + u->start_ratelimit = (RateLimit) { m->default_start_limit_interval, m->default_start_limit_burst }; u->auto_stop_ratelimit = (RateLimit) { 10 * USEC_PER_SEC, 16 }; for (CGroupIOAccountingMetric i = 0; i < _CGROUP_IO_ACCOUNTING_METRIC_MAX; i++) @@ -1679,7 +1679,7 @@ int unit_test_start_limit(Unit *u) { assert(u); - if (ratelimit_below(&u->start_limit)) { + if (ratelimit_below(&u->start_ratelimit)) { u->start_limit_hit = false; return 0; } @@ -4000,7 +4000,7 @@ void unit_reset_failed(Unit *u) { if (UNIT_VTABLE(u)->reset_failed) UNIT_VTABLE(u)->reset_failed(u); - ratelimit_reset(&u->start_limit); + ratelimit_reset(&u->start_ratelimit); u->start_limit_hit = false; } diff --git a/src/core/unit.h b/src/core/unit.h index 2ff4b13160..3dea8b8868 100644 --- a/src/core/unit.h +++ b/src/core/unit.h @@ -227,7 +227,7 @@ typedef struct Unit { int load_error; /* Put a ratelimit on unit starting */ - RateLimit start_limit; + RateLimit start_ratelimit; EmergencyAction start_limit_action; /* What to do on failure or success */ From 5ac1530eca652cd16819853fe06e76e156f5cf5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Thu, 19 Sep 2019 17:49:14 +0200 Subject: [PATCH 4/6] tree-wide: say "ratelimit" not "rate_limit" "ratelimit" is a real word, so we don't need to use the other form anywhere. We had both forms in various places, let's standarize on the shorter and more correct one. --- src/core/dbus-execute.c | 8 +++--- src/core/execute.c | 12 ++++---- src/core/execute.h | 4 +-- src/core/load-fragment-gperf.gperf.m4 | 4 +-- src/core/unit.c | 40 +++++++++++++-------------- src/core/unit.h | 4 +-- src/import/export-raw.c | 6 ++-- src/import/export-tar.c | 6 ++-- src/import/import-raw.c | 6 ++-- src/import/import-tar.c | 6 ++-- src/journal/journald-context.c | 20 +++++++------- src/journal/journald-context.h | 4 +-- src/journal/journald-gperf.gperf | 6 ++-- src/journal/journald-rate-limit.c | 26 ++++++++--------- src/journal/journald-rate-limit.h | 6 ++-- src/journal/journald-server.c | 20 +++++++------- src/journal/journald-server.h | 6 ++-- 17 files changed, 92 insertions(+), 92 deletions(-) diff --git a/src/core/dbus-execute.c b/src/core/dbus-execute.c index 2be3db26a6..63c5a81ace 100644 --- a/src/core/dbus-execute.c +++ b/src/core/dbus-execute.c @@ -764,8 +764,8 @@ const sd_bus_vtable bus_exec_vtable[] = { SD_BUS_PROPERTY("SyslogLevel", "i", property_get_syslog_level, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("SyslogFacility", "i", property_get_syslog_facility, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("LogLevelMax", "i", bus_property_get_int, offsetof(ExecContext, log_level_max), SD_BUS_VTABLE_PROPERTY_CONST), - SD_BUS_PROPERTY("LogRateLimitIntervalUSec", "t", bus_property_get_usec, offsetof(ExecContext, log_rate_limit_interval_usec), SD_BUS_VTABLE_PROPERTY_CONST), - SD_BUS_PROPERTY("LogRateLimitBurst", "u", bus_property_get_unsigned, offsetof(ExecContext, log_rate_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("LogRateLimitIntervalUSec", "t", bus_property_get_usec, offsetof(ExecContext, log_ratelimit_interval_usec), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("LogRateLimitBurst", "u", bus_property_get_unsigned, offsetof(ExecContext, log_ratelimit_burst), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("LogExtraFields", "aay", property_get_log_extra_fields, 0, SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST), SD_BUS_PROPERTY("CapabilityBoundingSet", "t", NULL, offsetof(ExecContext, capability_bounding_set), SD_BUS_VTABLE_PROPERTY_CONST), @@ -1204,10 +1204,10 @@ int bus_exec_context_set_transient_property( return bus_set_transient_log_level(u, name, &c->log_level_max, message, flags, error); if (streq(name, "LogRateLimitIntervalUSec")) - return bus_set_transient_usec(u, name, &c->log_rate_limit_interval_usec, message, flags, error); + return bus_set_transient_usec(u, name, &c->log_ratelimit_interval_usec, message, flags, error); if (streq(name, "LogRateLimitBurst")) - return bus_set_transient_unsigned(u, name, &c->log_rate_limit_burst, message, flags, error); + return bus_set_transient_unsigned(u, name, &c->log_ratelimit_burst, message, flags, error); if (streq(name, "Personality")) return bus_set_transient_personality(u, name, &c->personality, message, flags, error); diff --git a/src/core/execute.c b/src/core/execute.c index 4c90007778..ec95ce3d10 100644 --- a/src/core/execute.c +++ b/src/core/execute.c @@ -4000,8 +4000,8 @@ void exec_context_done(ExecContext *c) { exec_context_free_log_extra_fields(c); - c->log_rate_limit_interval_usec = 0; - c->log_rate_limit_burst = 0; + c->log_ratelimit_interval_usec = 0; + c->log_ratelimit_burst = 0; c->stdin_data = mfree(c->stdin_data); c->stdin_data_size = 0; @@ -4515,16 +4515,16 @@ void exec_context_dump(const ExecContext *c, FILE* f, const char *prefix) { fprintf(f, "%sLogLevelMax: %s\n", prefix, strna(t)); } - if (c->log_rate_limit_interval_usec > 0) { + if (c->log_ratelimit_interval_usec > 0) { char buf_timespan[FORMAT_TIMESPAN_MAX]; fprintf(f, "%sLogRateLimitIntervalSec: %s\n", - prefix, format_timespan(buf_timespan, sizeof(buf_timespan), c->log_rate_limit_interval_usec, USEC_PER_SEC)); + prefix, format_timespan(buf_timespan, sizeof(buf_timespan), c->log_ratelimit_interval_usec, USEC_PER_SEC)); } - if (c->log_rate_limit_burst > 0) - fprintf(f, "%sLogRateLimitBurst: %u\n", prefix, c->log_rate_limit_burst); + if (c->log_ratelimit_burst > 0) + fprintf(f, "%sLogRateLimitBurst: %u\n", prefix, c->log_ratelimit_burst); if (c->n_log_extra_fields > 0) { size_t j; diff --git a/src/core/execute.h b/src/core/execute.h index cddfafa0d6..2508c6d668 100644 --- a/src/core/execute.h +++ b/src/core/execute.h @@ -245,8 +245,8 @@ struct ExecContext { struct iovec* log_extra_fields; size_t n_log_extra_fields; - usec_t log_rate_limit_interval_usec; - unsigned log_rate_limit_burst; + usec_t log_ratelimit_interval_usec; + unsigned log_ratelimit_burst; int log_level_max; diff --git a/src/core/load-fragment-gperf.gperf.m4 b/src/core/load-fragment-gperf.gperf.m4 index e956dff41f..765d7d503d 100644 --- a/src/core/load-fragment-gperf.gperf.m4 +++ b/src/core/load-fragment-gperf.gperf.m4 @@ -59,8 +59,8 @@ $1.SyslogFacility, config_parse_log_facility, 0, $1.SyslogLevel, config_parse_log_level, 0, offsetof($1, exec_context.syslog_priority) $1.SyslogLevelPrefix, config_parse_bool, 0, offsetof($1, exec_context.syslog_level_prefix) $1.LogLevelMax, config_parse_log_level, 0, offsetof($1, exec_context.log_level_max) -$1.LogRateLimitIntervalSec, config_parse_sec, 0, offsetof($1, exec_context.log_rate_limit_interval_usec) -$1.LogRateLimitBurst, config_parse_unsigned, 0, offsetof($1, exec_context.log_rate_limit_burst) +$1.LogRateLimitIntervalSec, config_parse_sec, 0, offsetof($1, exec_context.log_ratelimit_interval_usec) +$1.LogRateLimitBurst, config_parse_unsigned, 0, offsetof($1, exec_context.log_ratelimit_burst) $1.LogExtraFields, config_parse_log_extra_fields, 0, offsetof($1, exec_context) $1.Capabilities, config_parse_warn_compat, DISABLED_LEGACY, offsetof($1, exec_context) $1.SecureBits, config_parse_exec_secure_bits, 0, offsetof($1, exec_context.secure_bits) diff --git a/src/core/unit.c b/src/core/unit.c index b186888db1..9ea8c1e66c 100644 --- a/src/core/unit.c +++ b/src/core/unit.c @@ -3416,8 +3416,8 @@ int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) { (void) serialize_bool(f, "exported-invocation-id", u->exported_invocation_id); (void) serialize_bool(f, "exported-log-level-max", u->exported_log_level_max); (void) serialize_bool(f, "exported-log-extra-fields", u->exported_log_extra_fields); - (void) serialize_bool(f, "exported-log-rate-limit-interval", u->exported_log_rate_limit_interval); - (void) serialize_bool(f, "exported-log-rate-limit-burst", u->exported_log_rate_limit_burst); + (void) serialize_bool(f, "exported-log-rate-limit-interval", u->exported_log_ratelimit_interval); + (void) serialize_bool(f, "exported-log-rate-limit-burst", u->exported_log_ratelimit_burst); (void) serialize_item_format(f, "cpu-usage-base", "%" PRIu64, u->cpu_usage_base); if (u->cpu_usage_last != NSEC_INFINITY) @@ -3636,7 +3636,7 @@ int unit_deserialize(Unit *u, FILE *f, FDSet *fds) { if (r < 0) log_unit_debug(u, "Failed to parse exported log rate limit interval %s, ignoring.", v); else - u->exported_log_rate_limit_interval = r; + u->exported_log_ratelimit_interval = r; continue; @@ -3646,7 +3646,7 @@ int unit_deserialize(Unit *u, FILE *f, FDSet *fds) { if (r < 0) log_unit_debug(u, "Failed to parse exported log rate limit burst %s, ignoring.", v); else - u->exported_log_rate_limit_burst = r; + u->exported_log_ratelimit_burst = r; continue; @@ -5504,7 +5504,7 @@ fail: return r; } -static int unit_export_log_rate_limit_interval(Unit *u, const ExecContext *c) { +static int unit_export_log_ratelimit_interval(Unit *u, const ExecContext *c) { _cleanup_free_ char *buf = NULL; const char *p; int r; @@ -5512,26 +5512,26 @@ static int unit_export_log_rate_limit_interval(Unit *u, const ExecContext *c) { assert(u); assert(c); - if (u->exported_log_rate_limit_interval) + if (u->exported_log_ratelimit_interval) return 0; - if (c->log_rate_limit_interval_usec == 0) + if (c->log_ratelimit_interval_usec == 0) return 0; p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id); - if (asprintf(&buf, "%" PRIu64, c->log_rate_limit_interval_usec) < 0) + if (asprintf(&buf, "%" PRIu64, c->log_ratelimit_interval_usec) < 0) return log_oom(); r = symlink_atomic(buf, p); if (r < 0) return log_unit_debug_errno(u, r, "Failed to create log rate limit interval symlink %s: %m", p); - u->exported_log_rate_limit_interval = true; + u->exported_log_ratelimit_interval = true; return 0; } -static int unit_export_log_rate_limit_burst(Unit *u, const ExecContext *c) { +static int unit_export_log_ratelimit_burst(Unit *u, const ExecContext *c) { _cleanup_free_ char *buf = NULL; const char *p; int r; @@ -5539,22 +5539,22 @@ static int unit_export_log_rate_limit_burst(Unit *u, const ExecContext *c) { assert(u); assert(c); - if (u->exported_log_rate_limit_burst) + if (u->exported_log_ratelimit_burst) return 0; - if (c->log_rate_limit_burst == 0) + if (c->log_ratelimit_burst == 0) return 0; p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id); - if (asprintf(&buf, "%u", c->log_rate_limit_burst) < 0) + if (asprintf(&buf, "%u", c->log_ratelimit_burst) < 0) return log_oom(); r = symlink_atomic(buf, p); if (r < 0) return log_unit_debug_errno(u, r, "Failed to create log rate limit burst symlink %s: %m", p); - u->exported_log_rate_limit_burst = true; + u->exported_log_ratelimit_burst = true; return 0; } @@ -5591,8 +5591,8 @@ void unit_export_state_files(Unit *u) { if (c) { (void) unit_export_log_level_max(u, c); (void) unit_export_log_extra_fields(u, c); - (void) unit_export_log_rate_limit_interval(u, c); - (void) unit_export_log_rate_limit_burst(u, c); + (void) unit_export_log_ratelimit_interval(u, c); + (void) unit_export_log_ratelimit_burst(u, c); } } @@ -5630,18 +5630,18 @@ void unit_unlink_state_files(Unit *u) { u->exported_log_extra_fields = false; } - if (u->exported_log_rate_limit_interval) { + if (u->exported_log_ratelimit_interval) { p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id); (void) unlink(p); - u->exported_log_rate_limit_interval = false; + u->exported_log_ratelimit_interval = false; } - if (u->exported_log_rate_limit_burst) { + if (u->exported_log_ratelimit_burst) { p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id); (void) unlink(p); - u->exported_log_rate_limit_burst = false; + u->exported_log_ratelimit_burst = false; } } diff --git a/src/core/unit.h b/src/core/unit.h index 3dea8b8868..3b0042a9eb 100644 --- a/src/core/unit.h +++ b/src/core/unit.h @@ -365,8 +365,8 @@ typedef struct Unit { bool exported_invocation_id:1; bool exported_log_level_max:1; bool exported_log_extra_fields:1; - bool exported_log_rate_limit_interval:1; - bool exported_log_rate_limit_burst:1; + bool exported_log_ratelimit_interval:1; + bool exported_log_ratelimit_burst:1; /* Whether we warned about clamping the CPU quota period */ bool warned_clamping_cpu_quota_period:1; diff --git a/src/import/export-raw.c b/src/import/export-raw.c index 57b4334a65..d76f3c0519 100644 --- a/src/import/export-raw.c +++ b/src/import/export-raw.c @@ -49,7 +49,7 @@ struct RawExport { uint64_t written_uncompressed; unsigned last_percent; - RateLimit progress_rate_limit; + RateLimit progress_ratelimit; struct stat st; @@ -96,7 +96,7 @@ int raw_export_new( .on_finished = on_finished, .userdata = userdata, .last_percent = (unsigned) -1, - .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, + .progress_ratelimit = { 100 * USEC_PER_MSEC, 1 }, }; if (event) @@ -124,7 +124,7 @@ static void raw_export_report_progress(RawExport *e) { if (percent == e->last_percent) return; - if (!ratelimit_below(&e->progress_rate_limit)) + if (!ratelimit_below(&e->progress_ratelimit)) return; sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent); diff --git a/src/import/export-tar.c b/src/import/export-tar.c index b66b5ee37c..5f89880ed6 100644 --- a/src/import/export-tar.c +++ b/src/import/export-tar.c @@ -44,7 +44,7 @@ struct TarExport { uint64_t quota_referenced; unsigned last_percent; - RateLimit progress_rate_limit; + RateLimit progress_ratelimit; bool eof; bool tried_splice; @@ -99,7 +99,7 @@ int tar_export_new( .userdata = userdata, .quota_referenced = (uint64_t) -1, .last_percent = (unsigned) -1, - .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, + .progress_ratelimit = { 100 * USEC_PER_MSEC, 1 }, }; if (event) @@ -131,7 +131,7 @@ static void tar_export_report_progress(TarExport *e) { if (percent == e->last_percent) return; - if (!ratelimit_below(&e->progress_rate_limit)) + if (!ratelimit_below(&e->progress_ratelimit)) return; sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent); diff --git a/src/import/import-raw.c b/src/import/import-raw.c index dc73387bc2..a12a6d63b1 100644 --- a/src/import/import-raw.c +++ b/src/import/import-raw.c @@ -57,7 +57,7 @@ struct RawImport { struct stat st; unsigned last_percent; - RateLimit progress_rate_limit; + RateLimit progress_ratelimit; }; RawImport* raw_import_unref(RawImport *i) { @@ -111,7 +111,7 @@ int raw_import_new( .userdata = userdata, .last_percent = (unsigned) -1, .image_root = TAKE_PTR(root), - .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, + .progress_ratelimit = { 100 * USEC_PER_MSEC, 1 }, }; if (event) @@ -143,7 +143,7 @@ static void raw_import_report_progress(RawImport *i) { if (percent == i->last_percent) return; - if (!ratelimit_below(&i->progress_rate_limit)) + if (!ratelimit_below(&i->progress_ratelimit)) return; sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent); diff --git a/src/import/import-tar.c b/src/import/import-tar.c index c2ece7af74..1e50d31bc2 100644 --- a/src/import/import-tar.c +++ b/src/import/import-tar.c @@ -60,7 +60,7 @@ struct TarImport { pid_t tar_pid; unsigned last_percent; - RateLimit progress_rate_limit; + RateLimit progress_ratelimit; }; TarImport* tar_import_unref(TarImport *i) { @@ -119,7 +119,7 @@ int tar_import_new( .userdata = userdata, .last_percent = (unsigned) -1, .image_root = TAKE_PTR(root), - .progress_rate_limit = { 100 * USEC_PER_MSEC, 1 }, + .progress_ratelimit = { 100 * USEC_PER_MSEC, 1 }, }; if (event) @@ -151,7 +151,7 @@ static void tar_import_report_progress(TarImport *i) { if (percent == i->last_percent) return; - if (!ratelimit_below(&i->progress_rate_limit)) + if (!ratelimit_below(&i->progress_ratelimit)) return; sd_notifyf(false, "X_IMPORT_PROGRESS=%u", percent); diff --git a/src/journal/journald-context.c b/src/journal/journald-context.c index 46edf24cd6..342ed062d4 100644 --- a/src/journal/journald-context.c +++ b/src/journal/journald-context.c @@ -132,8 +132,8 @@ static int client_context_new(Server *s, pid_t pid, ClientContext **ret) { c->timestamp = USEC_INFINITY; c->extra_fields_mtime = NSEC_INFINITY; c->log_level_max = -1; - c->log_rate_limit_interval = s->rate_limit_interval; - c->log_rate_limit_burst = s->rate_limit_burst; + c->log_ratelimit_interval = s->ratelimit_interval; + c->log_ratelimit_burst = s->ratelimit_burst; r = hashmap_put(s->client_contexts, PID_TO_PTR(pid), c); if (r < 0) { @@ -182,8 +182,8 @@ static void client_context_reset(Server *s, ClientContext *c) { c->log_level_max = -1; - c->log_rate_limit_interval = s->rate_limit_interval; - c->log_rate_limit_burst = s->rate_limit_burst; + c->log_ratelimit_interval = s->ratelimit_interval; + c->log_ratelimit_burst = s->ratelimit_burst; } static ClientContext* client_context_free(Server *s, ClientContext *c) { @@ -459,7 +459,7 @@ static int client_context_read_extra_fields( return 0; } -static int client_context_read_log_rate_limit_interval(ClientContext *c) { +static int client_context_read_log_ratelimit_interval(ClientContext *c) { _cleanup_free_ char *value = NULL; const char *p; int r; @@ -474,10 +474,10 @@ static int client_context_read_log_rate_limit_interval(ClientContext *c) { if (r < 0) return r; - return safe_atou64(value, &c->log_rate_limit_interval); + return safe_atou64(value, &c->log_ratelimit_interval); } -static int client_context_read_log_rate_limit_burst(ClientContext *c) { +static int client_context_read_log_ratelimit_burst(ClientContext *c) { _cleanup_free_ char *value = NULL; const char *p; int r; @@ -492,7 +492,7 @@ static int client_context_read_log_rate_limit_burst(ClientContext *c) { if (r < 0) return r; - return safe_atou(value, &c->log_rate_limit_burst); + return safe_atou(value, &c->log_ratelimit_burst); } static void client_context_really_refresh( @@ -521,8 +521,8 @@ static void client_context_really_refresh( (void) client_context_read_invocation_id(s, c); (void) client_context_read_log_level_max(s, c); (void) client_context_read_extra_fields(s, c); - (void) client_context_read_log_rate_limit_interval(c); - (void) client_context_read_log_rate_limit_burst(c); + (void) client_context_read_log_ratelimit_interval(c); + (void) client_context_read_log_ratelimit_burst(c); c->timestamp = timestamp; diff --git a/src/journal/journald-context.h b/src/journal/journald-context.h index 46f79fb5f7..91f0302be4 100644 --- a/src/journal/journald-context.h +++ b/src/journal/journald-context.h @@ -53,8 +53,8 @@ struct ClientContext { void *extra_fields_data; nsec_t extra_fields_mtime; - usec_t log_rate_limit_interval; - unsigned log_rate_limit_burst; + usec_t log_ratelimit_interval; + unsigned log_ratelimit_burst; }; int client_context_get( diff --git a/src/journal/journald-gperf.gperf b/src/journal/journald-gperf.gperf index 1adcb50b6d..0774444e8d 100644 --- a/src/journal/journald-gperf.gperf +++ b/src/journal/journald-gperf.gperf @@ -24,9 +24,9 @@ Journal.Seal, config_parse_bool, 0, offsetof(Server, seal) Journal.ReadKMsg, config_parse_bool, 0, offsetof(Server, read_kmsg) Journal.SyncIntervalSec, config_parse_sec, 0, offsetof(Server, sync_interval_usec) # The following is a legacy name for compatibility -Journal.RateLimitInterval, config_parse_sec, 0, offsetof(Server, rate_limit_interval) -Journal.RateLimitIntervalSec,config_parse_sec, 0, offsetof(Server, rate_limit_interval) -Journal.RateLimitBurst, config_parse_unsigned, 0, offsetof(Server, rate_limit_burst) +Journal.RateLimitInterval, config_parse_sec, 0, offsetof(Server, ratelimit_interval) +Journal.RateLimitIntervalSec,config_parse_sec, 0, offsetof(Server, ratelimit_interval) +Journal.RateLimitBurst, config_parse_unsigned, 0, offsetof(Server, ratelimit_burst) Journal.SystemMaxUse, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.max_use) Journal.SystemMaxFileSize, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.max_size) Journal.SystemKeepFree, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.keep_free) diff --git a/src/journal/journald-rate-limit.c b/src/journal/journald-rate-limit.c index 39e968bce3..30a3fa8720 100644 --- a/src/journal/journald-rate-limit.c +++ b/src/journal/journald-rate-limit.c @@ -60,7 +60,7 @@ struct JournalRateLimit { uint8_t hash_key[16]; }; -JournalRateLimit *journal_rate_limit_new(void) { +JournalRateLimit *journal_ratelimit_new(void) { JournalRateLimit *r; r = new0(JournalRateLimit, 1); @@ -72,7 +72,7 @@ JournalRateLimit *journal_rate_limit_new(void) { return r; } -static void journal_rate_limit_group_free(JournalRateLimitGroup *g) { +static void journal_ratelimit_group_free(JournalRateLimitGroup *g) { assert(g); if (g->parent) { @@ -91,16 +91,16 @@ static void journal_rate_limit_group_free(JournalRateLimitGroup *g) { free(g); } -void journal_rate_limit_free(JournalRateLimit *r) { +void journal_ratelimit_free(JournalRateLimit *r) { assert(r); while (r->lru) - journal_rate_limit_group_free(r->lru); + journal_ratelimit_group_free(r->lru); free(r); } -_pure_ static bool journal_rate_limit_group_expired(JournalRateLimitGroup *g, usec_t ts) { +_pure_ static bool journal_ratelimit_group_expired(JournalRateLimitGroup *g, usec_t ts) { unsigned i; assert(g); @@ -112,18 +112,18 @@ _pure_ static bool journal_rate_limit_group_expired(JournalRateLimitGroup *g, us return true; } -static void journal_rate_limit_vacuum(JournalRateLimit *r, usec_t ts) { +static void journal_ratelimit_vacuum(JournalRateLimit *r, usec_t ts) { assert(r); /* Makes room for at least one new item, but drop all * expored items too. */ while (r->n_groups >= GROUPS_MAX || - (r->lru_tail && journal_rate_limit_group_expired(r->lru_tail, ts))) - journal_rate_limit_group_free(r->lru_tail); + (r->lru_tail && journal_ratelimit_group_expired(r->lru_tail, ts))) + journal_ratelimit_group_free(r->lru_tail); } -static JournalRateLimitGroup* journal_rate_limit_group_new(JournalRateLimit *r, const char *id, usec_t interval, usec_t ts) { +static JournalRateLimitGroup* journal_ratelimit_group_new(JournalRateLimit *r, const char *id, usec_t interval, usec_t ts) { JournalRateLimitGroup *g; assert(r); @@ -141,7 +141,7 @@ static JournalRateLimitGroup* journal_rate_limit_group_new(JournalRateLimit *r, g->interval = interval; - journal_rate_limit_vacuum(r, ts); + journal_ratelimit_vacuum(r, ts); LIST_PREPEND(bucket, r->buckets[g->hash % BUCKETS_MAX], g); LIST_PREPEND(lru, r->lru, g); @@ -153,7 +153,7 @@ static JournalRateLimitGroup* journal_rate_limit_group_new(JournalRateLimit *r, return g; fail: - journal_rate_limit_group_free(g); + journal_ratelimit_group_free(g); return NULL; } @@ -185,7 +185,7 @@ static unsigned burst_modulate(unsigned burst, uint64_t available) { return burst; } -int journal_rate_limit_test(JournalRateLimit *r, const char *id, usec_t rl_interval, unsigned rl_burst, int priority, uint64_t available) { +int journal_ratelimit_test(JournalRateLimit *r, const char *id, usec_t rl_interval, unsigned rl_burst, int priority, uint64_t available) { uint64_t h; JournalRateLimitGroup *g; JournalRateLimitPool *p; @@ -214,7 +214,7 @@ int journal_rate_limit_test(JournalRateLimit *r, const char *id, usec_t rl_inter break; if (!g) { - g = journal_rate_limit_group_new(r, id, rl_interval, ts); + g = journal_ratelimit_group_new(r, id, rl_interval, ts); if (!g) return -ENOMEM; } else diff --git a/src/journal/journald-rate-limit.h b/src/journal/journald-rate-limit.h index 9dab51f7cc..0fff8767ac 100644 --- a/src/journal/journald-rate-limit.h +++ b/src/journal/journald-rate-limit.h @@ -5,6 +5,6 @@ typedef struct JournalRateLimit JournalRateLimit; -JournalRateLimit *journal_rate_limit_new(void); -void journal_rate_limit_free(JournalRateLimit *r); -int journal_rate_limit_test(JournalRateLimit *r, const char *id, usec_t rl_interval, unsigned rl_burst, int priority, uint64_t available); +JournalRateLimit *journal_ratelimit_new(void); +void journal_ratelimit_free(JournalRateLimit *r); +int journal_ratelimit_test(JournalRateLimit *r, const char *id, usec_t rl_interval, unsigned rl_burst, int priority, uint64_t available); diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c index a0c2dcd2d0..ff0188378f 100644 --- a/src/journal/journald-server.c +++ b/src/journal/journald-server.c @@ -1098,7 +1098,7 @@ void server_dispatch_message( if (c && c->unit) { (void) determine_space(s, &available, NULL); - rl = journal_rate_limit_test(s->rate_limit, c->unit, c->log_rate_limit_interval, c->log_rate_limit_burst, priority & LOG_PRIMASK, available); + rl = journal_ratelimit_test(s->ratelimit, c->unit, c->log_ratelimit_interval, c->log_ratelimit_burst, priority & LOG_PRIMASK, available); if (rl == 0) return; @@ -2020,8 +2020,8 @@ int server_init(Server *s) { .sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC, .sync_scheduled = false, - .rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL, - .rate_limit_burst = DEFAULT_RATE_LIMIT_BURST, + .ratelimit_interval = DEFAULT_RATE_LIMIT_INTERVAL, + .ratelimit_burst = DEFAULT_RATE_LIMIT_BURST, .forward_to_wall = true, @@ -2048,10 +2048,10 @@ int server_init(Server *s) { if (r < 0) log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m"); - if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) { + if (!!s->ratelimit_interval ^ !!s->ratelimit_burst) { log_debug("Setting both rate limit interval and burst from "USEC_FMT",%u to 0,0", - s->rate_limit_interval, s->rate_limit_burst); - s->rate_limit_interval = s->rate_limit_burst = 0; + s->ratelimit_interval, s->ratelimit_burst); + s->ratelimit_interval = s->ratelimit_burst = 0; } (void) mkdir_p("/run/systemd/journal", 0755); @@ -2180,8 +2180,8 @@ int server_init(Server *s) { if (r < 0) return r; - s->rate_limit = journal_rate_limit_new(); - if (!s->rate_limit) + s->ratelimit = journal_ratelimit_new(); + if (!s->ratelimit) return -ENOMEM; r = cg_get_root_path(&s->cgroup_root); @@ -2261,8 +2261,8 @@ void server_done(Server *s) { safe_close(s->hostname_fd); safe_close(s->notify_fd); - if (s->rate_limit) - journal_rate_limit_free(s->rate_limit); + if (s->ratelimit) + journal_ratelimit_free(s->ratelimit); if (s->kernel_seqnum) munmap(s->kernel_seqnum, sizeof(uint64_t)); diff --git a/src/journal/journald-server.h b/src/journal/journald-server.h index 6ce9f269ff..e16f64bb4b 100644 --- a/src/journal/journald-server.h +++ b/src/journal/journald-server.h @@ -94,10 +94,10 @@ struct Server { char *buffer; size_t buffer_size; - JournalRateLimit *rate_limit; + JournalRateLimit *ratelimit; usec_t sync_interval_usec; - usec_t rate_limit_interval; - unsigned rate_limit_burst; + usec_t ratelimit_interval; + unsigned ratelimit_burst; JournalStorage runtime_storage; JournalStorage system_storage; From 6123dfaa72589735c3e8e9b9b9e075a287f523ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Wed, 18 Sep 2019 21:02:07 +0200 Subject: [PATCH 5/6] pid1: disable printk ratelimit in early boot We have the problem that many early boot or late shutdown issues are harder to solve than they could be because we have no logs. When journald is not running, messages are redirected to /dev/kmsg. It is also the time when many things happen in a rapid succession, so we tend to hit the kernel printk ratelimit fairly reliably. The end result is that we get no logs from the time where they would be most useful. Thus let's disable the kernels ratelimit. Once the system is up and running, the ratelimit is not a problem. But during normal runtime, things also log to journald, and not to /dev/kmsg, so the ratelimit is not useful. Hence, there doesn't seem to be much point in trying to restore the ratelimit after boot is finished and journald is up and running. See kernel's commit 750afe7babd117daabebf4855da18e4418ea845e for the description of the kenrel interface. Our setting has lower precedence than explicit configuration on the kenrel command line. --- src/core/main.c | 2 ++ src/core/manager.c | 14 ++++++++++++++ src/core/manager.h | 1 + 3 files changed, 17 insertions(+) diff --git a/src/core/main.c b/src/core/main.c index 4633184b79..2e95edfbd8 100644 --- a/src/core/main.c +++ b/src/core/main.c @@ -2435,6 +2435,8 @@ int main(int argc, char *argv[]) { * available, and it previously wasn't. */ log_open(); + disable_printk_ratelimit(); + r = initialize_security( &loaded_policy, &security_start_timestamp, diff --git a/src/core/manager.c b/src/core/manager.c index dac4248356..600718e4bf 100644 --- a/src/core/manager.c +++ b/src/core/manager.c @@ -72,6 +72,7 @@ #include "string-util.h" #include "strv.h" #include "strxcpyx.h" +#include "sysctl-util.h" #include "syslog-util.h" #include "terminal-util.h" #include "time-util.h" @@ -4024,6 +4025,19 @@ static bool manager_journal_is_running(Manager *m) { return true; } +void disable_printk_ratelimit(void) { + /* Disable kernel's printk ratelimit. + * + * Logging to /dev/kmsg is most useful during early boot and shutdown, where normal logging + * mechanisms are not available. The semantics of this sysctl are such that any kernel command-line + * setting takes precedence. */ + int r; + + r = sysctl_write("kernel/printk_devkmsg", "on"); + if (r < 0) + log_debug_errno(r, "Failed to set sysctl kernel.printk_devkmsg=on: %m"); +} + void manager_recheck_journal(Manager *m) { assert(m); diff --git a/src/core/manager.h b/src/core/manager.h index 308ee013bd..424bf71704 100644 --- a/src/core/manager.h +++ b/src/core/manager.h @@ -499,6 +499,7 @@ bool manager_unit_inactive_or_pending(Manager *m, const char *name); void manager_check_finished(Manager *m); +void disable_printk_ratelimit(void); void manager_recheck_dbus(Manager *m); void manager_recheck_journal(Manager *m); From 78158d134b056ceb974292e40a58e5f8a9af4cbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= Date: Thu, 19 Sep 2019 18:01:23 +0200 Subject: [PATCH 6/6] basic/log: put a ratelimit on our logging to /dev/kmsg See the inline comment for details. --- src/basic/log.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/basic/log.c b/src/basic/log.c index 8bcc18bc80..f26b592a6c 100644 --- a/src/basic/log.c +++ b/src/basic/log.c @@ -29,6 +29,7 @@ #include "parse-util.h" #include "proc-cmdline.h" #include "process-util.h" +#include "ratelimit.h" #include "signal-util.h" #include "socket-util.h" #include "stdio-util.h" @@ -459,6 +460,15 @@ static int write_to_kmsg( const char *func, const char *buffer) { + /* Set a ratelimit on the amount of messages logged to /dev/kmsg. This is mostly supposed to be a + * safety catch for the case where start indiscriminately logging in a loop. It will not catch cases + * where we log excessively, but not in a tight loop. + * + * Note that this ratelimit is per-emitter, so we might still overwhelm /dev/kmsg with multiple + * loggers. + */ + static thread_local RateLimit ratelimit = { 5 * USEC_PER_SEC, 200 }; + char header_priority[2 + DECIMAL_STR_MAX(int) + 1], header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1]; struct iovec iovec[5] = {}; @@ -466,6 +476,9 @@ static int write_to_kmsg( if (kmsg_fd < 0) return 0; + if (!ratelimit_below(&ratelimit)) + return 0; + xsprintf(header_priority, "<%i>", level); xsprintf(header_pid, "["PID_FMT"]: ", getpid_cached());