justin/jsix
1
1
Fork 0
mirror of https://github.com/justinian/jsix.git synced 2025-12-10 00:14:32 -08:00
Code Issues Packages Projects Releases Wiki Activity

Make memory functions operate on structure type

Browse Source
This commit is contained in:
Justin C. Miller
2018-03-27 14:47:21 -07:00
parent 2b9a0ca15e
commit fd32af4905
3 changed files with 36 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/boot/main.c
View File

@@ -20,7 +20,7 @@
#pragma pack(push, 1) #pragma pack(push, 1)
struct kernel_version { struct kernel_header {
uint32_t magic; uint32_t magic;
uint16_t version; uint16_t version;
uint16_t length; uint16_t length;
@@ -54,14 +54,6 @@ efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{ {
EFI_STATUS status; EFI_STATUS status;
UINTN memmap_size = 0;
UINTN memmap_key = 0;
UINTN desc_size = 0;
UINTN newmap_size = 0;
UINTN data_length = 0;
UINT32 desc_version = 0;
InitializeLib(ImageHandle, SystemTable); InitializeLib(ImageHandle, SystemTable);
@@ -74,11 +66,14 @@ efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
// because the console is now set up // because the console is now set up
con_status_begin(L"Computing needed data pages..."); con_status_begin(L"Computing needed data pages...");
status = memory_get_map_size(&data_length); UINTN data_length = 0;
status = memory_get_map_length(&data_length);
size_t header_size = sizeof(struct popcorn_data); size_t header_size = sizeof(struct popcorn_data);
const size_t header_align = alignof(struct popcorn_data); const size_t header_align = alignof(struct popcorn_data);
if (header_size % header_align) if (header_size % header_align)
header_size += header_align - (header_size % header_align); header_size += header_align - (header_size % header_align);
data_length += header_size; data_length += header_size;
con_status_ok(); con_status_ok();
@@ -90,7 +85,7 @@ efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
Print(L"\n %u bytes at 0x%x", kernel_length, kernel_image); Print(L"\n %u bytes at 0x%x", kernel_length, kernel_image);
Print(L"\n %u data bytes at 0x%x", data_length, kernel_data); Print(L"\n %u data bytes at 0x%x", data_length, kernel_data);
struct kernel_version *version = (struct kernel_version *)kernel_image; struct kernel_header *version = (struct kernel_header *)kernel_image;
if (version->magic != KERNEL_HEADER_MAGIC) { if (version->magic != KERNEL_HEADER_MAGIC) {
Print(L"\n bad magic %x", version->magic); Print(L"\n bad magic %x", version->magic);
CHECK_EFI_STATUS_OR_FAIL(EFI_CRC_ERROR); CHECK_EFI_STATUS_OR_FAIL(EFI_CRC_ERROR);
@@ -114,42 +109,16 @@ efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
data_header->memory_map = (EFI_MEMORY_DESCRIPTOR *)(data_header + 1); data_header->memory_map = (EFI_MEMORY_DESCRIPTOR *)(data_header + 1);
data_header->runtime = SystemTable->RuntimeServices; data_header->runtime = SystemTable->RuntimeServices;
// Get info about this image
con_status_begin(L"Gathering image information...");
EFI_LOADED_IMAGE *info = 0;
EFI_GUID image_proto = EFI_LOADED_IMAGE_PROTOCOL_GUID;
status = ST->BootServices->HandleProtocol(ImageHandle, &image_proto, (void **)&info);
CHECK_EFI_STATUS_OR_FAIL(status);
con_status_ok();
EFI_MEMORY_DESCRIPTOR *memory_map;
/*
memory_get_map(&memory_map, &memmap_size, &memmap_key, &desc_size, &desc_version);
memory_dump_map(memory_map, memmap_size, desc_size);
*/
con_status_begin(L"Exiting boot services..."); con_status_begin(L"Exiting boot services...");
status = memory_mark_address_for_update((void **)&ST); struct memory_map map;
map.entries = data_header->memory_map;
map.length = (data_length - header_size);
status = memory_get_map(&map);
CHECK_EFI_STATUS_OR_FAIL(status); CHECK_EFI_STATUS_OR_FAIL(status);
status = memory_mark_address_for_update((void **)&kernel_image); status = ST->BootServices->ExitBootServices(ImageHandle, map.key);
CHECK_EFI_STATUS_OR_FAIL(status);
status = memory_mark_address_for_update((void **)&kernel_main);
CHECK_EFI_STATUS_OR_FAIL(status);
status = memory_mark_address_for_update((void **)&kernel_data);
CHECK_EFI_STATUS_OR_FAIL(status);
status = memory_get_map(&memory_map, &memmap_size, &memmap_key, &desc_size, &desc_version);
CHECK_EFI_STATUS_OR_FAIL(status);
status = memory_copy_map(memory_map, data_header->memory_map, memmap_size, desc_size, info->ImageBase, &newmap_size);
CHECK_EFI_STATUS_OR_FAIL(status);
status = ST->BootServices->ExitBootServices(ImageHandle, memmap_key);
CHECK_EFI_STATUS_OR_ASSERT(status, 0); CHECK_EFI_STATUS_OR_ASSERT(status, 0);
kernel_main(); kernel_main();

98
src/boot/memory.c
View File

@@ -39,28 +39,6 @@ memory_type_name(UINT32 value)
return memory_type_names[value]; return memory_type_names[value];
} }
void EFIAPI
memory_update_addresses(EFI_EVENT UNUSED *event, void *context)
{
EFI_STATUS status;
status = ST->RuntimeServices->ConvertPointer(0, (void **)context);
CHECK_EFI_STATUS_OR_ASSERT(status, *((void **)context));
}
EFI_STATUS
memory_mark_address_for_update(void **pointer)
{
EFI_EVENT event;
EFI_STATUS status;
status = ST->BootServices->CreateEvent(EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE, TPL_CALLBACK,
(EFI_EVENT_NOTIFY)&memory_update_addresses,
(void *)pointer, &event);
CHECK_EFI_STATUS_OR_ASSERT(status, pointer);
}
void void
copy_desc(EFI_MEMORY_DESCRIPTOR *src, EFI_MEMORY_DESCRIPTOR *dst, size_t len) copy_desc(EFI_MEMORY_DESCRIPTOR *src, EFI_MEMORY_DESCRIPTOR *dst, size_t len)
{ {
@@ -72,38 +50,7 @@ copy_desc(EFI_MEMORY_DESCRIPTOR *src, EFI_MEMORY_DESCRIPTOR *dst, size_t len)
} }
EFI_STATUS EFI_STATUS
memory_copy_map(EFI_MEMORY_DESCRIPTOR *oldmap, EFI_MEMORY_DESCRIPTOR *newmap, size_t oldmap_size, memory_get_map_length(size_t *size)
size_t desc_size, void *this_image, size_t *newmap_size)
{
size_t count = 0;
EFI_MEMORY_DESCRIPTOR *s;
EFI_MEMORY_DESCRIPTOR *end = INCREMENT_DESC(oldmap, oldmap_size);
for (s = oldmap; s < end; s = INCREMENT_DESC(s, desc_size)) {
if (this_image != (void *)s->PhysicalStart &&
s->Type == EfiLoaderCode ||
s->Type == EfiLoaderData ||
s->Type == EfiBootServicesCode ||
s->Type == EfiBootServicesData ||
s->Type == EfiConventionalMemory) {
// These are memory types we don't need to keep
continue;
}
s->Attribute |= EFI_MEMORY_RUNTIME;
s->VirtualStart = (EFI_VIRTUAL_ADDRESS)(s->PhysicalStart + VIRTUAL_OFFSET);
EFI_MEMORY_DESCRIPTOR *d = INCREMENT_DESC(newmap, count*desc_size);
copy_desc(s, d, desc_size);
++count;
}
*newmap_size = desc_size * count;
return EFI_SUCCESS;
}
EFI_STATUS
memory_get_map_size(size_t *size)
{ {
if (size == NULL) if (size == NULL)
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
@@ -120,43 +67,40 @@ memory_get_map_size(size_t *size)
} }
EFI_STATUS EFI_STATUS
memory_get_map(EFI_MEMORY_DESCRIPTOR **buffer, size_t *buffer_size, size_t *key, size_t *desc_size, memory_get_map(struct memory_map *map)
UINT32 *desc_version)
{ {
EFI_STATUS status; EFI_STATUS status;
if (map == NULL)
return EFI_INVALID_PARAMETER;
size_t needs_size = 0; size_t needs_size = 0;
status = ST->BootServices->GetMemoryMap(&needs_size, 0, key, desc_size, desc_version); status = memory_get_map_length(&needs_size);
if (status != EFI_BUFFER_TOO_SMALL) { if (EFI_ERROR(status)) return status;
CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
}
// Give some extra buffer to account for changes. if (map->length < needs_size)
*buffer_size = needs_size + 256; return EFI_BUFFER_TOO_SMALL;
status = ST->BootServices->AllocatePool(EfiLoaderData, *buffer_size, (void **)buffer);
CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate space for memory map");
status = ST->BootServices->GetMemoryMap(buffer_size, *buffer, key, desc_size, desc_version); status = ST->BootServices->GetMemoryMap(&map->length, map->entries, &map->key, &map->size, &map->version);
CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map"); CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
memory_dump_map(EFI_MEMORY_DESCRIPTOR *memory_map, size_t memmap_size, size_t desc_size) memory_dump_map(struct memory_map *map)
{ {
const size_t count = memmap_size / desc_size; if (map == NULL)
return EFI_INVALID_PARAMETER;
const size_t count = map->length / map->size;
Print(L"Memory map:\n"); Print(L"Memory map:\n");
Print(L"\t Descriptor Count: %d (%d bytes)\n", count, memmap_size); Print(L"\t Descriptor Count: %d (%d bytes)\n", count, map->length);
Print(L"\t Descriptor Size: %d bytes\n", desc_size); Print(L"\t Descriptor Size: %d bytes\n", map->size);
Print(L"\t Type offset: %d\n", offsetof(EFI_MEMORY_DESCRIPTOR, Type)); Print(L"\t Type offset: %d\n\n", offsetof(EFI_MEMORY_DESCRIPTOR, Type));
Print(L"\t Physical offset: %d\n", offsetof(EFI_MEMORY_DESCRIPTOR, PhysicalStart));
Print(L"\t Virtual offset: %d\n", offsetof(EFI_MEMORY_DESCRIPTOR, VirtualStart));
Print(L"\t Pages offset: %d\n", offsetof(EFI_MEMORY_DESCRIPTOR, NumberOfPages));
Print(L"\t Attr offset: %d\n\n", offsetof(EFI_MEMORY_DESCRIPTOR, Attribute));
EFI_MEMORY_DESCRIPTOR *end = INCREMENT_DESC(memory_map, memmap_size); EFI_MEMORY_DESCRIPTOR *end = INCREMENT_DESC(map->entries, map->length);
EFI_MEMORY_DESCRIPTOR *d = memory_map; EFI_MEMORY_DESCRIPTOR *d = map->entries;
while (d < end) { while (d < end) {
int runtime = (d->Attribute & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME; int runtime = (d->Attribute & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME;
Print(L"%23s%s ", memory_type_name(d->Type), runtime ? L"*" : L" "); Print(L"%23s%s ", memory_type_name(d->Type), runtime ? L"*" : L" ");
@@ -164,7 +108,7 @@ memory_dump_map(EFI_MEMORY_DESCRIPTOR *memory_map, size_t memmap_size, size_t de
Print(L"%016llx ", d->VirtualStart); Print(L"%016llx ", d->VirtualStart);
Print(L"[%4d]\n", d->NumberOfPages); Print(L"[%4d]\n", d->NumberOfPages);
d = INCREMENT_DESC(d, desc_size); d = INCREMENT_DESC(d, map->size);
} }
return EFI_SUCCESS; return EFI_SUCCESS;

18
src/boot/memory.h
View File

@@ -9,18 +9,6 @@ struct memory_map {
EFI_MEMORY_DESCRIPTOR *entries; EFI_MEMORY_DESCRIPTOR *entries;
}; };
EFI_STATUS memory_mark_address_for_update(void **pointer); EFI_STATUS memory_get_map_length(size_t *size);
EFI_STATUS memory_get_map(struct memory_map *map);
EFI_STATUS memory_virtualize(EFI_MEMORY_DESCRIPTOR *memory_map, size_t memmap_size, size_t desc_size, EFI_STATUS memory_dump_map(struct memory_map *map);
UINT32 desc_version);
EFI_STATUS memory_get_map_size(size_t *sizsize);
EFI_STATUS memory_get_map(EFI_MEMORY_DESCRIPTOR **buffer, size_t *buffer_size, size_t *key,
size_t *desc_size, UINT32 *desc_version);
EFI_STATUS memory_copy_map(EFI_MEMORY_DESCRIPTOR *oldmap, EFI_MEMORY_DESCRIPTOR *newmap,
size_t oldmap_size, size_t desc_size, void *this_image,
size_t *newmap_size);
EFI_STATUS memory_dump_map();