1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2011 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/>.
27 #include "path-util.h"
28 #include "unit-name.h"
30 #include "bus-common-errors.h"
31 #include "cgroup-util.h"
32 #include "machine-image.h"
33 #include "image-dbus.h"
35 #include "machine-dbus.h"
37 static int method_get_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
38 _cleanup_free_ char *p = NULL;
39 Manager *m = userdata;
48 r = sd_bus_message_read(message, "s", &name);
52 machine = hashmap_get(m->machines, name);
54 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
56 p = machine_bus_path(machine);
60 return sd_bus_reply_method_return(message, "o", p);
63 static int method_get_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
64 _cleanup_free_ char *p = NULL;
65 Manager *m = userdata;
73 r = sd_bus_message_read(message, "s", &name);
77 r = image_find(name, NULL);
79 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
83 p = image_bus_path(name);
87 return sd_bus_reply_method_return(message, "o", p);
90 static int method_get_machine_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
91 _cleanup_free_ char *p = NULL;
92 Manager *m = userdata;
93 Machine *machine = NULL;
101 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
103 r = sd_bus_message_read(message, "u", &pid);
108 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
110 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
114 r = sd_bus_creds_get_pid(creds, &pid);
119 r = manager_get_machine_by_pid(m, pid, &machine);
123 return sd_bus_error_setf(error, BUS_ERROR_NO_MACHINE_FOR_PID, "PID "PID_FMT" does not belong to any known machine", pid);
125 p = machine_bus_path(machine);
129 return sd_bus_reply_method_return(message, "o", p);
132 static int method_list_machines(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
133 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
134 Manager *m = userdata;
143 r = sd_bus_message_new_method_return(message, &reply);
145 return sd_bus_error_set_errno(error, r);
147 r = sd_bus_message_open_container(reply, 'a', "(ssso)");
149 return sd_bus_error_set_errno(error, r);
151 HASHMAP_FOREACH(machine, m->machines, i) {
152 _cleanup_free_ char *p = NULL;
154 p = machine_bus_path(machine);
158 r = sd_bus_message_append(reply, "(ssso)",
160 strempty(machine_class_to_string(machine->class)),
164 return sd_bus_error_set_errno(error, r);
167 r = sd_bus_message_close_container(reply);
169 return sd_bus_error_set_errno(error, r);
171 return sd_bus_send(bus, reply, NULL);
174 static int method_create_or_register_machine(Manager *manager, sd_bus_message *message, bool read_network, Machine **_m, sd_bus_error *error) {
175 const char *name, *service, *class, *root_directory;
176 const int32_t *netif = NULL;
182 size_t n, n_netif = 0;
189 r = sd_bus_message_read(message, "s", &name);
192 if (!machine_name_is_valid(name))
193 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine name");
195 r = sd_bus_message_read_array(message, 'y', &v, &n);
203 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine ID parameter");
205 r = sd_bus_message_read(message, "ssus", &service, &class, &leader, &root_directory);
212 r = sd_bus_message_read_array(message, 'i', (const void**) &netif, &n_netif);
216 n_netif /= sizeof(int32_t);
218 for (i = 0; i < n_netif; i++) {
220 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid network interface index %i", netif[i]);
225 c = _MACHINE_CLASS_INVALID;
227 c = machine_class_from_string(class);
229 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine class parameter");
233 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
235 if (!isempty(root_directory) && !path_is_absolute(root_directory))
236 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root directory must be empty or an absolute path");
239 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
241 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
245 assert_cc(sizeof(uint32_t) == sizeof(pid_t));
247 r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
252 if (hashmap_get(manager->machines, name))
253 return sd_bus_error_setf(error, BUS_ERROR_MACHINE_EXISTS, "Machine '%s' already exists", name);
255 r = manager_add_machine(manager, name, &m);
263 if (!isempty(service)) {
264 m->service = strdup(service);
271 if (!isempty(root_directory)) {
272 m->root_directory = strdup(root_directory);
273 if (!m->root_directory) {
280 assert_cc(sizeof(int32_t) == sizeof(int));
281 m->netif = memdup(netif, sizeof(int32_t) * n_netif);
287 m->n_netif = n_netif;
295 machine_add_to_gc_queue(m);
299 static int method_create_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
300 Manager *manager = userdata;
304 r = method_create_or_register_machine(manager, message, read_network, &m, error);
308 r = sd_bus_message_enter_container(message, 'a', "(sv)");
312 r = machine_start(m, message, error);
316 m->create_message = sd_bus_message_ref(message);
320 machine_add_to_gc_queue(m);
324 static int method_create_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
325 return method_create_machine_internal(bus, message, true, userdata, error);
328 static int method_create_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
329 return method_create_machine_internal(bus, message, false, userdata, error);
332 static int method_register_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
333 Manager *manager = userdata;
334 _cleanup_free_ char *p = NULL;
338 r = method_create_or_register_machine(manager, message, read_network, &m, error);
342 r = cg_pid_get_unit(m->leader, &m->unit);
344 r = sd_bus_error_set_errnof(error, r, "Failed to determine unit of process "PID_FMT" : %s", m->leader, strerror(-r));
348 r = machine_start(m, NULL, error);
352 p = machine_bus_path(m);
358 return sd_bus_reply_method_return(message, "o", p);
361 machine_add_to_gc_queue(m);
365 static int method_register_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
366 return method_register_machine_internal(bus, message, true, userdata, error);
369 static int method_register_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
370 return method_register_machine_internal(bus, message, false, userdata, error);
373 static int method_terminate_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
374 Manager *m = userdata;
383 r = sd_bus_message_read(message, "s", &name);
385 return sd_bus_error_set_errno(error, r);
387 machine = hashmap_get(m->machines, name);
389 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
391 return bus_machine_method_terminate(bus, message, machine, error);
394 static int method_kill_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
395 Manager *m = userdata;
404 r = sd_bus_message_read(message, "s", &name);
406 return sd_bus_error_set_errno(error, r);
408 machine = hashmap_get(m->machines, name);
410 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
412 return bus_machine_method_kill(bus, message, machine, error);
415 static int method_get_machine_addresses(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
416 Manager *m = userdata;
425 r = sd_bus_message_read(message, "s", &name);
427 return sd_bus_error_set_errno(error, r);
429 machine = hashmap_get(m->machines, name);
431 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
433 return bus_machine_method_get_addresses(bus, message, machine, error);
436 static int method_get_machine_os_release(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
437 Manager *m = userdata;
446 r = sd_bus_message_read(message, "s", &name);
448 return sd_bus_error_set_errno(error, r);
450 machine = hashmap_get(m->machines, name);
452 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
454 return bus_machine_method_get_os_release(bus, message, machine, error);
457 static int method_list_images(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
458 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
459 _cleanup_(image_hashmap_freep) Hashmap *images = NULL;
460 Manager *m = userdata;
469 images = hashmap_new(&string_hash_ops);
473 r = image_discover(images);
477 r = sd_bus_message_new_method_return(message, &reply);
481 r = sd_bus_message_open_container(reply, 'a', "(ssbttto)");
485 HASHMAP_FOREACH(image, images, i) {
486 _cleanup_free_ char *p = NULL;
488 p = image_bus_path(image->name);
492 r = sd_bus_message_append(reply, "(ssbttto)",
494 image_type_to_string(image->type),
504 r = sd_bus_message_close_container(reply);
508 return sd_bus_send(bus, reply, NULL);
511 static int method_open_machine_pty(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
512 Manager *m = userdata;
521 r = sd_bus_message_read(message, "s", &name);
523 return sd_bus_error_set_errno(error, r);
525 machine = hashmap_get(m->machines, name);
527 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
529 return bus_machine_method_open_pty(bus, message, machine, error);
532 static int method_open_machine_login(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
533 Manager *m = userdata;
542 r = sd_bus_message_read(message, "s", &name);
546 machine = hashmap_get(m->machines, name);
548 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
550 return bus_machine_method_open_login(bus, message, machine, error);
553 static int method_bind_mount_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
554 Manager *m = userdata;
563 r = sd_bus_message_read(message, "s", &name);
567 machine = hashmap_get(m->machines, name);
569 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
571 return bus_machine_method_bind_mount(bus, message, machine, error);
574 static int method_copy_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
575 Manager *m = userdata;
584 r = sd_bus_message_read(message, "s", &name);
588 machine = hashmap_get(m->machines, name);
590 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
592 return bus_machine_method_copy(bus, message, machine, error);
595 static int method_remove_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
596 _cleanup_(image_unrefp) Image* i = NULL;
603 r = sd_bus_message_read(message, "s", &name);
607 if (!image_name_is_valid(name))
608 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", name);
610 r = image_find(name, &i);
614 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
616 i->userdata = userdata;
617 return bus_image_method_remove(bus, message, i, error);
620 static int method_rename_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
621 _cleanup_(image_unrefp) Image* i = NULL;
622 const char *old_name;
628 r = sd_bus_message_read(message, "s", &old_name);
632 if (!image_name_is_valid(old_name))
633 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", old_name);
635 r = image_find(old_name, &i);
639 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", old_name);
641 i->userdata = userdata;
642 return bus_image_method_rename(bus, message, i, error);
645 static int method_clone_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
646 _cleanup_(image_unrefp) Image *i = NULL;
647 const char *old_name;
651 r = sd_bus_message_read(message, "s", &old_name);
655 if (!image_name_is_valid(old_name))
656 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", old_name);
658 r = image_find(old_name, &i);
662 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", old_name);
664 i->userdata = userdata;
665 return bus_image_method_clone(bus, message, i, error);
668 static int method_mark_image_read_only(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
669 _cleanup_(image_unrefp) Image *i = NULL;
674 r = sd_bus_message_read(message, "s", &name);
678 if (!image_name_is_valid(name))
679 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", name);
681 r = image_find(name, &i);
685 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
687 i->userdata = userdata;
688 return bus_image_method_mark_read_only(bus, message, i, error);
691 const sd_bus_vtable manager_vtable[] = {
692 SD_BUS_VTABLE_START(0),
693 SD_BUS_METHOD("GetMachine", "s", "o", method_get_machine, SD_BUS_VTABLE_UNPRIVILEGED),
694 SD_BUS_METHOD("GetImage", "s", "o", method_get_image, SD_BUS_VTABLE_UNPRIVILEGED),
695 SD_BUS_METHOD("GetMachineByPID", "u", "o", method_get_machine_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
696 SD_BUS_METHOD("ListMachines", NULL, "a(ssso)", method_list_machines, SD_BUS_VTABLE_UNPRIVILEGED),
697 SD_BUS_METHOD("ListImages", NULL, "a(ssbttto)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED),
698 SD_BUS_METHOD("CreateMachine", "sayssusa(sv)", "o", method_create_machine, 0),
699 SD_BUS_METHOD("CreateMachineWithNetwork", "sayssusaia(sv)", "o", method_create_machine_with_network, 0),
700 SD_BUS_METHOD("RegisterMachine", "sayssus", "o", method_register_machine, 0),
701 SD_BUS_METHOD("RegisterMachineWithNetwork", "sayssusai", "o", method_register_machine_with_network, 0),
702 SD_BUS_METHOD("TerminateMachine", "s", NULL, method_terminate_machine, SD_BUS_VTABLE_UNPRIVILEGED),
703 SD_BUS_METHOD("KillMachine", "ssi", NULL, method_kill_machine, SD_BUS_VTABLE_UNPRIVILEGED),
704 SD_BUS_METHOD("GetMachineAddresses", "s", "a(iay)", method_get_machine_addresses, SD_BUS_VTABLE_UNPRIVILEGED),
705 SD_BUS_METHOD("GetMachineOSRelease", "s", "a{ss}", method_get_machine_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
706 SD_BUS_METHOD("OpenMachinePTY", "s", "hs", method_open_machine_pty, 0),
707 SD_BUS_METHOD("OpenMachineLogin", "s", "hs", method_open_machine_login, SD_BUS_VTABLE_UNPRIVILEGED),
708 SD_BUS_METHOD("BindMountMachine", "sssbb", NULL, method_bind_mount_machine, SD_BUS_VTABLE_UNPRIVILEGED),
709 SD_BUS_METHOD("CopyFromMachine", "sss", NULL, method_copy_machine, SD_BUS_VTABLE_UNPRIVILEGED),
710 SD_BUS_METHOD("CopyToMachine", "sss", NULL, method_copy_machine, SD_BUS_VTABLE_UNPRIVILEGED),
711 SD_BUS_METHOD("RemoveImage", "s", NULL, method_remove_image, SD_BUS_VTABLE_UNPRIVILEGED),
712 SD_BUS_METHOD("RenameImage", "ss", NULL, method_rename_image, SD_BUS_VTABLE_UNPRIVILEGED),
713 SD_BUS_METHOD("CloneImage", "ssb", NULL, method_clone_image, SD_BUS_VTABLE_UNPRIVILEGED),
714 SD_BUS_METHOD("MarkImageReadOnly", "sb", NULL, method_mark_image_read_only, SD_BUS_VTABLE_UNPRIVILEGED),
715 SD_BUS_SIGNAL("MachineNew", "so", 0),
716 SD_BUS_SIGNAL("MachineRemoved", "so", 0),
720 int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
721 const char *path, *result, *unit;
722 Manager *m = userdata;
731 r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
733 bus_log_parse_error(r);
737 machine = hashmap_get(m->machine_units, unit);
741 if (streq_ptr(path, machine->scope_job)) {
742 free(machine->scope_job);
743 machine->scope_job = NULL;
745 if (machine->started) {
746 if (streq(result, "done"))
747 machine_send_create_reply(machine, NULL);
749 _cleanup_bus_error_free_ sd_bus_error e = SD_BUS_ERROR_NULL;
751 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
753 machine_send_create_reply(machine, &e);
756 machine_save(machine);
759 machine_add_to_gc_queue(machine);
763 int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
764 _cleanup_free_ char *unit = NULL;
765 Manager *m = userdata;
774 path = sd_bus_message_get_path(message);
778 r = unit_name_from_dbus_path(path, &unit);
779 if (r == -EINVAL) /* not for a unit */
784 machine = hashmap_get(m->machine_units, unit);
786 machine_add_to_gc_queue(machine);
791 int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
792 const char *path, *unit;
793 Manager *m = userdata;
801 r = sd_bus_message_read(message, "so", &unit, &path);
803 bus_log_parse_error(r);
807 machine = hashmap_get(m->machine_units, unit);
809 machine_add_to_gc_queue(machine);
814 int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
815 Manager *m = userdata;
822 r = sd_bus_message_read(message, "b", &b);
824 bus_log_parse_error(r);
830 /* systemd finished reloading, let's recheck all our machines */
831 log_debug("System manager has been reloaded, rechecking machines...");
833 HASHMAP_FOREACH(machine, m->machines, i)
834 machine_add_to_gc_queue(machine);
839 int manager_start_scope(
844 const char *description,
845 sd_bus_message *more_properties,
849 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
856 r = sd_bus_message_new_method_call(
859 "org.freedesktop.systemd1",
860 "/org/freedesktop/systemd1",
861 "org.freedesktop.systemd1.Manager",
862 "StartTransientUnit");
866 r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
870 r = sd_bus_message_open_container(m, 'a', "(sv)");
874 if (!isempty(slice)) {
875 r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
880 if (!isempty(description)) {
881 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
886 r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
890 r = sd_bus_message_append(m, "(sv)", "Delegate", "b", 1);
894 if (more_properties) {
895 r = sd_bus_message_copy(m, more_properties, true);
900 r = sd_bus_message_close_container(m);
904 r = sd_bus_message_append(m, "a(sa(sv))", 0);
908 r = sd_bus_call(manager->bus, m, 0, error, &reply);
916 r = sd_bus_message_read(reply, "o", &j);
930 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
931 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
937 r = sd_bus_call_method(
939 "org.freedesktop.systemd1",
940 "/org/freedesktop/systemd1",
941 "org.freedesktop.systemd1.Manager",
947 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
948 sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
953 sd_bus_error_free(error);
964 r = sd_bus_message_read(reply, "o", &j);
978 int manager_kill_unit(Manager *manager, const char *unit, int signo, sd_bus_error *error) {
982 return sd_bus_call_method(
984 "org.freedesktop.systemd1",
985 "/org/freedesktop/systemd1",
986 "org.freedesktop.systemd1.Manager",
990 "ssi", unit, "all", signo);
993 int manager_unit_is_active(Manager *manager, const char *unit) {
994 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
995 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
996 _cleanup_free_ char *path = NULL;
1003 path = unit_dbus_path_from_name(unit);
1007 r = sd_bus_get_property(
1009 "org.freedesktop.systemd1",
1011 "org.freedesktop.systemd1.Unit",
1017 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
1018 sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
1021 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
1022 sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
1028 r = sd_bus_message_read(reply, "s", &state);
1032 return !streq(state, "inactive") && !streq(state, "failed");
1035 int manager_job_is_active(Manager *manager, const char *path) {
1036 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1037 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1043 r = sd_bus_get_property(
1045 "org.freedesktop.systemd1",
1047 "org.freedesktop.systemd1.Job",
1053 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
1054 sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
1057 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
1063 /* We don't actually care about the state really. The fact
1064 * that we could read the job state is enough for us */
1069 int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine) {
1070 _cleanup_free_ char *unit = NULL;
1078 r = cg_pid_get_unit(pid, &unit);
1080 mm = hashmap_get(m->machine_leaders, UINT_TO_PTR(pid));
1082 mm = hashmap_get(m->machine_units, unit);
1091 int manager_add_machine(Manager *m, const char *name, Machine **_machine) {
1097 machine = hashmap_get(m->machines, name);
1099 machine = machine_new(m, name);
1105 *_machine = machine;