| /* SPDX-License-Identifier: GPL-2.0-or-later */ |
| |
| #include <commonlib/bsd/compression.h> |
| #include <console/console.h> |
| #include <bootmem.h> |
| #include <program_loading.h> |
| #include <string.h> |
| #include <lib.h> |
| #include <fit.h> |
| #include <endian.h> |
| |
| #define MAX_KERNEL_SIZE (64*MiB) |
| |
| struct arm64_kernel_header { |
| u32 code0; |
| u32 code1; |
| u64 text_offset; |
| u64 image_size; |
| u64 flags; |
| u64 res2; |
| u64 res3; |
| u64 res4; |
| u32 magic; |
| #define KERNEL_HEADER_MAGIC 0x644d5241 |
| u32 res5; |
| }; |
| |
| static struct { |
| union { |
| struct arm64_kernel_header header; |
| u8 raw[sizeof(struct arm64_kernel_header) + 0x100]; |
| }; |
| #define SCRATCH_CANARY_VALUE 0xdeadbeef |
| u32 canary; |
| } scratch; |
| |
| /* Returns true if decompressing was successful and it looks like a kernel. */ |
| static bool decompress_kernel_header(const struct fit_image_node *node) |
| { |
| /* Partially decompress to get text_offset. Can't check for errors. */ |
| scratch.canary = SCRATCH_CANARY_VALUE; |
| switch (node->compression) { |
| case CBFS_COMPRESS_NONE: |
| memcpy(scratch.raw, node->data, sizeof(scratch.raw)); |
| break; |
| case CBFS_COMPRESS_LZMA: |
| ulzman(node->data, node->size, |
| scratch.raw, sizeof(scratch.raw)); |
| break; |
| case CBFS_COMPRESS_LZ4: |
| ulz4fn(node->data, node->size, |
| scratch.raw, sizeof(scratch.raw)); |
| break; |
| default: |
| printk(BIOS_ERR, "Unsupported compression algorithm!\n"); |
| return false; |
| } |
| |
| /* Should never happen, but if it does we'll want to know. */ |
| if (scratch.canary != SCRATCH_CANARY_VALUE) |
| die("ERROR: Partial decompression ran over scratchbuf!\n"); |
| |
| if (scratch.header.magic != KERNEL_HEADER_MAGIC) { |
| printk(BIOS_ERR, "Invalid kernel magic: %#.8x\n != %#.8x\n", |
| scratch.header.magic, KERNEL_HEADER_MAGIC); |
| return false; |
| } |
| |
| /** |
| * Prior to v3.17, the endianness of text_offset was not specified. In |
| * these cases image_size is zero and text_offset is 0x80000 in the |
| * endianness of the kernel. Where image_size is non-zero image_size is |
| * little-endian and must be respected. Where image_size is zero, |
| * text_offset can be assumed to be 0x80000. |
| */ |
| if (!scratch.header.image_size) |
| scratch.header.text_offset = cpu_to_le64(0x80000); |
| |
| return true; |
| } |
| |
| static size_t get_kernel_size(const struct fit_image_node *node) |
| { |
| if (scratch.header.image_size) |
| return le64_to_cpu(scratch.header.image_size); |
| |
| /** |
| * When image_size is zero, a bootloader should attempt to keep as much |
| * memory as possible free for use by the kernel immediately after the |
| * end of the kernel image. The amount of space required will vary |
| * depending on selected features, and is effectively unbound. |
| */ |
| |
| printk(BIOS_WARNING, "FIT: image_size not set in kernel header.\n" |
| "Leaving additional %u MiB of free space after kernel.\n", |
| MAX_KERNEL_SIZE >> 20); |
| |
| return node->size + MAX_KERNEL_SIZE; |
| } |
| |
| static bool fit_place_kernel(const struct range_entry *r, void *arg) |
| { |
| struct region *region = arg; |
| resource_t start; |
| |
| if (range_entry_tag(r) != BM_MEM_RAM) |
| return true; |
| |
| /** |
| * The Image must be placed text_offset bytes from a 2MB aligned base |
| * address anywhere in usable system RAM and called there. The region |
| * between the 2 MB aligned base address and the start of the image has |
| * no special significance to the kernel, and may be used for other |
| * purposes. |
| * |
| * If the reserved memory (BL31 for example) is smaller than text_offset |
| * we can use the 2 MiB base address, otherwise use the next 2 MiB page. |
| * It's not mandatory, but wastes less memory below the kernel. |
| */ |
| start = ALIGN_DOWN(range_entry_base(r), 2 * MiB) + |
| le64_to_cpu(scratch.header.text_offset); |
| |
| if (start < range_entry_base(r)) |
| start += 2 * MiB; |
| /** |
| * At least image_size bytes from the start of the image must be free |
| * for use by the kernel. |
| */ |
| if (start + region->size < range_entry_end(r)) { |
| region->offset = (size_t)start; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Place the region in free memory range. |
| * |
| * The caller has to set region->offset to the minimum allowed address. |
| * The region->offset is usually 0 on kernel >v4.6 and kernel_base + kernel_size |
| * on kernel <v4.6. |
| */ |
| static bool fit_place_mem(const struct range_entry *r, void *arg) |
| { |
| struct region *region = arg; |
| resource_t start; |
| |
| if (range_entry_tag(r) != BM_MEM_RAM) |
| return true; |
| |
| /* Linux 4.15 doesn't like 4KiB alignment. Align to 1 MiB for now. */ |
| start = ALIGN_UP(MAX(region->offset, range_entry_base(r)), 1 * MiB); |
| |
| if (start + region->size < range_entry_end(r)) { |
| region->offset = (size_t)start; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool fit_payload_arch(struct prog *payload, struct fit_config_node *config, |
| struct region *kernel, |
| struct region *fdt, |
| struct region *initrd) |
| { |
| bool place_anywhere; |
| void *arg = NULL; |
| |
| if (!decompress_kernel_header(config->kernel)) { |
| printk(BIOS_CRIT, "Payload doesn't look like an ARM64" |
| " kernel Image.\n"); |
| return false; |
| } |
| |
| /* Update kernel size from image header, if possible */ |
| kernel->size = get_kernel_size(config->kernel); |
| printk(BIOS_DEBUG, "FIT: Using kernel size of 0x%zx bytes\n", |
| kernel->size); |
| |
| /** |
| * The code assumes that bootmem_walk provides a sorted list of memory |
| * regions, starting from the lowest address. |
| * The order of the calls here doesn't matter, as the placement is |
| * enforced in the called functions. |
| * For details check code on top. |
| */ |
| |
| if (!bootmem_walk(fit_place_kernel, kernel)) |
| return false; |
| |
| /* Mark as reserved for future allocations. */ |
| bootmem_add_range(kernel->offset, kernel->size, BM_MEM_PAYLOAD); |
| |
| /** |
| * NOTE: versions prior to v4.6 cannot make use of memory below the |
| * physical offset of the Image so it is recommended that the Image be |
| * placed as close as possible to the start of system RAM. |
| * |
| * For kernel <v4.6 the INITRD and FDT can't be placed below the kernel. |
| * In that case set region offset to an address on top of kernel. |
| */ |
| place_anywhere = !!(le64_to_cpu(scratch.header.flags) & (1 << 3)); |
| printk(BIOS_DEBUG, "FIT: Placing FDT and INITRD %s\n", |
| place_anywhere ? "anywhere" : "on top of kernel"); |
| |
| /* Place INITRD */ |
| if (config->ramdisk) { |
| if (place_anywhere) |
| initrd->offset = 0; |
| else |
| initrd->offset = kernel->offset + kernel->size; |
| |
| if (!bootmem_walk(fit_place_mem, initrd)) |
| return false; |
| /* Mark as reserved for future allocations. */ |
| bootmem_add_range(initrd->offset, initrd->size, BM_MEM_PAYLOAD); |
| } |
| |
| /* Place FDT */ |
| if (place_anywhere) |
| fdt->offset = 0; |
| else |
| fdt->offset = kernel->offset + kernel->size; |
| |
| if (!bootmem_walk(fit_place_mem, fdt)) |
| return false; |
| /* Mark as reserved for future allocations. */ |
| bootmem_add_range(fdt->offset, fdt->size, BM_MEM_PAYLOAD); |
| |
| /* Kernel expects FDT as argument */ |
| arg = (void *)fdt->offset; |
| |
| prog_set_entry(payload, (void *)kernel->offset, arg); |
| |
| bootmem_dump_ranges(); |
| |
| return true; |
| } |