mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 19:43:32 +00:00
7e0a09feec
This change ports APE Loader to Linux AARCH64, so that Raspberry Pi users can run programs like redbean, without the executable needing to modify itself. Progress has also slipped into this change on the issue of making progress better conforming to user expectations and industry standards regarding which symbols we're allowed to declare
264 lines
10 KiB
C
264 lines
10 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2021 Justine Alexandra Roberts Tunney │
|
|
│ │
|
|
│ Permission to use, copy, modify, and/or distribute this software for │
|
|
│ any purpose with or without fee is hereby granted, provided that the │
|
|
│ above copyright notice and this permission notice appear in all copies. │
|
|
│ │
|
|
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
|
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
|
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
|
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
|
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
|
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
|
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
|
│ PERFORMANCE OF THIS SOFTWARE. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "ape/relocations.h"
|
|
#include "ape/sections.internal.h"
|
|
#include "libc/dce.h"
|
|
#include "libc/intrin/bits.h"
|
|
#include "libc/intrin/newbie.h"
|
|
#include "libc/intrin/weaken.h"
|
|
#include "libc/macros.internal.h"
|
|
#include "libc/nt/efi.h"
|
|
#include "libc/nt/thunk/msabi.h"
|
|
#include "libc/runtime/e820.internal.h"
|
|
#include "libc/runtime/internal.h"
|
|
#include "libc/runtime/pc.internal.h"
|
|
#include "libc/runtime/runtime.h"
|
|
#include "libc/str/str.h"
|
|
|
|
#ifdef __x86_64__
|
|
|
|
/* TODO: Why can't we change CR3? Could it really need PML5T? */
|
|
/* TODO: Why does QEMU in UEFI mode take ten seconds to boot? */
|
|
|
|
struct EfiArgs {
|
|
char *Args[0x400 / sizeof(char *)];
|
|
char ArgBlock[0xC00];
|
|
};
|
|
|
|
static const EFI_GUID kEfiLoadedImageProtocol = LOADED_IMAGE_PROTOCOL;
|
|
static const EFI_GUID kEfiGraphicsOutputProtocol = GRAPHICS_OUTPUT_PROTOCOL;
|
|
|
|
extern const char vga_console[];
|
|
extern void _EfiPostboot(struct mman *, uint64_t *, uintptr_t, char **);
|
|
|
|
static void EfiInitVga(struct mman *mm, EFI_SYSTEM_TABLE *SystemTable) {
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphInfo;
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *GraphMode;
|
|
EFI_PIXEL_BITMASK *PixelInfo;
|
|
unsigned vid_typ = PC_VIDEO_TEXT;
|
|
size_t bytes_per_pix = 0;
|
|
|
|
SystemTable->BootServices->LocateProtocol(&kEfiGraphicsOutputProtocol, NULL,
|
|
&GraphInfo);
|
|
GraphMode = GraphInfo->Mode;
|
|
switch (GraphMode->Info->PixelFormat) {
|
|
case PixelRedGreenBlueReserved8BitPerColor:
|
|
vid_typ = PC_VIDEO_RGBX8888;
|
|
bytes_per_pix = 4;
|
|
break;
|
|
case PixelBlueGreenRedReserved8BitPerColor:
|
|
vid_typ = PC_VIDEO_BGRX8888;
|
|
bytes_per_pix = 4;
|
|
break;
|
|
case PixelBitMask:
|
|
PixelInfo = &GraphMode->Info->PixelInformation;
|
|
switch (le32toh(PixelInfo->RedMask)) {
|
|
case 0x00FF0000U:
|
|
if (le32toh(PixelInfo->ReservedMask) >= 0x01000000U &&
|
|
le32toh(PixelInfo->GreenMask) == 0x0000FF00U &&
|
|
le32toh(PixelInfo->BlueMask) == 0x000000FFU) {
|
|
vid_typ = PC_VIDEO_BGRX8888;
|
|
bytes_per_pix = 4;
|
|
}
|
|
break;
|
|
case 0x000000FFU:
|
|
if (le32toh(PixelInfo->ReservedMask) >= 0x01000000U &&
|
|
le32toh(PixelInfo->GreenMask) == 0x0000FF00U &&
|
|
le32toh(PixelInfo->BlueMask) == 0x00FF0000U) {
|
|
vid_typ = PC_VIDEO_RGBX8888;
|
|
bytes_per_pix = 4;
|
|
}
|
|
break;
|
|
case 0x0000F800U:
|
|
if (le32toh(PixelInfo->ReservedMask) <= 0x0000FFFFU &&
|
|
le32toh(PixelInfo->GreenMask) == 0x000007E0U &&
|
|
le32toh(PixelInfo->BlueMask) == 0x0000001FU) {
|
|
vid_typ = PC_VIDEO_BGR565;
|
|
bytes_per_pix = 2;
|
|
}
|
|
break;
|
|
case 0x00007C00U:
|
|
if (le32toh(PixelInfo->ReservedMask) <= 0x0000FFFFU &&
|
|
le32toh(PixelInfo->GreenMask) == 0x000003E0U &&
|
|
le32toh(PixelInfo->BlueMask) == 0x0000001FU) {
|
|
vid_typ = PC_VIDEO_BGR555;
|
|
bytes_per_pix = 2;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
notpossible;
|
|
}
|
|
if (!bytes_per_pix) notpossible;
|
|
mm->pc_video_type = vid_typ;
|
|
mm->pc_video_stride = GraphMode->Info->PixelsPerScanLine * bytes_per_pix;
|
|
mm->pc_video_width = GraphMode->Info->HorizontalResolution;
|
|
mm->pc_video_height = GraphMode->Info->VerticalResolution;
|
|
mm->pc_video_framebuffer = GraphMode->FrameBufferBase;
|
|
mm->pc_video_framebuffer_size = GraphMode->FrameBufferSize;
|
|
mm->pc_video_curs_info.y = mm->pc_video_curs_info.x = 0;
|
|
SystemTable->BootServices->SetMem((void *)GraphMode->FrameBufferBase,
|
|
GraphMode->FrameBufferSize, 0);
|
|
}
|
|
|
|
/**
|
|
* EFI Application Entrypoint.
|
|
*
|
|
* This entrypoint is mutually exclusive from WinMain since
|
|
* Windows apps and EFI apps use the same PE binary format.
|
|
* So if you want to trade away Windows so that you can use
|
|
* UEFI instead of the normal BIOS boot process, do this:
|
|
*
|
|
* __static_yoink("EfiMain");
|
|
* int main() { ... }
|
|
*
|
|
* You can use QEMU to test this, but please note that UEFI
|
|
* goes thousands of times slower than the normal BIOS boot
|
|
*
|
|
* qemu-system-x86_64 \
|
|
* -bios OVMF.fd \
|
|
* -nographic \
|
|
* -net none \
|
|
* -drive format=raw,file=fat:rw:o/tool/viz
|
|
* FS0:
|
|
* deathstar.com
|
|
*
|
|
* @see libc/dce.h
|
|
*/
|
|
__msabi dontasan EFI_STATUS EfiMain(EFI_HANDLE ImageHandle,
|
|
EFI_SYSTEM_TABLE *SystemTable) {
|
|
int type, x87cw = 0x037f;
|
|
struct mman *mm;
|
|
uint32_t DescVersion;
|
|
uintptr_t i, j, MapSize;
|
|
struct EfiArgs *ArgBlock;
|
|
EFI_LOADED_IMAGE *ImgInfo;
|
|
EFI_MEMORY_DESCRIPTOR *Map, *Desc;
|
|
uint64_t Address;
|
|
uintptr_t Args, MapKey, DescSize;
|
|
uint64_t p, pe, cr4, *m, *pd, *sp, *pml4t, *pdt1, *pdt2, *pdpt1, *pdpt2;
|
|
|
|
/*
|
|
* Allocates and clears PC-compatible memory and copies image. Marks the
|
|
* pages as EfiRuntimeServicesData, so that we can simply free up all
|
|
* EfiLoader... and EfiBootServices... pages later. The first page at
|
|
* address 0 is normally already allocated as EfiBootServicesData, so
|
|
* handle it separately.
|
|
*/
|
|
Address = 0;
|
|
SystemTable->BootServices->AllocatePages(
|
|
AllocateAddress, EfiRuntimeServicesData, 4096 / 4096, &Address);
|
|
Address = 4096;
|
|
SystemTable->BootServices->AllocatePages(
|
|
AllocateAddress, EfiRuntimeServicesData, (IMAGE_BASE_REAL - 4096) / 4096,
|
|
&Address);
|
|
Address = 0x79000;
|
|
SystemTable->BootServices->AllocatePages(
|
|
AllocateAddress, EfiRuntimeServicesData,
|
|
(0x7e000 - 0x79000 + sizeof(struct EfiArgs) + 4095) / 4096, &Address);
|
|
Address = IMAGE_BASE_PHYSICAL;
|
|
SystemTable->BootServices->AllocatePages(
|
|
AllocateAddress, EfiRuntimeServicesData,
|
|
((_end - __executable_start) + 4095) / 4096, &Address);
|
|
mm = __get_mm_phy();
|
|
SystemTable->BootServices->SetMem(mm, sizeof(*mm), 0);
|
|
SystemTable->BootServices->SetMem(
|
|
(void *)0x79000, 0x7e000 - 0x79000 + sizeof(struct EfiArgs), 0);
|
|
SystemTable->BootServices->CopyMem((void *)IMAGE_BASE_PHYSICAL,
|
|
__executable_start,
|
|
_end - __executable_start);
|
|
|
|
/*
|
|
* Converts UEFI shell arguments to argv.
|
|
*/
|
|
ArgBlock = (struct EfiArgs *)0x7e000;
|
|
SystemTable->BootServices->HandleProtocol(ImageHandle,
|
|
&kEfiLoadedImageProtocol, &ImgInfo);
|
|
Args = GetDosArgv(ImgInfo->LoadOptions, ArgBlock->ArgBlock,
|
|
sizeof(ArgBlock->ArgBlock), ArgBlock->Args,
|
|
ARRAYLEN(ArgBlock->Args));
|
|
|
|
/*
|
|
* Gets information about our current video mode. Clears the screen.
|
|
* TODO: if needed, switch to a video mode that has a linear frame buffer
|
|
* type we support.
|
|
*/
|
|
if (_weaken(vga_console)) EfiInitVga(mm, SystemTable);
|
|
|
|
/*
|
|
* Asks UEFI which parts of our RAM we're allowed to use.
|
|
*/
|
|
Map = NULL;
|
|
MapSize = 0;
|
|
SystemTable->BootServices->GetMemoryMap(&MapSize, Map, &MapKey, &DescSize,
|
|
&DescVersion);
|
|
SystemTable->BootServices->AllocatePool(EfiLoaderData, MapSize, &Map);
|
|
MapSize *= 2;
|
|
SystemTable->BootServices->GetMemoryMap(&MapSize, Map, &MapKey, &DescSize,
|
|
&DescVersion);
|
|
for (j = i = 0, Desc = Map; i < MapSize / DescSize; ++i) {
|
|
switch (Desc->Type) {
|
|
case EfiLoaderCode:
|
|
case EfiLoaderData:
|
|
case EfiBootServicesCode:
|
|
case EfiBootServicesData:
|
|
if (Desc->PhysicalStart != 0) break;
|
|
/* fallthrough */
|
|
case EfiConventionalMemory:
|
|
mm->e820[j].addr = Desc->PhysicalStart;
|
|
mm->e820[j].size = Desc->NumberOfPages * 4096;
|
|
mm->e820[j].type = kMemoryUsable;
|
|
++j;
|
|
}
|
|
Desc = (EFI_MEMORY_DESCRIPTOR *)((char *)Desc + DescSize);
|
|
}
|
|
SystemTable->BootServices->FreePool(Map);
|
|
|
|
/*
|
|
* Sets up page tables.
|
|
*/
|
|
pd = (uint64_t *)0x79000;
|
|
pdt1 = (uint64_t *)0x7b000;
|
|
pdt2 = (uint64_t *)0x7a000;
|
|
pdpt1 = (uint64_t *)0x7d000;
|
|
pdpt2 = (uint64_t *)0x7c000;
|
|
pml4t = (uint64_t *)0x7e000;
|
|
for (i = 0; i < 512; ++i) {
|
|
pd[i] = 0x1000 * i + PAGE_V + PAGE_RSRV + PAGE_RW;
|
|
}
|
|
pdt1[0] = (intptr_t)pd + PAGE_V + PAGE_RW;
|
|
pdt2[0] = (intptr_t)pd + PAGE_V + PAGE_RW;
|
|
pdpt1[0] = (intptr_t)pdt1 + PAGE_V + PAGE_RW;
|
|
pdpt2[0] = (intptr_t)pdt2 + PAGE_V + PAGE_RW;
|
|
pml4t[0] = (intptr_t)pdpt1 + PAGE_V + PAGE_RW;
|
|
pml4t[256] = (intptr_t)pdpt2 + PAGE_V + PAGE_RW;
|
|
|
|
/*
|
|
* Asks UEFI to handover control?
|
|
*/
|
|
SystemTable->BootServices->ExitBootServices(ImageHandle, MapKey);
|
|
|
|
/*
|
|
* Switches to copied image and launches program.
|
|
*/
|
|
_EfiPostboot(mm, pml4t, Args, ArgBlock->Args);
|
|
__builtin_unreachable();
|
|
}
|
|
|
|
#endif /* __x86_64__ */
|