efi.c

/*
 * Copyright (c) 2024 Netflix, Inc
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <sys/param.h>
#include <sys/linker.h>
#include "stand.h"
#include "bootstrap.h"
#include "efi.h"
#include "seg.h"
#include "util.h"

vm_paddr_t efi_systbl_phys;
struct efi_map_header *efi_map_hdr;
uint32_t efi_map_size;
vm_paddr_t efi_map_phys_src;	/* From DTB */
vm_paddr_t efi_map_phys_dst;	/* From our memory map metadata module */

void
efi_set_systbl(uint64_t tbl)
{
	efi_systbl_phys = tbl;
}
		
#if 0
/* Note: This is useless since runtime-map is a subset */
void
efi_read_from_sysfs(void)
{
	uint32_t efisz, sz, map_size;
	int entries = 0;
	struct efi_md *map;		/* Really an array */
	char *buf;
	struct stat sb;
	char fn[100];

	/*
	 * Count the number of entries we have. They are numbered from 0
	 * through entries - 1.
	 */
	do {
		printf("Looking at index %d\n", entries);
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/phys_addr", entries++);
	} while (stat(fn, &sb) == 0);

	/*
	 * We incremented entries one past the first failure, so we need to
	 * adjust the count and the test for 'nothing found' is against 1.
	 */
	if (entries == 1)
		goto err;
	entries--;

	/* XXX lots of copied code, refactor? */
	map_size = sizeof(struct efi_md) * entries;
	efisz = roundup2(sizeof(*efi_map_hdr), 16);
	sz = efisz + map_size;
	buf = malloc(efisz + map_size);
	if (buf == NULL)
		return;
	efi_map_hdr = (struct efi_map_header *)buf;
	efi_map_size = sz;
	map = (struct efi_md *)(buf + efisz);
	bzero(map, sz);
	efi_map_hdr->memory_size = map_size;
	efi_map_hdr->descriptor_size = sizeof(struct efi_md);
	efi_map_hdr->descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;
	for (int i = 0; i < entries; i++) {
		struct efi_md *m;

		printf("Populating index %d\n", i);
		m = map + i;
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/type", i);
		if (!file2u32(fn, &m->md_type))
			goto err;
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/phys_addr", i);
		if (!file2u64(fn, &m->md_phys))
			goto err;
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/virt_addr", i);
		if (!file2u64(fn, &m->md_virt))
			goto err;
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/num_pages", i);
		if (!file2u64(fn, &m->md_pages))
			goto err;
		snprintf(fn, sizeof(fn), "/sys/firmware/efi/runtime-map/%d/attribute", i);
		if (!file2u64(fn, &m->md_attr))
			goto err;
	}
	efi_map_phys_src = 0;
	printf("UEFI MAP:\n");
	print_efi_map(efi_map_hdr);
	printf("DONE\n");
	return;
err:
	printf("Parse error in reading current memory map\n");
}
#endif

/*
 * We may have no ability to read the PA that this map is in, so pass
 * the address to FreeBSD via a rather odd flag entry as the first map
 * so early boot can copy the memory map into this space and have the
 * rest of the code cope.
 */
bool
efi_read_from_pa(uint64_t pa, uint32_t map_size, uint32_t desc_size, uint32_t vers)
{
	uint32_t efisz, sz;
	char *buf;
	int fd2, len;
	struct efi_md *map;		/* Really an array */

	/*
	 * We may have no ability to read the PA that this map is in, so pass
	 * the address to FreeBSD via a rather odd flag entry as the first map
	 * so early boot can copy the memory map into this space and have the
	 * rest of the code cope. We also have to round the size of the header
	 * to 16 byte boundary.
	 */
	efisz = roundup2(sizeof(*efi_map_hdr), 16);
	sz = efisz + map_size;
	buf = malloc(efisz + map_size);
	if (buf == NULL)
		return false;
	efi_map_hdr = (struct efi_map_header *)buf;
	efi_map_size = sz;
	map = (struct efi_md *)(buf + efisz);
	bzero(map, sz);
	efi_map_hdr->memory_size = map_size;
	efi_map_hdr->descriptor_size = desc_size;
	efi_map_hdr->descriptor_version = vers;

	/*
	 * Try to read in the actual UEFI map. This may fail, and that's OK. We just
	 * won't print the map.
	 */
	fd2 = open("host:/dev/mem", O_RDONLY);
	if (fd2 < 0)
		goto no_read;
	if (lseek(fd2, pa, SEEK_SET) < 0)
		goto no_read;
	len = read(fd2, map, sz);
	if (len != sz)
		goto no_read;
	efi_map_phys_src = 0;		/* Mark MODINFOMD_EFI_MAP as valid */
	close(fd2);
	printf("UEFI MAP:\n");
	print_efi_map(efi_map_hdr);
	return (true);

no_read:				/* Just get it the trampoline */
	efi_map_phys_src = pa;
	close(fd2);
	return (true);
}

void
foreach_efi_map_entry(struct efi_map_header *efihdr, efi_map_entry_cb cb, void *argp)
{
	struct efi_md *map, *p;
	size_t efisz;
	int ndesc, i;

	/*
	 * Memory map data provided by UEFI via the GetMemoryMap
	 * Boot Services API.
	 */
	efisz = roundup2(sizeof(struct efi_map_header), 16);
	map = (struct efi_md *)((uint8_t *)efihdr + efisz);

	if (efihdr->descriptor_size == 0)
		return;
	ndesc = efihdr->memory_size / efihdr->descriptor_size;

	for (i = 0, p = map; i < ndesc; i++,
	    p = efi_next_descriptor(p, efihdr->descriptor_size)) {
		cb(p, argp);
	}
}

/* XXX REFACTOR WITH KERNEL */
static void
print_efi_map_entry(struct efi_md *p, void *argp __unused)
{
	const char *type;
	static const char *types[] = {
		"Reserved",
		"LoaderCode",
		"LoaderData",
		"BootServicesCode",
		"BootServicesData",
		"RuntimeServicesCode",
		"RuntimeServicesData",
		"ConventionalMemory",
		"UnusableMemory",
		"ACPIReclaimMemory",
		"ACPIMemoryNVS",
		"MemoryMappedIO",
		"MemoryMappedIOPortSpace",
		"PalCode",
		"PersistentMemory"
	};

	if (p->md_type < nitems(types))
		type = types[p->md_type];
	else
		type = "<INVALID>";
	printf("%23s %012lx %012lx %08lx ", type, p->md_phys,
	    p->md_virt, p->md_pages);
	if (p->md_attr & EFI_MD_ATTR_UC)
		printf("UC ");
	if (p->md_attr & EFI_MD_ATTR_WC)
		printf("WC ");
	if (p->md_attr & EFI_MD_ATTR_WT)
		printf("WT ");
	if (p->md_attr & EFI_MD_ATTR_WB)
		printf("WB ");
	if (p->md_attr & EFI_MD_ATTR_UCE)
		printf("UCE ");
	if (p->md_attr & EFI_MD_ATTR_WP)
		printf("WP ");
	if (p->md_attr & EFI_MD_ATTR_RP)
		printf("RP ");
	if (p->md_attr & EFI_MD_ATTR_XP)
		printf("XP ");
	if (p->md_attr & EFI_MD_ATTR_NV)
		printf("NV ");
	if (p->md_attr & EFI_MD_ATTR_MORE_RELIABLE)
		printf("MORE_RELIABLE ");
	if (p->md_attr & EFI_MD_ATTR_RO)
		printf("RO ");
	if (p->md_attr & EFI_MD_ATTR_RT)
		printf("RUNTIME");
	printf("\n");
}

void
print_efi_map(struct efi_map_header *efihdr)
{
	printf("%23s %12s %12s %8s %4s\n",
	    "Type", "Physical", "Virtual", "#Pages", "Attr");

	foreach_efi_map_entry(efihdr, print_efi_map_entry, NULL);
}

void
efi_bi_loadsmap(struct preloaded_file *kfp)
{
	/*
	 * Make a note of a systbl. This is nearly mandatory on AARCH64.
	 */
	if (efi_systbl_phys)
		file_addmetadata(kfp, MODINFOMD_FW_HANDLE, sizeof(efi_systbl_phys), &efi_systbl_phys);

	/*
	 * If we have efi_map_hdr, then it's a pointer to the PA where this
	 * memory map lives. The trampoline code will copy it over. If we don't
	 * have it, panic because /proc/iomem isn't sufficient and there's no
	 * hope.
	 */
	if (efi_map_hdr != NULL) {
		file_addmetadata(kfp, MODINFOMD_EFI_MAP, efi_map_size, efi_map_hdr);
		return;
	}

	panic("Can't get UEFI memory map, nor a pointer to it, can't proceed.\n");
}