HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/dbus-unit.c

110,864 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: db9688a7c7f1b455a1a7e1b100b5c3c6e2ab5d0e

Lines 1001–2000 of 2,807

        SD_BUS_PROPERTY("ConditionResult", "b", bus_property_get_bool, offsetof(Unit, condition_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("AssertResult", "b", bus_property_get_bool, offsetof(Unit, assert_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        BUS_PROPERTY_DUAL_TIMESTAMP("ConditionTimestamp", offsetof(Unit, condition_timestamp), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        BUS_PROPERTY_DUAL_TIMESTAMP("AssertTimestamp", offsetof(Unit, assert_timestamp), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Conditions", "a(sbbsi)", property_get_conditions, offsetof(Unit, conditions), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        SD_BUS_PROPERTY("Asserts", "a(sbbsi)", property_get_conditions, offsetof(Unit, asserts), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        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_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", bus_property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("FailureAction", "s", bus_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),
        SD_BUS_PROPERTY("SuccessAction", "s", bus_property_get_emergency_action, offsetof(Unit, success_action), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SuccessActionExitStatus", "i", bus_property_get_int, offsetof(Unit, success_action_exit_status), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("InvocationID", "ay", bus_property_get_id128, offsetof(Unit, invocation_id), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("CollectMode", "s", property_get_collect_mode, offsetof(Unit, collect_mode), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Refs", "as", property_get_refs, 0, 0),
        SD_BUS_PROPERTY("ActivationDetails", "a(ss)", bus_property_get_activation_details, offsetof(Unit, activation_details), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("DebugInvocation", "b", bus_property_get_bool, offsetof(Unit, debug_invocation), 0),
 
        SD_BUS_METHOD_WITH_ARGS("Start",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_start,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Stop",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_stop,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Reload",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_reload,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Restart",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_restart,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("TryRestart",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_try_restart,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ReloadOrRestart",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_reload_or_restart,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestart",
                                SD_BUS_ARGS("s", mode),
                                SD_BUS_RESULT("o", job),
                                bus_unit_method_reload_or_try_restart,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("EnqueueJob",
                                SD_BUS_ARGS("s", job_type, "s", job_mode),
                                SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
                                bus_unit_method_enqueue_job,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Kill",
                                SD_BUS_ARGS("s", whom, "i", signal),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_kill,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("KillSubgroup",
                                SD_BUS_ARGS("s", subgroup, "i", signal),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_kill_subgroup,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("QueueSignal",
                                SD_BUS_ARGS("s", whom, "i", signal, "i", value),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_kill,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("ResetFailed",
                      NULL,
                      NULL,
                      bus_unit_method_reset_failed,
                      SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetProperties",
                                SD_BUS_ARGS("b", runtime, "a(sv)", properties),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_set_properties,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Ref",
                      NULL,
                      NULL,
                      bus_unit_method_ref,
                      SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Unref",
                      NULL,
                      NULL,
                      bus_unit_method_unref,
                      SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Clean",
                                SD_BUS_ARGS("as", mask),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_clean,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Freeze",
                      NULL,
                      NULL,
                      bus_unit_method_freeze,
                      SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Thaw",
                      NULL,
                      NULL,
                      bus_unit_method_thaw,
                      SD_BUS_VTABLE_UNPRIVILEGED),
 
        /* For dependency types we don't support anymore always return an empty array */
        SD_BUS_PROPERTY("RequiresOverridable", "as", property_get_empty_strv, 0, SD_BUS_VTABLE_HIDDEN),
        SD_BUS_PROPERTY("RequisiteOverridable", "as", property_get_empty_strv, 0, SD_BUS_VTABLE_HIDDEN),
        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_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
};
 
static int property_get_slice(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        return sd_bus_message_append(reply, "s", unit_slice_name(u));
}
 
static int property_get_available_memory(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        uint64_t sz = UINT64_MAX;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(reply);
 
        r = unit_get_memory_available(u, &sz);
        if (r < 0 && r != -ENODATA)
                log_unit_warning_errno(u, r, "Failed to get total available memory from cgroup: %m");
 
        return sd_bus_message_append(reply, "t", sz);
}
 
static int property_get_memory_accounting(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
        CGroupMemoryAccountingMetric metric;
        uint64_t sz = UINT64_MAX;
 
        assert(bus);
        assert(reply);
 
        assert_se((metric = cgroup_memory_accounting_metric_from_string(property)) >= 0);
        (void) unit_get_memory_accounting(u, metric, &sz);
        return sd_bus_message_append(reply, "t", sz);
}
 
static int property_get_current_tasks(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        uint64_t cn = UINT64_MAX;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(reply);
 
        r = unit_get_tasks_current(u, &cn);
        if (r < 0 && r != -ENODATA)
                log_unit_warning_errno(u, r, "Failed to get pids.current attribute: %m");
 
        return sd_bus_message_append(reply, "t", cn);
}
 
static int property_get_cpu_usage(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        nsec_t ns = NSEC_INFINITY;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
        assert(reply);
 
        r = unit_get_cpu_usage(u, &ns);
        if (r < 0 && r != -ENODATA)
                log_unit_warning_errno(u, r, "Failed to get CPU usage: %m");
 
        return sd_bus_message_append(reply, "t", ns);
}
 
static int property_get_cpuset_cpus(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
        _cleanup_(cpu_set_done) CPUSet cpus = {};
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
 
        assert(bus);
        assert(reply);
 
        (void) unit_get_cpuset(u, &cpus, "cpuset.cpus.effective");
        (void) cpu_set_to_dbus(&cpus, &array, &allocated);
        return sd_bus_message_append_array(reply, 'y', array, allocated);
}
 
static int property_get_cpuset_mems(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
        _cleanup_(cpu_set_done) CPUSet mems = {};
        _cleanup_free_ uint8_t *array = NULL;
        size_t allocated;
 
        assert(bus);
        assert(reply);
 
        (void) unit_get_cpuset(u, &mems, "cpuset.mems.effective");
        (void) cpu_set_to_dbus(&mems, &array, &allocated);
        return sd_bus_message_append_array(reply, 'y', array, allocated);
}
 
static int property_get_cgroup(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
        const char *t = NULL;
 
        assert(bus);
        assert(reply);
 
        /* Three cases: a) u->cgroup_path is NULL, in which case the
         * unit has no control group, which we report as the empty
         * string. b) u->cgroup_path is the empty string, which
         * indicates the root cgroup, which we report as "/". c) all
         * other cases we report as-is. */
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
 
        if (crt && crt->cgroup_path)
                t = empty_to_root(crt->cgroup_path);
 
        return sd_bus_message_append(reply, "s", t);
}
 
static int property_get_cgroup_id(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
        return sd_bus_message_append(reply, "t", crt ? crt->cgroup_id : UINT64_C(0));
}
 
static int property_get_oom_kills(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
        return sd_bus_message_append(reply, "t", crt ? crt->oom_kill_last : UINT64_MAX);
}
 
static int property_get_managed_oom_kills(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        Unit *u = ASSERT_PTR(userdata);
 
        assert(bus);
        assert(reply);
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
        return sd_bus_message_append(reply, "t", crt ? crt->managed_oom_kill_last : UINT64_MAX);
}
 
static int append_process(sd_bus_message *reply, const char *p, PidRef *pid, Set *pids) {
        _cleanup_free_ char *buf = NULL, *cmdline = NULL;
        int r;
 
        assert(reply);
        assert(pidref_is_set(pid));
 
        r = set_put(pids, PID_TO_PTR(pid->pid));
        if (IN_SET(r, 0, -EEXIST))
                return 0;
        if (r < 0)
                return r;
 
        if (!p) {
                r = cg_pidref_get_path(pid, &buf);
                if (r == -ESRCH)
                        return 0;
                if (r < 0)
                        return r;
 
                p = buf;
        }
 
        (void) pidref_get_cmdline(
                        pid,
                        SIZE_MAX,
                        PROCESS_CMDLINE_COMM_FALLBACK | PROCESS_CMDLINE_QUOTE,
                        &cmdline);
 
        return sd_bus_message_append(reply,
                                     "(sus)",
                                     p,
                                     (uint32_t) pid->pid,
                                     cmdline);
}
 
static int append_cgroup(sd_bus_message *reply, const char *p, Set *pids) {
        _cleanup_closedir_ DIR *d = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        int r;
 
        assert(reply);
        assert(p);
 
        r = cg_enumerate_processes(p, &f);
        if (r == -ENOENT)
                return 0;
        if (r < 0)
                return r;
 
        for (;;) {
                _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 
                /* libvirt / qemu uses threaded mode and cgroup.procs cannot be read at the lower levels.
                 * From https://docs.kernel.org/admin-guide/cgroup-v2.html#threads, “cgroup.procs” in a
                 * threaded domain cgroup contains the PIDs of all processes in the subtree and is not
                 * readable in the subtree proper.
                 *
                 * We'll see ENODEV when trying to enumerate processes and the cgroup is removed at the same
                 * time. Handle this gracefully. */
 
                r = cg_read_pidref(f, &pidref, /* flags= */ 0);
                if (IN_SET(r, 0, -EOPNOTSUPP, -ENODEV))
                        break;
                if (r < 0)
                        return r;
 
                r = pidref_is_kernel_thread(&pidref);
                if (r == -ESRCH) /* gone by now */
                        continue;
                if (r < 0)
                        log_debug_errno(r, "Failed to determine if " PID_FMT " is a kernel thread, assuming not: %m", pidref.pid);
                if (r > 0)
                        continue;
 
                r = append_process(reply, p, &pidref, pids);
                if (r < 0)
                        return r;
        }
 
        r = cg_enumerate_subgroups(p, &d);
        if (r == -ENOENT)
                return 0;
        if (r < 0)
                return r;
 
        for (;;) {
                _cleanup_free_ char *g = NULL, *j = NULL;
 
                r = cg_read_subgroup(d, &g);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;
 
                j = path_join(empty_to_root(p), g);
                if (!j)
                        return -ENOMEM;
 
                r = append_cgroup(reply, j, pids);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
int bus_unit_method_get_processes(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_set_free_ Set *pids = NULL;
        Unit *u = userdata;
        int r;
 
        assert(message);
 
        r = mac_selinux_unit_access_check(u, message, "status", reterr_error);
        if (r < 0)
                return r;
 
        pids = set_new(NULL);
        if (!pids)
                return -ENOMEM;
 
        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;
 
        r = sd_bus_message_open_container(reply, 'a', "(sus)");
        if (r < 0)
                return r;
 
        CGroupRuntime *crt = unit_get_cgroup_runtime(u);
        if (crt && crt->cgroup_path) {
                r = append_cgroup(reply, crt->cgroup_path, pids);
                if (r < 0)
                        return r;
        }
 
        /* The main and control pids might live outside of the cgroup, hence fetch them separately */
        PidRef *pid = unit_main_pid(u);
        if (pidref_is_set(pid)) {
                r = append_process(reply, NULL, pid, pids);
                if (r < 0)
                        return r;
        }
 
        pid = unit_control_pid(u);
        if (pidref_is_set(pid)) {
                r = append_process(reply, NULL, pid, pids);
                if (r < 0)
                        return r;
        }
 
        r = sd_bus_message_close_container(reply);
        if (r < 0)
                return r;
 
        return sd_bus_message_send(reply);
}
 
static int property_get_ip_counter(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        uint64_t value = UINT64_MAX;
        Unit *u = ASSERT_PTR(userdata);
        CGroupIPAccountingMetric metric;
 
        assert(bus);
        assert(reply);
        assert(property);
 
        assert_se((metric = cgroup_ip_accounting_metric_from_string(property)) >= 0);
        (void) unit_get_ip_accounting(u, metric, &value);
        return sd_bus_message_append(reply, "t", value);
}
 
static int property_get_io_counter(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        uint64_t value = UINT64_MAX;
        Unit *u = ASSERT_PTR(userdata);
        ssize_t metric;
 
        assert(bus);
        assert(reply);
        assert(property);
 
        assert_se((metric = cgroup_io_accounting_metric_from_string(property)) >= 0);
        (void) unit_get_io_accounting(u, metric, &value);
        return sd_bus_message_append(reply, "t", value);
}
 
static int property_get_effective_limit(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *reterr_error) {
 
        uint64_t value = CGROUP_LIMIT_MAX;
        Unit *u = ASSERT_PTR(userdata);
        ssize_t type;
 
        assert(bus);
        assert(reply);
        assert(property);
 
        assert_se((type = cgroup_effective_limit_type_from_string(property)) >= 0);
        (void) unit_get_effective_limit(u, type, &value);
        return sd_bus_message_append(reply, "t", value);
}
 
int bus_unit_method_attach_processes(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
        Unit *u = ASSERT_PTR(userdata);
        _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
        _cleanup_set_free_ Set *pids = NULL;
        const char *path;
        int r;
 
        assert(message);
 
        /* This migrates the processes with the specified PIDs into the cgroup of this unit, optionally below a
         * specified cgroup path. Obviously this only works for units that actually maintain a cgroup
         * representation. If a process is already in the cgroup no operation is executed – in this case the specified
         * subcgroup path has no effect! */
 
        r = mac_selinux_unit_access_check(u, message, "start", reterr_error);
        if (r < 0)
                return r;
 
        r = sd_bus_message_read(message, "s", &path);
        if (r < 0)
                return r;
 
        path = empty_to_null(path);
        if (path) {
                if (!path_is_absolute(path))
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Control group path is not absolute: %s", path);
 
                if (!path_is_normalized(path))
                        return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Control group path is not normalized: %s", path);
        }
 
        if (!unit_cgroup_delegate(u))
                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Process migration not available on non-delegated units.");
 
        if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)))
                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Unit is not active, refusing.");
 
        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PIDFD, &creds);
        if (r < 0)
                return r;
 
        /* Let's query the sender's UID, so that we can make our security decisions */
        uid_t sender_uid;
        r = sd_bus_creds_get_euid(creds, &sender_uid);
        if (r < 0)
                return r;
        bool validate_ownership = sender_uid != 0 && sender_uid != getuid();
 
        if (validate_ownership && !uid_is_valid(u->ref_uid)) /* process_is_owned_by_uid() requires a valid uid */
                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED,
                                         "Refusing to attach processes to unit with unknown user credentials.");
 
        r = sd_bus_message_enter_container(message, 'a', "u");
        if (r < 0)
                return r;
        for (;;) {
                _cleanup_(pidref_freep) PidRef *pidref = NULL;
                uint32_t upid;
 
                r = sd_bus_message_read(message, "u", &upid);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;
 
                if (upid == 0) {
                        _cleanup_(pidref_done) PidRef p = PIDREF_NULL;
                        r = bus_creds_get_pidref(creds, &p);
                        if (r < 0)
                                return r;
 
                        r = pidref_dup(&p, &pidref);
                } else
                        r = pidref_new_from_pid(upid, &pidref);
                if (r < 0)
                        return r;
 
                /* Filter out duplicates */
                if (set_contains(pids, pidref))
                        continue;
 
                /* Check if this process is suitable for attaching to this unit */
                r = unit_pid_attachable(u, pidref, reterr_error);
                if (r < 0)
                        return r;
 
                /* Let's validate security: if the sender is root or the owner of the service manager, then
                 * all is OK. If the sender is any other user, then the process in question must be owned by
                 * both the sender and the target unit's UID. Note that ownership here means either direct
                 * ownership, or indirect via a userns that is owned by the right UID. */
                if (validate_ownership) {
                        r = process_is_owned_by_uid(pidref, sender_uid);
                        if (r < 0)
                                return sd_bus_error_set_errnof(reterr_error, r, "Failed to check if process " PID_FMT " is owned by client's UID: %m", pidref->pid);
                        if (r == 0)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Process " PID_FMT " not owned by client's UID. Refusing.", pidref->pid);
 
                        r = process_is_owned_by_uid(pidref, u->ref_uid);
                        if (r < 0)
                                return sd_bus_error_set_errnof(reterr_error, r, "Failed to check if process " PID_FMT " is owned by target unit's UID: %m", pidref->pid);
                        if (r == 0)
                                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Process " PID_FMT " not owned by target unit's UID. Refusing.", pidref->pid);
                }
 
                r = set_ensure_consume(&pids, &pidref_hash_ops_free, TAKE_PTR(pidref));
                if (r < 0)
                        return r;
        }
 
        r = sd_bus_message_exit_container(message);
        if (r < 0)
                return r;
 
        r = unit_attach_pids_to_cgroup(u, pids, path);
        if (r < 0)
                return sd_bus_error_set_errnof(reterr_error, r, "Failed to attach processes to control group: %m");
 
        return sd_bus_reply_method_return(message, NULL);
}
 
int bus_unit_method_remove_subgroup(sd_bus_message *message, void *userdata, sd_bus_error *reterr_error) {
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(message);
 
        /* This removes a subcgroup of the unit, regardless which user owns the subcgroup. This is useful
         * when cgroup delegation is enabled for a unit, and the unit subdelegates the cgroup further */
 
        r = mac_selinux_unit_access_check(u, message, "stop", reterr_error);
        if (r < 0)
                return r;
 
        const char *path;
        uint64_t flags;
        r = sd_bus_message_read(message, "st", &path, &flags);
        if (r < 0)
                return r;
 
        /* No flags defined for now. */
        if (flags != 0)
                return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid 'flags' parameter '%" PRIu64 "'", flags);
 
        if (!unit_cgroup_delegate(u))
                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Subcgroup removal not available on non-delegated units.");
 
        if (!path_is_absolute(path))
                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Control group path is not absolute: %s", path);
 
        if (!path_is_normalized(path))
                return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Control group path is not normalized: %s", path);
 
        _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
        r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
        if (r < 0)
                return r;
 
        uid_t sender_uid;
        r = sd_bus_creds_get_euid(creds, &sender_uid);
        if (r < 0)
                return r;
 
        /* Allow this only if the client is privileged, is us, or is the user of the unit itself. */
        if (sender_uid != 0 && sender_uid != getuid() && sender_uid != u->ref_uid)
                return sd_bus_error_set(reterr_error, SD_BUS_ERROR_ACCESS_DENIED, "Client is not permitted to alter cgroup.");
 
        r = unit_remove_subcgroup(u, path);
        if (r < 0)
                return sd_bus_error_set_errnof(reterr_error, r, "Failed to remove subgroup %s: %m", path);
 
        return sd_bus_reply_method_return(message, NULL);
}
 
const sd_bus_vtable bus_unit_cgroup_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("Slice", "s", property_get_slice, 0, 0),
        SD_BUS_PROPERTY("ControlGroup", "s", property_get_cgroup, 0, 0),
        SD_BUS_PROPERTY("ControlGroupId", "t", property_get_cgroup_id, 0, 0),
        SD_BUS_PROPERTY("MemoryCurrent", "t", property_get_memory_accounting, 0, 0),
        SD_BUS_PROPERTY("MemoryPeak", "t", property_get_memory_accounting, 0, 0),
        SD_BUS_PROPERTY("MemorySwapCurrent", "t", property_get_memory_accounting, 0, 0),
        SD_BUS_PROPERTY("MemorySwapPeak", "t", property_get_memory_accounting, 0, 0),
        SD_BUS_PROPERTY("MemoryZSwapCurrent", "t", property_get_memory_accounting, 0, 0),
        SD_BUS_PROPERTY("MemoryAvailable", "t", property_get_available_memory, 0, 0),
        SD_BUS_PROPERTY("EffectiveMemoryMax", "t", property_get_effective_limit, 0, 0),
        SD_BUS_PROPERTY("EffectiveMemoryHigh", "t", property_get_effective_limit, 0, 0),
        SD_BUS_PROPERTY("CPUUsageNSec", "t", property_get_cpu_usage, 0, 0),
        SD_BUS_PROPERTY("EffectiveCPUs", "ay", property_get_cpuset_cpus, 0, 0),
        SD_BUS_PROPERTY("EffectiveMemoryNodes", "ay", property_get_cpuset_mems, 0, 0),
        SD_BUS_PROPERTY("TasksCurrent", "t", property_get_current_tasks, 0, 0),
        SD_BUS_PROPERTY("EffectiveTasksMax", "t", property_get_effective_limit, 0, 0),
        SD_BUS_PROPERTY("IPIngressBytes", "t", property_get_ip_counter, 0, 0),
        SD_BUS_PROPERTY("IPIngressPackets", "t", property_get_ip_counter, 0, 0),
        SD_BUS_PROPERTY("IPEgressBytes", "t", property_get_ip_counter, 0, 0),
        SD_BUS_PROPERTY("IPEgressPackets", "t", property_get_ip_counter, 0, 0),
        SD_BUS_PROPERTY("IOReadBytes", "t", property_get_io_counter, 0, 0),
        SD_BUS_PROPERTY("IOReadOperations", "t", property_get_io_counter, 0, 0),
        SD_BUS_PROPERTY("IOWriteBytes", "t", property_get_io_counter, 0, 0),
        SD_BUS_PROPERTY("IOWriteOperations", "t", property_get_io_counter, 0, 0),
        SD_BUS_PROPERTY("OOMKills", "t", property_get_oom_kills, 0, 0),
        SD_BUS_PROPERTY("ManagedOOMKills", "t", property_get_managed_oom_kills, 0, 0),
 
        SD_BUS_METHOD_WITH_ARGS("GetProcesses",
                                SD_BUS_NO_ARGS,
                                SD_BUS_ARGS("a(sus)", processes),
                                bus_unit_method_get_processes,
                                SD_BUS_VTABLE_UNPRIVILEGED),
 
        SD_BUS_METHOD_WITH_ARGS("AttachProcesses",
                                SD_BUS_ARGS("s", subcgroup, "au", pids),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_attach_processes,
                                SD_BUS_VTABLE_UNPRIVILEGED),
 
        SD_BUS_METHOD_WITH_ARGS("RemoveSubgroup",
                                SD_BUS_ARGS("s", subcgroup, "t", flags),
                                SD_BUS_NO_RESULT,
                                bus_unit_method_remove_subgroup,
                                SD_BUS_VTABLE_UNPRIVILEGED),
 
        SD_BUS_VTABLE_END
};
 
static int send_new_signal(sd_bus *bus, void *userdata) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        _cleanup_free_ char *p = NULL;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
 
        p = unit_dbus_path(u);
        if (!p)
                return -ENOMEM;
 
        r = sd_bus_message_new_signal(
                        bus,
                        &m,
                        "/org/freedesktop/systemd1",
                        "org.freedesktop.systemd1.Manager",
                        "UnitNew");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(m, "so", u->id, p);
        if (r < 0)
                return r;
 
        return sd_bus_send(bus, m, NULL);
}
 
static int send_changed_signal(sd_bus *bus, void *userdata) {
        _cleanup_free_ char *p = NULL;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
 
        p = unit_dbus_path(u);
        if (!p)
                return -ENOMEM;
 
        /* Send a properties changed signal. First for the specific
         * type, then for the generic unit. The clients may rely on
         * this order to get atomic behavior if needed. */
 
        r = sd_bus_emit_properties_changed_strv(
                        bus, p,
                        unit_dbus_interface_from_type(u->type),
                        NULL);
        if (r < 0)
                return r;
 
        return sd_bus_emit_properties_changed_strv(
                        bus, p,
                        "org.freedesktop.systemd1.Unit",
                        NULL);
}
 
void bus_unit_send_change_signal(Unit *u) {
        int r;
        assert(u);
 
        if (u->in_dbus_queue) {
                LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
                u->in_dbus_queue = false;
 
                /* The unit might be good to be GC once its pending signals have been sent */
                unit_add_to_gc_queue(u);
        }
 
        if (!u->id)
                return;
 
        r = bus_foreach_bus(u->manager, u->bus_track, u->sent_dbus_new_signal ? send_changed_signal : send_new_signal, u);
        if (r < 0)
                log_unit_debug_errno(u, r, "Failed to send unit change signal for %s: %m", u->id);
 
        u->sent_dbus_new_signal = true;
}
 
void bus_unit_send_pending_change_signal(Unit *u, bool including_new) {
 
        /* Sends out any pending change signals, but only if they really are pending. This call is used when we are
         * about to change state in order to force out a PropertiesChanged signal beforehand if there was one pending
         * so that clients can follow the full state transition */
 
        if (!u->in_dbus_queue) /* If not enqueued, don't bother */
                return;
 
        if (!u->sent_dbus_new_signal && !including_new) /* If the unit was never announced, don't bother, it's fine if
                                                         * the unit appears in the new state right-away (except if the
                                                         * caller explicitly asked us to send it anyway) */
                return;
 
        if (MANAGER_IS_RELOADING(u->manager)) /* Don't generate unnecessary PropertiesChanged signals for the same unit
                                               * when we are reloading. */
                return;
 
        bus_unit_send_change_signal(u);
}
 
int bus_unit_send_pending_freezer_message(Unit *u, bool canceled) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        int r;
 
        assert(u);
 
        if (!u->pending_freezer_invocation)
                return 0;
 
        if (canceled)
                r = sd_bus_message_new_method_error(
                                u->pending_freezer_invocation,
                                &reply,
                                &SD_BUS_ERROR_MAKE_CONST(
                                                BUS_ERROR_FREEZE_CANCELLED, "Freeze operation aborted"));
        else
                r = sd_bus_message_new_method_return(u->pending_freezer_invocation, &reply);
        if (r < 0)
                return r;
 
        r = sd_bus_message_send(reply);
        if (r < 0)
                log_warning_errno(r, "Failed to send queued message, ignoring: %m");
 
        u->pending_freezer_invocation = sd_bus_message_unref(u->pending_freezer_invocation);
 
        return 0;
}
 
static int send_removed_signal(sd_bus *bus, void *userdata) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        _cleanup_free_ char *p = NULL;
        Unit *u = ASSERT_PTR(userdata);
        int r;
 
        assert(bus);
 
        p = unit_dbus_path(u);
        if (!p)
                return -ENOMEM;
 
        r = sd_bus_message_new_signal(
                        bus,
                        &m,
                        "/org/freedesktop/systemd1",
                        "org.freedesktop.systemd1.Manager",
                        "UnitRemoved");
        if (r < 0)
                return r;
 
        r = sd_bus_message_append(m, "so", u->id, p);
        if (r < 0)
                return r;
 
        return sd_bus_send(bus, m, NULL);
}
 
void bus_unit_send_removed_signal(Unit *u) {
        int r;
        assert(u);
 
        if (!u->sent_dbus_new_signal || u->in_dbus_queue)
                bus_unit_send_change_signal(u);
 
        if (!u->id)
                return;
 
        r = bus_foreach_bus(u->manager, u->bus_track, send_removed_signal, u);
        if (r < 0)
                log_unit_debug_errno(u, r, "Failed to send unit remove signal for %s: %m", u->id);
}
 
int bus_unit_queue_job_one(
                sd_bus_message *message,
                Unit *u,
                JobType type,
                JobMode mode,
                BusUnitQueueFlags flags,
                sd_bus_message *reply,
                sd_bus_error *reterr_error) {
 
        _cleanup_set_free_ Set *affected = NULL;
        _cleanup_free_ char *job_path = NULL, *unit_path = NULL;
        Job *j, *a;
        int r;
 
        assert(u);
 
        r = unit_queue_job_check_and_mangle_type(
                        u,
                        &type,
                        /* reload_if_possible= */ FLAGS_SET(flags, BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE),