1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
10 #include <sys/statvfs.h>
13 #include "alloc-util.h"
14 #include "architecture.h"
16 #include "bus-common-errors.h"
17 #include "dbus-execute.h"
19 #include "dbus-manager.h"
20 #include "dbus-unit.h"
25 #include "format-util.h"
29 #include "parse-util.h"
30 #include "path-util.h"
31 #include "selinux-access.h"
32 #include "stat-util.h"
33 #include "string-util.h"
35 #include "syslog-util.h"
36 #include "user-util.h"
40 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state there, and if
41 * we can't we'll fail badly. */
42 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
44 static UnitFileFlags
unit_file_bools_to_flags(bool runtime
, bool force
) {
45 return (runtime
? UNIT_FILE_RUNTIME
: 0) |
46 (force
? UNIT_FILE_FORCE
: 0);
49 static int property_get_version(
52 const char *interface
,
54 sd_bus_message
*reply
,
56 sd_bus_error
*error
) {
61 return sd_bus_message_append(reply
, "s", PACKAGE_VERSION
);
64 static int property_get_features(
67 const char *interface
,
69 sd_bus_message
*reply
,
71 sd_bus_error
*error
) {
76 return sd_bus_message_append(reply
, "s", SYSTEMD_FEATURES
);
79 static int property_get_virtualization(
82 const char *interface
,
84 sd_bus_message
*reply
,
86 sd_bus_error
*error
) {
93 v
= detect_virtualization();
95 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
97 * https://github.com/systemd/systemd/issues/1423
100 return sd_bus_message_append(
102 v
== VIRTUALIZATION_NONE
? NULL
: virtualization_to_string(v
));
105 static int property_get_architecture(
108 const char *interface
,
109 const char *property
,
110 sd_bus_message
*reply
,
112 sd_bus_error
*error
) {
117 return sd_bus_message_append(reply
, "s", architecture_to_string(uname_architecture()));
120 static int property_get_tainted(
123 const char *interface
,
124 const char *property
,
125 sd_bus_message
*reply
,
127 sd_bus_error
*error
) {
129 _cleanup_free_
char *s
= NULL
;
130 Manager
*m
= userdata
;
136 s
= manager_taint_string(m
);
140 return sd_bus_message_append(reply
, "s", s
);
143 static int property_get_log_target(
146 const char *interface
,
147 const char *property
,
148 sd_bus_message
*reply
,
150 sd_bus_error
*error
) {
155 return sd_bus_message_append(reply
, "s", log_target_to_string(log_get_target()));
158 static int property_set_log_target(
161 const char *interface
,
162 const char *property
,
163 sd_bus_message
*value
,
165 sd_bus_error
*error
) {
173 r
= sd_bus_message_read(value
, "s", &t
);
177 return log_set_target_from_string(t
);
180 static int property_get_log_level(
183 const char *interface
,
184 const char *property
,
185 sd_bus_message
*reply
,
187 sd_bus_error
*error
) {
189 _cleanup_free_
char *t
= NULL
;
195 r
= log_level_to_string_alloc(log_get_max_level(), &t
);
199 return sd_bus_message_append(reply
, "s", t
);
202 static int property_set_log_level(
205 const char *interface
,
206 const char *property
,
207 sd_bus_message
*value
,
209 sd_bus_error
*error
) {
217 r
= sd_bus_message_read(value
, "s", &t
);
221 r
= log_set_max_level_from_string(t
);
223 log_info("Setting log level to %s.", t
);
227 static int property_get_n_names(
230 const char *interface
,
231 const char *property
,
232 sd_bus_message
*reply
,
234 sd_bus_error
*error
) {
236 Manager
*m
= userdata
;
242 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->units
));
245 static int property_get_n_failed_units(
248 const char *interface
,
249 const char *property
,
250 sd_bus_message
*reply
,
252 sd_bus_error
*error
) {
254 Manager
*m
= userdata
;
260 return sd_bus_message_append(reply
, "u", (uint32_t) set_size(m
->failed_units
));
263 static int property_get_n_jobs(
266 const char *interface
,
267 const char *property
,
268 sd_bus_message
*reply
,
270 sd_bus_error
*error
) {
272 Manager
*m
= userdata
;
278 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->jobs
));
281 static int property_get_progress(
284 const char *interface
,
285 const char *property
,
286 sd_bus_message
*reply
,
288 sd_bus_error
*error
) {
290 Manager
*m
= userdata
;
297 if (MANAGER_IS_FINISHED(m
))
300 d
= 1.0 - ((double) hashmap_size(m
->jobs
) / (double) m
->n_installed_jobs
);
302 return sd_bus_message_append(reply
, "d", d
);
305 static int property_get_system_state(
308 const char *interface
,
309 const char *property
,
310 sd_bus_message
*reply
,
312 sd_bus_error
*error
) {
314 Manager
*m
= userdata
;
320 return sd_bus_message_append(reply
, "s", manager_state_to_string(manager_state(m
)));
323 static int property_set_runtime_watchdog(
326 const char *interface
,
327 const char *property
,
328 sd_bus_message
*value
,
330 sd_bus_error
*error
) {
332 usec_t
*t
= userdata
;
338 assert_cc(sizeof(usec_t
) == sizeof(uint64_t));
340 r
= sd_bus_message_read(value
, "t", t
);
344 return watchdog_set_timeout(t
);
347 static int property_get_timer_slack_nsec(
350 const char *interface
,
351 const char *property
,
352 sd_bus_message
*reply
,
354 sd_bus_error
*error
) {
359 return sd_bus_message_append(reply
, "t", (uint64_t) prctl(PR_GET_TIMERSLACK
));
362 static int bus_get_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
370 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up its sleeve:
371 * if the name is specified empty we use the client's unit. */
374 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
377 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
381 r
= sd_bus_creds_get_pid(creds
, &pid
);
385 u
= manager_get_unit_by_pid(m
, pid
);
387 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
389 u
= manager_get_unit(m
, name
);
391 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
398 static int bus_load_unit_by_name(Manager
*m
, sd_bus_message
*message
, const char *name
, Unit
**ret_unit
, sd_bus_error
*error
) {
403 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
406 return bus_get_unit_by_name(m
, message
, name
, ret_unit
, error
);
408 return manager_load_unit(m
, name
, NULL
, error
, ret_unit
);
411 static int method_get_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
412 _cleanup_free_
char *path
= NULL
;
413 Manager
*m
= userdata
;
421 /* Anyone can call this method */
423 r
= sd_bus_message_read(message
, "s", &name
);
427 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
431 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
435 path
= unit_dbus_path(u
);
439 return sd_bus_reply_method_return(message
, "o", path
);
442 static int method_get_unit_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
443 _cleanup_free_
char *path
= NULL
;
444 Manager
*m
= userdata
;
452 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
454 /* Anyone can call this method */
456 r
= sd_bus_message_read(message
, "u", &pid
);
460 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid PID " PID_FMT
, pid
);
463 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
465 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
469 r
= sd_bus_creds_get_pid(creds
, &pid
);
474 u
= manager_get_unit_by_pid(m
, pid
);
476 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_PID
, "PID "PID_FMT
" does not belong to any loaded unit.", pid
);
478 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
482 path
= unit_dbus_path(u
);
486 return sd_bus_reply_method_return(message
, "o", path
);
489 static int method_get_unit_by_invocation_id(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
490 _cleanup_free_
char *path
= NULL
;
491 Manager
*m
= userdata
;
501 /* Anyone can call this method */
503 r
= sd_bus_message_read_array(message
, 'y', &a
, &sz
);
511 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid invocation ID");
513 if (sd_id128_is_null(id
)) {
514 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
517 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
521 r
= sd_bus_creds_get_pid(creds
, &pid
);
525 u
= manager_get_unit_by_pid(m
, pid
);
527 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client " PID_FMT
" not member of any unit.", pid
);
529 u
= hashmap_get(m
->units_by_invocation_id
, &id
);
531 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
));
534 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
538 /* So here's a special trick: the bus path we return actually references the unit by its invocation ID instead
539 * of the unit name. This means it stays valid only as long as the invocation ID stays the same. */
540 path
= unit_dbus_path_invocation_id(u
);
544 return sd_bus_reply_method_return(message
, "o", path
);
547 static int method_get_unit_by_control_group(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
548 _cleanup_free_
char *path
= NULL
;
549 Manager
*m
= userdata
;
554 r
= sd_bus_message_read(message
, "s", &cgroup
);
558 u
= manager_get_unit_by_cgroup(m
, cgroup
);
560 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Control group '%s' is not valid or not managed by this instance", cgroup
);
562 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
566 path
= unit_dbus_path(u
);
570 return sd_bus_reply_method_return(message
, "o", path
);
573 static int method_load_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
574 _cleanup_free_
char *path
= NULL
;
575 Manager
*m
= userdata
;
583 /* Anyone can call this method */
585 r
= sd_bus_message_read(message
, "s", &name
);
589 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
593 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
597 path
= unit_dbus_path(u
);
601 return sd_bus_reply_method_return(message
, "o", path
);
604 static int method_start_unit_generic(sd_bus_message
*message
, Manager
*m
, JobType job_type
, bool reload_if_possible
, sd_bus_error
*error
) {
612 r
= sd_bus_message_read(message
, "s", &name
);
616 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
620 return bus_unit_method_start_generic(message
, u
, job_type
, reload_if_possible
, error
);
623 static int method_start_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
624 return method_start_unit_generic(message
, userdata
, JOB_START
, false, error
);
627 static int method_stop_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
628 return method_start_unit_generic(message
, userdata
, JOB_STOP
, false, error
);
631 static int method_reload_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
632 return method_start_unit_generic(message
, userdata
, JOB_RELOAD
, false, error
);
635 static int method_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
636 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, false, error
);
639 static int method_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
640 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, false, error
);
643 static int method_reload_or_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
644 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, true, error
);
647 static int method_reload_or_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
648 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, true, error
);
651 static int method_start_unit_replace(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
652 Manager
*m
= userdata
;
653 const char *old_name
;
660 r
= sd_bus_message_read(message
, "s", &old_name
);
664 r
= bus_get_unit_by_name(m
, message
, old_name
, &u
, error
);
667 if (!u
->job
|| u
->job
->type
!= JOB_START
)
668 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "No job queued for unit %s", old_name
);
670 return method_start_unit_generic(message
, m
, JOB_START
, false, error
);
673 static int method_kill_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
674 Manager
*m
= userdata
;
682 r
= sd_bus_message_read(message
, "s", &name
);
686 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
690 return bus_unit_method_kill(message
, u
, error
);
693 static int method_reset_failed_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
694 Manager
*m
= userdata
;
702 r
= sd_bus_message_read(message
, "s", &name
);
706 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
710 return bus_unit_method_reset_failed(message
, u
, error
);
713 static int method_set_unit_properties(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
714 Manager
*m
= userdata
;
722 r
= sd_bus_message_read(message
, "s", &name
);
726 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
730 r
= bus_unit_check_load_state(u
, error
);
734 return bus_unit_method_set_properties(message
, u
, error
);
737 static int method_ref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
738 Manager
*m
= userdata
;
746 r
= sd_bus_message_read(message
, "s", &name
);
750 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
754 r
= bus_unit_check_load_state(u
, error
);
758 return bus_unit_method_ref(message
, u
, error
);
761 static int method_unref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
762 Manager
*m
= userdata
;
770 r
= sd_bus_message_read(message
, "s", &name
);
774 r
= bus_load_unit_by_name(m
, message
, name
, &u
, error
);
778 r
= bus_unit_check_load_state(u
, error
);
782 return bus_unit_method_unref(message
, u
, error
);
785 static int reply_unit_info(sd_bus_message
*reply
, Unit
*u
) {
786 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
789 following
= unit_following(u
);
791 unit_path
= unit_dbus_path(u
);
796 job_path
= job_dbus_path(u
->job
);
801 return sd_bus_message_append(
802 reply
, "(ssssssouso)",
805 unit_load_state_to_string(u
->load_state
),
806 unit_active_state_to_string(unit_active_state(u
)),
807 unit_sub_state_to_string(u
),
808 following
? following
->id
: "",
810 u
->job
? u
->job
->id
: 0,
811 u
->job
? job_type_to_string(u
->job
->type
) : "",
812 job_path
? job_path
: "/");
815 static int method_list_units_by_names(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
816 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
817 Manager
*m
= userdata
;
820 _cleanup_strv_free_
char **units
= NULL
;
825 r
= sd_bus_message_read_strv(message
, &units
);
829 r
= sd_bus_message_new_method_return(message
, &reply
);
833 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
837 STRV_FOREACH(unit
, units
) {
840 if (!unit_name_is_valid(*unit
, UNIT_NAME_ANY
))
843 r
= bus_load_unit_by_name(m
, message
, *unit
, &u
, error
);
847 r
= reply_unit_info(reply
, u
);
852 r
= sd_bus_message_close_container(reply
);
856 return sd_bus_send(NULL
, reply
, NULL
);
859 static int method_get_unit_processes(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
860 Manager
*m
= userdata
;
868 r
= sd_bus_message_read(message
, "s", &name
);
872 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
876 return bus_unit_method_get_processes(message
, u
, error
);
879 static int method_attach_processes_to_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
880 Manager
*m
= userdata
;
888 r
= sd_bus_message_read(message
, "s", &name
);
892 r
= bus_get_unit_by_name(m
, message
, name
, &u
, error
);
896 return bus_unit_method_attach_processes(message
, u
, error
);
899 static int transient_unit_from_message(
901 sd_bus_message
*message
,
904 sd_bus_error
*error
) {
914 t
= unit_name_to_type(name
);
916 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid unit name or type.");
918 if (!unit_vtable
[t
]->can_transient
)
919 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unit type %s does not support transient units.", unit_type_to_string(t
));
921 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
925 if (!unit_is_pristine(u
))
926 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
, "Unit %s already exists.", name
);
928 /* OK, the unit failed to load and is unreferenced, now let's
929 * fill in the transient data instead */
930 r
= unit_make_transient(u
);
934 /* Set our properties */
935 r
= bus_unit_set_properties(u
, message
, UNIT_RUNTIME
, false, error
);
939 /* If the client asked for it, automatically add a reference to this unit. */
940 if (u
->bus_track_add
) {
941 r
= bus_unit_track_add_sender(u
, message
);
943 return log_error_errno(r
, "Failed to watch sender: %m");
946 /* Now load the missing bits of the unit we just created */
947 unit_add_to_load_queue(u
);
948 manager_dispatch_load_queue(m
);
955 static int transient_aux_units_from_message(
957 sd_bus_message
*message
,
958 sd_bus_error
*error
) {
965 r
= sd_bus_message_enter_container(message
, 'a', "(sa(sv))");
969 while ((r
= sd_bus_message_enter_container(message
, 'r', "sa(sv)")) > 0) {
970 const char *name
= NULL
;
973 r
= sd_bus_message_read(message
, "s", &name
);
977 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
981 r
= sd_bus_message_exit_container(message
);
988 r
= sd_bus_message_exit_container(message
);
995 static int method_start_transient_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
996 const char *name
, *smode
;
997 Manager
*m
= userdata
;
1005 r
= mac_selinux_access_check(message
, "start", error
);
1009 r
= sd_bus_message_read(message
, "ss", &name
, &smode
);
1013 mode
= job_mode_from_string(smode
);
1015 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Job mode %s is invalid.", smode
);
1017 r
= bus_verify_manage_units_async(m
, message
, error
);
1021 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1023 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
1027 r
= transient_aux_units_from_message(m
, message
, error
);
1031 /* Finally, start it */
1032 return bus_unit_queue_job(message
, u
, JOB_START
, mode
, false, error
);
1035 static int method_get_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1036 _cleanup_free_
char *path
= NULL
;
1037 Manager
*m
= userdata
;
1045 /* Anyone can call this method */
1047 r
= sd_bus_message_read(message
, "u", &id
);
1051 j
= manager_get_job(m
, id
);
1053 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1055 r
= mac_selinux_unit_access_check(j
->unit
, message
, "status", error
);
1059 path
= job_dbus_path(j
);
1063 return sd_bus_reply_method_return(message
, "o", path
);
1066 static int method_cancel_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1067 Manager
*m
= userdata
;
1075 r
= sd_bus_message_read(message
, "u", &id
);
1079 j
= manager_get_job(m
, id
);
1081 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1083 return bus_job_method_cancel(message
, j
, error
);
1086 static int method_clear_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1087 Manager
*m
= userdata
;
1093 r
= mac_selinux_access_check(message
, "reload", error
);
1097 r
= bus_verify_manage_units_async(m
, message
, error
);
1101 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1103 manager_clear_jobs(m
);
1105 return sd_bus_reply_method_return(message
, NULL
);
1108 static int method_reset_failed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1109 Manager
*m
= userdata
;
1115 r
= mac_selinux_access_check(message
, "reload", error
);
1119 r
= bus_verify_manage_units_async(m
, message
, error
);
1123 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1125 manager_reset_failed(m
);
1127 return sd_bus_reply_method_return(message
, NULL
);
1130 static int list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1131 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1132 Manager
*m
= userdata
;
1141 /* Anyone can call this method */
1143 r
= mac_selinux_access_check(message
, "status", error
);
1147 r
= sd_bus_message_new_method_return(message
, &reply
);
1151 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
1155 HASHMAP_FOREACH_KEY(u
, k
, m
->units
, i
) {
1159 if (!strv_isempty(states
) &&
1160 !strv_contains(states
, unit_load_state_to_string(u
->load_state
)) &&
1161 !strv_contains(states
, unit_active_state_to_string(unit_active_state(u
))) &&
1162 !strv_contains(states
, unit_sub_state_to_string(u
)))
1165 if (!strv_isempty(patterns
) &&
1166 !strv_fnmatch_or_empty(patterns
, u
->id
, FNM_NOESCAPE
))
1169 r
= reply_unit_info(reply
, u
);
1174 r
= sd_bus_message_close_container(reply
);
1178 return sd_bus_send(NULL
, reply
, NULL
);
1181 static int method_list_units(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1182 return list_units_filtered(message
, userdata
, error
, NULL
, NULL
);
1185 static int method_list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1186 _cleanup_strv_free_
char **states
= NULL
;
1189 r
= sd_bus_message_read_strv(message
, &states
);
1193 return list_units_filtered(message
, userdata
, error
, states
, NULL
);
1196 static int method_list_units_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1197 _cleanup_strv_free_
char **states
= NULL
;
1198 _cleanup_strv_free_
char **patterns
= NULL
;
1201 r
= sd_bus_message_read_strv(message
, &states
);
1205 r
= sd_bus_message_read_strv(message
, &patterns
);
1209 return list_units_filtered(message
, userdata
, error
, states
, patterns
);
1212 static int method_list_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1213 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1214 Manager
*m
= userdata
;
1222 /* Anyone can call this method */
1224 r
= mac_selinux_access_check(message
, "status", error
);
1228 r
= sd_bus_message_new_method_return(message
, &reply
);
1232 r
= sd_bus_message_open_container(reply
, 'a', "(usssoo)");
1236 HASHMAP_FOREACH(j
, m
->jobs
, i
) {
1237 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
1239 job_path
= job_dbus_path(j
);
1243 unit_path
= unit_dbus_path(j
->unit
);
1247 r
= sd_bus_message_append(
1251 job_type_to_string(j
->type
),
1252 job_state_to_string(j
->state
),
1259 r
= sd_bus_message_close_container(reply
);
1263 return sd_bus_send(NULL
, reply
, NULL
);
1266 static int method_subscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1267 Manager
*m
= userdata
;
1273 /* Anyone can call this method */
1275 r
= mac_selinux_access_check(message
, "status", error
);
1279 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1281 /* Note that direct bus connection subscribe by
1282 * default, we only track peers on the API bus here */
1284 if (!m
->subscribed
) {
1285 r
= sd_bus_track_new(sd_bus_message_get_bus(message
), &m
->subscribed
, NULL
, NULL
);
1290 r
= sd_bus_track_add_sender(m
->subscribed
, message
);
1294 return sd_bus_error_setf(error
, BUS_ERROR_ALREADY_SUBSCRIBED
, "Client is already subscribed.");
1297 return sd_bus_reply_method_return(message
, NULL
);
1300 static int method_unsubscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1301 Manager
*m
= userdata
;
1307 /* Anyone can call this method */
1309 r
= mac_selinux_access_check(message
, "status", error
);
1313 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1314 r
= sd_bus_track_remove_sender(m
->subscribed
, message
);
1318 return sd_bus_error_setf(error
, BUS_ERROR_NOT_SUBSCRIBED
, "Client is not subscribed.");
1321 return sd_bus_reply_method_return(message
, NULL
);
1324 static int dump_impl(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, int (*reply
)(sd_bus_message
*, char *)) {
1325 _cleanup_free_
char *dump
= NULL
;
1326 Manager
*m
= userdata
;
1332 /* Anyone can call this method */
1334 r
= mac_selinux_access_check(message
, "status", error
);
1338 r
= manager_get_dump_string(m
, &dump
);
1342 return reply(message
, dump
);
1345 static int reply_dump(sd_bus_message
*message
, char *dump
) {
1346 return sd_bus_reply_method_return(message
, "s", dump
);
1349 static int method_dump(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1350 return dump_impl(message
, userdata
, error
, reply_dump
);
1353 static int reply_dump_by_fd(sd_bus_message
*message
, char *dump
) {
1354 _cleanup_close_
int fd
= -1;
1356 fd
= acquire_data_fd(dump
, strlen(dump
), 0);
1360 return sd_bus_reply_method_return(message
, "h", fd
);
1363 static int method_dump_by_fd(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1364 return dump_impl(message
, userdata
, error
, reply_dump_by_fd
);
1367 static int method_refuse_snapshot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1368 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Support for snapshots has been removed.");
1371 static int verify_run_space(const char *message
, sd_bus_error
*error
) {
1372 struct statvfs svfs
;
1375 if (statvfs("/run/systemd", &svfs
) < 0)
1376 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1378 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1380 if (available
< RELOAD_DISK_SPACE_MIN
) {
1381 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1382 return sd_bus_error_setf(error
,
1383 BUS_ERROR_DISK_FULL
,
1384 "%s, not enough space available on /run/systemd. "
1385 "Currently, %s are free, but a safety buffer of %s is enforced.",
1387 format_bytes(fb_available
, sizeof(fb_available
), available
),
1388 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1394 int verify_run_space_and_log(const char *message
) {
1395 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1398 r
= verify_run_space(message
, &error
);
1400 log_error_errno(r
, "%s", bus_error_message(&error
, r
));
1405 static int method_reload(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1406 Manager
*m
= userdata
;
1412 r
= verify_run_space("Refusing to reload", error
);
1416 r
= mac_selinux_access_check(message
, "reload", error
);
1420 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1424 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1426 /* Instead of sending the reply back right away, we just
1427 * remember that we need to and then send it after the reload
1428 * is finished. That way the caller knows when the reload
1431 assert(!m
->queued_message
);
1432 r
= sd_bus_message_new_method_return(message
, &m
->queued_message
);
1436 m
->exit_code
= MANAGER_RELOAD
;
1441 static int method_reexecute(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1442 Manager
*m
= userdata
;
1448 r
= verify_run_space("Refusing to reexecute", error
);
1452 r
= mac_selinux_access_check(message
, "reload", error
);
1456 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1460 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1462 /* We don't send a reply back here, the client should
1463 * just wait for us disconnecting. */
1465 m
->exit_code
= MANAGER_REEXECUTE
;
1469 static int method_exit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1470 Manager
*m
= userdata
;
1476 r
= mac_selinux_access_check(message
, "halt", error
);
1480 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1481 * we are running on the host. It will fall back on reboot() in
1482 * systemd-shutdown if it cannot do the exit() because it isn't a
1485 m
->exit_code
= MANAGER_EXIT
;
1487 return sd_bus_reply_method_return(message
, NULL
);
1490 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1491 Manager
*m
= userdata
;
1497 r
= mac_selinux_access_check(message
, "reboot", error
);
1501 if (!MANAGER_IS_SYSTEM(m
))
1502 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Reboot is only supported for system managers.");
1504 m
->exit_code
= MANAGER_REBOOT
;
1506 return sd_bus_reply_method_return(message
, NULL
);
1509 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1510 Manager
*m
= userdata
;
1516 r
= mac_selinux_access_check(message
, "halt", error
);
1520 if (!MANAGER_IS_SYSTEM(m
))
1521 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Powering off is only supported for system managers.");
1523 m
->exit_code
= MANAGER_POWEROFF
;
1525 return sd_bus_reply_method_return(message
, NULL
);
1528 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1529 Manager
*m
= userdata
;
1535 r
= mac_selinux_access_check(message
, "halt", error
);
1539 if (!MANAGER_IS_SYSTEM(m
))
1540 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Halt is only supported for system managers.");
1542 m
->exit_code
= MANAGER_HALT
;
1544 return sd_bus_reply_method_return(message
, NULL
);
1547 static int method_kexec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1548 Manager
*m
= userdata
;
1554 r
= mac_selinux_access_check(message
, "reboot", error
);
1558 if (!MANAGER_IS_SYSTEM(m
))
1559 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "KExec is only supported for system managers.");
1561 m
->exit_code
= MANAGER_KEXEC
;
1563 return sd_bus_reply_method_return(message
, NULL
);
1566 static int method_switch_root(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1567 char *ri
= NULL
, *rt
= NULL
;
1568 const char *root
, *init
;
1569 Manager
*m
= userdata
;
1570 struct statvfs svfs
;
1577 if (statvfs("/run/systemd", &svfs
) < 0)
1578 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1580 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1582 if (available
< RELOAD_DISK_SPACE_MIN
) {
1583 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1584 log_warning("Dangerously low amount of free space on /run/systemd, root switching operation might not complete successfuly. "
1585 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1586 format_bytes(fb_available
, sizeof(fb_available
), available
),
1587 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1590 r
= mac_selinux_access_check(message
, "reboot", error
);
1594 if (!MANAGER_IS_SYSTEM(m
))
1595 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Root switching is only supported by system manager.");
1597 r
= sd_bus_message_read(message
, "ss", &root
, &init
);
1602 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory may not be the empty string.");
1603 if (!path_is_absolute(root
))
1604 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root path '%s' is not absolute.", root
);
1605 if (path_equal(root
, "/"))
1606 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory cannot be the old root directory.");
1609 if (isempty(init
)) {
1610 r
= path_is_os_tree(root
);
1612 return sd_bus_error_set_errnof(error
, r
, "Failed to determine whether root path '%s' contains an OS tree: %m", root
);
1614 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
);
1616 _cleanup_free_
char *chased
= NULL
;
1618 if (!path_is_absolute(init
))
1619 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path to init binary '%s' not absolute.", init
);
1621 r
= chase_symlinks(init
, root
, CHASE_PREFIX_ROOT
|CHASE_TRAIL_SLASH
, &chased
);
1623 return sd_bus_error_set_errnof(error
, r
, "Could not resolve init executable %s: %m", init
);
1625 if (laccess(chased
, X_OK
) < 0) {
1626 if (errno
== EACCES
)
1627 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Init binary %s is not executable.", init
);
1629 return sd_bus_error_set_errnof(error
, r
, "Could not check whether init binary %s is executable: %m", init
);
1637 if (!isempty(init
)) {
1645 free(m
->switch_root
);
1646 m
->switch_root
= rt
;
1648 free(m
->switch_root_init
);
1649 m
->switch_root_init
= ri
;
1651 m
->exit_code
= MANAGER_SWITCH_ROOT
;
1653 return sd_bus_reply_method_return(message
, NULL
);
1656 static int method_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1657 _cleanup_strv_free_
char **plus
= NULL
;
1658 Manager
*m
= userdata
;
1664 r
= mac_selinux_access_check(message
, "reload", error
);
1668 r
= sd_bus_message_read_strv(message
, &plus
);
1671 if (!strv_env_is_valid(plus
))
1672 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1674 r
= bus_verify_set_environment_async(m
, message
, error
);
1678 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1680 r
= manager_environment_add(m
, NULL
, plus
);
1684 return sd_bus_reply_method_return(message
, NULL
);
1687 static int method_unset_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1688 _cleanup_strv_free_
char **minus
= NULL
;
1689 Manager
*m
= userdata
;
1695 r
= mac_selinux_access_check(message
, "reload", error
);
1699 r
= sd_bus_message_read_strv(message
, &minus
);
1703 if (!strv_env_name_or_assignment_is_valid(minus
))
1704 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1706 r
= bus_verify_set_environment_async(m
, message
, error
);
1710 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1712 r
= manager_environment_add(m
, minus
, NULL
);
1716 return sd_bus_reply_method_return(message
, NULL
);
1719 static int method_unset_and_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1720 _cleanup_strv_free_
char **minus
= NULL
, **plus
= NULL
;
1721 Manager
*m
= userdata
;
1727 r
= mac_selinux_access_check(message
, "reload", error
);
1731 r
= sd_bus_message_read_strv(message
, &minus
);
1735 r
= sd_bus_message_read_strv(message
, &plus
);
1739 if (!strv_env_name_or_assignment_is_valid(minus
))
1740 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1741 if (!strv_env_is_valid(plus
))
1742 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1744 r
= bus_verify_set_environment_async(m
, message
, error
);
1748 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1750 r
= manager_environment_add(m
, minus
, plus
);
1754 return sd_bus_reply_method_return(message
, NULL
);
1757 static int method_set_exit_code(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1758 Manager
*m
= userdata
;
1765 r
= mac_selinux_access_check(message
, "exit", error
);
1769 r
= sd_bus_message_read_basic(message
, 'y', &code
);
1773 if (MANAGER_IS_SYSTEM(m
) && detect_container() <= 0)
1774 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "ExitCode can only be set for user service managers or in containers.");
1776 m
->return_value
= code
;
1778 return sd_bus_reply_method_return(message
, NULL
);
1781 static int method_lookup_dynamic_user_by_name(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1782 Manager
*m
= userdata
;
1790 r
= sd_bus_message_read_basic(message
, 's', &name
);
1794 if (!MANAGER_IS_SYSTEM(m
))
1795 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1796 if (!valid_user_group_name(name
))
1797 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User name invalid: %s", name
);
1799 r
= dynamic_user_lookup_name(m
, name
, &uid
);
1801 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user %s does not exist.", name
);
1805 return sd_bus_reply_method_return(message
, "u", (uint32_t) uid
);
1808 static int method_lookup_dynamic_user_by_uid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1809 _cleanup_free_
char *name
= NULL
;
1810 Manager
*m
= userdata
;
1817 assert_cc(sizeof(uid
) == sizeof(uint32_t));
1818 r
= sd_bus_message_read_basic(message
, 'u', &uid
);
1822 if (!MANAGER_IS_SYSTEM(m
))
1823 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1824 if (!uid_is_valid(uid
))
1825 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User ID invalid: " UID_FMT
, uid
);
1827 r
= dynamic_user_lookup_uid(m
, uid
, &name
);
1829 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user ID " UID_FMT
" does not exist.", uid
);
1833 return sd_bus_reply_method_return(message
, "s", name
);
1836 static int method_get_dynamic_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1837 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1838 Manager
*m
= userdata
;
1846 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
1848 if (!MANAGER_IS_SYSTEM(m
))
1849 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1851 r
= sd_bus_message_new_method_return(message
, &reply
);
1855 r
= sd_bus_message_open_container(reply
, 'a', "(us)");
1859 HASHMAP_FOREACH(d
, m
->dynamic_users
, i
) {
1862 r
= dynamic_user_current(d
, &uid
);
1863 if (r
== -EAGAIN
) /* not realized yet? */
1866 return sd_bus_error_setf(error
, SD_BUS_ERROR_FAILED
, "Failed to lookup a dynamic user.");
1868 r
= sd_bus_message_append(reply
, "(us)", uid
, d
->name
);
1873 r
= sd_bus_message_close_container(reply
);
1877 return sd_bus_send(NULL
, reply
, NULL
);
1880 static int list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1881 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1882 Manager
*m
= userdata
;
1891 /* Anyone can call this method */
1893 r
= mac_selinux_access_check(message
, "status", error
);
1897 r
= sd_bus_message_new_method_return(message
, &reply
);
1901 h
= hashmap_new(&string_hash_ops
);
1905 r
= unit_file_get_list(m
->unit_file_scope
, NULL
, h
, states
, patterns
);
1909 r
= sd_bus_message_open_container(reply
, 'a', "(ss)");
1913 HASHMAP_FOREACH(item
, h
, i
) {
1915 r
= sd_bus_message_append(reply
, "(ss)", item
->path
, unit_file_state_to_string(item
->state
));
1920 unit_file_list_free(h
);
1922 r
= sd_bus_message_close_container(reply
);
1926 return sd_bus_send(NULL
, reply
, NULL
);
1929 unit_file_list_free(h
);
1933 static int method_list_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1934 return list_unit_files_by_patterns(message
, userdata
, error
, NULL
, NULL
);
1937 static int method_list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1938 _cleanup_strv_free_
char **states
= NULL
;
1939 _cleanup_strv_free_
char **patterns
= NULL
;
1942 r
= sd_bus_message_read_strv(message
, &states
);
1946 r
= sd_bus_message_read_strv(message
, &patterns
);
1950 return list_unit_files_by_patterns(message
, userdata
, error
, states
, patterns
);
1953 static int method_get_unit_file_state(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1954 Manager
*m
= userdata
;
1956 UnitFileState state
;
1962 /* Anyone can call this method */
1964 r
= mac_selinux_access_check(message
, "status", error
);
1968 r
= sd_bus_message_read(message
, "s", &name
);
1972 r
= unit_file_get_state(m
->unit_file_scope
, NULL
, name
, &state
);
1976 return sd_bus_reply_method_return(message
, "s", unit_file_state_to_string(state
));
1979 static int method_get_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1980 _cleanup_free_
char *default_target
= NULL
;
1981 Manager
*m
= userdata
;
1987 /* Anyone can call this method */
1989 r
= mac_selinux_access_check(message
, "status", error
);
1993 r
= unit_file_get_default(m
->unit_file_scope
, NULL
, &default_target
);
1997 return sd_bus_reply_method_return(message
, "s", default_target
);
2000 static int send_unit_files_changed(sd_bus
*bus
, void *userdata
) {
2001 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2006 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
2010 return sd_bus_send(bus
, message
, NULL
);
2013 /* Create an error reply, using the error information from changes[]
2014 * if possible, and fall back to generating an error from error code c.
2015 * The error message only describes the first error.
2017 * Coordinate with unit_file_dump_changes() in install.c.
2019 static int install_error(
2020 sd_bus_error
*error
,
2022 UnitFileChange
*changes
,
2028 for (i
= 0; i
< n_changes
; i
++)
2030 switch(changes
[i
].type
) {
2036 if (changes
[i
].source
)
2037 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
2038 "File %s already exists and is a symlink to %s.",
2039 changes
[i
].path
, changes
[i
].source
);
2041 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
2042 "File %s already exists.",
2047 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
,
2048 "Unit file %s is masked.", changes
[i
].path
);
2051 case -EADDRNOTAVAIL
:
2052 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_GENERATED
,
2053 "Unit %s is transient or generated.", changes
[i
].path
);
2057 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_LINKED
,
2058 "Refusing to operate on linked unit file %s", changes
[i
].path
);
2062 r
= sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit file %s does not exist.", changes
[i
].path
);
2066 r
= sd_bus_error_set_errnof(error
, changes
[i
].type
, "File %s: %m", changes
[i
].path
);
2070 r
= c
< 0 ? c
: -EINVAL
;
2073 unit_file_changes_free(changes
, n_changes
);
2077 static int reply_unit_file_changes_and_free(
2079 sd_bus_message
*message
,
2080 int carries_install_info
,
2081 UnitFileChange
*changes
,
2083 sd_bus_error
*error
) {
2085 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2086 bool bad
= false, good
= false;
2090 if (unit_file_changes_have_modification(changes
, n_changes
)) {
2091 r
= bus_foreach_bus(m
, NULL
, send_unit_files_changed
, NULL
);
2093 log_debug_errno(r
, "Failed to send UnitFilesChanged signal: %m");
2096 r
= sd_bus_message_new_method_return(message
, &reply
);
2100 if (carries_install_info
>= 0) {
2101 r
= sd_bus_message_append(reply
, "b", carries_install_info
);
2106 r
= sd_bus_message_open_container(reply
, 'a', "(sss)");
2110 for (i
= 0; i
< n_changes
; i
++) {
2112 if (changes
[i
].type
< 0) {
2117 r
= sd_bus_message_append(
2119 unit_file_change_type_to_string(changes
[i
].type
),
2128 /* If there was a failed change, and no successful change, then return the first failure as proper method call
2131 return install_error(error
, 0, changes
, n_changes
);
2133 r
= sd_bus_message_close_container(reply
);
2137 unit_file_changes_free(changes
, n_changes
);
2138 return sd_bus_send(NULL
, reply
, NULL
);
2141 unit_file_changes_free(changes
, n_changes
);
2145 static int method_enable_unit_files_generic(
2146 sd_bus_message
*message
,
2148 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, size_t *n_changes
),
2149 bool carries_install_info
,
2150 sd_bus_error
*error
) {
2152 _cleanup_strv_free_
char **l
= NULL
;
2153 UnitFileChange
*changes
= NULL
;
2154 size_t n_changes
= 0;
2155 UnitFileFlags flags
;
2156 int runtime
, force
, r
;
2161 r
= sd_bus_message_read_strv(message
, &l
);
2165 r
= sd_bus_message_read(message
, "bb", &runtime
, &force
);
2169 flags
= unit_file_bools_to_flags(runtime
, force
);
2171 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2175 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2177 r
= call(m
->unit_file_scope
, flags
, NULL
, l
, &changes
, &n_changes
);
2179 return install_error(error
, r
, changes
, n_changes
);
2181 return reply_unit_file_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
, error
);
2184 static int method_enable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2185 return method_enable_unit_files_generic(message
, userdata
, unit_file_enable
, true, error
);
2188 static int method_reenable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2189 return method_enable_unit_files_generic(message
, userdata
, unit_file_reenable
, true, error
);
2192 static int method_link_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2193 return method_enable_unit_files_generic(message
, userdata
, unit_file_link
, false, error
);
2196 static int unit_file_preset_without_mode(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char **files
, UnitFileChange
**changes
, size_t *n_changes
) {
2197 return unit_file_preset(scope
, flags
, root_dir
, files
, UNIT_FILE_PRESET_FULL
, changes
, n_changes
);
2200 static int method_preset_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2201 return method_enable_unit_files_generic(message
, userdata
, unit_file_preset_without_mode
, true, error
);
2204 static int method_mask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2205 return method_enable_unit_files_generic(message
, userdata
, unit_file_mask
, false, error
);
2208 static int method_preset_unit_files_with_mode(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2210 _cleanup_strv_free_
char **l
= NULL
;
2211 UnitFileChange
*changes
= NULL
;
2212 size_t n_changes
= 0;
2213 Manager
*m
= userdata
;
2214 UnitFilePresetMode mm
;
2215 int runtime
, force
, r
;
2216 UnitFileFlags flags
;
2222 r
= sd_bus_message_read_strv(message
, &l
);
2226 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2230 flags
= unit_file_bools_to_flags(runtime
, force
);
2233 mm
= UNIT_FILE_PRESET_FULL
;
2235 mm
= unit_file_preset_mode_from_string(mode
);
2240 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2244 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2246 r
= unit_file_preset(m
->unit_file_scope
, flags
, NULL
, l
, mm
, &changes
, &n_changes
);
2248 return install_error(error
, r
, changes
, n_changes
);
2250 return reply_unit_file_changes_and_free(m
, message
, r
, changes
, n_changes
, error
);
2253 static int method_disable_unit_files_generic(
2254 sd_bus_message
*message
,
2256 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, size_t *n_changes
),
2257 sd_bus_error
*error
) {
2259 _cleanup_strv_free_
char **l
= NULL
;
2260 UnitFileChange
*changes
= NULL
;
2261 size_t n_changes
= 0;
2267 r
= sd_bus_message_read_strv(message
, &l
);
2271 r
= sd_bus_message_read(message
, "b", &runtime
);
2275 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2279 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2281 r
= call(m
->unit_file_scope
, runtime
? UNIT_FILE_RUNTIME
: 0, NULL
, l
, &changes
, &n_changes
);
2283 return install_error(error
, r
, changes
, n_changes
);
2285 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2288 static int method_disable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2289 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, error
);
2292 static int method_unmask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2293 return method_disable_unit_files_generic(message
, userdata
, unit_file_unmask
, error
);
2296 static int method_revert_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2297 _cleanup_strv_free_
char **l
= NULL
;
2298 UnitFileChange
*changes
= NULL
;
2299 size_t n_changes
= 0;
2300 Manager
*m
= userdata
;
2306 r
= sd_bus_message_read_strv(message
, &l
);
2310 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2314 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2316 r
= unit_file_revert(m
->unit_file_scope
, NULL
, l
, &changes
, &n_changes
);
2318 return install_error(error
, r
, changes
, n_changes
);
2320 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2323 static int method_set_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2324 UnitFileChange
*changes
= NULL
;
2325 size_t n_changes
= 0;
2326 Manager
*m
= userdata
;
2333 r
= mac_selinux_access_check(message
, "enable", error
);
2337 r
= sd_bus_message_read(message
, "sb", &name
, &force
);
2341 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2345 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2347 r
= unit_file_set_default(m
->unit_file_scope
, force
? UNIT_FILE_FORCE
: 0, NULL
, name
, &changes
, &n_changes
);
2349 return install_error(error
, r
, changes
, n_changes
);
2351 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2354 static int method_preset_all_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2355 UnitFileChange
*changes
= NULL
;
2356 size_t n_changes
= 0;
2357 Manager
*m
= userdata
;
2358 UnitFilePresetMode mm
;
2360 UnitFileFlags flags
;
2361 int force
, runtime
, r
;
2366 r
= mac_selinux_access_check(message
, "enable", error
);
2370 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2374 flags
= unit_file_bools_to_flags(runtime
, force
);
2377 mm
= UNIT_FILE_PRESET_FULL
;
2379 mm
= unit_file_preset_mode_from_string(mode
);
2384 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2388 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2390 r
= unit_file_preset_all(m
->unit_file_scope
, flags
, NULL
, mm
, &changes
, &n_changes
);
2392 return install_error(error
, r
, changes
, n_changes
);
2394 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2397 static int method_add_dependency_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2398 _cleanup_strv_free_
char **l
= NULL
;
2399 Manager
*m
= userdata
;
2400 UnitFileChange
*changes
= NULL
;
2401 size_t n_changes
= 0;
2402 int runtime
, force
, r
;
2403 char *target
, *type
;
2405 UnitFileFlags flags
;
2410 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2414 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2416 r
= sd_bus_message_read_strv(message
, &l
);
2420 r
= sd_bus_message_read(message
, "ssbb", &target
, &type
, &runtime
, &force
);
2424 flags
= unit_file_bools_to_flags(runtime
, force
);
2426 dep
= unit_dependency_from_string(type
);
2430 r
= unit_file_add_dependency(m
->unit_file_scope
, flags
, NULL
, l
, target
, dep
, &changes
, &n_changes
);
2432 return install_error(error
, r
, changes
, n_changes
);
2434 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2437 static int method_get_unit_file_links(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2438 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2439 UnitFileChange
*changes
= NULL
;
2440 size_t n_changes
= 0, i
;
2441 UnitFileFlags flags
;
2446 r
= sd_bus_message_read(message
, "sb", &name
, &runtime
);
2450 r
= sd_bus_message_new_method_return(message
, &reply
);
2454 r
= sd_bus_message_open_container(reply
, SD_BUS_TYPE_ARRAY
, "s");
2458 p
= STRV_MAKE(name
);
2459 flags
= UNIT_FILE_DRY_RUN
|
2460 (runtime
? UNIT_FILE_RUNTIME
: 0);
2462 r
= unit_file_disable(UNIT_FILE_SYSTEM
, flags
, NULL
, p
, &changes
, &n_changes
);
2464 return log_error_errno(r
, "Failed to get file links for %s: %m", name
);
2466 for (i
= 0; i
< n_changes
; i
++)
2467 if (changes
[i
].type
== UNIT_FILE_UNLINK
) {
2468 r
= sd_bus_message_append(reply
, "s", changes
[i
].path
);
2473 r
= sd_bus_message_close_container(reply
);
2477 return sd_bus_send(NULL
, reply
, NULL
);
2480 static int method_get_job_waiting(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2481 Manager
*m
= userdata
;
2489 r
= sd_bus_message_read(message
, "u", &id
);
2493 j
= manager_get_job(m
, id
);
2495 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
2497 return bus_job_method_get_waiting_jobs(message
, j
, error
);
2500 const sd_bus_vtable bus_manager_vtable
[] = {
2501 SD_BUS_VTABLE_START(0),
2503 SD_BUS_PROPERTY("Version", "s", property_get_version
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2504 SD_BUS_PROPERTY("Features", "s", property_get_features
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2505 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2506 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2507 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2508 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FIRMWARE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2509 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_LOADER
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2510 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_KERNEL
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2511 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2512 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_USERSPACE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2513 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2514 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2515 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2516 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2517 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2518 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2519 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2520 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level
, property_set_log_level
, 0, 0),
2521 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target
, property_set_log_target
, 0, 0),
2522 SD_BUS_PROPERTY("NNames", "u", property_get_n_names
, 0, 0),
2523 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_n_failed_units
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2524 SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs
, 0, 0),
2525 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_installed_jobs
), 0),
2526 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_failed_jobs
), 0),
2527 SD_BUS_PROPERTY("Progress", "d", property_get_progress
, 0, 0),
2528 SD_BUS_PROPERTY("Environment", "as", NULL
, offsetof(Manager
, environment
), 0),
2529 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool
, offsetof(Manager
, confirm_spawn
), SD_BUS_VTABLE_PROPERTY_CONST
),
2530 SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool
, offsetof(Manager
, show_status
), SD_BUS_VTABLE_PROPERTY_CONST
),
2531 SD_BUS_PROPERTY("UnitPath", "as", NULL
, offsetof(Manager
, lookup_paths
.search_path
), SD_BUS_VTABLE_PROPERTY_CONST
),
2532 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2533 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2534 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec
, property_set_runtime_watchdog
, offsetof(Manager
, runtime_watchdog
), 0),
2535 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, shutdown_watchdog
), 0),
2536 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool
, bus_property_set_bool
, offsetof(Manager
, service_watchdogs
), 0),
2537 SD_BUS_PROPERTY("ControlGroup", "s", NULL
, offsetof(Manager
, cgroup_root
), 0),
2538 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state
, 0, 0),
2539 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned
, offsetof(Manager
, return_value
), 0),
2540 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timer_accuracy_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2541 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_start_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2542 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_stop_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2543 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_restart_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2544 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
),
2545 /* The following two items are obsolete alias */
2546 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2547 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2548 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned
, offsetof(Manager
, default_start_limit_burst
), SD_BUS_VTABLE_PROPERTY_CONST
),
2549 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_cpu_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2550 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_blockio_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2551 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_memory_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2552 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_tasks_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2553 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2554 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2555 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2556 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2557 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2558 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2559 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2560 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2561 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2562 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2563 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2564 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2565 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2566 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2567 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2568 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2569 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2570 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2571 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2572 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2573 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2574 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2575 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2576 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2577 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2578 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2579 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2580 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2581 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2582 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2583 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2584 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2585 SD_BUS_PROPERTY("DefaultTasksMax", "t", NULL
, offsetof(Manager
, default_tasks_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2586 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2588 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2589 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2590 SD_BUS_METHOD("GetUnitByInvocationID", "ay", "o", method_get_unit_by_invocation_id
, SD_BUS_VTABLE_UNPRIVILEGED
),
2591 SD_BUS_METHOD("GetUnitByControlGroup", "s", "o", method_get_unit_by_control_group
, SD_BUS_VTABLE_UNPRIVILEGED
),
2592 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2593 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2594 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace
, SD_BUS_VTABLE_UNPRIVILEGED
),
2595 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2596 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2597 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2598 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2599 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2600 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2601 SD_BUS_METHOD("KillUnit", "ssi", NULL
, method_kill_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2602 SD_BUS_METHOD("ResetFailedUnit", "s", NULL
, method_reset_failed_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2603 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL
, method_set_unit_properties
, SD_BUS_VTABLE_UNPRIVILEGED
),
2604 SD_BUS_METHOD("RefUnit", "s", NULL
, method_ref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2605 SD_BUS_METHOD("UnrefUnit", "s", NULL
, method_unref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2606 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2607 SD_BUS_METHOD("GetUnitProcesses", "s", "a(sus)", method_get_unit_processes
, SD_BUS_VTABLE_UNPRIVILEGED
),
2608 SD_BUS_METHOD("AttachProcessesToUnit", "ssau", NULL
, method_attach_processes_to_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2609 SD_BUS_METHOD("GetJob", "u", "o", method_get_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2610 SD_BUS_METHOD("GetJobAfter", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2611 SD_BUS_METHOD("GetJobBefore", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2612 SD_BUS_METHOD("CancelJob", "u", NULL
, method_cancel_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2613 SD_BUS_METHOD("ClearJobs", NULL
, NULL
, method_clear_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2614 SD_BUS_METHOD("ResetFailed", NULL
, NULL
, method_reset_failed
, SD_BUS_VTABLE_UNPRIVILEGED
),
2615 SD_BUS_METHOD("ListUnits", NULL
, "a(ssssssouso)", method_list_units
, SD_BUS_VTABLE_UNPRIVILEGED
),
2616 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered
, SD_BUS_VTABLE_UNPRIVILEGED
),
2617 SD_BUS_METHOD("ListUnitsByPatterns", "asas", "a(ssssssouso)", method_list_units_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2618 SD_BUS_METHOD("ListUnitsByNames", "as", "a(ssssssouso)", method_list_units_by_names
, SD_BUS_VTABLE_UNPRIVILEGED
),
2619 SD_BUS_METHOD("ListJobs", NULL
, "a(usssoo)", method_list_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2620 SD_BUS_METHOD("Subscribe", NULL
, NULL
, method_subscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2621 SD_BUS_METHOD("Unsubscribe", NULL
, NULL
, method_unsubscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2622 SD_BUS_METHOD("Dump", NULL
, "s", method_dump
, SD_BUS_VTABLE_UNPRIVILEGED
),
2623 SD_BUS_METHOD("DumpByFileDescriptor", NULL
, "h", method_dump_by_fd
, SD_BUS_VTABLE_UNPRIVILEGED
),
2624 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
2625 SD_BUS_METHOD("RemoveSnapshot", "s", NULL
, method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
|SD_BUS_VTABLE_HIDDEN
),
2626 SD_BUS_METHOD("Reload", NULL
, NULL
, method_reload
, SD_BUS_VTABLE_UNPRIVILEGED
),
2627 SD_BUS_METHOD("Reexecute", NULL
, NULL
, method_reexecute
, SD_BUS_VTABLE_UNPRIVILEGED
),
2628 SD_BUS_METHOD("Exit", NULL
, NULL
, method_exit
, 0),
2629 SD_BUS_METHOD("Reboot", NULL
, NULL
, method_reboot
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2630 SD_BUS_METHOD("PowerOff", NULL
, NULL
, method_poweroff
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2631 SD_BUS_METHOD("Halt", NULL
, NULL
, method_halt
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2632 SD_BUS_METHOD("KExec", NULL
, NULL
, method_kexec
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2633 SD_BUS_METHOD("SwitchRoot", "ss", NULL
, method_switch_root
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2634 SD_BUS_METHOD("SetEnvironment", "as", NULL
, method_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2635 SD_BUS_METHOD("UnsetEnvironment", "as", NULL
, method_unset_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2636 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL
, method_unset_and_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2637 SD_BUS_METHOD("ListUnitFiles", NULL
, "a(ss)", method_list_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2638 SD_BUS_METHOD("ListUnitFilesByPatterns", "asas", "a(ss)", method_list_unit_files_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2639 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state
, SD_BUS_VTABLE_UNPRIVILEGED
),
2640 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2641 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2642 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2643 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2644 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2645 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode
, SD_BUS_VTABLE_UNPRIVILEGED
),
2646 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2647 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2648 SD_BUS_METHOD("RevertUnitFiles", "as", "a(sss)", method_revert_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2649 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2650 SD_BUS_METHOD("GetDefaultTarget", NULL
, "s", method_get_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2651 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2652 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2653 SD_BUS_METHOD("GetUnitFileLinks", "sb", "as", method_get_unit_file_links
, SD_BUS_VTABLE_UNPRIVILEGED
),
2654 SD_BUS_METHOD("SetExitCode", "y", NULL
, method_set_exit_code
, SD_BUS_VTABLE_UNPRIVILEGED
),
2655 SD_BUS_METHOD("LookupDynamicUserByName", "s", "u", method_lookup_dynamic_user_by_name
, SD_BUS_VTABLE_UNPRIVILEGED
),
2656 SD_BUS_METHOD("LookupDynamicUserByUID", "u", "s", method_lookup_dynamic_user_by_uid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2657 SD_BUS_METHOD("GetDynamicUsers", NULL
, "a(us)", method_get_dynamic_users
, SD_BUS_VTABLE_UNPRIVILEGED
),
2659 SD_BUS_SIGNAL("UnitNew", "so", 0),
2660 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2661 SD_BUS_SIGNAL("JobNew", "uos", 0),
2662 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2663 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2664 SD_BUS_SIGNAL("UnitFilesChanged", NULL
, 0),
2665 SD_BUS_SIGNAL("Reloading", "b", 0),
2670 static int send_finished(sd_bus
*bus
, void *userdata
) {
2671 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2672 usec_t
*times
= userdata
;
2678 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2682 r
= sd_bus_message_append(message
, "tttttt", times
[0], times
[1], times
[2], times
[3], times
[4], times
[5]);
2686 return sd_bus_send(bus
, message
, NULL
);
2689 void bus_manager_send_finished(
2691 usec_t firmware_usec
,
2695 usec_t userspace_usec
,
2696 usec_t total_usec
) {
2702 r
= bus_foreach_bus(
2715 log_debug_errno(r
, "Failed to send finished signal: %m");
2718 static int send_reloading(sd_bus
*bus
, void *userdata
) {
2719 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2724 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2728 r
= sd_bus_message_append(message
, "b", PTR_TO_INT(userdata
));
2732 return sd_bus_send(bus
, message
, NULL
);
2735 void bus_manager_send_reloading(Manager
*m
, bool active
) {
2740 r
= bus_foreach_bus(m
, NULL
, send_reloading
, INT_TO_PTR(active
));
2742 log_debug_errno(r
, "Failed to send reloading signal: %m");
2745 static int send_changed_signal(sd_bus
*bus
, void *userdata
) {
2748 return sd_bus_emit_properties_changed_strv(bus
,
2749 "/org/freedesktop/systemd1",
2750 "org.freedesktop.systemd1.Manager",
2754 void bus_manager_send_change_signal(Manager
*m
) {
2759 r
= bus_foreach_bus(m
, NULL
, send_changed_signal
, NULL
);
2761 log_debug_errno(r
, "Failed to send manager change signal: %m");