XFESystem

// Hardware instruction bridge and Limine ABI storage only. Kernel policy is C#.
// Limine request constants/layout reuse XFESystem's own Rust boot.rs at 1139821;
// the public Limine protocol is under 0BSD. No Cosmos source is included.
#include <stdint.h>
#include <stddef.h>

struct request { uint64_t id[4], revision; volatile void *response; };
struct stack_request { struct request request; uint64_t bytes; };
struct memmap_response { uint64_t revision, count; void **entries; };
struct address_response { uint64_t revision, address; };
struct framebuffer_response { uint64_t revision, count; void **framebuffers; };
struct boot_info {
    uint64_t supported, hhdm;
    void **entries;
    uint64_t count;
    void *framebuffer;
    uint64_t rsdp;
    uint64_t efi_system_table;
    uint64_t boot_disk_id[2], boot_partition_id[2];
};
struct executable_file {
    uint64_t revision; void *address; uint64_t size; char *path, *string;
    uint32_t media_type, unused; uint8_t tftp_ipv4[4];
    uint32_t tftp_port, partition_index, mbr_disk_id;
    uint64_t disk_id[2], partition_id[2], volume_id[2];
};
extern const void *xfe_boot_file_metadata(void);
#define REQUEST(a,b) {{0xc7b1dd30df4c8b88ULL,0x0a82e883a194f07bULL,a,b},0,0}
#define SECTION(name) __attribute__((used,section(name)))
SECTION(".limine_requests_start") static volatile uint64_t request_start[4] = {
    0xf6b8f4b39de7d1aeULL,0xfab91a6940fcb9cfULL,0x785c6ed015d3e316ULL,0x181e920a7852b9d9ULL
};
SECTION(".limine_requests") static volatile uint64_t base_revision[3] = {
    0xf9562b2d5c95a6c8ULL,0x6a7b384944536bdcULL,6
};
SECTION(".limine_requests") static volatile struct request memory_request = REQUEST(0x67cf3d9d378a806fULL,0xe304acdfc50c3c62ULL);
SECTION(".limine_requests") static volatile struct request hhdm_request = REQUEST(0x48dcf1cb8ad2b852ULL,0x63984e959a98244bULL);
SECTION(".limine_requests") static volatile struct request framebuffer_request = REQUEST(0x9d5827dcd881dd75ULL,0xa3148604f6fab11bULL);
SECTION(".limine_requests") static volatile struct request rsdp_request = REQUEST(0xc5e77b6b397e7b43ULL,0x27637845accdcf3cULL);
SECTION(".limine_requests") static volatile struct request efi_request = REQUEST(0x5ceba5163eaaf6d6ULL,0x0a6981610cf65fccULL);
SECTION(".limine_requests") static volatile struct stack_request stack_request = {
    REQUEST(0x224ef0460a8e8926ULL,0xe1cb0fc25f46ea3dULL),1024*1024
};
SECTION(".limine_requests_end") static volatile uint64_t request_end[2] = {0xadc0e0531bb10d03ULL,0x9572709f31764c62ULL};

static struct boot_info info;
static uint64_t gdt[5] __attribute__((aligned(16)));
static uint8_t idt[4096] __attribute__((aligned(16)));
static uint8_t tss[104] __attribute__((aligned(16)));
static uint8_t double_fault_stack[16384] __attribute__((aligned(16)));
static uint8_t exception_stack[65536] __attribute__((aligned(16)));
static uint8_t free_pages[262144] __attribute__((aligned(4096)));
static uint8_t owned_pages[262144] __attribute__((aligned(4096)));
static uint8_t allocation_starts[262144] __attribute__((aligned(4096)));
static uint8_t allocation_ends[262144] __attribute__((aligned(4096)));
static uint64_t virtual_regions[256 * 3] __attribute__((aligned(16)));
static uint8_t thread_records[32 * 128] __attribute__((aligned(16)));
static uint8_t thread_contexts[32 * 1024] __attribute__((aligned(16)));
static uint64_t event_records[128 * 4] __attribute__((aligned(16)));
static uint8_t input_reports[256 * 32] __attribute__((aligned(16)));
uint64_t xfe_initial_stack_top;
static uint64_t breakpoint_stack;
static uint64_t timer_ticks;

struct boot_info *xfe_boot_info(void) {
    info.supported = base_revision[2] == 0;
    struct memmap_response *map = (struct memmap_response *)memory_request.response;
    struct address_response *hhdm = (struct address_response *)hhdm_request.response;
    struct framebuffer_response *fb = (struct framebuffer_response *)framebuffer_request.response;
    struct address_response *rsdp = (struct address_response *)rsdp_request.response;
    if (map) { info.entries = map->entries; info.count = map->count; }
    if (hhdm) info.hhdm = hhdm->address;
    if (fb && fb->count && fb->count <= 32 && fb->framebuffers) info.framebuffer = fb->framebuffers[0];
    if (rsdp) info.rsdp = rsdp->address;
    struct address_response *efi = (struct address_response *)efi_request.response;
    if (efi) info.efi_system_table = efi->address;
    const struct executable_file *executable = xfe_boot_file_metadata();
    if (executable) {
        info.boot_disk_id[0] = executable->disk_id[0]; info.boot_disk_id[1] = executable->disk_id[1];
        info.boot_partition_id[0] = executable->partition_id[0]; info.boot_partition_id[1] = executable->partition_id[1];
    }
    return &info;
}
void *xfe_storage(uint32_t kind) {
    switch(kind) {
        case 0: return gdt;
        case 1: return idt;
        case 2: return tss;
        case 3: return double_fault_stack + sizeof(double_fault_stack);
        case 4: return free_pages;
        case 5: return owned_pages;
        case 6: return virtual_regions;
        case 7: return thread_records;
        case 8: return thread_contexts;
        case 9: return event_records;
        case 10: return input_reports;
        case 11: return exception_stack + sizeof(exception_stack);
        case 12: return allocation_starts;
        case 13: return allocation_ends;
        case 14: return &timer_ticks;
        default: return 0;
    }
}
uint8_t xfe_in8(uint16_t port) { uint8_t value; __asm__ volatile("inb %1,%0":"=a"(value):"Nd"(port)); return value; }
void xfe_out8(uint16_t port,uint8_t value) { __asm__ volatile("outb %0,%1"::"a"(value),"Nd"(port)); }
void xfe_pause(void) { __asm__ volatile("pause"); }
void xfe_halt(void) { __asm__ volatile("cli; hlt":::"memory"); }
void xfe_idle(void) { __asm__ volatile("sti; hlt; cli":::"memory"); }
uint64_t xfe_irq_save(void) { uint64_t flags; __asm__ volatile("pushfq; popq %0; cli":"=r"(flags)::"memory"); return flags; }
void xfe_irq_restore(uint64_t flags) { __asm__ volatile("pushq %0; popfq"::"r"(flags):"memory","cc"); }
uint32_t xfe_mmio_read32(uint64_t address) { return *(volatile uint32_t*)address; }
void xfe_mmio_write32(uint64_t address,uint32_t value) { *(volatile uint32_t*)address=value; }
uint64_t xfe_read_cr2(void) { uint64_t value; __asm__ volatile("mov %%cr2,%0":"=r"(value)); return value; }
uint64_t xfe_read_cr3(void) { uint64_t value; __asm__ volatile("mov %%cr3,%0":"=r"(value)); return value; }
uint64_t xfe_read_cr4(void) { uint64_t value; __asm__ volatile("mov %%cr4,%0":"=r"(value)); return value; }
uint64_t xfe_read_msr(uint32_t reg) { uint32_t low,high; __asm__ volatile("rdmsr":"=a"(low),"=d"(high):"c"(reg)); return ((uint64_t)high<<32)|low; }
void xfe_write_msr(uint32_t reg,uint64_t value) { __asm__ volatile("wrmsr"::"c"(reg),"a"((uint32_t)value),"d"((uint32_t)(value>>32)):"memory"); }
void xfe_invalidate_page(uint64_t address) { __asm__ volatile("invlpg (%0)"::"r"(address):"memory"); }
uint64_t xfe_read_tsc(void) { uint32_t low,high; __asm__ volatile("lfence; rdtsc":"=a"(low),"=d"(high)::"memory"); return ((uint64_t)high<<32)|low; }
void xfe_cpuid(uint32_t leaf,uint32_t subleaf,uint32_t *result) {
    __asm__ volatile("cpuid":"=a"(result[0]),"=b"(result[1]),"=c"(result[2]),"=d"(result[3]):"a"(leaf),"c"(subleaf));
}
void xfe_load_idt(void *pointer) { __asm__ volatile("lidt (%0)"::"r"(pointer):"memory"); }
void xfe_read_gdt(void *pointer) { __asm__ volatile("sgdt (%0)"::"r"(pointer):"memory"); }
void xfe_read_idt(void *pointer) { __asm__ volatile("sidt (%0)"::"r"(pointer):"memory"); }
void xfe_load_tss(uint16_t selector) { __asm__ volatile("ltr %0"::"r"(selector):"memory"); }
void xfe_breakpoint(void) { __asm__ volatile("mov %%rsp,%0; int3":"=m"(breakpoint_stack)::"memory"); }
uint64_t xfe_breakpoint_stack(void) { return breakpoint_stack; }
uint64_t xfe_boot_stack_top(void) { return xfe_initial_stack_top; }
extern char __xfe_kernel_start[],__xfe_kernel_end[];
uint64_t xfe_kernel_image_start(void) { return (uint64_t)__xfe_kernel_start; }
uint64_t xfe_kernel_image_end(void) { return (uint64_t)__xfe_kernel_end; }
void xfe_memory_barrier(void) { __asm__ volatile("mfence":::"memory"); }
extern void *xfe_isr_table[256];
uint64_t xfe_isr_address(uint32_t vector) { return vector < 256 ? (uint64_t)xfe_isr_table[vector] : 0; }
extern char xfe_probe_read_fault[],xfe_probe_read_resume[],xfe_probe_write_fault[],xfe_probe_write_resume[],xfe_probe_execute_resume[];
uint64_t xfe_probe_info(uint32_t kind) {
    switch(kind) {
        case 0: return (uint64_t)xfe_probe_read_fault;
        case 1: return (uint64_t)xfe_probe_read_resume;
        case 2: return (uint64_t)xfe_probe_write_fault;
        case 3: return (uint64_t)xfe_probe_write_resume;
        case 4: return (uint64_t)xfe_probe_execute_resume;
        default: return 0;
    }
}
extern char xfe_thread_trampoline[];
uint64_t xfe_thread_trampoline_address(void) { return (uint64_t)xfe_thread_trampoline; }
extern char xfe_thread_probe[];
uint64_t xfe_thread_probe_address(void) { return (uint64_t)xfe_thread_probe; }
void xfe_context_initialize(void *context) {
    uint8_t saved[512] __attribute__((aligned(16)));
    uint32_t mxcsr=0x1f80;
    __asm__ volatile("fxsave64 (%0); fninit; ldmxcsr (%1); fxsave64 (%2); fxrstor64 (%0)"
        ::"r"(saved),"r"(&mxcsr),"r"((uint8_t*)context+96):"memory");
}
extern void *XfeRuntimeTlsCreate(void) __attribute__((weak));
extern int XfeRuntimeTlsRelease(void*) __attribute__((weak));
extern int XfeRuntimeDetachThread(void*) __attribute__((weak));
extern int XfeRuntimeTryHijack(void*,const void*) __attribute__((weak));
extern int XfeRuntimeDispatchHardwareFault(void*,uint64_t,void*) __attribute__((weak));
uint64_t xfe_thread_tls_create(void) { return XfeRuntimeTlsCreate?(uint64_t)XfeRuntimeTlsCreate():0; }
int xfe_thread_tls_release(uint64_t control) { return XfeRuntimeTlsRelease?XfeRuntimeTlsRelease((void*)control):0; }
int xfe_thread_runtime_exit(void* thread) { return !thread?1:XfeRuntimeDetachThread?XfeRuntimeDetachThread(thread):0; }
int xfe_thread_try_hijack(void* thread,void* context) { return XfeRuntimeTryHijack?XfeRuntimeTryHijack(thread,context):-1; }
int xfe_runtime_hardware_exception_bridge(void* frame,uint64_t address,void* fxSave) {
    return XfeRuntimeDispatchHardwareFault?XfeRuntimeDispatchHardwareFault(frame,address,fxSave):0;
}

extern void *xfe_runtime_alloc_pages(uint64_t pages);
void *xfe_zero_malloc(size_t bytes) {
    if (!bytes || bytes > UINT64_MAX - 4095) return 0;
    return xfe_runtime_alloc_pages((bytes + 4095) / 4096);
}
__attribute__((noreturn)) void xfe_zero_abort(void) {
    // Even a compiler-generated fail-fast before C# initialization is bounded.
    const char *message = "XFE_ZERO_FAILFAST\r\n";
    for (const char *p = message; *p; ++p) {
        for (uint32_t poll = 0; poll < 100000; ++poll) {
            if ((xfe_in8(0x3fd) & 0x20) != 0) { xfe_out8(0x3f8,(uint8_t)*p); break; }
            xfe_pause();
        }
    }
    for (;;) xfe_halt();
}