Sync/include/kernel.h
Curle f524eee6ff More minor changes.
Header and graphics had some one-liners.
2019-07-24 01:37:39 +01:00

923 lines
27 KiB
C

/************************
*** Team Kitty, 2019 ***
*** Sync ***
***********************/
/* ==================== Kernel Header ==================== */
/* This file contains most of the shared code for the kernel and
* the classes it interacts with.
*
* Most of this file is constants and struct definitions. */
#pragma once
#define SYNC_MAJOR_VERSION 1
#define SYNC_MINOR_VERSION 0
/* ==================== Standard Headers ==================== */
#include <stddef.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdbool.h>
#include <float.h>
#include <efibind.h>
#include <efitypes.h>
#include <efierr.h>
/* ==================== Custom Headers ==================== */
#include <bitmapfont.h>
/* ==================== EFI structs and constants ==================== */
/* ========= Graphics ========== */
typedef struct {
uint32_t RedMask;
uint32_t GreenMask;
uint32_t BlueMask;
uint32_t ReservedMask;
} EFI_PIXEL_BITMASK;
typedef enum {
PixelRedGreenBlueReserved8BitPerColor,
PixelBlueRedGreenReserved8BitPerColor,
PixelBitMask,
PixelBitOnly,
PixelFormatMax
} EFI_GRAPHICS_PIXEL_FORMAT;
typedef struct {
uint32_t Version;
uint32_t HorizontalResolution;
uint32_t VerticalResolution;
EFI_GRAPHICS_PIXEL_FORMAT PixelFormat;
EFI_PIXEL_BITMASK PixelInformation;
uint32_t PixelsPerScanline;
} EFI_GRAPHICS_OUTPUT_MODE_INFORMATION;
typedef struct {
uint32_t MaxMode;
uint32_t Mode;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* Info;
size_t SizeOfInfo;
EFI_PHYSICAL_ADDRESS FrameBufferBase;
size_t FrameBufferSize;
} EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE;
/* ========== Time ========== */
typedef struct {
uint32_t Resolution;
uint32_t Accuracy;
BOOLEAN SetsToZero;
} EFI_TIME_CAPABILITIES;
typedef EFI_STATUS (EFIAPI* EFI_GET_TIME) (
OUT EFI_TIME* Time,
OUT EFI_TIME_CAPABILITIES* Capabilities OPTIONAL
);
typedef EFI_STATUS (EFIAPI* EFI_SET_TIME) (
IN EFI_TIME* Time
);
typedef EFI_STATUS (EFIAPI* EFI_GET_WAKEUP_TIME) (
OUT BOOLEAN* Enabled,
OUT BOOLEAN* Pending,
OUT EFI_TIME* Time
);
typedef EFI_STATUS (EFIAPI* EFI_SET_WAKEUP_TIME) (
IN BOOLEAN Enable,
IN EFI_TIME* Time OPTIONAL
);
/* ========== Variables ========== */
#define EFI_GLOBAL_VARIABLE \
{ 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} }
#define EFI_VARIABLE_NON_VOLATILE 0x00000001
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002
#define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004
#define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x00000008
#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x00000010
#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x00000020
#define EFI_VARIABLE_APPEND_WRITE 0x00000040
typedef EFI_STATUS (EFIAPI* EFI_GET_VARIABLE) (
IN CHAR16* VariableName,
IN EFI_GUID* VendorGuid,
OUT uint32_t* Attributes OPTIONAL,
IN OUT size_t* DataSize,
OUT void* Data
);
typedef EFI_STATUS (EFIAPI* EFI_GET_NEXT_VARIABLE_NAME) (
IN OUT size_t* VariableNameSize,
IN OUT CHAR16* VariableName,
IN OUT EFI_GUID* VendorGuid
);
typedef EFI_STATUS (EFIAPI* EFI_SET_VARIABLE) (
IN CHAR16* VariableName,
IN EFI_GUID* VendorGuid,
IN uint32_t Attributes,
IN size_t DataSize,
IN void* Data
);
/* ========== Memory ========== */
typedef EFI_STATUS (EFIAPI* EFI_SET_VIRTUAL_ADDRESS_MAP) (
IN size_t MemoryMapSize,
IN size_t DescriptorSize,
IN uint32_t DescriptorVersion,
IN EFI_MEMORY_DESCRIPTOR* VirtualMap
);
#define EFI_OPTIONAL_PTR 0x00000001
#define EFI_INTERNAL_FNC 0x00000002
#define EFI_INTERNAL_PTR 0x00000004
typedef EFI_STATUS (EFIAPI* EFI_CONVERT_POINTER) (
IN size_t DebugDeposition,
IN OUT void* *Address
);
/* ========== Reset ========== */
typedef enum {
EfiResetCold,
EfiResetWarm,
EfiResetShutdown
} EFI_RESET_TYPE;
typedef EFI_STATUS (EFIAPI* EFI_RESET_SYSTEM) (
IN EFI_RESET_TYPE ResetType,
IN EFI_STATUS ResetStatus,
IN size_t DataSize,
IN CHAR16* ResetData OPTIONAL
);
/* ========== Other ========== */
typedef EFI_STATUS(EFIAPI* EFI_GET_NEXT_HIGH_MONO_COUNT) (
OUT uint32_t* HighCount
);
/* ===== Capsule ===== */
typedef struct {
EFI_GUID CapsuleGuid;
uint32_t HeaderSize;
uint32_t Flags;
uint32_t CapsuleImageSize;
} EFI_CAPSULE_HEADER;
#define CAPSULE_FLAGS_PERSIST_ACROSS_RESET 0x00010000
#define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE 0x00020000
#define CAPSULE_FLAGS_INITIATE_RESET 0x00040000
typedef EFI_STATUS (EFIAPI* EFI_UPDATE_CAPSULE) (
IN EFI_CAPSULE_HEADER* *CapsuleHeaderArray,
IN size_t CapsuleCount,
IN EFI_PHYSICAL_ADDRESS ScatterGatherList OPTIONAL
);
typedef EFI_STATUS (EFIAPI* EFI_QUERY_CAPSULE_CAPABILITIES) (
IN EFI_CAPSULE_HEADER* *CapsuleHeaderArray,
IN size_t CapsuleCount,
OUT size_t* MaximumCapsuleSize,
OUT EFI_RESET_TYPE* ResetType
);
typedef EFI_STATUS (EFIAPI* EFI_QUERY_VARIABLE_INFO) (
IN uint32_t Attributes,
OUT size_t* MaximumVariableStorage,
OUT size_t* RemainingVariableStorageSize,
OUT size_t* MaximumVariableSize
);
/* ==================== EFI Runtime Services ==================== */
typedef struct {
EFI_TABLE_HEADER Header;
/* Time */
EFI_GET_TIME GetTime;
EFI_SET_TIME SetTime;
EFI_GET_WAKEUP_TIME GetWakeupTime;
EFI_SET_WAKEUP_TIME SetWakeupTime;
/* Virtual Memory */
EFI_SET_VIRTUAL_ADDRESS_MAP SetVirtualAddressMap;
EFI_CONVERT_POINTER ConvertPointer;
/* Variable Services */
EFI_GET_VARIABLE GetVariable;
EFI_GET_NEXT_VARIABLE_NAME GetNextVariableName;
EFI_SET_VARIABLE SetVariable;
/* Other */
EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonoCount;
EFI_RESET_SYSTEM ResetSystem;
/* Capsule Services */
EFI_UPDATE_CAPSULE UpdateCapsule;
EFI_QUERY_CAPSULE_CAPABILITIES QueryCapsuleCapabilities;
EFI_QUERY_VARIABLE_INFO QueryVariableInfo;
} EFI_RUNTIME_SERVICES;
/* ==================== EFI File Info ==================== */
typedef struct {
size_t Size;
size_t FileSize;
size_t PhysicalSize;
EFI_TIME CreateTime;
EFI_TIME LastAccessTime;
EFI_TIME ModificationTime;
size_t Attribute;
CHAR16 FileName[1];
} EFI_FILE_INFO;
/* ==================== EFI System Configuration Tables ==================== */
#define MPS_TABLE_GUID \
{ 0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
#define ACPI_10_TABLE_GUID \
{ 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
#define ACPI_20_TABLE_GUID \
{ 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
#define SMBIOS_TABLE_GUID \
{ 0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
#define SMBIOS3_TABLE_GUID \
{ 0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94} }
#define SAL_SYSTEM_TABLE_GUID \
{ 0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
static const EFI_GUID MpsTableGuid = MPS_TABLE_GUID;
static const EFI_GUID Acpi10TableGuid = ACPI_10_TABLE_GUID;
static const EFI_GUID Acpi20TableGuid = ACPI_20_TABLE_GUID;
static const EFI_GUID SmBiosTableGuid = SMBIOS_TABLE_GUID;
static const EFI_GUID SmBios3TableGuid = SMBIOS3_TABLE_GUID;
static const EFI_GUID SalSystemTableGuid = SAL_SYSTEM_TABLE_GUID;
typedef struct _EFI_CONFIGURATION_TABLE {
EFI_GUID VendorGuid;
void* VendorTable;
} EFI_CONFIGURATION_TABLE;
/* ============================================================= */
/* = Syncboot Structures = */
/* ============================================================= */
typedef struct {
EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE* GPUs;
size_t FBCount;
} GPU_INFO;
typedef struct {
uint32_t UEFI_Version;
uint32_t SYNCBOOT_Major;
uint32_t SYNCBOOT_Minor;
uint32_t MemoryMapDescriptorVersion;
size_t MemoryMapDescriptorSize;
EFI_MEMORY_DESCRIPTOR* MemoryMap;
size_t MemoryMap_Size;
EFI_PHYSICAL_ADDRESS KernelBase;
size_t KernelPages;
CHAR16* ESPRootPath;
size_t ESPRootPathSize;
CHAR16* KernelPath;
size_t KernelPathSize;
CHAR16* KernelOptions;
size_t KernelOptionsSize;
EFI_RUNTIME_SERVICES* RTServices;
GPU_INFO* GPU_Info;
EFI_FILE_INFO* KernelFileMetadata;
EFI_CONFIGURATION_TABLE* ConfigurationTables;
size_t NumConfigurationTables;
} FILELOADER_PARAMS;
/* ============================================================= */
/* = Sync Structures = */
/* ============================================================= */
typedef struct {
uint32_t MemoryMapDescriptorVersion;
size_t MemoryMapDescriptorSize;
size_t MemoryMapSize;
EFI_MEMORY_DESCRIPTOR* MemoryMap;
uint32_t Pad;
} MEMORY_INFO;
typedef struct {
EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE defaultGPU;
uint32_t charHeight;
uint32_t charWidth; // Bit width
uint32_t charFGColor; // ForeGround Color
uint32_t charHLColor; // HighLight Color
uint32_t charBGColor; // BackGround Color
uint32_t screenMinX; // Far left side of the screen
uint32_t screenMinY; // Top of the screen
uint32_t charScale;
uint32_t cursorPos;
uint32_t scrollMode; // Move screen up, or wraparound
} PRINT_INFO;
/* ==================== GDT ==================== */
typedef struct __attribute__((packed)) {
uint16_t LowLimit;
uint16_t LowBase;
uint8_t MiddleBase;
uint8_t Access;
uint8_t Granularity;
uint8_t HighBase;
} GDT_ENTRY;
typedef struct __attribute__((packed)) {
uint16_t Limit;
size_t BaseAddress;
} DESCRIPTOR_TABLE_POINTER;
GDT_ENTRY gdt[3]; //3-entry gdt
DESCRIPTOR_TABLE_POINTER gtdp;
/* ==================== IDT ==================== */
typedef struct __attribute__((packed)) {
uint16_t LowBase;
uint16_t Segment;
uint8_t IST;
uint8_t SegmentType;
uint16_t MiddleBase;
uint32_t HighBase;
uint32_t Reserved;
} IDT_GATE;
typedef struct __attribute__((packed)) {
uint16_t LowBase;
uint16_t Selector;
uint8_t IST;
uint8_t Flags;
uint16_t HighBase;
} IDT_ENTRY;
IDT_ENTRY idt[256];
DESCRIPTOR_TABLE_POINTER idtp; // IDT Pointer
/* ==================== TSS ==================== */
/* Intel Architecture Manual Vol. 3A, Fig. 7-4 (Format of TSS and LDT Descriptors in 64-bit Mode)
*
* Segment Limit is a 20-bit value - the lower 16 bits are stored at SegmentLimitLow and the higher 4 bits at SegmentLimitHigh;
* Base Address is a 64-bit value - The lower 24 bits are stored at Low and Middle1, the upper 46 bits at Middle2 and High.
* SegmentType stores the following:
*
* =========================
* | 0 - 3 | 4 | 5 6 | 7 |
* | SEGType | S | DPL | P |
* =========================
*
* SegmentLimitHigh stores the following:
*
* ==========================================
* | 0 - 3 | 4 | 5 | 6 | 7 |
* | SegmentLimit | Avail | L | D/B | Gran |
* ==========================================
*
*/
typedef struct __attribute__((packed)) {
uint16_t SegmentLimitLow;
uint16_t BaseLow;
uint8_t BaseMiddle1;
uint8_t SegmentType;
uint8_t SegmentLimitHigh;
uint8_t BaseMiddle2;
uint32_t BaseHigh;
uint32_t Reserved;
} TSS_ENTRY;
typedef struct __attribute__((packed)) {
uint32_t SegmentSelector;
uint16_t SegmentType;
uint16_t SegmentLow;
uint32_t SegmentHigh;
uint32_t Reserved;
} CALL_GATE_ENTRY;
/* Intel Architecture Manual Vol. 3A, Fig. 7-11 (64-Bit TSS Format)
*/
typedef struct __attribute__((packed)) {
uint32_t Reserved0;
size_t RSP0;
size_t RSP1;
size_t RSP2;
size_t Reserved12;
size_t IST1;
size_t IST2;
size_t IST3;
size_t IST4;
size_t IST5;
size_t IST6;
size_t IST7;
size_t Reserved34;
uint16_t Reserved5;
uint16_t IOMap;
} TSS_64;
/* ==================== ACPI ==================== */
/*
* ACPI Specification 6.2A, section 5.2.5 (Root System Description Pointer (RSDP))
*/
typedef struct __attribute__((packed)) {
char Signature[8]; // "RSD PTR "
uint8_t Checksum;
char OEMID[6];
uint8_t Revision;
uint32_t RSDT; // 32 bit
} RSDP_10;
typedef struct __attribute__((packed)) {
RSDP_10 RSDP_10_Section;
uint32_t Length;
size_t XSDT; // = 64 bit RSDT
uint8_t ChecksumExtended;
uint8_t Reserved[3];
} RSDP_20;
typedef struct __attribute__((packed)) {
char Signature[4];
uint32_t Length;
uint8_t Revision;
uint8_t Checksum;
char OEMID[6];
char OEMTableID[8];
uint32_t OEMRevision;
uint32_t CreatorID;
uint32_t CreatorRevision;
} SDTHeader; // System Descriptor Table
typedef struct __attribute__((packed)) {
SDTHeader SDTHeader;
size_t Entry[1];
} XSDT;
/* ==================== Global Variables ==================== */
MEMORY_INFO Memory_Info = {0};
PRINT_INFO Print_Info = {0};
uint8_t Image[96] = {0};
char BrandStr[48] = {0};
char ManufacturerStr[13] = {0};
/* ==================== Interrupts ==================== */
typedef struct __attribute__((packed)) {
size_t rip;
size_t cs;
size_t rflags;
size_t rsp;
size_t ss;
} INTERRUPT_FRAME;
typedef struct __attribute__((packed)) {
size_t ErrorCode;
size_t rip;
size_t cs;
size_t rflags;
size_t rsp;
size_t ss;
} EXCEPTION_FRAME;
typedef struct __attribute__((aligned(64), packed)) {
// Legacy FXSAVE header
UINT16 fcw;
UINT16 fsw;
UINT8 ftw;
UINT8 Reserved1;
UINT16 fop;
UINT64 fip;
UINT64 fdp;
UINT32 mxcsr;
UINT32 mxcsr_mask;
// Legacy x87/MMX registers
UINT64 st_mm_0[2];
UINT64 st_mm_1[2];
UINT64 st_mm_2[2];
UINT64 st_mm_3[2];
UINT64 st_mm_4[2];
UINT64 st_mm_5[2];
UINT64 st_mm_6[2];
UINT64 st_mm_7[2];
// SSE registers
UINT64 xmm0[2];
UINT64 xmm1[2];
UINT64 xmm2[2];
UINT64 xmm3[2];
UINT64 xmm4[2];
UINT64 xmm5[2];
UINT64 xmm6[2];
UINT64 xmm7[2];
UINT64 xmm8[2];
UINT64 xmm9[2];
UINT64 xmm10[2];
UINT64 xmm11[2];
UINT64 xmm12[2];
UINT64 xmm13[2];
UINT64 xmm14[2];
UINT64 xmm15[2];
UINT8 Reserved2[48];
UINT8 pad[48];
UINT64 xstate_bv;
UINT64 xcomp_bv;
UINT64 Reserved3[6];
UINT8 extended_region[1];
} XSAVE_AREA;
static void* irq_routines[16] = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
static const char* exception_messages[] = {
"Division by Zero",
"Debug",
"Non Maskable Interrupt",
"Breakpoint",
"Into Detected Overflow",
"Out of Bounds",
"Invalid Opcode",
"No Coprocessor",
"Double Fault",
"Coprocessor Segment Overrun",
"Bad TSS",
"Segment Not Present",
"Stack Fault",
"General Protection Fault",
"Page Fault",
"Unknown Interrupt",
"Coprocessor Fault",
"Alignment Check",
"Machine Check",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved"
};
/* ============================================================= */
/* = Sync Functions = */
/* ============================================================= */
/* System Initialization */
void PrepareSystem(FILELOADER_PARAMS* FLOP);
/* System Utilities */
size_t ClockTick(void);
void Halt(void);
void PrepareAVX(void);
void AVXStub(void);
void PrepareMaskableInterrupts(void);
void PreparePowerManagement(void);
/* Hypervisor / Scheduler */
uint8_t CheckForHypervisor(void);
uint8_t ReadPerformance(size_t* PerformanceDest);
size_t ReadCPUFrequency(size_t* PerformanceDest, uint8_t AvgOrDirect);
/* Read/Write Port (eg. Serial) */
uint32_t ReadPort(uint16_t Port, int Length);
uint32_t WritePort(uint16_t Port, uint32_t Data, int Length);
/* ==================== Registers ==================== */
size_t ReadModelSpecificRegister(size_t MSR);
size_t WriteModelSpecificRegister(size_t MSR, size_t Data);
uint32_t ReadVexMXCSR(void);
uint32_t WriteVexMXCSR(uint32_t Data);
uint32_t ReadMXCSR(void);
uint32_t WriteMXCSR(uint32_t Data);
size_t ReadControlRegister(int CRX);
size_t WriteControlRegister(int CRX, size_t Data);
size_t ReadExtendedControlRegister(size_t XCRX);
size_t WriteExtendedControlRegister(size_t XCRX, size_t Data);
// XCS = Extended Code Segment
size_t ReadXCS(void);
/* ==================== Descriptor Tables ==================== */
DESCRIPTOR_TABLE_POINTER FetchGDT(void);
void SetGDT(DESCRIPTOR_TABLE_POINTER GDTData);
DESCRIPTOR_TABLE_POINTER FetchIDT(void);
void SetIDT(DESCRIPTOR_TABLE_POINTER IDTData);
uint16_t FetchLDT(void);
void SetLDT(uint16_t LDTData);
uint16_t FetchTSR(void);
void SetTSR(uint16_t TSRData);
void InstallGDT(void);
void InstallIDT(void);
void InstallPaging(void);
/* ==================== Branding ==================== */
char* FetchBrandStr(uint32_t* Str);
char* FetchManufacturer(char* ID);
void ScanCPUFeatures(size_t RAX, size_t RCX);
/* ==================== Interrupts ==================== */
void IRQ_Common(INTERRUPT_FRAME* Frame);
void ISR_Common(INTERRUPT_FRAME* Frame);
void ISR_Error_Common(EXCEPTION_FRAME* Frame);
void ISR0Handler(INTERRUPT_FRAME* Frame); // Divide-By-Zero
void ISR1Handler(INTERRUPT_FRAME* Frame); // Debug
void ISR2Handler(INTERRUPT_FRAME* Frame); // Non-Maskable Interrupt
void ISR3Handler(INTERRUPT_FRAME* Frame); // Breakpoint
void ISR4Handler(INTERRUPT_FRAME* Frame); // Overflow
void ISR5Handler(INTERRUPT_FRAME* Frame); // Out-of-Bounds
void ISR6Handler(INTERRUPT_FRAME* Frame); // Invalid Opcode
void ISR7Handler(INTERRUPT_FRAME* Frame); // No Coprocessor
void ISR8Handler(EXCEPTION_FRAME* Frame); // Double Fault
void ISR9Handler(INTERRUPT_FRAME* Frame); // Coprocessor Overrun
void ISR10Handler(EXCEPTION_FRAME* Frame); // Invalid TSS
void ISR11Handler(EXCEPTION_FRAME* Frame); // Segment Not Present
void ISR12Handler(EXCEPTION_FRAME* Frame); // Stack Segment Fault
void ISR13Handler(EXCEPTION_FRAME* Frame); // General Protection Fault
void ISR14Handler(EXCEPTION_FRAME* Frame); // Page Fault
void ISR15Handler(INTERRUPT_FRAME* Frame); // Unknown Interrupt
void ISR16Handler(INTERRUPT_FRAME* Frame); // Math Error / Coprocessor Fault
void ISR17Handler(EXCEPTION_FRAME* Frame); // Alignment Error
void ISR18Handler(INTERRUPT_FRAME* Frame); // Machine Check
void ISR19Handler(INTERRUPT_FRAME* Frame); // SSE Math Error
void ISR20Handler(INTERRUPT_FRAME* Frame); // Virtualization Exception
void ISR30Handler(EXCEPTION_FRAME* Frame); // Security Fault
void ReservedISRHandler(INTERRUPT_FRAME* Frame);
/* ==================== Interrupt Support ==================== */
void DumpRegisters_ISR(INTERRUPT_FRAME* Frame);
void DumpRegisters_Error(EXCEPTION_FRAME* Frame);
void DumpRegisters_AVX(XSAVE_AREA* Area);
void DumpControlRegisters(void);
void DumpFileloaderParams(FILELOADER_PARAMS* FLOP);
void DumpSegmentRegisters(void);
void irq_install_handler(int irq, void (*handler)(INTERRUPT_FRAME* r));
void irq_uninstall_handler(int);
void irq_install();
void irq_remap();
void timer_install();
/* ==================== Memory ==================== */
uint8_t VerifyZero(size_t Length, size_t Start);
size_t FetchMemoryLimit(void);
size_t FetchVisibleMemory(void);
size_t FetchAvailableMemory(void);
size_t FetchAvailablePMemory(void);
size_t FetchInstalledMemory(void);
void PrintMemoryMap();
EFI_MEMORY_DESCRIPTOR* SetIdentityMap(EFI_RUNTIME_SERVICES* RT);
void InstallMemoryMap(void);
void ReclaimEfiBootServicesMemory(void);
void ReclaimEfiLoaderCodeMemory(void);
void MergeFragmentedMemory(void);
EFI_PHYSICAL_ADDRESS PurgeAllMemory(void);
EFI_PHYSICAL_ADDRESS AllocatePagetable(size_t PagetableSize);
/* AVX */
void* memmoveAVX(void* Dest, void* Source, size_t Length);
void* memcpyAVX(void* Dest, void* Source, size_t Length);
void* memsetAVX(void* Dest, void* Source, size_t Length);
void* memsetAVX_By4Bytes(void* Dest, void* Source, size_t Length);
uint8_t memcmpAVX(const void* String1, const void* String2, size_t Length);
/* Physical Addresses */
__attribute__((malloc)) void* kalloc(size_t Length);
__attribute__((malloc)) void* kalloc_16(size_t Length);
__attribute__((malloc)) void* kalloc_32(size_t Length);
__attribute__((malloc)) void* kalloc_64(size_t Length);
__attribute__((malloc)) void* kalloc_pages(size_t Pages);
EFI_PHYSICAL_ADDRESS FindFreeAddress(size_t Pages, EFI_PHYSICAL_ADDRESS Start);
EFI_PHYSICAL_ADDRESS FindFreeAddress_ByPage(size_t Pages, EFI_PHYSICAL_ADDRESS Start);
/* The _ByXBytes functions here try to align the allocated space to the specified size. */
EFI_PHYSICAL_ADDRESS AllocateFreeAddress_ByPage(size_t Pages, EFI_PHYSICAL_ADDRESS Start);
EFI_PHYSICAL_ADDRESS AllocateFreeAddress_By16Bytes(size_t Bytes, EFI_PHYSICAL_ADDRESS Start);
EFI_PHYSICAL_ADDRESS AllocateFreeAddress_By32Bytes(size_t Bytes, EFI_PHYSICAL_ADDRESS Start);
EFI_PHYSICAL_ADDRESS AllocateFreeAddress_By64Bytes(size_t Bytes, EFI_PHYSICAL_ADDRESS Start);
/* Virtual Addresses */
__attribute__((malloc)) void* valloc(size_t Length);
__attribute__((malloc)) void* valloc_16(size_t Length);
__attribute__((malloc)) void* valloc_32(size_t Length);
__attribute__((malloc)) void* valloc_64(size_t Length);
__attribute__((malloc)) void* valloc_pages(size_t Pages);
EFI_VIRTUAL_ADDRESS FindVirtualAddress(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
EFI_VIRTUAL_ADDRESS FindVirtualAddress_ByPage(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
EFI_VIRTUAL_ADDRESS AllocateVirtualAddress_ByPage(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
EFI_VIRTUAL_ADDRESS AllocateVirtualAddress_By16Bytes(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
EFI_VIRTUAL_ADDRESS AllocateVirtualAddress_By32Bytes(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
EFI_VIRTUAL_ADDRESS AllocateVirtualAddress_By64Bytes(size_t Pages, EFI_VIRTUAL_ADDRESS Start);
/* ==================== Graphics ==================== */
void ClearScreen(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU);
void FillScreen(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU, uint32_t Color);
void ResetFillScreen(void);
void ResetScreen(void);
void DrawPixel(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
uint32_t x,
uint32_t y,
uint32_t Color);
void BitmapSetup(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
const uint8_t* Bitmap,
uint32_t Height,
uint32_t BitWidth,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale);
void BitmapRender(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
const uint8_t* BitMap,
uint32_t Height,
uint32_t BitWidth,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale,
uint32_t Character);
void BitmapBitswap(const uint8_t* BitMap,
uint32_t Height,
uint32_t BitWidth,
uint8_t* Out);
void BitmapReverse(const uint8_t* BitMap,
uint32_t Height,
uint32_t BitWidth,
uint8_t* Out);
void BitmapMirror(const uint8_t* BitMap,
uint32_t Height,
uint32_t BitWidth,
uint8_t* Out);
/* ========== Text ========== */
void SetupPrinting(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU);
void WriteChar(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
int Char,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor);
void WriteCharPos(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
int Char,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y);
void WriteScaledChar(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
int Char,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale);
void WriteScaledString(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
const char* string,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale);
void WriteScaledFormatString(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale,
const char* String,
...);
void RenderText(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE GPU,
int Char,
uint32_t Height,
uint32_t Width,
uint32_t FontColor,
uint32_t HighlightColor,
uint32_t x,
uint32_t y,
uint32_t Scale,
uint32_t Index);
/* ==================== Printf ==================== */
int snprintf(char* String, size_t Length, const char* Format, ...);
int vsnprintf(char* String, size_t Length, const char* Format, va_list AP);
int vsnrprintf(char* String, size_t Length, int Radix, const char* Format, va_list AP);
int sprintf(char* Buffer, const char* Format, ...);
int vsprintf(char* Buffer, const char* Format, va_list AP);
int printf(const char* Format, ...);
int vprintf(const char* Format, va_list AP);
int kvprintf(const char* Format, void (*func)(int, void*), void* Args, int Radix, va_list AP);
void PrintUTF16AsUTF8(CHAR16* String, size_t Length);
char* UTF16ToUTF8(CHAR16* String, size_t Length);
void gdb_end();