HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/machine/machinectl.c

98,584 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
                }