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/>.
29 #include "selinux-access.h"
32 #include "path-util.h"
36 #include "dbus-manager.h"
37 #include "dbus-unit.h"
38 #include "dbus-snapshot.h"
39 #include "dbus-client-track.h"
40 #include "dbus-execute.h"
41 #include "bus-errors.h"
43 static int property_get_version(
46 const char *interface,
48 sd_bus_message *reply,
55 return sd_bus_message_append(reply, "s", PACKAGE_VERSION);
58 static int property_get_features(
61 const char *interface,
63 sd_bus_message *reply,
70 return sd_bus_message_append(reply, "s", SYSTEMD_FEATURES);
73 static int property_get_virtualization(
76 const char *interface,
78 sd_bus_message *reply,
82 const char *id = NULL;
87 detect_virtualization(&id);
89 return sd_bus_message_append(reply, "s", id);
92 static int property_get_tainted(
95 const char *interface,
97 sd_bus_message *reply,
101 char buf[LINE_MAX] = "", *e = buf;
102 _cleanup_free_ char *p = NULL;
103 Manager *m = userdata;
110 e = stpcpy(e, "split-usr:");
112 if (readlink_malloc("/etc/mtab", &p) < 0)
113 e = stpcpy(e, "mtab-not-symlink:");
115 if (access("/proc/cgroups", F_OK) < 0)
116 e = stpcpy(e, "cgroups-missing:");
118 if (hwclock_is_localtime() > 0)
119 e = stpcpy(e, "local-hwclock:");
121 /* remove the last ':' */
125 return sd_bus_message_append(reply, "s", buf);
128 static int property_get_log_target(
131 const char *interface,
132 const char *property,
133 sd_bus_message *reply,
140 return sd_bus_message_append(reply, "s", log_target_to_string(log_get_target()));
143 static int property_set_log_target(
146 const char *interface,
147 const char *property,
148 sd_bus_message *value,
158 r = sd_bus_message_read(value, "s", &t);
162 return log_set_target_from_string(t);
165 static int property_get_log_level(
168 const char *interface,
169 const char *property,
170 sd_bus_message *reply,
174 _cleanup_free_ char *t = NULL;
180 r = log_level_to_string_alloc(log_get_max_level(), &t);
184 return sd_bus_message_append(reply, "s", t);
187 static int property_set_log_level(
190 const char *interface,
191 const char *property,
192 sd_bus_message *value,
202 r = sd_bus_message_read(value, "s", &t);
206 return log_set_max_level_from_string(t);
209 static int property_get_n_names(
212 const char *interface,
213 const char *property,
214 sd_bus_message *reply,
218 Manager *m = userdata;
224 return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->units));
227 static int property_get_n_jobs(
230 const char *interface,
231 const char *property,
232 sd_bus_message *reply,
236 Manager *m = userdata;
242 return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->jobs));
245 static int property_get_progress(
248 const char *interface,
249 const char *property,
250 sd_bus_message *reply,
254 Manager *m = userdata;
261 if (dual_timestamp_is_set(&m->finish_timestamp))
264 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
266 return sd_bus_message_append(reply, "d", d);
269 static int property_set_runtime_watchdog(
272 const char *interface,
273 const char *property,
274 sd_bus_message *value,
278 usec_t *t = userdata;
284 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
286 r = sd_bus_message_read(value, "t", t);
290 return watchdog_set_timeout(t);
293 static int method_get_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
294 _cleanup_free_ char *path = NULL;
295 Manager *m = userdata;
304 r = sd_bus_message_read(message, "s", &name);
306 return sd_bus_reply_method_errno(bus, message, r, NULL);
308 u = manager_get_unit(m, name);
310 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
312 SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
314 path = unit_dbus_path(u);
316 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
318 return sd_bus_reply_method_return(bus, message, "o", path);
321 static int method_get_unit_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
322 _cleanup_free_ char *path = NULL;
323 Manager *m = userdata;
332 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
334 r = sd_bus_message_read(message, "u", &pid);
336 return sd_bus_reply_method_errno(bus, message, r, NULL);
339 r = sd_bus_get_owner_pid(bus, sd_bus_message_get_sender(message), &pid);
341 return sd_bus_reply_method_errno(bus, message, r, NULL);
344 u = manager_get_unit_by_pid(m, pid);
346 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_UNIT_FOR_PID, "PID %u does not belong to any loaded unit.", pid);
348 SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
350 path = unit_dbus_path(u);
352 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
354 return sd_bus_reply_method_return(bus, message, "o", path);
357 static int method_load_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
358 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
359 _cleanup_free_ char *path = NULL;
360 Manager *m = userdata;
369 r = sd_bus_message_read(message, "s", &name);
371 return sd_bus_reply_method_errno(bus, message, r, NULL);
373 r = manager_load_unit(m, name, NULL, &error, &u);
375 return sd_bus_reply_method_errno(bus, message, r, &error);
377 SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
379 path = unit_dbus_path(u);
381 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
383 return sd_bus_reply_method_return(bus, message, "o", path);
386 static int method_start_unit_generic(sd_bus *bus, sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible) {
387 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
396 r = sd_bus_message_read(message, "s", &name);
398 return sd_bus_reply_method_errno(bus, message, r, NULL);
400 r = manager_load_unit(m, name, NULL, &error, &u);
402 return sd_bus_reply_method_errno(bus, message, r, &error);
404 return bus_unit_method_start_generic(bus, message, u, job_type, reload_if_possible);
407 static int method_start_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
408 return method_start_unit_generic(bus, message, userdata, JOB_START, false);
411 static int method_stop_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
412 return method_start_unit_generic(bus, message, userdata, JOB_STOP, false);
415 static int method_reload_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
416 return method_start_unit_generic(bus, message, userdata, JOB_RELOAD, false);
419 static int method_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
420 return method_start_unit_generic(bus, message, userdata, JOB_RESTART, false);
423 static int method_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
424 return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, false);
427 static int method_reload_or_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
428 return method_start_unit_generic(bus, message, userdata, JOB_RESTART, true);
431 static int method_reload_or_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
432 return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, true);
435 static int method_start_unit_replace(sd_bus *bus, sd_bus_message *message, void *userdata) {
436 Manager *m = userdata;
437 const char *old_name;
445 r = sd_bus_message_read(message, "s", &old_name);
447 return sd_bus_reply_method_errno(bus, message, r, NULL);
449 u = manager_get_unit(m, old_name);
450 if (!u || !u->job || u->job->type != JOB_START)
451 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
453 return method_start_unit_generic(bus, message, m, JOB_START, false);
456 static int method_kill_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
457 Manager *m = userdata;
466 r = sd_bus_message_read(message, "s", &name);
468 return sd_bus_reply_method_errno(bus, message, r, NULL);
470 u = manager_get_unit(m, name);
472 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
474 return bus_unit_method_kill(bus, message, u);
477 static int method_reset_failed_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
478 Manager *m = userdata;
487 r = sd_bus_message_read(message, "s", &name);
489 return sd_bus_reply_method_errno(bus, message, r, NULL);
491 u = manager_get_unit(m, name);
493 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
495 return bus_unit_method_reset_failed(bus, message, u);
498 static int method_set_unit_properties(sd_bus *bus, sd_bus_message *message, void *userdata) {
499 Manager *m = userdata;
508 r = sd_bus_message_read(message, "s", &name);
510 return sd_bus_reply_method_errno(bus, message, r, NULL);
512 u = manager_get_unit(m, name);
514 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
516 return bus_unit_method_set_properties(bus, message, u);
519 static int method_start_transient_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
520 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
521 const char *name, *smode;
522 Manager *m = userdata;
532 r = sd_bus_message_read(message, "ss", &name, &smode);
534 return sd_bus_reply_method_errno(bus, message, r, NULL);
536 t = unit_name_to_type(name);
538 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit type.");
540 if (!unit_vtable[t]->can_transient)
541 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Unit type %s does not support transient units.");
543 mode = job_mode_from_string(smode);
545 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
547 r = manager_load_unit(m, name, NULL, &error, &u);
549 return sd_bus_reply_method_errno(bus, message, r, &error);
551 SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "start");
553 if (u->load_state != UNIT_NOT_FOUND || set_size(u->dependencies[UNIT_REFERENCED_BY]) > 0)
554 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_UNIT_EXISTS, "Unit %s already exists.", name);
556 /* OK, the unit failed to load and is unreferenced, now let's
557 * fill in the transient data instead */
558 r = unit_make_transient(u);
560 return sd_bus_reply_method_errno(bus, message, r, NULL);
562 /* Set our properties */
563 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, &error);
565 return sd_bus_reply_method_errno(bus, message, r, &error);
567 /* And load this stub fully */
570 return sd_bus_reply_method_errno(bus, message, r, &error);
572 manager_dispatch_load_queue(m);
574 /* Finally, start it */
575 return bus_unit_queue_job(bus, message, u, JOB_START, mode, false);
578 static int method_get_job(sd_bus *bus, sd_bus_message *message, void *userdata) {
579 _cleanup_free_ char *path = NULL;
580 Manager *m = userdata;
589 r = sd_bus_message_read(message, "u", &id);
591 return sd_bus_reply_method_errno(bus, message, r, NULL);
593 j = manager_get_job(m, id);
595 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
597 SELINUX_UNIT_ACCESS_CHECK(j->unit, bus, message, "status");
599 path = job_dbus_path(j);
601 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
603 return sd_bus_reply_method_return(bus, message, "o", path);
606 static int method_cancel_job(sd_bus *bus, sd_bus_message *message, void *userdata) {
607 Manager *m = userdata;
616 r = sd_bus_message_read(message, "u", &id);
618 return sd_bus_reply_method_errno(bus, message, r, NULL);
620 j = manager_get_job(m, id);
622 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
624 SELINUX_UNIT_ACCESS_CHECK(j->unit, bus, message, "stop");
626 job_finish_and_invalidate(j, JOB_CANCELED, true);
628 return sd_bus_reply_method_return(bus, message, NULL);
631 static int method_clear_jobs(sd_bus *bus, sd_bus_message *message, void *userdata) {
632 Manager *m = userdata;
638 SELINUX_ACCESS_CHECK(bus, message, "reboot");
639 manager_clear_jobs(m);
641 return sd_bus_reply_method_return(bus, message, NULL);
644 static int method_reset_failed(sd_bus *bus, sd_bus_message *message, void *userdata) {
645 Manager *m = userdata;
651 SELINUX_ACCESS_CHECK(bus, message, "reload");
652 manager_reset_failed(m);
654 return sd_bus_reply_method_return(bus, message, NULL);
657 static int method_list_units(sd_bus *bus, sd_bus_message *message, void *userdata) {
658 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
659 Manager *m = userdata;
669 SELINUX_ACCESS_CHECK(bus, message, "status");
671 r = sd_bus_message_new_method_return(bus, message, &reply);
673 return sd_bus_reply_method_errno(bus, message, r, NULL);
675 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
677 return sd_bus_reply_method_errno(bus, message, r, NULL);
679 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
680 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
686 following = unit_following(u);
688 unit_path = unit_dbus_path(u);
690 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
693 job_path = job_dbus_path(u->job);
695 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
698 r = sd_bus_message_append(
699 reply, "(ssssssouso)",
702 unit_load_state_to_string(u->load_state),
703 unit_active_state_to_string(unit_active_state(u)),
704 unit_sub_state_to_string(u),
705 following ? following->id : "",
707 u->job ? u->job->id : 0,
708 u->job ? job_type_to_string(u->job->type) : "",
709 job_path ? job_path : "/");
711 return sd_bus_reply_method_errno(bus, message, r, NULL);
714 r = sd_bus_message_close_container(reply);
716 return sd_bus_reply_method_errno(bus, message, r, NULL);
718 return sd_bus_send(bus, reply, NULL);
721 static int method_list_jobs(sd_bus *bus, sd_bus_message *message, void *userdata) {
722 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
723 Manager *m = userdata;
732 SELINUX_ACCESS_CHECK(bus, message, "status");
734 r = sd_bus_message_new_method_return(bus, message, &reply);
736 return sd_bus_reply_method_errno(bus, message, r, NULL);
738 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
740 return sd_bus_reply_method_errno(bus, message, r, NULL);
742 HASHMAP_FOREACH(j, m->jobs, i) {
743 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
745 job_path = job_dbus_path(j);
747 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
749 unit_path = unit_dbus_path(j->unit);
751 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
753 r = sd_bus_message_append(
756 job_state_to_string(j->state),
757 job_type_to_string(j->type),
761 return sd_bus_reply_method_errno(bus, message, r, NULL);
764 r = sd_bus_message_close_container(reply);
766 return sd_bus_reply_method_errno(bus, message, r, NULL);
768 return sd_bus_send(bus, reply, NULL);
771 static int method_subscribe(sd_bus *bus, sd_bus_message *message, void *userdata) {
772 Manager *m = userdata;
779 SELINUX_ACCESS_CHECK(bus, message, "status");
781 r = bus_client_track(&m->subscribed, bus, sd_bus_message_get_sender(message));
783 return sd_bus_reply_method_errno(bus, message, r, NULL);
785 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
787 return sd_bus_reply_method_return(bus, message, NULL);
790 static int method_unsubscribe(sd_bus *bus, sd_bus_message *message, void *userdata) {
791 Manager *m = userdata;
798 SELINUX_ACCESS_CHECK(bus, message, "status");
800 r = bus_client_untrack(m->subscribed, bus, sd_bus_message_get_sender(message));
802 return sd_bus_reply_method_errno(bus, message, r, NULL);
804 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
806 return sd_bus_reply_method_return(bus, message, NULL);
809 static int method_dump(sd_bus *bus, sd_bus_message *message, void *userdata) {
810 _cleanup_free_ char *dump = NULL;
811 _cleanup_fclose_ FILE *f = NULL;
812 Manager *m = userdata;
819 SELINUX_ACCESS_CHECK(bus, message, "status");
821 f = open_memstream(&dump, &size);
823 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
825 manager_dump_units(m, f, NULL);
826 manager_dump_jobs(m, f, NULL);
831 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
833 return sd_bus_reply_method_return(bus, message, "s", dump);
836 static int method_create_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata) {
837 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
838 _cleanup_free_ char *path = NULL;
839 Manager *m = userdata;
849 SELINUX_ACCESS_CHECK(bus, message, "start");
851 r = sd_bus_message_read(message, "sb", &name, &cleanup);
853 return sd_bus_reply_method_errno(bus, message, r, NULL);
858 r = snapshot_create(m, name, cleanup, &error, &s);
860 return sd_bus_reply_method_errno(bus, message, r, &error);
862 path = unit_dbus_path(UNIT(s));
864 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
866 return sd_bus_reply_method_return(bus, message, "o", path);
869 static int method_remove_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata) {
870 Manager *m = userdata;
879 SELINUX_ACCESS_CHECK(bus, message, "start");
881 r = sd_bus_message_read(message, "s", &name);
883 return sd_bus_reply_method_errno(bus, message, r, NULL);
885 u = manager_get_unit(m, name);
887 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s does not exist.", name);
889 if (u->type != UNIT_SNAPSHOT)
890 return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not a snapshot", name);
892 return bus_snapshot_method_remove(bus, message, u);
895 static int method_reload(sd_bus *bus, sd_bus_message *message, void *userdata) {
896 Manager *m = userdata;
903 SELINUX_ACCESS_CHECK(bus, message, "reload");
905 /* Instead of sending the reply back right away, we just
906 * remember that we need to and then send it after the reload
907 * is finished. That way the caller knows when the reload
910 assert(!m->queued_message);
911 r = sd_bus_message_new_method_return(bus, message, &m->queued_message);
913 return sd_bus_reply_method_errno(bus, message, r, NULL);
915 m->queued_message_bus = sd_bus_ref(bus);
916 m->exit_code = MANAGER_RELOAD;
921 static int method_reexecute(sd_bus *bus, sd_bus_message *message, void *userdata) {
922 Manager *m = userdata;
928 SELINUX_ACCESS_CHECK(bus, message, "reload");
930 /* We don't send a reply back here, the client should
931 * just wait for us disconnecting. */
933 m->exit_code = MANAGER_REEXECUTE;
937 static int method_exit(sd_bus *bus, sd_bus_message *message, void *userdata) {
938 Manager *m = userdata;
944 SELINUX_ACCESS_CHECK(bus, message, "halt");
946 if (m->running_as == SYSTEMD_SYSTEM)
947 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "Exit is only supported for user service managers.");
949 m->exit_code = MANAGER_EXIT;
951 return sd_bus_reply_method_return(bus, message, NULL);
954 static int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
955 Manager *m = userdata;
961 SELINUX_ACCESS_CHECK(bus, message, "reboot");
963 if (m->running_as != SYSTEMD_SYSTEM)
964 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
966 m->exit_code = MANAGER_REBOOT;
968 return sd_bus_reply_method_return(bus, message, NULL);
972 static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
973 Manager *m = userdata;
979 SELINUX_ACCESS_CHECK(bus, message, "halt");
981 if (m->running_as != SYSTEMD_SYSTEM)
982 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
984 m->exit_code = MANAGER_POWEROFF;
986 return sd_bus_reply_method_return(bus, message, NULL);
989 static int method_halt(sd_bus *bus, sd_bus_message *message, void *userdata) {
990 Manager *m = userdata;
996 SELINUX_ACCESS_CHECK(bus, message, "halt");
998 if (m->running_as != SYSTEMD_SYSTEM)
999 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "Halt is only supported for system managers.");
1001 m->exit_code = MANAGER_HALT;
1003 return sd_bus_reply_method_return(bus, message, NULL);
1006 static int method_kexec(sd_bus *bus, sd_bus_message *message, void *userdata) {
1007 Manager *m = userdata;
1013 SELINUX_ACCESS_CHECK(bus, message, "reboot");
1015 if (m->running_as != SYSTEMD_SYSTEM)
1016 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1018 m->exit_code = MANAGER_KEXEC;
1020 return sd_bus_reply_method_return(bus, message, NULL);
1023 static int method_switch_root(sd_bus *bus, sd_bus_message *message, void *userdata) {
1024 char *ri = NULL, *rt = NULL;
1025 const char *root, *init;
1026 Manager *m = userdata;
1033 SELINUX_ACCESS_CHECK(bus, message, "reboot");
1035 if (m->running_as != SYSTEMD_SYSTEM)
1036 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1038 r = sd_bus_message_read(message, "ss", &root, &init);
1040 return sd_bus_reply_method_errno(bus, message, r, NULL);
1042 if (path_equal(root, "/") || !path_is_absolute(root))
1043 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid switch root path %s", root);
1046 if (isempty(init)) {
1047 if (! path_is_os_tree(root))
1048 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Specified switch root path %s does not seem to be an OS tree. /etc/os-release is missing.", root);
1050 _cleanup_free_ char *p = NULL;
1052 if (!path_is_absolute(init))
1053 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid init path %s", init);
1055 p = strappend(root, init);
1057 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
1059 if (access(p, X_OK) < 0)
1060 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Specified init binary %s does not exist.", p);
1065 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
1067 if (!isempty(init)) {
1071 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
1075 free(m->switch_root);
1076 m->switch_root = rt;
1078 free(m->switch_root_init);
1079 m->switch_root_init = ri;
1081 return sd_bus_reply_method_return(bus, message, NULL);
1084 static int method_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1085 _cleanup_strv_free_ char **plus = NULL;
1086 Manager *m = userdata;
1093 SELINUX_ACCESS_CHECK(bus, message, "reload");
1095 r = sd_bus_message_read_strv(message, &plus);
1097 return sd_bus_reply_method_errno(bus, message, r, NULL);
1098 if (!strv_env_is_valid(plus))
1099 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1101 r = manager_environment_add(m, NULL, plus);
1103 return sd_bus_reply_method_errno(bus, message, r, NULL);
1105 return sd_bus_reply_method_return(bus, message, NULL);
1108 static int method_unset_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1109 _cleanup_strv_free_ char **minus = NULL;
1110 Manager *m = userdata;
1117 SELINUX_ACCESS_CHECK(bus, message, "reload");
1119 r = sd_bus_message_read_strv(message, &minus);
1121 return sd_bus_reply_method_errno(bus, message, r, NULL);
1123 if (!strv_env_name_or_assignment_is_valid(minus))
1124 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1126 r = manager_environment_add(m, minus, NULL);
1128 return sd_bus_reply_method_errno(bus, message, r, NULL);
1130 return sd_bus_reply_method_return(bus, message, NULL);
1133 static int method_unset_and_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1134 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1135 Manager *m = userdata;
1142 SELINUX_ACCESS_CHECK(bus, message, "reload");
1144 r = sd_bus_message_read_strv(message, &plus);
1146 return sd_bus_reply_method_errno(bus, message, r, NULL);
1148 r = sd_bus_message_read_strv(message, &minus);
1150 return sd_bus_reply_method_errno(bus, message, r, NULL);
1152 if (!strv_env_is_valid(plus))
1153 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1154 if (!strv_env_name_or_assignment_is_valid(minus))
1155 return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1157 r = manager_environment_add(m, minus, plus);
1159 return sd_bus_reply_method_errno(bus, message, r, NULL);
1161 return sd_bus_reply_method_return(bus, message, NULL);
1164 static int method_list_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1165 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1166 Manager *m = userdata;
1176 SELINUX_ACCESS_CHECK(bus, message, "status");
1178 r = sd_bus_message_new_method_return(bus, message, &reply);
1180 return sd_bus_reply_method_errno(bus, message, r, NULL);
1182 h = hashmap_new(string_hash_func, string_compare_func);
1184 return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
1186 r = unit_file_get_list(m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, h);
1188 r = sd_bus_reply_method_errno(bus, message, r, NULL);
1192 r = sd_bus_message_open_container(reply, 'a', "(ss)");
1194 r = sd_bus_reply_method_errno(bus, message, r, NULL);
1198 HASHMAP_FOREACH(item, h, i) {
1200 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
1202 r = sd_bus_reply_method_errno(bus, message, r, NULL);
1207 unit_file_list_free(h);
1209 r = sd_bus_message_close_container(reply);
1211 return sd_bus_reply_method_errno(bus, message, r, NULL);
1213 return sd_bus_send(bus, reply, NULL);
1216 unit_file_list_free(h);
1220 static int method_get_unit_file_state(sd_bus *bus, sd_bus_message *message, void *userdata) {
1221 Manager *m = userdata;
1223 UnitFileState state;
1224 UnitFileScope scope;
1231 SELINUX_ACCESS_CHECK(bus, message, "status");
1233 r = sd_bus_message_read(message, "s", &name);
1235 return sd_bus_reply_method_errno(bus, message, r, NULL);
1237 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1239 state = unit_file_get_state(scope, NULL, name);
1241 return sd_bus_reply_method_errno(bus, message, state, NULL);
1243 return sd_bus_reply_method_return(bus, message, "s", unit_file_state_to_string(state));
1246 static int method_get_default_target(sd_bus *bus, sd_bus_message *message, void *userdata) {
1247 _cleanup_free_ char *default_target = NULL;
1248 Manager *m = userdata;
1249 UnitFileScope scope;
1256 SELINUX_ACCESS_CHECK(bus, message, "status");
1258 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1260 r = unit_file_get_default(scope, NULL, &default_target);
1262 return sd_bus_reply_method_errno(bus, message, r, NULL);
1264 return sd_bus_reply_method_return(bus, message, "s", default_target);
1267 static int send_unit_files_changed(sd_bus *bus, const char *destination, void *userdata) {
1268 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1273 r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged", &message);
1277 return sd_bus_send_to(bus, message, destination, NULL);
1280 static int reply_unit_file_changes_and_free(
1283 sd_bus_message *message,
1284 int carries_install_info,
1285 UnitFileChange *changes,
1286 unsigned n_changes) {
1288 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1293 bus_manager_foreach_client(m, send_unit_files_changed, NULL);
1295 r = sd_bus_message_new_method_return(bus, message, &reply);
1299 if (carries_install_info >= 0) {
1300 r = sd_bus_message_append(reply, "b", carries_install_info);
1305 r = sd_bus_message_open_container(reply, 'a', "(sss)");
1309 for (i = 0; i < n_changes; i++) {
1310 r = sd_bus_message_append(
1312 unit_file_change_type_to_string(changes[i].type),
1319 r = sd_bus_message_close_container(reply);
1323 return sd_bus_send(bus, message, NULL);
1326 unit_file_changes_free(changes, n_changes);
1327 return sd_bus_reply_method_errno(bus, message, r, NULL);
1330 static int method_enable_unit_files_generic(
1332 sd_bus_message *message,
1335 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], bool force, UnitFileChange **changes, unsigned *n_changes),
1336 bool carries_install_info) {
1338 _cleanup_strv_free_ char **l = NULL;
1339 UnitFileChange *changes = NULL;
1340 unsigned n_changes = 0;
1341 UnitFileScope scope;
1342 int runtime, force, r;
1348 SELINUX_ACCESS_CHECK(bus, message, verb);
1350 r = sd_bus_message_read_strv(message, &l);
1352 return sd_bus_reply_method_errno(bus, message, r, NULL);
1354 r = sd_bus_message_read(message, "bb", &runtime, &force);
1356 return sd_bus_reply_method_errno(bus, message, r, NULL);
1358 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1360 r = call(scope, runtime, NULL, l, force, &changes, &n_changes);
1362 return sd_bus_reply_method_errno(bus, message, r, NULL);
1364 return reply_unit_file_changes_and_free(m, bus, message, carries_install_info ? r : -1, changes, n_changes);
1367 static int method_enable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1368 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_enable, true);
1371 static int method_reenable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1372 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_reenable, true);
1375 static int method_link_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1376 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_link, false);
1379 static int method_preset_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1380 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_preset, true);
1383 static int method_mask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1384 return method_enable_unit_files_generic(bus, message, userdata, "disable", unit_file_mask, false);
1387 static int method_disable_unit_files_generic(
1389 sd_bus_message *message,
1392 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], UnitFileChange **changes, unsigned *n_changes)) {
1394 _cleanup_strv_free_ char **l = NULL;
1395 UnitFileChange *changes = NULL;
1396 unsigned n_changes = 0;
1397 UnitFileScope scope;
1404 SELINUX_ACCESS_CHECK(bus, message, verb);
1406 r = sd_bus_message_read_strv(message, &l);
1408 return sd_bus_reply_method_errno(bus, message, r, NULL);
1410 r = sd_bus_message_read(message, "b", &runtime);
1412 return sd_bus_reply_method_errno(bus, message, r, NULL);
1414 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1416 r = call(scope, runtime, NULL, l, &changes, &n_changes);
1418 return sd_bus_reply_method_errno(bus, message, r, NULL);
1420 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1423 static int method_disable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1424 return method_disable_unit_files_generic(bus, message, userdata, "disable", unit_file_disable);
1427 static int method_unmask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1428 return method_disable_unit_files_generic(bus, message, userdata, "enable", unit_file_unmask);
1431 static int method_set_default_target(sd_bus *bus, sd_bus_message *message, void *userdata) {
1432 UnitFileChange *changes = NULL;
1433 unsigned n_changes = 0;
1434 Manager *m = userdata;
1435 UnitFileScope scope;
1443 SELINUX_ACCESS_CHECK(bus, message, "enable");
1445 r = sd_bus_message_read(message, "sb", &name, &force);
1447 return sd_bus_reply_method_errno(bus, message, r, NULL);
1449 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1451 r = unit_file_set_default(scope, NULL, name, force, &changes, &n_changes);
1453 return sd_bus_reply_method_errno(bus, message, r, NULL);
1455 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1458 const sd_bus_vtable bus_manager_vtable[] = {
1459 SD_BUS_VTABLE_START(0),
1461 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, 0),
1462 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, 0),
1463 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, 0),
1464 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, 0),
1465 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, firmware_timestamp), 0),
1466 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, loader_timestamp), 0),
1467 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, firmware_timestamp), 0),
1468 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, initrd_timestamp), 0),
1469 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, userspace_timestamp), 0),
1470 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, finish_timestamp), 0),
1471 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, security_start_timestamp), 0),
1472 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, security_finish_timestamp), 0),
1473 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, generators_start_timestamp), 0),
1474 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, generators_finish_timestamp), 0),
1475 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, units_load_start_timestamp), 0),
1476 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, units_load_finish_timestamp), 0),
1477 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level, property_set_log_level, 0, 0),
1478 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target, property_set_log_target, 0, 0),
1479 SD_BUS_PROPERTY("NNames", "u", property_get_n_names, 0, 0),
1480 SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs, 0, 0),
1481 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
1482 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
1483 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1484 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(Manager, environment), 0),
1485 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), 0),
1486 SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool, offsetof(Manager, show_status), 0),
1487 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.unit_path), 0),
1488 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), 0),
1489 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), 0),
1490 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec, property_set_runtime_watchdog, offsetof(Manager, runtime_watchdog), 0),
1491 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec, bus_property_set_usec, offsetof(Manager, shutdown_watchdog), 0),
1493 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit, 0),
1494 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid, 0),
1495 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit, 0),
1496 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit, 0),
1497 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace, 0),
1498 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit, 0),
1499 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit, 0),
1500 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit, 0),
1501 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit, 0),
1502 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit, 0),
1503 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit, 0),
1504 SD_BUS_METHOD("KillUnit", "ssi", NULL, method_kill_unit, 0),
1505 SD_BUS_METHOD("ResetFailedUnit", "s", NULL, method_reset_failed_unit, 0),
1506 SD_BUS_METHOD("SetUnitProperties", "sb", "a(sv)", method_set_unit_properties, 0),
1507 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit, 0),
1508 SD_BUS_METHOD("GetJob", "u", "o", method_get_job, 0),
1509 SD_BUS_METHOD("CancelJob", "u", NULL, method_cancel_job, 0),
1510 SD_BUS_METHOD("ClearJobs", NULL, NULL, method_clear_jobs, 0),
1511 SD_BUS_METHOD("ResetFailed", NULL, NULL, method_reset_failed, 0),
1512 SD_BUS_METHOD("ListUnits", NULL, "a(ssssssouso)", method_list_units, 0),
1513 SD_BUS_METHOD("ListJobs", NULL, "a(usssoo)", method_list_jobs, 0),
1514 SD_BUS_METHOD("Subscribe", NULL, NULL, method_subscribe, 0),
1515 SD_BUS_METHOD("Unsubscribe", NULL, NULL, method_unsubscribe, 0),
1516 SD_BUS_METHOD("Dump", NULL, "s", method_dump, 0),
1517 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_create_snapshot, 0),
1518 SD_BUS_METHOD("RemoveSnapshot", "s", NULL, method_remove_snapshot, 0),
1519 SD_BUS_METHOD("Reload", NULL, NULL, method_reload, 0),
1520 SD_BUS_METHOD("Reexecute", NULL, NULL, method_reexecute, 0),
1521 SD_BUS_METHOD("Exit", NULL, NULL, method_exit, 0),
1522 SD_BUS_METHOD("Reboot", NULL, NULL, method_reboot, 0),
1523 SD_BUS_METHOD("PowerOff", NULL, NULL, method_poweroff, 0),
1524 SD_BUS_METHOD("Halt", NULL, NULL, method_halt, 0),
1525 SD_BUS_METHOD("KExec", NULL, NULL, method_kexec, 0),
1526 SD_BUS_METHOD("SwitchRoot", "ss", NULL, method_switch_root, 0),
1527 SD_BUS_METHOD("SetEnvironment", "as", NULL, method_set_environment, 0),
1528 SD_BUS_METHOD("UnsetEnvironment", "as", NULL, method_unset_environment, 0),
1529 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL, method_unset_and_set_environment, 0),
1530 SD_BUS_METHOD("ListUnitFiles", NULL, "a(ss)", method_list_unit_files, 0),
1531 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state, 0),
1532 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files, 0),
1533 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files, 0),
1534 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files, 0),
1535 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files, 0),
1536 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files, 0),
1537 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files, 0),
1538 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files, 0),
1539 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target, 0),
1540 SD_BUS_METHOD("GetDefaultTarget", NULL, "s", method_get_default_target, 0),
1542 SD_BUS_SIGNAL("UnitNew", "so", 0),
1543 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
1544 SD_BUS_SIGNAL("JobNew", "uos", 0),
1545 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
1546 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
1547 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
1548 SD_BUS_SIGNAL("Reloading", "b", 0),
1553 int bus_manager_foreach_client(Manager *m, int (*send_message)(sd_bus *bus, const char *destination, void *userdata), void *userdata) {
1559 n = set_size(m->subscribed);
1563 BusTrackedClient *d;
1565 assert_se(d = set_first(m->subscribed));
1566 return send_message(d->bus, isempty(d->name) ? NULL : d->name, userdata);
1569 /* Send to everybody */
1570 SET_FOREACH(b, m->private_buses, i) {
1571 r = send_message(b, NULL, userdata);
1577 return send_message(m->api_bus, NULL, userdata);
1582 static int send_finished(sd_bus *bus, const char *destination, void *userdata) {
1583 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1584 usec_t *times = userdata;
1590 r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished", &message);
1594 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
1598 return sd_bus_send_to(bus, message, destination, NULL);
1601 int bus_manager_send_finished(
1603 usec_t firmware_usec,
1607 usec_t userspace_usec,
1608 usec_t total_usec) {
1612 return bus_manager_foreach_client(m, send_finished,
1613 (usec_t[6]) { firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec });
1616 static int send_reloading(sd_bus *bus, const char *destination, void *userdata) {
1617 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1622 r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading", &message);
1626 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
1630 return sd_bus_send_to(bus, message, destination, NULL);
1633 int bus_manager_send_reloading(Manager *m, bool active) {
1636 return bus_manager_foreach_client(m, send_reloading, INT_TO_PTR(active));