/* SPDX-License-Identifier: GPL-2.0-only */ #include <commonlib/bsd/compression.h> #include <commonlib/endian.h> #include <console/console.h> #include <string.h> #include <symbols.h> #include <cbfs.h> #include <lib.h> #include <bootmem.h> #include <program_loading.h> #include <timestamp.h> #include <cbmem.h> #include <types.h> /* The type syntax for C is essentially unparsable. -- Rob Pike */ typedef int (*checker_t)(struct cbfs_payload_segment *cbfssegs, void *args); /* Decode a serialized cbfs payload segment * from memory into native endianness. */ static void cbfs_decode_payload_segment(struct cbfs_payload_segment *segment, const struct cbfs_payload_segment *src) { segment->type = read_be32(&src->type); segment->compression = read_be32(&src->compression); segment->offset = read_be32(&src->offset); segment->load_addr = read_be64(&src->load_addr); segment->len = read_be32(&src->len); segment->mem_len = read_be32(&src->mem_len); } static int segment_targets_type(void *dest, unsigned long memsz, enum bootmem_type dest_type) { /* No bootmem to check in earlier stages, caller should not use selfload_check(). */ if (!ENV_RAMSTAGE) { printk(BIOS_ERR, "Callers not supposed to call selfload_check() in romstage"); return 0; } uintptr_t d = (uintptr_t) dest; if (bootmem_region_targets_type(d, memsz, dest_type)) return 1; if (payload_arch_usable_ram_quirk(d, memsz)) return 1; printk(BIOS_ERR, "SELF segment doesn't target RAM: %p, %lu bytes\n", dest, memsz); bootmem_dump_ranges(); return 0; } static int load_one_segment(uint8_t *dest, uint8_t *src, size_t len, size_t memsz, uint32_t compression, int flags) { unsigned char *middle, *end; printk(BIOS_DEBUG, "Loading Segment: addr: %p memsz: 0x%016zx filesz: 0x%016zx\n", dest, memsz, len); /* Compute the boundaries of the segment */ end = dest + memsz; /* Copy data from the initial buffer */ switch (compression) { case CBFS_COMPRESS_LZMA: { printk(BIOS_DEBUG, "using LZMA\n"); timestamp_add_now(TS_ULZMA_START); len = ulzman(src, len, dest, memsz); timestamp_add_now(TS_ULZMA_END); if (!len) /* Decompression Error. */ return 0; break; } case CBFS_COMPRESS_LZ4: { printk(BIOS_DEBUG, "using LZ4\n"); timestamp_add_now(TS_ULZ4F_START); len = ulz4fn(src, len, dest, memsz); timestamp_add_now(TS_ULZ4F_END); if (!len) /* Decompression Error. */ return 0; break; } case CBFS_COMPRESS_NONE: { printk(BIOS_DEBUG, "it's not compressed!\n"); memcpy(dest, src, len); break; } default: printk(BIOS_INFO, "CBFS: Unknown compression type %d\n", compression); return 0; } /* Calculate middle after any changes to len. */ middle = dest + len; printk(BIOS_SPEW, "[ 0x%08lx, %08lx, 0x%08lx) <- %08lx\n", (unsigned long)dest, (unsigned long)middle, (unsigned long)end, (unsigned long)src); /* Zero the extra bytes between middle & end */ if (middle < end) { printk(BIOS_DEBUG, "Clearing Segment: addr: 0x%016lx memsz: 0x%016lx\n", (unsigned long)middle, (unsigned long)(end - middle)); /* Zero the extra bytes */ memset(middle, 0, end - middle); } /* * Each architecture can perform additional operations * on the loaded segment */ prog_segment_loaded((uintptr_t)dest, memsz, flags); return 1; } /* Note: this function is a bit dangerous so is not exported. * It assumes you're smart enough not to call it with the very * last segment, since it uses seg + 1 */ static int last_loadable_segment(struct cbfs_payload_segment *seg) { return read_be32(&(seg + 1)->type) == PAYLOAD_SEGMENT_ENTRY; } static int check_payload_segments(struct cbfs_payload_segment *cbfssegs, enum bootmem_type dest_type) { uint8_t *dest; size_t memsz; struct cbfs_payload_segment *seg, segment; /* dest_type == INVALID means we're not supposed to check anything. */ if (dest_type == BM_MEM_INVALID) return 0; for (seg = cbfssegs;; ++seg) { printk(BIOS_DEBUG, "Checking segment from ROM address %p\n", seg); cbfs_decode_payload_segment(&segment, seg); dest = (uint8_t *)(uintptr_t)segment.load_addr; memsz = segment.mem_len; if (segment.type == PAYLOAD_SEGMENT_ENTRY) break; if (!segment_targets_type(dest, memsz, dest_type)) return -1; } return 0; } static int load_payload_segments(struct cbfs_payload_segment *cbfssegs, uintptr_t *entry) { uint8_t *dest, *src; size_t filesz, memsz; uint32_t compression; struct cbfs_payload_segment *first_segment, *seg, segment; int flags = 0; for (first_segment = seg = cbfssegs;; ++seg) { printk(BIOS_DEBUG, "Loading segment from ROM address %p\n", seg); cbfs_decode_payload_segment(&segment, seg); dest = (uint8_t *)(uintptr_t)segment.load_addr; memsz = segment.mem_len; compression = segment.compression; filesz = segment.len; switch (segment.type) { case PAYLOAD_SEGMENT_CODE: case PAYLOAD_SEGMENT_DATA: printk(BIOS_DEBUG, " %s (compression=%x)\n", segment.type == PAYLOAD_SEGMENT_CODE ? "code" : "data", segment.compression); src = ((uint8_t *)first_segment) + segment.offset; printk(BIOS_DEBUG, " New segment dstaddr %p memsize 0x%zx srcaddr %p filesize 0x%zx\n", dest, memsz, src, filesz); /* Clean up the values */ if (filesz > memsz) { filesz = memsz; printk(BIOS_DEBUG, " cleaned up filesize 0x%zx\n", filesz); } break; case PAYLOAD_SEGMENT_BSS: printk(BIOS_DEBUG, " BSS %p (%d byte)\n", (void *) (intptr_t)segment.load_addr, segment.mem_len); filesz = 0; src = ((uint8_t *)first_segment) + segment.offset; compression = CBFS_COMPRESS_NONE; break; case PAYLOAD_SEGMENT_ENTRY: printk(BIOS_DEBUG, " Entry Point %p\n", (void *) (intptr_t)segment.load_addr); *entry = segment.load_addr; /* Per definition, a payload always has the entry point * as last segment. Thus, we use the occurrence of the * entry point as break condition for the loop. */ return 0; default: /* We found something that we don't know about. Throw * hands into the sky and run away! */ printk(BIOS_EMERG, "Bad segment type %x\n", segment.type); return -1; } /* Note that the 'seg + 1' is safe as we only call this * function on "not the last" * items, since entry * is always last. */ if (last_loadable_segment(seg)) flags = SEG_FINAL; if (!load_one_segment(dest, src, filesz, memsz, compression, flags)) return -1; } return 1; } __weak int payload_arch_usable_ram_quirk(uint64_t start, uint64_t size) { return 0; } bool selfload_mapped(struct prog *payload, void *mapping, enum bootmem_type dest_type) { uintptr_t entry = 0; struct cbfs_payload_segment *cbfssegs; cbfssegs = &((struct cbfs_payload *)mapping)->segments; if (check_payload_segments(cbfssegs, dest_type)) return false; if (load_payload_segments(cbfssegs, &entry)) return false; printk(BIOS_SPEW, "Loaded segments\n"); /* Pass cbtables to payload if architecture desires it. */ prog_set_entry(payload, (void *)entry, cbmem_find(CBMEM_ID_CBTABLE)); return true; } bool selfload_check(struct prog *payload, enum bootmem_type dest_type) { if (prog_locate_hook(payload)) return false; payload->cbfs_type = CBFS_TYPE_SELF; void *mapping = cbfs_type_map(prog_name(payload), NULL, &payload->cbfs_type); if (!mapping) return false; bool ret = selfload_mapped(payload, mapping, dest_type); cbfs_unmap(mapping); return ret; } bool selfload(struct prog *payload) { return selfload_check(payload, BM_MEM_INVALID); }