rumpk/core/kernel.nim

# Rumpk Layer 1: The Logic Core
# Markus Maiwald (Architect) | Voxis Forge (AI)
#
# This is the Nim kernel entry point.
# Compiled with --os:standalone --mm:arc

{.push stackTrace: off, lineTrace: off.}

import fiber
import npl

# =========================================================
# HAL Imports from Zig (Layer 0)
# =========================================================

proc console_write(p: pointer, len: csize_t) {.importc, cdecl.}
proc rumpk_halt() {.importc, cdecl, noreturn.}

# =========================================================
# Kernel I/O
# =========================================================

proc kprint(s: string) =
  if s.len > 0:
    console_write(unsafeAddr s[0], csize_t(s.len))

proc kprintln(s: string) =
  kprint(s)
  kprint("\n")

# =========================================================
# Panic Handler (Required for --os:standalone)
# =========================================================

proc nimPanic(msg: cstring) {.exportc: "panic", cdecl, noreturn.} =
  kprint("\n[PANIC] ")
  if msg != nil:
    var i = 0
    while msg[i] != '\0':
      var buf: array[1, char]
      buf[0] = msg[i]
      console_write(addr buf[0], 1)
      inc i
  kprint("\n")
  rumpk_halt()

# =========================================================
# Fiber Test: Ping Pong
# =========================================================

var fiber_a: FiberObject
var stack_a: array[4096, uint8]

var fiber_b: FiberObject
var stack_b: array[4096, uint8]

proc thread_a_entry() {.cdecl.} =
  kprintln("[Fiber A] I am alive! Yielding to B...")
  switch(addr fiber_b)
  kprintln("[Fiber A] I am back! Yielding to B...")
  switch(addr fiber_b)
  kprintln("[Fiber A] Final return. Halting.")
  while true:
    {.emit: "asm volatile(\"wfi\");".}

proc thread_b_entry() {.cdecl.} =
  kprintln("[Fiber B] Hello from B! Yielding to A...")
  switch(addr fiber_a)
  kprintln("[Fiber B] Returned! Yielding to A...")
  switch(addr fiber_a)
  kprintln("[Fiber B] Final return. Halting.")
  while true:
    {.emit: "asm volatile(\"wfi\");".}

# =========================================================
# NPL Loader Test
# =========================================================

var npl_test_buffer {.align: 128.}: array[256, uint8]

proc test_npl_loader() =
  kprintln("")
  kprintln("╔═══════════════════════════════════════╗")
  kprintln("║     NPL Loader Test (Phase 4)         ║")
  kprintln("╚═══════════════════════════════════════╝")
  kprintln("")

  # Build test payload with architecture-specific RET instruction
  when defined(arm64) or defined(aarch64):
    let retCode = [0xC0'u8, 0x03'u8, 0x5F'u8, 0xD6'u8]
    let archCode = ARCH_ARM64
    kprintln("[NPL] Building ARM64 test payload...")
  elif defined(amd64) or defined(x86_64):
    let retCode = [0xC3'u8]
    let archCode = ARCH_X86_64
    kprintln("[NPL] Building x86_64 test payload...")
  elif defined(riscv64):
    let retCode = [0x67'u8, 0x80'u8, 0x00'u8, 0x00'u8]
    let archCode = ARCH_RISCV64
    kprintln("[NPL] Building RISC-V test payload...")
  else:
    kprintln("[NPL] Unsupported architecture!")
    return

  buildTestPayload(addr npl_test_buffer, archCode, retCode)
  kprintln("[NPL] Loading...")

  let entry = loadNpl(addr npl_test_buffer[0], 256)

  kprintln("[NPL] loadNpl returned")

  if entry != nil:
    kprintln("[NPL] ✅ Verification PASSED")
    kprintln("[NPL] Executing payload...")
    entry()
    kprintln("[NPL] ✅ Payload returned!")
  else:
    kprintln("[NPL] ❌ Load failed")

proc test_npl_rejection() =
  kprintln("")
  kprintln("[NPL] Testing rejection...")

  when defined(arm64) or defined(aarch64):
    let retCode = [0xC0'u8, 0x03'u8, 0x5F'u8, 0xD6'u8]
    let archCode = ARCH_ARM64
  elif defined(amd64) or defined(x86_64):
    let retCode = [0xC3'u8]
    let archCode = ARCH_X86_64
  elif defined(riscv64):
    let retCode = [0x67'u8, 0x80'u8, 0x00'u8, 0x00'u8]
    let archCode = ARCH_RISCV64
  else:
    return

  buildTestPayload(addr npl_test_buffer, archCode, retCode)
  npl_test_buffer[8] = 0xFF'u8 # Trigger rejection

  let entry = loadNpl(addr npl_test_buffer[0], 256)

  if entry == nil:
    kprintln("[NPL] ✅ Bad sig rejected")
  else:
    kprintln("[NPL] ❌ Should reject!")

# =========================================================
# Kernel Main Entry
# =========================================================

proc kmain() {.exportc, cdecl.} =
  kprintln("╔═══════════════════════════════════════╗")
  kprintln("║     Layer 1: Nim Kernel Alive!        ║")
  kprintln("╚═══════════════════════════════════════╝")
  kprintln("")
  kprintln("[Rumpk L1] Memory: ARC (Deterministic)")
  kprintln("[Rumpk L1] POSIX: None (Hostile)")
  kprintln("[Rumpk L1] Status: OPERATIONAL")
  kprintln("")
  kprintln("[Rumpk L1] The Rubicon is crossed.")
  kprintln("[Rumpk L1] Zig + Nim = Sovereign Metal.")

  # Phase 4: NPL Loader Test
  test_npl_loader()
  test_npl_rejection()

  kprintln("")
  kprintln("[Rumpk L1] Initializing Fibers...")

  # Initialize Fibers
  fiber_a.name = "Fiber A"
  fiber_b.name = "Fiber B"

  init_fiber(addr fiber_a, thread_a_entry, addr stack_a[0])
  init_fiber(addr fiber_b, thread_b_entry, addr stack_b[0])

  kprintln("[Kernel] Switching to Fiber A...")
  kprintln("")
  switch(addr fiber_a)

  nimPanic("Main thread returned!")

{.pop.}