HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/boot/stub.c

58,034 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 94c4ac49e4bf61b2a7b50bf62dbd9226be8ba134

Lines 1001–1317 of 1,317

        UnifiedSection section = _UNIFIED_SECTION_MAX;
 
        /* Use automatically selected DT if available, otherwise go for "normal" one */
        if (PE_SECTION_VECTOR_IS_SET(sections + UNIFIED_SECTION_DTBAUTO))
                section = UNIFIED_SECTION_DTBAUTO;
        else if (PE_SECTION_VECTOR_IS_SET(sections + UNIFIED_SECTION_DTB))
                section = UNIFIED_SECTION_DTB;
        else
                return;
 
        err = devicetree_install_from_memory(
                        dt_state,
                        (const uint8_t*) loaded_image->ImageBase + sections[section].memory_offset,
                        sections[section].memory_size);
        if (err != EFI_SUCCESS)
                log_error_status(err, "Error loading embedded devicetree, ignoring: %m");
}
 
static void load_all_addons(
                EFI_HANDLE image,
                EFI_LOADED_IMAGE_PROTOCOL *loaded_image,
                const char *uname,
                char16_t **cmdline_addons,
                NamedAddon **dt_addons,
                size_t *n_dt_addons,
                NamedAddon **initrd_addons,
                size_t *n_initrd_addons,
                NamedAddon **ucode_addons,
                size_t *n_ucode_addons) {
 
        EFI_STATUS err;
 
        assert(loaded_image);
        assert(cmdline_addons);
        assert(dt_addons);
        assert(n_dt_addons);
        assert(initrd_addons);
        assert(n_initrd_addons);
        assert(ucode_addons);
        assert(n_ucode_addons);
 
        err = load_addons(
                        image,
                        loaded_image,
                        u"\\loader\\addons",
                        uname,
                        cmdline_addons,
                        dt_addons,
                        n_dt_addons,
                        initrd_addons,
                        n_initrd_addons,
                        ucode_addons,
                        n_ucode_addons);
        if (err != EFI_SUCCESS)
                log_error_status(err, "Error loading global addons, ignoring: %m");
 
        /* Some bootloaders always pass NULL in FilePath, so we need to check for it here. */
        _cleanup_free_ char16_t *dropin_dir = get_extra_dir(loaded_image->FilePath);
        if (!dropin_dir)
                return;
 
        err = load_addons(
                        image,
                        loaded_image,
                        dropin_dir,
                        uname,
                        cmdline_addons,
                        dt_addons,
                        n_dt_addons,
                        initrd_addons,
                        n_initrd_addons,
                        ucode_addons,
                        n_ucode_addons);
        if (err != EFI_SUCCESS)
                log_error_status(err, "Error loading UKI-specific addons, ignoring: %m");
}
 
static void display_splash(
                EFI_LOADED_IMAGE_PROTOCOL *loaded_image,
                const PeSectionVector sections[static _UNIFIED_SECTION_MAX]) {
 
        assert(loaded_image);
        assert(sections);
 
        if (!PE_SECTION_VECTOR_IS_SET(sections + UNIFIED_SECTION_SPLASH))
                return;
 
        graphics_splash((const uint8_t*) loaded_image->ImageBase + sections[UNIFIED_SECTION_SPLASH].memory_offset, sections[UNIFIED_SECTION_SPLASH].memory_size);
}
 
static EFI_STATUS find_sections(
                EFI_LOADED_IMAGE_PROTOCOL *loaded_image,
                unsigned profile,
                PeSectionVector sections[static _UNIFIED_SECTION_MAX]) {
 
        EFI_STATUS err;
 
        assert(loaded_image);
        assert(sections);
 
        const PeSectionHeader *section_table;
        size_t n_section_table, size_in_memory;
        err = pe_section_table_from_base(loaded_image->ImageBase, loaded_image->ImageSize, &section_table, &n_section_table, &size_in_memory);
        if (err != EFI_SUCCESS)
                return log_error_status(err, "Unable to locate PE section table: %m");
 
        /* Get the base sections */
        err = pe_locate_profile_sections(
                        section_table,
                        n_section_table,
                        unified_sections,
                        /* profile= */ UINT_MAX,
                        /* validate_base= */ PTR_TO_SIZE(loaded_image->ImageBase),
                        size_in_memory,
                        sections);
        if (err != EFI_SUCCESS)
                return log_error_status(err, "Unable to locate embedded base PE sections: %m");
 
        if (profile != UINT_MAX) {
                /* And then override them with the per-profile sections of the selected profile */
                err = pe_locate_profile_sections(
                                section_table,
                                n_section_table,
                                unified_sections,
                                profile,
                                /* validate_base= */ PTR_TO_SIZE(loaded_image->ImageBase),
                                size_in_memory,
                                sections);
                if (err != EFI_SUCCESS && !(err == EFI_NOT_FOUND && profile == 0)) /* the first profile is implied if it doesn't exist */
                        return log_error_status(err, "Unable to locate embedded per-profile PE sections: %m");
        }
 
        if (!PE_SECTION_VECTOR_IS_SET(sections + UNIFIED_SECTION_LINUX))
                return log_error_status(EFI_NOT_FOUND, "Image lacks .linux section.");
 
        return EFI_SUCCESS;
}
 
static void settle_command_line(
                EFI_LOADED_IMAGE_PROTOCOL *loaded_image,
                const PeSectionVector sections[static _UNIFIED_SECTION_MAX],
                char16_t **cmdline,
                int *parameters_measured) {
 
        assert(loaded_image);
        assert(sections);
        assert(cmdline);
 
        /* This determines which command line to use. On input *cmdline contains the custom passed in cmdline
         * if there is any.
         *
         * We'll suppress the custom cmdline if we are in Secure Boot mode, and if either there is already
         * a cmdline baked into the UKI or we are in confidential VM mode. */
 
        if (!isempty(*cmdline)) {
                if (secure_boot_enabled() && (PE_SECTION_VECTOR_IS_SET(sections + UNIFIED_SECTION_CMDLINE) || is_confidential_vm()))
                        /* Drop the custom cmdline */
                        *cmdline = mfree(*cmdline);
                else {
                        /* Let's measure the passed kernel command line into the TPM. Note that this possibly
                         * duplicates what we already did in the boot menu, if that was already
                         * used. However, since we want the boot menu to support an EFI binary, and want to
                         * this stub to be usable from any boot menu, let's measure things anyway. */
                        bool m = false;
                        (void) tpm_log_load_options(*cmdline, &m);
                        combine_measured_flag(parameters_measured, m);
                }
        }
 
        /* No cmdline specified? Or suppressed? Then let's take the one from the UKI, if there is any. */
        if (isempty(*cmdline))
                *cmdline = mangle_stub_cmdline(pe_section_to_str16(loaded_image, sections + UNIFIED_SECTION_CMDLINE));
}
 
static void measure_profile(unsigned profile, int *parameters_measured) {
        if (profile == 0) /* don't measure anything about the default profile */
                return;
 
        _cleanup_free_ char16_t *s = xasprintf("%u", profile);
 
        bool m = false;
        (void) tpm_log_tagged_event(
                        TPM2_PCR_KERNEL_CONFIG,
                        POINTER_TO_PHYSICAL_ADDRESS(s),
                        strsize16(s),
                        UKI_PROFILE_EVENT_TAG_ID,
                        s,
                        &m);
        combine_measured_flag(parameters_measured, m);
}
 
static EFI_STATUS run(EFI_HANDLE image) {
        int sections_measured = -1, parameters_measured = -1, sysext_measured = -1, confext_measured = -1;
        _cleanup_(devicetree_cleanup) struct devicetree_state dt_state = {};
        _cleanup_free_ char16_t *cmdline = NULL, *cmdline_addons = NULL;
        _cleanup_(initrds_free) struct iovec initrds[_INITRD_MAX] = {};
        PeSectionVector sections[ELEMENTSOF(unified_sections)] = {};
        EFI_LOADED_IMAGE_PROTOCOL *loaded_image;
        _cleanup_free_ char *uname = NULL;
        NamedAddon *dt_addons = NULL, *initrd_addons = NULL, *ucode_addons = NULL;
        size_t n_dt_addons = 0, n_initrd_addons = 0, n_ucode_addons = 0;
        _cleanup_free_ struct iovec *all_initrds = NULL;
        size_t n_all_initrds = 0;
        unsigned profile = 0;
        EFI_STATUS err;
 
        log_set_max_level_from_smbios();
 
        err = BS->HandleProtocol(image, MAKE_GUID_PTR(EFI_LOADED_IMAGE_PROTOCOL), (void **) &loaded_image);
        if (err != EFI_SUCCESS)
                return log_error_status(err, "Error getting a LoadedImageProtocol handle: %m");
 
        /* Pick up the arguments passed to us, split out the prefixing profile parameter, and return the rest
         * as potential command line to use. */
        process_arguments(image, loaded_image, &profile, &cmdline);
 
        /* Find the sections we want to operate on, both the basic ones, and the one appropriate for the
         * selected profile. */
        err = find_sections(loaded_image, profile, sections);
        if (err != EFI_SUCCESS)
                return err;
 
        measure_profile(profile, &parameters_measured);
        measure_sections(loaded_image, sections, &sections_measured);
 
        /* Show splash screen as early as possible, but after measuring it */
        display_splash(loaded_image, sections);
 
        refresh_random_seed(loaded_image);
 
        uint8_t boot_secret[BOOT_SECRET_SIZE] = {}; /* all zeroes means: not acquired */
        CLEANUP_ERASE(boot_secret);
        (void) prepare_boot_secret(loaded_image, sections + UNIFIED_SECTION_OSREL, boot_secret);
 
        uname = pe_section_to_str8(loaded_image, sections + UNIFIED_SECTION_UNAME);
 
        /* Let's now check if we actually want to use the command line, measure it if it was passed in. */
        settle_command_line(loaded_image, sections, &cmdline, &parameters_measured);
 
        /* Now that we have the UKI sections loaded, also load global first and then local (per-UKI)
         * addons. The data is loaded at once, and then used later. */
        CLEANUP_ARRAY(dt_addons, n_dt_addons, named_addon_free_array);
        CLEANUP_ARRAY(initrd_addons, n_initrd_addons, named_addon_free_array);
        CLEANUP_ARRAY(ucode_addons, n_ucode_addons, named_addon_free_array);
        load_all_addons(image, loaded_image, uname, &cmdline_addons, &dt_addons, &n_dt_addons, &initrd_addons, &n_initrd_addons, &ucode_addons, &n_ucode_addons);
 
        /* If we have any extra command line to add via PE addons, load them now and append, and measure the
         * additions together, after the embedded options, but before the smbios ones, so that the order is
         * reversed from "most hardcoded" to "most dynamic". The global addons are loaded first, and the
         * image-specific ones later, for the same reason. */
        cmdline_append_and_measure_addons(cmdline_addons, &cmdline, &parameters_measured);
        cmdline_append_and_measure_smbios(&cmdline, &parameters_measured);
 
        cmdline_append_console(&cmdline);
 
        export_common_variables(loaded_image);
        export_stub_variables(loaded_image, profile);
 
        /* Measure SMBIOS data into PCR 1, unless sd-boot already did so in the same boot (tracked via
         * the LoaderPcrSMBIOS EFI variable). */
        measure_smbios();
 
        /* First load the base device tree, then fix it up using addons - global first, then per-UKI. */
        install_embedded_devicetree(loaded_image, sections, &dt_state);
        install_addon_devicetrees(&dt_state, dt_addons, n_dt_addons, &parameters_measured);
 
        /* Generate & find all initrds */
        acquire_previous_initrd(initrds);
        generate_sidecar_initrds(loaded_image, initrds, &parameters_measured, &sysext_measured, &confext_measured);
        generate_embedded_initrds(loaded_image, sections, initrds);
        generate_boot_secret_initrd(boot_secret, initrds);
        lookup_embedded_initrds(loaded_image, sections, initrds);
 
        /* Add initrds in the right order. Generally, later initrds can overwrite files in earlier ones,
         * except for ucode, where the kernel uses the first matching embedded filename.
         * We want addons to take precedence over the base initrds, so the order is:
         * 1. Ucode addons
         * 2. UKI ucode
         * 3. Previous initrds
         * 4. UKI initrd
         * 5. Generated initrds
         * 6. initrd addons */
        measure_and_append_ucode_addons(&all_initrds, &n_all_initrds, ucode_addons, n_ucode_addons, &parameters_measured);
        extend_initrds(initrds, &all_initrds, &n_all_initrds);
        measure_and_append_initrd_addons(&all_initrds, &n_all_initrds, initrd_addons, n_initrd_addons, &parameters_measured);
 
        /* Export variables indicating what we measured */
        export_pcr_variables(sections_measured, parameters_measured, sysext_measured, confext_measured);
 
        /* Combine the initrds into one */
        _cleanup_pages_ Pages initrd_pages = {};
        struct iovec final_initrd = {};
        if (n_all_initrds > 1) {
                /* If there is more then 1 initrd we need to combine them */
                err = combine_initrds(all_initrds, n_all_initrds, &initrd_pages, &final_initrd.iov_len);
                if (err != EFI_SUCCESS)
                        return err;
 
                final_initrd.iov_base = PHYSICAL_ADDRESS_TO_POINTER(initrd_pages.addr);
 
                /* Given these might be large let's free them explicitly before we pass control to Linux */
                initrds_free(&initrds);
        } else if (n_all_initrds == 1)
                final_initrd = all_initrds[0];
 
        struct iovec kernel = IOVEC_MAKE(
                        (const uint8_t*) loaded_image->ImageBase + sections[UNIFIED_SECTION_LINUX].memory_offset,
                        sections[UNIFIED_SECTION_LINUX].memory_size);
 
        err = linux_exec(image, cmdline, &kernel, &final_initrd);
        graphics_mode(false);
        return err;
}
 
// NOLINTNEXTLINE(misc-use-internal-linkage)
DEFINE_EFI_MAIN_FUNCTION(run, "systemd-stub", /* wait_for_debugger= */ false);