main/vaseboot
main
/
vaseboot
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
vaseboot/VasEBoot-core/kern/efi/mm.c

807 lines
25 KiB
C
Raw Blame History

/* mm.c - generic EFI memory management */
/*
* VAS_EBOOT -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
*
* VAS_EBOOT is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* VAS_EBOOT is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with VAS_EBOOT. If not, see <http://www.gnu.org/licenses/>.
*/
#include <VasEBoot/misc.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/efi/api.h>
#include <VasEBoot/efi/efi.h>
#include <VasEBoot/cpu/efi/memory.h>
#if defined (__i386__) || defined (__x86_64__)
#include <VasEBoot/pci.h>
#endif
#define NEXT_MEMORY_DESCRIPTOR(desc, size) \
((VasEBoot_efi_memory_descriptor_t *) ((char *) (desc) + (size)))
#define BYTES_TO_PAGES(bytes) (((bytes) + 0xfff) >> 12)
#define BYTES_TO_PAGES_DOWN(bytes) ((bytes) >> 12)
#define PAGES_TO_BYTES(pages) ((pages) << 12)
/* The size of a memory map obtained from the firmware. This must be
a multiplier of 4KB. */
#define MEMORY_MAP_SIZE 0x3000
/* The default heap size for VAS_EBOOT itself in bytes. */
#define DEFAULT_HEAP_SIZE 0x2000000
static void *finish_mmap_buf = 0;
static VasEBoot_efi_uintn_t finish_mmap_size = 0;
static VasEBoot_efi_uintn_t finish_key = 0;
static VasEBoot_efi_uintn_t finish_desc_size;
static VasEBoot_efi_uint32_t finish_desc_version;
int VasEBoot_efi_is_finished = 0;
/*
* We need to roll back EFI allocations on exit. Remember allocations that
* we'll free on exit.
*/
struct efi_allocation;
struct efi_allocation {
VasEBoot_efi_physical_address_t address;
VasEBoot_efi_uint64_t pages;
struct efi_allocation *next;
};
static struct efi_allocation *efi_allocated_memory;
static void
VasEBoot_efi_store_alloc (VasEBoot_efi_physical_address_t address,
VasEBoot_efi_uintn_t pages)
{
VasEBoot_efi_boot_services_t *b;
struct efi_allocation *alloc;
VasEBoot_efi_status_t status;
b = VasEBoot_efi_system_table->boot_services;
status = b->allocate_pool (VAS_EBOOT_EFI_LOADER_DATA,
sizeof(*alloc), (void**)&alloc);
if (status == VAS_EBOOT_EFI_SUCCESS)
{
alloc->next = efi_allocated_memory;
alloc->address = address;
alloc->pages = pages;
efi_allocated_memory = alloc;
}
else
VasEBoot_printf ("Could not malloc memory to remember EFI allocation. "
"Exiting VAS_EBOOT won't free all memory.\n");
}
static void
VasEBoot_efi_drop_alloc (VasEBoot_efi_physical_address_t address,
VasEBoot_efi_uintn_t pages)
{
struct efi_allocation *ea, *eap;
VasEBoot_efi_boot_services_t *b;
b = VasEBoot_efi_system_table->boot_services;
for (eap = NULL, ea = efi_allocated_memory; ea; eap = ea, ea = ea->next)
{
if (ea->address != address)
continue;
if (ea->pages != pages)
VasEBoot_fatal ("VasEBoot_efi_drop_alloc() called with wrong page count");
/* Remove the current entry from the list. */
if (eap)
eap->next = ea->next;
else
efi_allocated_memory = ea->next;
/* Then free the memory backing it. */
b->free_pool (ea);
/* And leave, we're done. */
break;
}
}
/* Allocate pages. Return the pointer to the first of allocated pages. */
void *
VasEBoot_efi_allocate_pages_real (VasEBoot_efi_physical_address_t address,
VasEBoot_efi_uintn_t pages,
VasEBoot_efi_allocate_type_t alloctype,
VasEBoot_efi_memory_type_t memtype)
{
VasEBoot_efi_status_t status;
VasEBoot_efi_boot_services_t *b;
/* Limit the memory access to less than 4GB for 32-bit platforms. */
if (address > VAS_EBOOT_EFI_MAX_USABLE_ADDRESS)
{
char inv_addr[17], max_addr[17]; /* log16(2^64) = 16, plus NUL. */
VasEBoot_snprintf (inv_addr, sizeof (inv_addr) - 1, "%" PRIxVAS_EBOOT_UINT64_T,
address);
VasEBoot_snprintf (max_addr, sizeof (max_addr) - 1, "%" PRIxVAS_EBOOT_UINT64_T,
(VasEBoot_efi_uint64_t) VAS_EBOOT_EFI_MAX_USABLE_ADDRESS);
VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
N_("invalid memory address (0x%s > 0x%s)"), inv_addr, max_addr);
return NULL;
}
b = VasEBoot_efi_system_table->boot_services;
status = b->allocate_pages (alloctype, memtype, pages, &address);
if (status != VAS_EBOOT_EFI_SUCCESS)
{
VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY, N_("out of memory"));
return NULL;
}
if (address == 0)
{
/* Uggh, the address 0 was allocated... This is too annoying,
so reallocate another one. */
address = VAS_EBOOT_EFI_MAX_USABLE_ADDRESS;
status = b->allocate_pages (alloctype, memtype, pages, &address);
b->free_pages (0, pages);
if (status != VAS_EBOOT_EFI_SUCCESS)
{
VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY, N_("out of memory"));
return NULL;
}
}
VasEBoot_efi_store_alloc (address, pages);
return (void *) ((VasEBoot_addr_t) address);
}
void *
VasEBoot_efi_allocate_any_pages (VasEBoot_efi_uintn_t pages)
{
return VasEBoot_efi_allocate_pages_real (VAS_EBOOT_EFI_MAX_USABLE_ADDRESS,
pages, VAS_EBOOT_EFI_ALLOCATE_MAX_ADDRESS,
VAS_EBOOT_EFI_LOADER_DATA);
}
void *
VasEBoot_efi_allocate_fixed (VasEBoot_efi_physical_address_t address,
VasEBoot_efi_uintn_t pages)
{
return VasEBoot_efi_allocate_pages_real (address, pages,
VAS_EBOOT_EFI_ALLOCATE_ADDRESS,
VAS_EBOOT_EFI_LOADER_DATA);
}
/* Free pages starting from ADDRESS. */
void
VasEBoot_efi_free_pages (VasEBoot_efi_physical_address_t address,
VasEBoot_efi_uintn_t pages)
{
VasEBoot_efi_boot_services_t *b;
b = VasEBoot_efi_system_table->boot_services;
b->free_pages (address, pages);
VasEBoot_efi_drop_alloc (address, pages);
}
#if defined (__i386__) || defined (__x86_64__)
/* Helper for stop_broadcom. */
static int
find_card (VasEBoot_pci_device_t dev, VasEBoot_pci_id_t pciid,
void *data __attribute__ ((unused)))
{
VasEBoot_pci_address_t addr;
VasEBoot_uint8_t cap;
VasEBoot_uint16_t pm_state;
if ((pciid & 0xffff) != VAS_EBOOT_PCI_VENDOR_BROADCOM)
return 0;
addr = VasEBoot_pci_make_address (dev, VAS_EBOOT_PCI_REG_CLASS);
if (VasEBoot_pci_read (addr) >> 24 != VAS_EBOOT_PCI_CLASS_NETWORK)
return 0;
cap = VasEBoot_pci_find_capability (dev, VAS_EBOOT_PCI_CAP_POWER_MANAGEMENT);
if (!cap)
return 0;
addr = VasEBoot_pci_make_address (dev, cap + 4);
pm_state = VasEBoot_pci_read_word (addr);
pm_state = pm_state | 0x03;
VasEBoot_pci_write_word (addr, pm_state);
VasEBoot_pci_read_word (addr);
return 0;
}
static void
stop_broadcom (void)
{
VasEBoot_pci_iterate (find_card, NULL);
}
#endif
VasEBoot_err_t
VasEBoot_efi_finish_boot_services (VasEBoot_efi_uintn_t *outbuf_size, void *outbuf,
VasEBoot_efi_uintn_t *map_key,
VasEBoot_efi_uintn_t *efi_desc_size,
VasEBoot_efi_uint32_t *efi_desc_version)
{
VasEBoot_efi_boot_services_t *b;
VasEBoot_efi_status_t status;
#if defined (__i386__) || defined (__x86_64__)
const VasEBoot_uint16_t apple[] = { 'A', 'p', 'p', 'l', 'e' };
int is_apple;
is_apple = (VasEBoot_memcmp (VasEBoot_efi_system_table->firmware_vendor,
apple, sizeof (apple)) == 0);
#endif
while (1)
{
if (VasEBoot_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
&finish_desc_size, &finish_desc_version) < 0)
return VasEBoot_error (VAS_EBOOT_ERR_IO, "couldn't retrieve memory map");
if (outbuf && *outbuf_size < finish_mmap_size)
return VasEBoot_error (VAS_EBOOT_ERR_IO, "memory map buffer is too small");
finish_mmap_buf = VasEBoot_malloc (finish_mmap_size);
if (!finish_mmap_buf)
return VasEBoot_errno;
if (VasEBoot_efi_get_memory_map (&finish_mmap_size, finish_mmap_buf, &finish_key,
&finish_desc_size, &finish_desc_version) <= 0)
{
VasEBoot_free (finish_mmap_buf);
finish_mmap_buf = NULL;
return VasEBoot_error (VAS_EBOOT_ERR_IO, "couldn't retrieve memory map");
}
b = VasEBoot_efi_system_table->boot_services;
status = b->exit_boot_services (VasEBoot_efi_image_handle, finish_key);
if (status == VAS_EBOOT_EFI_SUCCESS)
break;
if (status != VAS_EBOOT_EFI_INVALID_PARAMETER)
{
VasEBoot_free (finish_mmap_buf);
finish_mmap_buf = NULL;
return VasEBoot_error (VAS_EBOOT_ERR_IO, "couldn't terminate EFI services");
}
VasEBoot_free (finish_mmap_buf);
finish_mmap_buf = NULL;
VasEBoot_printf ("Trying to terminate EFI services again\n");
}
VasEBoot_efi_is_finished = 1;
if (outbuf_size)
*outbuf_size = finish_mmap_size;
if (outbuf)
VasEBoot_memcpy (outbuf, finish_mmap_buf, finish_mmap_size);
if (map_key)
*map_key = finish_key;
if (efi_desc_size)
*efi_desc_size = finish_desc_size;
if (efi_desc_version)
*efi_desc_version = finish_desc_version;
/*
* We cannot request new memory regions from the EFI Boot Services anymore.
* FIXME: Can we completely avoid memory allocations after this?
*/
VasEBoot_mm_add_region_fn = NULL;
#if defined (__i386__) || defined (__x86_64__)
if (is_apple)
stop_broadcom ();
#endif
return VAS_EBOOT_ERR_NONE;
}
/*
* To obtain the UEFI memory map, we must pass a buffer of sufficient size
* to hold the entire map. This function returns a sane start value for
* buffer size.
*/
VasEBoot_efi_uintn_t
VasEBoot_efi_find_mmap_size (void)
{
VasEBoot_efi_uintn_t mmap_size = 0;
VasEBoot_efi_uintn_t desc_size;
if (VasEBoot_efi_get_memory_map (&mmap_size, NULL, NULL, &desc_size, 0) < 0)
{
VasEBoot_error (VAS_EBOOT_ERR_IO, "cannot get EFI memory map size");
return 0;
}
/*
* Add an extra page, since UEFI can alter the memory map itself on
* callbacks or explicit calls, including console output.
*/
return ALIGN_UP (mmap_size + VAS_EBOOT_EFI_PAGE_SIZE, VAS_EBOOT_EFI_PAGE_SIZE);
}
/* Get the memory map as defined in the EFI spec. Return 1 if successful,
return 0 if partial, or return -1 if an error occurs. */
int
VasEBoot_efi_get_memory_map (VasEBoot_efi_uintn_t *memory_map_size,
VasEBoot_efi_memory_descriptor_t *memory_map,
VasEBoot_efi_uintn_t *map_key,
VasEBoot_efi_uintn_t *descriptor_size,
VasEBoot_efi_uint32_t *descriptor_version)
{
VasEBoot_efi_status_t status;
VasEBoot_efi_boot_services_t *b;
VasEBoot_efi_uintn_t key;
VasEBoot_efi_uint32_t version;
VasEBoot_efi_uintn_t size;
if (VasEBoot_efi_is_finished)
{
int ret = 1;
if (memory_map != NULL)
{
if (*memory_map_size < finish_mmap_size)
{
VasEBoot_memcpy (memory_map, finish_mmap_buf, *memory_map_size);
ret = 0;
}
else
VasEBoot_memcpy (memory_map, finish_mmap_buf, finish_mmap_size);
}
else
{
/*
* Incomplete, no buffer to copy into, same as
* VAS_EBOOT_EFI_BUFFER_TOO_SMALL below.
*/
ret = 0;
}
*memory_map_size = finish_mmap_size;
if (map_key)
*map_key = finish_key;
if (descriptor_size)
*descriptor_size = finish_desc_size;
if (descriptor_version)
*descriptor_version = finish_desc_version;
return ret;
}
/* Allow some parameters to be missing. */
if (! map_key)
map_key = &key;
if (! descriptor_version)
descriptor_version = &version;
if (! descriptor_size)
descriptor_size = &size;
b = VasEBoot_efi_system_table->boot_services;
status = b->get_memory_map (memory_map_size, memory_map, map_key,
descriptor_size, descriptor_version);
if (*descriptor_size == 0)
*descriptor_size = sizeof (VasEBoot_efi_memory_descriptor_t);
if (status == VAS_EBOOT_EFI_SUCCESS)
return 1;
else if (status == VAS_EBOOT_EFI_BUFFER_TOO_SMALL)
return 0;
else
return -1;
}
/* Sort the memory map in place. */
static void
sort_memory_map (VasEBoot_efi_memory_descriptor_t *memory_map,
VasEBoot_efi_uintn_t desc_size,
VasEBoot_efi_memory_descriptor_t *memory_map_end)
{
VasEBoot_efi_memory_descriptor_t *d1;
VasEBoot_efi_memory_descriptor_t *d2;
for (d1 = memory_map;
d1 < memory_map_end;
d1 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size))
{
VasEBoot_efi_memory_descriptor_t *max_desc = d1;
for (d2 = NEXT_MEMORY_DESCRIPTOR (d1, desc_size);
d2 < memory_map_end;
d2 = NEXT_MEMORY_DESCRIPTOR (d2, desc_size))
{
if (max_desc->num_pages < d2->num_pages)
max_desc = d2;
}
if (max_desc != d1)
{
VasEBoot_efi_memory_descriptor_t tmp;
tmp = *d1;
*d1 = *max_desc;
*max_desc = tmp;
}
}
}
/* Filter the descriptors. VAS_EBOOT needs only available memory. */
static VasEBoot_efi_memory_descriptor_t *
filter_memory_map (VasEBoot_efi_memory_descriptor_t *memory_map,
VasEBoot_efi_memory_descriptor_t *filtered_memory_map,
VasEBoot_efi_uintn_t desc_size,
VasEBoot_efi_memory_descriptor_t *memory_map_end)
{
VasEBoot_efi_memory_descriptor_t *desc;
VasEBoot_efi_memory_descriptor_t *filtered_desc;
for (desc = memory_map, filtered_desc = filtered_memory_map;
desc < memory_map_end;
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
{
if (desc->type == VAS_EBOOT_EFI_CONVENTIONAL_MEMORY
#if 1
&& desc->physical_start <= VAS_EBOOT_EFI_MAX_USABLE_ADDRESS
#endif
&& desc->physical_start + PAGES_TO_BYTES (desc->num_pages) > 0x100000
&& desc->num_pages != 0)
{
VasEBoot_memcpy (filtered_desc, desc, desc_size);
/* Avoid less than 1MB, because some loaders seem to be confused. */
if (desc->physical_start < 0x100000)
{
desc->num_pages -= BYTES_TO_PAGES (0x100000
- desc->physical_start);
desc->physical_start = 0x100000;
}
#if 1
if (BYTES_TO_PAGES (filtered_desc->physical_start)
+ filtered_desc->num_pages
> BYTES_TO_PAGES_DOWN (VAS_EBOOT_EFI_MAX_USABLE_ADDRESS))
filtered_desc->num_pages
= (BYTES_TO_PAGES_DOWN (VAS_EBOOT_EFI_MAX_USABLE_ADDRESS)
- BYTES_TO_PAGES (filtered_desc->physical_start));
#endif
if (filtered_desc->num_pages == 0)
continue;
filtered_desc = NEXT_MEMORY_DESCRIPTOR (filtered_desc, desc_size);
}
}
return filtered_desc;
}
/* Add memory regions. */
static VasEBoot_err_t
add_memory_regions (VasEBoot_efi_memory_descriptor_t *memory_map,
VasEBoot_efi_uintn_t desc_size,
VasEBoot_efi_memory_descriptor_t *memory_map_end,
VasEBoot_efi_uint64_t required_pages,
unsigned int flags)
{
VasEBoot_efi_memory_descriptor_t *desc;
for (desc = memory_map;
desc < memory_map_end;
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
{
VasEBoot_efi_uint64_t pages;
VasEBoot_efi_physical_address_t start;
void *addr;
start = desc->physical_start;
pages = desc->num_pages;
if (pages < required_pages && (flags & VAS_EBOOT_MM_ADD_REGION_CONSECUTIVE))
continue;
if (pages > required_pages)
{
start += PAGES_TO_BYTES (pages - required_pages);
pages = required_pages;
}
addr = VasEBoot_efi_allocate_pages_real (start, pages,
VAS_EBOOT_EFI_ALLOCATE_ADDRESS,
VAS_EBOOT_EFI_LOADER_CODE);
if (! addr)
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY,
"Memory starting at %p (%u pages) marked as free, but EFI would not allocate",
(void *) ((VasEBoot_addr_t) start), (unsigned) pages);
VasEBoot_mm_init_region (addr, PAGES_TO_BYTES (pages));
required_pages -= pages;
if (required_pages == 0)
break;
}
if (required_pages > 0)
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY,
"could not allocate all requested memory: %" PRIuVAS_EBOOT_UINT64_T " pages still required after iterating EFI memory map",
required_pages);
return VAS_EBOOT_ERR_NONE;
}
void
VasEBoot_efi_memory_fini (void)
{
/*
* Free all stale allocations. VasEBoot_efi_free_pages() will remove
* the found entry from the list and it will always find the first
* list entry (efi_allocated_memory is the list start). Hence we
* remove all entries from the list until none is left altogether.
*/
while (efi_allocated_memory)
VasEBoot_efi_free_pages (efi_allocated_memory->address,
efi_allocated_memory->pages);
}
#if 0
/* Print the memory map. */
static void
print_memory_map (VasEBoot_efi_memory_descriptor_t *memory_map,
VasEBoot_efi_uintn_t desc_size,
VasEBoot_efi_memory_descriptor_t *memory_map_end)
{
VasEBoot_efi_memory_descriptor_t *desc;
int i;
for (desc = memory_map, i = 0;
desc < memory_map_end;
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size), i++)
{
VasEBoot_printf ("MD: t=%x, p=%llx, v=%llx, n=%llx, a=%llx\n",
desc->type, desc->physical_start, desc->virtual_start,
desc->num_pages, desc->attribute);
}
}
#endif
static VasEBoot_err_t
VasEBoot_efi_mm_add_regions (VasEBoot_size_t required_bytes, unsigned int flags)
{
VasEBoot_efi_memory_descriptor_t *memory_map;
VasEBoot_efi_memory_descriptor_t *memory_map_end;
VasEBoot_efi_memory_descriptor_t *filtered_memory_map;
VasEBoot_efi_memory_descriptor_t *filtered_memory_map_end;
VasEBoot_efi_uintn_t alloc_size;
VasEBoot_efi_uintn_t map_size;
VasEBoot_efi_uintn_t desc_size;
VasEBoot_err_t err;
int mm_status;
/* Prepare a memory region to store two memory maps. */
alloc_size = 2 * BYTES_TO_PAGES (MEMORY_MAP_SIZE);
memory_map = VasEBoot_efi_allocate_any_pages (alloc_size);
if (! memory_map)
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY, "cannot allocate memory for memory map");
/* Obtain descriptors for available memory. */
map_size = MEMORY_MAP_SIZE;
mm_status = VasEBoot_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0);
if (mm_status == 0)
{
VasEBoot_efi_free_pages ((VasEBoot_efi_physical_address_t)(VasEBoot_addr_t) memory_map, alloc_size);
/* Freeing/allocating operations may increase memory map size. */
map_size += desc_size * 32;
alloc_size = 2 * BYTES_TO_PAGES (map_size);
memory_map = VasEBoot_efi_allocate_any_pages (alloc_size);
if (! memory_map)
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY, "cannot allocate memory for new memory map");
mm_status = VasEBoot_efi_get_memory_map (&map_size, memory_map, 0,
&desc_size, 0);
}
if (mm_status < 0)
return VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_MEMORY, "error fetching memory map from EFI");
memory_map_end = NEXT_MEMORY_DESCRIPTOR (memory_map, map_size);
filtered_memory_map = memory_map_end;
filtered_memory_map_end = filter_memory_map (memory_map, filtered_memory_map,
desc_size, memory_map_end);
/* Sort the filtered descriptors, so that VAS_EBOOT can allocate pages
from smaller regions. */
sort_memory_map (filtered_memory_map, desc_size, filtered_memory_map_end);
/* Allocate memory regions for VAS_EBOOT's memory management. */
err = add_memory_regions (filtered_memory_map, desc_size,
filtered_memory_map_end,
BYTES_TO_PAGES (required_bytes),
flags);
if (err != VAS_EBOOT_ERR_NONE)
return err;
#if 0
/* For debug. */
map_size = MEMORY_MAP_SIZE;
if (VasEBoot_efi_get_memory_map (&map_size, memory_map, 0, &desc_size, 0) < 0)
VasEBoot_fatal ("cannot get memory map");
VasEBoot_printf ("printing memory map\n");
print_memory_map (memory_map, desc_size,
NEXT_MEMORY_DESCRIPTOR (memory_map, map_size));
VasEBoot_fatal ("Debug. ");
#endif
/* Release the memory maps. */
VasEBoot_efi_free_pages ((VasEBoot_efi_physical_address_t)(VasEBoot_addr_t) memory_map, alloc_size);
return VAS_EBOOT_ERR_NONE;
}
void
VasEBoot_efi_mm_init (void)
{
if (VasEBoot_efi_mm_add_regions (DEFAULT_HEAP_SIZE, VAS_EBOOT_MM_ADD_REGION_NONE) != VAS_EBOOT_ERR_NONE)
VasEBoot_fatal ("%s", VasEBoot_errmsg);
VasEBoot_mm_add_region_fn = VasEBoot_efi_mm_add_regions;
}
#if defined (__aarch64__) || defined (__arm__) || defined (__riscv) || \
defined (__loongarch__)
VasEBoot_err_t
VasEBoot_efi_get_ram_base(VasEBoot_addr_t *base_addr)
{
VasEBoot_efi_memory_descriptor_t *memory_map, *desc;
VasEBoot_efi_uintn_t memory_map_size, desc_size;
int ret;
memory_map_size = VasEBoot_efi_find_mmap_size();
memory_map = VasEBoot_malloc (memory_map_size);
if (! memory_map)
return VAS_EBOOT_ERR_OUT_OF_MEMORY;
ret = VasEBoot_efi_get_memory_map (&memory_map_size, memory_map, NULL,
&desc_size, NULL);
if (ret < 1)
return VAS_EBOOT_ERR_BUG;
for (desc = memory_map, *base_addr = VAS_EBOOT_EFI_MAX_USABLE_ADDRESS;
(VasEBoot_addr_t) desc < ((VasEBoot_addr_t) memory_map + memory_map_size);
desc = NEXT_MEMORY_DESCRIPTOR (desc, desc_size))
if (desc->attribute & VAS_EBOOT_EFI_MEMORY_WB)
*base_addr = VasEBoot_min (*base_addr, desc->physical_start);
VasEBoot_free(memory_map);
return VAS_EBOOT_ERR_NONE;
}
#endif
static VasEBoot_uint64_t
VasEBoot_mem_attrs_to_uefi_mem_attrs (VasEBoot_mem_attr_t attrs)
{
VasEBoot_efi_uint64_t ret = VAS_EBOOT_EFI_MEMORY_RP | VAS_EBOOT_EFI_MEMORY_RO | VAS_EBOOT_EFI_MEMORY_XP;
if (attrs & VAS_EBOOT_MEM_ATTR_R)
ret &= ~VAS_EBOOT_EFI_MEMORY_RP;
if (attrs & VAS_EBOOT_MEM_ATTR_W)
ret &= ~VAS_EBOOT_EFI_MEMORY_RO;
if (attrs & VAS_EBOOT_MEM_ATTR_X)
ret &= ~VAS_EBOOT_EFI_MEMORY_XP;
return ret;
}
static VasEBoot_mem_attr_t
uefi_mem_attrs_to_VasEBoot_mem_attrs (VasEBoot_efi_uint64_t attrs)
{
VasEBoot_mem_attr_t ret = VAS_EBOOT_MEM_ATTR_R | VAS_EBOOT_MEM_ATTR_W | VAS_EBOOT_MEM_ATTR_X;
if (attrs & VAS_EBOOT_EFI_MEMORY_RP)
ret &= ~VAS_EBOOT_MEM_ATTR_R;
if (attrs & VAS_EBOOT_EFI_MEMORY_RO)
ret &= ~VAS_EBOOT_MEM_ATTR_W;
if (attrs & VAS_EBOOT_EFI_MEMORY_XP)
ret &= ~VAS_EBOOT_MEM_ATTR_X;
return ret;
}
VasEBoot_err_t
VasEBoot_get_mem_attrs (VasEBoot_addr_t addr, VasEBoot_size_t size, VasEBoot_mem_attr_t *attrs)
{
VasEBoot_efi_memory_attribute_protocol_t *proto;
VasEBoot_efi_physical_address_t physaddr = addr;
static VasEBoot_guid_t protocol_guid = VAS_EBOOT_EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID;
VasEBoot_efi_status_t efi_status;
VasEBoot_efi_uint64_t efi_attrs;
if (physaddr & (VAS_EBOOT_EFI_PAGE_SIZE - 1) || size & (VAS_EBOOT_EFI_PAGE_SIZE - 1) || size == 0 || attrs == NULL)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "%s() called with invalid arguments", __FUNCTION__);
proto = VasEBoot_efi_locate_protocol (&protocol_guid, 0);
if (proto == NULL)
{
/* No protocol -> do nothing, all memory is RWX in boot services */
*attrs = VAS_EBOOT_MEM_ATTR_R | VAS_EBOOT_MEM_ATTR_W | VAS_EBOOT_MEM_ATTR_X;
return VAS_EBOOT_ERR_NONE;
}
efi_status = proto->get_memory_attributes (proto, physaddr, size, &efi_attrs);
if (efi_status != VAS_EBOOT_EFI_SUCCESS)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "%s() called with invalid arguments", __FUNCTION__);
*attrs = uefi_mem_attrs_to_VasEBoot_mem_attrs (efi_attrs);
VasEBoot_dprintf ("nx", "get 0x%" PRIxVAS_EBOOT_ADDR "-0x%" PRIxVAS_EBOOT_ADDR ":%c%c%c\n",
addr, addr + size - 1,
(*attrs & VAS_EBOOT_MEM_ATTR_R) ? 'r' : '-',
(*attrs & VAS_EBOOT_MEM_ATTR_W) ? 'w' : '-',
(*attrs & VAS_EBOOT_MEM_ATTR_X) ? 'x' : '-');
return VAS_EBOOT_ERR_NONE;
}
VasEBoot_err_t
VasEBoot_update_mem_attrs (VasEBoot_addr_t addr, VasEBoot_size_t size,
VasEBoot_mem_attr_t set_attrs, VasEBoot_mem_attr_t clear_attrs)
{
VasEBoot_efi_memory_attribute_protocol_t *proto;
VasEBoot_efi_physical_address_t physaddr = addr;
static VasEBoot_guid_t protocol_guid = VAS_EBOOT_EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID;
VasEBoot_efi_status_t efi_status = VAS_EBOOT_EFI_SUCCESS;
VasEBoot_efi_uint64_t uefi_set_attrs, uefi_clear_attrs;
if (physaddr & (VAS_EBOOT_EFI_PAGE_SIZE - 1) || size & (VAS_EBOOT_EFI_PAGE_SIZE - 1) || size == 0)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "%s() called with invalid arguments", __FUNCTION__);
proto = VasEBoot_efi_locate_protocol (&protocol_guid, 0);
if (proto == NULL)
/* No protocol -> do nothing, all memory is RWX in boot services */
return VAS_EBOOT_ERR_NONE;
uefi_set_attrs = VasEBoot_mem_attrs_to_uefi_mem_attrs (set_attrs);
uefi_clear_attrs = VasEBoot_mem_attrs_to_uefi_mem_attrs (clear_attrs);
if (uefi_set_attrs)
efi_status = proto->set_memory_attributes (proto, physaddr, size, uefi_set_attrs);
if (efi_status == VAS_EBOOT_EFI_SUCCESS && uefi_clear_attrs)
efi_status = proto->clear_memory_attributes (proto, physaddr, size, uefi_clear_attrs);
if (efi_status != VAS_EBOOT_EFI_SUCCESS)
return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "%s() called with invalid arguments", __FUNCTION__);
VasEBoot_dprintf ("nx", "set +%s%s%s -%s%s%s on 0x%" PRIxVAS_EBOOT_ADDR "-0x%" PRIxVAS_EBOOT_ADDR "\n",
(set_attrs & VAS_EBOOT_MEM_ATTR_R) ? "r" : "",
(set_attrs & VAS_EBOOT_MEM_ATTR_W) ? "w" : "",
(set_attrs & VAS_EBOOT_MEM_ATTR_X) ? "x" : "",
(clear_attrs & VAS_EBOOT_MEM_ATTR_R) ? "r" : "",
(clear_attrs & VAS_EBOOT_MEM_ATTR_W) ? "w" : "",
(clear_attrs & VAS_EBOOT_MEM_ATTR_X) ? "x" : "",
addr, addr + size - 1);
return VAS_EBOOT_ERR_NONE;
}
Reference in New Issue View Git Blame Copy Permalink