HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/machine/machine.c
Git blob: 9f77840f3967a18e0b110d08777f4b7f8a40b580
Lines 1–1000 of 1,671
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sched.h>
#include <sys/stat.h>
#include <unistd.h>
#include "sd-bus.h"
#include "sd-event.h"
#include "sd-messages.h"
#include "alloc-util.h"
#include "bus-error.h"
#include "bus-internal.h"
#include "bus-locator.h"
#include "bus-unit-util.h"
#include "cgroup-util.h"
#include "env-file.h"
#include "errno-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "fs-util.h"
#include "hashmap.h"
#include "log.h"
#include "machine.h"
#include "machine-dbus.h"
#include "machined-resolve-hook.h"
#include "machined.h"
#include "mkdir.h"
#include "namespace-util.h"
#include "operation.h"
#include "parse-util.h"
#include "path-util.h"
#include "process-util.h"
#include "serialize.h"
#include "signal-util.h"
#include "socket-util.h"
#include "special.h"
#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "tmpfile-util.h"
#include "uid-range.h"
#include "unit-name.h"
#include "user-util.h"
int machine_new(MachineClass class, const char *name, Machine **ret) {
_cleanup_(machine_freep) Machine *m = NULL;
assert(class < _MACHINE_CLASS_MAX);
assert(ret);
/* Passing class == _MACHINE_CLASS_INVALID here is fine. It
* means as much as "we don't know yet", and that we'll figure
* it out later when loading the state file. */
m = new(Machine, 1);
if (!m)
return -ENOMEM;
*m = (Machine) {
.class = class,
.leader = PIDREF_NULL,
.supervisor = PIDREF_NULL,
.vsock_cid = VMADDR_CID_ANY,
};
if (name) {
m->name = strdup(name);
if (!m->name)
return -ENOMEM;
}
*ret = TAKE_PTR(m);
return 0;
}
int machine_link(Manager *manager, Machine *machine) {
int r;
assert(manager);
assert(machine);
if (machine->manager)
return -EEXIST;
if (!machine->name)
return -EINVAL;
if (machine->class != MACHINE_HOST) {
char *temp = path_join(manager->state_dir, machine->name);
if (!temp)
return -ENOMEM;
free_and_replace(machine->state_file, temp);
}
r = hashmap_put(manager->machines, machine->name, machine);
if (r < 0)
return r;
machine->manager = manager;
return 0;
}
Machine* machine_free(Machine *m) {
if (!m)
return NULL;
while (m->operations)
operation_free(m->operations);
if (m->in_gc_queue) {
assert(m->manager);
LIST_REMOVE(gc_queue, m->manager->machine_gc_queue, m);
}
if (m->manager) {
machine_release_unit(m);
(void) hashmap_remove(m->manager->machines, m->name);
if (m->manager->host_machine == m)
m->manager->host_machine = NULL;
}
m->leader_pidfd_event_source = sd_event_source_disable_unref(m->leader_pidfd_event_source);
if (pidref_is_set(&m->leader)) {
if (m->manager)
(void) hashmap_remove_value(m->manager->machines_by_leader, &m->leader, m);
pidref_done(&m->leader);
}
m->supervisor_pidfd_event_source = sd_event_source_disable_unref(m->supervisor_pidfd_event_source);
pidref_done(&m->supervisor);
sd_bus_message_unref(m->create_message);
m->cgroup_empty_event_source = sd_event_source_disable_unref(m->cgroup_empty_event_source);
free(m->name);
free(m->state_file);
free(m->service);
free(m->root_directory);
free(m->unit);
free(m->subgroup);
free(m->scope_job);
free(m->cgroup);
free(m->netif);
free(m->ssh_address);
free(m->ssh_private_key_path);
free(m->control_address);
return mfree(m);
}
int machine_save(Machine *m) {
int r;
assert(m);
if (!m->state_file)
return 0;
if (!m->started)
return 0;
_cleanup_(unlink_and_freep) char *sl = NULL; /* auto-unlink! */
if (m->unit && !m->subgroup) {
sl = strjoin(m->manager->state_dir, "/unit:", m->unit);
if (!sl)
return log_oom();
}
r = mkdir_safe_label(m->manager->state_dir, 0755, UID_INVALID, GID_INVALID, MKDIR_WARN_MODE);
if (r < 0)
return log_error_errno(r, "Failed to create '%s': %m", m->manager->state_dir);
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
r = fopen_tmpfile_linkable(m->state_file, O_WRONLY|O_CLOEXEC, &temp_path, &f);
if (r < 0)
return log_error_errno(r, "Failed to create state file '%s': %m", m->state_file);
if (fchmod(fileno(f), 0644) < 0)
return log_error_errno(errno, "Failed to set access mode for state file '%s' to 0644: %m", m->state_file);
fprintf(f,
"# This is private data. Do not parse.\n"
"NAME=%s\n"
"UID=" UID_FMT "\n",
m->name,
m->uid);
/* We continue to call this "SCOPE=" because it is internal only, and we want to stay compatible with old files */
env_file_fputs_assignment(f, "SCOPE=", m->unit);
env_file_fputs_assignment(f, "SCOPE_JOB=", m->scope_job);
env_file_fputs_assignment(f, "SERVICE=", m->service);
env_file_fputs_assignment(f, "ROOT=", m->root_directory);
if (!sd_id128_is_null(m->id))
fprintf(f, "ID=" SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(m->id));
if (pidref_is_set(&m->leader)) {
fprintf(f, "LEADER="PID_FMT"\n", m->leader.pid);
(void) pidref_acquire_pidfd_id(&m->leader);
if (m->leader.fd_id != 0)
fprintf(f, "LEADER_PIDFDID=%" PRIu64 "\n", m->leader.fd_id);
}
if (pidref_is_set(&m->supervisor)) {
fprintf(f, "SUPERVISOR=" PID_FMT "\n", m->supervisor.pid);
(void) pidref_acquire_pidfd_id(&m->supervisor);
if (m->supervisor.fd_id != 0)
fprintf(f, "SUPERVISOR_PIDFDID=%" PRIu64 "\n", m->supervisor.fd_id);
}
if (m->class != _MACHINE_CLASS_INVALID)
fprintf(f, "CLASS=%s\n", machine_class_to_string(m->class));
if (dual_timestamp_is_set(&m->timestamp))
fprintf(f,
"REALTIME="USEC_FMT"\n"
"MONOTONIC="USEC_FMT"\n",
m->timestamp.realtime,
m->timestamp.monotonic);
if (m->n_netif > 0) {
fputs("NETIF=\"", f);
FOREACH_ARRAY(ifi, m->netif, m->n_netif) {
if (*ifi != 0)
fputc(' ', f);
fprintf(f, "%i", *ifi);
}
fputs("\"\n", f);
}
if (m->vsock_cid != 0)
fprintf(f, "VSOCK_CID=%u\n", m->vsock_cid);
env_file_fputs_assignment(f, "SSH_ADDRESS=", m->ssh_address);
env_file_fputs_assignment(f, "SSH_PRIVATE_KEY_PATH=", m->ssh_private_key_path);
env_file_fputs_assignment(f, "CONTROL_ADDRESS=", m->control_address);
r = flink_tmpfile(f, temp_path, m->state_file, LINK_TMPFILE_REPLACE);
if (r < 0)
return log_error_errno(r, "Failed to move '%s' into place: %m", m->state_file);
temp_path = mfree(temp_path); /* disarm auto-destroy: temporary file does not exist anymore */
if (sl) {
/* Create a symlink from the unit name to the machine name, so that we can quickly find the machine
* for each given unit. Ignore error. */
(void) symlink(m->name, sl);
/* disarm auto-removal */
sl = mfree(sl);
}
return 0;
}
static void machine_unlink(Machine *m) {
assert(m);
if (m->unit && !m->subgroup) {
const char *sl = strjoina(m->manager->state_dir, "/unit:", m->unit);
(void) unlink(sl);
}
if (m->state_file)
(void) unlink(m->state_file);
}
static void parse_pid_and_pidfdid(
PidRef *pidref,
const char *pid,
const char *pidfdid,
const char *name) {
int r;
assert(pidref);
assert(name);
pidref_done(pidref);
if (!pid)
return;
r = pidref_set_pidstr(pidref, pid);
if (r < 0)
return (void) log_debug_errno(r, "Failed to set %s PID to '%s', ignoring: %m", name, pid);
if (!pidfdid)
return;
uint64_t fd_id;
r = safe_atou64(pidfdid, &fd_id);
if (r < 0)
return (void) log_warning_errno(r, "Failed to parse %s pidfd ID, ignoring: %s", name, pidfdid);
(void) pidref_acquire_pidfd_id(pidref);
if (fd_id != pidref->fd_id) {
log_debug("PID of %s got recycled, ignoring.", name);
pidref_done(pidref);
}
}
int machine_load(Machine *m) {
_cleanup_free_ char *name = NULL, *realtime = NULL, *monotonic = NULL, *id = NULL,
*leader = NULL, *leader_pidfdid = NULL, *supervisor = NULL, *supervisor_pidfdid = NULL,
*class = NULL, *netif = NULL, *vsock_cid = NULL, *uid = NULL;
int r;
assert(m);
if (!m->state_file)
return 0;
r = parse_env_file(NULL, m->state_file,
"NAME", &name,
"SCOPE", &m->unit,
"SUBGROUP", &m->subgroup,
"SCOPE_JOB", &m->scope_job,
"SERVICE", &m->service,
"ROOT", &m->root_directory,
"ID", &id,
"LEADER", &leader,
"LEADER_PIDFDID", &leader_pidfdid,
"SUPERVISOR", &supervisor,
"SUPERVISOR_PIDFDID", &supervisor_pidfdid,
"CLASS", &class,
"REALTIME", &realtime,
"MONOTONIC", &monotonic,
"NETIF", &netif,
"VSOCK_CID", &vsock_cid,
"SSH_ADDRESS", &m->ssh_address,
"SSH_PRIVATE_KEY_PATH", &m->ssh_private_key_path,
"CONTROL_ADDRESS", &m->control_address,
"UID", &uid);
if (r == -ENOENT)
return 0;
if (r < 0)
return log_error_errno(r, "Failed to read %s: %m", m->state_file);
if (!streq_ptr(name, m->name))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "State file '%s' for machine '%s' reports a different name '%s', refusing", m->state_file, m->name, name);
if (id)
(void) sd_id128_from_string(id, &m->id);
parse_pid_and_pidfdid(&m->leader, leader, leader_pidfdid, "leader");
parse_pid_and_pidfdid(&m->supervisor, supervisor, supervisor_pidfdid, "supervisor");
if (class) {
MachineClass c = machine_class_from_string(class);
if (c >= 0)
m->class = c;
}
if (realtime)
(void) deserialize_usec(realtime, &m->timestamp.realtime);
if (monotonic)
(void) deserialize_usec(monotonic, &m->timestamp.monotonic);
m->netif = mfree(m->netif);
m->n_netif = 0;
if (netif) {
_cleanup_free_ int *ni = NULL;
size_t nr = 0;
for (const char *p = netif;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&p, &word, NULL, 0);
if (r == 0)
break;
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_warning_errno(r, "Failed to parse NETIF: %s", netif);
break;
}
r = parse_ifindex(word);
if (r < 0)
continue;
if (!GREEDY_REALLOC(ni, nr + 1))
return log_oom();
ni[nr++] = r;
}
m->netif = TAKE_PTR(ni);
m->n_netif = nr;
}
m->vsock_cid = 0;
if (vsock_cid) {
r = safe_atou(vsock_cid, &m->vsock_cid);
if (r < 0)
log_warning_errno(r, "Failed to parse AF_VSOCK CID, ignoring: %s", vsock_cid);
}
if (uid) {
r = parse_uid(uid, &m->uid);
if (r < 0)
log_warning_errno(r, "Failed to parse owning UID, ignoring: %s", uid);
}
return r;
}
static int machine_start_scope(
Machine *machine,
bool allow_pidfd,
sd_bus_message *more_properties,
sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
_cleanup_free_ char *escaped = NULL, *unit = NULL;
const char *description;
int r;
assert(machine);
assert(pidref_is_set(&machine->leader));
assert(!machine->unit);
assert(!machine->subgroup);
escaped = unit_name_escape(machine->name);
if (!escaped)
return log_oom();
unit = strjoin("machine-", escaped, ".scope");
if (!unit)
return log_oom();
r = bus_message_new_method_call(
machine->manager->api_bus,
&m,
bus_systemd_mgr,
"StartTransientUnit");
if (r < 0)
return r;
r = sd_bus_message_append(m, "ss", unit, "fail");
if (r < 0)
return r;
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return r;
r = sd_bus_message_append(m, "(sv)", "Slice", "s", SPECIAL_MACHINE_SLICE);
if (r < 0)
return r;
description = strjoina(machine->class == MACHINE_VM ? "Virtual Machine " : "Container ", machine->name);
r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
if (r < 0)
return r;
r = bus_append_scope_pidref(m, &machine->leader, allow_pidfd);
if (r < 0)
return r;
r = sd_bus_message_append(
m, "(sv)(sv)(sv)(sv)",
"Delegate", "b", 1,
"CollectMode", "s", "inactive-or-failed",
"AddRef", "b", 1,
"TasksMax", "t", UINT64_C(16384));
if (r < 0)
return r;
if (machine->uid != 0) {
_cleanup_free_ char *u = NULL;
if (asprintf(&u, UID_FMT, machine->uid) < 0)
return -ENOMEM;
r = sd_bus_message_append(
m, "(sv)",
"User", "s", u);
if (r < 0)
return r;
}
if (more_properties) {
r = sd_bus_message_copy(m, more_properties, true);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(m);
if (r < 0)
return r;
r = sd_bus_message_append(m, "a(sa(sv))", 0);
if (r < 0)
return r;
r = sd_bus_call(NULL, m, 0, &e, &reply);
if (r < 0) {
/* If this failed with a property we couldn't write, this is quite likely because the server
* doesn't support PIDFDs yet, let's try without. */
if (allow_pidfd &&
sd_bus_error_has_names(&e, SD_BUS_ERROR_UNKNOWN_PROPERTY, SD_BUS_ERROR_PROPERTY_READ_ONLY))
return machine_start_scope(machine, /* allow_pidfd= */ false, more_properties, error);
return sd_bus_error_move(error, &e);
}
machine->unit = TAKE_PTR(unit);
machine->referenced = true;
const char *job;
r = sd_bus_message_read(reply, "o", &job);
if (r < 0)
return r;
return free_and_strdup(&machine->scope_job, job);
}
static int machine_ensure_scope(Machine *m, sd_bus_message *properties, sd_bus_error *error) {
int r;
assert(m);
assert(m->class != MACHINE_HOST);
if (!m->unit) {
r = machine_start_scope(m, /* allow_pidfd= */ true, properties, error);
if (r < 0)
return log_error_errno(r, "Failed to start machine scope: %s", bus_error_message(error, r));
}
assert(m->unit);
if (!m->subgroup) {
r = hashmap_ensure_put(&m->manager->machines_by_unit, &string_hash_ops, m->unit, m);
if (r < 0)
return r;
}
return 0;
}
static int machine_dispatch_leader_pidfd(sd_event_source *s, int fd, unsigned revents, void *userdata) {
Machine *m = ASSERT_PTR(userdata);
m->leader_pidfd_event_source = sd_event_source_disable_unref(m->leader_pidfd_event_source);
machine_add_to_gc_queue(m);
return 0;
}
static int machine_dispatch_supervisor_pidfd(sd_event_source *s, int fd, unsigned revents, void *userdata) {
Machine *m = ASSERT_PTR(userdata);
m->supervisor_pidfd_event_source = sd_event_source_disable_unref(m->supervisor_pidfd_event_source);
machine_add_to_gc_queue(m);
return 0;
}
static int machine_watch_pidfd(Machine *m, PidRef *pidref, sd_event_source **source, sd_event_io_handler_t cb) {
int r;
assert(m);
assert(m->manager);
assert(source);
assert(!*source);
assert(cb);
if (!pidref_is_set(pidref) || pidref->fd < 0)
return 0;
/* If we have a pidfd for the leader or supervisor, let's also track it for POLLIN, and GC the machine
* automatically if it dies */
r = sd_event_add_io(m->manager->event, source, pidref->fd, EPOLLIN, cb, m);
if (r < 0)
return r;
(void) sd_event_source_set_description(*source, "machine-pidfd");
return 0;
}
static int machine_dispatch_cgroup_empty(sd_event_source *s, const struct inotify_event *event, void *userdata) {
Machine *m = ASSERT_PTR(userdata);
int r;
assert(m->cgroup);
r = cg_is_empty(m->cgroup);
if (r < 0)
return log_error_errno(r, "Failed to determine if cgroup '%s' is empty: %m", m->cgroup);
if (r > 0)
machine_add_to_gc_queue(m);
return 0;
}
static int machine_watch_cgroup(Machine *m) {
int r;
assert(m);
assert(!m->cgroup_empty_event_source);
if (!m->cgroup)
return 0;
_cleanup_free_ char *p = NULL;
r = cg_get_path(m->cgroup, "cgroup.events", &p);
if (r < 0)
return log_error_errno(r, "Failed to get cgroup path for cgroup '%s': %m", m->cgroup);
r = sd_event_add_inotify(m->manager->event, &m->cgroup_empty_event_source, p, IN_MODIFY, machine_dispatch_cgroup_empty, m);
if (r < 0)
return log_error_errno(r, "Failed to watch %s events: %m", p);
return 0;
}
int machine_determine_unit(Machine *m) {
int r;
assert(m);
assert(m->manager);
assert(!m->unit);
assert(!m->subgroup);
assert(!m->cgroup);
r = manager_get_unit_by_pidref(m->manager, &m->leader, &m->unit, &m->subgroup);
if (r < 0)
return log_debug_errno(r, "Failed to determine unit of process " PID_FMT ": %m", m->leader.pid);
if (!empty_or_root(m->subgroup)) {
/* If this is not a top-level cgroup, then we need the cgroup path to be able to watch when
* it empties */
r = cg_pidref_get_path(&m->leader, &m->cgroup);
if (r < 0)
return log_debug_errno(r, "Failed to determine cgroup of process " PID_FMT ": %m", m->leader.pid);
}
return 0;
}
int machine_start(Machine *m, sd_bus_message *properties, sd_bus_error *error) {
int r;
assert(m);
if (!IN_SET(m->class, MACHINE_CONTAINER, MACHINE_VM))
return -EOPNOTSUPP;
if (m->started)
return 0;
r = hashmap_ensure_put(&m->manager->machines_by_leader, &pidref_hash_ops, &m->leader, m);
if (r < 0)
return r;
r = machine_watch_pidfd(m, &m->leader, &m->leader_pidfd_event_source, machine_dispatch_leader_pidfd);
if (r < 0)
return r;
r = machine_watch_pidfd(m, &m->supervisor, &m->supervisor_pidfd_event_source, machine_dispatch_supervisor_pidfd);
if (r < 0)
return r;
r = machine_watch_cgroup(m);
if (r < 0)
return r;
/* Create cgroup */
r = machine_ensure_scope(m, properties, error);
if (r < 0)
return r;
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_MACHINE_START_STR),
LOG_ITEM("NAME=%s", m->name),
LOG_ITEM("LEADER="PID_FMT, m->leader.pid),
LOG_MESSAGE("New machine %s.", m->name));
if (!dual_timestamp_is_set(&m->timestamp))
dual_timestamp_now(&m->timestamp);
m->started = true;
/* Save new machine data */
machine_save(m);
machine_send_signal(m, "MachineNew");
(void) manager_notify_hook_filters(m->manager);
return 0;
}
int machine_stop(Machine *m) {
int r;
assert(m);
log_debug("Stopping machine '%s'.", m->name);
if (!IN_SET(m->class, MACHINE_CONTAINER, MACHINE_VM))
return -EOPNOTSUPP;
if (m->unit && !m->subgroup) {
/* If the machine runs as its own unit, then we'll terminate that */
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
char *job = NULL;
r = manager_stop_unit(m->manager, m->unit, &error, &job);
if (r < 0)
return log_error_errno(r, "Failed to stop machine unit: %s", bus_error_message(&error, r));
free_and_replace(m->scope_job, job);
} else if (pidref_is_set(&m->supervisor)) {
/* Otherwise, send a friendly SIGTERM to the supervisor */
r = pidref_kill(&m->supervisor, SIGTERM);
if (r < 0)
return log_error_errno(r, "Failed to kill supervisor process " PID_FMT " of machine '%s': %m", m->supervisor.pid, m->name);
} else
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Don't know how to terminate machine '%s'.", m->name);
m->stopping = true;
machine_save(m);
return 0;
}
int machine_finalize(Machine *m) {
assert(m);
if (m->started) {
log_struct(LOG_INFO,
LOG_MESSAGE_ID(SD_MESSAGE_MACHINE_STOP_STR),
LOG_ITEM("NAME=%s", m->name),
LOG_ITEM("LEADER="PID_FMT, m->leader.pid),
LOG_MESSAGE("Machine %s terminated.", m->name));
m->stopping = true; /* The machine is supposed to be going away. Don't try to kill it. */
}
machine_unlink(m);
machine_add_to_gc_queue(m);
if (m->started) {
machine_send_signal(m, "MachineRemoved");
m->started = false;
(void) manager_notify_hook_filters(m->manager);
}
return 0;
}
bool machine_may_gc(Machine *m, bool drop_not_started) {
int r;
assert(m);
if (m->class == MACHINE_HOST)
return false;
if (drop_not_started && !m->started)
return true;
r = pidref_is_alive(&m->leader);
if (r == -ESRCH)
return true;
if (r < 0)
log_debug_errno(r, "Unable to determine if leader PID " PID_FMT " is still alive, assuming not: %m", m->leader.pid);
if (r > 0)
return false;
if (m->scope_job) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = manager_job_is_active(m->manager, m->scope_job, &error);
if (r < 0)
log_debug_errno(r, "Failed to determine whether job '%s' is active, assuming it is: %s", m->scope_job, bus_error_message(&error, r));
if (r != 0)
return false;
}
if (m->unit && !m->subgroup) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = manager_unit_is_active(m->manager, m->unit, &error);
if (r < 0)
log_debug_errno(r, "Failed to determine whether unit '%s' is active, assuming it is: %s", m->unit, bus_error_message(&error, r));
if (r != 0)
return false;
}
if (m->cgroup) {
r = cg_is_empty(m->cgroup);
if (IN_SET(r, 0, -ENOENT))
return true;
if (r < 0)
log_debug_errno(r, "Failed to determine if cgroup '%s' is empty, ignoring: %m", m->cgroup);
}
return true;
}
void machine_add_to_gc_queue(Machine *m) {
assert(m);
if (m->in_gc_queue)
return;
LIST_PREPEND(gc_queue, m->manager->machine_gc_queue, m);
m->in_gc_queue = true;
manager_enqueue_gc(m->manager);
}
MachineState machine_get_state(Machine *m) {
assert(m);
if (m->class == MACHINE_HOST)
return MACHINE_RUNNING;
if (m->stopping)
return MACHINE_CLOSING;
if (m->scope_job)
return MACHINE_OPENING;
return MACHINE_RUNNING;
}
int machine_kill(Machine *m, KillWhom whom, int signo) {
assert(m);
log_debug("Killing machine '%s' (%s) with signal %s.", m->name, kill_whom_to_string(whom), signal_to_string(signo));
if (!IN_SET(m->class, MACHINE_VM, MACHINE_CONTAINER))
return -EOPNOTSUPP;
switch (whom) {
case KILL_LEADER:
return pidref_kill(&m->leader, signo);
case KILL_SUPERVISOR:
return pidref_kill(&m->supervisor, signo);
case KILL_ALL:
if (!m->unit)
return -ESRCH;
return manager_kill_unit(m->manager, m->unit, m->subgroup, signo, /* error= */ NULL);
default:
assert_not_reached();
}
}
int machine_openpt(Machine *m, int flags, char **ret_peer) {
assert(m);
switch (m->class) {
case MACHINE_HOST:
return openpt_allocate(flags, ret_peer);
case MACHINE_CONTAINER:
if (!pidref_is_set(&m->leader))
return -EINVAL;
return openpt_allocate_in_namespace(&m->leader, flags, ret_peer);
default:
return -EOPNOTSUPP;
}
}
static int machine_bus_new(Machine *m, sd_bus_error *error, sd_bus **ret) {
int r;
assert(m);
assert(ret);
switch (m->class) {
case MACHINE_HOST:
*ret = NULL;
return 0;
case MACHINE_CONTAINER: {
_cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
char *address;
r = sd_bus_new(&bus);
if (r < 0)
return log_debug_errno(r, "Failed to allocate new DBus: %m");
if (asprintf(&address, "x-machine-unix:pid=%" PID_PRI, m->leader.pid) < 0)
return -ENOMEM;
bus->address = address;
bus->bus_client = true;
bus->trusted = false;
bus->runtime_scope = RUNTIME_SCOPE_SYSTEM;
r = sd_bus_start(bus);
if (r == -ENOENT)
return sd_bus_error_set_errnof(error, r, "There is no system bus in container %s.", m->name);
if (r < 0)
return r;
*ret = TAKE_PTR(bus);
return 0;
}
default:
return -EOPNOTSUPP;
}
}
int machine_start_getty(Machine *m, const char *ptmx_name, sd_bus_error *error) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *allocated_bus = NULL;
sd_bus *container_bus = NULL;
const char *p, *getty;
int r;
assert(m);
assert(ptmx_name);
p = path_startswith(ptmx_name, "/dev/pts/");
if (!p)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Path of pseudo TTY has unexpected prefix");
r = machine_bus_new(m, error, &allocated_bus);
if (r < 0)
return log_debug_errno(r, "Failed to create DBus to machine: %m");
container_bus = allocated_bus ?: m->manager->system_bus;
getty = strjoina("container-getty@", p, ".service");
r = bus_call_method(container_bus, bus_systemd_mgr, "StartUnit", error, /* ret_reply= */ NULL, "ss", getty, "replace");
if (r < 0)
return log_debug_errno(r, "Failed to StartUnit '%s' in container '%s': %m", getty, m->name);
return 0;
}
int machine_start_shell(
Machine *m,
int ptmx_fd,
const char *ptmx_name,
const char *user,
const char *path,
char **args,
char **env,
sd_bus_error *error) {
_cleanup_close_ int pty_fd = -EBADF;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *tm = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *allocated_bus = NULL;
const char *p, *utmp_id, *unit, *description;
sd_bus *container_bus = NULL;
int r;
assert(m);
assert(ptmx_fd >= 0);
assert(ptmx_name);
if (isempty(user) || isempty(path) || strv_isempty(args))
return -EINVAL;
p = path_startswith(ptmx_name, "/dev/pts/");
utmp_id = path_startswith(ptmx_name, "/dev/");
if (!p || !utmp_id)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Path of pseudo TTY has unexpected prefix");
pty_fd = pty_open_peer(ptmx_fd, O_RDWR|O_NOCTTY|O_CLOEXEC);
if (pty_fd < 0)
return log_debug_errno(pty_fd, "Failed to open terminal: %m");
r = machine_bus_new(m, error, &allocated_bus);
if (r < 0)
return log_debug_errno(r, "Failed to create DBus to machine: %m");