HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/machine/machinectl.c
Git blob: 716f23c6ded933841fb02c45bd18ca97aed8379f
Lines 2001–2625 of 2,625
q = normalize_nspawn_filename(*name, &file);
if (q < 0)
return r < 0 ? r : q;
q = get_settings_path(file, &path);
if (q == -ENOENT) {
log_error_errno(q, "No settings file found for machine '%s'.", *name);
r = r < 0 ? r : q;
continue;
}
if (q < 0) {
log_error_errno(q, "Failed to get the path of the settings file: %m");
return r < 0 ? r : q;
}
q = cat_files(path, /* dropins= */ NULL, /* flags= */ CAT_FORMAT_HAS_SECTIONS);
if (q < 0)
return r < 0 ? r : q;
}
return r;
}
VERB(verb_clone_image, "clone", "NAME NAME\0", 3, 3, 0,
"Clone an image");
static int verb_clone_image(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;
sd_bus *bus = ASSERT_PTR(userdata);
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CloneImage");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "ssb", argv[1], argv[2], arg_read_only);
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, "Could not clone image: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_rename_image, "rename", "NAME NAME\0", 3, 3, 0,
"Rename an image");
static int verb_rename_image(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,
"RenameImage",
&error,
NULL,
"ss", argv[1], argv[2]);
if (r < 0)
return log_error_errno(r, "Could not rename image: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_read_only_image, "read-only", "NAME [BOOL]\0", 2, 3, 0,
"Mark or unmark image read-only");
static int verb_read_only_image(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 b = true, r;
if (argc > 2) {
b = parse_boolean(argv[2]);
if (b < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse boolean argument: %s",
argv[2]);
}
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_call_method(bus, bus_machine_mgr, "MarkImageReadOnly", &error, NULL, "sb", argv[1], b);
if (r < 0)
return log_error_errno(r, "Could not mark image read-only: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_remove_image, "remove", "NAME…\0", 2, VERB_ANY, 0,
"Remove an image");
static int verb_remove_image(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++) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "RemoveImage");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", argv[i]);
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, "Could not remove image: %s", bus_error_message(&error, r));
}
return 0;
}
VERB(verb_set_limit, "set-limit", "[NAME] BYTES\0", 2, 3, 0,
"Set image or pool size limit (disk quota)");
static int verb_set_limit(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 = userdata;
uint64_t limit;
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
if (STR_IN_SET(argv[argc-1], "-", "none", "infinity"))
limit = UINT64_MAX;
else {
r = parse_size(argv[argc-1], 1024, &limit);
if (r < 0)
return log_error_errno(r, "Failed to parse size: %s", argv[argc-1]);
}
if (argc > 2)
/* With two arguments changes the quota limit of the
* specified image */
r = bus_call_method(bus, bus_machine_mgr, "SetImageLimit", &error, NULL, "st", argv[1], limit);
else
/* With one argument changes the pool quota limit */
r = bus_call_method(bus, bus_machine_mgr, "SetPoolLimit", &error, NULL, "t", limit);
if (r < 0)
return log_error_errno(r, "Could not set limit: %s", bus_error_message(&error, r));
return 0;
}
VERB(verb_clean_images, "clean", /* argspec= */ NULL, VERB_ANY, 1, 0,
"Remove hidden (or all) images");
static int verb_clean_images(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;
uint64_t usage, total = 0;
sd_bus *bus = userdata;
const char *name;
unsigned c = 0;
int r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CleanPool");
if (r < 0)
return bus_log_create_error(r);
r = sd_bus_message_append(m, "s", arg_all ? "all" : "hidden");
if (r < 0)
return bus_log_create_error(r);
/* This is a slow operation, hence permit a longer time for completion. */
r = sd_bus_call(bus, m, USEC_INFINITY, &error, &reply);
if (r < 0)
return log_error_errno(r, "Could not clean pool: %s", bus_error_message(&error, r));
r = sd_bus_message_enter_container(reply, 'a', "(st)");
if (r < 0)
return bus_log_parse_error(r);
while ((r = sd_bus_message_read(reply, "(st)", &name, &usage)) > 0) {
if (usage == UINT64_MAX) {
log_info("Removed image '%s'", name);
total = UINT64_MAX;
} else {
log_info("Removed image '%s'. Freed exclusive disk space: %s",
name, FORMAT_BYTES(usage));
if (total != UINT64_MAX)
total += usage;
}
c++;
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return bus_log_parse_error(r);
if (total == UINT64_MAX)
log_info("Removed %u images in total.", c);
else
log_info("Removed %u images in total. Total freed exclusive disk space: %s.",
c, FORMAT_BYTES(total));
return 0;
}
VERB(verb_bind_volume, "bind-volume", "MACHINE PROVIDER:VOLUME[:…]\0", 3, 3, 0,
"Attach a volume to a running machine");
static int verb_bind_volume(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
if (arg_transport != BUS_TRANSPORT_LOCAL)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"bind-volume is only supported on the local transport.");
_cleanup_(bind_volume_freep) BindVolume *bv = NULL;
r = bind_volume_parse(argv[2], &bv);
if (r < 0)
return log_error_errno(r, "Failed to parse bind-volume argument '%s': %m", argv[2]);
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
/* Locate and connect to the target machine before acquiring storage, so a missing
* machine doesn't trigger 'create=new' side effects on the StorageProvider. */
_cleanup_free_ char *address = NULL;
r = machine_get_control_address(argv[1], &address);
if (r == -EOPNOTSUPP)
return log_error_errno(r, "Machine '%s' does not expose a varlink control socket.", argv[1]);
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 %s: %m", address);
r = sd_varlink_set_allow_fd_passing_output(vl, true);
if (r < 0)
return log_error_errno(r, "Failed to enable fd passing on varlink connection: %m");
_cleanup_(storage_acquire_reply_done) StorageAcquireReply reply = STORAGE_ACQUIRE_REPLY_INIT;
_cleanup_free_ char *acquire_error_id = NULL;
r = storage_acquire_volume(arg_runtime_scope, bv, arg_ask_password, &acquire_error_id, &reply);
if (r < 0) {
if (acquire_error_id)
return log_error_errno(r, "Failed to acquire storage volume '%s:%s' from provider: %s",
bv->provider, bv->volume, acquire_error_id);
return log_error_errno(r, "Failed to acquire storage volume '%s:%s' from provider: %m",
bv->provider, bv->volume);
}
int fd_index = sd_varlink_push_fd(vl, reply.fd);
if (fd_index < 0)
return log_error_errno(fd_index, "Failed to push storage fd onto varlink connection: %m");
TAKE_FD(reply.fd);
_cleanup_free_ char *name = strjoin(bv->provider, ":", bv->volume);
if (!name)
return log_oom();
sd_json_variant *vl_reply = NULL;
const char *error_id = NULL;
r = sd_varlink_callbo(
vl,
"io.systemd.MachineInstance.AddStorage",
&vl_reply, &error_id,
SD_JSON_BUILD_PAIR_INTEGER("fileDescriptorIndex", fd_index),
SD_JSON_BUILD_PAIR_STRING("name", name),
JSON_BUILD_PAIR_STRING_NON_EMPTY("config", bv->config));
if (r < 0)
return log_error_errno(r, "Failed to call io.systemd.MachineInstance.AddStorage: %m");
if (error_id)
return log_error_errno(sd_varlink_error_to_errno(error_id, vl_reply),
"AddStorage failed for '%s': %s", name, error_id);
return 0;
}
VERB(verb_unbind_volume, "unbind-volume", "MACHINE PROVIDER:VOLUME\0", 3, 3, 0,
"Detach a volume from a running machine");
static int verb_unbind_volume(int argc, char *argv[], uintptr_t _data, void *userdata) {
int r;
if (arg_transport != BUS_TRANSPORT_LOCAL)
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"unbind-volume is only supported on the local transport.");
r = machine_storage_name_split(argv[2], /* ret_provider= */ NULL, /* ret_volume= */ NULL);
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid unbind-volume name '%s', expected '<provider>:<volume>'.", argv[2]);
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
_cleanup_free_ char *address = NULL;
r = machine_get_control_address(argv[1], &address);
if (r == -EOPNOTSUPP)
return log_error_errno(r, "Machine '%s' does not expose a varlink control socket.", argv[1]);
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 %s: %m", address);
sd_json_variant *reply = NULL;
const char *error_id = NULL;
r = sd_varlink_callbo(
vl,
"io.systemd.MachineInstance.RemoveStorage",
&reply, &error_id,
SD_JSON_BUILD_PAIR_STRING("name", argv[2]));
if (r < 0)
return log_error_errno(r, "Failed to call io.systemd.MachineInstance.RemoveStorage: %m");
if (error_id)
return log_error_errno(sd_varlink_error_to_errno(error_id, reply),
"RemoveStorage failed for '%s': %s", argv[2], error_id);
return 0;
}
static int chainload_importctl(char **args) {
int r;
if (!arg_quiet)
log_notice("The 'machinectl %1$s' command has been replaced by 'importctl -m %1$s'. "
"Redirecting invocation.", args[0]);
_cleanup_strv_free_ char **c =
strv_new("importctl", "--class=machine");
if (!c)
return log_oom();
if (FLAGS_SET(arg_pager_flags, PAGER_DISABLE))
if (strv_extend(&c, "--no-pager") < 0)
return log_oom();
if (!arg_legend)
if (strv_extend(&c, "--no-legend") < 0)
return log_oom();
if (arg_read_only)
if (strv_extend(&c, "--read-only") < 0)
return log_oom();
if (arg_force)
if (strv_extend(&c, "--force") < 0)
return log_oom();
if (arg_quiet)
if (strv_extend(&c, "--quiet") < 0)
return log_oom();
if (!arg_ask_password)
if (strv_extend(&c, "--no-ask-password") < 0)
return log_oom();
if (strv_extend_many(&c, "--verify", import_verify_to_string(arg_verify)) < 0)
return log_oom();
if (arg_format)
if (strv_extend_many(&c, "--format", arg_format) < 0)
return log_oom();
if (strv_extend_strv(&c, args, /* filter_duplicates= */ false) < 0)
return log_oom();
if (DEBUG_LOGGING) {
_cleanup_free_ char *joined = strv_join(c, " ");
log_debug("Chainloading: %s", joined);
}
r = invoke_callout_binary(BINDIR "/importctl", c);
return log_error_errno(r, "Failed to invoke 'importctl': %m");
}
VERB_COMMON_HELP_AUTO_HIDDEN();
static int parse_argv(int argc, char *argv[], char ***ret_args) {
assert(argc >= 0);
assert(argv);
assert(ret_args);
/* For "shell" we don't want option reordering; options specified after the command should be passed
* to the program to execute, and not processed by us. For other verbs, we consume all options as
* usual. To make this work, start with OPTION_PARSER_RETURN_POSITIONAL_ARGS and switch to either
* OPTION_PARSER_STOP_AT_FIRST_NONOPTION or OPTION_PARSER_NORMAL after we've seen the verb and one
* more argument after that. */
OptionParser opts = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
_cleanup_strv_free_ char **args = NULL;
int r;
FOREACH_OPTION_OR_RETURN(c, &opts)
switch (c) {
OPTION_POSITIONAL:
assert(opts.mode == OPTION_PARSER_RETURN_POSITIONAL_ARGS);
if (!args && !streq(opts.arg, "shell"))
opts.mode = OPTION_PARSER_NORMAL;
else if (args)
opts.mode = OPTION_PARSER_STOP_AT_FIRST_NONOPTION;
r = strv_extend(&args, opts.arg);
if (r < 0)
return log_oom();
break;
OPTION_COMMON_HELP:
return command_print_help();
OPTION_COMMON_VERSION:
return version();
OPTION_COMMON_HOST:
arg_transport = BUS_TRANSPORT_REMOTE;
arg_host = opts.arg;
break;
OPTION_COMMON_MACHINE:
arg_transport = BUS_TRANSPORT_MACHINE;
arg_host = opts.arg;
break;
OPTION_LONG("system", NULL, "Connect to system machine manager"):
arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
break;
OPTION_LONG("user", NULL, "Connect to user machine manager"):
arg_runtime_scope = RUNTIME_SCOPE_USER;
break;
OPTION_LONG("value", NULL, "When showing properties, only print the value"):
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
break;
OPTION('p', "property", "NAME", "Show only properties by this name"): {}
OPTION_SHORT('P', "NAME", "Equivalent to --value --property=NAME"):
r = strv_extend(&arg_property, opts.arg);
if (r < 0)
return log_oom();
/* If the user asked for a particular property, show it to them, even if empty. */
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
if (opts.opt->short_code == 'P')
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
break;
OPTION('a', "all", NULL, "Show all properties, including empty ones"):
SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
arg_all = true;
break;
OPTION('l', "full", NULL, "Do not ellipsize output"):
arg_full = true;
break;
OPTION_LONG("kill-whom", "WHOM", "Whom to send signal to"):
arg_kill_whom = opts.arg;
break;
OPTION('s', "signal", "SIGNAL", "Which signal to send"):
r = parse_signal_argument(opts.arg, &arg_signal);
if (r <= 0)
return r;
break;
OPTION_LONG("uid", "USER", "Specify user ID to invoke shell as"):
arg_uid = opts.arg;
break;
OPTION('E', "setenv", "VAR[=VALUE]", "Add an environment variable for shell"):
r = strv_env_replace_strdup_passthrough(&arg_setenv, opts.arg);
if (r < 0)
return log_error_errno(r, "Cannot assign environment variable %s: %m", opts.arg);
break;
OPTION_LONG("read-only", NULL, "Create read-only bind mount or clone"):
arg_read_only = true;
break;
OPTION_LONG("mkdir", NULL, "Create directory before bind mounting, if missing"):
arg_mkdir = true;
break;
OPTION('n', "lines", "INTEGER", "Number of journal entries to show"):
if (safe_atou(opts.arg, &arg_lines) < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to parse lines '%s'", opts.arg);
break;
OPTION_LONG("max-addresses", "INTEGER",
"Number of internet addresses to show at most"):
if (streq(opts.arg, "all"))
arg_max_addresses = UINT_MAX;
else if (safe_atou(opts.arg, &arg_max_addresses) < 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Invalid number of addresses: %s", opts.arg);
break;
OPTION('o', "output", "STRING",
"Change journal output mode (short, short-precise, short-iso, "
"short-iso-precise, short-full, short-monotonic, short-unix, short-delta, "
"json, json-pretty, json-sse, json-seq, cat, verbose, export, with-unit)"):
if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);
r = output_mode_from_string(opts.arg);
if (r < 0)
return log_error_errno(r, "Unknown output '%s'.", opts.arg);
arg_output = r;
if (OUTPUT_MODE_IS_JSON(arg_output))
arg_legend = false;
break;
OPTION_LONG("force", NULL, "Replace target file when copying, if necessary"):
arg_force = true;
break;
OPTION_LONG("now", NULL,
"Start or power off container after enabling or disabling it"):
arg_now = true;
break;
OPTION_LONG("runner", "RUNNER",
"Select between nspawn and vmspawn as the runner"):
r = machine_runner_from_string(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse --runner= setting: %s", opts.arg);
arg_runner = r;
break;
OPTION_SHORT('V', NULL, "Short for --runner=vmspawn"):
arg_runner = RUNNER_VMSPAWN;
break;
/* Hidden options below */
OPTION_LONG("verify", "MODE", /* help= */ NULL):
if (streq(opts.arg, "help"))
return DUMP_STRING_TABLE(import_verify, ImportVerify, _IMPORT_VERIFY_MAX);
r = import_verify_from_string(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse --verify= setting: %s", opts.arg);
arg_verify = r;
break;
OPTION_LONG("format", "FORMAT", /* help= */ NULL):
if (!STR_IN_SET(opts.arg, "uncompressed", "xz", "gzip", "bzip2", "zstd"))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"Unknown format: %s", opts.arg);
arg_format = opts.arg;
break;
OPTION_COMMON_NO_PAGER:
arg_pager_flags |= PAGER_DISABLE;
break;
OPTION_COMMON_NO_LEGEND:
arg_legend = false;
break;
OPTION_COMMON_NO_ASK_PASSWORD:
arg_ask_password = false;
break;
OPTION('q', "quiet", NULL, "Suppress output"):
arg_quiet = true;
break;
OPTION_COMMON_INTROSPECT_CLI:
return introspect_cli(SD_JSON_FORMAT_OFF);
}
/* We gathered some positional args in 'args' ourselves. Append the remaining ones. */
if (strv_extend_strv(&args, option_parser_get_args(&opts), /* filter_duplicates= */ false) < 0)
return log_oom();
*ret_args = TAKE_PTR(args);
return 1;
}
static int run(int argc, char *argv[]) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_strv_free_ char **args = NULL;
int r;
COMPRESS_JOURNAL_NOTE;
LIBSELINUX_NOTE(recommended);
setlocale(LC_ALL, "");
log_setup();
r = parse_argv(argc, argv, &args);
if (r <= 0)
return r;
journal_browse_prepare();
if (args && STR_IN_SET(args[0],
"import-tar", "import-raw", "import-fs",
"export-tar", "export-raw",
"pull-tar", "pull-raw",
"list-transfers", "cancel-transfer"))
return chainload_importctl(args);
r = bus_connect_transport(arg_transport, arg_host, arg_runtime_scope, &bus);
if (r < 0)
return bus_log_connect_error(r, arg_transport, arg_runtime_scope);
(void) sd_bus_set_allow_interactive_authorization(bus, arg_ask_password);
return dispatch_verb(args, bus);
}
DEFINE_MAIN_FUNCTION(run);