HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/sysext/sysext.c
Git blob: e31d38d83f0ebe3c4643975d7ec98aa1f9102715
Lines 3001–3321 of 3,321
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
static int refresh_class(ImageClass image_class) {
_cleanup_(context_done) Context c = CONTEXT_NULL;
int r;
/* The sysupdate notification service is systemd-sysext, but it refreshes both sysexts and
* confexts. Apply the relevant class-specific environment and configuration for each refresh. */
r = context_from_cmdline(&c, image_class);
if (r < 0)
return r;
return refresh(&c);
}
static int vl_method_on_completed_update(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
int r;
assert(link);
/* Only honour update notifications if they come from root */
r = varlink_check_privileged_peer(link);
if (r < 0)
return r;
/* Triggered by systemd-sysupdate after an update completed. We deliberately ignore all parameters
* (we don't even dispatch them). This method is reached through the sysext socket, but a single
* notification refreshes both image classes, so freshly downloaded sysexts and confexts are both
* picked up, equivalent to "systemd-confext refresh" plus "systemd-sysext refresh", in the same order
* as at boot. We attempt both classes and only fail afterwards, so a problem with one does not
* prevent refreshing the other. */
r = 0;
RET_GATHER(r, refresh_class(IMAGE_CONFEXT));
RET_GATHER(r, refresh_class(IMAGE_SYSEXT));
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
VERB_NOARG(verb_list, "list", "List installed extensions");
static int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata) {
_cleanup_hashmap_free_ Hashmap *images = NULL;
_cleanup_(table_unrefp) Table *t = NULL;
Image *img;
int r;
r = image_discover(RUNTIME_SCOPE_SYSTEM, arg_image_class, arg_root, &images);
if (r < 0)
return log_error_errno(r, "Failed to discover images: %m");
if (hashmap_isempty(images) && !sd_json_format_enabled(arg_json_format_flags)) {
log_info("No OS extensions found.");
return 0;
}
t = table_new("name", "type", "path", "time");
if (!t)
return log_oom();
HASHMAP_FOREACH(img, images) {
r = table_add_many(
t,
TABLE_STRING, img->name,
TABLE_STRING, image_type_to_string(img->type),
TABLE_PATH, img->path,
TABLE_TIMESTAMP, img->mtime != 0 ? img->mtime : img->crtime);
if (r < 0)
return table_log_add_error(r);
}
(void) table_set_sort(t, (size_t) 0);
return table_print_with_pager(t, arg_json_format_flags, arg_pager_flags, arg_legend);
}
static int vl_method_list(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "class", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, 0 },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
Hashmap **polkit_registry = ASSERT_PTR(userdata);
int r;
assert(link);
assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
const char *class = NULL;
r = sd_varlink_dispatch(link, parameters, dispatch_table, &class);
if (r != 0)
return r;
ImageClass image_class = arg_image_class;
r = parse_image_class_parameter(link, class, &image_class);
if (r < 0)
return r;
r = varlink_verify_polkit_async(
link,
/* bus= */ NULL,
image_class_info[image_class].polkit_ro_action_id,
(const char**) STRV_MAKE("verb", "list"),
polkit_registry);
if (r <= 0)
return r;
_cleanup_hashmap_free_ Hashmap *images = NULL;
r = image_discover(RUNTIME_SCOPE_SYSTEM, image_class, arg_root, &images);
if (r < 0)
return r;
r = sd_varlink_set_sentinel(link, "io.systemd.sysext.NoImagesFound");
if (r < 0)
return r;
Image *img;
HASHMAP_FOREACH(img, images) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = image_to_json(img, &v);
if (r < 0)
return r;
r = sd_varlink_reply(link, v);
if (r < 0)
return r;
}
return 0;
}
VERB_FULL(verb_help, "help", NULL, VERB_ANY, VERB_ANY, 0, /* dat= */ 0u, /* help= */ NULL);
static int verb_help(int argc, char **argv, uintptr_t data, void *userdata) {
return command_print_help_name(
arg_image_class == IMAGE_SYSEXT ? "systemd-sysext" : "systemd-confext");
}
static int parse_argv(int argc, char *argv[], char ***ret_args) {
int r;
assert(argc >= 0);
assert(argv);
assert(ret_args);
OptionParser opts = { argc, argv };
FOREACH_OPTION_OR_RETURN(c, &opts)
switch (c) {
OPTION_COMMON_HELP:
return verb_help(argc, argv, /* data= */ 0u, /* userdata= */ NULL);
OPTION_COMMON_VERSION:
return version();
OPTION_LONG("root", "PATH", "Operate relative to root PATH"):
r = parse_path_argument(opts.arg, false, &arg_root);
if (r < 0)
return r;
/* If --root= is provided, do not reload the service manager */
arg_no_reload = true;
break;
OPTION_LONG("mutable", "MODE",
"Specify a mutability mode (yes, no, auto, import, ephemeral, ephemeral-import, help)"):
if (streq(opts.arg, "help")) {
if (arg_legend)
puts("Known mutability modes:");
return DUMP_STRING_TABLE(mutable_mode, MutableMode, _MUTABLE_MAX);
}
r = parse_mutable_mode(opts.arg);
if (r < 0)
return log_error_errno(r, "Failed to parse argument to --mutable=: %s", opts.arg);
arg_mutable = r;
arg_mutable_argv_set = true;
break;
OPTION_LONG("image-policy", "POLICY", "Specify disk image dissection policy"):
r = parse_image_policy_argument(opts.arg, &arg_image_policy);
if (r < 0)
return r;
arg_image_policy_argv_set = true;
break;
OPTION_LONG("noexec", "BOOL", "Whether to mount extension overlay with noexec"):
r = parse_boolean_argument("--noexec", opts.arg, NULL);
if (r < 0)
return r;
arg_noexec = r;
break;
OPTION_LONG("force", NULL, "Ignore version incompatibilities"):
arg_force = true;
break;
OPTION_LONG("no-reload", NULL, "Do not reload the service manager"):
arg_no_reload = true;
break;
OPTION_LONG("always-refresh", "BOOL", "Whether to refresh when no changes were found"):
r = parse_boolean_argument("--always-refresh", opts.arg, &arg_always_refresh);
if (r < 0)
return r;
break;
OPTION_COMMON_NO_PAGER:
arg_pager_flags |= PAGER_DISABLE;
break;
OPTION_COMMON_NO_LEGEND:
arg_legend = false;
break;
OPTION_COMMON_JSON:
r = parse_json_argument(opts.arg, &arg_json_format_flags);
if (r <= 0)
return r;
break;
OPTION_COMMON_INTROSPECT_CLI:
return introspect_cli(arg_json_format_flags);
}
r = sd_varlink_invocation(SD_VARLINK_ALLOW_ACCEPT);
if (r < 0)
return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
if (r > 0)
arg_varlink = true;
*ret_args = option_parser_get_args(&opts);
return 1;
}
static int run(int argc, char *argv[]) {
char **args = NULL;
int r;
LIBBLKID_NOTE(required);
LIBCRYPTO_NOTE(suggested);
LIBCRYPTSETUP_NOTE(recommended);
LIBMOUNT_NOTE(required);
LIBSELINUX_NOTE(recommended);
log_setup();
arg_image_class = invoked_as(argv, "systemd-confext") ? IMAGE_CONFEXT : IMAGE_SYSEXT;
/* Parse command line */
r = parse_argv(argc, argv, &args);
if (r <= 0)
return r;
/* PROC_CMDLINE_STRIP_RD_PREFIX cannot be used here as we need to be able to distinguish between
* rd.systemd.{sysext,confext} and systemd.{sysext,confext} in the initrd where they are both used
* and have different meaning. */
const char *string_class = image_class_to_string(arg_image_class);
const char *cmdline_opt = strjoina(in_initrd() && !arg_root ? "rd." : "", "systemd.", string_class);
bool enabled;
r = proc_cmdline_get_bool(cmdline_opt, PROC_CMDLINE_TRUE_WHEN_MISSING, &enabled);
if (r < 0)
log_debug_errno(r, "Failed to check '%s=' kernel command line option, proceeding: %m", cmdline_opt);
else if (!enabled && invoked_by_systemd()) {
/* Kernel command line option should not affect manual invocation. */
log_notice("Disabled by the kernel command line option '%s=', skipping execution.", cmdline_opt);
return 0;
}
if (arg_varlink) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
_cleanup_hashmap_free_ Hashmap *polkit_registry = NULL;
/* Invocation as Varlink service */
r = varlink_server_new(
&varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
&polkit_registry);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");
r = sd_varlink_server_add_interface_many(
varlink_server,
&vl_interface_io_systemd_sysext,
&vl_interface_io_systemd_SysUpdate_Notify);
if (r < 0)
return log_error_errno(r, "Failed to add Varlink interfaces: %m");
r = sd_varlink_server_bind_method_many(
varlink_server,
"io.systemd.sysext.Merge", vl_method_merge,
"io.systemd.sysext.Unmerge", vl_method_unmerge,
"io.systemd.sysext.Refresh", vl_method_refresh,
"io.systemd.sysext.List", vl_method_list,
"io.systemd.SysUpdate.Notify.OnCompletedUpdate", vl_method_on_completed_update);
if (r < 0)
return log_error_errno(r, "Failed to bind Varlink methods: %m");
r = sd_varlink_server_loop_auto(varlink_server);
if (r == -EPERM)
return log_error_errno(r, "Invoked by unprivileged Varlink peer, refusing.");
if (r < 0)
return log_error_errno(r, "Failed to run Varlink event loop: %m");
return EXIT_SUCCESS;
}
return dispatch_verb(args, NULL);
}
DEFINE_MAIN_FUNCTION(run);