1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
5 #include <sys/statvfs.h>
8 #include "alloc-util.h"
9 #include "architecture.h"
11 #include "bus-common-errors.h"
12 #include "bus-get-properties.h"
13 #include "bus-log-control-api.h"
14 #include "chase-symlinks.h"
15 #include "data-fd-util.h"
16 #include "dbus-cgroup.h"
17 #include "dbus-execute.h"
19 #include "dbus-manager.h"
20 #include "dbus-scope.h"
21 #include "dbus-service.h"
22 #include "dbus-unit.h"
27 #include "format-util.h"
30 #include "manager-dump.h"
32 #include "parse-util.h"
33 #include "path-util.h"
34 #include "process-util.h"
35 #include "selinux-access.h"
36 #include "stat-util.h"
37 #include "string-util.h"
39 #include "syslog-util.h"
40 #include "user-util.h"
44 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state
45 * there, and if we can't we'll fail badly. */
46 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
48 static UnitFileFlags
unit_file_bools_to_flags(bool runtime
, bool force
) {
49 return (runtime
? UNIT_FILE_RUNTIME
: 0) |
50 (force
? UNIT_FILE_FORCE
: 0);
53 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_oom_policy
, oom_policy
, OOMPolicy
);
54 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_emergency_action
, emergency_action
, EmergencyAction
);
56 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version
, "s", GIT_VERSION
);
57 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features
, "s", systemd_features
);
58 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture
, "s", architecture_to_string(uname_architecture()));
59 static BUS_DEFINE_PROPERTY_GET2(property_get_system_state
, "s", Manager
, manager_state
, manager_state_to_string
);
60 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec
, "t", (uint64_t) prctl(PR_GET_TIMERSLACK
));
61 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size
, "u", Hashmap
*, hashmap_size
);
62 static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size
, "u", Set
*, set_size
);
63 static BUS_DEFINE_PROPERTY_GET(property_get_default_timeout_abort_usec
, "t", Manager
, manager_default_timeout_abort_usec
);
64 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_device
, "s", watchdog_get_device());
65 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_realtime
, "t", watchdog_get_last_ping(CLOCK_REALTIME
));
66 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_monotonic
, "t", watchdog_get_last_ping(CLOCK_MONOTONIC
));
68 static int property_get_virtualization(
71 const char *interface
,
73 sd_bus_message
*reply
,
75 sd_bus_error
*error
) {
82 v
= detect_virtualization();
84 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
86 * https://github.com/systemd/systemd/issues/1423
89 return sd_bus_message_append(
91 v
== VIRTUALIZATION_NONE
? NULL
: virtualization_to_string(v
));
94 static int property_get_tainted(
97 const char *interface
,
99 sd_bus_message
*reply
,
101 sd_bus_error
*error
) {
103 _cleanup_free_
char *s
= NULL
;
104 Manager
*m
= ASSERT_PTR(userdata
);
109 s
= manager_taint_string(m
);
113 return sd_bus_message_append(reply
, "s", s
);
116 static int property_set_log_target(
119 const char *interface
,
120 const char *property
,
121 sd_bus_message
*value
,
123 sd_bus_error
*error
) {
125 Manager
*m
= userdata
;
132 r
= sd_bus_message_read(value
, "s", &t
);
137 manager_restore_original_log_target(m
);
141 target
= log_target_from_string(t
);
143 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid log target '%s'", t
);
145 manager_override_log_target(m
, target
);
151 static int property_set_log_level(
154 const char *interface
,
155 const char *property
,
156 sd_bus_message
*value
,
158 sd_bus_error
*error
) {
160 Manager
*m
= userdata
;
167 r
= sd_bus_message_read(value
, "s", &t
);
172 manager_restore_original_log_level(m
);
176 level
= log_level_from_string(t
);
178 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid log level '%s'", t
);
180 manager_override_log_level(m
, level
);
186 static int property_get_progress(
189 const char *interface
,
190 const char *property
,
191 sd_bus_message
*reply
,
193 sd_bus_error
*error
) {
195 Manager
*m
= ASSERT_PTR(userdata
);
201 if (MANAGER_IS_FINISHED(m
))
204 d
= 1.0 - ((double) hashmap_size(m
->jobs
) / (double) m
->n_installed_jobs
);
206 return sd_bus_message_append(reply
, "d", d
);
209 static int property_get_environment(
212 const char *interface
,
213 const char *property
,
214 sd_bus_message
*reply
,
216 sd_bus_error
*error
) {
218 _cleanup_strv_free_
char **l
= NULL
;
219 Manager
*m
= ASSERT_PTR(userdata
);
225 r
= manager_get_effective_environment(m
, &l
);
229 return sd_bus_message_append_strv(reply
, l
);
232 static int property_get_show_status(
235 const char *interface
,
236 const char *property
,
237 sd_bus_message
*reply
,
239 sd_bus_error
*error
) {
241 Manager
*m
= ASSERT_PTR(userdata
);
246 return sd_bus_message_append(reply
, "b", manager_get_show_status_on(m
));
249 static int property_get_runtime_watchdog(
252 const char *interface
,
253 const char *property
,
254 sd_bus_message
*reply
,
256 sd_bus_error
*error
) {
258 Manager
*m
= ASSERT_PTR(userdata
);
263 return sd_bus_message_append(reply
, "t", manager_get_watchdog(m
, WATCHDOG_RUNTIME
));
266 static int property_get_pretimeout_watchdog(
269 const char *interface
,
270 const char *property
,
271 sd_bus_message
*reply
,
273 sd_bus_error
*error
) {
275 Manager
*m
= ASSERT_PTR(userdata
);
280 return sd_bus_message_append(reply
, "t", manager_get_watchdog(m
, WATCHDOG_PRETIMEOUT
));
283 static int property_get_pretimeout_watchdog_governor(
286 const char *interface
,
287 const char *property
,
288 sd_bus_message
*reply
,
290 sd_bus_error
*error
) {
292 Manager
*m
= ASSERT_PTR(userdata
);
297 return sd_bus_message_append(reply
, "s", m
->watchdog_pretimeout_governor
);
300 static int property_get_reboot_watchdog(
303 const char *interface
,
304 const char *property
,
305 sd_bus_message
*reply
,
307 sd_bus_error
*error
) {
309 Manager
*m
= ASSERT_PTR(userdata
);
314 return sd_bus_message_append(reply
, "t", manager_get_watchdog(m
, WATCHDOG_REBOOT
));
317 static int property_get_kexec_watchdog(
320 const char *interface
,
321 const char *property
,
322 sd_bus_message
*reply
,
324 sd_bus_error
*error
) {
326 Manager
*m
= ASSERT_PTR(userdata
);
331 return sd_bus_message_append(reply
, "t", manager_get_watchdog(m
, WATCHDOG_KEXEC
));
334 static int property_set_watchdog(Manager
*m
, WatchdogType type
, sd_bus_message
*value
) {
341 assert_cc(sizeof(usec_t
) == sizeof(uint64_t));
343 r
= sd_bus_message_read(value
, "t", &timeout
);
347 manager_override_watchdog(m
, type
, timeout
);
351 static int property_set_runtime_watchdog(
354 const char *interface
,
355 const char *property
,
356 sd_bus_message
*value
,
358 sd_bus_error
*error
) {
360 return property_set_watchdog(userdata
, WATCHDOG_RUNTIME
, value
);
363 static int property_set_pretimeout_watchdog(
366 const char *interface
,
367 const char *property
,
368 sd_bus_message
*value
,
370 sd_bus_error
*error
) {
372 return property_set_watchdog(userdata
, WATCHDOG_PRETIMEOUT
, value
);
375 static int property_set_pretimeout_watchdog_governor(
378 const char *interface
,
379 const char *property
,
380 sd_bus_message
*value
,
382 sd_bus_error
*error
) {
384 Manager
*m
= ASSERT_PTR(userdata
);
388 r
= sd_bus_message_read(value
, "s", &governor
);
391 if (!string_is_safe(governor
))
394 return manager_override_watchdog_pretimeout_governor(m
, governor
);
397 static int property_set_reboot_watchdog(
400 const char *interface
,
401 const char *property
,
402 sd_bus_message
*value
,
404 sd_bus_error
*error
) {
406 return property_set_watchdog(userdata
, WATCHDOG_REBOOT
, value
);
409 static int property_set_kexec_watchdog(
412 const char *interface
,
413 const char *property
,
414 sd_bus_message
*value
,
416 sd_bus_error
*error
) {
418 _unused_ Manager
*m
= ASSERT_PTR(userdata
);
423 return property_set_watchdog(userdata
, WATCHDOG_KEXEC
, value
);
426 static int property_get_oom_score_adjust(
429 const char *interface
,
430 const char *property
,
431 sd_bus_message
*reply
,
433 sd_bus_error
*error
) {
435 Manager
*m
= ASSERT_PTR(userdata
);
441 if (m
->default_oom_score_adjust_set
)
442 n
= m
->default_oom_score_adjust
;
445 r
= get_oom_score_adjust(&n
);
447 log_debug_errno(r
, "Failed to read current OOM score adjustment value, ignoring: %m");
450 return sd_bus_message_append(reply
, "i", n
);
453 static int bus_get_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
461 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up
462 * its sleeve: if the name is specified empty we use the client's unit. */
465 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
468 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
472 r
= sd_bus_creds_get_pid(creds
, &pid
);
476 u
= manager_get_unit_by_pid(m
, pid
);
478 return sd_bus_error_set(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
480 u
= manager_get_unit(m
, name
);
482 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
489 static int bus_load_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
494 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
497 return bus_get_unit_by_name(m
, message
, name
, ret_unit
, error
);
499 return manager_load_unit(m
, name
, NULL
, error
, ret_unit
);
502 static int reply_unit_path(Unit
*u
, sd_bus_message
*message
, sd_bus_error
*error
) {
503 _cleanup_free_
char *path
= NULL
;
509 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
513 path
= unit_dbus_path(u
);
517 return sd_bus_reply_method_return(message
, "o", path
);
520 static int method_get_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
521 Manager
*m
= ASSERT_PTR(userdata
);
528 /* Anyone can call this method */
530 r
= sd_bus_message_read(message
, "s", &name
);
534 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
538 return reply_unit_path(u
, message
, error
);
541 static int method_get_unit_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
542 Manager
*m
= ASSERT_PTR(userdata
);
549 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
551 /* Anyone can call this method */
553 r
= sd_bus_message_read(message
, "u", &pid
);
557 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid PID " PID_FMT
, pid
);
560 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
562 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
566 r
= sd_bus_creds_get_pid(creds
, &pid
);
571 u
= manager_get_unit_by_pid(m
, pid
);
573 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_PID
, "PID "PID_FMT
" does not belong to any loaded unit.", pid
);
575 return reply_unit_path(u
, message
, error
);
578 static int method_get_unit_by_invocation_id(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
579 _cleanup_free_
char *path
= NULL
;
580 Manager
*m
= ASSERT_PTR(userdata
);
589 /* Anyone can call this method */
591 r
= sd_bus_message_read_array(message
, 'y', &a
, &sz
);
599 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid invocation ID");
601 if (sd_id128_is_null(id
)) {
602 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
605 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
609 r
= sd_bus_creds_get_pid(creds
, &pid
);
613 u
= manager_get_unit_by_pid(m
, pid
);
615 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
,
616 "Client " PID_FMT
" not member of any unit.", pid
);
618 u
= hashmap_get(m
->units_by_invocation_id
, &id
);
620 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID
, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR
" known.", SD_ID128_FORMAT_VAL(id
));
623 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
627 /* So here's a special trick: the bus path we return actually references the unit by its invocation
628 * ID instead of the unit name. This means it stays valid only as long as the invocation ID stays the
630 path
= unit_dbus_path_invocation_id(u
);
634 return sd_bus_reply_method_return(message
, "o", path
);
637 static int method_get_unit_by_control_group(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
638 Manager
*m
= userdata
;
643 r
= sd_bus_message_read(message
, "s", &cgroup
);
647 u
= manager_get_unit_by_cgroup(m
, cgroup
);
649 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
,
650 "Control group '%s' is not valid or not managed by this instance",
653 return reply_unit_path(u
, message
, error
);
656 static int method_load_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
657 Manager
*m
= ASSERT_PTR(userdata
);
664 /* Anyone can call this method */
666 r
= sd_bus_message_read(message
, "s", &name
);
670 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
674 return reply_unit_path(u
, message
, error
);
677 static int method_start_unit_generic(sd_bus_message
*message
, Manager
*m
, JobType job_type
, bool reload_if_possible
, sd_bus_error
*error
) {
685 r
= sd_bus_message_read(message
, "s", &name
);
689 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
693 return bus_unit_method_start_generic(message
, u
, job_type
, reload_if_possible
, error
);
696 static int method_start_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
697 return method_start_unit_generic(message
, userdata
, JOB_START
, /* reload_if_possible = */ false, error
);
700 static int method_stop_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
701 return method_start_unit_generic(message
, userdata
, JOB_STOP
, /* reload_if_possible = */ false, error
);
704 static int method_reload_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
705 return method_start_unit_generic(message
, userdata
, JOB_RELOAD
, /* reload_if_possible = */ false, error
);
708 static int method_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
709 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, /* reload_if_possible = */ false, error
);
712 static int method_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
713 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, /* reload_if_possible = */ false, error
);
716 static int method_reload_or_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
717 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, /* reload_if_possible = */ true, error
);
720 static int method_reload_or_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
721 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, /* reload_if_possible = */ true, error
);
724 typedef enum GenericUnitOperationFlags
{
725 GENERIC_UNIT_LOAD
= 1 << 0, /* Load if the unit is not loaded yet */
726 GENERIC_UNIT_VALIDATE_LOADED
= 1 << 1, /* Verify unit is properly loaded before forwarding call */
727 } GenericUnitOperationFlags
;
729 static int method_generic_unit_operation(
730 sd_bus_message
*message
,
733 sd_bus_message_handler_t handler
,
734 GenericUnitOperationFlags flags
) {
743 /* Read the first argument from the command and pass the operation to the specified per-unit
746 r
= sd_bus_message_read(message
, "s", &name
);
750 if (!isempty(name
) && FLAGS_SET(flags
, GENERIC_UNIT_LOAD
))
751 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
753 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
757 if (FLAGS_SET(flags
, GENERIC_UNIT_VALIDATE_LOADED
)) {
758 r
= bus_unit_validate_load_state(u
, error
);
763 return handler(message
, u
, error
);
766 static int method_enqueue_unit_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
767 /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
768 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_enqueue_job
, GENERIC_UNIT_LOAD
);
771 static int method_start_unit_replace(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
772 Manager
*m
= ASSERT_PTR(userdata
);
773 const char *old_name
;
779 r
= sd_bus_message_read(message
, "s", &old_name
);
783 r
= bus_get_unit_by_name(m
, message
, old_name
, &u
, error
);
786 if (!u
->job
|| u
->job
->type
!= JOB_START
)
787 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "No job queued for unit %s", old_name
);
789 return method_start_unit_generic(message
, m
, JOB_START
, /* reload_if_possible = */ false, error
);
792 static int method_kill_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
793 /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
794 * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
795 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_kill
, 0);
798 static int method_clean_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
799 /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
801 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_clean
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
804 static int method_freeze_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
805 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_freeze
, 0);
808 static int method_thaw_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
809 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_thaw
, 0);
812 static int method_reset_failed_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
813 /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
814 * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
815 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_reset_failed
, 0);
818 static int method_set_unit_properties(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
819 /* Only change properties on fully loaded units, and load them in order to set properties */
820 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_set_properties
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
823 static int method_bind_mount_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
824 /* Only add mounts on fully loaded units */
825 return method_generic_unit_operation(message
, userdata
, error
, bus_service_method_bind_mount
, GENERIC_UNIT_VALIDATE_LOADED
);
828 static int method_mount_image_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
829 /* Only add mounts on fully loaded units */
830 return method_generic_unit_operation(message
, userdata
, error
, bus_service_method_mount_image
, GENERIC_UNIT_VALIDATE_LOADED
);
833 static int method_ref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
834 /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
835 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_ref
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
838 static int method_unref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
839 /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
840 * loaded unit there's no need to load the unit for unreffing it. */
841 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_unref
, 0);
844 static int reply_unit_info(sd_bus_message
*reply
, Unit
*u
) {
845 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
848 following
= unit_following(u
);
850 unit_path
= unit_dbus_path(u
);
855 job_path
= job_dbus_path(u
->job
);
860 return sd_bus_message_append(
861 reply
, "(ssssssouso)",
864 unit_load_state_to_string(u
->load_state
),
865 unit_active_state_to_string(unit_active_state(u
)),
866 unit_sub_state_to_string(u
),
867 following
? following
->id
: "",
869 u
->job
? u
->job
->id
: 0,
870 u
->job
? job_type_to_string(u
->job
->type
) : "",
871 empty_to_root(job_path
));
874 static int method_list_units_by_names(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
875 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
876 Manager
*m
= ASSERT_PTR(userdata
);
878 _cleanup_strv_free_
char **units
= NULL
;
882 r
= sd_bus_message_read_strv(message
, &units
);
886 r
= sd_bus_message_new_method_return(message
, &reply
);
890 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
894 STRV_FOREACH(unit
, units
) {
897 if (!unit_name_is_valid(*unit
, UNIT_NAME_ANY
))
900 r
= bus_load_unit_by_name(m
, message
, *unit
, &u
, error
);
904 r
= reply_unit_info(reply
, u
);
909 r
= sd_bus_message_close_container(reply
);
913 return sd_bus_send(NULL
, reply
, NULL
);
916 static int method_get_unit_processes(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
917 /* Don't load a unit (since it won't have any processes if it's not loaded), but don't insist on the
918 * unit being loaded (because even improperly loaded units might still have processes around */
919 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_get_processes
, 0);
922 static int method_attach_processes_to_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
923 /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
924 * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
925 * processes to stopped units anyway. */
926 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_attach_processes
, GENERIC_UNIT_VALIDATE_LOADED
);
929 static int transient_unit_from_message(
931 sd_bus_message
*message
,
934 sd_bus_error
*error
) {
944 t
= unit_name_to_type(name
);
946 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
947 "Invalid unit name or type.");
949 if (!unit_vtable
[t
]->can_transient
)
950 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
951 "Unit type %s does not support transient units.",
952 unit_type_to_string(t
));
954 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
958 if (!unit_is_pristine(u
))
959 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
960 "Unit %s was already loaded or has a fragment file.", name
);
962 /* OK, the unit failed to load and is unreferenced, now let's
963 * fill in the transient data instead */
964 r
= unit_make_transient(u
);
968 /* Set our properties */
969 r
= bus_unit_set_properties(u
, message
, UNIT_RUNTIME
, false, error
);
973 /* If the client asked for it, automatically add a reference to this unit. */
974 if (u
->bus_track_add
) {
975 r
= bus_unit_track_add_sender(u
, message
);
977 return log_error_errno(r
, "Failed to watch sender: %m");
980 /* Now load the missing bits of the unit we just created */
981 unit_add_to_load_queue(u
);
982 manager_dispatch_load_queue(m
);
989 static int transient_aux_units_from_message(
991 sd_bus_message
*message
,
992 sd_bus_error
*error
) {
999 r
= sd_bus_message_enter_container(message
, 'a', "(sa(sv))");
1003 while ((r
= sd_bus_message_enter_container(message
, 'r', "sa(sv)")) > 0) {
1004 const char *name
= NULL
;
1007 r
= sd_bus_message_read(message
, "s", &name
);
1011 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
1015 r
= sd_bus_message_exit_container(message
);
1022 r
= sd_bus_message_exit_container(message
);
1029 static int method_start_transient_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1030 const char *name
, *smode
;
1031 Manager
*m
= ASSERT_PTR(userdata
);
1038 r
= mac_selinux_access_check(message
, "start", error
);
1042 r
= sd_bus_message_read(message
, "ss", &name
, &smode
);
1046 mode
= job_mode_from_string(smode
);
1048 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Job mode %s is invalid.", smode
);
1050 r
= bus_verify_manage_units_async(m
, message
, error
);
1054 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1056 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
1060 r
= transient_aux_units_from_message(m
, message
, error
);
1064 /* Finally, start it */
1065 return bus_unit_queue_job(message
, u
, JOB_START
, mode
, 0, error
);
1068 static int method_get_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1069 _cleanup_free_
char *path
= NULL
;
1070 Manager
*m
= ASSERT_PTR(userdata
);
1077 /* Anyone can call this method */
1079 r
= sd_bus_message_read(message
, "u", &id
);
1083 j
= manager_get_job(m
, id
);
1085 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1087 r
= mac_selinux_unit_access_check(j
->unit
, message
, "status", error
);
1091 path
= job_dbus_path(j
);
1095 return sd_bus_reply_method_return(message
, "o", path
);
1098 static int method_cancel_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1099 Manager
*m
= ASSERT_PTR(userdata
);
1106 r
= sd_bus_message_read(message
, "u", &id
);
1110 j
= manager_get_job(m
, id
);
1112 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1114 return bus_job_method_cancel(message
, j
, error
);
1117 static int method_clear_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1118 Manager
*m
= ASSERT_PTR(userdata
);
1123 r
= mac_selinux_access_check(message
, "reload", error
);
1127 r
= bus_verify_manage_units_async(m
, message
, error
);
1131 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1133 manager_clear_jobs(m
);
1135 return sd_bus_reply_method_return(message
, NULL
);
1138 static int method_reset_failed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1139 Manager
*m
= ASSERT_PTR(userdata
);
1144 r
= mac_selinux_access_check(message
, "reload", error
);
1148 r
= bus_verify_manage_units_async(m
, message
, error
);
1152 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1154 manager_reset_failed(m
);
1156 return sd_bus_reply_method_return(message
, NULL
);
1159 static int list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1160 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1161 Manager
*m
= ASSERT_PTR(userdata
);
1168 /* Anyone can call this method */
1170 r
= mac_selinux_access_check(message
, "status", error
);
1174 r
= sd_bus_message_new_method_return(message
, &reply
);
1178 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
1182 HASHMAP_FOREACH_KEY(u
, k
, m
->units
) {
1186 if (!strv_isempty(states
) &&
1187 !strv_contains(states
, unit_load_state_to_string(u
->load_state
)) &&
1188 !strv_contains(states
, unit_active_state_to_string(unit_active_state(u
))) &&
1189 !strv_contains(states
, unit_sub_state_to_string(u
)))
1192 if (!strv_isempty(patterns
) &&
1193 !strv_fnmatch_or_empty(patterns
, u
->id
, FNM_NOESCAPE
))
1196 r
= reply_unit_info(reply
, u
);
1201 r
= sd_bus_message_close_container(reply
);
1205 return sd_bus_send(NULL
, reply
, NULL
);
1208 static int method_list_units(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1209 return list_units_filtered(message
, userdata
, error
, NULL
, NULL
);
1212 static int method_list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1213 _cleanup_strv_free_
char **states
= NULL
;
1216 r
= sd_bus_message_read_strv(message
, &states
);
1220 return list_units_filtered(message
, userdata
, error
, states
, NULL
);
1223 static int method_list_units_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1224 _cleanup_strv_free_
char **states
= NULL
;
1225 _cleanup_strv_free_
char **patterns
= NULL
;
1228 r
= sd_bus_message_read_strv(message
, &states
);
1232 r
= sd_bus_message_read_strv(message
, &patterns
);
1236 return list_units_filtered(message
, userdata
, error
, states
, patterns
);
1239 static int method_list_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1240 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1241 Manager
*m
= ASSERT_PTR(userdata
);
1247 /* Anyone can call this method */
1249 r
= mac_selinux_access_check(message
, "status", error
);
1253 r
= sd_bus_message_new_method_return(message
, &reply
);
1257 r
= sd_bus_message_open_container(reply
, 'a', "(usssoo)");
1261 HASHMAP_FOREACH(j
, m
->jobs
) {
1262 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
1264 job_path
= job_dbus_path(j
);
1268 unit_path
= unit_dbus_path(j
->unit
);
1272 r
= sd_bus_message_append(
1276 job_type_to_string(j
->type
),
1277 job_state_to_string(j
->state
),
1284 r
= sd_bus_message_close_container(reply
);
1288 return sd_bus_send(NULL
, reply
, NULL
);
1291 static int method_subscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1292 Manager
*m
= ASSERT_PTR(userdata
);
1297 /* Anyone can call this method */
1299 r
= mac_selinux_access_check(message
, "status", error
);
1303 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1305 /* Note that direct bus connection subscribe by
1306 * default, we only track peers on the API bus here */
1308 if (!m
->subscribed
) {
1309 r
= sd_bus_track_new(sd_bus_message_get_bus(message
), &m
->subscribed
, NULL
, NULL
);
1314 r
= sd_bus_track_add_sender(m
->subscribed
, message
);
1318 return sd_bus_error_set(error
, BUS_ERROR_ALREADY_SUBSCRIBED
, "Client is already subscribed.");
1321 return sd_bus_reply_method_return(message
, NULL
);
1324 static int method_unsubscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1325 Manager
*m
= ASSERT_PTR(userdata
);
1330 /* Anyone can call this method */
1332 r
= mac_selinux_access_check(message
, "status", error
);
1336 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1337 r
= sd_bus_track_remove_sender(m
->subscribed
, message
);
1341 return sd_bus_error_set(error
, BUS_ERROR_NOT_SUBSCRIBED
, "Client is not subscribed.");
1344 return sd_bus_reply_method_return(message
, NULL
);
1347 static int dump_impl(
1348 sd_bus_message
*message
,
1350 sd_bus_error
*error
,
1352 int (*reply
)(sd_bus_message
*, char *)) {
1354 _cleanup_free_
char *dump
= NULL
;
1355 Manager
*m
= ASSERT_PTR(userdata
);
1360 /* Anyone can call this method */
1362 r
= mac_selinux_access_check(message
, "status", error
);
1366 r
= manager_get_dump_string(m
, patterns
, &dump
);
1370 return reply(message
, dump
);
1373 static int reply_dump(sd_bus_message
*message
, char *dump
) {
1374 return sd_bus_reply_method_return(message
, "s", dump
);
1377 static int method_dump(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1378 return dump_impl(message
, userdata
, error
, NULL
, reply_dump
);
1381 static int reply_dump_by_fd(sd_bus_message
*message
, char *dump
) {
1382 _cleanup_close_
int fd
= -EBADF
;
1384 fd
= acquire_data_fd(dump
, strlen(dump
), 0);
1388 return sd_bus_reply_method_return(message
, "h", fd
);
1391 static int method_dump_by_fd(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1392 return dump_impl(message
, userdata
, error
, NULL
, reply_dump_by_fd
);
1395 static int dump_units_matching_patterns(
1396 sd_bus_message
*message
,
1398 sd_bus_error
*error
,
1399 int (*reply
)(sd_bus_message
*, char *)) {
1400 _cleanup_strv_free_
char **patterns
= NULL
;
1403 r
= sd_bus_message_read_strv(message
, &patterns
);
1407 return dump_impl(message
, userdata
, error
, patterns
, reply
);
1410 static int method_dump_units_matching_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1411 return dump_units_matching_patterns(message
, userdata
, error
, reply_dump
);
1414 static int method_dump_units_matching_patterns_by_fd(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1415 return dump_units_matching_patterns(message
, userdata
, error
, reply_dump_by_fd
);
1418 static int method_refuse_snapshot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1419 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Support for snapshots has been removed.");
1422 static int verify_run_space(const char *message
, sd_bus_error
*error
) {
1423 struct statvfs svfs
;
1426 if (statvfs("/run/systemd", &svfs
) < 0)
1427 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1429 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1431 if (available
< RELOAD_DISK_SPACE_MIN
)
1432 return sd_bus_error_setf(error
,
1433 BUS_ERROR_DISK_FULL
,
1434 "%s, not enough space available on /run/systemd. "
1435 "Currently, %s are free, but a safety buffer of %s is enforced.",
1437 FORMAT_BYTES(available
),
1438 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN
));
1443 int verify_run_space_and_log(const char *message
) {
1444 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1447 r
= verify_run_space(message
, &error
);
1449 return log_error_errno(r
, "%s", bus_error_message(&error
, r
));
1454 static void log_caller(sd_bus_message
*message
, Manager
*manager
, const char *method
) {
1455 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1456 const char *comm
= NULL
;
1464 if (sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
|SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_COMM
, &creds
) < 0)
1467 /* We need at least the PID, otherwise there's nothing to log, the rest is optional */
1468 if (sd_bus_creds_get_pid(creds
, &pid
) < 0)
1471 (void) sd_bus_creds_get_comm(creds
, &comm
);
1472 caller
= manager_get_unit_by_pid(manager
, pid
);
1474 log_info("%s requested from client PID " PID_FMT
" ('%s') (from unit '%s')...",
1475 method
, pid
, strna(comm
), strna(caller
? caller
->id
: NULL
));
1478 static int method_reload(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1479 Manager
*m
= ASSERT_PTR(userdata
);
1484 r
= verify_run_space("Refusing to reload", error
);
1488 r
= mac_selinux_access_check(message
, "reload", error
);
1492 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1496 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1498 /* Write a log message noting the unit or process who requested the Reload() */
1499 log_caller(message
, m
, "Reloading");
1501 /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1502 if (!ratelimit_below(&m
->reload_ratelimit
)) {
1503 log_warning("Reloading request rejected due to rate limit.");
1504 return sd_bus_error_setf(error
,
1505 SD_BUS_ERROR_LIMITS_EXCEEDED
,
1506 "Reload() request rejected due to rate limit.");
1509 /* Instead of sending the reply back right away, we just
1510 * remember that we need to and then send it after the reload
1511 * is finished. That way the caller knows when the reload
1514 assert(!m
->pending_reload_message
);
1515 r
= sd_bus_message_new_method_return(message
, &m
->pending_reload_message
);
1519 m
->objective
= MANAGER_RELOAD
;
1524 static int method_reexecute(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1525 Manager
*m
= ASSERT_PTR(userdata
);
1530 r
= verify_run_space("Refusing to reexecute", error
);
1534 r
= mac_selinux_access_check(message
, "reload", error
);
1538 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1542 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1544 /* Write a log message noting the unit or process who requested the Reexecute() */
1545 log_caller(message
, m
, "Reexecuting");
1547 /* We don't send a reply back here, the client should
1548 * just wait for us disconnecting. */
1550 m
->objective
= MANAGER_REEXECUTE
;
1554 static int method_exit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1555 Manager
*m
= ASSERT_PTR(userdata
);
1560 r
= mac_selinux_access_check(message
, "halt", error
);
1564 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1565 * we are running on the host. It will fall back on reboot() in
1566 * systemd-shutdown if it cannot do the exit() because it isn't a
1569 m
->objective
= MANAGER_EXIT
;
1571 return sd_bus_reply_method_return(message
, NULL
);
1574 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1575 Manager
*m
= ASSERT_PTR(userdata
);
1580 r
= mac_selinux_access_check(message
, "reboot", error
);
1584 if (!MANAGER_IS_SYSTEM(m
))
1585 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1586 "Reboot is only supported for system managers.");
1588 m
->objective
= MANAGER_REBOOT
;
1590 return sd_bus_reply_method_return(message
, NULL
);
1593 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1594 Manager
*m
= ASSERT_PTR(userdata
);
1599 r
= mac_selinux_access_check(message
, "halt", error
);
1603 if (!MANAGER_IS_SYSTEM(m
))
1604 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1605 "Powering off is only supported for system managers.");
1607 m
->objective
= MANAGER_POWEROFF
;
1609 return sd_bus_reply_method_return(message
, NULL
);
1612 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1613 Manager
*m
= ASSERT_PTR(userdata
);
1618 r
= mac_selinux_access_check(message
, "halt", error
);
1622 if (!MANAGER_IS_SYSTEM(m
))
1623 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1624 "Halt is only supported for system managers.");
1626 m
->objective
= MANAGER_HALT
;
1628 return sd_bus_reply_method_return(message
, NULL
);
1631 static int method_kexec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1632 Manager
*m
= ASSERT_PTR(userdata
);
1637 r
= mac_selinux_access_check(message
, "reboot", error
);
1641 if (!MANAGER_IS_SYSTEM(m
))
1642 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1643 "KExec is only supported for system managers.");
1645 m
->objective
= MANAGER_KEXEC
;
1647 return sd_bus_reply_method_return(message
, NULL
);
1650 static int method_switch_root(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1651 _cleanup_free_
char *ri
= NULL
, *rt
= NULL
;
1652 const char *root
, *init
;
1653 Manager
*m
= ASSERT_PTR(userdata
);
1654 struct statvfs svfs
;
1660 if (statvfs("/run/systemd", &svfs
) < 0)
1661 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1663 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1665 if (available
< RELOAD_DISK_SPACE_MIN
)
1666 log_warning("Dangerously low amount of free space on /run/systemd, root switching might fail.\n"
1667 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1668 FORMAT_BYTES(available
),
1669 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN
));
1671 r
= mac_selinux_access_check(message
, "reboot", error
);
1675 if (!MANAGER_IS_SYSTEM(m
))
1676 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1677 "Root switching is only supported by system manager.");
1679 r
= sd_bus_message_read(message
, "ss", &root
, &init
);
1683 if (!path_is_valid(root
))
1684 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1685 "New root directory must be a valid path.");
1686 if (!path_is_absolute(root
))
1687 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1688 "New root path '%s' is not absolute.", root
);
1689 if (path_equal(root
, "/"))
1690 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1691 "New root directory cannot be the old root directory.");
1694 if (isempty(init
)) {
1695 r
= path_is_os_tree(root
);
1697 return sd_bus_error_set_errnof(error
, r
,
1698 "Failed to determine whether root path '%s' contains an OS tree: %m",
1701 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1702 "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1705 if (!path_is_valid(init
))
1706 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1707 "Path to init binary '%s' is not a valid path.", init
);
1709 if (!path_is_absolute(init
))
1710 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1711 "Path to init binary '%s' not absolute.", init
);
1713 r
= chase_symlinks_and_access(init
, root
, CHASE_PREFIX_ROOT
, X_OK
, NULL
, NULL
);
1715 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1716 "Init binary %s is not executable.", init
);
1718 return sd_bus_error_set_errnof(error
, r
,
1719 "Could not resolve init executable %s: %m", init
);
1726 if (!isempty(init
)) {
1732 free_and_replace(m
->switch_root
, rt
);
1733 free_and_replace(m
->switch_root_init
, ri
);
1735 m
->objective
= MANAGER_SWITCH_ROOT
;
1737 return sd_bus_reply_method_return(message
, NULL
);
1740 static int method_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1741 _cleanup_strv_free_
char **plus
= NULL
;
1742 Manager
*m
= ASSERT_PTR(userdata
);
1747 r
= mac_selinux_access_check(message
, "reload", error
);
1751 r
= sd_bus_message_read_strv(message
, &plus
);
1754 if (!strv_env_is_valid(plus
))
1755 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1757 r
= bus_verify_set_environment_async(m
, message
, error
);
1761 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1763 r
= manager_client_environment_modify(m
, NULL
, plus
);
1767 return sd_bus_reply_method_return(message
, NULL
);
1770 static int method_unset_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1771 _cleanup_strv_free_
char **minus
= NULL
;
1772 Manager
*m
= ASSERT_PTR(userdata
);
1777 r
= mac_selinux_access_check(message
, "reload", error
);
1781 r
= sd_bus_message_read_strv(message
, &minus
);
1785 if (!strv_env_name_or_assignment_is_valid(minus
))
1786 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1787 "Invalid environment variable names or assignments");
1789 r
= bus_verify_set_environment_async(m
, message
, error
);
1793 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1795 r
= manager_client_environment_modify(m
, minus
, NULL
);
1799 return sd_bus_reply_method_return(message
, NULL
);
1802 static int method_unset_and_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1803 _cleanup_strv_free_
char **minus
= NULL
, **plus
= NULL
;
1804 Manager
*m
= ASSERT_PTR(userdata
);
1809 r
= mac_selinux_access_check(message
, "reload", error
);
1813 r
= sd_bus_message_read_strv(message
, &minus
);
1817 r
= sd_bus_message_read_strv(message
, &plus
);
1821 if (!strv_env_name_or_assignment_is_valid(minus
))
1822 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1823 "Invalid environment variable names or assignments");
1824 if (!strv_env_is_valid(plus
))
1825 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1826 "Invalid environment assignments");
1828 r
= bus_verify_set_environment_async(m
, message
, error
);
1832 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1834 r
= manager_client_environment_modify(m
, minus
, plus
);
1838 return sd_bus_reply_method_return(message
, NULL
);
1841 static int method_set_exit_code(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1842 Manager
*m
= ASSERT_PTR(userdata
);
1848 r
= mac_selinux_access_check(message
, "exit", error
);
1852 r
= sd_bus_message_read_basic(message
, 'y', &code
);
1856 if (MANAGER_IS_SYSTEM(m
) && detect_container() <= 0)
1857 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "ExitCode can only be set for user service managers or in containers.");
1859 m
->return_value
= code
;
1861 return sd_bus_reply_method_return(message
, NULL
);
1864 static int method_lookup_dynamic_user_by_name(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1865 Manager
*m
= ASSERT_PTR(userdata
);
1872 r
= sd_bus_message_read_basic(message
, 's', &name
);
1876 if (!MANAGER_IS_SYSTEM(m
))
1877 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1878 "Dynamic users are only supported in the system instance.");
1879 if (!valid_user_group_name(name
, VALID_USER_RELAX
))
1880 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1881 "User name invalid: %s", name
);
1883 r
= dynamic_user_lookup_name(m
, name
, &uid
);
1885 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
,
1886 "Dynamic user %s does not exist.", name
);
1890 return sd_bus_reply_method_return(message
, "u", (uint32_t) uid
);
1893 static int method_lookup_dynamic_user_by_uid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1894 _cleanup_free_
char *name
= NULL
;
1895 Manager
*m
= ASSERT_PTR(userdata
);
1901 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
1902 r
= sd_bus_message_read_basic(message
, 'u', &uid
);
1906 if (!MANAGER_IS_SYSTEM(m
))
1907 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1908 "Dynamic users are only supported in the system instance.");
1909 if (!uid_is_valid(uid
))
1910 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
1911 "User ID invalid: " UID_FMT
, uid
);
1913 r
= dynamic_user_lookup_uid(m
, uid
, &name
);
1915 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
,
1916 "Dynamic user ID " UID_FMT
" does not exist.", uid
);
1920 return sd_bus_reply_method_return(message
, "s", name
);
1923 static int method_get_dynamic_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1924 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1925 Manager
*m
= ASSERT_PTR(userdata
);
1931 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
1933 if (!MANAGER_IS_SYSTEM(m
))
1934 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
1935 "Dynamic users are only supported in the system instance.");
1937 r
= sd_bus_message_new_method_return(message
, &reply
);
1941 r
= sd_bus_message_open_container(reply
, 'a', "(us)");
1945 HASHMAP_FOREACH(d
, m
->dynamic_users
) {
1948 r
= dynamic_user_current(d
, &uid
);
1949 if (r
== -EAGAIN
) /* not realized yet? */
1952 return sd_bus_error_setf(error
, SD_BUS_ERROR_FAILED
,
1953 "Failed to look up a dynamic user.");
1955 r
= sd_bus_message_append(reply
, "(us)", uid
, d
->name
);
1960 r
= sd_bus_message_close_container(reply
);
1964 return sd_bus_send(NULL
, reply
, NULL
);
1967 static int method_enqueue_marked_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1968 Manager
*m
= ASSERT_PTR(userdata
);
1973 r
= mac_selinux_access_check(message
, "start", error
);
1977 r
= bus_verify_manage_units_async(m
, message
, error
);
1981 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1983 log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS
));
1985 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1986 r
= sd_bus_message_new_method_return(message
, &reply
);
1990 r
= sd_bus_message_open_container(reply
, 'a', "o");
1997 HASHMAP_FOREACH_KEY(u
, k
, m
->units
) {
1998 /* ignore aliases */
2002 BusUnitQueueFlags flags
;
2003 if (FLAGS_SET(u
->markers
, 1u << UNIT_MARKER_NEEDS_RESTART
))
2005 else if (FLAGS_SET(u
->markers
, 1u << UNIT_MARKER_NEEDS_RELOAD
))
2006 flags
= BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE
;
2010 r
= mac_selinux_unit_access_check(u
, message
, "start", error
);
2012 r
= bus_unit_queue_job_one(message
, u
,
2013 JOB_TRY_RESTART
, JOB_FAIL
, flags
,
2016 if (ERRNO_IS_RESOURCE(r
))
2020 sd_bus_error_free(error
);
2025 return sd_bus_error_set_errnof(error
, ret
,
2026 "Failed to enqueue some jobs, see logs for details: %m");
2028 r
= sd_bus_message_close_container(reply
);
2032 return sd_bus_send(NULL
, reply
, NULL
);
2035 static int list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
2036 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2037 Manager
*m
= ASSERT_PTR(userdata
);
2044 /* Anyone can call this method */
2046 r
= mac_selinux_access_check(message
, "status", error
);
2050 r
= sd_bus_message_new_method_return(message
, &reply
);
2054 h
= hashmap_new(&string_hash_ops
);
2058 r
= unit_file_get_list(m
->unit_file_scope
, NULL
, h
, states
, patterns
);
2062 r
= sd_bus_message_open_container(reply
, 'a', "(ss)");
2066 HASHMAP_FOREACH(item
, h
) {
2068 r
= sd_bus_message_append(reply
, "(ss)", item
->path
, unit_file_state_to_string(item
->state
));
2073 unit_file_list_free(h
);
2075 r
= sd_bus_message_close_container(reply
);
2079 return sd_bus_send(NULL
, reply
, NULL
);
2082 unit_file_list_free(h
);
2086 static int method_list_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2087 return list_unit_files_by_patterns(message
, userdata
, error
, NULL
, NULL
);
2090 static int method_list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2091 _cleanup_strv_free_
char **states
= NULL
;
2092 _cleanup_strv_free_
char **patterns
= NULL
;
2095 r
= sd_bus_message_read_strv(message
, &states
);
2099 r
= sd_bus_message_read_strv(message
, &patterns
);
2103 return list_unit_files_by_patterns(message
, userdata
, error
, states
, patterns
);
2106 static int method_get_unit_file_state(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2107 Manager
*m
= ASSERT_PTR(userdata
);
2109 UnitFileState state
;
2114 /* Anyone can call this method */
2116 r
= mac_selinux_access_check(message
, "status", error
);
2120 r
= sd_bus_message_read(message
, "s", &name
);
2124 r
= unit_file_get_state(m
->unit_file_scope
, NULL
, name
, &state
);
2128 return sd_bus_reply_method_return(message
, "s", unit_file_state_to_string(state
));
2131 static int method_get_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2132 _cleanup_free_
char *default_target
= NULL
;
2133 Manager
*m
= ASSERT_PTR(userdata
);
2138 /* Anyone can call this method */
2140 r
= mac_selinux_access_check(message
, "status", error
);
2144 r
= unit_file_get_default(m
->unit_file_scope
, NULL
, &default_target
);
2148 return sd_bus_reply_method_return(message
, "s", default_target
);
2151 static int send_unit_files_changed(sd_bus
*bus
, void *userdata
) {
2152 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2157 r
= sd_bus_message_new_signal(bus
, &message
,
2158 "/org/freedesktop/systemd1",
2159 "org.freedesktop.systemd1.Manager",
2160 "UnitFilesChanged");
2164 return sd_bus_send(bus
, message
, NULL
);
2167 /* Create an error reply, using the error information from changes[]
2168 * if possible, and fall back to generating an error from error code c.
2169 * The error message only describes the first error.
2171 static int install_error(
2172 sd_bus_error
*error
,
2174 InstallChange
*changes
,
2179 for (size_t i
= 0; i
< n_changes
; i
++)
2181 /* When making changes here, make sure to also change install_changes_dump() in install.c. */
2183 switch (changes
[i
].type
) {
2184 case 0 ... _INSTALL_CHANGE_TYPE_MAX
: /* not errors */
2188 if (changes
[i
].source
)
2189 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
2190 "File %s already exists and is a symlink to %s.",
2191 changes
[i
].path
, changes
[i
].source
);
2193 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
2194 "File %s already exists.",
2199 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
,
2200 "Unit file %s is masked.", changes
[i
].path
);
2203 case -EADDRNOTAVAIL
:
2204 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_GENERATED
,
2205 "Unit %s is transient or generated.", changes
[i
].path
);
2209 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_BAD_PATH
,
2210 "File %s is under the systemd unit hierarchy already.", changes
[i
].path
);
2214 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2215 "Invalid specifier in %s.", changes
[i
].path
);
2219 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2220 "Destination unit %s is a non-template unit.", changes
[i
].path
);
2224 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2225 "\"%s\" is not a valid unit name.",
2230 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_LINKED
,
2231 "Refusing to operate on alias name or linked unit file: %s",
2236 if (changes
[i
].source
)
2237 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2238 "Cannot alias %s as %s.",
2239 changes
[i
].source
, changes
[i
].path
);
2241 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2242 "Invalid unit reference %s.", changes
[i
].path
);
2246 r
= sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
,
2247 "Unit file %s does not exist.", changes
[i
].path
);
2251 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
2252 "Cannot resolve specifiers in %s.", changes
[i
].path
);
2256 assert(changes
[i
].type
< 0); /* other errors */
2257 r
= sd_bus_error_set_errnof(error
, changes
[i
].type
, "File %s: %m", changes
[i
].path
);
2261 r
= c
< 0 ? c
: -EINVAL
;
2264 install_changes_free(changes
, n_changes
);
2268 static int reply_install_changes_and_free(
2270 sd_bus_message
*message
,
2271 int carries_install_info
,
2272 InstallChange
*changes
,
2274 sd_bus_error
*error
) {
2276 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2277 bool bad
= false, good
= false;
2280 if (install_changes_have_modification(changes
, n_changes
)) {
2281 r
= bus_foreach_bus(m
, NULL
, send_unit_files_changed
, NULL
);
2283 log_debug_errno(r
, "Failed to send UnitFilesChanged signal: %m");
2286 r
= sd_bus_message_new_method_return(message
, &reply
);
2290 if (carries_install_info
>= 0) {
2291 r
= sd_bus_message_append(reply
, "b", carries_install_info
);
2296 r
= sd_bus_message_open_container(reply
, 'a', "(sss)");
2300 for (size_t i
= 0; i
< n_changes
; i
++) {
2302 if (changes
[i
].type
< 0) {
2307 r
= sd_bus_message_append(
2309 install_change_type_to_string(changes
[i
].type
),
2318 /* If there was a failed change, and no successful change, then return the first failure as proper
2319 * method call error. */
2321 return install_error(error
, 0, changes
, n_changes
);
2323 r
= sd_bus_message_close_container(reply
);
2327 install_changes_free(changes
, n_changes
);
2328 return sd_bus_send(NULL
, reply
, NULL
);
2331 install_changes_free(changes
, n_changes
);
2335 static int method_enable_unit_files_generic(
2336 sd_bus_message
*message
,
2338 int (*call
)(LookupScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], InstallChange
**changes
, size_t *n_changes
),
2339 bool carries_install_info
,
2340 sd_bus_error
*error
) {
2342 _cleanup_strv_free_
char **l
= NULL
;
2343 InstallChange
*changes
= NULL
;
2344 size_t n_changes
= 0;
2345 UnitFileFlags flags
;
2351 r
= sd_bus_message_read_strv(message
, &l
);
2355 if (sd_bus_message_is_method_call(message
, NULL
, "EnableUnitFilesWithFlags")) {
2358 r
= sd_bus_message_read(message
, "t", &raw_flags
);
2361 if ((raw_flags
& ~_UNIT_FILE_FLAGS_MASK_PUBLIC
) != 0)
2367 r
= sd_bus_message_read(message
, "bb", &runtime
, &force
);
2370 flags
= unit_file_bools_to_flags(runtime
, force
);
2373 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2377 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2379 r
= call(m
->unit_file_scope
, flags
, NULL
, l
, &changes
, &n_changes
);
2381 return install_error(error
, r
, changes
, n_changes
);
2383 return reply_install_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
, error
);
2386 static int method_enable_unit_files_with_flags(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2387 return method_enable_unit_files_generic(message
, userdata
, unit_file_enable
, /* carries_install_info = */ true, error
);
2390 static int method_enable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2391 return method_enable_unit_files_generic(message
, userdata
, unit_file_enable
, /* carries_install_info = */ true, error
);
2394 static int method_reenable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2395 return method_enable_unit_files_generic(message
, userdata
, unit_file_reenable
, /* carries_install_info = */ true, error
);
2398 static int method_link_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2399 return method_enable_unit_files_generic(message
, userdata
, unit_file_link
, /* carries_install_info = */ false, error
);
2402 static int unit_file_preset_without_mode(LookupScope scope
, UnitFileFlags flags
, const char *root_dir
, char **files
, InstallChange
**changes
, size_t *n_changes
) {
2403 return unit_file_preset(scope
, flags
, root_dir
, files
, UNIT_FILE_PRESET_FULL
, changes
, n_changes
);
2406 static int method_preset_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2407 return method_enable_unit_files_generic(message
, userdata
, unit_file_preset_without_mode
, /* carries_install_info = */ true, error
);
2410 static int method_mask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2411 return method_enable_unit_files_generic(message
, userdata
, unit_file_mask
, /* carries_install_info = */ false, error
);
2414 static int method_preset_unit_files_with_mode(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2416 _cleanup_strv_free_
char **l
= NULL
;
2417 InstallChange
*changes
= NULL
;
2418 size_t n_changes
= 0;
2419 Manager
*m
= ASSERT_PTR(userdata
);
2420 UnitFilePresetMode preset_mode
;
2421 int runtime
, force
, r
;
2422 UnitFileFlags flags
;
2427 r
= sd_bus_message_read_strv(message
, &l
);
2431 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2435 flags
= unit_file_bools_to_flags(runtime
, force
);
2438 preset_mode
= UNIT_FILE_PRESET_FULL
;
2440 preset_mode
= unit_file_preset_mode_from_string(mode
);
2441 if (preset_mode
< 0)
2445 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2449 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2451 r
= unit_file_preset(m
->unit_file_scope
, flags
, NULL
, l
, preset_mode
, &changes
, &n_changes
);
2453 return install_error(error
, r
, changes
, n_changes
);
2455 return reply_install_changes_and_free(m
, message
, r
, changes
, n_changes
, error
);
2458 static int method_disable_unit_files_generic(
2459 sd_bus_message
*message
,
2461 int (*call
)(LookupScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], InstallChange
**changes
, size_t *n_changes
),
2462 bool carries_install_info
,
2463 sd_bus_error
*error
) {
2465 _cleanup_strv_free_
char **l
= NULL
;
2466 InstallChange
*changes
= NULL
;
2467 UnitFileFlags flags
;
2468 size_t n_changes
= 0;
2474 r
= sd_bus_message_read_strv(message
, &l
);
2478 if (sd_bus_message_is_method_call(message
, NULL
, "DisableUnitFilesWithFlags") ||
2479 sd_bus_message_is_method_call(message
, NULL
, "DisableUnitFilesWithFlagsAndInstallInfo")) {
2482 r
= sd_bus_message_read(message
, "t", &raw_flags
);
2485 if ((raw_flags
& ~_UNIT_FILE_FLAGS_MASK_PUBLIC
) != 0 ||
2486 FLAGS_SET(raw_flags
, UNIT_FILE_FORCE
))
2492 r
= sd_bus_message_read(message
, "b", &runtime
);
2495 flags
= unit_file_bools_to_flags(runtime
, false);
2498 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2502 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2504 r
= call(m
->unit_file_scope
, flags
, NULL
, l
, &changes
, &n_changes
);
2506 return install_error(error
, r
, changes
, n_changes
);
2508 return reply_install_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
, error
);
2511 static int method_disable_unit_files_with_flags(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2512 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, /* carries_install_info = */ false, error
);
2515 static int method_disable_unit_files_with_flags_and_install_info(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2516 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, /* carries_install_info = */ true, error
);
2519 static int method_disable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2520 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, /* carries_install_info = */ false, error
);
2523 static int method_unmask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2524 return method_disable_unit_files_generic(message
, userdata
, unit_file_unmask
, /* carries_install_info = */ false, error
);
2527 static int method_revert_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2528 _cleanup_strv_free_
char **l
= NULL
;
2529 InstallChange
*changes
= NULL
;
2530 size_t n_changes
= 0;
2531 Manager
*m
= ASSERT_PTR(userdata
);
2536 r
= sd_bus_message_read_strv(message
, &l
);
2540 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2544 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2546 r
= unit_file_revert(m
->unit_file_scope
, NULL
, l
, &changes
, &n_changes
);
2548 return install_error(error
, r
, changes
, n_changes
);
2550 return reply_install_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2553 static int method_set_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2554 InstallChange
*changes
= NULL
;
2555 size_t n_changes
= 0;
2556 Manager
*m
= ASSERT_PTR(userdata
);
2562 r
= mac_selinux_access_check(message
, "enable", error
);
2566 r
= sd_bus_message_read(message
, "sb", &name
, &force
);
2570 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2574 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2576 r
= unit_file_set_default(m
->unit_file_scope
, force
? UNIT_FILE_FORCE
: 0, NULL
, name
, &changes
, &n_changes
);
2578 return install_error(error
, r
, changes
, n_changes
);
2580 return reply_install_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2583 static int method_preset_all_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2584 InstallChange
*changes
= NULL
;
2585 size_t n_changes
= 0;
2586 Manager
*m
= ASSERT_PTR(userdata
);
2587 UnitFilePresetMode preset_mode
;
2589 UnitFileFlags flags
;
2590 int force
, runtime
, r
;
2594 r
= mac_selinux_access_check(message
, "enable", error
);
2598 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2602 flags
= unit_file_bools_to_flags(runtime
, force
);
2605 preset_mode
= UNIT_FILE_PRESET_FULL
;
2607 preset_mode
= unit_file_preset_mode_from_string(mode
);
2608 if (preset_mode
< 0)
2612 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2616 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2618 r
= unit_file_preset_all(m
->unit_file_scope
, flags
, NULL
, preset_mode
, &changes
, &n_changes
);
2620 return install_error(error
, r
, changes
, n_changes
);
2622 return reply_install_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2625 static int method_add_dependency_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2626 _cleanup_strv_free_
char **l
= NULL
;
2627 Manager
*m
= ASSERT_PTR(userdata
);
2628 InstallChange
*changes
= NULL
;
2629 size_t n_changes
= 0;
2630 int runtime
, force
, r
;
2631 char *target
, *type
;
2633 UnitFileFlags flags
;
2637 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2641 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2643 r
= sd_bus_message_read_strv(message
, &l
);
2647 r
= sd_bus_message_read(message
, "ssbb", &target
, &type
, &runtime
, &force
);
2651 flags
= unit_file_bools_to_flags(runtime
, force
);
2653 dep
= unit_dependency_from_string(type
);
2657 r
= unit_file_add_dependency(m
->unit_file_scope
, flags
, NULL
, l
, target
, dep
, &changes
, &n_changes
);
2659 return install_error(error
, r
, changes
, n_changes
);
2661 return reply_install_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2664 static int method_get_unit_file_links(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2665 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2666 Manager
*m
= ASSERT_PTR(userdata
);
2667 InstallChange
*changes
= NULL
;
2668 size_t n_changes
= 0, i
;
2672 r
= sd_bus_message_read(message
, "sb", &name
, &runtime
);
2676 r
= sd_bus_message_new_method_return(message
, &reply
);
2680 r
= sd_bus_message_open_container(reply
, SD_BUS_TYPE_ARRAY
, "s");
2684 r
= unit_file_disable(m
->unit_file_scope
,
2685 UNIT_FILE_DRY_RUN
| (runtime
? UNIT_FILE_RUNTIME
: 0),
2686 NULL
, STRV_MAKE(name
), &changes
, &n_changes
);
2688 log_error_errno(r
, "Failed to get file links for %s: %m", name
);
2692 for (i
= 0; i
< n_changes
; i
++)
2693 if (changes
[i
].type
== INSTALL_CHANGE_UNLINK
) {
2694 r
= sd_bus_message_append(reply
, "s", changes
[i
].path
);
2699 r
= sd_bus_message_close_container(reply
);
2703 r
= sd_bus_send(NULL
, reply
, NULL
);
2706 install_changes_free(changes
, n_changes
);
2710 static int method_get_job_waiting(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2711 Manager
*m
= ASSERT_PTR(userdata
);
2718 r
= sd_bus_message_read(message
, "u", &id
);
2722 j
= manager_get_job(m
, id
);
2724 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
2726 return bus_job_method_get_waiting_jobs(message
, j
, error
);
2729 static int method_abandon_scope(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2730 Manager
*m
= ASSERT_PTR(userdata
);
2737 r
= sd_bus_message_read(message
, "s", &name
);
2741 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
2745 if (u
->type
!= UNIT_SCOPE
)
2746 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
2747 "Unit '%s' is not a scope unit, refusing.", name
);
2749 return bus_scope_method_abandon(message
, u
, error
);
2752 static int method_set_show_status(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2753 Manager
*m
= ASSERT_PTR(userdata
);
2754 ShowStatus mode
= _SHOW_STATUS_INVALID
;
2760 r
= mac_selinux_access_check(message
, "reload", error
);
2764 r
= bus_verify_set_environment_async(m
, message
, error
);
2768 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2770 r
= sd_bus_message_read(message
, "s", &t
);
2775 mode
= show_status_from_string(t
);
2777 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
2778 "Invalid show status '%s'", t
);
2781 manager_override_show_status(m
, mode
, "bus");
2783 return sd_bus_reply_method_return(message
, NULL
);
2786 const sd_bus_vtable bus_manager_vtable
[] = {
2787 SD_BUS_VTABLE_START(0),
2789 SD_BUS_PROPERTY("Version", "s", property_get_version
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2790 SD_BUS_PROPERTY("Features", "s", property_get_features
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2791 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2792 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2793 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2794 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FIRMWARE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2795 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_LOADER
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2796 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_KERNEL
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2797 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2798 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_USERSPACE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2799 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2800 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2801 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2802 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2803 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2804 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2805 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2806 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2807 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2808 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2809 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2810 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2811 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2812 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2813 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level
, property_set_log_level
, 0, 0),
2814 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target
, property_set_log_target
, 0, 0),
2815 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size
, offsetof(Manager
, units
), 0),
2816 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size
, offsetof(Manager
, failed_units
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2817 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size
, offsetof(Manager
, jobs
), 0),
2818 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_installed_jobs
), 0),
2819 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_failed_jobs
), 0),
2820 SD_BUS_PROPERTY("Progress", "d", property_get_progress
, 0, 0),
2821 SD_BUS_PROPERTY("Environment", "as", property_get_environment
, 0, 0),
2822 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool
, offsetof(Manager
, confirm_spawn
), SD_BUS_VTABLE_PROPERTY_CONST
),
2823 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status
, 0, 0),
2824 SD_BUS_PROPERTY("UnitPath", "as", NULL
, offsetof(Manager
, lookup_paths
.search_path
), SD_BUS_VTABLE_PROPERTY_CONST
),
2825 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2826 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_error
), SD_BUS_VTABLE_PROPERTY_CONST
),
2827 SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2828 SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime
, 0, 0),
2829 SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic
, 0, 0),
2830 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog
, property_set_runtime_watchdog
, 0, 0),
2831 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog
, property_set_pretimeout_watchdog
, 0, 0),
2832 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor
, property_set_pretimeout_watchdog_governor
, 0, 0),
2833 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog
, property_set_reboot_watchdog
, 0, 0),
2834 /* The following item is an obsolete alias */
2835 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog
, property_set_reboot_watchdog
, 0, SD_BUS_VTABLE_HIDDEN
),
2836 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog
, property_set_kexec_watchdog
, 0, 0),
2837 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool
, bus_property_set_bool
, offsetof(Manager
, service_watchdogs
), 0),
2838 SD_BUS_PROPERTY("ControlGroup", "s", NULL
, offsetof(Manager
, cgroup_root
), 0),
2839 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state
, 0, 0),
2840 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned
, offsetof(Manager
, return_value
), 0),
2841 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timer_accuracy_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2842 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_start_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2843 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_stop_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2844 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec
, 0, 0),
2845 SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_device_timeout_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2846 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_restart_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2847 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
),
2848 /* The following two items are obsolete alias */
2849 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2850 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2851 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned
, offsetof(Manager
, default_start_limit_burst
), SD_BUS_VTABLE_PROPERTY_CONST
),
2852 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_cpu_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2853 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_blockio_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2854 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_memory_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2855 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_tasks_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2856 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2857 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2858 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2859 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2860 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2861 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2862 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2863 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2864 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2865 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2866 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2867 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2868 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2869 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2870 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2871 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2872 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2873 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2874 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2875 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2876 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2877 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2878 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2879 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2880 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2881 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2882 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2883 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2884 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2885 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2886 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2887 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2888 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max
, offsetof(Manager
, default_tasks_max
), 0),
2889 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2890 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy
, offsetof(Manager
, default_oom_policy
), SD_BUS_VTABLE_PROPERTY_CONST
),
2891 SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2892 SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action
, offsetof(Manager
, cad_burst_action
), SD_BUS_VTABLE_PROPERTY_CONST
),
2894 SD_BUS_METHOD_WITH_ARGS("GetUnit",
2895 SD_BUS_ARGS("s", name
),
2896 SD_BUS_RESULT("o", unit
),
2898 SD_BUS_VTABLE_UNPRIVILEGED
),
2899 SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
2900 SD_BUS_ARGS("u", pid
),
2901 SD_BUS_RESULT("o", unit
),
2902 method_get_unit_by_pid
,
2903 SD_BUS_VTABLE_UNPRIVILEGED
),
2904 SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
2905 SD_BUS_ARGS("ay", invocation_id
),
2906 SD_BUS_RESULT("o", unit
),
2907 method_get_unit_by_invocation_id
,
2908 SD_BUS_VTABLE_UNPRIVILEGED
),
2909 SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
2910 SD_BUS_ARGS("s", cgroup
),
2911 SD_BUS_RESULT("o", unit
),
2912 method_get_unit_by_control_group
,
2913 SD_BUS_VTABLE_UNPRIVILEGED
),
2914 SD_BUS_METHOD_WITH_ARGS("LoadUnit",
2915 SD_BUS_ARGS("s", name
),
2916 SD_BUS_RESULT("o", unit
),
2918 SD_BUS_VTABLE_UNPRIVILEGED
),
2919 SD_BUS_METHOD_WITH_ARGS("StartUnit",
2920 SD_BUS_ARGS("s", name
, "s", mode
),
2921 SD_BUS_RESULT("o", job
),
2923 SD_BUS_VTABLE_UNPRIVILEGED
),
2924 SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
2925 SD_BUS_ARGS("s", name
, "s", mode
, "t", flags
),
2926 SD_BUS_RESULT("o", job
),
2928 SD_BUS_VTABLE_UNPRIVILEGED
),
2929 SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
2930 SD_BUS_ARGS("s", old_unit
, "s", new_unit
, "s", mode
),
2931 SD_BUS_RESULT("o", job
),
2932 method_start_unit_replace
,
2933 SD_BUS_VTABLE_UNPRIVILEGED
),
2934 SD_BUS_METHOD_WITH_ARGS("StopUnit",
2935 SD_BUS_ARGS("s", name
, "s", mode
),
2936 SD_BUS_RESULT("o", job
),
2938 SD_BUS_VTABLE_UNPRIVILEGED
),
2939 SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
2940 SD_BUS_ARGS("s", name
, "s", mode
),
2941 SD_BUS_RESULT("o", job
),
2943 SD_BUS_VTABLE_UNPRIVILEGED
),
2944 SD_BUS_METHOD_WITH_ARGS("RestartUnit",
2945 SD_BUS_ARGS("s", name
, "s", mode
),
2946 SD_BUS_RESULT("o", job
),
2947 method_restart_unit
,
2948 SD_BUS_VTABLE_UNPRIVILEGED
),
2949 SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
2950 SD_BUS_ARGS("s", name
, "s", mode
),
2951 SD_BUS_RESULT("o", job
),
2952 method_try_restart_unit
,
2953 SD_BUS_VTABLE_UNPRIVILEGED
),
2954 SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
2955 SD_BUS_ARGS("s", name
, "s", mode
),
2956 SD_BUS_RESULT("o", job
),
2957 method_reload_or_restart_unit
,
2958 SD_BUS_VTABLE_UNPRIVILEGED
),
2959 SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
2960 SD_BUS_ARGS("s", name
, "s", mode
),
2961 SD_BUS_RESULT("o", job
),
2962 method_reload_or_try_restart_unit
,
2963 SD_BUS_VTABLE_UNPRIVILEGED
),
2964 SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
2965 SD_BUS_ARGS("s", name
, "s", job_type
, "s", job_mode
),
2966 SD_BUS_RESULT("u", job_id
, "o", job_path
, "s", unit_id
, "o", unit_path
, "s", job_type
, "a(uosos)", affected_jobs
),
2967 method_enqueue_unit_job
,
2968 SD_BUS_VTABLE_UNPRIVILEGED
),
2969 SD_BUS_METHOD_WITH_ARGS("KillUnit",
2970 SD_BUS_ARGS("s", name
, "s", whom
, "i", signal
),
2973 SD_BUS_VTABLE_UNPRIVILEGED
),
2974 SD_BUS_METHOD_WITH_ARGS("CleanUnit",
2975 SD_BUS_ARGS("s", name
, "as", mask
),
2978 SD_BUS_VTABLE_UNPRIVILEGED
),
2979 SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
2980 SD_BUS_ARGS("s", name
),
2983 SD_BUS_VTABLE_UNPRIVILEGED
),
2984 SD_BUS_METHOD_WITH_ARGS("ThawUnit",
2985 SD_BUS_ARGS("s", name
),
2988 SD_BUS_VTABLE_UNPRIVILEGED
),
2989 SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
2990 SD_BUS_ARGS("s", name
),
2992 method_reset_failed_unit
,
2993 SD_BUS_VTABLE_UNPRIVILEGED
),
2994 SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
2995 SD_BUS_ARGS("s", name
, "b", runtime
, "a(sv)", properties
),
2997 method_set_unit_properties
,
2998 SD_BUS_VTABLE_UNPRIVILEGED
),
2999 SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
3000 SD_BUS_ARGS("s", name
, "s", source
, "s", destination
, "b", read_only
, "b", mkdir
),
3002 method_bind_mount_unit
,
3003 SD_BUS_VTABLE_UNPRIVILEGED
),
3004 SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
3005 SD_BUS_ARGS("s", name
, "s", source
, "s", destination
, "b", read_only
, "b", mkdir
, "a(ss)", options
),
3007 method_mount_image_unit
,
3008 SD_BUS_VTABLE_UNPRIVILEGED
),
3009 SD_BUS_METHOD_WITH_ARGS("RefUnit",
3010 SD_BUS_ARGS("s", name
),
3013 SD_BUS_VTABLE_UNPRIVILEGED
),
3014 SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
3015 SD_BUS_ARGS("s", name
),
3018 SD_BUS_VTABLE_UNPRIVILEGED
),
3019 SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
3020 SD_BUS_ARGS("s", name
, "s", mode
, "a(sv)", properties
, "a(sa(sv))", aux
),
3021 SD_BUS_RESULT("o", job
),
3022 method_start_transient_unit
,
3023 SD_BUS_VTABLE_UNPRIVILEGED
),
3024 SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
3025 SD_BUS_ARGS("s", name
),
3026 SD_BUS_RESULT("a(sus)", processes
),
3027 method_get_unit_processes
,
3028 SD_BUS_VTABLE_UNPRIVILEGED
),
3029 SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
3030 SD_BUS_ARGS("s", unit_name
, "s", subcgroup
, "au", pids
),
3032 method_attach_processes_to_unit
,
3033 SD_BUS_VTABLE_UNPRIVILEGED
),
3034 SD_BUS_METHOD_WITH_ARGS("AbandonScope",
3035 SD_BUS_ARGS("s", name
),
3037 method_abandon_scope
,
3038 SD_BUS_VTABLE_UNPRIVILEGED
),
3039 SD_BUS_METHOD_WITH_ARGS("GetJob",
3040 SD_BUS_ARGS("u", id
),
3041 SD_BUS_RESULT("o", job
),
3043 SD_BUS_VTABLE_UNPRIVILEGED
),
3044 SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
3045 SD_BUS_ARGS("u", id
),
3046 SD_BUS_RESULT("a(usssoo)", jobs
),
3047 method_get_job_waiting
,
3048 SD_BUS_VTABLE_UNPRIVILEGED
),
3049 SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
3050 SD_BUS_ARGS("u", id
),
3051 SD_BUS_RESULT("a(usssoo)", jobs
),
3052 method_get_job_waiting
,
3053 SD_BUS_VTABLE_UNPRIVILEGED
),
3054 SD_BUS_METHOD_WITH_ARGS("CancelJob",
3055 SD_BUS_ARGS("u", id
),
3058 SD_BUS_VTABLE_UNPRIVILEGED
),
3059 SD_BUS_METHOD("ClearJobs",
3063 SD_BUS_VTABLE_UNPRIVILEGED
),
3064 SD_BUS_METHOD("ResetFailed",
3067 method_reset_failed
,
3068 SD_BUS_VTABLE_UNPRIVILEGED
),
3069 SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
3070 SD_BUS_ARGS("s", mode
),
3072 method_set_show_status
,
3073 SD_BUS_VTABLE_UNPRIVILEGED
),
3074 SD_BUS_METHOD_WITH_ARGS("ListUnits",
3076 SD_BUS_RESULT("a(ssssssouso)", units
),
3078 SD_BUS_VTABLE_UNPRIVILEGED
),
3079 SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
3080 SD_BUS_ARGS("as", states
),
3081 SD_BUS_RESULT("a(ssssssouso)", units
),
3082 method_list_units_filtered
,
3083 SD_BUS_VTABLE_UNPRIVILEGED
),
3084 SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3085 SD_BUS_ARGS("as", states
, "as", patterns
),
3086 SD_BUS_RESULT("a(ssssssouso)", units
),
3087 method_list_units_by_patterns
,
3088 SD_BUS_VTABLE_UNPRIVILEGED
),
3089 SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3090 SD_BUS_ARGS("as", names
),
3091 SD_BUS_RESULT("a(ssssssouso)", units
),
3092 method_list_units_by_names
,
3093 SD_BUS_VTABLE_UNPRIVILEGED
),
3094 SD_BUS_METHOD_WITH_ARGS("ListJobs",
3096 SD_BUS_RESULT("a(usssoo)", jobs
),
3098 SD_BUS_VTABLE_UNPRIVILEGED
),
3099 SD_BUS_METHOD("Subscribe",
3103 SD_BUS_VTABLE_UNPRIVILEGED
),
3104 SD_BUS_METHOD("Unsubscribe",
3108 SD_BUS_VTABLE_UNPRIVILEGED
),
3109 SD_BUS_METHOD_WITH_ARGS("Dump",
3111 SD_BUS_RESULT("s", output
),
3113 SD_BUS_VTABLE_UNPRIVILEGED
),
3114 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatterns",
3115 SD_BUS_ARGS("as", patterns
),
3116 SD_BUS_RESULT("s", output
),
3117 method_dump_units_matching_patterns
,
3118 SD_BUS_VTABLE_UNPRIVILEGED
),
3119 SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3121 SD_BUS_RESULT("h", fd
),
3123 SD_BUS_VTABLE_UNPRIVILEGED
),
3124 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatternsByFileDescriptor",
3125 SD_BUS_ARGS("as", patterns
),
3126 SD_BUS_RESULT("h", fd
),
3127 method_dump_units_matching_patterns_by_fd
,
3128 SD_BUS_VTABLE_UNPRIVILEGED
),
3129 SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3130 SD_BUS_ARGS("s", name
, "b", cleanup
),
3131 SD_BUS_RESULT("o", unit
),
3132 method_refuse_snapshot
,
3133 SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
3134 SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3135 SD_BUS_ARGS("s", name
),
3137 method_refuse_snapshot
,
3138 SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
3139 SD_BUS_METHOD("Reload",
3143 SD_BUS_VTABLE_UNPRIVILEGED
),
3144 SD_BUS_METHOD("Reexecute",
3148 SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_METHOD_NO_REPLY
),
3149 SD_BUS_METHOD("Exit",
3154 SD_BUS_METHOD("Reboot",
3158 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
3159 SD_BUS_METHOD("PowerOff",
3163 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
3164 SD_BUS_METHOD("Halt",
3168 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
3169 SD_BUS_METHOD("KExec",
3173 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
3174 SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3175 SD_BUS_ARGS("s", new_root
, "s", init
),
3178 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
3179 SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3180 SD_BUS_ARGS("as", assignments
),
3182 method_set_environment
,
3183 SD_BUS_VTABLE_UNPRIVILEGED
),
3184 SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3185 SD_BUS_ARGS("as", names
),
3187 method_unset_environment
,
3188 SD_BUS_VTABLE_UNPRIVILEGED
),
3189 SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3190 SD_BUS_ARGS("as", names
, "as", assignments
),
3192 method_unset_and_set_environment
,
3193 SD_BUS_VTABLE_UNPRIVILEGED
),
3194 SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3196 SD_BUS_RESULT("ao", jobs
),
3197 method_enqueue_marked_jobs
,
3198 SD_BUS_VTABLE_UNPRIVILEGED
),
3199 SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3201 SD_BUS_RESULT("a(ss)", unit_files
),
3202 method_list_unit_files
,
3203 SD_BUS_VTABLE_UNPRIVILEGED
),
3204 SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3205 SD_BUS_ARGS("as", states
, "as", patterns
),
3206 SD_BUS_RESULT("a(ss)", unit_files
),
3207 method_list_unit_files_by_patterns
,
3208 SD_BUS_VTABLE_UNPRIVILEGED
),
3209 SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3210 SD_BUS_ARGS("s", file
),
3211 SD_BUS_RESULT("s", state
),
3212 method_get_unit_file_state
,
3213 SD_BUS_VTABLE_UNPRIVILEGED
),
3214 SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3215 SD_BUS_ARGS("as", files
, "b", runtime
, "b", force
),
3216 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3217 method_enable_unit_files
,
3218 SD_BUS_VTABLE_UNPRIVILEGED
),
3219 SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3220 SD_BUS_ARGS("as", files
, "b", runtime
),
3221 SD_BUS_RESULT("a(sss)", changes
),
3222 method_disable_unit_files
,
3223 SD_BUS_VTABLE_UNPRIVILEGED
),
3224 SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3225 SD_BUS_ARGS("as", files
, "t", flags
),
3226 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3227 method_enable_unit_files_with_flags
,
3228 SD_BUS_VTABLE_UNPRIVILEGED
),
3229 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3230 SD_BUS_ARGS("as", files
, "t", flags
),
3231 SD_BUS_RESULT("a(sss)", changes
),
3232 method_disable_unit_files_with_flags
,
3233 SD_BUS_VTABLE_UNPRIVILEGED
),
3234 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlagsAndInstallInfo",
3235 SD_BUS_ARGS("as", files
, "t", flags
),
3236 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3237 method_disable_unit_files_with_flags_and_install_info
,
3238 SD_BUS_VTABLE_UNPRIVILEGED
),
3239 SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3240 SD_BUS_ARGS("as", files
, "b", runtime
, "b", force
),
3241 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3242 method_reenable_unit_files
,
3243 SD_BUS_VTABLE_UNPRIVILEGED
),
3244 SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3245 SD_BUS_ARGS("as", files
, "b", runtime
, "b", force
),
3246 SD_BUS_RESULT("a(sss)", changes
),
3247 method_link_unit_files
,
3248 SD_BUS_VTABLE_UNPRIVILEGED
),
3249 SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3250 SD_BUS_ARGS("as", files
, "b", runtime
, "b", force
),
3251 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3252 method_preset_unit_files
,
3253 SD_BUS_VTABLE_UNPRIVILEGED
),
3254 SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3255 SD_BUS_ARGS("as", files
, "s", mode
, "b", runtime
, "b", force
),
3256 SD_BUS_RESULT("b", carries_install_info
, "a(sss)", changes
),
3257 method_preset_unit_files_with_mode
,
3258 SD_BUS_VTABLE_UNPRIVILEGED
),
3259 SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3260 SD_BUS_ARGS("as", files
, "b", runtime
, "b", force
),
3261 SD_BUS_RESULT("a(sss)", changes
),
3262 method_mask_unit_files
,
3263 SD_BUS_VTABLE_UNPRIVILEGED
),
3264 SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3265 SD_BUS_ARGS("as", files
, "b", runtime
),
3266 SD_BUS_RESULT("a(sss)", changes
),
3267 method_unmask_unit_files
,
3268 SD_BUS_VTABLE_UNPRIVILEGED
),
3269 SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3270 SD_BUS_ARGS("as", files
),
3271 SD_BUS_RESULT("a(sss)", changes
),
3272 method_revert_unit_files
,
3273 SD_BUS_VTABLE_UNPRIVILEGED
),
3274 SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3275 SD_BUS_ARGS("s", name
, "b", force
),
3276 SD_BUS_RESULT("a(sss)", changes
),
3277 method_set_default_target
,
3278 SD_BUS_VTABLE_UNPRIVILEGED
),
3279 SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3281 SD_BUS_RESULT("s", name
),
3282 method_get_default_target
,
3283 SD_BUS_VTABLE_UNPRIVILEGED
),
3284 SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3285 SD_BUS_ARGS("s", mode
, "b", runtime
, "b", force
),
3286 SD_BUS_RESULT("a(sss)", changes
),
3287 method_preset_all_unit_files
,
3288 SD_BUS_VTABLE_UNPRIVILEGED
),
3289 SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3290 SD_BUS_ARGS("as", files
, "s", target
, "s", type
, "b", runtime
, "b", force
),
3291 SD_BUS_RESULT("a(sss)", changes
),
3292 method_add_dependency_unit_files
,
3293 SD_BUS_VTABLE_UNPRIVILEGED
),
3294 SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3295 SD_BUS_ARGS("s", name
, "b", runtime
),
3296 SD_BUS_RESULT("as", links
),
3297 method_get_unit_file_links
,
3298 SD_BUS_VTABLE_UNPRIVILEGED
),
3299 SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3300 SD_BUS_ARGS("y", number
),
3302 method_set_exit_code
,
3303 SD_BUS_VTABLE_UNPRIVILEGED
),
3304 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3305 SD_BUS_ARGS("s", name
),
3306 SD_BUS_RESULT("u", uid
),
3307 method_lookup_dynamic_user_by_name
,
3308 SD_BUS_VTABLE_UNPRIVILEGED
),
3309 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3310 SD_BUS_ARGS("u", uid
),
3311 SD_BUS_RESULT("s", name
),
3312 method_lookup_dynamic_user_by_uid
,
3313 SD_BUS_VTABLE_UNPRIVILEGED
),
3314 SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3316 SD_BUS_RESULT("a(us)", users
),
3317 method_get_dynamic_users
,
3318 SD_BUS_VTABLE_UNPRIVILEGED
),
3320 SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3321 SD_BUS_ARGS("s", id
, "o", unit
),
3323 SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3324 SD_BUS_ARGS("s", id
, "o", unit
),
3326 SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3327 SD_BUS_ARGS("u", id
, "o", job
, "s", unit
),
3329 SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3330 SD_BUS_ARGS("u", id
, "o", job
, "s", unit
, "s", result
),
3332 SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3333 SD_BUS_ARGS("t", firmware
, "t", loader
, "t", kernel
, "t", initrd
, "t", userspace
, "t", total
),
3335 SD_BUS_SIGNAL("UnitFilesChanged", NULL
, 0),
3336 SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3337 SD_BUS_ARGS("b", active
),
3343 const sd_bus_vtable bus_manager_log_control_vtable
[] = {
3344 SD_BUS_VTABLE_START(0),
3346 /* We define a private version of this interface here, since we want slightly different
3347 * implementations for the setters. We'll still use the generic getters however, and we share the
3348 * setters with the implementations for the Manager interface above (which pre-dates the generic
3349 * service API interface). */
3351 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level
, property_set_log_level
, 0, 0),
3352 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target
, property_set_log_target
, 0, 0),
3353 SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier
, 0, 0),
3358 static int send_finished(sd_bus
*bus
, void *userdata
) {
3359 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
3360 usec_t
*times
= ASSERT_PTR(userdata
);
3365 r
= sd_bus_message_new_signal(bus
,
3367 "/org/freedesktop/systemd1",
3368 "org.freedesktop.systemd1.Manager",
3373 r
= sd_bus_message_append(message
, "tttttt", times
[0], times
[1], times
[2], times
[3], times
[4], times
[5]);
3377 return sd_bus_send(bus
, message
, NULL
);
3380 void bus_manager_send_finished(
3382 usec_t firmware_usec
,
3386 usec_t userspace_usec
,
3387 usec_t total_usec
) {
3393 r
= bus_foreach_bus(
3406 log_debug_errno(r
, "Failed to send finished signal: %m");
3409 static int send_reloading(sd_bus
*bus
, void *userdata
) {
3410 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
3415 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
3419 r
= sd_bus_message_append(message
, "b", PTR_TO_INT(userdata
));
3423 return sd_bus_send(bus
, message
, NULL
);
3426 void bus_manager_send_reloading(Manager
*m
, bool active
) {
3431 r
= bus_foreach_bus(m
, NULL
, send_reloading
, INT_TO_PTR(active
));
3433 log_debug_errno(r
, "Failed to send reloading signal: %m");
3436 static int send_changed_signal(sd_bus
*bus
, void *userdata
) {
3439 return sd_bus_emit_properties_changed_strv(bus
,
3440 "/org/freedesktop/systemd1",
3441 "org.freedesktop.systemd1.Manager",
3445 void bus_manager_send_change_signal(Manager
*m
) {
3450 r
= bus_foreach_bus(m
, NULL
, send_changed_signal
, NULL
);
3452 log_debug_errno(r
, "Failed to send manager change signal: %m");