HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/oom/oomd-manager.c

59,596 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 10343f6c55a351d85afeb425fd7eb7dc9263d43c

Lines 1001–1394 of 1,394

        }
 
        /* Always keep the subscribed (parent) cgroup contexts fresh so pgscan rate differentials
         * stay accurate across intervals, even during the post-action delay. Only suppress the
         * kill action itself.
         *
         * Note: update_monitored_cgroup_contexts() rebuilds the hashmap by calling
         * oomd_insert_cgroup_context(), which also carries over the per-cgroup 'rules' strv
         * from the old context. We rely on that implicit rule propagation here — the
         * rules attached to each cgroup context persist across refreshes. */
        r = update_monitored_cgroup_contexts(&m->monitored_rules_cgroup_contexts);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0)
                log_debug_errno(r, "Failed to update monitored rules cgroup contexts, ignoring: %m");
 
        /* The candidate refresh is the expensive part — it recursively walks descendants of every
         * monitored cgroup. Since candidates are only consumed by kill-by-pgscan / kill-by-swap
         * (both suppressed during the delay), skip the walk while we're not going to act. */
        if (!in_post_action_delay) {
                r = update_monitored_cgroup_contexts_candidates(
                                m->monitored_rules_cgroup_contexts, &m->monitored_rules_cgroup_contexts_candidates);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        log_debug_errno(r, "Failed to update monitored rules cgroup candidates, ignoring: %m");
        }
 
        r = prune_stale_ruleset_start_times(m);
        if (r < 0)
                return r;
 
        if (in_post_action_delay)
                return 0;
 
        /* Only read /proc/meminfo if at least one ruleset actually needs swap info — either as
         * a SwapUsageMax= condition or as a kill-by-swap action (which uses swap_total to
         * compute the per-cgroup selection threshold). */
        OomdRuleset *ruleset;
        HASHMAP_FOREACH(ruleset, m->rulesets)
                if (ruleset->swap_above >= 0 || ruleset->action == OOMD_ACTION_KILL_BY_SWAP) {
                        r = oomd_system_context_acquire("/proc/meminfo", &m->system_context);
                        if (r < 0)
                                return log_error_errno(r, "Failed to acquire system context: %m");
                        break;
                }
 
        OomdCGroupContext *ctx;
        HASHMAP_FOREACH(ctx, m->monitored_rules_cgroup_contexts) {
                r = process_rules_cgroup_context(m, ctx, usec_now);
                if (r < 0)
                        return r;
 
                /* process_rules_cgroup_context() sets rules_post_action_delay_start when it queues
                 * a kill. Honor the delay *within the same tick* too: otherwise a single overload
                 * could cascade into kills across unrelated sibling cgroups before pressure metrics
                 * have a chance to reflect the first kill. */
                if (m->rules_post_action_delay_start > 0)
                        break;
        }
 
        return 0;
}
 
static int monitor_swap_contexts(Manager *m) {
        _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
        int r;
 
        assert(m);
        assert(m->event);
 
        r = sd_event_add_time(m->event, &s, CLOCK_MONOTONIC, 0, 0, monitor_swap_contexts_handler, m);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_exit_on_failure(s, true);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(s, "oomd-swap-timer");
 
        m->swap_context_event_source = TAKE_PTR(s);
        return 0;
}
 
static int monitor_memory_pressure_contexts(Manager *m) {
        _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
        int r;
 
        assert(m);
        assert(m->event);
 
        r = sd_event_add_time(m->event, &s, CLOCK_MONOTONIC, 0, 0, monitor_memory_pressure_contexts_handler, m);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_exit_on_failure(s, true);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_enabled(s, SD_EVENT_ON);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(s, "oomd-memory-pressure-timer");
 
        m->mem_pressure_context_event_source = TAKE_PTR(s);
        return 0;
}
 
static int monitor_rules_contexts(Manager *m) {
        _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
        int r;
 
        assert(m);
        assert(m->event);
 
        r = sd_event_add_time(m->event, &s, CLOCK_MONOTONIC, 0, 0, monitor_rules_contexts_handler, m);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_exit_on_failure(s, true);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
        if (r < 0)
                return r;
 
        (void) sd_event_source_set_description(s, "oomd-rules-timer");
 
        m->rules_context_event_source = TAKE_PTR(s);
        return 0;
}
 
Manager* manager_free(Manager *m) {
        assert(m);
 
        sd_varlink_server_unref(m->varlink_server);
        sd_varlink_close_unref(m->varlink_client);
        sd_event_source_unref(m->swap_context_event_source);
        sd_event_source_unref(m->mem_pressure_context_event_source);
        sd_event_source_unref(m->rules_context_event_source);
        sd_event_unref(m->event);
 
        hashmap_free(m->polkit_registry);
        sd_bus_flush_close_unref(m->bus);
 
        hashmap_free(m->monitored_swap_cgroup_contexts);
        hashmap_free(m->monitored_mem_pressure_cgroup_contexts);
        hashmap_free(m->monitored_mem_pressure_cgroup_contexts_candidates);
        hashmap_free(m->monitored_rules_cgroup_contexts);
        hashmap_free(m->monitored_rules_cgroup_contexts_candidates);
 
        set_free(m->kill_states);
 
        hashmap_free(m->rulesets);
 
        return mfree(m);
}
 
static int manager_dispatch_reload_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        (void) notify_reloading();
 
        manager_set_defaults(m);
        manager_parse_config_file(m);
        warn_missing_rulesets(m);
 
        (void) sd_notify(/* unset_environment= */ false, NOTIFY_READY_MESSAGE);
        return 0;
}
 
int manager_new(Manager **ret) {
        _cleanup_(manager_freep) Manager *m = NULL;
        int r;
 
        assert(ret);
 
        m = new0(Manager, 1);
        if (!m)
                return -ENOMEM;
 
        manager_set_defaults(m);
        manager_parse_config_file(m);
 
        r = sd_event_default(&m->event);
        if (r < 0)
                return r;
 
        (void) sd_event_set_watchdog(m->event, true);
 
        r = sd_event_add_signal(m->event, /* ret= */ NULL, SIGHUP | SD_EVENT_SIGNAL_PROCMASK, manager_dispatch_reload_signal, m);
        if (r < 0)
                return r;
 
        r = sd_event_set_signal_exit(m->event, true);
        if (r < 0)
                return r;
 
        m->monitored_swap_cgroup_contexts = hashmap_new(&oomd_cgroup_ctx_hash_ops);
        if (!m->monitored_swap_cgroup_contexts)
                return -ENOMEM;
 
        m->monitored_mem_pressure_cgroup_contexts = hashmap_new(&oomd_cgroup_ctx_hash_ops);
        if (!m->monitored_mem_pressure_cgroup_contexts)
                return -ENOMEM;
 
        m->monitored_mem_pressure_cgroup_contexts_candidates = hashmap_new(&oomd_cgroup_ctx_hash_ops);
        if (!m->monitored_mem_pressure_cgroup_contexts_candidates)
                return -ENOMEM;
 
        m->monitored_rules_cgroup_contexts = hashmap_new(&oomd_cgroup_ctx_hash_ops);
        if (!m->monitored_rules_cgroup_contexts)
                return -ENOMEM;
 
        m->monitored_rules_cgroup_contexts_candidates = hashmap_new(&oomd_cgroup_ctx_hash_ops);
        if (!m->monitored_rules_cgroup_contexts_candidates)
                return -ENOMEM;
 
        *ret = TAKE_PTR(m);
        return 0;
}
 
static int manager_connect_bus(Manager *m) {
        int r;
 
        assert(m);
        assert(!m->bus);
 
        r = bus_open_system_watch_bind_with_description(&m->bus, "bus-api-oom");
        if (r < 0)
                return log_error_errno(r, "Failed to connect to bus: %m");
 
        r = bus_add_implementation(m->bus, &manager_object, m);
        if (r < 0)
                return r;
 
        r = bus_log_control_api_register(m->bus);
        if (r < 0)
                return r;
 
        r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.oom1", 0, NULL, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to request name: %m");
 
        r = sd_bus_attach_event(m->bus, m->event, 0);
        if (r < 0)
                return log_error_errno(r, "Failed to attach bus to event loop: %m");
 
        return 0;
}
 
static int manager_varlink_init(Manager *m, int fd) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
        int r;
 
        assert(m);
        assert(!m->varlink_server);
 
        r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate varlink server object: %m");
 
        r = sd_varlink_server_add_interface_many(
                        s,
                        &vl_interface_io_systemd_oom,
                        &vl_interface_io_systemd_service);
        if (r < 0)
                return log_error_errno(r, "Failed to add Varlink interfaces to varlink server: %m");
 
        r = sd_varlink_server_bind_method_many(
                        s,
                        "io.systemd.oom.ReportManagedOOMCGroups", process_managed_oom_request,
                        "io.systemd.service.Ping",                varlink_method_ping,
                        "io.systemd.service.SetLogLevel",         varlink_method_set_log_level,
                        "io.systemd.service.GetLogLevel",         varlink_method_get_log_level,
                        "io.systemd.service.GetEnvironment",      varlink_method_get_environment);
        if (r < 0)
                return log_error_errno(r, "Failed to register varlink methods: %m");
 
        if (fd < 0)
                r = sd_varlink_server_listen_address(s, VARLINK_PATH_MANAGED_OOM_USER, 0666);
        else
                r = sd_varlink_server_listen_fd(s, fd);
        if (r < 0)
                return log_error_errno(r, "Failed to bind to varlink socket %s: %m",
                                       VARLINK_PATH_MANAGED_OOM_USER);
 
        r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
 
        log_debug("Initialized systemd-oomd varlink server");
 
        m->varlink_server = TAKE_PTR(s);
        return 0;
}
 
int manager_start(
                Manager *m,
                bool dry_run,
                int fd) {
 
        int r;
 
        assert(m);
 
        m->dry_run = dry_run;
 
        r = manager_connect_bus(m);
        if (r < 0)
                return r;
 
        r = acquire_managed_oom_connect(m);
        if (r < 0)
                return r;
 
        r = manager_varlink_init(m, fd);
        if (r < 0)
                return r;
 
        r = monitor_memory_pressure_contexts(m);
        if (r < 0)
                return r;
 
        r = monitor_swap_contexts(m);
        if (r < 0)
                return r;
 
        r = monitor_rules_contexts(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
int manager_get_dump_string(Manager *m, char **ret) {
        _cleanup_(memstream_done) MemStream ms = {};
        _cleanup_free_ OomdCGroupContext **sorted = NULL;
        size_t n;
        FILE *f;
        int r;
 
        assert(m);
        assert(ret);
 
        /* Always reread memory/swap info here. Otherwise it may be outdated if swap monitoring is off.
         * Let's make sure to always report up-to-date data. */
        r = oomd_system_context_acquire("/proc/meminfo", &m->system_context);
        if (r < 0)
                log_debug_errno(r, "Failed to acquire system context, ignoring: %m");
 
        f = memstream_init(&ms);
        if (!f)
                return -ENOMEM;
 
        fprintf(f,
                "Dry Run: %s\n"
                "Swap Used Limit: " PERMYRIAD_AS_PERCENT_FORMAT_STR "\n"
                "Default Memory Pressure Limit: %lu.%02lu%%\n"
                "Default Memory Pressure Duration: %s\n"
                "System Context:\n",
                yes_no(m->dry_run),
                PERMYRIAD_AS_PERCENT_FORMAT_VAL(m->swap_used_limit_permyriad),
                LOADAVG_INT_SIDE(m->default_mem_pressure_limit), LOADAVG_DECIMAL_SIDE(m->default_mem_pressure_limit),
                FORMAT_TIMESPAN(m->default_mem_pressure_duration_usec, USEC_PER_SEC));
        oomd_dump_system_context(&m->system_context, f, "\t");
 
        r = hashmap_dump_sorted(m->monitored_swap_cgroup_contexts, (void***) &sorted, &n);
        if (r < 0)
                return r;
 
        fprintf(f, "Swap Monitored CGroups:\n");
        FOREACH_ARRAY(c, sorted, n)
                oomd_dump_swap_cgroup_context(*c, f, "\t");
 
        sorted = mfree(sorted);
        r = hashmap_dump_sorted(m->monitored_mem_pressure_cgroup_contexts, (void***) &sorted, &n);
        if (r < 0)
                return r;
 
        fprintf(f, "Memory Pressure Monitored CGroups:\n");
        FOREACH_ARRAY(c, sorted, n)
                oomd_dump_memory_pressure_cgroup_context(*c, f, "\t");
 
        return memstream_finalize(&ms, ret, NULL);
}