1 /* SPDX-License-Identifier: LGPL-2.1+ */
5 #include <sys/statvfs.h>
8 #include "alloc-util.h"
9 #include "architecture.h"
11 #include "bus-common-errors.h"
13 #include "dbus-cgroup.h"
14 #include "dbus-execute.h"
16 #include "dbus-manager.h"
17 #include "dbus-scope.h"
18 #include "dbus-unit.h"
23 #include "format-util.h"
28 #include "parse-util.h"
29 #include "path-util.h"
30 #include "selinux-access.h"
31 #include "stat-util.h"
32 #include "string-util.h"
34 #include "syslog-util.h"
35 #include "user-util.h"
39 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state there, and if
40 * we can't we'll fail badly. */
41 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
43 static UnitFileFlags
unit_file_bools_to_flags(bool runtime
, bool force
) {
44 return (runtime
? UNIT_FILE_RUNTIME
: 0) |
45 (force
? UNIT_FILE_FORCE
: 0);
48 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_oom_policy
, oom_policy
, OOMPolicy
);
50 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version
, "s", GIT_VERSION
);
51 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features
, "s", SYSTEMD_FEATURES
);
52 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture
, "s", architecture_to_string(uname_architecture()));
53 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_log_target
, "s", log_target_to_string(log_get_target()));
54 static BUS_DEFINE_PROPERTY_GET2(property_get_system_state
, "s", Manager
, manager_state
, manager_state_to_string
);
55 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec
, "t", (uint64_t) prctl(PR_GET_TIMERSLACK
));
56 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size
, "u", Hashmap
*, hashmap_size
);
57 static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size
, "u", Set
*, set_size
);
58 static BUS_DEFINE_PROPERTY_GET(property_get_default_timeout_abort_usec
, "t", Manager
, manager_default_timeout_abort_usec
);
60 static int property_get_virtualization(
63 const char *interface
,
65 sd_bus_message
*reply
,
67 sd_bus_error
*error
) {
74 v
= detect_virtualization();
76 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
78 * https://github.com/systemd/systemd/issues/1423
81 return sd_bus_message_append(
83 v
== VIRTUALIZATION_NONE
? NULL
: virtualization_to_string(v
));
86 static int property_get_tainted(
89 const char *interface
,
91 sd_bus_message
*reply
,
93 sd_bus_error
*error
) {
95 _cleanup_free_
char *s
= NULL
;
96 Manager
*m
= userdata
;
102 s
= manager_taint_string(m
);
106 return sd_bus_message_append(reply
, "s", s
);
109 static int property_set_log_target(
112 const char *interface
,
113 const char *property
,
114 sd_bus_message
*value
,
116 sd_bus_error
*error
) {
118 Manager
*m
= userdata
;
125 r
= sd_bus_message_read(value
, "s", &t
);
130 manager_restore_original_log_target(m
);
134 target
= log_target_from_string(t
);
136 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid log target '%s'", t
);
138 manager_override_log_target(m
, target
);
144 static int property_get_log_level(
147 const char *interface
,
148 const char *property
,
149 sd_bus_message
*reply
,
151 sd_bus_error
*error
) {
153 _cleanup_free_
char *t
= NULL
;
159 r
= log_level_to_string_alloc(log_get_max_level(), &t
);
163 return sd_bus_message_append(reply
, "s", t
);
166 static int property_set_log_level(
169 const char *interface
,
170 const char *property
,
171 sd_bus_message
*value
,
173 sd_bus_error
*error
) {
175 Manager
*m
= userdata
;
182 r
= sd_bus_message_read(value
, "s", &t
);
187 manager_restore_original_log_level(m
);
191 level
= log_level_from_string(t
);
193 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid log level '%s'", t
);
195 manager_override_log_level(m
, level
);
201 static int property_get_progress(
204 const char *interface
,
205 const char *property
,
206 sd_bus_message
*reply
,
208 sd_bus_error
*error
) {
210 Manager
*m
= userdata
;
217 if (MANAGER_IS_FINISHED(m
))
220 d
= 1.0 - ((double) hashmap_size(m
->jobs
) / (double) m
->n_installed_jobs
);
222 return sd_bus_message_append(reply
, "d", d
);
225 static int property_get_environment(
228 const char *interface
,
229 const char *property
,
230 sd_bus_message
*reply
,
232 sd_bus_error
*error
) {
234 _cleanup_strv_free_
char **l
= NULL
;
235 Manager
*m
= userdata
;
242 r
= manager_get_effective_environment(m
, &l
);
246 return sd_bus_message_append_strv(reply
, l
);
249 static int property_get_show_status(
252 const char *interface
,
253 const char *property
,
254 sd_bus_message
*reply
,
256 sd_bus_error
*error
) {
258 Manager
*m
= userdata
;
265 b
= IN_SET(m
->show_status
, SHOW_STATUS_TEMPORARY
, SHOW_STATUS_YES
);
266 return sd_bus_message_append_basic(reply
, 'b', &b
);
269 static int property_set_runtime_watchdog(
272 const char *interface
,
273 const char *property
,
274 sd_bus_message
*value
,
276 sd_bus_error
*error
) {
278 usec_t
*t
= userdata
;
284 assert_cc(sizeof(usec_t
) == sizeof(uint64_t));
286 r
= sd_bus_message_read(value
, "t", t
);
290 return watchdog_set_timeout(t
);
293 static int bus_get_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
301 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up its sleeve:
302 * if the name is specified empty we use the client's unit. */
305 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
308 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
312 r
= sd_bus_creds_get_pid(creds
, &pid
);
316 u
= manager_get_unit_by_pid(m
, pid
);
318 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
320 u
= manager_get_unit(m
, name
);
322 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
329 static int bus_load_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
334 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
337 return bus_get_unit_by_name(m
, message
, name
, ret_unit
, error
);
339 return manager_load_unit(m
, name
, NULL
, error
, ret_unit
);
342 static int reply_unit_path(Unit
*u
, sd_bus_message
*message
, sd_bus_error
*error
) {
343 _cleanup_free_
char *path
= NULL
;
349 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
353 path
= unit_dbus_path(u
);
357 return sd_bus_reply_method_return(message
, "o", path
);
360 static int method_get_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
361 Manager
*m
= userdata
;
369 /* Anyone can call this method */
371 r
= sd_bus_message_read(message
, "s", &name
);
375 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
379 return reply_unit_path(u
, message
, error
);
382 static int method_get_unit_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
383 Manager
*m
= userdata
;
391 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
393 /* Anyone can call this method */
395 r
= sd_bus_message_read(message
, "u", &pid
);
399 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid PID " PID_FMT
, pid
);
402 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
404 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
408 r
= sd_bus_creds_get_pid(creds
, &pid
);
413 u
= manager_get_unit_by_pid(m
, pid
);
415 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_PID
, "PID "PID_FMT
" does not belong to any loaded unit.", pid
);
417 return reply_unit_path(u
, message
, error
);
420 static int method_get_unit_by_invocation_id(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
421 _cleanup_free_
char *path
= NULL
;
422 Manager
*m
= userdata
;
432 /* Anyone can call this method */
434 r
= sd_bus_message_read_array(message
, 'y', &a
, &sz
);
442 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid invocation ID");
444 if (sd_id128_is_null(id
)) {
445 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
448 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
452 r
= sd_bus_creds_get_pid(creds
, &pid
);
456 u
= manager_get_unit_by_pid(m
, pid
);
458 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client " PID_FMT
" not member of any unit.", pid
);
460 u
= hashmap_get(m
->units_by_invocation_id
, &id
);
462 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
));
465 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
469 /* So here's a special trick: the bus path we return actually references the unit by its invocation ID instead
470 * of the unit name. This means it stays valid only as long as the invocation ID stays the same. */
471 path
= unit_dbus_path_invocation_id(u
);
475 return sd_bus_reply_method_return(message
, "o", path
);
478 static int method_get_unit_by_control_group(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
479 Manager
*m
= userdata
;
484 r
= sd_bus_message_read(message
, "s", &cgroup
);
488 u
= manager_get_unit_by_cgroup(m
, cgroup
);
490 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Control group '%s' is not valid or not managed by this instance", cgroup
);
492 return reply_unit_path(u
, message
, error
);
495 static int method_load_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
496 Manager
*m
= userdata
;
504 /* Anyone can call this method */
506 r
= sd_bus_message_read(message
, "s", &name
);
510 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
514 return reply_unit_path(u
, message
, error
);
517 static int method_start_unit_generic(sd_bus_message
*message
, Manager
*m
, JobType job_type
, bool reload_if_possible
, sd_bus_error
*error
) {
525 r
= sd_bus_message_read(message
, "s", &name
);
529 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
533 return bus_unit_method_start_generic(message
, u
, job_type
, reload_if_possible
, error
);
536 static int method_start_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
537 return method_start_unit_generic(message
, userdata
, JOB_START
, false, error
);
540 static int method_stop_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
541 return method_start_unit_generic(message
, userdata
, JOB_STOP
, false, error
);
544 static int method_reload_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
545 return method_start_unit_generic(message
, userdata
, JOB_RELOAD
, false, error
);
548 static int method_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
549 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, false, error
);
552 static int method_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
553 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, false, error
);
556 static int method_reload_or_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
557 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, true, error
);
560 static int method_reload_or_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
561 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, true, error
);
564 typedef enum GenericUnitOperationFlags
{
565 GENERIC_UNIT_LOAD
= 1 << 0, /* Load if the unit is not loaded yet */
566 GENERIC_UNIT_VALIDATE_LOADED
= 1 << 1, /* Verify unit is properly loaded before forwarding call */
567 } GenericUnitOperationFlags
;
569 static int method_generic_unit_operation(
570 sd_bus_message
*message
,
573 sd_bus_message_handler_t handler
,
574 GenericUnitOperationFlags flags
) {
583 /* Read the first argument from the command and pass the operation to the specified per-unit
586 r
= sd_bus_message_read(message
, "s", &name
);
590 if (!isempty(name
) && FLAGS_SET(flags
, GENERIC_UNIT_LOAD
))
591 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
593 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
597 if (FLAGS_SET(flags
, GENERIC_UNIT_VALIDATE_LOADED
)) {
598 r
= bus_unit_validate_load_state(u
, error
);
603 return handler(message
, u
, error
);
606 static int method_enqueue_unit_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
607 /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
608 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_enqueue_job
, GENERIC_UNIT_LOAD
);
611 static int method_start_unit_replace(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
612 Manager
*m
= userdata
;
613 const char *old_name
;
620 r
= sd_bus_message_read(message
, "s", &old_name
);
624 r
= bus_get_unit_by_name(m
, message
, old_name
, &u
, error
);
627 if (!u
->job
|| u
->job
->type
!= JOB_START
)
628 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "No job queued for unit %s", old_name
);
630 return method_start_unit_generic(message
, m
, JOB_START
, false, error
);
633 static int method_kill_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
634 /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
635 * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
636 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_kill
, 0);
639 static int method_clean_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
640 /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
642 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_clean
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
645 static int method_reset_failed_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
646 /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
647 * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
648 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_reset_failed
, 0);
651 static int method_set_unit_properties(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
652 /* Only change properties on fully loaded units, and load them in order to set properties */
653 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_set_properties
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
656 static int method_ref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
657 /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
658 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_ref
, GENERIC_UNIT_LOAD
|GENERIC_UNIT_VALIDATE_LOADED
);
661 static int method_unref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
662 /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
663 * loaded unit there's no need to load the unit for unreffing it. */
664 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_unref
, 0);
667 static int reply_unit_info(sd_bus_message
*reply
, Unit
*u
) {
668 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
671 following
= unit_following(u
);
673 unit_path
= unit_dbus_path(u
);
678 job_path
= job_dbus_path(u
->job
);
683 return sd_bus_message_append(
684 reply
, "(ssssssouso)",
687 unit_load_state_to_string(u
->load_state
),
688 unit_active_state_to_string(unit_active_state(u
)),
689 unit_sub_state_to_string(u
),
690 following
? following
->id
: "",
692 u
->job
? u
->job
->id
: 0,
693 u
->job
? job_type_to_string(u
->job
->type
) : "",
694 empty_to_root(job_path
));
697 static int method_list_units_by_names(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
698 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
699 Manager
*m
= userdata
;
702 _cleanup_strv_free_
char **units
= NULL
;
707 r
= sd_bus_message_read_strv(message
, &units
);
711 r
= sd_bus_message_new_method_return(message
, &reply
);
715 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
719 STRV_FOREACH(unit
, units
) {
722 if (!unit_name_is_valid(*unit
, UNIT_NAME_ANY
))
725 r
= bus_load_unit_by_name(m
, message
, *unit
, &u
, error
);
729 r
= reply_unit_info(reply
, u
);
734 r
= sd_bus_message_close_container(reply
);
738 return sd_bus_send(NULL
, reply
, NULL
);
741 static int method_get_unit_processes(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
742 /* Don't load a unit (since it won't have any processes if it's not loaded), but don't insist on the
743 * unit being loaded (because even improperly loaded units might still have processes around */
744 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_get_processes
, 0);
747 static int method_attach_processes_to_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
748 /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
749 * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
750 * processes to stopped units anyway. */
751 return method_generic_unit_operation(message
, userdata
, error
, bus_unit_method_attach_processes
, GENERIC_UNIT_VALIDATE_LOADED
);
754 static int transient_unit_from_message(
756 sd_bus_message
*message
,
759 sd_bus_error
*error
) {
769 t
= unit_name_to_type(name
);
771 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid unit name or type.");
773 if (!unit_vtable
[t
]->can_transient
)
774 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unit type %s does not support transient units.", unit_type_to_string(t
));
776 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
780 if (!unit_is_pristine(u
))
781 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
, "Unit %s already exists.", name
);
783 /* OK, the unit failed to load and is unreferenced, now let's
784 * fill in the transient data instead */
785 r
= unit_make_transient(u
);
789 /* Set our properties */
790 r
= bus_unit_set_properties(u
, message
, UNIT_RUNTIME
, false, error
);
794 /* If the client asked for it, automatically add a reference to this unit. */
795 if (u
->bus_track_add
) {
796 r
= bus_unit_track_add_sender(u
, message
);
798 return log_error_errno(r
, "Failed to watch sender: %m");
801 /* Now load the missing bits of the unit we just created */
802 unit_add_to_load_queue(u
);
803 manager_dispatch_load_queue(m
);
810 static int transient_aux_units_from_message(
812 sd_bus_message
*message
,
813 sd_bus_error
*error
) {
820 r
= sd_bus_message_enter_container(message
, 'a', "(sa(sv))");
824 while ((r
= sd_bus_message_enter_container(message
, 'r', "sa(sv)")) > 0) {
825 const char *name
= NULL
;
828 r
= sd_bus_message_read(message
, "s", &name
);
832 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
836 r
= sd_bus_message_exit_container(message
);
843 r
= sd_bus_message_exit_container(message
);
850 static int method_start_transient_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
851 const char *name
, *smode
;
852 Manager
*m
= userdata
;
860 r
= mac_selinux_access_check(message
, "start", error
);
864 r
= sd_bus_message_read(message
, "ss", &name
, &smode
);
868 mode
= job_mode_from_string(smode
);
870 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Job mode %s is invalid.", smode
);
872 r
= bus_verify_manage_units_async(m
, message
, error
);
876 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
878 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
882 r
= transient_aux_units_from_message(m
, message
, error
);
886 /* Finally, start it */
887 return bus_unit_queue_job(message
, u
, JOB_START
, mode
, 0, error
);
890 static int method_get_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
891 _cleanup_free_
char *path
= NULL
;
892 Manager
*m
= userdata
;
900 /* Anyone can call this method */
902 r
= sd_bus_message_read(message
, "u", &id
);
906 j
= manager_get_job(m
, id
);
908 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
910 r
= mac_selinux_unit_access_check(j
->unit
, message
, "status", error
);
914 path
= job_dbus_path(j
);
918 return sd_bus_reply_method_return(message
, "o", path
);
921 static int method_cancel_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
922 Manager
*m
= userdata
;
930 r
= sd_bus_message_read(message
, "u", &id
);
934 j
= manager_get_job(m
, id
);
936 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
938 return bus_job_method_cancel(message
, j
, error
);
941 static int method_clear_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
942 Manager
*m
= userdata
;
948 r
= mac_selinux_access_check(message
, "reload", error
);
952 r
= bus_verify_manage_units_async(m
, message
, error
);
956 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
958 manager_clear_jobs(m
);
960 return sd_bus_reply_method_return(message
, NULL
);
963 static int method_reset_failed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
964 Manager
*m
= userdata
;
970 r
= mac_selinux_access_check(message
, "reload", error
);
974 r
= bus_verify_manage_units_async(m
, message
, error
);
978 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
980 manager_reset_failed(m
);
982 return sd_bus_reply_method_return(message
, NULL
);
985 static int list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
986 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
987 Manager
*m
= userdata
;
996 /* Anyone can call this method */
998 r
= mac_selinux_access_check(message
, "status", error
);
1002 r
= sd_bus_message_new_method_return(message
, &reply
);
1006 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
1010 HASHMAP_FOREACH_KEY(u
, k
, m
->units
, i
) {
1014 if (!strv_isempty(states
) &&
1015 !strv_contains(states
, unit_load_state_to_string(u
->load_state
)) &&
1016 !strv_contains(states
, unit_active_state_to_string(unit_active_state(u
))) &&
1017 !strv_contains(states
, unit_sub_state_to_string(u
)))
1020 if (!strv_isempty(patterns
) &&
1021 !strv_fnmatch_or_empty(patterns
, u
->id
, FNM_NOESCAPE
))
1024 r
= reply_unit_info(reply
, u
);
1029 r
= sd_bus_message_close_container(reply
);
1033 return sd_bus_send(NULL
, reply
, NULL
);
1036 static int method_list_units(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1037 return list_units_filtered(message
, userdata
, error
, NULL
, NULL
);
1040 static int method_list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1041 _cleanup_strv_free_
char **states
= NULL
;
1044 r
= sd_bus_message_read_strv(message
, &states
);
1048 return list_units_filtered(message
, userdata
, error
, states
, NULL
);
1051 static int method_list_units_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1052 _cleanup_strv_free_
char **states
= NULL
;
1053 _cleanup_strv_free_
char **patterns
= NULL
;
1056 r
= sd_bus_message_read_strv(message
, &states
);
1060 r
= sd_bus_message_read_strv(message
, &patterns
);
1064 return list_units_filtered(message
, userdata
, error
, states
, patterns
);
1067 static int method_list_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1068 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1069 Manager
*m
= userdata
;
1077 /* Anyone can call this method */
1079 r
= mac_selinux_access_check(message
, "status", error
);
1083 r
= sd_bus_message_new_method_return(message
, &reply
);
1087 r
= sd_bus_message_open_container(reply
, 'a', "(usssoo)");
1091 HASHMAP_FOREACH(j
, m
->jobs
, i
) {
1092 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
1094 job_path
= job_dbus_path(j
);
1098 unit_path
= unit_dbus_path(j
->unit
);
1102 r
= sd_bus_message_append(
1106 job_type_to_string(j
->type
),
1107 job_state_to_string(j
->state
),
1114 r
= sd_bus_message_close_container(reply
);
1118 return sd_bus_send(NULL
, reply
, NULL
);
1121 static int method_subscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1122 Manager
*m
= userdata
;
1128 /* Anyone can call this method */
1130 r
= mac_selinux_access_check(message
, "status", error
);
1134 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1136 /* Note that direct bus connection subscribe by
1137 * default, we only track peers on the API bus here */
1139 if (!m
->subscribed
) {
1140 r
= sd_bus_track_new(sd_bus_message_get_bus(message
), &m
->subscribed
, NULL
, NULL
);
1145 r
= sd_bus_track_add_sender(m
->subscribed
, message
);
1149 return sd_bus_error_setf(error
, BUS_ERROR_ALREADY_SUBSCRIBED
, "Client is already subscribed.");
1152 return sd_bus_reply_method_return(message
, NULL
);
1155 static int method_unsubscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1156 Manager
*m
= userdata
;
1162 /* Anyone can call this method */
1164 r
= mac_selinux_access_check(message
, "status", error
);
1168 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1169 r
= sd_bus_track_remove_sender(m
->subscribed
, message
);
1173 return sd_bus_error_setf(error
, BUS_ERROR_NOT_SUBSCRIBED
, "Client is not subscribed.");
1176 return sd_bus_reply_method_return(message
, NULL
);
1179 static int dump_impl(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, int (*reply
)(sd_bus_message
*, char *)) {
1180 _cleanup_free_
char *dump
= NULL
;
1181 Manager
*m
= userdata
;
1187 /* Anyone can call this method */
1189 r
= mac_selinux_access_check(message
, "status", error
);
1193 r
= manager_get_dump_string(m
, &dump
);
1197 return reply(message
, dump
);
1200 static int reply_dump(sd_bus_message
*message
, char *dump
) {
1201 return sd_bus_reply_method_return(message
, "s", dump
);
1204 static int method_dump(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1205 return dump_impl(message
, userdata
, error
, reply_dump
);
1208 static int reply_dump_by_fd(sd_bus_message
*message
, char *dump
) {
1209 _cleanup_close_
int fd
= -1;
1211 fd
= acquire_data_fd(dump
, strlen(dump
), 0);
1215 return sd_bus_reply_method_return(message
, "h", fd
);
1218 static int method_dump_by_fd(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1219 return dump_impl(message
, userdata
, error
, reply_dump_by_fd
);
1222 static int method_refuse_snapshot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1223 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Support for snapshots has been removed.");
1226 static int verify_run_space(const char *message
, sd_bus_error
*error
) {
1227 struct statvfs svfs
;
1230 if (statvfs("/run/systemd", &svfs
) < 0)
1231 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1233 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1235 if (available
< RELOAD_DISK_SPACE_MIN
) {
1236 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1237 return sd_bus_error_setf(error
,
1238 BUS_ERROR_DISK_FULL
,
1239 "%s, not enough space available on /run/systemd. "
1240 "Currently, %s are free, but a safety buffer of %s is enforced.",
1242 format_bytes(fb_available
, sizeof(fb_available
), available
),
1243 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1249 int verify_run_space_and_log(const char *message
) {
1250 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1253 r
= verify_run_space(message
, &error
);
1255 return log_error_errno(r
, "%s", bus_error_message(&error
, r
));
1260 static int method_reload(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1261 Manager
*m
= userdata
;
1267 r
= verify_run_space("Refusing to reload", error
);
1271 r
= mac_selinux_access_check(message
, "reload", error
);
1275 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1279 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1281 /* Instead of sending the reply back right away, we just
1282 * remember that we need to and then send it after the reload
1283 * is finished. That way the caller knows when the reload
1286 assert(!m
->pending_reload_message
);
1287 r
= sd_bus_message_new_method_return(message
, &m
->pending_reload_message
);
1291 m
->objective
= MANAGER_RELOAD
;
1296 static int method_reexecute(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1297 Manager
*m
= userdata
;
1303 r
= verify_run_space("Refusing to reexecute", error
);
1307 r
= mac_selinux_access_check(message
, "reload", error
);
1311 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1315 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1317 /* We don't send a reply back here, the client should
1318 * just wait for us disconnecting. */
1320 m
->objective
= MANAGER_REEXECUTE
;
1324 static int method_exit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1325 Manager
*m
= userdata
;
1331 r
= mac_selinux_access_check(message
, "halt", error
);
1335 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1336 * we are running on the host. It will fall back on reboot() in
1337 * systemd-shutdown if it cannot do the exit() because it isn't a
1340 m
->objective
= MANAGER_EXIT
;
1342 return sd_bus_reply_method_return(message
, NULL
);
1345 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1346 Manager
*m
= userdata
;
1352 r
= mac_selinux_access_check(message
, "reboot", error
);
1356 if (!MANAGER_IS_SYSTEM(m
))
1357 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Reboot is only supported for system managers.");
1359 m
->objective
= MANAGER_REBOOT
;
1361 return sd_bus_reply_method_return(message
, NULL
);
1364 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1365 Manager
*m
= userdata
;
1371 r
= mac_selinux_access_check(message
, "halt", error
);
1375 if (!MANAGER_IS_SYSTEM(m
))
1376 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Powering off is only supported for system managers.");
1378 m
->objective
= MANAGER_POWEROFF
;
1380 return sd_bus_reply_method_return(message
, NULL
);
1383 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1384 Manager
*m
= userdata
;
1390 r
= mac_selinux_access_check(message
, "halt", error
);
1394 if (!MANAGER_IS_SYSTEM(m
))
1395 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Halt is only supported for system managers.");
1397 m
->objective
= MANAGER_HALT
;
1399 return sd_bus_reply_method_return(message
, NULL
);
1402 static int method_kexec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1403 Manager
*m
= userdata
;
1409 r
= mac_selinux_access_check(message
, "reboot", error
);
1413 if (!MANAGER_IS_SYSTEM(m
))
1414 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "KExec is only supported for system managers.");
1416 m
->objective
= MANAGER_KEXEC
;
1418 return sd_bus_reply_method_return(message
, NULL
);
1421 static int method_switch_root(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1422 _cleanup_free_
char *ri
= NULL
, *rt
= NULL
;
1423 const char *root
, *init
;
1424 Manager
*m
= userdata
;
1425 struct statvfs svfs
;
1432 if (statvfs("/run/systemd", &svfs
) < 0)
1433 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1435 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1437 if (available
< RELOAD_DISK_SPACE_MIN
) {
1438 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1439 log_warning("Dangerously low amount of free space on /run/systemd, root switching operation might not complete successfully. "
1440 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1441 format_bytes(fb_available
, sizeof(fb_available
), available
),
1442 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1445 r
= mac_selinux_access_check(message
, "reboot", error
);
1449 if (!MANAGER_IS_SYSTEM(m
))
1450 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Root switching is only supported by system manager.");
1452 r
= sd_bus_message_read(message
, "ss", &root
, &init
);
1457 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory may not be the empty string.");
1458 if (!path_is_absolute(root
))
1459 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root path '%s' is not absolute.", root
);
1460 if (path_equal(root
, "/"))
1461 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory cannot be the old root directory.");
1464 if (isempty(init
)) {
1465 r
= path_is_os_tree(root
);
1467 return sd_bus_error_set_errnof(error
, r
, "Failed to determine whether root path '%s' contains an OS tree: %m", root
);
1469 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.", root
);
1471 _cleanup_free_
char *chased
= NULL
;
1473 if (!path_is_absolute(init
))
1474 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path to init binary '%s' not absolute.", init
);
1476 r
= chase_symlinks(init
, root
, CHASE_PREFIX_ROOT
|CHASE_TRAIL_SLASH
, &chased
, NULL
);
1478 return sd_bus_error_set_errnof(error
, r
, "Could not resolve init executable %s: %m", init
);
1480 if (laccess(chased
, X_OK
) < 0) {
1481 if (errno
== EACCES
)
1482 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Init binary %s is not executable.", init
);
1484 return sd_bus_error_set_errnof(error
, r
, "Could not check whether init binary %s is executable: %m", init
);
1492 if (!isempty(init
)) {
1498 free_and_replace(m
->switch_root
, rt
);
1499 free_and_replace(m
->switch_root_init
, ri
);
1501 m
->objective
= MANAGER_SWITCH_ROOT
;
1503 return sd_bus_reply_method_return(message
, NULL
);
1506 static int method_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1507 _cleanup_strv_free_
char **plus
= NULL
;
1508 Manager
*m
= userdata
;
1514 r
= mac_selinux_access_check(message
, "reload", error
);
1518 r
= sd_bus_message_read_strv(message
, &plus
);
1521 if (!strv_env_is_valid(plus
))
1522 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1524 r
= bus_verify_set_environment_async(m
, message
, error
);
1528 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1530 r
= manager_client_environment_modify(m
, NULL
, plus
);
1534 return sd_bus_reply_method_return(message
, NULL
);
1537 static int method_unset_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1538 _cleanup_strv_free_
char **minus
= NULL
;
1539 Manager
*m
= userdata
;
1545 r
= mac_selinux_access_check(message
, "reload", error
);
1549 r
= sd_bus_message_read_strv(message
, &minus
);
1553 if (!strv_env_name_or_assignment_is_valid(minus
))
1554 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1556 r
= bus_verify_set_environment_async(m
, message
, error
);
1560 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1562 r
= manager_client_environment_modify(m
, minus
, NULL
);
1566 return sd_bus_reply_method_return(message
, NULL
);
1569 static int method_unset_and_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1570 _cleanup_strv_free_
char **minus
= NULL
, **plus
= NULL
;
1571 Manager
*m
= userdata
;
1577 r
= mac_selinux_access_check(message
, "reload", error
);
1581 r
= sd_bus_message_read_strv(message
, &minus
);
1585 r
= sd_bus_message_read_strv(message
, &plus
);
1589 if (!strv_env_name_or_assignment_is_valid(minus
))
1590 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1591 if (!strv_env_is_valid(plus
))
1592 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1594 r
= bus_verify_set_environment_async(m
, message
, error
);
1598 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1600 r
= manager_client_environment_modify(m
, minus
, plus
);
1604 return sd_bus_reply_method_return(message
, NULL
);
1607 static int method_set_exit_code(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1608 Manager
*m
= userdata
;
1615 r
= mac_selinux_access_check(message
, "exit", error
);
1619 r
= sd_bus_message_read_basic(message
, 'y', &code
);
1623 if (MANAGER_IS_SYSTEM(m
) && detect_container() <= 0)
1624 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "ExitCode can only be set for user service managers or in containers.");
1626 m
->return_value
= code
;
1628 return sd_bus_reply_method_return(message
, NULL
);
1631 static int method_lookup_dynamic_user_by_name(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1632 Manager
*m
= userdata
;
1640 r
= sd_bus_message_read_basic(message
, 's', &name
);
1644 if (!MANAGER_IS_SYSTEM(m
))
1645 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1646 if (!valid_user_group_name(name
, VALID_USER_RELAX
))
1647 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User name invalid: %s", name
);
1649 r
= dynamic_user_lookup_name(m
, name
, &uid
);
1651 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user %s does not exist.", name
);
1655 return sd_bus_reply_method_return(message
, "u", (uint32_t) uid
);
1658 static int method_lookup_dynamic_user_by_uid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1659 _cleanup_free_
char *name
= NULL
;
1660 Manager
*m
= userdata
;
1667 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
1668 r
= sd_bus_message_read_basic(message
, 'u', &uid
);
1672 if (!MANAGER_IS_SYSTEM(m
))
1673 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1674 if (!uid_is_valid(uid
))
1675 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User ID invalid: " UID_FMT
, uid
);
1677 r
= dynamic_user_lookup_uid(m
, uid
, &name
);
1679 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user ID " UID_FMT
" does not exist.", uid
);
1683 return sd_bus_reply_method_return(message
, "s", name
);
1686 static int method_get_dynamic_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1687 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1688 Manager
*m
= userdata
;
1696 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
1698 if (!MANAGER_IS_SYSTEM(m
))
1699 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1701 r
= sd_bus_message_new_method_return(message
, &reply
);
1705 r
= sd_bus_message_open_container(reply
, 'a', "(us)");
1709 HASHMAP_FOREACH(d
, m
->dynamic_users
, i
) {
1712 r
= dynamic_user_current(d
, &uid
);
1713 if (r
== -EAGAIN
) /* not realized yet? */
1716 return sd_bus_error_setf(error
, SD_BUS_ERROR_FAILED
, "Failed to look up a dynamic user.");
1718 r
= sd_bus_message_append(reply
, "(us)", uid
, d
->name
);
1723 r
= sd_bus_message_close_container(reply
);
1727 return sd_bus_send(NULL
, reply
, NULL
);
1730 static int list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1731 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1732 Manager
*m
= userdata
;
1741 /* Anyone can call this method */
1743 r
= mac_selinux_access_check(message
, "status", error
);
1747 r
= sd_bus_message_new_method_return(message
, &reply
);
1751 h
= hashmap_new(&string_hash_ops
);
1755 r
= unit_file_get_list(m
->unit_file_scope
, NULL
, h
, states
, patterns
);
1759 r
= sd_bus_message_open_container(reply
, 'a', "(ss)");
1763 HASHMAP_FOREACH(item
, h
, i
) {
1765 r
= sd_bus_message_append(reply
, "(ss)", item
->path
, unit_file_state_to_string(item
->state
));
1770 unit_file_list_free(h
);
1772 r
= sd_bus_message_close_container(reply
);
1776 return sd_bus_send(NULL
, reply
, NULL
);
1779 unit_file_list_free(h
);
1783 static int method_list_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1784 return list_unit_files_by_patterns(message
, userdata
, error
, NULL
, NULL
);
1787 static int method_list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1788 _cleanup_strv_free_
char **states
= NULL
;
1789 _cleanup_strv_free_
char **patterns
= NULL
;
1792 r
= sd_bus_message_read_strv(message
, &states
);
1796 r
= sd_bus_message_read_strv(message
, &patterns
);
1800 return list_unit_files_by_patterns(message
, userdata
, error
, states
, patterns
);
1803 static int method_get_unit_file_state(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1804 Manager
*m
= userdata
;
1806 UnitFileState state
;
1812 /* Anyone can call this method */
1814 r
= mac_selinux_access_check(message
, "status", error
);
1818 r
= sd_bus_message_read(message
, "s", &name
);
1822 r
= unit_file_get_state(m
->unit_file_scope
, NULL
, name
, &state
);
1826 return sd_bus_reply_method_return(message
, "s", unit_file_state_to_string(state
));
1829 static int method_get_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1830 _cleanup_free_
char *default_target
= NULL
;
1831 Manager
*m
= userdata
;
1837 /* Anyone can call this method */
1839 r
= mac_selinux_access_check(message
, "status", error
);
1843 r
= unit_file_get_default(m
->unit_file_scope
, NULL
, &default_target
);
1847 return sd_bus_reply_method_return(message
, "s", default_target
);
1850 static int send_unit_files_changed(sd_bus
*bus
, void *userdata
) {
1851 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
1856 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1860 return sd_bus_send(bus
, message
, NULL
);
1863 /* Create an error reply, using the error information from changes[]
1864 * if possible, and fall back to generating an error from error code c.
1865 * The error message only describes the first error.
1867 * Coordinate with unit_file_dump_changes() in install.c.
1869 static int install_error(
1870 sd_bus_error
*error
,
1872 UnitFileChange
*changes
,
1878 for (i
= 0; i
< n_changes
; i
++)
1880 switch(changes
[i
].type
) {
1886 if (changes
[i
].source
)
1887 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
1888 "File %s already exists and is a symlink to %s.",
1889 changes
[i
].path
, changes
[i
].source
);
1891 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
1892 "File %s already exists.",
1897 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
,
1898 "Unit file %s is masked.", changes
[i
].path
);
1901 case -EADDRNOTAVAIL
:
1902 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_GENERATED
,
1903 "Unit %s is transient or generated.", changes
[i
].path
);
1907 r
= sd_bus_error_setf(error
, BUS_ERROR_BAD_UNIT_SETTING
,
1908 "\"%s\" is not a valid unit name.",
1913 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_LINKED
,
1914 "Refusing to operate on alias name or linked unit file: %s",
1919 r
= sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
,
1920 "Unit file %s does not exist.", changes
[i
].path
);
1924 r
= sd_bus_error_set_errnof(error
, changes
[i
].type
, "File %s: %m", changes
[i
].path
);
1928 r
= c
< 0 ? c
: -EINVAL
;
1931 unit_file_changes_free(changes
, n_changes
);
1935 static int reply_unit_file_changes_and_free(
1937 sd_bus_message
*message
,
1938 int carries_install_info
,
1939 UnitFileChange
*changes
,
1941 sd_bus_error
*error
) {
1943 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1944 bool bad
= false, good
= false;
1948 if (unit_file_changes_have_modification(changes
, n_changes
)) {
1949 r
= bus_foreach_bus(m
, NULL
, send_unit_files_changed
, NULL
);
1951 log_debug_errno(r
, "Failed to send UnitFilesChanged signal: %m");
1954 r
= sd_bus_message_new_method_return(message
, &reply
);
1958 if (carries_install_info
>= 0) {
1959 r
= sd_bus_message_append(reply
, "b", carries_install_info
);
1964 r
= sd_bus_message_open_container(reply
, 'a', "(sss)");
1968 for (i
= 0; i
< n_changes
; i
++) {
1970 if (changes
[i
].type
< 0) {
1975 r
= sd_bus_message_append(
1977 unit_file_change_type_to_string(changes
[i
].type
),
1986 /* If there was a failed change, and no successful change, then return the first failure as proper method call
1989 return install_error(error
, 0, changes
, n_changes
);
1991 r
= sd_bus_message_close_container(reply
);
1995 unit_file_changes_free(changes
, n_changes
);
1996 return sd_bus_send(NULL
, reply
, NULL
);
1999 unit_file_changes_free(changes
, n_changes
);
2003 static int method_enable_unit_files_generic(
2004 sd_bus_message
*message
,
2006 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, size_t *n_changes
),
2007 bool carries_install_info
,
2008 sd_bus_error
*error
) {
2010 _cleanup_strv_free_
char **l
= NULL
;
2011 UnitFileChange
*changes
= NULL
;
2012 size_t n_changes
= 0;
2013 UnitFileFlags flags
;
2014 int runtime
, force
, r
;
2019 r
= sd_bus_message_read_strv(message
, &l
);
2023 r
= sd_bus_message_read(message
, "bb", &runtime
, &force
);
2027 flags
= unit_file_bools_to_flags(runtime
, force
);
2029 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2033 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2035 r
= call(m
->unit_file_scope
, flags
, NULL
, l
, &changes
, &n_changes
);
2037 return install_error(error
, r
, changes
, n_changes
);
2039 return reply_unit_file_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
, error
);
2042 static int method_enable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2043 return method_enable_unit_files_generic(message
, userdata
, unit_file_enable
, true, error
);
2046 static int method_reenable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2047 return method_enable_unit_files_generic(message
, userdata
, unit_file_reenable
, true, error
);
2050 static int method_link_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2051 return method_enable_unit_files_generic(message
, userdata
, unit_file_link
, false, error
);
2054 static int unit_file_preset_without_mode(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char **files
, UnitFileChange
**changes
, size_t *n_changes
) {
2055 return unit_file_preset(scope
, flags
, root_dir
, files
, UNIT_FILE_PRESET_FULL
, changes
, n_changes
);
2058 static int method_preset_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2059 return method_enable_unit_files_generic(message
, userdata
, unit_file_preset_without_mode
, true, error
);
2062 static int method_mask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2063 return method_enable_unit_files_generic(message
, userdata
, unit_file_mask
, false, error
);
2066 static int method_preset_unit_files_with_mode(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2068 _cleanup_strv_free_
char **l
= NULL
;
2069 UnitFileChange
*changes
= NULL
;
2070 size_t n_changes
= 0;
2071 Manager
*m
= userdata
;
2072 UnitFilePresetMode mm
;
2073 int runtime
, force
, r
;
2074 UnitFileFlags flags
;
2080 r
= sd_bus_message_read_strv(message
, &l
);
2084 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2088 flags
= unit_file_bools_to_flags(runtime
, force
);
2091 mm
= UNIT_FILE_PRESET_FULL
;
2093 mm
= unit_file_preset_mode_from_string(mode
);
2098 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2102 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2104 r
= unit_file_preset(m
->unit_file_scope
, flags
, NULL
, l
, mm
, &changes
, &n_changes
);
2106 return install_error(error
, r
, changes
, n_changes
);
2108 return reply_unit_file_changes_and_free(m
, message
, r
, changes
, n_changes
, error
);
2111 static int method_disable_unit_files_generic(
2112 sd_bus_message
*message
,
2114 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, size_t *n_changes
),
2115 sd_bus_error
*error
) {
2117 _cleanup_strv_free_
char **l
= NULL
;
2118 UnitFileChange
*changes
= NULL
;
2119 size_t n_changes
= 0;
2125 r
= sd_bus_message_read_strv(message
, &l
);
2129 r
= sd_bus_message_read(message
, "b", &runtime
);
2133 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2137 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2139 r
= call(m
->unit_file_scope
, runtime
? UNIT_FILE_RUNTIME
: 0, NULL
, l
, &changes
, &n_changes
);
2141 return install_error(error
, r
, changes
, n_changes
);
2143 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2146 static int method_disable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2147 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, error
);
2150 static int method_unmask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2151 return method_disable_unit_files_generic(message
, userdata
, unit_file_unmask
, error
);
2154 static int method_revert_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2155 _cleanup_strv_free_
char **l
= NULL
;
2156 UnitFileChange
*changes
= NULL
;
2157 size_t n_changes
= 0;
2158 Manager
*m
= userdata
;
2164 r
= sd_bus_message_read_strv(message
, &l
);
2168 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2172 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2174 r
= unit_file_revert(m
->unit_file_scope
, NULL
, l
, &changes
, &n_changes
);
2176 return install_error(error
, r
, changes
, n_changes
);
2178 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2181 static int method_set_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2182 UnitFileChange
*changes
= NULL
;
2183 size_t n_changes
= 0;
2184 Manager
*m
= userdata
;
2191 r
= mac_selinux_access_check(message
, "enable", error
);
2195 r
= sd_bus_message_read(message
, "sb", &name
, &force
);
2199 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2203 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2205 r
= unit_file_set_default(m
->unit_file_scope
, force
? UNIT_FILE_FORCE
: 0, NULL
, name
, &changes
, &n_changes
);
2207 return install_error(error
, r
, changes
, n_changes
);
2209 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2212 static int method_preset_all_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2213 UnitFileChange
*changes
= NULL
;
2214 size_t n_changes
= 0;
2215 Manager
*m
= userdata
;
2216 UnitFilePresetMode mm
;
2218 UnitFileFlags flags
;
2219 int force
, runtime
, r
;
2224 r
= mac_selinux_access_check(message
, "enable", error
);
2228 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2232 flags
= unit_file_bools_to_flags(runtime
, force
);
2235 mm
= UNIT_FILE_PRESET_FULL
;
2237 mm
= unit_file_preset_mode_from_string(mode
);
2242 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2246 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2248 r
= unit_file_preset_all(m
->unit_file_scope
, flags
, NULL
, mm
, &changes
, &n_changes
);
2250 return install_error(error
, r
, changes
, n_changes
);
2252 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2255 static int method_add_dependency_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2256 _cleanup_strv_free_
char **l
= NULL
;
2257 Manager
*m
= userdata
;
2258 UnitFileChange
*changes
= NULL
;
2259 size_t n_changes
= 0;
2260 int runtime
, force
, r
;
2261 char *target
, *type
;
2263 UnitFileFlags flags
;
2268 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2272 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2274 r
= sd_bus_message_read_strv(message
, &l
);
2278 r
= sd_bus_message_read(message
, "ssbb", &target
, &type
, &runtime
, &force
);
2282 flags
= unit_file_bools_to_flags(runtime
, force
);
2284 dep
= unit_dependency_from_string(type
);
2288 r
= unit_file_add_dependency(m
->unit_file_scope
, flags
, NULL
, l
, target
, dep
, &changes
, &n_changes
);
2290 return install_error(error
, r
, changes
, n_changes
);
2292 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2295 static int method_get_unit_file_links(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2296 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2297 UnitFileChange
*changes
= NULL
;
2298 size_t n_changes
= 0, i
;
2299 UnitFileFlags flags
;
2304 r
= sd_bus_message_read(message
, "sb", &name
, &runtime
);
2308 r
= sd_bus_message_new_method_return(message
, &reply
);
2312 r
= sd_bus_message_open_container(reply
, SD_BUS_TYPE_ARRAY
, "s");
2316 p
= STRV_MAKE(name
);
2317 flags
= UNIT_FILE_DRY_RUN
|
2318 (runtime
? UNIT_FILE_RUNTIME
: 0);
2320 r
= unit_file_disable(UNIT_FILE_SYSTEM
, flags
, NULL
, p
, &changes
, &n_changes
);
2322 return log_error_errno(r
, "Failed to get file links for %s: %m", name
);
2324 for (i
= 0; i
< n_changes
; i
++)
2325 if (changes
[i
].type
== UNIT_FILE_UNLINK
) {
2326 r
= sd_bus_message_append(reply
, "s", changes
[i
].path
);
2331 r
= sd_bus_message_close_container(reply
);
2335 return sd_bus_send(NULL
, reply
, NULL
);
2338 static int method_get_job_waiting(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2339 Manager
*m
= userdata
;
2347 r
= sd_bus_message_read(message
, "u", &id
);
2351 j
= manager_get_job(m
, id
);
2353 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
2355 return bus_job_method_get_waiting_jobs(message
, j
, error
);
2358 static int method_abandon_scope(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2359 Manager
*m
= userdata
;
2367 r
= sd_bus_message_read(message
, "s", &name
);
2371 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
2375 if (u
->type
!= UNIT_SCOPE
)
2376 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unit '%s' is not a scope unit, refusing.", name
);
2378 return bus_scope_method_abandon(message
, u
, error
);
2381 const sd_bus_vtable bus_manager_vtable
[] = {
2382 SD_BUS_VTABLE_START(0),
2384 SD_BUS_PROPERTY("Version", "s", property_get_version
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2385 SD_BUS_PROPERTY("Features", "s", property_get_features
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2386 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2387 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2388 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2389 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FIRMWARE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2390 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_LOADER
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2391 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_KERNEL
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2392 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2393 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_USERSPACE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2394 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2395 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2396 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2397 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2398 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2399 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2400 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2401 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2402 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2403 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2404 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2405 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2406 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2407 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level
, property_set_log_level
, 0, 0),
2408 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target
, property_set_log_target
, 0, 0),
2409 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size
, offsetof(Manager
, units
), 0),
2410 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size
, offsetof(Manager
, failed_units
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2411 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size
, offsetof(Manager
, jobs
), 0),
2412 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_installed_jobs
), 0),
2413 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_failed_jobs
), 0),
2414 SD_BUS_PROPERTY("Progress", "d", property_get_progress
, 0, 0),
2415 SD_BUS_PROPERTY("Environment", "as", property_get_environment
, 0, 0),
2416 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool
, offsetof(Manager
, confirm_spawn
), SD_BUS_VTABLE_PROPERTY_CONST
),
2417 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status
, 0, 0),
2418 SD_BUS_PROPERTY("UnitPath", "as", NULL
, offsetof(Manager
, lookup_paths
.search_path
), SD_BUS_VTABLE_PROPERTY_CONST
),
2419 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2420 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2421 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec
, property_set_runtime_watchdog
, offsetof(Manager
, runtime_watchdog
), 0),
2422 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, reboot_watchdog
), 0),
2423 /* The following item is an obsolete alias */
2424 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, reboot_watchdog
), SD_BUS_VTABLE_HIDDEN
),
2425 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, kexec_watchdog
), 0),
2426 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool
, bus_property_set_bool
, offsetof(Manager
, service_watchdogs
), 0),
2427 SD_BUS_PROPERTY("ControlGroup", "s", NULL
, offsetof(Manager
, cgroup_root
), 0),
2428 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state
, 0, 0),
2429 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned
, offsetof(Manager
, return_value
), 0),
2430 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timer_accuracy_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2431 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_start_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2432 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_stop_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2433 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec
, 0, 0),
2434 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_restart_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2435 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
),
2436 /* The following two items are obsolete alias */
2437 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2438 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2439 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned
, offsetof(Manager
, default_start_limit_burst
), SD_BUS_VTABLE_PROPERTY_CONST
),
2440 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_cpu_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2441 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_blockio_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2442 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_memory_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2443 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_tasks_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2444 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2445 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2446 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2447 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2448 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2449 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2450 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2451 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2452 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2453 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2454 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2455 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2456 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2457 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2458 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2459 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2460 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2461 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2462 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2463 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2464 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2465 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2466 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2467 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2468 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2469 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2470 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2471 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2472 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2473 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2474 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2475 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2476 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max
, offsetof(Manager
, default_tasks_max
), 0),
2477 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2478 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy
, offsetof(Manager
, default_oom_policy
), SD_BUS_VTABLE_PROPERTY_CONST
),
2480 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2481 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2482 SD_BUS_METHOD("GetUnitByInvocationID", "ay", "o", method_get_unit_by_invocation_id
, SD_BUS_VTABLE_UNPRIVILEGED
),
2483 SD_BUS_METHOD("GetUnitByControlGroup", "s", "o", method_get_unit_by_control_group
, SD_BUS_VTABLE_UNPRIVILEGED
),
2484 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2485 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2486 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace
, SD_BUS_VTABLE_UNPRIVILEGED
),
2487 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2488 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2489 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2490 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2491 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2492 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2493 SD_BUS_METHOD("EnqueueUnitJob", "sss", "uososa(uosos)", method_enqueue_unit_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2494 SD_BUS_METHOD("KillUnit", "ssi", NULL
, method_kill_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2495 SD_BUS_METHOD("CleanUnit", "sas", NULL
, method_clean_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2496 SD_BUS_METHOD("ResetFailedUnit", "s", NULL
, method_reset_failed_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2497 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL
, method_set_unit_properties
, SD_BUS_VTABLE_UNPRIVILEGED
),
2498 SD_BUS_METHOD("RefUnit", "s", NULL
, method_ref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2499 SD_BUS_METHOD("UnrefUnit", "s", NULL
, method_unref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2500 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2501 SD_BUS_METHOD("GetUnitProcesses", "s", "a(sus)", method_get_unit_processes
, SD_BUS_VTABLE_UNPRIVILEGED
),
2502 SD_BUS_METHOD("AttachProcessesToUnit", "ssau", NULL
, method_attach_processes_to_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2503 SD_BUS_METHOD("AbandonScope", "s", NULL
, method_abandon_scope
, SD_BUS_VTABLE_UNPRIVILEGED
),
2504 SD_BUS_METHOD("GetJob", "u", "o", method_get_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2505 SD_BUS_METHOD("GetJobAfter", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2506 SD_BUS_METHOD("GetJobBefore", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2507 SD_BUS_METHOD("CancelJob", "u", NULL
, method_cancel_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2508 SD_BUS_METHOD("ClearJobs", NULL
, NULL
, method_clear_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2509 SD_BUS_METHOD("ResetFailed", NULL
, NULL
, method_reset_failed
, SD_BUS_VTABLE_UNPRIVILEGED
),
2510 SD_BUS_METHOD("ListUnits", NULL
, "a(ssssssouso)", method_list_units
, SD_BUS_VTABLE_UNPRIVILEGED
),
2511 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered
, SD_BUS_VTABLE_UNPRIVILEGED
),
2512 SD_BUS_METHOD("ListUnitsByPatterns", "asas", "a(ssssssouso)", method_list_units_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2513 SD_BUS_METHOD("ListUnitsByNames", "as", "a(ssssssouso)", method_list_units_by_names
, SD_BUS_VTABLE_UNPRIVILEGED
),
2514 SD_BUS_METHOD("ListJobs", NULL
, "a(usssoo)", method_list_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2515 SD_BUS_METHOD("Subscribe", NULL
, NULL
, method_subscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2516 SD_BUS_METHOD("Unsubscribe", NULL
, NULL
, method_unsubscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2517 SD_BUS_METHOD("Dump", NULL
, "s", method_dump
, SD_BUS_VTABLE_UNPRIVILEGED
),
2518 SD_BUS_METHOD("DumpByFileDescriptor", NULL
, "h", method_dump_by_fd
, SD_BUS_VTABLE_UNPRIVILEGED
),
2519 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
2520 SD_BUS_METHOD("RemoveSnapshot", "s", NULL
, method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
2521 SD_BUS_METHOD("Reload", NULL
, NULL
, method_reload
, SD_BUS_VTABLE_UNPRIVILEGED
),
2522 SD_BUS_METHOD("Reexecute", NULL
, NULL
, method_reexecute
, SD_BUS_VTABLE_UNPRIVILEGED
),
2523 SD_BUS_METHOD("Exit", NULL
, NULL
, method_exit
, 0),
2524 SD_BUS_METHOD("Reboot", NULL
, NULL
, method_reboot
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2525 SD_BUS_METHOD("PowerOff", NULL
, NULL
, method_poweroff
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2526 SD_BUS_METHOD("Halt", NULL
, NULL
, method_halt
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2527 SD_BUS_METHOD("KExec", NULL
, NULL
, method_kexec
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2528 SD_BUS_METHOD("SwitchRoot", "ss", NULL
, method_switch_root
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2529 SD_BUS_METHOD("SetEnvironment", "as", NULL
, method_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2530 SD_BUS_METHOD("UnsetEnvironment", "as", NULL
, method_unset_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2531 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL
, method_unset_and_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2532 SD_BUS_METHOD("ListUnitFiles", NULL
, "a(ss)", method_list_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2533 SD_BUS_METHOD("ListUnitFilesByPatterns", "asas", "a(ss)", method_list_unit_files_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2534 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state
, SD_BUS_VTABLE_UNPRIVILEGED
),
2535 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2536 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2537 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2538 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2539 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2540 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode
, SD_BUS_VTABLE_UNPRIVILEGED
),
2541 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2542 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2543 SD_BUS_METHOD("RevertUnitFiles", "as", "a(sss)", method_revert_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2544 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2545 SD_BUS_METHOD("GetDefaultTarget", NULL
, "s", method_get_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2546 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2547 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2548 SD_BUS_METHOD("GetUnitFileLinks", "sb", "as", method_get_unit_file_links
, SD_BUS_VTABLE_UNPRIVILEGED
),
2549 SD_BUS_METHOD("SetExitCode", "y", NULL
, method_set_exit_code
, SD_BUS_VTABLE_UNPRIVILEGED
),
2550 SD_BUS_METHOD("LookupDynamicUserByName", "s", "u", method_lookup_dynamic_user_by_name
, SD_BUS_VTABLE_UNPRIVILEGED
),
2551 SD_BUS_METHOD("LookupDynamicUserByUID", "u", "s", method_lookup_dynamic_user_by_uid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2552 SD_BUS_METHOD("GetDynamicUsers", NULL
, "a(us)", method_get_dynamic_users
, SD_BUS_VTABLE_UNPRIVILEGED
),
2554 SD_BUS_SIGNAL("UnitNew", "so", 0),
2555 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2556 SD_BUS_SIGNAL("JobNew", "uos", 0),
2557 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2558 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2559 SD_BUS_SIGNAL("UnitFilesChanged", NULL
, 0),
2560 SD_BUS_SIGNAL("Reloading", "b", 0),
2565 static int send_finished(sd_bus
*bus
, void *userdata
) {
2566 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2567 usec_t
*times
= userdata
;
2573 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2577 r
= sd_bus_message_append(message
, "tttttt", times
[0], times
[1], times
[2], times
[3], times
[4], times
[5]);
2581 return sd_bus_send(bus
, message
, NULL
);
2584 void bus_manager_send_finished(
2586 usec_t firmware_usec
,
2590 usec_t userspace_usec
,
2591 usec_t total_usec
) {
2597 r
= bus_foreach_bus(
2610 log_debug_errno(r
, "Failed to send finished signal: %m");
2613 static int send_reloading(sd_bus
*bus
, void *userdata
) {
2614 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2619 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2623 r
= sd_bus_message_append(message
, "b", PTR_TO_INT(userdata
));
2627 return sd_bus_send(bus
, message
, NULL
);
2630 void bus_manager_send_reloading(Manager
*m
, bool active
) {
2635 r
= bus_foreach_bus(m
, NULL
, send_reloading
, INT_TO_PTR(active
));
2637 log_debug_errno(r
, "Failed to send reloading signal: %m");
2640 static int send_changed_signal(sd_bus
*bus
, void *userdata
) {
2643 return sd_bus_emit_properties_changed_strv(bus
,
2644 "/org/freedesktop/systemd1",
2645 "org.freedesktop.systemd1.Manager",
2649 void bus_manager_send_change_signal(Manager
*m
) {
2654 r
= bus_foreach_bus(m
, NULL
, send_changed_signal
, NULL
);
2656 log_debug_errno(r
, "Failed to send manager change signal: %m");