HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/machine/machinectl.c
Git blob: 716f23c6ded933841fb02c45bd18ca97aed8379f
Lines 1001–2000 of 2,625
if (r < 0)
return bus_log_parse_error(r);
return process_forward(event, slot, master, PTY_FORWARD_IGNORE_VHANGUP, machine);
}
VERB(verb_shell_machine, "shell", "[[USER@]NAME [COMMAND…]]\0", VERB_ANY, VERB_ANY, 0,
"Invoke a shell (or other command) in a container or on the local host");
static int verb_shell_machine(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL, *m = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
int master = -1, r;
sd_bus *bus = ASSERT_PTR(userdata);
const char *match, *machine, *path;
_cleanup_free_ char *uid = NULL;
if (!IN_SET(arg_transport, BUS_TRANSPORT_LOCAL, BUS_TRANSPORT_MACHINE))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"Shell only supported on local machines.");
if (terminal_is_dumb()) {
/* Set TERM=dumb if we are running on a dumb terminal or with a pipe.
* Otherwise, we will get unwanted OSC sequences. */
if (!strv_find_prefix(arg_setenv, "TERM="))
if (strv_extend(&arg_setenv, "TERM=dumb") < 0)
return log_oom();
} else
/* Pass $TERM & Co. to shell session, if not explicitly specified. */
FOREACH_STRING(v, "TERM=", "COLORTERM=", "NO_COLOR=") {
if (strv_find_prefix(arg_setenv, v))
continue;
const char *t = strv_find_prefix(environ, v);
if (!t)
continue;
if (strv_extend(&arg_setenv, t) < 0)
return log_oom();
}
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = sd_event_default(&event);
if (r < 0)
return log_error_errno(r, "Failed to get event loop: %m");
r = sd_bus_attach_event(bus, event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
r = parse_machine_uid(argc >= 2 ? argv[1] : NULL, &machine, &uid);
if (r < 0)
return log_error_errno(r, "Failed to parse machine specification: %m");
match = strjoina("type='signal',"
"sender='org.freedesktop.machine1',"
"path='/org/freedesktop/machine1',",
"interface='org.freedesktop.machine1.Manager',"
"member='MachineRemoved',"
"arg0='", machine, "'");
r = sd_bus_add_match_async(bus, &slot, match, on_machine_removed, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to request machine removal match: %m");
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "OpenMachineShell");
if (r < 0)
return bus_log_create_error(r);
path = argc < 3 || isempty(argv[2]) ? NULL : argv[2];
r = sd_bus_message_append(m, "sss", machine, uid, path);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append_strv(m, strv_length(argv) <= 3 ? NULL : argv + 2);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append_strv(m, arg_setenv);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0)
return log_error_errno(r, "Failed to get shell PTY: %s", bus_error_message(&error, r));
r = sd_bus_message_read(reply, "hs", &master, NULL);
if (r < 0)
return bus_log_parse_error(r);
return process_forward(event, slot, master, /* flags= */ 0, machine);
}
static int verb_poweroff_machine(int argc, char *argv[], uintptr_t data, void *userdata);
VERB(verb_enable_machine, "enable", "NAME…\0", 2, VERB_ANY, 0,
"Enable automatic container start at boot");
VERB(verb_enable_machine, "disable", "NAME…\0", 2, VERB_ANY, 0,
"Disable automatic container start at boot");
static int verb_enable_machine(int argc, char *argv[], uintptr_t data, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char *method;
sd_bus *bus = ASSERT_PTR(userdata);
int r;
bool enable;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
enable = streq(argv[0], "enable");
method = enable ? "EnableUnitFiles" : "DisableUnitFiles";
r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, method);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_open_container(m, 'a', "s");
if (r < 0)
return bus_log_create_error(r);
if (enable) {
r = sd_bus_message_append(m, "s", "machines.target");
if (r < 0)
return bus_log_create_error(r);
}
for (int i = 1; i < argc; i++) {
_cleanup_free_ char *unit = NULL;
r = make_service_name(argv[i], &unit);
if (r < 0)
return r;
r = image_exists(bus, argv[i]);
if (r < 0)
return r;
if (r == 0)
return log_error_errno(SYNTHETIC_ERRNO(ENXIO),
"Machine image '%s' does not exist.",
argv[i]);
r = sd_bus_message_append(m, "s", unit);
if (r < 0)
return bus_log_create_error(r);
}
r = sd_bus_message_close_container(m);
if (r < 0)
return bus_log_create_error(r);
if (enable)
r = sd_bus_message_append(m, "bb", false, false);
else
r = sd_bus_message_append(m, "b", false);
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0)
return log_error_errno(r, "Failed to enable or disable unit: %s", bus_error_message(&error, r));
if (enable) {
r = sd_bus_message_read(reply, "b", NULL);
if (r < 0)
return bus_log_parse_error(r);
}
r = bus_deserialize_and_dump_unit_file_changes(reply, arg_quiet);
if (r < 0)
return r;
r = bus_service_manager_reload(bus);
if (r < 0)
return r;
if (arg_now) {
_cleanup_strv_free_ char **new_args = NULL;
new_args = strv_new(enable ? "start" : "poweroff");
if (!new_args)
return log_oom();
r = strv_extend_strv(&new_args, argv + 1, /* filter_duplicates= */ false);
if (r < 0)
return log_oom();
if (enable)
return verb_start_machine(strv_length(new_args), new_args, data, userdata);
return verb_poweroff_machine(strv_length(new_args), new_args, data, userdata);
}
return 0;
}
/* Look up the controlAddress of a machine by calling machined's Machine.List varlink interface. */
static int machine_get_control_address(const char *machine_name, char **ret) {
_cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
sd_json_variant *reply = NULL;
const char *error_id = NULL;
int r;
assert(machine_name);
assert(ret);
if (arg_transport != BUS_TRANSPORT_LOCAL)
return -EOPNOTSUPP;
_cleanup_free_ char *p = NULL;
r = runtime_directory_generic(arg_runtime_scope, "systemd/machine/io.systemd.Machine", &p);
if (r < 0)
return log_error_errno(r, "Failed to determine Machine varlink socket path: %m");
r = sd_varlink_connect_address(&vl, p);
if (r < 0)
return log_error_errno(r, "Failed to connect to machined varlink: %m");
r = sd_varlink_callbo(
vl,
"io.systemd.Machine.List",
&reply,
&error_id,
SD_JSON_BUILD_PAIR_STRING("name", machine_name));
if (r < 0)
return log_error_errno(r, "Failed to list machine: %m");
if (error_id)
return log_error_errno(sd_varlink_error_to_errno(error_id, reply),
"Failed to look up machine '%s': %s", machine_name, error_id);
sd_json_variant *addr = sd_json_variant_by_key(reply, "controlAddress");
if (!addr || !sd_json_variant_is_string(addr))
return -EOPNOTSUPP; /* No varlink control socket, caller decides whether to log */
char *a = strdup(sd_json_variant_string(addr));
if (!a)
return log_oom();
*ret = a;
return 0;
}
static int verb_machine_control_one(const char *machine_name, const char *method) {
_cleanup_free_ char *address = NULL;
int r;
r = machine_get_control_address(machine_name, &address);
if (r < 0)
return r;
_cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
r = sd_varlink_connect_address(&vl, address);
if (r < 0)
return log_error_errno(r, "Failed to connect to machine control socket: %m");
sd_json_variant *reply = NULL;
const char *error_id = NULL;
r = sd_varlink_call(vl, method, /* parameters= */ NULL, &reply, &error_id);
if (r < 0)
return log_error_errno(r, "Failed to call %s: %m", method);
if (error_id)
return log_error_errno(sd_varlink_error_to_errno(error_id, reply),
"Machine control call failed: %s", error_id);
return 0;
}
VERB(verb_poweroff_machine, "poweroff", "NAME…\0", 2, VERB_ANY, 0,
"Power off one or more machines");
VERB(verb_poweroff_machine, "stop", "NAME…\0", 2, VERB_ANY, 0,
/* help= */ NULL); /* Convenience alias */
static int verb_poweroff_machine(int argc, char *argv[], uintptr_t data, void *userdata) {
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
/* VM with varlink control socket: QMP graceful powerdown */
r = verb_machine_control_one(argv[i], "io.systemd.MachineInstance.PowerOff");
if (r >= 0)
continue;
if (r != -EOPNOTSUPP)
return r;
/* Not a VM: signal-based poweroff */
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = bus_call_method(bus, bus_machine_mgr, "KillMachine", &error, NULL,
"ssi", argv[i], "leader", (int32_t) (SIGRTMIN+4));
if (r < 0)
return log_error_errno(r, "Could not kill machine: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_reboot_machine, "reboot", "NAME…\0", 2, VERB_ANY, 0,
"Reboot one or more machines");
VERB(verb_reboot_machine, "restart", "NAME…\0", 2, VERB_ANY, 0,
/* help= */ NULL); /* Convenience alias */
static int verb_reboot_machine(int argc, char *argv[], uintptr_t data, void *userdata) {
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
r = verb_machine_control_one(argv[i], "io.systemd.MachineInstance.Reboot");
if (r >= 0)
continue;
if (r != -EOPNOTSUPP)
return r;
/* Container fallback: SIGINT to init (sysvinit + systemd compatible) */
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = bus_call_method(bus, bus_machine_mgr, "KillMachine", &error, NULL,
"ssi", argv[i], "leader", (int32_t) SIGINT);
if (r < 0)
return log_error_errno(r, "Could not reboot machine '%s': %s", argv[i], bus_error_message(&error, r));
}
return 0;
}
static int verb_vm_control(int argc, char *argv[], const char *method) {
int r;
for (int i = 1; i < argc; i++) {
r = verb_machine_control_one(argv[i], method);
if (r == -EOPNOTSUPP)
return log_error_errno(r, "Machine '%s' does not expose a varlink control socket.", argv[i]);
if (r < 0)
return r;
}
return 0;
}
VERB(verb_pause, "pause", "NAME…\0", 2, VERB_ANY, 0,
"Pause one or more machines");
static int verb_pause(int argc, char *argv[], uintptr_t _data, void *userdata) {
return verb_vm_control(argc, argv, "io.systemd.MachineInstance.Pause");
}
VERB(verb_resume, "resume", "NAME…\0", 2, VERB_ANY, 0,
"Resume one or more paused machines");
static int verb_resume(int argc, char *argv[], uintptr_t _data, void *userdata) {
return verb_vm_control(argc, argv, "io.systemd.MachineInstance.Resume");
}
VERB(verb_terminate_machine, "terminate", "NAME…\0", 2, VERB_ANY, 0,
"Terminate one or more machines");
static int verb_terminate_machine(int argc, char *argv[], uintptr_t _data, void *userdata) {
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
/* VM with varlink control socket: QMP quit (immediate termination) */
r = verb_machine_control_one(argv[i], "io.systemd.MachineInstance.Terminate");
if (r >= 0)
continue;
if (r != -EOPNOTSUPP)
return r;
/* Not a VM or no varlink socket: fall back to machined */
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = bus_call_method(bus, bus_machine_mgr, "TerminateMachine", &error, NULL, "s", argv[i]);
if (r < 0)
return log_error_errno(r, "Could not terminate machine: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_kill_machine, "kill", "NAME…\0", 2, VERB_ANY, 0,
"Send signal to processes of a machine");
static int verb_kill_machine(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
if (!arg_kill_whom)
arg_kill_whom = "all";
for (int i = 1; i < argc; i++) {
r = bus_call_method(
bus,
bus_machine_mgr,
"KillMachine",
&error,
NULL,
"ssi", argv[i], arg_kill_whom, arg_signal);
if (r < 0)
return log_error_errno(r, "Could not kill machine: %s", bus_error_message(&error, r));
}
return 0;
}
static const char* select_copy_method(bool copy_from, bool force) {
if (force)
return copy_from ? "CopyFromMachineWithFlags" : "CopyToMachineWithFlags";
else
return copy_from ? "CopyFromMachine" : "CopyToMachine";
}
VERB(verb_copy_files, "copy-to", "NAME PATH [PATH]\0", 3, 4, 0,
"Copy files from the host to a container");
VERB(verb_copy_files, "copy-from", "NAME PATH [PATH]\0", 3, 4, 0,
"Copy files from a container to the host");
static int verb_copy_files(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *abs_host_path = NULL;
char *dest, *host_path, *container_path;
sd_bus *bus = ASSERT_PTR(userdata);
bool copy_from;
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
copy_from = streq(argv[0], "copy-from");
dest = argv[3] ?: argv[2];
host_path = copy_from ? dest : argv[2];
container_path = copy_from ? argv[2] : dest;
if (!path_is_absolute(host_path)) {
r = path_make_absolute_cwd(host_path, &abs_host_path);
if (r < 0)
return log_error_errno(r, "Failed to make path absolute: %m");
host_path = abs_host_path;
}
r = bus_message_new_method_call(
bus,
&m,
bus_machine_mgr,
select_copy_method(copy_from, arg_force));
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(
m,
"sss",
argv[1],
copy_from ? container_path : host_path,
copy_from ? host_path : container_path);
if (r < 0)
return bus_log_create_error(r);
if (arg_force) {
r = sd_bus_message_append(m, "t", (uint64_t) MACHINE_COPY_REPLACE);
if (r < 0)
return bus_log_create_error(r);
}
/* This is a slow operation, hence turn off any method call timeouts */
r = sd_bus_call(bus, m, USEC_INFINITY, &error, NULL);
if (r < 0)
return log_error_errno(r, "Failed to copy: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_bind_mount, "bind", "NAME PATH [PATH]\0", 3, 4, 0,
"Bind mount a path from the host into a container");
static int verb_bind_mount(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_call_method(
bus,
bus_machine_mgr,
"BindMountMachine",
&error,
NULL,
"sssbb",
argv[1],
argv[2],
argv[3],
arg_read_only,
arg_mkdir);
if (r < 0)
return log_error_errno(r, "Failed to bind mount: %s", bus_error_message(&error, r));
return 0;
}
VERB_GROUP("Image Commands");
VERB(verb_list_images, "list-images", /* argspec= */ NULL, VERB_ANY, 1, 0,
"Show available container and VM images");
static int verb_list_images(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
sd_bus *bus = ASSERT_PTR(userdata);
int r;
pager_open(arg_pager_flags);
r = bus_call_method(bus, bus_machine_mgr, "ListImages", &error, &reply, NULL);
if (r < 0)
return log_error_errno(r, "Could not get images: %s", bus_error_message(&error, r));
table = table_new("name", "type", "ro", "usage", "created", "modified");
if (!table)
return log_oom();
if (arg_full)
table_set_width(table, 0);
(void) table_set_align_percent(table, TABLE_HEADER_CELL(3), 100);
r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssbttto)");
if (r < 0)
return bus_log_parse_error(r);
for (;;) {
uint64_t crtime, mtime, size;
const char *name, *type;
int ro_int;
r = sd_bus_message_read(reply, "(ssbttto)", &name, &type, &ro_int, &crtime, &mtime, &size, NULL);
if (r < 0)
return bus_log_parse_error(r);
if (r == 0)
break;
if (name[0] == '.' && !arg_all)
continue;
r = table_add_many(table,
TABLE_STRING, name,
TABLE_STRING, type,
TABLE_BOOLEAN, ro_int,
TABLE_SET_COLOR, ro_int ? ansi_highlight_red() : NULL,
TABLE_SIZE, size,
TABLE_TIMESTAMP, crtime,
TABLE_TIMESTAMP, mtime);
if (r < 0)
return table_log_add_error(r);
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return bus_log_parse_error(r);
return show_table(table, "images");
}
static int print_image_hostname(sd_bus *bus, const char *name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
const char *hn;
int r;
r = bus_call_method(bus, bus_machine_mgr, "GetImageHostname", NULL, &reply, "s", name);
if (r < 0)
return r;
r = sd_bus_message_read(reply, "s", &hn);
if (r < 0)
return r;
if (!isempty(hn))
printf("\tHostname: %s\n", hn);
return 0;
}
static int print_image_machine_id(sd_bus *bus, const char *name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
sd_id128_t id;
int r;
r = bus_call_method(bus, bus_machine_mgr, "GetImageMachineID", NULL, &reply, "s", name);
if (r < 0)
return r;
r = bus_message_read_id128(reply, &id);
if (r < 0)
return r;
if (!sd_id128_is_null(id))
printf(" Machine ID: " SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(id));
return 0;
}
static int print_image_machine_info(sd_bus *bus, const char *name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
int r;
r = bus_call_method(bus, bus_machine_mgr, "GetImageMachineInfo", NULL, &reply, "s", name);
if (r < 0)
return r;
r = sd_bus_message_enter_container(reply, 'a', "{ss}");
if (r < 0)
return r;
for (;;) {
const char *p, *q;
r = sd_bus_message_read(reply, "{ss}", &p, &q);
if (r < 0)
return r;
if (r == 0)
break;
if (streq(p, "DEPLOYMENT"))
printf(" Deployment: %s\n", q);
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return r;
return 0;
}
typedef struct ImageStatusInfo {
const char *name;
const char *path;
const char *type;
bool read_only;
usec_t crtime;
usec_t mtime;
uint64_t usage;
uint64_t limit;
uint64_t usage_exclusive;
uint64_t limit_exclusive;
} ImageStatusInfo;
static void print_image_status_info(sd_bus *bus, ImageStatusInfo *i) {
assert(bus);
assert(i);
if (i->name) {
fputs(i->name, stdout);
putchar('\n');
}
if (i->type)
printf("\t Type: %s\n", i->type);
if (i->path)
printf("\t Path: %s\n", i->path);
(void) print_image_hostname(bus, i->name);
(void) print_image_machine_id(bus, i->name);
(void) print_image_machine_info(bus, i->name);
print_os_release(bus, "GetImageOSRelease", i->name, "\t OS: ");
printf("\t RO: %s%s%s\n",
i->read_only ? ansi_highlight_red() : "",
i->read_only ? "read-only" : "writable",
i->read_only ? ansi_normal() : "");
if (timestamp_is_set(i->crtime))
printf("\t Created: %s; %s\n",
FORMAT_TIMESTAMP(i->crtime), FORMAT_TIMESTAMP_RELATIVE(i->crtime));
if (timestamp_is_set(i->mtime))
printf("\tModified: %s; %s\n",
FORMAT_TIMESTAMP(i->mtime), FORMAT_TIMESTAMP_RELATIVE(i->mtime));
if (i->usage != UINT64_MAX) {
if (i->usage_exclusive != i->usage && i->usage_exclusive != UINT64_MAX)
printf("\t Usage: %s (exclusive: %s)\n",
FORMAT_BYTES(i->usage), FORMAT_BYTES(i->usage_exclusive));
else
printf("\t Usage: %s\n", FORMAT_BYTES(i->usage));
}
if (i->limit != UINT64_MAX) {
if (i->limit_exclusive != i->limit && i->limit_exclusive != UINT64_MAX)
printf("\t Limit: %s (exclusive: %s)\n",
FORMAT_BYTES(i->limit), FORMAT_BYTES(i->limit_exclusive));
else
printf("\t Limit: %s\n", FORMAT_BYTES(i->limit));
}
}
static int show_image_info(sd_bus *bus, const char *path, bool *new_line) {
static const struct bus_properties_map map[] = {
{ "Name", "s", NULL, offsetof(ImageStatusInfo, name) },
{ "Path", "s", NULL, offsetof(ImageStatusInfo, path) },
{ "Type", "s", NULL, offsetof(ImageStatusInfo, type) },
{ "ReadOnly", "b", NULL, offsetof(ImageStatusInfo, read_only) },
{ "CreationTimestamp", "t", NULL, offsetof(ImageStatusInfo, crtime) },
{ "ModificationTimestamp", "t", NULL, offsetof(ImageStatusInfo, mtime) },
{ "Usage", "t", NULL, offsetof(ImageStatusInfo, usage) },
{ "Limit", "t", NULL, offsetof(ImageStatusInfo, limit) },
{ "UsageExclusive", "t", NULL, offsetof(ImageStatusInfo, usage_exclusive) },
{ "LimitExclusive", "t", NULL, offsetof(ImageStatusInfo, limit_exclusive) },
{}
};
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
ImageStatusInfo info = {};
int r;
assert(bus);
assert(path);
assert(new_line);
r = bus_map_all_properties(bus,
"org.freedesktop.machine1",
path,
map,
BUS_MAP_BOOLEAN_AS_BOOL,
&error,
&m,
&info);
if (r < 0)
return log_error_errno(r, "Could not get properties: %s", bus_error_message(&error, r));
if (*new_line)
printf("\n");
*new_line = true;
print_image_status_info(bus, &info);
return r;
}
typedef struct PoolStatusInfo {
const char *path;
uint64_t usage;
uint64_t limit;
} PoolStatusInfo;
static void print_pool_status_info(sd_bus *bus, PoolStatusInfo *i) {
if (i->path)
printf("\t Path: %s\n", i->path);
if (i->usage != UINT64_MAX)
printf("\t Usage: %s\n", FORMAT_BYTES(i->usage));
if (i->limit != UINT64_MAX)
printf("\t Limit: %s\n", FORMAT_BYTES(i->limit));
}
static int show_pool_info(sd_bus *bus) {
static const struct bus_properties_map map[] = {
{ "PoolPath", "s", NULL, offsetof(PoolStatusInfo, path) },
{ "PoolUsage", "t", NULL, offsetof(PoolStatusInfo, usage) },
{ "PoolLimit", "t", NULL, offsetof(PoolStatusInfo, limit) },
{}
};
PoolStatusInfo info = {
.usage = UINT64_MAX,
.limit = UINT64_MAX,
};
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
int r;
assert(bus);
r = bus_map_all_properties(bus,
"org.freedesktop.machine1",
"/org/freedesktop/machine1",
map,
0,
&error,
&m,
&info);
if (r < 0)
return log_error_errno(r, "Could not get properties: %s", bus_error_message(&error, r));
print_pool_status_info(bus, &info);
return 0;
}
static int show_image_properties(sd_bus *bus, const char *path, bool *new_line) {
int r;
assert(bus);
assert(path);
assert(new_line);
if (*new_line)
printf("\n");
*new_line = true;
r = bus_print_all_properties(bus, "org.freedesktop.machine1", path, NULL, arg_property, arg_print_flags, NULL);
if (r < 0)
log_error_errno(r, "Could not get properties: %m");
return r;
}
VERB(verb_show_image, "image-status", "[NAME…]\0", VERB_ANY, VERB_ANY, 0,
"Show image details");
VERB(verb_show_image, "show-image", "[NAME…]\0", VERB_ANY, VERB_ANY, 0,
"Show properties of image");
static int verb_show_image(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
bool properties, new_line = false;
sd_bus *bus = ASSERT_PTR(userdata);
int r = 0;
properties = !strstr(argv[0], "status");
pager_open(arg_pager_flags);
if (argc <= 1) {
/* If no argument is specified, inspect the manager
* itself */
if (properties)
r = show_image_properties(bus, "/org/freedesktop/machine1", &new_line);
else
r = show_pool_info(bus);
if (r < 0)
return r;
}
for (int i = 1; i < argc; i++) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
const char *path = NULL;
r = bus_call_method(bus, bus_machine_mgr, "GetImage", &error, &reply, "s", argv[i]);
if (r < 0)
return log_error_errno(r, "Could not get path to image: %s", bus_error_message(&error, r));
r = sd_bus_message_read(reply, "o", &path);
if (r < 0)
return bus_log_parse_error(r);
if (properties)
r = show_image_properties(bus, path, &new_line);
else
r = show_image_info(bus, path, &new_line);
}
return r;
}
static int normalize_nspawn_filename(const char *name, char **ret_file) {
_cleanup_free_ char *file = NULL;
assert(name);
assert(ret_file);
if (!endswith(name, ".nspawn"))
file = strjoin(name, ".nspawn");
else
file = strdup(name);
if (!file)
return log_oom();
if (!filename_is_valid(file))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid settings file name '%s'.", file);
*ret_file = TAKE_PTR(file);
return 0;
}
static int get_settings_path(const char *name, char **ret_path) {
assert(name);
assert(ret_path);
FOREACH_STRING(i, "/etc/systemd/nspawn", "/run/systemd/nspawn", "/var/lib/machines") {
_cleanup_free_ char *path = NULL;
path = path_join(i, name);
if (!path)
return -ENOMEM;
if (access(path, F_OK) >= 0) {
*ret_path = TAKE_PTR(path);
return 0;
}
}
return -ENOENT;
}
VERB(verb_edit_settings, "edit", "NAME|FILE…\0", 2, VERB_ANY, 0,
"Edit settings of one or more VMs/containers");
static int verb_edit_settings(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_(edit_file_context_done) EditFileContext context = {};
int r;
if (!on_tty())
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot edit machine settings if not on a tty.");
if (arg_transport != BUS_TRANSPORT_LOCAL)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"Edit is only supported on the host machine.");
if (arg_runner == RUNNER_VMSPAWN)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Edit is only supported for --runner=nspawn");
r = mac_init();
if (r < 0)
return r;
STRV_FOREACH(name, strv_skip(argv, 1)) {
_cleanup_free_ char *file = NULL, *path = NULL;
if (path_is_absolute(*name)) {
if (!path_is_safe(*name))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid settings file path '%s'.",
*name);
r = edit_files_add(&context, *name, NULL, NULL);
if (r < 0)
return r;
continue;
}
r = normalize_nspawn_filename(*name, &file);
if (r < 0)
return r;
r = get_settings_path(file, &path);
if (r == -ENOENT) {
log_debug("No existing settings file for machine '%s' found, creating a new file.", *name);
path = path_join("/etc/systemd/nspawn", file);
if (!path)
return log_oom();
r = edit_files_add(&context, path, NULL, NULL);
if (r < 0)
return r;
continue;
}
if (r < 0)
return log_error_errno(r, "Failed to get the path of the settings file: %m");
if (path_startswith(path, "/var/lib/machines")) {
_cleanup_free_ char *new_path = NULL;
new_path = path_join("/etc/systemd/nspawn", file);
if (!new_path)
return log_oom();
r = edit_files_add(&context, new_path, path, NULL);
} else
r = edit_files_add(&context, path, NULL, NULL);
if (r < 0)
return r;
}
return do_edit_files_and_install(&context);
}
VERB(verb_cat_settings, "cat", "NAME|FILE…\0", 2, VERB_ANY, 0,
"Show settings of one or more VMs/containers");
static int verb_cat_settings(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r = 0;
if (arg_transport != BUS_TRANSPORT_LOCAL)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"Cat is only supported on the host machine.");
if (arg_runner == RUNNER_VMSPAWN)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Cat is only supported for --runner=nspawn");
pager_open(arg_pager_flags);
STRV_FOREACH(name, strv_skip(argv, 1)) {
_cleanup_free_ char *file = NULL, *path = NULL;
int q;
if (path_is_absolute(*name)) {
if (!path_is_safe(*name))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid settings file path '%s'.",
*name);
q = cat_files(*name, /* dropins= */ NULL, /* flags= */ CAT_FORMAT_HAS_SECTIONS);
if (q < 0)
return r < 0 ? r : q;
continue;
}