HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/dbus-cgroup.c

91,721 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 168bdf10c13da78d4726ca648f42a4ffbd95ad80

Lines 1001–2000 of 2,101

static int bus_cgroup_set_tasks_max_scale(
                Unit *u,
                const char *name,
                CGroupTasksMax *p,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *reterr_error) {
 
        uint32_t v;
        int r;
 
        assert(p);
 
        r = sd_bus_message_read(message, "u", &v);
        if (r < 0)
                return r;
 
        if (v < 1 || v >= UINT32_MAX)
                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
                                         "Value specified in %s is out of range", name);
 
        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                *p = (CGroupTasksMax) { v, UINT32_MAX }; /* .scale is not 0, so this is interpreted as v/UINT32_MAX. */
                unit_invalidate_cgroup(u, CGROUP_MASK_PIDS);
 
                int scaled = UINT32_SCALE_TO_PERMYRIAD(v);
                unit_write_settingf(u, flags, name, "TasksMax=" PERMYRIAD_AS_PERCENT_FORMAT_STR,
                                   PERMYRIAD_AS_PERCENT_FORMAT_VAL(scaled));
        }
 
        return 1;
}
 
int bus_cgroup_set_property(
                Unit *u,
                CGroupContext *c,
                const char *name,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *reterr_error) {
 
        CGroupIOLimitType iol_type;
        int r;
 
        assert(u);
        assert(c);
        assert(name);
        assert(message);
 
        flags |= UNIT_PRIVATE;
 
        if (streq(name, "CPUWeight"))
                return bus_cgroup_set_cpu_weight(u, name, &c->cpu_weight, message, flags, reterr_error);
 
        if (streq(name, "StartupCPUWeight"))
                return bus_cgroup_set_cpu_weight(u, name, &c->startup_cpu_weight, message, flags, reterr_error);
 
        if (streq(name, "IOAccounting"))
                return bus_cgroup_set_boolean(u, name, &c->io_accounting, CGROUP_MASK_IO, message, flags, reterr_error);
 
        if (streq(name, "IOWeight"))
                return bus_cgroup_set_io_weight(u, name, &c->io_weight, message, flags, reterr_error);
 
        if (streq(name, "StartupIOWeight"))
                return bus_cgroup_set_io_weight(u, name, &c->startup_io_weight, message, flags, reterr_error);
 
        if (streq(name, "MemoryAccounting"))
                return bus_cgroup_set_boolean(u, name, &c->memory_accounting, CGROUP_MASK_MEMORY, message, flags, reterr_error);
 
        if (streq(name, "MemoryMin"))
                return bus_cgroup_set_memory_protection(u, name, &c->memory_min, message, flags, reterr_error);
 
        if (streq(name, "MemoryLow"))
                return bus_cgroup_set_memory_protection(u, name, &c->memory_low, message, flags, reterr_error);
 
        if (streq(name, "StartupMemoryLow")) {
                r = bus_cgroup_set_memory_protection(u, name, &c->startup_memory_low, message, flags, reterr_error);
                if (r > 0)
                        c->startup_memory_low_set = true;
                return r;
        }
 
        if (streq(name, "MemoryHigh"))
                return bus_cgroup_set_memory(u, name, &c->memory_high, message, flags, reterr_error);
 
        if (streq(name, "StartupMemoryHigh")) {
                r = bus_cgroup_set_memory(u, name, &c->startup_memory_high, message, flags, reterr_error);
                if (r > 0)
                        c->startup_memory_high_set = true;
                return r;
        }
 
        if (streq(name, "MemorySwapMax"))
                return bus_cgroup_set_swap(u, name, &c->memory_swap_max, message, flags, reterr_error);
 
        if (streq(name, "StartupMemorySwapMax")) {
                r = bus_cgroup_set_swap(u, name, &c->startup_memory_swap_max, message, flags, reterr_error);
                if (r > 0)
                        c->startup_memory_swap_max_set = true;
                return r;
        }
 
        if (streq(name, "MemoryZSwapMax"))
                return bus_cgroup_set_zswap(u, name, &c->memory_zswap_max, message, flags, reterr_error);
 
        if (streq(name, "StartupMemoryZSwapMax")) {
                r = bus_cgroup_set_zswap(u, name, &c->startup_memory_zswap_max, message, flags, reterr_error);
                if (r > 0)
                        c->startup_memory_zswap_max_set = true;
                return r;
        }
 
        if (streq(name, "MemoryMax"))
                return bus_cgroup_set_memory(u, name, &c->memory_max, message, flags, reterr_error);
 
        if (streq(name, "StartupMemoryMax")) {
                r = bus_cgroup_set_memory(u, name, &c->startup_memory_max, message, flags, reterr_error);
                if (r > 0)
                        c->startup_memory_max_set = true;
                return r;
        }
 
        if (streq(name, "MemoryMinScale"))
                return bus_cgroup_set_memory_protection_scale(u, name, &c->memory_min, message, flags, reterr_error);
 
        if (streq(name, "MemoryLowScale"))
                return bus_cgroup_set_memory_protection_scale(u, name, &c->memory_low, message, flags, reterr_error);
 
        if (streq(name, "MemoryHighScale"))
                return bus_cgroup_set_memory_scale(u, name, &c->memory_high, message, flags, reterr_error);
 
        if (streq(name, "MemorySwapMaxScale"))
                return bus_cgroup_set_swap_scale(u, name, &c->memory_swap_max, message, flags, reterr_error);
 
        if (streq(name, "MemoryZSwapMaxScale"))
                return bus_cgroup_set_zswap_scale(u, name, &c->memory_zswap_max, message, flags, reterr_error);
 
        if (streq(name, "MemoryMaxScale"))
                return bus_cgroup_set_memory_scale(u, name, &c->memory_max, message, flags, reterr_error);
 
        if (streq(name, "MemoryZSwapWriteback"))
                return bus_cgroup_set_boolean(u, name, &c->memory_zswap_writeback, CGROUP_MASK_MEMORY, message, flags, reterr_error);
 
        if (streq(name, "TasksAccounting"))
                return bus_cgroup_set_boolean(u, name, &c->tasks_accounting, CGROUP_MASK_PIDS, message, flags, reterr_error);
 
        if (streq(name, "TasksMax"))
                return bus_cgroup_set_tasks_max(u, name, &c->tasks_max, message, flags, reterr_error);
 
        if (streq(name, "TasksMaxScale"))
                return bus_cgroup_set_tasks_max_scale(u, name, &c->tasks_max, message, flags, reterr_error);
 
        if (streq(name, "CPUQuotaPerSecUSec")) {
                uint64_t u64;
 
                r = sd_bus_message_read(message, "t", &u64);
                if (r < 0)
                        return r;
 
                if (u64 <= 0)
                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "CPUQuotaPerSecUSec= value out of range");
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->cpu_quota_per_sec_usec = u64;
                        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
                        if (crt)
                                crt->warned_clamping_cpu_quota_period = false;
                        unit_invalidate_cgroup(u, CGROUP_MASK_CPU);
 
                        if (c->cpu_quota_per_sec_usec == USEC_INFINITY)
                                unit_write_setting(u, flags, "CPUQuota", "CPUQuota=");
                        else
                                unit_write_settingf(u, flags, "CPUQuota",
                                                    "CPUQuota=" USEC_FMT ".%02" PRI_USEC "%%",
                                                    c->cpu_quota_per_sec_usec / 10000,
                                                    (c->cpu_quota_per_sec_usec % 10000) / 100);
                }
 
                return 1;
 
        } else if (streq(name, "CPUQuotaPeriodUSec")) {
                uint64_t u64;
 
                r = sd_bus_message_read(message, "t", &u64);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->cpu_quota_period_usec = u64;
                        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
                        if (crt)
                                crt->warned_clamping_cpu_quota_period = false;
                        unit_invalidate_cgroup(u, CGROUP_MASK_CPU);
                        if (c->cpu_quota_period_usec == USEC_INFINITY)
                                unit_write_setting(u, flags, "CPUQuotaPeriodSec", "CPUQuotaPeriodSec=");
                        else
                                unit_write_settingf(u, flags, "CPUQuotaPeriodSec",
                                                    "CPUQuotaPeriodSec=%s",
                                                    FORMAT_TIMESPAN(c->cpu_quota_period_usec, 1));
                }
 
                return 1;
 
        } else if (STR_IN_SET(name, "AllowedCPUs", "StartupAllowedCPUs", "AllowedMemoryNodes", "StartupAllowedMemoryNodes")) {
                const void *a;
                size_t n;
                _cleanup_(cpu_set_done) CPUSet new_set = {};
 
                r = sd_bus_message_read_array(message, 'y', &a, &n);
                if (r < 0)
                        return r;
 
                r = cpu_set_from_dbus(a, n, &new_set);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *setstr = NULL;
                        CPUSet *set = NULL;
 
                        setstr = cpu_set_to_range_string(&new_set);
                        if (!setstr)
                                return -ENOMEM;
 
                        if (streq(name, "AllowedCPUs"))
                                set = &c->cpuset_cpus;
                        else if (streq(name, "StartupAllowedCPUs"))
                                set = &c->startup_cpuset_cpus;
                        else if (streq(name, "AllowedMemoryNodes"))
                                set = &c->cpuset_mems;
                        else if (streq(name, "StartupAllowedMemoryNodes"))
                                set = &c->startup_cpuset_mems;
                        else
                                assert_not_reached();
 
                        cpu_set_done_and_replace(*set, new_set);
 
                        unit_invalidate_cgroup(u, CGROUP_MASK_CPUSET);
                        unit_write_settingf(u, flags, name, "%s=\n%s=%s", name, name, setstr);
                }
 
                return 1;
 
        } else if ((iol_type = cgroup_io_limit_type_from_string(name)) >= 0) {
                const char *path;
                unsigned n = 0;
                uint64_t u64;
 
                r = sd_bus_message_enter_container(message, 'a', "(st)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(st)", &path, &u64)) > 0) {
 
                        if (!path_is_normalized(path))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Path '%s' specified in %s= is not normalized.", name, path);
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                CGroupIODeviceLimit *a = NULL;
 
                                LIST_FOREACH(device_limits, b, c->io_device_limits)
                                        if (path_equal(path, b->path)) {
                                                a = b;
                                                break;
                                        }
 
                                if (!a) {
                                        CGroupIOLimitType type;
 
                                        a = new0(CGroupIODeviceLimit, 1);
                                        if (!a)
                                                return -ENOMEM;
 
                                        a->path = strdup(path);
                                        if (!a->path) {
                                                free(a);
                                                return -ENOMEM;
                                        }
 
                                        for (type = 0; type < _CGROUP_IO_LIMIT_TYPE_MAX; type++)
                                                a->limits[type] = cgroup_io_limit_defaults[type];
 
                                        LIST_APPEND(device_limits, c->io_device_limits, a);
                                }
 
                                a->limits[iol_type] = u64;
                        }
 
                        n++;
                }
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        FILE *f;
 
                        if (n == 0)
                                LIST_FOREACH(device_limits, a, c->io_device_limits)
                                        a->limits[iol_type] = cgroup_io_limit_defaults[iol_type];
 
                        unit_invalidate_cgroup(u, CGROUP_MASK_IO);
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        fprintf(f, "%s=\n", name);
                        LIST_FOREACH(device_limits, a, c->io_device_limits)
                                if (a->limits[iol_type] != cgroup_io_limit_defaults[iol_type])
                                        fprintf(f, "%s=%s %" PRIu64 "\n", name, a->path, a->limits[iol_type]);
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
 
        } else if (streq(name, "IODeviceWeight")) {
                const char *path;
                uint64_t weight;
                unsigned n = 0;
 
                r = sd_bus_message_enter_container(message, 'a', "(st)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(st)", &path, &weight)) > 0) {
 
                        if (!path_is_normalized(path))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Path '%s' specified in %s= is not normalized.", name, path);
 
                        if (!CGROUP_WEIGHT_IS_OK(weight) || weight == CGROUP_WEIGHT_INVALID)
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "IODeviceWeight= value out of range");
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                CGroupIODeviceWeight *a = NULL;
 
                                LIST_FOREACH(device_weights, b, c->io_device_weights)
                                        if (path_equal(b->path, path)) {
                                                a = b;
                                                break;
                                        }
 
                                if (!a) {
                                        a = new0(CGroupIODeviceWeight, 1);
                                        if (!a)
                                                return -ENOMEM;
 
                                        a->path = strdup(path);
                                        if (!a->path) {
                                                free(a);
                                                return -ENOMEM;
                                        }
                                        LIST_APPEND(device_weights, c->io_device_weights, a);
                                }
 
                                a->weight = weight;
                        }
 
                        n++;
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        FILE *f;
 
                        if (n == 0)
                                while (c->io_device_weights)
                                        cgroup_context_free_io_device_weight(c, c->io_device_weights);
 
                        unit_invalidate_cgroup(u, CGROUP_MASK_IO);
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        fputs("IODeviceWeight=\n", f);
                        LIST_FOREACH(device_weights, a, c->io_device_weights)
                                fprintf(f, "IODeviceWeight=%s %" PRIu64 "\n", a->path, a->weight);
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
 
        } else if (streq(name, "IODeviceLatencyTargetUSec")) {
                const char *path;
                uint64_t target;
                unsigned n = 0;
 
                r = sd_bus_message_enter_container(message, 'a', "(st)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(st)", &path, &target)) > 0) {
 
                        if (!path_is_normalized(path))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Path '%s' specified in %s= is not normalized.", name, path);
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                CGroupIODeviceLatency *a = NULL;
 
                                LIST_FOREACH(device_latencies, b, c->io_device_latencies)
                                        if (path_equal(b->path, path)) {
                                                a = b;
                                                break;
                                        }
 
                                if (!a) {
                                        a = new0(CGroupIODeviceLatency, 1);
                                        if (!a)
                                                return -ENOMEM;
 
                                        a->path = strdup(path);
                                        if (!a->path) {
                                                free(a);
                                                return -ENOMEM;
                                        }
                                        LIST_APPEND(device_latencies, c->io_device_latencies, a);
                                }
 
                                a->target_usec = target;
                        }
 
                        n++;
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        FILE *f;
 
                        if (n == 0)
                                while (c->io_device_latencies)
                                        cgroup_context_free_io_device_latency(c, c->io_device_latencies);
 
                        unit_invalidate_cgroup(u, CGROUP_MASK_IO);
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        fputs("IODeviceLatencyTargetSec=\n", f);
                        LIST_FOREACH(device_latencies, a, c->io_device_latencies)
                                fprintf(f, "IODeviceLatencyTargetSec=%s %s\n",
                                        a->path, FORMAT_TIMESPAN(a->target_usec, 1));
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
 
        } else if (streq(name, "DevicePolicy")) {
                const char *policy;
                CGroupDevicePolicy p;
 
                r = sd_bus_message_read(message, "s", &policy);
                if (r < 0)
                        return r;
 
                p = cgroup_device_policy_from_string(policy);
                if (p < 0)
                        return p;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->device_policy = p;
                        unit_invalidate_cgroup(u, CGROUP_MASK_BPF_DEVICES);
                        unit_write_settingf(u, flags, name, "DevicePolicy=%s", policy);
                }
 
                return 1;
 
        } else if (streq(name, "CPUSetPartition")) {
                const char *partition_str;
                CPUSetPartition p;
 
                r = sd_bus_message_read(message, "s", &partition_str);
                if (r < 0)
                        return r;
 
                if (isempty(partition_str))
                        p = _CPUSET_PARTITION_INVALID;
                else {
                        p = cpuset_partition_from_string(partition_str);
                        if (p < 0)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
                                                         "Invalid CPUSetPartition value: %s", partition_str);
                }
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->cpuset_partition = p;
                        unit_invalidate_cgroup(u, CGROUP_MASK_CPUSET);
 
                        if (p == _CPUSET_PARTITION_INVALID)
                                unit_write_settingf(u, flags, name, "%s=", name);
                        else
                                unit_write_settingf(u, flags, name, "%s=%s", name, partition_str);
                }
 
                return 1;
 
        } else if (streq(name, "DeviceAllow")) {
                const char *path, *rwm;
                unsigned n = 0;
 
                r = sd_bus_message_enter_container(message, 'a', "(ss)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(ss)", &path, &rwm)) > 0) {
                        CGroupDevicePermissions p;
 
                        if (!valid_device_allow_pattern(path) || strpbrk(path, WHITESPACE))
                                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "DeviceAllow= requires device node or pattern");
 
                        if (isempty(rwm))
                                p = _CGROUP_DEVICE_PERMISSIONS_ALL;
                        else {
                                p = cgroup_device_permissions_from_string(rwm);
                                if (p < 0)
                                        return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "DeviceAllow= requires combination of rwm flags");
                        }
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                r = cgroup_context_add_or_update_device_allow(c, path, p);
                                if (r < 0)
                                        return r;
                        }
 
                        n++;
                }
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        FILE *f;
 
                        if (n == 0)
                                while (c->device_allow)
                                        cgroup_context_free_device_allow(c, c->device_allow);
 
                        unit_invalidate_cgroup(u, CGROUP_MASK_BPF_DEVICES);
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        fputs("DeviceAllow=\n", f);
                        LIST_FOREACH(device_allow, a, c->device_allow)
                                fprintf(f, "DeviceAllow=%s %s\n", a->path, cgroup_device_permissions_to_string(a->permissions));
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
 
        } else if (streq(name, "IPAccounting")) {
                int b;
 
                r = sd_bus_message_read(message, "b", &b);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->ip_accounting = b;
 
                        unit_invalidate_cgroup_bpf_firewall(u);
                        unit_write_settingf(u, flags, name, "IPAccounting=%s", yes_no(b));
                }
 
                return 1;
 
        } else if (STR_IN_SET(name, "IPAddressAllow", "IPAddressDeny")) {
                _cleanup_set_free_ Set *new_prefixes = NULL;
                size_t n = 0;
 
                r = sd_bus_message_enter_container(message, 'a', "(iayu)");
                if (r < 0)
                        return r;
 
                for (;;) {
                        r = sd_bus_message_enter_container(message, 'r', "iayu");
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        struct in_addr_prefix prefix;
                        r = bus_message_read_in_addr_auto(message, reterr_error, &prefix.family, &prefix.address);
                        if (r < 0)
                                return r;
 
                        uint32_t prefixlen;
                        r = sd_bus_message_read(message, "u", &prefixlen);
                        if (r < 0)
                                return r;
 
                        if (prefixlen > FAMILY_ADDRESS_SIZE(prefix.family)*8)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS,
                                                         "Prefix length %" PRIu32 " too large for address family %s.",
                                                         prefixlen, af_to_name(prefix.family));
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                prefix.prefixlen = (uint8_t) prefixlen;
 
                                r = in_addr_prefix_add(&new_prefixes, &prefix);
                                if (r < 0)
                                        return r;
                        }
 
                        r = sd_bus_message_exit_container(message);
                        if (r < 0)
                                return r;
 
                        n++;
                }
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        Set **prefixes;
                        bool *reduced;
                        FILE *f;
 
                        unit_invalidate_cgroup_bpf_firewall(u);
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        prefixes = streq(name, "IPAddressAllow") ? &c->ip_address_allow : &c->ip_address_deny;
                        reduced = streq(name, "IPAddressAllow") ? &c->ip_address_allow_reduced : &c->ip_address_deny_reduced;
 
                        fputs(name, f);
                        fputs("=\n", f);
 
                        if (n == 0) {
                                *reduced = true;
                                *prefixes = set_free(*prefixes);
                        } else {
                                *reduced = false;
 
                                r = in_addr_prefixes_merge(prefixes, new_prefixes);
                                if (r < 0)
                                        return r;
 
                                const struct in_addr_prefix *p;
                                SET_FOREACH(p, *prefixes)
                                        fprintf(f, "%s=%s\n", name,
                                                IN_ADDR_PREFIX_TO_STRING(p->family, &p->address, p->prefixlen));
                        }
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
        }
 
        if (STR_IN_SET(name, "ManagedOOMSwap", "ManagedOOMMemoryPressure")) {
                ManagedOOMMode *cgroup_mode = streq(name, "ManagedOOMSwap") ? &c->moom_swap : &c->moom_mem_pressure;
                ManagedOOMMode m;
                const char *mode;
 
                if (!UNIT_VTABLE(u)->can_set_managed_oom)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Cannot set %s for this unit type", name);
 
                r = sd_bus_message_read(message, "s", &mode);
                if (r < 0)
                        return r;
 
                m = managed_oom_mode_from_string(mode);
                if (m < 0)
                        return -EINVAL;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        *cgroup_mode = m;
                        unit_write_settingf(u, flags, name, "%s=%s", name, mode);
                }
 
                (void) manager_varlink_send_managed_oom_update(u);
                return 1;
        }
 
        if (streq(name, "ManagedOOMMemoryPressureLimit")) {
                uint32_t v;
 
                if (!UNIT_VTABLE(u)->can_set_managed_oom)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Cannot set %s for this unit type", name);
 
                r = sd_bus_message_read(message, "u", &v);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->moom_mem_pressure_limit = v;
                        unit_write_settingf(u, flags, name,
                                            "ManagedOOMMemoryPressureLimit=" PERMYRIAD_AS_PERCENT_FORMAT_STR,
                                            PERMYRIAD_AS_PERCENT_FORMAT_VAL(UINT32_SCALE_TO_PERMYRIAD(v)));
                }
 
                if (c->moom_mem_pressure == MANAGED_OOM_KILL)
                        (void) manager_varlink_send_managed_oom_update(u);
 
                return 1;
        }
 
        if (streq(name, "ManagedOOMMemoryPressureDurationUSec")) {
                uint64_t t;
 
                if (!UNIT_VTABLE(u)->can_set_managed_oom)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Cannot set %s for this unit type", name);
 
                r = sd_bus_message_read(message, "t", &t);
                if (r < 0)
                        return r;
 
                if (t < 1 * USEC_PER_SEC)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s= must be at least 1s, got %s", name,
                                                 FORMAT_TIMESPAN(t, USEC_PER_SEC));
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->moom_mem_pressure_duration_usec = t;
                        if (c->moom_mem_pressure_duration_usec == USEC_INFINITY)
                                unit_write_setting(u, flags, name, "ManagedOOMMemoryPressureDurationSec=");
                        else
                                unit_write_settingf(u, flags, name,
                                                    "ManagedOOMMemoryPressureDurationSec=%s",
                                                    FORMAT_TIMESPAN(c->moom_mem_pressure_duration_usec, 1));
                }
 
                if (c->moom_mem_pressure == MANAGED_OOM_KILL)
                        (void) manager_varlink_send_managed_oom_update(u);
 
                return 1;
        }
 
        if (streq(name, "ManagedOOMPreference")) {
                ManagedOOMPreference p;
                const char *pref;
 
                r = sd_bus_message_read(message, "s", &pref);
                if (r < 0)
                        return r;
 
                p = managed_oom_preference_from_string(pref);
                if (p < 0)
                        return p;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        c->moom_preference = p;
                        unit_write_settingf(u, flags, name, "ManagedOOMPreference=%s", pref);
                }
 
                return 1;
        }
 
        if (streq(name, "OOMRules")) {
                _cleanup_strv_free_ char **oom_rules = NULL;
 
                if (!UNIT_VTABLE(u)->can_set_managed_oom)
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Cannot set %s for this unit type", name);
 
                r = sd_bus_message_read_strv(message, &oom_rules);
                if (r < 0)
                        return r;
 
                STRV_FOREACH(rule, oom_rules)
                        if (!string_is_safe(*rule, STRING_FILENAME))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid rule name: %s", *rule);
 
                strv_uniq(oom_rules);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = strv_join(oom_rules, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        strv_free_and_replace(c->moom_rules, oom_rules);
 
                        unit_write_settingf(u, flags, name, "OOMRules=\nOOMRules=%s", joined);
 
                        (void) manager_varlink_send_managed_oom_update(u);
                }
 
                return 1;
        }
 
        if (STR_IN_SET(name, "SocketBindAllow", "SocketBindDeny")) {
                CGroupSocketBindItem **list;
                uint16_t nr_ports, port_min;
                size_t n = 0;
                int32_t family, ip_protocol;
 
                list = streq(name, "SocketBindAllow") ? &c->socket_bind_allow : &c->socket_bind_deny;
 
                r = sd_bus_message_enter_container(message, 'a', "(iiqq)");
                if (r < 0)
                        return r;
 
                while ((r = sd_bus_message_read(message, "(iiqq)", &family, &ip_protocol, &nr_ports, &port_min)) > 0) {
 
                        if (!IN_SET(family, AF_UNSPEC, AF_INET, AF_INET6))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s= expects INET or INET6 family, if specified.", name);
 
                        if (!IN_SET(ip_protocol, 0, IPPROTO_TCP, IPPROTO_UDP))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s= expects TCP or UDP protocol, if specified.", name);
 
                        if (port_min + (uint32_t) nr_ports > (1 << 16))
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s= expects maximum port value lesser than 65536.", name);
 
                        if (port_min == 0 && nr_ports != 0)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "%s= expects port range starting with positive value.", name);
 
                        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                                _cleanup_free_ CGroupSocketBindItem *item = NULL;
 
                                item = new(CGroupSocketBindItem, 1);
                                if (!item)
                                        return log_oom();
 
                                *item = (CGroupSocketBindItem) {
                                        .address_family = family,
                                        .ip_protocol = ip_protocol,
                                        .nr_ports = nr_ports,
                                        .port_min = port_min
                                };
 
                                LIST_PREPEND(socket_bind_items, *list, TAKE_PTR(item));
                        }
                        n++;
                }
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_(memstream_done) MemStream m = {};
                        _cleanup_free_ char *buf = NULL;
                        FILE *f;
 
                        if (n == 0)
                                cgroup_context_remove_socket_bind(list);
                        else {
                                if ((u->manager->cgroup_supported & CGROUP_MASK_BPF_SOCKET_BIND) == 0)
                                        log_full(LOG_DEBUG,
                                                 "Unit %s configures source compiled BPF programs "
                                                 "but the local system does not support that.\n"
                                                 "Starting this unit will fail!", u->id);
                        }
 
                        f = memstream_init(&m);
                        if (!f)
                                return -ENOMEM;
 
                        if (n == 0)
                                fprintf(f, "%s=\n", name);
                        else
                                LIST_FOREACH(socket_bind_items, item, *list) {
                                        fprintf(f, "%s=", name);
                                        cgroup_context_dump_socket_bind_item(item, f);
                                        fputc('\n', f);
                                }
 
                        r = memstream_finalize(&m, &buf, NULL);
                        if (r < 0)
                                return r;
 
                        unit_write_setting(u, flags, name, buf);
                }
 
                return 1;
        }
 
        if (streq(name, "RestrictNetworkInterfaces")) {
                int is_allow_list;
                _cleanup_strv_free_ char **l = NULL;
 
                r = sd_bus_message_enter_container(message, 'r', "bas");
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read(message, "b", &is_allow_list);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_read_strv(message, &l);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        _cleanup_free_ char *joined = NULL;
 
                        if (strv_isempty(l)) {
                                c->restrict_network_interfaces_is_allow_list = false;
                                c->restrict_network_interfaces = set_free(c->restrict_network_interfaces);
 
                                unit_write_settingf(u, flags, name, "%s=", name);
                                return 1;
                        }
 
                        if (set_isempty(c->restrict_network_interfaces))
                                c->restrict_network_interfaces_is_allow_list = is_allow_list;
 
                        STRV_FOREACH(s, l) {
                                if (!ifname_valid_full(*s, IFNAME_VALID_ALTERNATIVE)) {
                                        log_full(LOG_WARNING, "Invalid interface name, ignoring: %s", *s);
                                        continue;
                                }
                                if (c->restrict_network_interfaces_is_allow_list != (bool) is_allow_list)
                                        free(set_remove(c->restrict_network_interfaces, *s));
                                else {
                                        r = set_put_strdup(&c->restrict_network_interfaces, *s);
                                        if (r < 0)
                                                return log_oom();
                                }
                        }
 
                        joined = strv_join(l, " ");
                        if (!joined)
                                return -ENOMEM;
 
                        unit_write_settingf(u, flags, name, "%s=%s%s", name, is_allow_list ? "" : "~", joined);
                }
 
                return 1;
        }
 
        if (streq(name, "BindNetworkInterface")) {
                const char *s;
 
                r = sd_bus_message_read(message, "s", &s);
                if (r < 0)
                        return r;
 
                if (!isempty(s) && !ifname_valid_full(s, IFNAME_VALID_ALTERNATIVE))
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface name: %s", s);
 
                if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                        r = free_and_strdup_warn(&c->bind_network_interface, empty_to_null(s));
                        if (r < 0)
                                return r;
                        if (r > 0)
                                unit_write_settingf(u, flags, name, "BindNetworkInterface=%s", s);
                }
 
                return 1;
        }
 
        if (streq(name, "NFTSet")) {