1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include <sys/prctl.h>
26 #include "alloc-util.h"
27 #include "architecture.h"
29 #include "bus-common-errors.h"
30 #include "clock-util.h"
31 #include "dbus-execute.h"
33 #include "dbus-manager.h"
34 #include "dbus-unit.h"
39 #include "formats-util.h"
42 #include "path-util.h"
43 #include "selinux-access.h"
44 #include "stat-util.h"
45 #include "string-util.h"
47 #include "syslog-util.h"
51 static int property_get_version(
54 const char *interface
,
56 sd_bus_message
*reply
,
58 sd_bus_error
*error
) {
63 return sd_bus_message_append(reply
, "s", PACKAGE_VERSION
);
66 static int property_get_features(
69 const char *interface
,
71 sd_bus_message
*reply
,
73 sd_bus_error
*error
) {
78 return sd_bus_message_append(reply
, "s", SYSTEMD_FEATURES
);
81 static int property_get_virtualization(
84 const char *interface
,
86 sd_bus_message
*reply
,
88 sd_bus_error
*error
) {
95 v
= detect_virtualization();
97 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
99 * https://github.com/systemd/systemd/issues/1423
102 return sd_bus_message_append(
104 v
== VIRTUALIZATION_NONE
? "" : virtualization_to_string(v
));
107 static int property_get_architecture(
110 const char *interface
,
111 const char *property
,
112 sd_bus_message
*reply
,
114 sd_bus_error
*error
) {
119 return sd_bus_message_append(reply
, "s", architecture_to_string(uname_architecture()));
122 static int property_get_tainted(
125 const char *interface
,
126 const char *property
,
127 sd_bus_message
*reply
,
129 sd_bus_error
*error
) {
131 char buf
[sizeof("split-usr:cgroups-missing:local-hwclock:")] = "", *e
= buf
;
132 Manager
*m
= userdata
;
139 e
= stpcpy(e
, "split-usr:");
141 if (access("/proc/cgroups", F_OK
) < 0)
142 e
= stpcpy(e
, "cgroups-missing:");
144 if (clock_is_localtime() > 0)
145 e
= stpcpy(e
, "local-hwclock:");
147 /* remove the last ':' */
151 return sd_bus_message_append(reply
, "s", buf
);
154 static int property_get_log_target(
157 const char *interface
,
158 const char *property
,
159 sd_bus_message
*reply
,
161 sd_bus_error
*error
) {
166 return sd_bus_message_append(reply
, "s", log_target_to_string(log_get_target()));
169 static int property_set_log_target(
172 const char *interface
,
173 const char *property
,
174 sd_bus_message
*value
,
176 sd_bus_error
*error
) {
184 r
= sd_bus_message_read(value
, "s", &t
);
188 return log_set_target_from_string(t
);
191 static int property_get_log_level(
194 const char *interface
,
195 const char *property
,
196 sd_bus_message
*reply
,
198 sd_bus_error
*error
) {
200 _cleanup_free_
char *t
= NULL
;
206 r
= log_level_to_string_alloc(log_get_max_level(), &t
);
210 return sd_bus_message_append(reply
, "s", t
);
213 static int property_set_log_level(
216 const char *interface
,
217 const char *property
,
218 sd_bus_message
*value
,
220 sd_bus_error
*error
) {
228 r
= sd_bus_message_read(value
, "s", &t
);
232 r
= log_set_max_level_from_string(t
);
234 log_info("Setting log level to %s.", t
);
238 static int property_get_n_names(
241 const char *interface
,
242 const char *property
,
243 sd_bus_message
*reply
,
245 sd_bus_error
*error
) {
247 Manager
*m
= userdata
;
253 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->units
));
256 static int property_get_n_failed_units(
259 const char *interface
,
260 const char *property
,
261 sd_bus_message
*reply
,
263 sd_bus_error
*error
) {
265 Manager
*m
= userdata
;
271 return sd_bus_message_append(reply
, "u", (uint32_t) set_size(m
->failed_units
));
274 static int property_get_n_jobs(
277 const char *interface
,
278 const char *property
,
279 sd_bus_message
*reply
,
281 sd_bus_error
*error
) {
283 Manager
*m
= userdata
;
289 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->jobs
));
292 static int property_get_progress(
295 const char *interface
,
296 const char *property
,
297 sd_bus_message
*reply
,
299 sd_bus_error
*error
) {
301 Manager
*m
= userdata
;
308 if (dual_timestamp_is_set(&m
->finish_timestamp
))
311 d
= 1.0 - ((double) hashmap_size(m
->jobs
) / (double) m
->n_installed_jobs
);
313 return sd_bus_message_append(reply
, "d", d
);
316 static int property_get_system_state(
319 const char *interface
,
320 const char *property
,
321 sd_bus_message
*reply
,
323 sd_bus_error
*error
) {
325 Manager
*m
= userdata
;
331 return sd_bus_message_append(reply
, "s", manager_state_to_string(manager_state(m
)));
334 static int property_set_runtime_watchdog(
337 const char *interface
,
338 const char *property
,
339 sd_bus_message
*value
,
341 sd_bus_error
*error
) {
343 usec_t
*t
= userdata
;
349 assert_cc(sizeof(usec_t
) == sizeof(uint64_t));
351 r
= sd_bus_message_read(value
, "t", t
);
355 return watchdog_set_timeout(t
);
358 static int property_get_timer_slack_nsec(
361 const char *interface
,
362 const char *property
,
363 sd_bus_message
*reply
,
365 sd_bus_error
*error
) {
370 return sd_bus_message_append(reply
, "t", (uint64_t) prctl(PR_GET_TIMERSLACK
));
373 static int method_get_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
374 _cleanup_free_
char *path
= NULL
;
375 Manager
*m
= userdata
;
383 /* Anyone can call this method */
385 r
= sd_bus_message_read(message
, "s", &name
);
390 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
393 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
397 r
= sd_bus_creds_get_pid(creds
, &pid
);
401 u
= manager_get_unit_by_pid(m
, pid
);
403 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
405 u
= manager_get_unit(m
, name
);
407 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
410 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
414 path
= unit_dbus_path(u
);
418 return sd_bus_reply_method_return(message
, "o", path
);
421 static int method_get_unit_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
422 _cleanup_free_
char *path
= NULL
;
423 Manager
*m
= userdata
;
431 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
433 /* Anyone can call this method */
435 r
= sd_bus_message_read(message
, "u", &pid
);
439 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid PID " PID_FMT
, pid
);
442 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
444 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
448 r
= sd_bus_creds_get_pid(creds
, &pid
);
453 u
= manager_get_unit_by_pid(m
, pid
);
455 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_PID
, "PID "PID_FMT
" does not belong to any loaded unit.", pid
);
457 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
461 path
= unit_dbus_path(u
);
465 return sd_bus_reply_method_return(message
, "o", path
);
468 static int method_load_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
469 _cleanup_free_
char *path
= NULL
;
470 Manager
*m
= userdata
;
478 /* Anyone can call this method */
480 r
= sd_bus_message_read(message
, "s", &name
);
485 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
488 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
492 r
= sd_bus_creds_get_pid(creds
, &pid
);
496 u
= manager_get_unit_by_pid(m
, pid
);
498 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
500 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
505 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
509 path
= unit_dbus_path(u
);
513 return sd_bus_reply_method_return(message
, "o", path
);
516 static int method_start_unit_generic(sd_bus_message
*message
, Manager
*m
, JobType job_type
, bool reload_if_possible
, sd_bus_error
*error
) {
524 r
= sd_bus_message_read(message
, "s", &name
);
528 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
532 return bus_unit_method_start_generic(message
, u
, job_type
, reload_if_possible
, error
);
535 static int method_start_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
536 return method_start_unit_generic(message
, userdata
, JOB_START
, false, error
);
539 static int method_stop_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
540 return method_start_unit_generic(message
, userdata
, JOB_STOP
, false, error
);
543 static int method_reload_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
544 return method_start_unit_generic(message
, userdata
, JOB_RELOAD
, false, error
);
547 static int method_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
548 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, false, error
);
551 static int method_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
552 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, false, error
);
555 static int method_reload_or_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
556 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, true, error
);
559 static int method_reload_or_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
560 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, true, error
);
563 static int method_start_unit_replace(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
564 Manager
*m
= userdata
;
565 const char *old_name
;
572 r
= sd_bus_message_read(message
, "s", &old_name
);
576 u
= manager_get_unit(m
, old_name
);
577 if (!u
|| !u
->job
|| u
->job
->type
!= JOB_START
)
578 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "No job queued for unit %s", old_name
);
580 return method_start_unit_generic(message
, m
, JOB_START
, false, error
);
583 static int method_kill_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
584 Manager
*m
= userdata
;
592 r
= sd_bus_message_read(message
, "s", &name
);
596 u
= manager_get_unit(m
, name
);
598 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s is not loaded.", name
);
600 return bus_unit_method_kill(message
, u
, error
);
603 static int method_reset_failed_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
604 Manager
*m
= userdata
;
612 r
= sd_bus_message_read(message
, "s", &name
);
616 u
= manager_get_unit(m
, name
);
618 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s is not loaded.", name
);
620 return bus_unit_method_reset_failed(message
, u
, error
);
623 static int method_set_unit_properties(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
624 Manager
*m
= userdata
;
632 r
= sd_bus_message_read(message
, "s", &name
);
636 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
640 r
= bus_unit_check_load_state(u
, error
);
644 return bus_unit_method_set_properties(message
, u
, error
);
647 static int transient_unit_from_message(
649 sd_bus_message
*message
,
652 sd_bus_error
*error
) {
662 t
= unit_name_to_type(name
);
664 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid unit name or type.");
666 if (!unit_vtable
[t
]->can_transient
)
667 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unit type %s does not support transient units.", unit_type_to_string(t
));
669 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
673 if (!unit_is_pristine(u
))
674 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
, "Unit %s already exists.", name
);
676 /* OK, the unit failed to load and is unreferenced, now let's
677 * fill in the transient data instead */
678 r
= unit_make_transient(u
);
682 /* Set our properties */
683 r
= bus_unit_set_properties(u
, message
, UNIT_RUNTIME
, false, error
);
687 /* Now load the missing bits of the unit we just created */
688 manager_dispatch_load_queue(m
);
695 static int transient_aux_units_from_message(
697 sd_bus_message
*message
,
698 sd_bus_error
*error
) {
705 r
= sd_bus_message_enter_container(message
, 'a', "(sa(sv))");
709 while ((r
= sd_bus_message_enter_container(message
, 'r', "sa(sv)")) > 0) {
710 const char *name
= NULL
;
713 r
= sd_bus_message_read(message
, "s", &name
);
717 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
721 r
= sd_bus_message_exit_container(message
);
728 r
= sd_bus_message_exit_container(message
);
735 static int method_start_transient_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
736 const char *name
, *smode
;
737 Manager
*m
= userdata
;
745 r
= mac_selinux_access_check(message
, "start", error
);
749 r
= sd_bus_message_read(message
, "ss", &name
, &smode
);
753 mode
= job_mode_from_string(smode
);
755 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Job mode %s is invalid.", smode
);
757 r
= bus_verify_manage_units_async(m
, message
, error
);
761 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
763 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
767 r
= transient_aux_units_from_message(m
, message
, error
);
771 /* Finally, start it */
772 return bus_unit_queue_job(message
, u
, JOB_START
, mode
, false, error
);
775 static int method_get_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
776 _cleanup_free_
char *path
= NULL
;
777 Manager
*m
= userdata
;
785 /* Anyone can call this method */
787 r
= sd_bus_message_read(message
, "u", &id
);
791 j
= manager_get_job(m
, id
);
793 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
795 r
= mac_selinux_unit_access_check(j
->unit
, message
, "status", error
);
799 path
= job_dbus_path(j
);
803 return sd_bus_reply_method_return(message
, "o", path
);
806 static int method_cancel_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
807 Manager
*m
= userdata
;
815 r
= sd_bus_message_read(message
, "u", &id
);
819 j
= manager_get_job(m
, id
);
821 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
823 return bus_job_method_cancel(message
, j
, error
);
826 static int method_clear_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
827 Manager
*m
= userdata
;
833 r
= mac_selinux_access_check(message
, "reload", error
);
837 r
= bus_verify_manage_units_async(m
, message
, error
);
841 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
843 manager_clear_jobs(m
);
845 return sd_bus_reply_method_return(message
, NULL
);
848 static int method_reset_failed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
849 Manager
*m
= userdata
;
855 r
= mac_selinux_access_check(message
, "reload", error
);
859 r
= bus_verify_manage_units_async(m
, message
, error
);
863 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
865 manager_reset_failed(m
);
867 return sd_bus_reply_method_return(message
, NULL
);
870 static int list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
) {
871 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
872 Manager
*m
= userdata
;
881 /* Anyone can call this method */
883 r
= mac_selinux_access_check(message
, "status", error
);
887 r
= sd_bus_message_new_method_return(message
, &reply
);
891 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
895 HASHMAP_FOREACH_KEY(u
, k
, m
->units
, i
) {
896 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
902 following
= unit_following(u
);
904 if (!strv_isempty(states
) &&
905 !strv_contains(states
, unit_load_state_to_string(u
->load_state
)) &&
906 !strv_contains(states
, unit_active_state_to_string(unit_active_state(u
))) &&
907 !strv_contains(states
, unit_sub_state_to_string(u
)))
910 unit_path
= unit_dbus_path(u
);
915 job_path
= job_dbus_path(u
->job
);
920 r
= sd_bus_message_append(
921 reply
, "(ssssssouso)",
924 unit_load_state_to_string(u
->load_state
),
925 unit_active_state_to_string(unit_active_state(u
)),
926 unit_sub_state_to_string(u
),
927 following
? following
->id
: "",
929 u
->job
? u
->job
->id
: 0,
930 u
->job
? job_type_to_string(u
->job
->type
) : "",
931 job_path
? job_path
: "/");
936 r
= sd_bus_message_close_container(reply
);
940 return sd_bus_send(NULL
, reply
, NULL
);
943 static int method_list_units(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
944 return list_units_filtered(message
, userdata
, error
, NULL
);
947 static int method_list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
948 _cleanup_strv_free_
char **states
= NULL
;
951 r
= sd_bus_message_read_strv(message
, &states
);
955 return list_units_filtered(message
, userdata
, error
, states
);
958 static int method_list_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
959 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
960 Manager
*m
= userdata
;
968 /* Anyone can call this method */
970 r
= mac_selinux_access_check(message
, "status", error
);
974 r
= sd_bus_message_new_method_return(message
, &reply
);
978 r
= sd_bus_message_open_container(reply
, 'a', "(usssoo)");
982 HASHMAP_FOREACH(j
, m
->jobs
, i
) {
983 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
985 job_path
= job_dbus_path(j
);
989 unit_path
= unit_dbus_path(j
->unit
);
993 r
= sd_bus_message_append(
997 job_type_to_string(j
->type
),
998 job_state_to_string(j
->state
),
1005 r
= sd_bus_message_close_container(reply
);
1009 return sd_bus_send(NULL
, reply
, NULL
);
1012 static int method_subscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1013 Manager
*m
= userdata
;
1019 /* Anyone can call this method */
1021 r
= mac_selinux_access_check(message
, "status", error
);
1025 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1027 /* Note that direct bus connection subscribe by
1028 * default, we only track peers on the API bus here */
1030 if (!m
->subscribed
) {
1031 r
= sd_bus_track_new(sd_bus_message_get_bus(message
), &m
->subscribed
, NULL
, NULL
);
1036 r
= sd_bus_track_add_sender(m
->subscribed
, message
);
1040 return sd_bus_error_setf(error
, BUS_ERROR_ALREADY_SUBSCRIBED
, "Client is already subscribed.");
1043 return sd_bus_reply_method_return(message
, NULL
);
1046 static int method_unsubscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1047 Manager
*m
= userdata
;
1053 /* Anyone can call this method */
1055 r
= mac_selinux_access_check(message
, "status", error
);
1059 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1060 r
= sd_bus_track_remove_sender(m
->subscribed
, message
);
1064 return sd_bus_error_setf(error
, BUS_ERROR_NOT_SUBSCRIBED
, "Client is not subscribed.");
1067 return sd_bus_reply_method_return(message
, NULL
);
1070 static int method_dump(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1071 _cleanup_free_
char *dump
= NULL
;
1072 _cleanup_fclose_
FILE *f
= NULL
;
1073 Manager
*m
= userdata
;
1080 /* Anyone can call this method */
1082 r
= mac_selinux_access_check(message
, "status", error
);
1086 f
= open_memstream(&dump
, &size
);
1090 manager_dump_units(m
, f
, NULL
);
1091 manager_dump_jobs(m
, f
, NULL
);
1093 r
= fflush_and_check(f
);
1097 return sd_bus_reply_method_return(message
, "s", dump
);
1100 static int method_refuse_snapshot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1101 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Support for snapshots has been removed.");
1104 static int method_reload(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1105 Manager
*m
= userdata
;
1111 r
= mac_selinux_access_check(message
, "reload", error
);
1115 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1119 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1121 /* Instead of sending the reply back right away, we just
1122 * remember that we need to and then send it after the reload
1123 * is finished. That way the caller knows when the reload
1126 assert(!m
->queued_message
);
1127 r
= sd_bus_message_new_method_return(message
, &m
->queued_message
);
1131 m
->exit_code
= MANAGER_RELOAD
;
1136 static int method_reexecute(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1137 Manager
*m
= userdata
;
1143 r
= mac_selinux_access_check(message
, "reload", error
);
1147 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1151 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1153 /* We don't send a reply back here, the client should
1154 * just wait for us disconnecting. */
1156 m
->exit_code
= MANAGER_REEXECUTE
;
1160 static int method_exit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1161 Manager
*m
= userdata
;
1167 r
= mac_selinux_access_check(message
, "halt", error
);
1171 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1172 * we are running on the host. It will fall back on reboot() in
1173 * systemd-shutdown if it cannot do the exit() because it isn't a
1176 m
->exit_code
= MANAGER_EXIT
;
1178 return sd_bus_reply_method_return(message
, NULL
);
1181 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1182 Manager
*m
= userdata
;
1188 r
= mac_selinux_access_check(message
, "reboot", error
);
1192 if (m
->running_as
!= MANAGER_SYSTEM
)
1193 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Reboot is only supported for system managers.");
1195 m
->exit_code
= MANAGER_REBOOT
;
1197 return sd_bus_reply_method_return(message
, NULL
);
1200 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1201 Manager
*m
= userdata
;
1207 r
= mac_selinux_access_check(message
, "halt", error
);
1211 if (m
->running_as
!= MANAGER_SYSTEM
)
1212 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Powering off is only supported for system managers.");
1214 m
->exit_code
= MANAGER_POWEROFF
;
1216 return sd_bus_reply_method_return(message
, NULL
);
1219 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1220 Manager
*m
= userdata
;
1226 r
= mac_selinux_access_check(message
, "halt", error
);
1230 if (m
->running_as
!= MANAGER_SYSTEM
)
1231 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Halt is only supported for system managers.");
1233 m
->exit_code
= MANAGER_HALT
;
1235 return sd_bus_reply_method_return(message
, NULL
);
1238 static int method_kexec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1239 Manager
*m
= userdata
;
1245 r
= mac_selinux_access_check(message
, "reboot", error
);
1249 if (m
->running_as
!= MANAGER_SYSTEM
)
1250 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "KExec is only supported for system managers.");
1252 m
->exit_code
= MANAGER_KEXEC
;
1254 return sd_bus_reply_method_return(message
, NULL
);
1257 static int method_switch_root(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1258 char *ri
= NULL
, *rt
= NULL
;
1259 const char *root
, *init
;
1260 Manager
*m
= userdata
;
1266 r
= mac_selinux_access_check(message
, "reboot", error
);
1270 if (m
->running_as
!= MANAGER_SYSTEM
)
1271 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Root switching is only supported by system manager.");
1273 r
= sd_bus_message_read(message
, "ss", &root
, &init
);
1277 if (path_equal(root
, "/") || !path_is_absolute(root
))
1278 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid switch root path %s", root
);
1281 if (isempty(init
)) {
1282 if (!path_is_os_tree(root
))
1283 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
);
1285 _cleanup_free_
char *p
= NULL
;
1287 if (!path_is_absolute(init
))
1288 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid init path %s", init
);
1290 p
= strappend(root
, init
);
1294 if (access(p
, X_OK
) < 0)
1295 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Specified init binary %s does not exist.", p
);
1302 if (!isempty(init
)) {
1310 free(m
->switch_root
);
1311 m
->switch_root
= rt
;
1313 free(m
->switch_root_init
);
1314 m
->switch_root_init
= ri
;
1316 m
->exit_code
= MANAGER_SWITCH_ROOT
;
1318 return sd_bus_reply_method_return(message
, NULL
);
1321 static int method_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1322 _cleanup_strv_free_
char **plus
= NULL
;
1323 Manager
*m
= userdata
;
1329 r
= mac_selinux_access_check(message
, "reload", error
);
1333 r
= sd_bus_message_read_strv(message
, &plus
);
1336 if (!strv_env_is_valid(plus
))
1337 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1339 r
= bus_verify_set_environment_async(m
, message
, error
);
1343 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1345 r
= manager_environment_add(m
, NULL
, plus
);
1349 return sd_bus_reply_method_return(message
, NULL
);
1352 static int method_unset_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1353 _cleanup_strv_free_
char **minus
= NULL
;
1354 Manager
*m
= userdata
;
1360 r
= mac_selinux_access_check(message
, "reload", error
);
1364 r
= sd_bus_message_read_strv(message
, &minus
);
1368 if (!strv_env_name_or_assignment_is_valid(minus
))
1369 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1371 r
= bus_verify_set_environment_async(m
, message
, error
);
1375 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1377 r
= manager_environment_add(m
, minus
, NULL
);
1381 return sd_bus_reply_method_return(message
, NULL
);
1384 static int method_unset_and_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1385 _cleanup_strv_free_
char **minus
= NULL
, **plus
= NULL
;
1386 Manager
*m
= userdata
;
1392 r
= mac_selinux_access_check(message
, "reload", error
);
1396 r
= sd_bus_message_read_strv(message
, &minus
);
1400 r
= sd_bus_message_read_strv(message
, &plus
);
1404 if (!strv_env_name_or_assignment_is_valid(minus
))
1405 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1406 if (!strv_env_is_valid(plus
))
1407 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1409 r
= bus_verify_set_environment_async(m
, message
, error
);
1413 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1415 r
= manager_environment_add(m
, minus
, plus
);
1419 return sd_bus_reply_method_return(message
, NULL
);
1422 static int method_set_exit_code(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1424 Manager
*m
= userdata
;
1430 r
= mac_selinux_access_check(message
, "exit", error
);
1434 r
= sd_bus_message_read_basic(message
, 'y', &code
);
1438 if (m
->running_as
== MANAGER_SYSTEM
&& detect_container() <= 0)
1439 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "ExitCode can only be set for user service managers or in containers.");
1441 m
->return_value
= code
;
1443 return sd_bus_reply_method_return(message
, NULL
);
1446 static int method_list_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1447 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1448 Manager
*m
= userdata
;
1457 /* Anyone can call this method */
1459 r
= mac_selinux_access_check(message
, "status", error
);
1463 r
= sd_bus_message_new_method_return(message
, &reply
);
1467 h
= hashmap_new(&string_hash_ops
);
1471 r
= unit_file_get_list(m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
, NULL
, h
);
1475 r
= sd_bus_message_open_container(reply
, 'a', "(ss)");
1479 HASHMAP_FOREACH(item
, h
, i
) {
1481 r
= sd_bus_message_append(reply
, "(ss)", item
->path
, unit_file_state_to_string(item
->state
));
1486 unit_file_list_free(h
);
1488 r
= sd_bus_message_close_container(reply
);
1492 return sd_bus_send(NULL
, reply
, NULL
);
1495 unit_file_list_free(h
);
1499 static int method_get_unit_file_state(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1500 Manager
*m
= userdata
;
1502 UnitFileState state
;
1503 UnitFileScope scope
;
1509 /* Anyone can call this method */
1511 r
= mac_selinux_access_check(message
, "status", error
);
1515 r
= sd_bus_message_read(message
, "s", &name
);
1519 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1521 r
= unit_file_get_state(scope
, NULL
, name
, &state
);
1525 return sd_bus_reply_method_return(message
, "s", unit_file_state_to_string(state
));
1528 static int method_get_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1529 _cleanup_free_
char *default_target
= NULL
;
1530 Manager
*m
= userdata
;
1531 UnitFileScope scope
;
1537 /* Anyone can call this method */
1539 r
= mac_selinux_access_check(message
, "status", error
);
1543 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1545 r
= unit_file_get_default(scope
, NULL
, &default_target
);
1549 return sd_bus_reply_method_return(message
, "s", default_target
);
1552 static int send_unit_files_changed(sd_bus
*bus
, void *userdata
) {
1553 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
1558 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1562 return sd_bus_send(bus
, message
, NULL
);
1565 static int reply_unit_file_changes_and_free(
1567 sd_bus_message
*message
,
1568 int carries_install_info
,
1569 UnitFileChange
*changes
,
1570 unsigned n_changes
) {
1572 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1576 if (n_changes
> 0) {
1577 r
= bus_foreach_bus(m
, NULL
, send_unit_files_changed
, NULL
);
1579 log_debug_errno(r
, "Failed to send UnitFilesChanged signal: %m");
1582 r
= sd_bus_message_new_method_return(message
, &reply
);
1586 if (carries_install_info
>= 0) {
1587 r
= sd_bus_message_append(reply
, "b", carries_install_info
);
1592 r
= sd_bus_message_open_container(reply
, 'a', "(sss)");
1596 for (i
= 0; i
< n_changes
; i
++) {
1597 r
= sd_bus_message_append(
1599 unit_file_change_type_to_string(changes
[i
].type
),
1606 r
= sd_bus_message_close_container(reply
);
1610 unit_file_changes_free(changes
, n_changes
);
1611 return sd_bus_send(NULL
, reply
, NULL
);
1614 unit_file_changes_free(changes
, n_changes
);
1618 static int method_enable_unit_files_generic(
1619 sd_bus_message
*message
,
1622 int (*call
)(UnitFileScope scope
, bool runtime
, const char *root_dir
, char *files
[], bool force
, UnitFileChange
**changes
, unsigned *n_changes
),
1623 bool carries_install_info
,
1624 sd_bus_error
*error
) {
1626 _cleanup_strv_free_
char **l
= NULL
;
1627 UnitFileChange
*changes
= NULL
;
1628 unsigned n_changes
= 0;
1629 UnitFileScope scope
;
1630 int runtime
, force
, r
;
1635 r
= sd_bus_message_read_strv(message
, &l
);
1639 r
= sd_bus_message_read(message
, "bb", &runtime
, &force
);
1643 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1647 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1649 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1651 r
= call(scope
, runtime
, NULL
, l
, force
, &changes
, &n_changes
);
1652 if (r
== -ESHUTDOWN
)
1653 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
, "Unit file is masked");
1657 return reply_unit_file_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
);
1660 static int method_enable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1661 return method_enable_unit_files_generic(message
, userdata
, "enable", unit_file_enable
, true, error
);
1664 static int method_reenable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1665 return method_enable_unit_files_generic(message
, userdata
, "enable", unit_file_reenable
, true, error
);
1668 static int method_link_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1669 return method_enable_unit_files_generic(message
, userdata
, "enable", unit_file_link
, false, error
);
1672 static int unit_file_preset_without_mode(UnitFileScope scope
, bool runtime
, const char *root_dir
, char **files
, bool force
, UnitFileChange
**changes
, unsigned *n_changes
) {
1673 return unit_file_preset(scope
, runtime
, root_dir
, files
, UNIT_FILE_PRESET_FULL
, force
, changes
, n_changes
);
1676 static int method_preset_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1677 return method_enable_unit_files_generic(message
, userdata
, "enable", unit_file_preset_without_mode
, true, error
);
1680 static int method_mask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1681 return method_enable_unit_files_generic(message
, userdata
, "disable", unit_file_mask
, false, error
);
1684 static int method_preset_unit_files_with_mode(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1686 _cleanup_strv_free_
char **l
= NULL
;
1687 UnitFileChange
*changes
= NULL
;
1688 unsigned n_changes
= 0;
1689 Manager
*m
= userdata
;
1690 UnitFilePresetMode mm
;
1691 UnitFileScope scope
;
1692 int runtime
, force
, r
;
1698 r
= sd_bus_message_read_strv(message
, &l
);
1702 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
1707 mm
= UNIT_FILE_PRESET_FULL
;
1709 mm
= unit_file_preset_mode_from_string(mode
);
1714 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1718 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1720 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1722 r
= unit_file_preset(scope
, runtime
, NULL
, l
, mm
, force
, &changes
, &n_changes
);
1726 return reply_unit_file_changes_and_free(m
, message
, r
, changes
, n_changes
);
1729 static int method_disable_unit_files_generic(
1730 sd_bus_message
*message
,
1733 int (*call
)(UnitFileScope scope
, bool runtime
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, unsigned *n_changes
),
1734 sd_bus_error
*error
) {
1736 _cleanup_strv_free_
char **l
= NULL
;
1737 UnitFileChange
*changes
= NULL
;
1738 unsigned n_changes
= 0;
1739 UnitFileScope scope
;
1745 r
= sd_bus_message_read_strv(message
, &l
);
1749 r
= sd_bus_message_read(message
, "b", &runtime
);
1753 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1755 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1759 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1761 r
= call(scope
, runtime
, NULL
, l
, &changes
, &n_changes
);
1765 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
);
1768 static int method_disable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1769 return method_disable_unit_files_generic(message
, userdata
, "disable", unit_file_disable
, error
);
1772 static int method_unmask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1773 return method_disable_unit_files_generic(message
, userdata
, "enable", unit_file_unmask
, error
);
1776 static int method_set_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1777 UnitFileChange
*changes
= NULL
;
1778 unsigned n_changes
= 0;
1779 Manager
*m
= userdata
;
1780 UnitFileScope scope
;
1787 r
= mac_selinux_access_check(message
, "enable", error
);
1791 r
= sd_bus_message_read(message
, "sb", &name
, &force
);
1795 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1799 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1801 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1803 r
= unit_file_set_default(scope
, NULL
, name
, force
, &changes
, &n_changes
);
1807 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
);
1810 static int method_preset_all_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1811 UnitFileChange
*changes
= NULL
;
1812 unsigned n_changes
= 0;
1813 Manager
*m
= userdata
;
1814 UnitFilePresetMode mm
;
1815 UnitFileScope scope
;
1817 int force
, runtime
, r
;
1822 r
= mac_selinux_access_check(message
, "enable", error
);
1826 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
1831 mm
= UNIT_FILE_PRESET_FULL
;
1833 mm
= unit_file_preset_mode_from_string(mode
);
1838 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1842 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1844 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1846 r
= unit_file_preset_all(scope
, runtime
, NULL
, mm
, force
, &changes
, &n_changes
);
1850 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
);
1853 static int method_add_dependency_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1854 _cleanup_strv_free_
char **l
= NULL
;
1855 Manager
*m
= userdata
;
1856 UnitFileChange
*changes
= NULL
;
1857 unsigned n_changes
= 0;
1858 UnitFileScope scope
;
1859 int runtime
, force
, r
;
1867 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
1871 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1873 r
= sd_bus_message_read_strv(message
, &l
);
1877 r
= sd_bus_message_read(message
, "ssbb", &target
, &type
, &runtime
, &force
);
1881 dep
= unit_dependency_from_string(type
);
1885 scope
= m
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
;
1887 r
= unit_file_add_dependency(scope
, runtime
, NULL
, l
, target
, dep
, force
, &changes
, &n_changes
);
1888 if (r
== -ESHUTDOWN
)
1889 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
, "Unit file is masked");
1893 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
);
1896 const sd_bus_vtable bus_manager_vtable
[] = {
1897 SD_BUS_VTABLE_START(0),
1899 SD_BUS_PROPERTY("Version", "s", property_get_version
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1900 SD_BUS_PROPERTY("Features", "s", property_get_features
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1901 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1902 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1903 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1904 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager
, firmware_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1905 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager
, loader_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1906 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager
, kernel_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1907 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager
, initrd_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1908 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager
, userspace_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1909 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager
, finish_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1910 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager
, security_start_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1911 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager
, security_finish_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1912 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager
, generators_start_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1913 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager
, generators_finish_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1914 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager
, units_load_start_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1915 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager
, units_load_finish_timestamp
), SD_BUS_VTABLE_PROPERTY_CONST
),
1916 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level
, property_set_log_level
, 0, 0),
1917 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target
, property_set_log_target
, 0, 0),
1918 SD_BUS_PROPERTY("NNames", "u", property_get_n_names
, 0, 0),
1919 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_n_failed_units
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
1920 SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs
, 0, 0),
1921 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_installed_jobs
), 0),
1922 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_failed_jobs
), 0),
1923 SD_BUS_PROPERTY("Progress", "d", property_get_progress
, 0, 0),
1924 SD_BUS_PROPERTY("Environment", "as", NULL
, offsetof(Manager
, environment
), 0),
1925 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool
, offsetof(Manager
, confirm_spawn
), SD_BUS_VTABLE_PROPERTY_CONST
),
1926 SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool
, offsetof(Manager
, show_status
), SD_BUS_VTABLE_PROPERTY_CONST
),
1927 SD_BUS_PROPERTY("UnitPath", "as", NULL
, offsetof(Manager
, lookup_paths
.unit_path
), SD_BUS_VTABLE_PROPERTY_CONST
),
1928 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
1929 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
1930 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec
, property_set_runtime_watchdog
, offsetof(Manager
, runtime_watchdog
), 0),
1931 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, shutdown_watchdog
), 0),
1932 SD_BUS_PROPERTY("ControlGroup", "s", NULL
, offsetof(Manager
, cgroup_root
), 0),
1933 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state
, 0, 0),
1934 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned
, offsetof(Manager
, return_value
), 0),
1935 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timer_accuracy_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
1936 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_start_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
1937 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_stop_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
1938 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_restart_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
1939 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
),
1940 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned
, offsetof(Manager
, default_start_limit_burst
), SD_BUS_VTABLE_PROPERTY_CONST
),
1941 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_cpu_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
1942 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_blockio_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
1943 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_memory_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
1944 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_tasks_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
1945 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1946 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1947 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1948 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1949 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1950 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1951 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1952 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1953 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1954 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1955 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1956 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1957 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1958 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1959 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1960 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1961 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1962 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1963 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1964 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1965 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1966 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1967 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1968 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1969 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1970 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1971 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1972 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1973 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1974 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1975 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1976 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
1977 SD_BUS_PROPERTY("DefaultTasksMax", "t", NULL
, offsetof(Manager
, default_tasks_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
1978 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
1980 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1981 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
1982 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1983 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1984 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace
, SD_BUS_VTABLE_UNPRIVILEGED
),
1985 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1986 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1987 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1988 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1989 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1990 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1991 SD_BUS_METHOD("KillUnit", "ssi", NULL
, method_kill_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1992 SD_BUS_METHOD("ResetFailedUnit", "s", NULL
, method_reset_failed_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1993 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL
, method_set_unit_properties
, SD_BUS_VTABLE_UNPRIVILEGED
),
1994 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
1995 SD_BUS_METHOD("GetJob", "u", "o", method_get_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
1996 SD_BUS_METHOD("CancelJob", "u", NULL
, method_cancel_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
1997 SD_BUS_METHOD("ClearJobs", NULL
, NULL
, method_clear_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
1998 SD_BUS_METHOD("ResetFailed", NULL
, NULL
, method_reset_failed
, SD_BUS_VTABLE_UNPRIVILEGED
),
1999 SD_BUS_METHOD("ListUnits", NULL
, "a(ssssssouso)", method_list_units
, SD_BUS_VTABLE_UNPRIVILEGED
),
2000 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered
, SD_BUS_VTABLE_UNPRIVILEGED
),
2001 SD_BUS_METHOD("ListJobs", NULL
, "a(usssoo)", method_list_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2002 SD_BUS_METHOD("Subscribe", NULL
, NULL
, method_subscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2003 SD_BUS_METHOD("Unsubscribe", NULL
, NULL
, method_unsubscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2004 SD_BUS_METHOD("Dump", NULL
, "s", method_dump
, SD_BUS_VTABLE_UNPRIVILEGED
),
2005 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2006 SD_BUS_METHOD("RemoveSnapshot", "s", NULL
, method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2007 SD_BUS_METHOD("Reload", NULL
, NULL
, method_reload
, SD_BUS_VTABLE_UNPRIVILEGED
),
2008 SD_BUS_METHOD("Reexecute", NULL
, NULL
, method_reexecute
, SD_BUS_VTABLE_UNPRIVILEGED
),
2009 SD_BUS_METHOD("Exit", NULL
, NULL
, method_exit
, 0),
2010 SD_BUS_METHOD("Reboot", NULL
, NULL
, method_reboot
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2011 SD_BUS_METHOD("PowerOff", NULL
, NULL
, method_poweroff
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2012 SD_BUS_METHOD("Halt", NULL
, NULL
, method_halt
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2013 SD_BUS_METHOD("KExec", NULL
, NULL
, method_kexec
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2014 SD_BUS_METHOD("SwitchRoot", "ss", NULL
, method_switch_root
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2015 SD_BUS_METHOD("SetEnvironment", "as", NULL
, method_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2016 SD_BUS_METHOD("UnsetEnvironment", "as", NULL
, method_unset_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2017 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL
, method_unset_and_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2018 SD_BUS_METHOD("ListUnitFiles", NULL
, "a(ss)", method_list_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2019 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state
, SD_BUS_VTABLE_UNPRIVILEGED
),
2020 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2021 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2022 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2023 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2024 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2025 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode
, SD_BUS_VTABLE_UNPRIVILEGED
),
2026 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2027 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2028 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2029 SD_BUS_METHOD("GetDefaultTarget", NULL
, "s", method_get_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2030 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2031 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2032 SD_BUS_METHOD("SetExitCode", "y", NULL
, method_set_exit_code
, SD_BUS_VTABLE_UNPRIVILEGED
),
2034 SD_BUS_SIGNAL("UnitNew", "so", 0),
2035 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2036 SD_BUS_SIGNAL("JobNew", "uos", 0),
2037 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2038 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2039 SD_BUS_SIGNAL("UnitFilesChanged", NULL
, 0),
2040 SD_BUS_SIGNAL("Reloading", "b", 0),
2045 static int send_finished(sd_bus
*bus
, void *userdata
) {
2046 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2047 usec_t
*times
= userdata
;
2053 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2057 r
= sd_bus_message_append(message
, "tttttt", times
[0], times
[1], times
[2], times
[3], times
[4], times
[5]);
2061 return sd_bus_send(bus
, message
, NULL
);
2064 void bus_manager_send_finished(
2066 usec_t firmware_usec
,
2070 usec_t userspace_usec
,
2071 usec_t total_usec
) {
2077 r
= bus_foreach_bus(
2090 log_debug_errno(r
, "Failed to send finished signal: %m");
2093 static int send_reloading(sd_bus
*bus
, void *userdata
) {
2094 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2099 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2103 r
= sd_bus_message_append(message
, "b", PTR_TO_INT(userdata
));
2107 return sd_bus_send(bus
, message
, NULL
);
2110 void bus_manager_send_reloading(Manager
*m
, bool active
) {
2115 r
= bus_foreach_bus(m
, NULL
, send_reloading
, INT_TO_PTR(active
));
2117 log_debug_errno(r
, "Failed to send reloading signal: %m");
2120 static int send_changed_signal(sd_bus
*bus
, void *userdata
) {
2123 return sd_bus_emit_properties_changed_strv(bus
,
2124 "/org/freedesktop/systemd1",
2125 "org.freedesktop.systemd1.Manager",
2129 void bus_manager_send_change_signal(Manager
*m
) {
2134 r
= bus_foreach_bus(m
, NULL
, send_changed_signal
, NULL
);
2136 log_debug_errno(r
, "Failed to send manager change signal: %m");