1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/prctl.h>
23 #include <sys/statvfs.h>
26 #include "alloc-util.h"
27 #include "architecture.h"
29 #include "bus-common-errors.h"
30 #include "dbus-execute.h"
32 #include "dbus-manager.h"
33 #include "dbus-unit.h"
38 #include "format-util.h"
42 #include "parse-util.h"
43 #include "path-util.h"
44 #include "selinux-access.h"
45 #include "stat-util.h"
46 #include "string-util.h"
48 #include "syslog-util.h"
49 #include "user-util.h"
53 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state there, and if
54 * we can't we'll fail badly. */
55 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
57 static UnitFileFlags
unit_file_bools_to_flags(bool runtime
, bool force
) {
58 return (runtime
? UNIT_FILE_RUNTIME
: 0) |
59 (force
? UNIT_FILE_FORCE
: 0);
62 static int property_get_version(
65 const char *interface
,
67 sd_bus_message
*reply
,
69 sd_bus_error
*error
) {
74 return sd_bus_message_append(reply
, "s", PACKAGE_VERSION
);
77 static int property_get_features(
80 const char *interface
,
82 sd_bus_message
*reply
,
84 sd_bus_error
*error
) {
89 return sd_bus_message_append(reply
, "s", SYSTEMD_FEATURES
);
92 static int property_get_virtualization(
95 const char *interface
,
97 sd_bus_message
*reply
,
99 sd_bus_error
*error
) {
106 v
= detect_virtualization();
108 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
110 * https://github.com/systemd/systemd/issues/1423
113 return sd_bus_message_append(
115 v
== VIRTUALIZATION_NONE
? "" : virtualization_to_string(v
));
118 static int property_get_architecture(
121 const char *interface
,
122 const char *property
,
123 sd_bus_message
*reply
,
125 sd_bus_error
*error
) {
130 return sd_bus_message_append(reply
, "s", architecture_to_string(uname_architecture()));
133 static int property_get_tainted(
136 const char *interface
,
137 const char *property
,
138 sd_bus_message
*reply
,
140 sd_bus_error
*error
) {
142 _cleanup_free_
char *s
= NULL
;
143 Manager
*m
= userdata
;
149 s
= manager_taint_string(m
);
153 return sd_bus_message_append(reply
, "s", s
);
156 static int property_get_log_target(
159 const char *interface
,
160 const char *property
,
161 sd_bus_message
*reply
,
163 sd_bus_error
*error
) {
168 return sd_bus_message_append(reply
, "s", log_target_to_string(log_get_target()));
171 static int property_set_log_target(
174 const char *interface
,
175 const char *property
,
176 sd_bus_message
*value
,
178 sd_bus_error
*error
) {
186 r
= sd_bus_message_read(value
, "s", &t
);
190 return log_set_target_from_string(t
);
193 static int property_get_log_level(
196 const char *interface
,
197 const char *property
,
198 sd_bus_message
*reply
,
200 sd_bus_error
*error
) {
202 _cleanup_free_
char *t
= NULL
;
208 r
= log_level_to_string_alloc(log_get_max_level(), &t
);
212 return sd_bus_message_append(reply
, "s", t
);
215 static int property_set_log_level(
218 const char *interface
,
219 const char *property
,
220 sd_bus_message
*value
,
222 sd_bus_error
*error
) {
230 r
= sd_bus_message_read(value
, "s", &t
);
234 r
= log_set_max_level_from_string(t
);
236 log_info("Setting log level to %s.", t
);
240 static int property_get_n_names(
243 const char *interface
,
244 const char *property
,
245 sd_bus_message
*reply
,
247 sd_bus_error
*error
) {
249 Manager
*m
= userdata
;
255 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->units
));
258 static int property_get_n_failed_units(
261 const char *interface
,
262 const char *property
,
263 sd_bus_message
*reply
,
265 sd_bus_error
*error
) {
267 Manager
*m
= userdata
;
273 return sd_bus_message_append(reply
, "u", (uint32_t) set_size(m
->failed_units
));
276 static int property_get_n_jobs(
279 const char *interface
,
280 const char *property
,
281 sd_bus_message
*reply
,
283 sd_bus_error
*error
) {
285 Manager
*m
= userdata
;
291 return sd_bus_message_append(reply
, "u", (uint32_t) hashmap_size(m
->jobs
));
294 static int property_get_progress(
297 const char *interface
,
298 const char *property
,
299 sd_bus_message
*reply
,
301 sd_bus_error
*error
) {
303 Manager
*m
= userdata
;
310 if (MANAGER_IS_FINISHED(m
))
313 d
= 1.0 - ((double) hashmap_size(m
->jobs
) / (double) m
->n_installed_jobs
);
315 return sd_bus_message_append(reply
, "d", d
);
318 static int property_get_system_state(
321 const char *interface
,
322 const char *property
,
323 sd_bus_message
*reply
,
325 sd_bus_error
*error
) {
327 Manager
*m
= userdata
;
333 return sd_bus_message_append(reply
, "s", manager_state_to_string(manager_state(m
)));
336 static int property_set_runtime_watchdog(
339 const char *interface
,
340 const char *property
,
341 sd_bus_message
*value
,
343 sd_bus_error
*error
) {
345 usec_t
*t
= userdata
;
351 assert_cc(sizeof(usec_t
) == sizeof(uint64_t));
353 r
= sd_bus_message_read(value
, "t", t
);
357 return watchdog_set_timeout(t
);
360 static int property_get_timer_slack_nsec(
363 const char *interface
,
364 const char *property
,
365 sd_bus_message
*reply
,
367 sd_bus_error
*error
) {
372 return sd_bus_message_append(reply
, "t", (uint64_t) prctl(PR_GET_TIMERSLACK
));
375 static int method_get_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
376 _cleanup_free_
char *path
= NULL
;
377 Manager
*m
= userdata
;
385 /* Anyone can call this method */
387 r
= sd_bus_message_read(message
, "s", &name
);
392 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
395 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
399 r
= sd_bus_creds_get_pid(creds
, &pid
);
403 u
= manager_get_unit_by_pid(m
, pid
);
405 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
407 u
= manager_get_unit(m
, name
);
409 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
412 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
416 path
= unit_dbus_path(u
);
420 return sd_bus_reply_method_return(message
, "o", path
);
423 static int method_get_unit_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
424 _cleanup_free_
char *path
= NULL
;
425 Manager
*m
= userdata
;
433 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
435 /* Anyone can call this method */
437 r
= sd_bus_message_read(message
, "u", &pid
);
441 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid PID " PID_FMT
, pid
);
444 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
446 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
450 r
= sd_bus_creds_get_pid(creds
, &pid
);
455 u
= manager_get_unit_by_pid(m
, pid
);
457 return sd_bus_error_setf(error
, BUS_ERROR_NO_UNIT_FOR_PID
, "PID "PID_FMT
" does not belong to any loaded unit.", pid
);
459 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
463 path
= unit_dbus_path(u
);
467 return sd_bus_reply_method_return(message
, "o", path
);
470 static int method_get_unit_by_invocation_id(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
471 _cleanup_free_
char *path
= NULL
;
472 Manager
*m
= userdata
;
482 /* Anyone can call this method */
484 r
= sd_bus_message_read_array(message
, 'y', &a
, &sz
);
492 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid invocation ID");
494 if (sd_id128_is_null(id
)) {
495 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
498 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
502 r
= sd_bus_creds_get_pid(creds
, &pid
);
506 u
= manager_get_unit_by_pid(m
, pid
);
508 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client " PID_FMT
" not member of any unit.", pid
);
510 u
= hashmap_get(m
->units_by_invocation_id
, &id
);
512 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
));
515 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
519 /* So here's a special trick: the bus path we return actually references the unit by its invocation ID instead
520 * of the unit name. This means it stays valid only as long as the invocation ID stays the same. */
521 path
= unit_dbus_path_invocation_id(u
);
525 return sd_bus_reply_method_return(message
, "o", path
);
528 static int method_load_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
529 _cleanup_free_
char *path
= NULL
;
530 Manager
*m
= userdata
;
538 /* Anyone can call this method */
540 r
= sd_bus_message_read(message
, "s", &name
);
545 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
548 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
552 r
= sd_bus_creds_get_pid(creds
, &pid
);
556 u
= manager_get_unit_by_pid(m
, pid
);
558 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Client not member of any unit.");
560 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
565 r
= mac_selinux_unit_access_check(u
, message
, "status", error
);
569 path
= unit_dbus_path(u
);
573 return sd_bus_reply_method_return(message
, "o", path
);
576 static int method_start_unit_generic(sd_bus_message
*message
, Manager
*m
, JobType job_type
, bool reload_if_possible
, sd_bus_error
*error
) {
584 r
= sd_bus_message_read(message
, "s", &name
);
588 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
592 return bus_unit_method_start_generic(message
, u
, job_type
, reload_if_possible
, error
);
595 static int method_start_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
596 return method_start_unit_generic(message
, userdata
, JOB_START
, false, error
);
599 static int method_stop_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
600 return method_start_unit_generic(message
, userdata
, JOB_STOP
, false, error
);
603 static int method_reload_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
604 return method_start_unit_generic(message
, userdata
, JOB_RELOAD
, false, error
);
607 static int method_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
608 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, false, error
);
611 static int method_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
612 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, false, error
);
615 static int method_reload_or_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
616 return method_start_unit_generic(message
, userdata
, JOB_RESTART
, true, error
);
619 static int method_reload_or_try_restart_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
620 return method_start_unit_generic(message
, userdata
, JOB_TRY_RESTART
, true, error
);
623 static int method_start_unit_replace(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
624 Manager
*m
= userdata
;
625 const char *old_name
;
632 r
= sd_bus_message_read(message
, "s", &old_name
);
636 u
= manager_get_unit(m
, old_name
);
637 if (!u
|| !u
->job
|| u
->job
->type
!= JOB_START
)
638 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "No job queued for unit %s", old_name
);
640 return method_start_unit_generic(message
, m
, JOB_START
, false, error
);
643 static int method_kill_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
644 Manager
*m
= userdata
;
652 r
= sd_bus_message_read(message
, "s", &name
);
656 u
= manager_get_unit(m
, name
);
658 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s is not loaded.", name
);
660 return bus_unit_method_kill(message
, u
, error
);
663 static int method_reset_failed_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
664 Manager
*m
= userdata
;
672 r
= sd_bus_message_read(message
, "s", &name
);
676 u
= manager_get_unit(m
, name
);
678 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s is not loaded.", name
);
680 return bus_unit_method_reset_failed(message
, u
, error
);
683 static int method_set_unit_properties(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
684 Manager
*m
= userdata
;
692 r
= sd_bus_message_read(message
, "s", &name
);
696 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
700 r
= bus_unit_check_load_state(u
, error
);
704 return bus_unit_method_set_properties(message
, u
, error
);
707 static int method_ref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
708 Manager
*m
= userdata
;
716 r
= sd_bus_message_read(message
, "s", &name
);
720 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
724 r
= bus_unit_check_load_state(u
, error
);
728 return bus_unit_method_ref(message
, u
, error
);
731 static int method_unref_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
732 Manager
*m
= userdata
;
740 r
= sd_bus_message_read(message
, "s", &name
);
744 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
748 r
= bus_unit_check_load_state(u
, error
);
752 return bus_unit_method_unref(message
, u
, error
);
755 static int reply_unit_info(sd_bus_message
*reply
, Unit
*u
) {
756 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
759 following
= unit_following(u
);
761 unit_path
= unit_dbus_path(u
);
766 job_path
= job_dbus_path(u
->job
);
771 return sd_bus_message_append(
772 reply
, "(ssssssouso)",
775 unit_load_state_to_string(u
->load_state
),
776 unit_active_state_to_string(unit_active_state(u
)),
777 unit_sub_state_to_string(u
),
778 following
? following
->id
: "",
780 u
->job
? u
->job
->id
: 0,
781 u
->job
? job_type_to_string(u
->job
->type
) : "",
782 job_path
? job_path
: "/");
785 static int method_list_units_by_names(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
786 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
787 Manager
*m
= userdata
;
790 _cleanup_strv_free_
char **units
= NULL
;
795 r
= sd_bus_message_read_strv(message
, &units
);
799 r
= sd_bus_message_new_method_return(message
, &reply
);
803 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
807 STRV_FOREACH(unit
, units
) {
810 if (!unit_name_is_valid(*unit
, UNIT_NAME_ANY
))
813 r
= manager_load_unit(m
, *unit
, NULL
, error
, &u
);
817 r
= reply_unit_info(reply
, u
);
822 r
= sd_bus_message_close_container(reply
);
826 return sd_bus_send(NULL
, reply
, NULL
);
829 static int method_get_unit_processes(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
830 Manager
*m
= userdata
;
838 r
= sd_bus_message_read(message
, "s", &name
);
842 u
= manager_get_unit(m
, name
);
844 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit %s not loaded.", name
);
846 return bus_unit_method_get_processes(message
, u
, error
);
849 static int transient_unit_from_message(
851 sd_bus_message
*message
,
854 sd_bus_error
*error
) {
864 t
= unit_name_to_type(name
);
866 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid unit name or type.");
868 if (!unit_vtable
[t
]->can_transient
)
869 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unit type %s does not support transient units.", unit_type_to_string(t
));
871 r
= manager_load_unit(m
, name
, NULL
, error
, &u
);
875 if (!unit_is_pristine(u
))
876 return sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
, "Unit %s already exists.", name
);
878 /* OK, the unit failed to load and is unreferenced, now let's
879 * fill in the transient data instead */
880 r
= unit_make_transient(u
);
884 /* Set our properties */
885 r
= bus_unit_set_properties(u
, message
, UNIT_RUNTIME
, false, error
);
889 /* If the client asked for it, automatically add a reference to this unit. */
890 if (u
->bus_track_add
) {
891 r
= bus_unit_track_add_sender(u
, message
);
893 return log_error_errno(r
, "Failed to watch sender: %m");
896 /* Now load the missing bits of the unit we just created */
897 unit_add_to_load_queue(u
);
898 manager_dispatch_load_queue(m
);
905 static int transient_aux_units_from_message(
907 sd_bus_message
*message
,
908 sd_bus_error
*error
) {
915 r
= sd_bus_message_enter_container(message
, 'a', "(sa(sv))");
919 while ((r
= sd_bus_message_enter_container(message
, 'r', "sa(sv)")) > 0) {
920 const char *name
= NULL
;
923 r
= sd_bus_message_read(message
, "s", &name
);
927 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
931 r
= sd_bus_message_exit_container(message
);
938 r
= sd_bus_message_exit_container(message
);
945 static int method_start_transient_unit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
946 const char *name
, *smode
;
947 Manager
*m
= userdata
;
955 r
= mac_selinux_access_check(message
, "start", error
);
959 r
= sd_bus_message_read(message
, "ss", &name
, &smode
);
963 mode
= job_mode_from_string(smode
);
965 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Job mode %s is invalid.", smode
);
967 r
= bus_verify_manage_units_async(m
, message
, error
);
971 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
973 r
= transient_unit_from_message(m
, message
, name
, &u
, error
);
977 r
= transient_aux_units_from_message(m
, message
, error
);
981 /* Finally, start it */
982 return bus_unit_queue_job(message
, u
, JOB_START
, mode
, false, error
);
985 static int method_get_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
986 _cleanup_free_
char *path
= NULL
;
987 Manager
*m
= userdata
;
995 /* Anyone can call this method */
997 r
= sd_bus_message_read(message
, "u", &id
);
1001 j
= manager_get_job(m
, id
);
1003 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1005 r
= mac_selinux_unit_access_check(j
->unit
, message
, "status", error
);
1009 path
= job_dbus_path(j
);
1013 return sd_bus_reply_method_return(message
, "o", path
);
1016 static int method_cancel_job(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1017 Manager
*m
= userdata
;
1025 r
= sd_bus_message_read(message
, "u", &id
);
1029 j
= manager_get_job(m
, id
);
1031 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
1033 return bus_job_method_cancel(message
, j
, error
);
1036 static int method_clear_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1037 Manager
*m
= userdata
;
1043 r
= mac_selinux_access_check(message
, "reload", error
);
1047 r
= bus_verify_manage_units_async(m
, message
, error
);
1051 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1053 manager_clear_jobs(m
);
1055 return sd_bus_reply_method_return(message
, NULL
);
1058 static int method_reset_failed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1059 Manager
*m
= userdata
;
1065 r
= mac_selinux_access_check(message
, "reload", error
);
1069 r
= bus_verify_manage_units_async(m
, message
, error
);
1073 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1075 manager_reset_failed(m
);
1077 return sd_bus_reply_method_return(message
, NULL
);
1080 static int list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1081 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1082 Manager
*m
= userdata
;
1091 /* Anyone can call this method */
1093 r
= mac_selinux_access_check(message
, "status", error
);
1097 r
= sd_bus_message_new_method_return(message
, &reply
);
1101 r
= sd_bus_message_open_container(reply
, 'a', "(ssssssouso)");
1105 HASHMAP_FOREACH_KEY(u
, k
, m
->units
, i
) {
1109 if (!strv_isempty(states
) &&
1110 !strv_contains(states
, unit_load_state_to_string(u
->load_state
)) &&
1111 !strv_contains(states
, unit_active_state_to_string(unit_active_state(u
))) &&
1112 !strv_contains(states
, unit_sub_state_to_string(u
)))
1115 if (!strv_isempty(patterns
) &&
1116 !strv_fnmatch_or_empty(patterns
, u
->id
, FNM_NOESCAPE
))
1119 r
= reply_unit_info(reply
, u
);
1124 r
= sd_bus_message_close_container(reply
);
1128 return sd_bus_send(NULL
, reply
, NULL
);
1131 static int method_list_units(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1132 return list_units_filtered(message
, userdata
, error
, NULL
, NULL
);
1135 static int method_list_units_filtered(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1136 _cleanup_strv_free_
char **states
= NULL
;
1139 r
= sd_bus_message_read_strv(message
, &states
);
1143 return list_units_filtered(message
, userdata
, error
, states
, NULL
);
1146 static int method_list_units_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1147 _cleanup_strv_free_
char **states
= NULL
;
1148 _cleanup_strv_free_
char **patterns
= NULL
;
1151 r
= sd_bus_message_read_strv(message
, &states
);
1155 r
= sd_bus_message_read_strv(message
, &patterns
);
1159 return list_units_filtered(message
, userdata
, error
, states
, patterns
);
1162 static int method_list_jobs(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1163 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1164 Manager
*m
= userdata
;
1172 /* Anyone can call this method */
1174 r
= mac_selinux_access_check(message
, "status", error
);
1178 r
= sd_bus_message_new_method_return(message
, &reply
);
1182 r
= sd_bus_message_open_container(reply
, 'a', "(usssoo)");
1186 HASHMAP_FOREACH(j
, m
->jobs
, i
) {
1187 _cleanup_free_
char *unit_path
= NULL
, *job_path
= NULL
;
1189 job_path
= job_dbus_path(j
);
1193 unit_path
= unit_dbus_path(j
->unit
);
1197 r
= sd_bus_message_append(
1201 job_type_to_string(j
->type
),
1202 job_state_to_string(j
->state
),
1209 r
= sd_bus_message_close_container(reply
);
1213 return sd_bus_send(NULL
, reply
, NULL
);
1216 static int method_subscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1217 Manager
*m
= userdata
;
1223 /* Anyone can call this method */
1225 r
= mac_selinux_access_check(message
, "status", error
);
1229 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1231 /* Note that direct bus connection subscribe by
1232 * default, we only track peers on the API bus here */
1234 if (!m
->subscribed
) {
1235 r
= sd_bus_track_new(sd_bus_message_get_bus(message
), &m
->subscribed
, NULL
, NULL
);
1240 r
= sd_bus_track_add_sender(m
->subscribed
, message
);
1244 return sd_bus_error_setf(error
, BUS_ERROR_ALREADY_SUBSCRIBED
, "Client is already subscribed.");
1247 return sd_bus_reply_method_return(message
, NULL
);
1250 static int method_unsubscribe(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1251 Manager
*m
= userdata
;
1257 /* Anyone can call this method */
1259 r
= mac_selinux_access_check(message
, "status", error
);
1263 if (sd_bus_message_get_bus(message
) == m
->api_bus
) {
1264 r
= sd_bus_track_remove_sender(m
->subscribed
, message
);
1268 return sd_bus_error_setf(error
, BUS_ERROR_NOT_SUBSCRIBED
, "Client is not subscribed.");
1271 return sd_bus_reply_method_return(message
, NULL
);
1274 static int method_dump(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1275 _cleanup_free_
char *dump
= NULL
;
1276 Manager
*m
= userdata
;
1282 /* Anyone can call this method */
1284 r
= mac_selinux_access_check(message
, "status", error
);
1288 r
= manager_get_dump_string(m
, &dump
);
1292 return sd_bus_reply_method_return(message
, "s", dump
);
1295 static int method_refuse_snapshot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1296 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Support for snapshots has been removed.");
1299 static int verify_run_space(const char *message
, sd_bus_error
*error
) {
1300 struct statvfs svfs
;
1303 if (statvfs("/run/systemd", &svfs
) < 0)
1304 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1306 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1308 if (available
< RELOAD_DISK_SPACE_MIN
) {
1309 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1310 return sd_bus_error_setf(error
,
1311 BUS_ERROR_DISK_FULL
,
1312 "%s, not enough space available on /run/systemd. "
1313 "Currently, %s are free, but a safety buffer of %s is enforced.",
1315 format_bytes(fb_available
, sizeof(fb_available
), available
),
1316 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1322 int verify_run_space_and_log(const char *message
) {
1323 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1326 r
= verify_run_space(message
, &error
);
1328 log_error_errno(r
, "%s", bus_error_message(&error
, r
));
1333 static int method_reload(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1334 Manager
*m
= userdata
;
1340 r
= verify_run_space("Refusing to reload", error
);
1344 r
= mac_selinux_access_check(message
, "reload", error
);
1348 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1352 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1354 /* Instead of sending the reply back right away, we just
1355 * remember that we need to and then send it after the reload
1356 * is finished. That way the caller knows when the reload
1359 assert(!m
->queued_message
);
1360 r
= sd_bus_message_new_method_return(message
, &m
->queued_message
);
1364 m
->exit_code
= MANAGER_RELOAD
;
1369 static int method_reexecute(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1370 Manager
*m
= userdata
;
1376 r
= verify_run_space("Refusing to reexecute", error
);
1380 r
= mac_selinux_access_check(message
, "reload", error
);
1384 r
= bus_verify_reload_daemon_async(m
, message
, error
);
1388 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1390 /* We don't send a reply back here, the client should
1391 * just wait for us disconnecting. */
1393 m
->exit_code
= MANAGER_REEXECUTE
;
1397 static int method_exit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1398 Manager
*m
= userdata
;
1404 r
= mac_selinux_access_check(message
, "halt", error
);
1408 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1409 * we are running on the host. It will fall back on reboot() in
1410 * systemd-shutdown if it cannot do the exit() because it isn't a
1413 m
->exit_code
= MANAGER_EXIT
;
1415 return sd_bus_reply_method_return(message
, NULL
);
1418 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1419 Manager
*m
= userdata
;
1425 r
= mac_selinux_access_check(message
, "reboot", error
);
1429 if (!MANAGER_IS_SYSTEM(m
))
1430 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Reboot is only supported for system managers.");
1432 m
->exit_code
= MANAGER_REBOOT
;
1434 return sd_bus_reply_method_return(message
, NULL
);
1437 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1438 Manager
*m
= userdata
;
1444 r
= mac_selinux_access_check(message
, "halt", error
);
1448 if (!MANAGER_IS_SYSTEM(m
))
1449 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Powering off is only supported for system managers.");
1451 m
->exit_code
= MANAGER_POWEROFF
;
1453 return sd_bus_reply_method_return(message
, NULL
);
1456 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1457 Manager
*m
= userdata
;
1463 r
= mac_selinux_access_check(message
, "halt", error
);
1467 if (!MANAGER_IS_SYSTEM(m
))
1468 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Halt is only supported for system managers.");
1470 m
->exit_code
= MANAGER_HALT
;
1472 return sd_bus_reply_method_return(message
, NULL
);
1475 static int method_kexec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1476 Manager
*m
= userdata
;
1482 r
= mac_selinux_access_check(message
, "reboot", error
);
1486 if (!MANAGER_IS_SYSTEM(m
))
1487 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "KExec is only supported for system managers.");
1489 m
->exit_code
= MANAGER_KEXEC
;
1491 return sd_bus_reply_method_return(message
, NULL
);
1494 static int method_switch_root(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1495 char *ri
= NULL
, *rt
= NULL
;
1496 const char *root
, *init
;
1497 Manager
*m
= userdata
;
1498 struct statvfs svfs
;
1505 if (statvfs("/run/systemd", &svfs
) < 0)
1506 return sd_bus_error_set_errnof(error
, errno
, "Failed to statvfs(/run/systemd): %m");
1508 available
= (uint64_t) svfs
.f_bfree
* (uint64_t) svfs
.f_bsize
;
1510 if (available
< RELOAD_DISK_SPACE_MIN
) {
1511 char fb_available
[FORMAT_BYTES_MAX
], fb_need
[FORMAT_BYTES_MAX
];
1512 log_warning("Dangerously low amount of free space on /run/systemd, root switching operation might not complete successfuly. "
1513 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1514 format_bytes(fb_available
, sizeof(fb_available
), available
),
1515 format_bytes(fb_need
, sizeof(fb_need
), RELOAD_DISK_SPACE_MIN
));
1518 r
= mac_selinux_access_check(message
, "reboot", error
);
1522 if (!MANAGER_IS_SYSTEM(m
))
1523 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Root switching is only supported by system manager.");
1525 r
= sd_bus_message_read(message
, "ss", &root
, &init
);
1530 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory may not be the empty string.");
1531 if (!path_is_absolute(root
))
1532 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root path '%s' is not absolute.", root
);
1533 if (path_equal(root
, "/"))
1534 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "New root directory cannot be the old root directory.");
1537 if (isempty(init
)) {
1538 r
= path_is_os_tree(root
);
1540 return sd_bus_error_set_errnof(error
, r
, "Failed to determine whether root path '%s' contains an OS tree: %m", root
);
1542 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
);
1544 _cleanup_free_
char *chased
= NULL
;
1546 if (!path_is_absolute(init
))
1547 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path to init binary '%s' not absolute.", init
);
1549 r
= chase_symlinks(init
, root
, CHASE_PREFIX_ROOT
, &chased
);
1551 return sd_bus_error_set_errnof(error
, r
, "Could not resolve init executable %s: %m", init
);
1553 if (laccess(chased
, X_OK
) < 0) {
1554 if (errno
== EACCES
)
1555 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Init binary %s is not executable.", init
);
1557 return sd_bus_error_set_errnof(error
, r
, "Could not check whether init binary %s is executable: %m", init
);
1565 if (!isempty(init
)) {
1573 free(m
->switch_root
);
1574 m
->switch_root
= rt
;
1576 free(m
->switch_root_init
);
1577 m
->switch_root_init
= ri
;
1579 m
->exit_code
= MANAGER_SWITCH_ROOT
;
1581 return sd_bus_reply_method_return(message
, NULL
);
1584 static int method_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1585 _cleanup_strv_free_
char **plus
= NULL
;
1586 Manager
*m
= userdata
;
1592 r
= mac_selinux_access_check(message
, "reload", error
);
1596 r
= sd_bus_message_read_strv(message
, &plus
);
1599 if (!strv_env_is_valid(plus
))
1600 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1602 r
= bus_verify_set_environment_async(m
, message
, error
);
1606 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1608 r
= manager_environment_add(m
, NULL
, plus
);
1612 return sd_bus_reply_method_return(message
, NULL
);
1615 static int method_unset_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1616 _cleanup_strv_free_
char **minus
= NULL
;
1617 Manager
*m
= userdata
;
1623 r
= mac_selinux_access_check(message
, "reload", error
);
1627 r
= sd_bus_message_read_strv(message
, &minus
);
1631 if (!strv_env_name_or_assignment_is_valid(minus
))
1632 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1634 r
= bus_verify_set_environment_async(m
, message
, error
);
1638 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1640 r
= manager_environment_add(m
, minus
, NULL
);
1644 return sd_bus_reply_method_return(message
, NULL
);
1647 static int method_unset_and_set_environment(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1648 _cleanup_strv_free_
char **minus
= NULL
, **plus
= NULL
;
1649 Manager
*m
= userdata
;
1655 r
= mac_selinux_access_check(message
, "reload", error
);
1659 r
= sd_bus_message_read_strv(message
, &minus
);
1663 r
= sd_bus_message_read_strv(message
, &plus
);
1667 if (!strv_env_name_or_assignment_is_valid(minus
))
1668 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment variable names or assignments");
1669 if (!strv_env_is_valid(plus
))
1670 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid environment assignments");
1672 r
= bus_verify_set_environment_async(m
, message
, error
);
1676 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1678 r
= manager_environment_add(m
, minus
, plus
);
1682 return sd_bus_reply_method_return(message
, NULL
);
1685 static int method_set_exit_code(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1686 Manager
*m
= userdata
;
1693 r
= mac_selinux_access_check(message
, "exit", error
);
1697 r
= sd_bus_message_read_basic(message
, 'y', &code
);
1701 if (MANAGER_IS_SYSTEM(m
) && detect_container() <= 0)
1702 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "ExitCode can only be set for user service managers or in containers.");
1704 m
->return_value
= code
;
1706 return sd_bus_reply_method_return(message
, NULL
);
1709 static int method_lookup_dynamic_user_by_name(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1710 Manager
*m
= userdata
;
1718 r
= sd_bus_message_read_basic(message
, 's', &name
);
1722 if (!MANAGER_IS_SYSTEM(m
))
1723 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1724 if (!valid_user_group_name(name
))
1725 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User name invalid: %s", name
);
1727 r
= dynamic_user_lookup_name(m
, name
, &uid
);
1729 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user %s does not exist.", name
);
1733 return sd_bus_reply_method_return(message
, "u", (uint32_t) uid
);
1736 static int method_lookup_dynamic_user_by_uid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1737 _cleanup_free_
char *name
= NULL
;
1738 Manager
*m
= userdata
;
1745 assert_cc(sizeof(uid
) == sizeof(uint32_t));
1746 r
= sd_bus_message_read_basic(message
, 'u', &uid
);
1750 if (!MANAGER_IS_SYSTEM(m
))
1751 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Dynamic users are only supported in the system instance.");
1752 if (!uid_is_valid(uid
))
1753 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "User ID invalid: " UID_FMT
, uid
);
1755 r
= dynamic_user_lookup_uid(m
, uid
, &name
);
1757 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_DYNAMIC_USER
, "Dynamic user ID " UID_FMT
" does not exist.", uid
);
1761 return sd_bus_reply_method_return(message
, "s", name
);
1764 static int list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
, char **states
, char **patterns
) {
1765 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1766 Manager
*m
= userdata
;
1775 /* Anyone can call this method */
1777 r
= mac_selinux_access_check(message
, "status", error
);
1781 r
= sd_bus_message_new_method_return(message
, &reply
);
1785 h
= hashmap_new(&string_hash_ops
);
1789 r
= unit_file_get_list(m
->unit_file_scope
, NULL
, h
, states
, patterns
);
1793 r
= sd_bus_message_open_container(reply
, 'a', "(ss)");
1797 HASHMAP_FOREACH(item
, h
, i
) {
1799 r
= sd_bus_message_append(reply
, "(ss)", item
->path
, unit_file_state_to_string(item
->state
));
1804 unit_file_list_free(h
);
1806 r
= sd_bus_message_close_container(reply
);
1810 return sd_bus_send(NULL
, reply
, NULL
);
1813 unit_file_list_free(h
);
1817 static int method_list_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1818 return list_unit_files_by_patterns(message
, userdata
, error
, NULL
, NULL
);
1821 static int method_list_unit_files_by_patterns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1822 _cleanup_strv_free_
char **states
= NULL
;
1823 _cleanup_strv_free_
char **patterns
= NULL
;
1826 r
= sd_bus_message_read_strv(message
, &states
);
1830 r
= sd_bus_message_read_strv(message
, &patterns
);
1834 return list_unit_files_by_patterns(message
, userdata
, error
, states
, patterns
);
1837 static int method_get_unit_file_state(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1838 Manager
*m
= userdata
;
1840 UnitFileState state
;
1846 /* Anyone can call this method */
1848 r
= mac_selinux_access_check(message
, "status", error
);
1852 r
= sd_bus_message_read(message
, "s", &name
);
1856 r
= unit_file_get_state(m
->unit_file_scope
, NULL
, name
, &state
);
1860 return sd_bus_reply_method_return(message
, "s", unit_file_state_to_string(state
));
1863 static int method_get_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1864 _cleanup_free_
char *default_target
= NULL
;
1865 Manager
*m
= userdata
;
1871 /* Anyone can call this method */
1873 r
= mac_selinux_access_check(message
, "status", error
);
1877 r
= unit_file_get_default(m
->unit_file_scope
, NULL
, &default_target
);
1881 return sd_bus_reply_method_return(message
, "s", default_target
);
1884 static int send_unit_files_changed(sd_bus
*bus
, void *userdata
) {
1885 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
1890 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1894 return sd_bus_send(bus
, message
, NULL
);
1897 /* Create an error reply, using the error information from changes[]
1898 * if possible, and fall back to generating an error from error code c.
1899 * The error message only describes the first error.
1901 * Coordinate with unit_file_dump_changes() in install.c.
1903 static int install_error(
1904 sd_bus_error
*error
,
1906 UnitFileChange
*changes
,
1907 unsigned n_changes
) {
1911 for (i
= 0; i
< n_changes
; i
++)
1913 switch(changes
[i
].type
) {
1919 if (changes
[i
].source
)
1920 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
1921 "File %s already exists and is a symlink to %s.",
1922 changes
[i
].path
, changes
[i
].source
);
1924 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_EXISTS
,
1925 "File %s already exists.",
1930 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_MASKED
,
1931 "Unit file %s is masked.", changes
[i
].path
);
1934 case -EADDRNOTAVAIL
:
1935 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_GENERATED
,
1936 "Unit %s is transient or generated.", changes
[i
].path
);
1940 r
= sd_bus_error_setf(error
, BUS_ERROR_UNIT_LINKED
,
1941 "Refusing to operate on linked unit file %s", changes
[i
].path
);
1945 r
= sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_UNIT
, "Unit file %s does not exist.", changes
[i
].path
);
1949 r
= sd_bus_error_set_errnof(error
, changes
[i
].type
, "File %s: %m", changes
[i
].path
);
1953 r
= c
< 0 ? c
: -EINVAL
;
1956 unit_file_changes_free(changes
, n_changes
);
1960 static int reply_unit_file_changes_and_free(
1962 sd_bus_message
*message
,
1963 int carries_install_info
,
1964 UnitFileChange
*changes
,
1966 sd_bus_error
*error
) {
1968 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1969 bool bad
= false, good
= false;
1973 if (unit_file_changes_have_modification(changes
, n_changes
)) {
1974 r
= bus_foreach_bus(m
, NULL
, send_unit_files_changed
, NULL
);
1976 log_debug_errno(r
, "Failed to send UnitFilesChanged signal: %m");
1979 r
= sd_bus_message_new_method_return(message
, &reply
);
1983 if (carries_install_info
>= 0) {
1984 r
= sd_bus_message_append(reply
, "b", carries_install_info
);
1989 r
= sd_bus_message_open_container(reply
, 'a', "(sss)");
1993 for (i
= 0; i
< n_changes
; i
++) {
1995 if (changes
[i
].type
< 0) {
2000 r
= sd_bus_message_append(
2002 unit_file_change_type_to_string(changes
[i
].type
),
2011 /* If there was a failed change, and no successful change, then return the first failure as proper method call
2014 return install_error(error
, 0, changes
, n_changes
);
2016 r
= sd_bus_message_close_container(reply
);
2020 unit_file_changes_free(changes
, n_changes
);
2021 return sd_bus_send(NULL
, reply
, NULL
);
2024 unit_file_changes_free(changes
, n_changes
);
2028 static int method_enable_unit_files_generic(
2029 sd_bus_message
*message
,
2031 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, unsigned *n_changes
),
2032 bool carries_install_info
,
2033 sd_bus_error
*error
) {
2035 _cleanup_strv_free_
char **l
= NULL
;
2036 UnitFileChange
*changes
= NULL
;
2037 unsigned n_changes
= 0;
2038 UnitFileFlags flags
;
2039 int runtime
, force
, r
;
2044 r
= sd_bus_message_read_strv(message
, &l
);
2048 r
= sd_bus_message_read(message
, "bb", &runtime
, &force
);
2052 flags
= unit_file_bools_to_flags(runtime
, force
);
2054 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2058 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2060 r
= call(m
->unit_file_scope
, flags
, NULL
, l
, &changes
, &n_changes
);
2062 return install_error(error
, r
, changes
, n_changes
);
2064 return reply_unit_file_changes_and_free(m
, message
, carries_install_info
? r
: -1, changes
, n_changes
, error
);
2067 static int method_enable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2068 return method_enable_unit_files_generic(message
, userdata
, unit_file_enable
, true, error
);
2071 static int method_reenable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2072 return method_enable_unit_files_generic(message
, userdata
, unit_file_reenable
, true, error
);
2075 static int method_link_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2076 return method_enable_unit_files_generic(message
, userdata
, unit_file_link
, false, error
);
2079 static int unit_file_preset_without_mode(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char **files
, UnitFileChange
**changes
, unsigned *n_changes
) {
2080 return unit_file_preset(scope
, flags
, root_dir
, files
, UNIT_FILE_PRESET_FULL
, changes
, n_changes
);
2083 static int method_preset_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2084 return method_enable_unit_files_generic(message
, userdata
, unit_file_preset_without_mode
, true, error
);
2087 static int method_mask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2088 return method_enable_unit_files_generic(message
, userdata
, unit_file_mask
, false, error
);
2091 static int method_preset_unit_files_with_mode(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2093 _cleanup_strv_free_
char **l
= NULL
;
2094 UnitFileChange
*changes
= NULL
;
2095 unsigned n_changes
= 0;
2096 Manager
*m
= userdata
;
2097 UnitFilePresetMode mm
;
2098 int runtime
, force
, r
;
2099 UnitFileFlags flags
;
2105 r
= sd_bus_message_read_strv(message
, &l
);
2109 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2113 flags
= unit_file_bools_to_flags(runtime
, force
);
2116 mm
= UNIT_FILE_PRESET_FULL
;
2118 mm
= unit_file_preset_mode_from_string(mode
);
2123 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2127 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2129 r
= unit_file_preset(m
->unit_file_scope
, flags
, NULL
, l
, mm
, &changes
, &n_changes
);
2131 return install_error(error
, r
, changes
, n_changes
);
2133 return reply_unit_file_changes_and_free(m
, message
, r
, changes
, n_changes
, error
);
2136 static int method_disable_unit_files_generic(
2137 sd_bus_message
*message
,
2139 int (*call
)(UnitFileScope scope
, UnitFileFlags flags
, const char *root_dir
, char *files
[], UnitFileChange
**changes
, unsigned *n_changes
),
2140 sd_bus_error
*error
) {
2142 _cleanup_strv_free_
char **l
= NULL
;
2143 UnitFileChange
*changes
= NULL
;
2144 unsigned n_changes
= 0;
2150 r
= sd_bus_message_read_strv(message
, &l
);
2154 r
= sd_bus_message_read(message
, "b", &runtime
);
2158 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2162 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2164 r
= call(m
->unit_file_scope
, runtime
? UNIT_FILE_RUNTIME
: 0, NULL
, l
, &changes
, &n_changes
);
2166 return install_error(error
, r
, changes
, n_changes
);
2168 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2171 static int method_disable_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2172 return method_disable_unit_files_generic(message
, userdata
, unit_file_disable
, error
);
2175 static int method_unmask_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2176 return method_disable_unit_files_generic(message
, userdata
, unit_file_unmask
, error
);
2179 static int method_revert_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2180 _cleanup_strv_free_
char **l
= NULL
;
2181 UnitFileChange
*changes
= NULL
;
2182 unsigned n_changes
= 0;
2183 Manager
*m
= userdata
;
2189 r
= sd_bus_message_read_strv(message
, &l
);
2193 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2197 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2199 r
= unit_file_revert(m
->unit_file_scope
, NULL
, l
, &changes
, &n_changes
);
2201 return install_error(error
, r
, changes
, n_changes
);
2203 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2206 static int method_set_default_target(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2207 UnitFileChange
*changes
= NULL
;
2208 unsigned n_changes
= 0;
2209 Manager
*m
= userdata
;
2216 r
= mac_selinux_access_check(message
, "enable", error
);
2220 r
= sd_bus_message_read(message
, "sb", &name
, &force
);
2224 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2228 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2230 r
= unit_file_set_default(m
->unit_file_scope
, force
? UNIT_FILE_FORCE
: 0, NULL
, name
, &changes
, &n_changes
);
2232 return install_error(error
, r
, changes
, n_changes
);
2234 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2237 static int method_preset_all_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2238 UnitFileChange
*changes
= NULL
;
2239 unsigned n_changes
= 0;
2240 Manager
*m
= userdata
;
2241 UnitFilePresetMode mm
;
2243 UnitFileFlags flags
;
2244 int force
, runtime
, r
;
2249 r
= mac_selinux_access_check(message
, "enable", error
);
2253 r
= sd_bus_message_read(message
, "sbb", &mode
, &runtime
, &force
);
2257 flags
= unit_file_bools_to_flags(runtime
, force
);
2260 mm
= UNIT_FILE_PRESET_FULL
;
2262 mm
= unit_file_preset_mode_from_string(mode
);
2267 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2271 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2273 r
= unit_file_preset_all(m
->unit_file_scope
, flags
, NULL
, mm
, &changes
, &n_changes
);
2275 return install_error(error
, r
, changes
, n_changes
);
2277 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2280 static int method_add_dependency_unit_files(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2281 _cleanup_strv_free_
char **l
= NULL
;
2282 Manager
*m
= userdata
;
2283 UnitFileChange
*changes
= NULL
;
2284 unsigned n_changes
= 0;
2285 int runtime
, force
, r
;
2286 char *target
, *type
;
2288 UnitFileFlags flags
;
2293 r
= bus_verify_manage_unit_files_async(m
, message
, error
);
2297 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2299 r
= sd_bus_message_read_strv(message
, &l
);
2303 r
= sd_bus_message_read(message
, "ssbb", &target
, &type
, &runtime
, &force
);
2307 flags
= unit_file_bools_to_flags(runtime
, force
);
2309 dep
= unit_dependency_from_string(type
);
2313 r
= unit_file_add_dependency(m
->unit_file_scope
, flags
, NULL
, l
, target
, dep
, &changes
, &n_changes
);
2315 return install_error(error
, r
, changes
, n_changes
);
2317 return reply_unit_file_changes_and_free(m
, message
, -1, changes
, n_changes
, error
);
2320 static int method_get_unit_file_links(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2321 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2322 UnitFileChange
*changes
= NULL
;
2323 unsigned n_changes
= 0, i
;
2324 UnitFileFlags flags
;
2329 r
= sd_bus_message_read(message
, "sb", &name
, &runtime
);
2333 r
= sd_bus_message_new_method_return(message
, &reply
);
2337 r
= sd_bus_message_open_container(reply
, SD_BUS_TYPE_ARRAY
, "s");
2341 p
= STRV_MAKE(name
);
2342 flags
= UNIT_FILE_DRY_RUN
|
2343 (runtime
? UNIT_FILE_RUNTIME
: 0);
2345 r
= unit_file_disable(UNIT_FILE_SYSTEM
, flags
, NULL
, p
, &changes
, &n_changes
);
2347 return log_error_errno(r
, "Failed to get file links for %s: %m", name
);
2349 for (i
= 0; i
< n_changes
; i
++)
2350 if (changes
[i
].type
== UNIT_FILE_UNLINK
) {
2351 r
= sd_bus_message_append(reply
, "s", changes
[i
].path
);
2356 r
= sd_bus_message_close_container(reply
);
2360 return sd_bus_send(NULL
, reply
, NULL
);
2363 static int method_get_job_waiting(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2364 Manager
*m
= userdata
;
2372 r
= sd_bus_message_read(message
, "u", &id
);
2376 j
= manager_get_job(m
, id
);
2378 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_JOB
, "Job %u does not exist.", (unsigned) id
);
2380 return bus_job_method_get_waiting_jobs(message
, j
, error
);
2383 const sd_bus_vtable bus_manager_vtable
[] = {
2384 SD_BUS_VTABLE_START(0),
2386 SD_BUS_PROPERTY("Version", "s", property_get_version
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2387 SD_BUS_PROPERTY("Features", "s", property_get_features
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2388 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2389 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2390 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2391 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FIRMWARE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2392 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_LOADER
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2393 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_KERNEL
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2394 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_INITRD
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2395 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_USERSPACE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2396 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2397 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2398 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_SECURITY_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2399 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2400 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_GENERATORS_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2401 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_START
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2402 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager
, timestamps
[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2403 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level
, property_set_log_level
, 0, 0),
2404 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target
, property_set_log_target
, 0, 0),
2405 SD_BUS_PROPERTY("NNames", "u", property_get_n_names
, 0, 0),
2406 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_n_failed_units
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2407 SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs
, 0, 0),
2408 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_installed_jobs
), 0),
2409 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned
, offsetof(Manager
, n_failed_jobs
), 0),
2410 SD_BUS_PROPERTY("Progress", "d", property_get_progress
, 0, 0),
2411 SD_BUS_PROPERTY("Environment", "as", NULL
, offsetof(Manager
, environment
), 0),
2412 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool
, offsetof(Manager
, confirm_spawn
), SD_BUS_VTABLE_PROPERTY_CONST
),
2413 SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool
, offsetof(Manager
, show_status
), SD_BUS_VTABLE_PROPERTY_CONST
),
2414 SD_BUS_PROPERTY("UnitPath", "as", NULL
, offsetof(Manager
, lookup_paths
.search_path
), SD_BUS_VTABLE_PROPERTY_CONST
),
2415 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2416 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output
, offsetof(Manager
, default_std_output
), SD_BUS_VTABLE_PROPERTY_CONST
),
2417 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec
, property_set_runtime_watchdog
, offsetof(Manager
, runtime_watchdog
), 0),
2418 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec
, bus_property_set_usec
, offsetof(Manager
, shutdown_watchdog
), 0),
2419 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool
, bus_property_set_bool
, offsetof(Manager
, service_watchdogs
), 0),
2420 SD_BUS_PROPERTY("ControlGroup", "s", NULL
, offsetof(Manager
, cgroup_root
), 0),
2421 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state
, 0, 0),
2422 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned
, offsetof(Manager
, return_value
), 0),
2423 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timer_accuracy_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2424 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_start_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2425 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_timeout_stop_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2426 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_restart_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2427 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
),
2428 /* The following two items are obsolete alias */
2429 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2430 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec
, offsetof(Manager
, default_start_limit_interval
), SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
2431 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned
, offsetof(Manager
, default_start_limit_burst
), SD_BUS_VTABLE_PROPERTY_CONST
),
2432 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_cpu_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2433 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_blockio_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2434 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_memory_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2435 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool
, offsetof(Manager
, default_tasks_accounting
), SD_BUS_VTABLE_PROPERTY_CONST
),
2436 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2437 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CPU
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2438 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2439 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_FSIZE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2440 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2441 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_DATA
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2442 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2443 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_STACK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2444 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2445 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_CORE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2446 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2447 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RSS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2448 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2449 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NOFILE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2450 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2451 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_AS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2452 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2453 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NPROC
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2454 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2455 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MEMLOCK
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2456 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2457 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_LOCKS
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2458 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2459 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_SIGPENDING
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2460 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2461 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_MSGQUEUE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2462 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2463 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_NICE
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2464 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2465 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTPRIO
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2466 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2467 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit
, offsetof(Manager
, rlimit
[RLIMIT_RTTIME
]), SD_BUS_VTABLE_PROPERTY_CONST
),
2468 SD_BUS_PROPERTY("DefaultTasksMax", "t", NULL
, offsetof(Manager
, default_tasks_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2469 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2471 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2472 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2473 SD_BUS_METHOD("GetUnitByInvocationID", "ay", "o", method_get_unit_by_invocation_id
, SD_BUS_VTABLE_UNPRIVILEGED
),
2474 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2475 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2476 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace
, SD_BUS_VTABLE_UNPRIVILEGED
),
2477 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2478 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2479 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2480 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2481 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2482 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2483 SD_BUS_METHOD("KillUnit", "ssi", NULL
, method_kill_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2484 SD_BUS_METHOD("ResetFailedUnit", "s", NULL
, method_reset_failed_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2485 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL
, method_set_unit_properties
, SD_BUS_VTABLE_UNPRIVILEGED
),
2486 SD_BUS_METHOD("RefUnit", "s", NULL
, method_ref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2487 SD_BUS_METHOD("UnrefUnit", "s", NULL
, method_unref_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2488 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2489 SD_BUS_METHOD("GetUnitProcesses", "s", "a(sus)", method_get_unit_processes
, SD_BUS_VTABLE_UNPRIVILEGED
),
2490 SD_BUS_METHOD("GetJob", "u", "o", method_get_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2491 SD_BUS_METHOD("GetJobAfter", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2492 SD_BUS_METHOD("GetJobBefore", "u", "a(usssoo)", method_get_job_waiting
, SD_BUS_VTABLE_UNPRIVILEGED
),
2493 SD_BUS_METHOD("CancelJob", "u", NULL
, method_cancel_job
, SD_BUS_VTABLE_UNPRIVILEGED
),
2494 SD_BUS_METHOD("ClearJobs", NULL
, NULL
, method_clear_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2495 SD_BUS_METHOD("ResetFailed", NULL
, NULL
, method_reset_failed
, SD_BUS_VTABLE_UNPRIVILEGED
),
2496 SD_BUS_METHOD("ListUnits", NULL
, "a(ssssssouso)", method_list_units
, SD_BUS_VTABLE_UNPRIVILEGED
),
2497 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered
, SD_BUS_VTABLE_UNPRIVILEGED
),
2498 SD_BUS_METHOD("ListUnitsByPatterns", "asas", "a(ssssssouso)", method_list_units_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2499 SD_BUS_METHOD("ListUnitsByNames", "as", "a(ssssssouso)", method_list_units_by_names
, SD_BUS_VTABLE_UNPRIVILEGED
),
2500 SD_BUS_METHOD("ListJobs", NULL
, "a(usssoo)", method_list_jobs
, SD_BUS_VTABLE_UNPRIVILEGED
),
2501 SD_BUS_METHOD("Subscribe", NULL
, NULL
, method_subscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2502 SD_BUS_METHOD("Unsubscribe", NULL
, NULL
, method_unsubscribe
, SD_BUS_VTABLE_UNPRIVILEGED
),
2503 SD_BUS_METHOD("Dump", NULL
, "s", method_dump
, SD_BUS_VTABLE_UNPRIVILEGED
),
2504 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2505 SD_BUS_METHOD("RemoveSnapshot", "s", NULL
, method_refuse_snapshot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2506 SD_BUS_METHOD("Reload", NULL
, NULL
, method_reload
, SD_BUS_VTABLE_UNPRIVILEGED
),
2507 SD_BUS_METHOD("Reexecute", NULL
, NULL
, method_reexecute
, SD_BUS_VTABLE_UNPRIVILEGED
),
2508 SD_BUS_METHOD("Exit", NULL
, NULL
, method_exit
, 0),
2509 SD_BUS_METHOD("Reboot", NULL
, NULL
, method_reboot
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2510 SD_BUS_METHOD("PowerOff", NULL
, NULL
, method_poweroff
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2511 SD_BUS_METHOD("Halt", NULL
, NULL
, method_halt
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2512 SD_BUS_METHOD("KExec", NULL
, NULL
, method_kexec
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2513 SD_BUS_METHOD("SwitchRoot", "ss", NULL
, method_switch_root
, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT
)),
2514 SD_BUS_METHOD("SetEnvironment", "as", NULL
, method_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2515 SD_BUS_METHOD("UnsetEnvironment", "as", NULL
, method_unset_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2516 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL
, method_unset_and_set_environment
, SD_BUS_VTABLE_UNPRIVILEGED
),
2517 SD_BUS_METHOD("ListUnitFiles", NULL
, "a(ss)", method_list_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2518 SD_BUS_METHOD("ListUnitFilesByPatterns", "asas", "a(ss)", method_list_unit_files_by_patterns
, SD_BUS_VTABLE_UNPRIVILEGED
),
2519 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state
, SD_BUS_VTABLE_UNPRIVILEGED
),
2520 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2521 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2522 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2523 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2524 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2525 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode
, SD_BUS_VTABLE_UNPRIVILEGED
),
2526 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2527 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2528 SD_BUS_METHOD("RevertUnitFiles", "as", "a(sss)", method_revert_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2529 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2530 SD_BUS_METHOD("GetDefaultTarget", NULL
, "s", method_get_default_target
, SD_BUS_VTABLE_UNPRIVILEGED
),
2531 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2532 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files
, SD_BUS_VTABLE_UNPRIVILEGED
),
2533 SD_BUS_METHOD("GetUnitFileLinks", "sb", "as", method_get_unit_file_links
, SD_BUS_VTABLE_UNPRIVILEGED
),
2534 SD_BUS_METHOD("SetExitCode", "y", NULL
, method_set_exit_code
, SD_BUS_VTABLE_UNPRIVILEGED
),
2535 SD_BUS_METHOD("LookupDynamicUserByName", "s", "u", method_lookup_dynamic_user_by_name
, SD_BUS_VTABLE_UNPRIVILEGED
),
2536 SD_BUS_METHOD("LookupDynamicUserByUID", "u", "s", method_lookup_dynamic_user_by_uid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2538 SD_BUS_SIGNAL("UnitNew", "so", 0),
2539 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2540 SD_BUS_SIGNAL("JobNew", "uos", 0),
2541 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2542 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2543 SD_BUS_SIGNAL("UnitFilesChanged", NULL
, 0),
2544 SD_BUS_SIGNAL("Reloading", "b", 0),
2549 static int send_finished(sd_bus
*bus
, void *userdata
) {
2550 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2551 usec_t
*times
= userdata
;
2557 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2561 r
= sd_bus_message_append(message
, "tttttt", times
[0], times
[1], times
[2], times
[3], times
[4], times
[5]);
2565 return sd_bus_send(bus
, message
, NULL
);
2568 void bus_manager_send_finished(
2570 usec_t firmware_usec
,
2574 usec_t userspace_usec
,
2575 usec_t total_usec
) {
2581 r
= bus_foreach_bus(
2594 log_debug_errno(r
, "Failed to send finished signal: %m");
2597 static int send_reloading(sd_bus
*bus
, void *userdata
) {
2598 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*message
= NULL
;
2603 r
= sd_bus_message_new_signal(bus
, &message
, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2607 r
= sd_bus_message_append(message
, "b", PTR_TO_INT(userdata
));
2611 return sd_bus_send(bus
, message
, NULL
);
2614 void bus_manager_send_reloading(Manager
*m
, bool active
) {
2619 r
= bus_foreach_bus(m
, NULL
, send_reloading
, INT_TO_PTR(active
));
2621 log_debug_errno(r
, "Failed to send reloading signal: %m");
2624 static int send_changed_signal(sd_bus
*bus
, void *userdata
) {
2627 return sd_bus_emit_properties_changed_strv(bus
,
2628 "/org/freedesktop/systemd1",
2629 "org.freedesktop.systemd1.Manager",
2633 void bus_manager_send_change_signal(Manager
*m
) {
2638 r
= bus_foreach_bus(m
, NULL
, send_changed_signal
, NULL
);
2640 log_debug_errno(r
, "Failed to send manager change signal: %m");