284 lines
8.7 KiB
Nim
284 lines
8.7 KiB
Nim
# MARKUS MAIWALD (ARCHITECT) | VOXIS FORGE (AI)
|
|
# Rumpk Layer 1: The Logic Core (Autonomous Immune System)
|
|
|
|
{.push stackTrace: off, lineTrace: off.}
|
|
|
|
import fiber
|
|
import ion
|
|
|
|
|
|
var ion_paused*: bool = false
|
|
var pause_start*: uint64 = 0
|
|
|
|
|
|
# =========================================================
|
|
# Fiber Management (Forward Declared)
|
|
# =========================================================
|
|
|
|
var fiber_ion: FiberObject
|
|
var fiber_nexshell: FiberObject
|
|
var fiber_ui: FiberObject
|
|
var fiber_subject: FiberObject
|
|
var fiber_watchdog: FiberObject
|
|
|
|
# Exports for Zig NPLs
|
|
proc console_write(p: pointer, len: csize_t) {.importc, cdecl.}
|
|
proc write*(fd: cint, p: pointer, len: csize_t): csize_t {.exportc, cdecl.} =
|
|
console_write(p, len)
|
|
return len
|
|
|
|
# Utility for Logic Core
|
|
proc kprint*(s: cstring) {.exportc, cdecl.} =
|
|
if s != nil:
|
|
let length = len(s)
|
|
if length > 0:
|
|
console_write(s, csize_t(length))
|
|
|
|
proc kprintln*(s: cstring) {.exportc, cdecl.} =
|
|
kprint(s); kprint("\n")
|
|
|
|
# =========================================================
|
|
# Shared Infrastructure
|
|
# =========================================================
|
|
|
|
const SYSTABLE_BASE = 0x83000000'u64
|
|
|
|
# Global Rings (The Pipes - L0 Physics)
|
|
var guest_rx_hal: HAL_Ring[IonPacket]
|
|
var guest_tx_hal: HAL_Ring[IonPacket]
|
|
var guest_event_hal: HAL_Ring[IonPacket]
|
|
var guest_cmd_hal: HAL_Ring[CmdPacket]
|
|
|
|
# Shared Channels (The Valves - L1 Logic)
|
|
var chan_rx*: SovereignChannel[IonPacket]
|
|
var chan_tx*: SovereignChannel[IonPacket]
|
|
var chan_event*: SovereignChannel[IonPacket]
|
|
var chan_cmd*: SovereignChannel[CmdPacket]
|
|
|
|
proc get_ion_load(): int =
|
|
## Calculate load of the Command Ring (The Heartbeat of the NPLs)
|
|
let head = guest_cmd_hal.head
|
|
let tail = guest_cmd_hal.tail
|
|
let mask = guest_cmd_hal.mask
|
|
return int((head - tail) and mask)
|
|
|
|
proc rumpk_yield_internal() {.cdecl, exportc.} =
|
|
let load = get_ion_load()
|
|
|
|
# 🏛️ ADAPTIVE GOVERNOR (Phase 3: FLOOD CONTROL)
|
|
# Ring Size = 256. 80% = ~200.
|
|
if load > 200:
|
|
# BACKPRESSURE MODE: Ring is filling up! Panic Flush!
|
|
# Force switch to ION Fiber to drain.
|
|
if current_fiber != addr fiber_ion:
|
|
switch(addr fiber_ion)
|
|
return
|
|
elif load > 0:
|
|
# WAR MODE: Priority to IO Loop. Bypass NexShell/Watchdog.
|
|
if current_fiber == addr fiber_subject:
|
|
switch(addr fiber_ion)
|
|
return
|
|
elif current_fiber == addr fiber_ion:
|
|
# If Subject is the main producer, we must let it run
|
|
switch(addr fiber_subject)
|
|
return
|
|
elif load == 0:
|
|
# IDLE MODE (Phase 3): No pending commands.
|
|
# We must enable interrupts to receive packets!
|
|
asm "csrsi sstatus, 2"
|
|
# We can just yield here, interrupts will fire and preempt us (if we had preemption)
|
|
# or fire and return to here.
|
|
# But if we just loop, we burn CPU.
|
|
# Ideally: WFI.
|
|
# For now: Just enable interrupts so ISR can fire.
|
|
# asm "wfi" # Optional: Save power.
|
|
|
|
# Normal Round Robin logic
|
|
if current_fiber == addr fiber_ion:
|
|
switch(addr fiber_nexshell)
|
|
elif current_fiber == addr fiber_nexshell:
|
|
switch(addr fiber_ui)
|
|
elif current_fiber == addr fiber_ui:
|
|
switch(addr fiber_subject)
|
|
elif current_fiber == addr fiber_subject:
|
|
switch(addr fiber_watchdog)
|
|
else:
|
|
switch(addr fiber_ion)
|
|
|
|
proc fiber_yield*() {.exportc, cdecl.} =
|
|
rumpk_yield_internal()
|
|
|
|
|
|
# Utility moved up
|
|
|
|
|
|
# Channel API (The Valve) - Wrappers for ION
|
|
# Channel API is imported from ion.nim
|
|
|
|
|
|
|
|
# HAL/NPL Entry points
|
|
proc rumpk_halt() {.importc, cdecl, noreturn.}
|
|
proc hal_io_init() {.importc, cdecl.}
|
|
proc nexshell_main() {.importc, cdecl.}
|
|
proc launch_subject() {.importc, cdecl.}
|
|
|
|
# Hardware Ingress (Zig -> Nim)
|
|
proc ion_ingress*(id: uint16, len: uint16) {.exportc, cdecl.} =
|
|
## Intercept raw hardware packet and push to Sovereign RX Channel
|
|
# kprint("[Kernel] Ingress ID: "); kprint_int(int(id)); kprint(" Len: "); kprint_int(int(len)); kprintln("")
|
|
let data = ion_get_virt(id)
|
|
var pkt = IonPacket(data: cast[ptr UncheckedArray[byte]](data), len: len, id: id)
|
|
chan_rx.send(pkt)
|
|
|
|
# Panic Handler
|
|
proc nimPanic(msg: cstring) {.exportc: "panic", cdecl, noreturn.} =
|
|
kprint("\n[PANIC] "); kprintln(msg)
|
|
rumpk_halt()
|
|
|
|
# =========================================================
|
|
# Fiber Entries
|
|
# =========================================================
|
|
|
|
var stack_ion: array[32768, uint8]
|
|
var stack_nexshell: array[32768, uint8]
|
|
var stack_ui: array[32768, uint8]
|
|
var stack_subject: array[65536, uint8]
|
|
var stack_watchdog: array[4096, uint8]
|
|
|
|
proc ui_fiber_entry() {.importc, cdecl.}
|
|
|
|
proc subject_fiber_entry() {.cdecl.} =
|
|
launch_subject()
|
|
|
|
# Include Watchdog Logic (Access to Kernel Globals)
|
|
include watchdog
|
|
|
|
# HAL Driver API
|
|
proc virtio_net_poll() {.importc, cdecl.}
|
|
proc virtio_net_send(data: pointer, len: csize_t) {.importc, cdecl.}
|
|
proc ion_free_raw(id: uint16) {.importc, cdecl.}
|
|
|
|
proc ion_fiber_entry() {.cdecl.} =
|
|
kprint("[ION] Fiber 1 Reporting for Duty.")
|
|
if ion_paused: kprintln(" (PAUSED)") else: kprintln("")
|
|
|
|
var pkt: IonPacket
|
|
var cmd: CmdPacket
|
|
|
|
while true:
|
|
# 0. Poll Hardware (The Heartbeat)
|
|
virtio_net_poll()
|
|
|
|
# 1. Process Commands (Drain the ring!)
|
|
while chan_cmd.recv(cmd):
|
|
if cmd.kind == uint32(CMD_ION_STOP):
|
|
kprintln("[ION] STOP received. Suspending IO.")
|
|
ion_paused = true
|
|
pause_start = cpu_ticks()
|
|
elif cmd.kind == uint32(CMD_ION_START):
|
|
kprintln("[ION] START received. Resuming IO.")
|
|
ion_paused = false
|
|
|
|
# 2. Process Data (if not paused, Drain the ring!)
|
|
if not ion_paused:
|
|
while chan_tx.recv(pkt):
|
|
# Transmit to Hardware
|
|
kprint("[ION] TX from chan_tx, len=")
|
|
# kprint_int(int(pkt.len))
|
|
kprintln("")
|
|
virtio_net_send(pkt.data, csize_t(pkt.len))
|
|
# Zero-Copy Ingest means we own the buffer now.
|
|
# Since virtio_net_send copies (for now), we must free the original slab.
|
|
ion_free_raw(pkt.id)
|
|
|
|
fiber_yield()
|
|
|
|
|
|
# =========================================================
|
|
# kmain: The Orchestrator
|
|
# =========================================================
|
|
|
|
proc kmain() {.exportc, cdecl.} =
|
|
kprintln("\n\n")
|
|
kprintln("╔═══════════════════════════════════════╗")
|
|
kprintln("║ NEXUS RUMK v1.1 - SOVEREIGN ║")
|
|
kprintln("╚═══════════════════════════════════════╝")
|
|
|
|
# 1. Hardware & Memory
|
|
kprintln("[Kernel] Initializing Memory Substrate...")
|
|
ion_pool_init()
|
|
hal_io_init()
|
|
|
|
# 1.5 The Retina (VirtIO-GPU)
|
|
proc virtio_gpu_init(base: uint64) {.importc, cdecl.}
|
|
|
|
# On QEMU virt machine, virtio-mmio devices are at 0x10001000-0x10008000
|
|
# GPU could be at any slot.
|
|
kprintln("[Kernel] Scanning for VirtIO-GPU...")
|
|
for i in 1..8:
|
|
let base_addr = 0x10000000'u64 + (uint64(i) * 0x1000'u64)
|
|
virtio_gpu_init(base_addr)
|
|
|
|
# 2. Channel Infrastructure
|
|
kprintln("[Kernel] Mapping Sovereign Channels...")
|
|
|
|
# Initialize Invariant Shield (Masking)
|
|
for r in [addr guest_rx_hal, addr guest_tx_hal, addr guest_event_hal]:
|
|
r.head = 0
|
|
r.tail = 0
|
|
r.mask = 255
|
|
|
|
guest_cmd_hal.head = 0
|
|
guest_cmd_hal.tail = 0
|
|
guest_cmd_hal.mask = 255
|
|
|
|
chan_rx.ring = addr guest_rx_hal
|
|
chan_tx.ring = addr guest_tx_hal
|
|
chan_event.ring = addr guest_event_hal
|
|
chan_cmd.ring = addr guest_cmd_hal
|
|
|
|
let sys_table = cast[ptr SysTable](SYSTABLE_BASE)
|
|
sys_table.magic = 0x4E585553
|
|
sys_table.s_rx = addr guest_rx_hal
|
|
sys_table.s_tx = addr guest_tx_hal
|
|
sys_table.s_event = addr guest_event_hal
|
|
sys_table.s_cmd = addr guest_cmd_hal
|
|
|
|
|
|
# 3. The Nerve (Yield Anchor)
|
|
proc rumpk_yield_guard() {.importc, cdecl.}
|
|
let yield_ptr_loc = cast[ptr pointer](0x83000FF0'u64)
|
|
yield_ptr_loc[] = cast[pointer](rumpk_yield_guard)
|
|
|
|
# 4. Deployment
|
|
kprintln("[Kernel] Spawning System Fibers...")
|
|
|
|
# 1. ION FIBER (The Valve)
|
|
init_fiber(addr fiber_ion, ion_fiber_entry, addr stack_ion[0], sizeof(stack_ion))
|
|
|
|
# 2. NEXSHELL FIBER (The Brain)
|
|
init_fiber(addr fiber_nexshell, nexshell_main, addr stack_nexshell[0], sizeof(stack_nexshell))
|
|
|
|
# 3. UI FIBER (The Face)
|
|
init_fiber(addr fiber_ui, ui_fiber_entry, addr stack_ui[0], sizeof(stack_ui))
|
|
|
|
# 4. SUBJECT FIBER (The Payload)
|
|
init_fiber(addr fiber_subject, subject_fiber_entry, addr stack_subject[0],
|
|
sizeof(stack_subject))
|
|
|
|
# 5. WATCHDOG FIBER (The Immune System)
|
|
init_fiber(addr fiber_watchdog, watchdog_loop, addr stack_watchdog[0], sizeof(stack_watchdog))
|
|
|
|
# [FIX] GLOBAL INTERRUPT ENABLE
|
|
# Open the ear before we enter the loop.
|
|
kprintln("[Kernel] Enabling Supervisor Interrupts (SIE)...")
|
|
asm "csrsi sstatus, 2"
|
|
|
|
kprintln("[Kernel] All Systems Go. Entering Autonomous Loop.")
|
|
|
|
# Handover to Scheduler (The Heartbeat)
|
|
switch(addr fiber_ion)
|
|
|
|
{.pop.}
|