nexus
/
rumpk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: nexus:6335b54e1fc3839a60e0e40c7e29bb9420dadfd5
Branches Tags
nexus:unstable
..
compare: nexus:2e55188096c67cc2234cc8d0a57ad8c909b2d425
Branches Tags
nexus:unstable

No commits in common. "6335b54e1fc3839a60e0e40c7e29bb9420dadfd5" and "2e55188096c67cc2234cc8d0a57ad8c909b2d425" have entirely different histories.
6335b54e1f ... 2e55188096

45 changed files with 1214 additions and 1356 deletions
Show Stats Expand all files Collapse all files

94
apps/init/init.nim
View File

@ -6,73 +6,113 @@
# See legal/LICENSE_SOVEREIGN.md for license terms.
## Sovereign Init: The Genesis Process
##
## Responsible for bootstrapping the system, starting core services,
## and managing the lifecycle of the user environment.
import ../../libs/membrane/libc
# --- Entry Point ---
proc main() =
# 1. Pledge Sovereignty
discard pledge(0xFFFFFFFFFFFFFFFF'u64) # PLEDGE_ALL
print(cstring("\n"))
print(cstring("\x1b[1;35m╔═══════════════════════════════════════╗\x1b[0m\n"))
print(cstring("\x1b[1;35m║ SOVEREIGN INIT (NexInit v1.0) ║\x1b[0m\n"))
print(cstring("\x1b[1;35m║ SOVEREIGN INIT (NexInit v0.1) ║\x1b[0m\n"))
print(cstring("\x1b[1;35m╚═══════════════════════════════════════╝\x1b[0m\n\n"))
print(cstring("[INIT] System Ready. Starting heartbeat...\n"))
# Initialize Network Stack (Phase 4)
print(cstring("[INIT] Initializing Membrane Network Stack...\n"))
membrane_init()
proc glue_get_ip(): uint32 {.importc: "glue_get_ip", cdecl.}
# --- DHCP PHASE ---
# Wait for IP (Max 30 seconds)
print(cstring("[INIT] Waiting for DHCP IP Address...\n"))
var ip: uint32 = 0
for i in 0 ..< 600: # 60 seconds
for i in 0 ..< 300:
pump_membrane_stack()
ip = glue_get_ip()
if ip != 0: break
discard syscall(0x65, 100000000'u64) # 100ms
# Sleep 100ms (100,000,000 ns)
discard syscall(0x65, 100000000'u64)
if ip == 0:
print(cstring("[INIT] WARNING: DHCP Discovery timed out. Proceeding...\n"))
print(cstring("\x1b[1;33m[INIT] WARNING: Ongoing DHCP discovery. Proceeding with caution...\x1b[0m\n"))
else:
print(cstring("[INIT] Network ONLINE (10.0.2.15)\n"))
print(cstring("[INIT] Network ONLINE.\n"))
# --- DNS PHASE ---
# --- TEST: Verify getaddrinfo with IP ---
print(cstring("[INIT] Phase 1: Verify getaddrinfo shim with IP Address...\n"))
var res: ptr AddrInfo
if getaddrinfo("8.8.8.8", nil, nil, addr res) == 0:
print(cstring("[INIT] Success: Shim correctly handled IP address string.\n"))
freeaddrinfo(res)
else:
print(cstring("\x1b[1;31m[INIT] ERROR: getaddrinfo shim failed for 8.8.8.8\x1b[0m\n"))
# --- HEPHAESTUS DIAGNOSTIC: PING TEST ---
print(cstring("\n[TEST] ══════════════════════════════════════\n"))
print(cstring("[TEST] DNS Resolution: google.com\n"))
print(cstring("[TEST] ICMP Ping Diagnostic (Hephaestus)\n"))
print(cstring("[TEST] Target: 10.0.2.2 (QEMU Gateway)\n"))
print(cstring("[TEST] ══════════════════════════════════════\n\n"))
var res: ptr AddrInfo
for attempt in 1..5:
print(cstring("[TEST] Resolving google.com (Attempt "))
# (Simplified number printing not available, just loop)
# The ping implementation is already in net_glue.nim (lines 58-103)
# We just need to trigger it via the existing mechanism
# For now, let's just pump the stack and let the built-in ping run
# Actually, looking at net_glue.nim line 293-302, it already auto-pings!
if getaddrinfo("google.com", nil, nil, addr res) == 0:
print(cstring(") -> SUCCESS!\n"))
freeaddrinfo(res)
break
else:
print(cstring(") -> FAILED. Waiting 5s...\n"))
for j in 1..50:
print(cstring("[TEST] Membrane auto-ping is enabled in net_glue.nim\n"))
print(cstring("[TEST] Pumping stack for 10 seconds to allow ICMP traffic...\n"))
for i in 1..10:
pump_membrane_stack()
discard syscall(0x65, 100000000'u64) # 100ms
discard syscall(0x65, 1000000000'u64) # 1 second
# --- SHELL PHASE ---
print(cstring("[TEST] Ping window complete. Check qemu_network.pcap for:\n"))
print(cstring("[TEST] - ICMP Echo Request (10.0.2.15 -> 10.0.2.2)\n"))
print(cstring("[TEST] - ICMP Echo Reply (10.0.2.2 -> 10.0.2.15)\n\n"))
# Spawn mksh as a separate fiber fibers (NOT execv - we stay alive as supervisor)
proc spawn_fiber(path: cstring): int =
# SYS_SPAWN_FIBER = 0x300
return int(syscall(0x300, cast[uint64](path), 0, 0))
print(cstring("[INIT] Spawning mksh...\n"))
discard spawn_fiber(cstring("/bin/mksh"))
let fiber_id = spawn_fiber(cstring("/bin/mksh"))
if fiber_id > 0:
print(cstring("[INIT] Spawned mksh fiber ID: "))
# Note: Can't easily print int in minimal libc, just confirm success
print(cstring("OK\n"))
else:
print(cstring("\x1b[1;31m[INIT] Failed to spawn shell!\x1b[0m\n"))
# Supervisor loop - REACTIVE MODE (Silence Doctrine)
# Only wake when network packets arrive or other I/O events occur
print(cstring("[INIT] Entering supervisor mode (REACTIVE)...\n"))
# Slot 2 is CMD_NET_RX (0x501) granted by Kernel
const SLOT_NET_RX = 2
let wait_mask = 1'u64 shl SLOT_NET_RX # Wait for network events
# --- SUPERVISOR PHASE ---
print(cstring("[INIT] Entering Supervisor Loop...\n"))
var loop_count = 0
while true:
# Process network events and LwIP timers
pump_membrane_stack()
# Heartbeat every iteration
loop_count += 1
if loop_count mod 100 == 0:
if loop_count mod 1 == 0:
print(cstring("[INIT] Heartbeat\n"))
discard syscall(0x65, 100000000'u64) # 100ms
# Sleep 10ms using Timer Driver (System Call)
discard syscall(0x65, 10000000'u64)
when isMainModule:
main()

20
boot/header.zig
View File

@ -46,19 +46,13 @@ export const multiboot2_header linksection(".multiboot2") = Multiboot2Header{
// Entry Point
// =========================================================
extern fn riscv_init() noreturn;
extern fn kmain() noreturn;
// 1MB Kernel Stack
const STACK_SIZE = 0x100000;
export var kernel_stack: [STACK_SIZE]u8 align(16) linksection(".bss.stack") = undefined;
export fn _start() callconv(.naked) noreturn {
// Clear BSS, set up stack, then jump to RISC-V Init
export fn _start() callconv(.Naked) noreturn {
// Clear BSS, set up stack, then jump to Nim
asm volatile (
\\ // Set up stack
\\ la sp, kernel_stack
\\ li t0, %[stack_size]
\\ add sp, sp, t0
\\ la sp, __stack_top
\\
\\ // Clear BSS
\\ la t0, __bss_start
@ -69,13 +63,11 @@ export fn _start() callconv(.naked) noreturn {
\\ addi t0, t0, 8
\\ j 1b
\\2:
\\ // Jump to HAL Init
\\ call riscv_init
\\ // Jump to Nim kmain
\\ call kmain
\\
\\ // Should never return
\\ wfi
\\ j 2b
:
: [stack_size] "i" (STACK_SIZE),
);
}

24
boot/linker.ld
View File

@ -1,13 +1,11 @@
# Rumpk Linker Script (RISC-V 64)
# For QEMU virt machine (RISC-V)
# Rumpk Linker Script (ARM64)
# For QEMU virt machine
ENTRY(_start)
SECTIONS
{
. = 0x80200000; /* Standard RISC-V QEMU virt kernel address */
PROVIDE(__kernel_vbase = .);
PROVIDE(__kernel_pbase = .);
. = 0x40080000; /* QEMU virt kernel load address */
.text : {
*(.text._start)
@ -19,19 +17,9 @@ SECTIONS
}
.data : {
. = ALIGN(16);
__global_pointer$ = . + 0x800;
*(.sdata*)
*(.sdata.*)
*(.data*)
}
.initrd : {
_initrd_start = .;
KEEP(*(.initrd))
_initrd_end = .;
}
.bss : {
__bss_start = .;
*(.bss*)
@ -39,12 +27,6 @@ SECTIONS
__bss_end = .;
}
.stack (NOLOAD) : {
. = ALIGN(16);
. += 0x100000; /* 1MB Stack */
PROVIDE(__stack_top = .);
}
/DISCARD/ : {
*(.comment)
*(.note*)

50
build.zig
View File

@ -29,7 +29,6 @@ pub fn build(b: *std.Build) void {
// Freestanding kernel - no libc, no red zone, no stack checks
hal_mod.red_zone = false;
hal_mod.stack_check = false;
hal_mod.code_model = .medany;
const hal = b.addLibrary(.{
.name = "rumpk_hal",
@ -59,60 +58,13 @@ pub fn build(b: *std.Build) void {
});
boot_mod.red_zone = false;
boot_mod.stack_check = false;
boot_mod.code_model = .medany;
const boot = b.addObject(.{
.name = "boot",
.root_module = boot_mod,
});
// =========================================================
// Final Link: rumpk.elf
// =========================================================
const kernel_mod = b.createModule(.{
.root_source_file = b.path("hal/abi.zig"), // Fake root, we add objects later
.target = target,
.optimize = optimize,
});
kernel_mod.red_zone = false;
kernel_mod.stack_check = false;
kernel_mod.code_model = .medany;
const kernel = b.addExecutable(.{
.name = "rumpk.elf",
.root_module = kernel_mod,
});
kernel.setLinkerScript(b.path("boot/linker.ld"));
kernel.addObject(boot);
// kernel.linkLibrary(hal); // Redundant, already in kernel_mod
// Add Nim-generated objects
{
var nimcache_dir = std.fs.cwd().openDir("build/nimcache", .{ .iterate = true }) catch |err| {
std.debug.print("Warning: Could not open nimcache dir: {}\n", .{err});
return;
};
defer nimcache_dir.close();
var it = nimcache_dir.iterate();
while (it.next() catch null) |entry| {
if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".o")) {
const path = b.fmt("build/nimcache/{s}", .{entry.name});
kernel.addObjectFile(b.path(path));
}
}
}
// Add external pre-built dependencies (Order matters: Libs after users)
kernel.addObjectFile(b.path("build/switch.o")); // cpu_switch_to
kernel.addObjectFile(b.path("build/sys_arch.o")); // sys_now, nexus_lwip_panic
kernel.addObjectFile(b.path("build/libc_shim.o"));
kernel.addObjectFile(b.path("build/clib.o"));
kernel.addObjectFile(b.path("build/liblwip.a"));
kernel.addObjectFile(b.path("build/initrd.o"));
b.installArtifact(kernel);
_ = boot; // Mark as used for now
// =========================================================
// Tests

259
core/cstubs.c
View File

@ -1,57 +1,210 @@
// C runtime stubs for freestanding Nim
#include <stddef.h>
/* Duplicates provided by libnexus.a (clib.o) */
#if 0
void *memcpy(void *dest, const void *src, size_t n) { ... }
void *memset(void *s, int c, size_t n) { ... }
void *memmove(void *dest, const void *src, size_t n) { ... }
int memcmp(const void *s1, const void *s2, size_t n) { ... }
/* Externs from libnexus.a */
extern size_t strlen(const char *s);
extern int atoi(const char *nptr);
extern int strncmp(const char *s1, const char *s2, size_t n);
char *strcpy(char *dest, const char *src) { ... }
int strcmp(const char *s1, const char *s2) { ... }
char *strncpy(char *dest, const char *src, size_t n) { ... }
#endif
// panic is used by abort/exit
void panic(const char* msg) {
extern void console_write(const char*, unsigned long);
extern size_t strlen(const char*);
console_write("\n[KERNEL PANIC] ", 16);
if (msg) console_write(msg, strlen(msg));
else console_write("Unknown Error", 13);
console_write("\n", 1);
while(1) {
// Halt
void *memcpy(void *dest, const void *src, size_t n) {
unsigned char *d = dest;
const unsigned char *s = src;
while (n--) *d++ = *s++;
return dest;
}
void *memset(void *s, int c, size_t n) {
unsigned char *p = s;
while (n--) *p++ = (unsigned char)c;
return s;
}
void *memmove(void *dest, const void *src, size_t n) {
unsigned char *d = dest;
const unsigned char *s = src;
if (d < s) {
while (n--) *d++ = *s++;
} else {
d += n;
s += n;
while (n--) *--d = *--s;
}
return dest;
}
int memcmp(const void *s1, const void *s2, size_t n) {
const unsigned char *p1 = s1, *p2 = s2;
while (n--) {
if (*p1 != *p2) return *p1 - *p2;
p1++; p2++;
}
return 0;
}
size_t strlen(const char *s) {
size_t len = 0;
while (*s++) len++;
return len;
}
char *strcpy(char *dest, const char *src) {
char *d = dest;
while ((*d++ = *src++));
return dest;
}
int strcmp(const char *s1, const char *s2) {
while (*s1 && (*s1 == *s2)) { s1++; s2++; }
return *(unsigned char*)s1 - *(unsigned char*)s2;
}
int strncmp(const char *s1, const char *s2, size_t n) {
while (n && *s1 && (*s1 == *s2)) {
s1++; s2++; n--;
}
if (n == 0) return 0;
return *(unsigned char*)s1 - *(unsigned char*)s2;
}
char *strncpy(char *dest, const char *src, size_t n) {
char *d = dest;
while (n && (*d++ = *src++)) n--;
while (n--) *d++ = '\0';
return dest;
}
// abort is used by Nim panic
void abort(void) {
/* Call Nim panic */
extern void panic(const char*);
panic("abort() called");
while(1) {}
}
#if 0
/* Stdio stubs - these call into Zig UART */
extern void console_write(const char*, unsigned long);
int puts(const char *s) { ... }
int putchar(int c) { ... }
// ... (printf, etc)
int snprintf(char *str, size_t size, const char *format, ...) { ... }
int fflush(void *stream) { ... }
unsigned long fwrite(const void *ptr, unsigned long size, unsigned long nmemb, void *stream) { ... }
sighandler_t signal(int signum, sighandler_t handler) { ... }
int raise(int sig) { ... }
int sprintf(char *str, const char *format, ...) { ... }
double strtod(const char *nptr, char **endptr) { ... }
#endif
int puts(const char *s) {
if (s) {
unsigned long len = strlen(s);
console_write(s, len);
console_write("\n", 1);
}
return 0;
}
int putchar(int c) {
char buf[1] = {(char)c};
console_write(buf, 1);
return c;
}
#include <stdarg.h>
void itoa(int n, char s[]) {
int i, sign;
if ((sign = n) < 0) n = -n;
i = 0;
do { s[i++] = n % 10 + '0'; } while ((n /= 10) > 0);
if (sign < 0) s[i++] = '-';
s[i] = '\0';
// reverse
for (int j = 0, k = i-1; j < k; j++, k--) {
char temp = s[j]; s[j] = s[k]; s[k] = temp;
}
}
int printf(const char *format, ...) {
va_list args;
va_start(args, format);
while (*format) {
if (*format == '%' && *(format + 1)) {
format++;
if (*format == 's') {
char *s = va_arg(args, char *);
if (s) console_write(s, strlen(s));
} else if (*format == 'd') {
int d = va_arg(args, int);
char buf[16];
itoa(d, buf);
console_write(buf, strlen(buf));
} else {
putchar('%');
putchar(*format);
}
} else {
putchar(*format);
}
format++;
}
va_end(args);
return 0;
}
int fprintf(void *stream, const char *format, ...) {
return printf(format);
}
int vsnprintf(char *str, size_t size, const char *format, va_list args) {
size_t count = 0;
if (size == 0) return 0;
while (*format && count < size - 1) {
if (*format == '%' && *(format + 1)) {
format++;
if (*format == 's') {
char *s = va_arg(args, char *);
if (s) {
while (*s && count < size - 1) {
str[count++] = *s++;
}
}
} else if (*format == 'd' || *format == 'i') {
int d = va_arg(args, int);
char buf[16];
itoa(d, buf);
char *b = buf;
while (*b && count < size - 1) {
str[count++] = *b++;
}
} else {
str[count++] = '%';
if (count < size - 1) str[count++] = *format;
}
} else {
str[count++] = *format;
}
format++;
}
str[count] = '\0';
return count;
}
int snprintf(char *str, size_t size, const char *format, ...) {
va_list args;
va_start(args, format);
int ret = vsnprintf(str, size, format, args);
va_end(args);
return ret;
}
int fflush(void *stream) {
return 0;
}
unsigned long fwrite(const void *ptr, unsigned long size, unsigned long nmemb, void *stream) {
console_write(ptr, size * nmemb);
return nmemb;
}
/* Signal stubs - no signals in freestanding */
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler) {
(void)signum;
(void)handler;
return (sighandler_t)0;
}
int raise(int sig) {
(void)sig;
return 0;
}
/* Exit stubs */
void exit(int status) {
@ -64,10 +217,30 @@ void _Exit(int status) {
exit(status);
}
int atoi(const char *nptr) {
int res = 0;
while (*nptr >= '0' && *nptr <= '9') {
res = res * 10 + (*nptr - '0');
nptr++;
}
return res;
}
int sprintf(char *str, const char *format, ...) {
va_list args;
va_start(args, format);
// Unsafe sprintf limit
int ret = vsnprintf(str, 2048, format, args);
va_end(args);
return ret;
}
double strtod(const char *nptr, char **endptr) {
if (endptr) *endptr = (char*)nptr + strlen(nptr); // Fake endptr
return (double)atoi(nptr);
}
// qsort uses existing memcpy
// Note: We need memcpy for qsort!
// libnexus.a provides memcpy. We need to declare it.
extern void *memcpy(void *dest, const void *src, size_t n);
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)) {
// Bubble sort for simplicity (O(n^2))
@ -93,4 +266,4 @@ void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, co
}
}
// int errno = 0; // Provided by clib.c
int errno = 0;

16
core/fiber.nim
View File

@ -92,15 +92,13 @@ proc cpu_switch_to(prev_sp_ptr: ptr uint64, next_sp: uint64) {.importc, cdecl.}
proc mm_activate_satp(satp_val: uint64) {.importc, cdecl.}
proc mm_get_kernel_satp(): uint64 {.importc, cdecl.}
proc debug(s: cstring) =
proc debug(s: string) =
proc console_write(p: pointer, len: int) {.importc, cdecl.}
var i = 0
while s[i] != '\0': i += 1
if i > 0:
console_write(cast[pointer](s), i)
if s.len > 0:
console_write(unsafeAddr s[0], s.len)
proc print_arch_info*() =
debug("[Rumpk] Architecture Context: riscv64\n")
debug("[Rumpk] Architecture Context: " & ARCH_NAME & "\n")
# =========================================================
# Constants
@ -120,12 +118,10 @@ var current_fiber* {.global.}: Fiber = addr main_fiber
# =========================================================
proc fiber_trampoline() {.cdecl, exportc, noreturn.} =
let msg: cstring = "[FIBER] Trampoline Entry!\n"
var msg = "[FIBER] Trampoline Entry!\n"
# We can't use kprintln here if it's not imported or we use emit
proc console_write(p: pointer, len: int) {.importc, cdecl.}
var i = 0
while msg[i] != '\0': i += 1
console_write(cast[pointer](msg), i)
console_write(addr msg[0], msg.len)
let f = current_fiber
if f.state.entry != nil:

2
core/fs/sfs.nim
View File

@ -10,7 +10,7 @@
## Freestanding implementation (No OS module dependencies).
## Uses fixed-size buffers and raw blocks for persistence.
import ../ring, ../fiber # For yield
import ring, fiber # For yield
proc kprintln(s: cstring) {.importc, cdecl.}
proc kprint(s: cstring) {.importc, cdecl.}

15
core/include/stdio.h
View File

@ -1,14 +1,27 @@
/* Minimal stdio.h stub for freestanding Nim */
#ifndef _STDIO_H
#define _STDIO_H
#include <stddef.h>
#include <stdarg.h>
typedef struct {
int fd;
} FILE;
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
#define EOF (-1)
int printf(const char *format, ...);
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);
int fprintf(FILE *stream, const char *format, ...);
int rename(const char *oldpath, const char *newpath);
int remove(const char *pathname);
#endif
#endif /* _STDIO_H */

18
core/include/stdlib.h
View File

@ -1,14 +1,24 @@
/* Minimal stdlib.h stub for freestanding Nim */
#ifndef _STDLIB_H
#define _STDLIB_H
#include <stddef.h>
void exit(int status);
void abort(void);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
void *calloc(size_t nmemb, size_t size);
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
void abort(void);
void exit(int status);
void _Exit(int status);
int atoi(const char *nptr);
double strtod(const char *nptr, char **endptr);
long strtol(const char *nptr, char **endptr, int base);
unsigned long strtoul(const char *nptr, char **endptr, int base);
#endif
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
int rand(void);
void srand(unsigned int seed);
#endif /* _STDLIB_H */

26
core/include/string.h
View File

@ -1,17 +1,33 @@
/* Minimal string.h stub for freestanding Nim */
#ifndef _STRING_H
#define _STRING_H
#include <stddef.h>
/* Minimal implementations defined in cstubs.c */
void *memcpy(void *dest, const void *src, size_t n);
void *memchr(const void *s, int c, size_t n);
void *memset(void *s, int c, size_t n);
void *memmove(void *dest, const void *src, size_t n);
int memcmp(const void *s1, const void *s2, size_t n);
size_t strlen(const char *s);
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t n);
char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
char *strchr(const char *s, int c);
char *strstr(const char *haystack, const char *needle);
size_t strlen(const char *s);
void *memchr(const void *s, int c, size_t n);
char *strerror(int errnum);
#endif
char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);
char *strstr(const char *haystack, const char *needle);
char *strdup(const char *s);
size_t strspn(const char *s, const char *accept);
size_t strcspn(const char *s, const char *reject);
char *strpbrk(const char *s, const char *accept);
char *strsep(char **stringp, const char *delim);
int strcasecmp(const char *s1, const char *s2);
int strncasecmp(const char *s1, const char *s2, size_t n);
#endif /* _STRING_H */

119
core/kernel.nim
View File

@ -8,10 +8,11 @@
# Nexus Sovereign Core: Kernel Implementation
# target Bravo: Complete Build Unification
import fiber, ion, sched, pty, cspace, ontology, fastpath, utcp
import fs/vfs, fs/tar
import ring, fiber, ion, sched, pty, cspace, ontology, channels, fastpath, utcp
import fs/vfs, fs/tar, fs/sfs
import loader/elf
import ../libs/membrane/term
import ../libs/membrane/libc as libc_impl
const
MAX_WORKERS* = 8
@ -30,9 +31,8 @@ proc virtio_blk_read(sector: uint64, buf: ptr byte) {.importc, cdecl.}
proc virtio_blk_write(sector: uint64, buf: ptr byte) {.importc, cdecl.}
proc fb_kern_get_addr(): uint64 {.importc, cdecl.}
proc hal_io_init() {.importc, cdecl.}
proc console_write*(p: pointer, len: csize_t) {.importc: "hal_console_write", cdecl.}
proc console_write*(p: pointer, len: csize_t) {.importc, cdecl.}
proc nexshell_main() {.importc, cdecl.}
proc console_poll() {.importc, cdecl.}
proc ion_get_virt(id: uint16): uint64 {.importc, cdecl.}
# InitRD Symbols
@ -42,7 +42,7 @@ var initrd_end {.importc: "_initrd_end" .}: byte
# Globals
var
fiber_ion, fiber_subject, fiber_child, fiber_compositor, fiber_nexshell, fiber_netswitch: FiberObject
stack_ion {.align: 4096.}, stack_subject {.align: 4096.}, stack_child {.align: 4096.}, stack_compositor {.align: 4096.}, stack_nexshell {.align: 4096.}, stack_netswitch {.align: 4096.}: array[MAX_FIBER_STACK, byte]
stack_ion, stack_subject, stack_child, stack_compositor, stack_nexshell, stack_netswitch: array[MAX_FIBER_STACK, byte]
subject_loading_path: array[64, char] = [ '/', 's', 'y', 's', 'r', 'o', '/', 'b', 'i', 'n', '/', 'm', 'k', 's', 'h', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' ]
matrix_enabled: bool = false
active_fibers_arr: array[16, ptr FiberObject]
@ -165,7 +165,7 @@ proc kload_phys(path: cstring, phys_offset: uint64): uint64 =
kprint(" - Zeroing BSS: VA="); kprint_hex(bss_start); kprint(" Len="); kprint_hex(bss_len); kprintln("")
k_zero_mem(cast[pointer](bss_start), bss_len)
# {.emit: """asm volatile ("li t1, 0x40000; csrc sstatus, t1" : : : "t1");""" .}
{.emit: """asm volatile ("li t1, 0x40000; csrc sstatus, t1" : : : "t1");""" .}
# ⚡ ARCH-SYNC: Flush I-Cache after loading new code
{.emit: """asm volatile ("fence.i" : : : "memory");""" .}
@ -193,34 +193,12 @@ proc subject_fiber_entry() {.cdecl.} =
# Fallback (Legacy/Init) - Top of the 64MB Sentinel Cell
sp = 0x8BFFFFF0'u64
kprintln("╔════════════════════════════════════════════════════╗")
kprintln("║ PRE-FLIGHT: USERLAND TRANSITION ║")
kprintln("╚════════════════════════════════════════════════════╝")
kprint(" Entry: "); kprint_hex(entry_addr); kprintln("")
kprint(" SysTable: "); kprint_hex(SYSTABLE_BASE); kprintln("")
kprint(" Stack: "); kprint_hex(sp); kprintln("")
kprint(" SATP: "); kprint_hex(current_fiber.satp_value); kprintln("")
kprint(" Phys Off: "); kprint_hex(current_fiber.phys_offset); kprintln("")
kprintln("")
# 🔥 CRITICAL: Activate worker page table BEFORE entering userland!
# Without this, userland executes with kernel identity map → instant page fault
if current_fiber.satp_value != 0:
proc mm_activate_satp(satp_val: uint64) {.importc, cdecl.}
kprint("[Subject:"); kprint_hex(fid); kprint("] Activating worker page table: "); kprint_hex(current_fiber.satp_value); kprintln("")
mm_activate_satp(current_fiber.satp_value)
kprint("[Subject:"); kprint_hex(fid); kprint("] JUMPING to Userland. SP="); kprint_hex(sp); kprintln("")
hal_enter_userland(entry_addr, SYSTABLE_BASE, sp)
else:
kprint("[Subject:"); kprint_hex(fid); kprintln("] Loader failed to find/load payload!")
while true: fiber_sleep(1000)
proc nexshell_fiber_entry() {.cdecl.} =
kprintln("[NexShell] Interactive Fiber Online")
while true:
console_poll()
fiber_sleep(10)
proc compositor_fiber_entry() {.cdecl.} =
kprintln("[Compositor] Fiber Entry reached.")
while true:
@ -276,7 +254,6 @@ proc ion_fiber_entry() {.cdecl.} =
while true:
var pkt: CmdPacket
if chan_cmd.recv(pkt):
kprint("[ION] Received Packet Kind: "); kprint_hex(uint64(pkt.kind))
case CmdType(pkt.kind):
of CMD_SYS_EXIT:
kprintln("[ION] Restarting Subject...")
@ -317,9 +294,7 @@ proc ion_fiber_entry() {.cdecl.} =
fiber_child.satp_value = mm_create_worker_map(cast[uint64](addr stack_child[0]), uint64(sizeof(stack_child)), SYSTABLE_BASE, cell_base, cell_size)
kprintln("[ION] Child fiber spawned successfully")
else: discard
else:
# No pending commands - yield to scheduler (short sleep to avoid busy spin)
fiber_sleep(1) # 1ms
fiber_sleep(10_000_000) # 10ms
proc rumpk_yield_internal*() {.exportc, cdecl.} =
# Switch back to the main dispatcher loop
@ -370,15 +345,11 @@ proc fiber_netswitch_entry() {.cdecl.} =
var res = ion_tx_push(pkt)
if not res: kprintln("[NetSwitch] Drop (TX Full)")
# Poll Network
# Manual Polling (Interrupts Disabled)
virtio_net_poll()
# Poll UART (Backup/Primary Polling Mode)
{.emit: "extern void uart_poll_input(void); uart_poll_input();".}
# Prevent Starvation
fiber_sleep(10) # 10ms - allow DHCP state machine to execute
# 10ms - allow DHCP state machine to execute
proc ion_ingress*(id: uint16, len: uint16, offset: uint16) {.exportc, cdecl.} =
## Handle packet from Network Driver
@ -413,58 +384,22 @@ proc k_check_deferred_yield*() {.exportc, cdecl.} =
fiber_yield()
proc k_handle_exception*(scause, sepc, stval: uint) {.exportc, cdecl.} =
kprintln("")
kprintln("╔════════════════════════════════════════════════════╗")
kprintln("║ KERNEL IMMUNE SYSTEM: EXCEPTION DETECTED ║")
kprintln("╚════════════════════════════════════════════════════╝")
# Decode scause
let cause_code = scause and 0x7FFFFFFFFFFFFFFF'u64
kprint(" SCAUSE: "); kprint_hex(scause); kprint(" (")
case cause_code:
of 0: kprint("Instruction address misaligned")
of 1: kprint("Instruction access fault")
of 2: kprint("Illegal instruction")
of 3: kprint("Breakpoint")
of 4: kprint("Load address misaligned")
of 5: kprint("Load access fault")
of 6: kprint("Store/AMO address misaligned")
of 7: kprint("Store/AMO access fault")
of 8: kprint("Environment call from U-mode")
of 9: kprint("Environment call from S-mode")
of 12: kprint("Instruction page fault")
of 13: kprint("Load page fault")
of 15: kprint("Store/AMO page fault")
else: kprint("Unknown exception")
kprintln(")")
kprint(" SEPC: "); kprint_hex(sepc); kprintln(" (Faulting PC)")
kprint(" STVAL: "); kprint_hex(stval); kprintln(" (Fault address/info)")
# Dump current fiber context
if current_fiber != nil:
kprint(" Fiber: "); kprint_hex(current_fiber.id)
kprint(" SATP: "); kprint_hex(current_fiber.satp_value)
kprintln("")
kprint("[IMMUNE] EXCEPTION: scause="); kprint_hex(scause)
kprint(" sepc="); kprint_hex(sepc)
kprint(" stval="); kprint_hex(stval)
kprintln("")
kprintln("[IMMUNE] System HALTING (Trap Loop Prevention).")
while true:
{.emit: "asm volatile(\"wfi\");".}
proc k_get_current_satp*(): uint64 {.exportc, cdecl.} =
if current_fiber != nil:
return current_fiber.satp_value
return 0
proc wrapper_vfs_write(fd: int32, buf: pointer, count: uint64): int64 {.cdecl.} =
return ion_vfs_write(fd, buf, count)
# --- SYSCALL HANDLER ---
proc k_handle_syscall*(nr, a0, a1, a2: uint): uint {.exportc, cdecl.} =
if nr != 0x100 and nr != 0x205 and nr != 0x204 and nr != 0x203:
kprint("[Syscall] NR: "); kprint_hex(uint64(nr)); kprintln("")
# if nr != 0x100:
# kprint("[Syscall] NR: "); kprint_hex(nr); kprintln("")
case nr:
of 0x01: # EXIT
@ -498,10 +433,8 @@ proc k_handle_syscall*(nr, a0, a1, a2: uint): uint {.exportc, cdecl.} =
of 0x202: # LIST
return uint(ion_vfs_list(cast[pointer](a0), uint64(a1)))
of 0x905: # SYS_SOCK_RESOLVE
# TODO: Implement getaddrinfo kernel integration
return 0 # Not implemented yet
return uint(libc_impl.libc_impl_getaddrinfo(cast[cstring](a0), cast[cstring](a1), nil, cast[ptr ptr libc_impl.AddrInfo](a2)))
of 0x203: # READ
# kprint("[Syscall] READ(fd="); kprint_hex(a0); kprint(")\n")
var vres = -2
if a0 == 0 or vres == -2:
let pid = if current_fiber.pty_id >= 0: current_fiber.pty_id else: 0
@ -510,18 +443,16 @@ proc k_handle_syscall*(nr, a0, a1, a2: uint): uint {.exportc, cdecl.} =
var buf: array[1, byte]
let n = pty_read_slave(PTY_SLAVE_BASE + pid, addr buf[0], 1)
if n > 0:
# kprint("[Kernel] READ delivered PTY byte: "); kprint_hex8(buf[0]); kprint("\n")
cast[ptr UncheckedArray[byte]](a1)[0] = buf[0]
return 1
var pkt: IonPacket
if chan_input.recv(pkt):
kprint("[Kernel] Got Input Packet of len: "); kprint_hex(uint64(pkt.len)); kprint("\n")
let n = if uint64(pkt.len) < a2: uint64(pkt.len) else: a2
if n > 0:
# copyMem(cast[pointer](a1), cast[pointer](pkt.data), int(n))
# console_write(pkt.data, csize_t(n))
let data = cast[ptr UncheckedArray[byte]](pkt.data)
for i in 0 ..< int(n):
kprint(" Input Char: "); kprint(cast[cstring](unsafeAddr data[i])); kprint("\n")
pty_push_input(pid, char(data[i]))
for i in 0 ..< int(n): pty_push_input(pid, char(data[i]))
ion_free_raw(pkt.id)
# Loop again to read from PTY
else:
@ -563,13 +494,7 @@ proc k_handle_syscall*(nr, a0, a1, a2: uint): uint {.exportc, cdecl.} =
# Re-initialize fiber_subject with new binary
# The ION fiber will pick this up and restart the Subject fiber
var pkt = CmdPacket(kind: uint32(CMD_SPAWN_FIBER), arg: 0)
# DEBUG: Check if send works
if chan_cmd.send(pkt):
kprintln("[Kernel] CMD_SPAWN_FIBER sent to ION.")
else:
kprintln("[Kernel] CRITICAL: Failed to send CMD_SPAWN_FIBER to ION!")
discard chan_cmd.send(pkt)
# Return fiber ID (always 4 for Subject currently)
return 4
else: return 0
@ -706,7 +631,7 @@ proc kmain() {.exportc, cdecl.} =
let compositor_spawn_id = emit_fiber_spawn(3, 0, boot_id) # Compositor fiber
discard compositor_spawn_id
init_fiber(addr fiber_nexshell, nexshell_fiber_entry, addr stack_nexshell[0], sizeof(stack_nexshell))
init_fiber(addr fiber_nexshell, nexshell_main, addr stack_nexshell[0], sizeof(stack_nexshell))
let shell_spawn_id = emit_fiber_spawn(2, 0, boot_id) # NexShell fiber
# NetSwitch Spawn
@ -758,8 +683,8 @@ proc kmain() {.exportc, cdecl.} =
# cast[ptr uint32](plic_base + 140)[] = 1 # VirtIO-Net (IRQ 35: 35*4 = 140)
# Enable (Supervisor Context 1)
# IRQs 0-31 (Enable IRQ 10 = UART)
cast[ptr uint32](plic_base + 0x2000 + 0x80)[] = (1'u32 shl 10)
# IRQs 0-31
# cast[ptr uint32](plic_base + 0x2000 + 0x80)[] = (1'u32 shl 10)
# IRQs 32-63
# cast[ptr uint32](plic_base + 0x2000 + 0x80 + 4)[] = 0x0000000F # Enable 32,33,34,35

4
core/netswitch.nim
View File

@ -92,6 +92,7 @@ proc netswitch_process_packet(pkt: IonPacket): bool =
return false
proc fiber_netswitch_entry*() {.cdecl.} =
membrane_init()
kprintln("[NetSwitch] Fiber Entry - The Traffic Cop is ON DUTY")
var rx_activity: bool = false
@ -107,7 +108,8 @@ proc fiber_netswitch_entry*() {.cdecl.} =
# 1. Drive the hardware poll (fills chan_netswitch_rx)
virtio_net_poll()
# [Cleaned] Driven by Userland now
# 2. Drive the LwIP Stack (Timers/RX)
pump_membrane_stack()
# 2. Consume from the Driver -> Switch internal ring
var raw_pkt: IonPacket

2
core/overrides.c
View File

@ -21,7 +21,6 @@ double floor(double x) {
}
double fmod(double x, double y) { return 0.0; } // Stub
/* atomic overrides commented out to prefer stubs.zig
// ----------------------------------------------------------------------------
// Atomic Overrides (To avoid libcompiler_rt atomics.o which uses medlow)
// ----------------------------------------------------------------------------
@ -117,7 +116,6 @@ void sovereign_atomic_fetch_min_16(void *ptr, void *val, void *ret, int model) {
bool sovereign_atomic_is_lock_free(size_t size, void *ptr) {
return true; // We are single core or spinlocked elsewhere
}
*/
// ===================================
// Compiler-RT Stubs (128-bit Math)

42
core/panicoverride.nim
View File

@ -11,40 +11,11 @@
# Required for Nim --os:any / --os:standalone
# This file must be named panicoverride.nim
var nimErrorFlag* {.exportc: "nimErrorFlag", compilerproc.}: bool = false
proc nimAddInt(a, b: int, res: var int): bool {.compilerproc.} =
let r = a + b
if (r < a) != (b < 0): return true
res = r
return false
proc nimSubInt(a, b: int, res: var int): bool {.compilerproc.} =
let r = a - b
if (r > a) != (b < 0): return true
res = r
return false
proc nimMulInt(a, b: int, res: var int): bool {.compilerproc.} =
let r = a * b
if b != 0 and (r div b) != a: return true
res = r
return false
{.push stackTrace: off.}
proc console_write(p: pointer, len: csize_t) {.importc, cdecl.}
proc rumpk_halt() {.importc, cdecl, noreturn.}
# Stubs for missing runtime symbols to satisfy linker
proc setLengthStr*(s: pointer, newLen: int) {.exportc, compilerproc.} = discard
proc addChar*(s: pointer, c: char) {.exportc, compilerproc.} = discard
proc callDepthLimitReached*() {.exportc, compilerproc.} =
while true: discard
# Type Info stub for Defect (referenced by digitsutils/exceptions)
var NTIdefect* {.exportc: "NTIdefect__SEK9acOiG0hv2dnGQbk52qg_", compilerproc.}: pointer = nil
proc rawoutput(s: string) =
if s.len > 0:
console_write(unsafeAddr s[0], csize_t(s.len))
@ -61,17 +32,4 @@ proc panic(s: cstring) {.exportc, noreturn.} =
rawoutput("\n")
rumpk_halt()
proc raiseIndexError2(i, n: int) {.exportc, noreturn, compilerproc.} =
rawoutput("[PANIC] Index Error: ")
panic("Index Out of Bounds")
proc raiseOverflow() {.exportc, noreturn, compilerproc.} =
panic("Integer Overflow")
proc raiseRangeError(val: int64) {.exportc, noreturn, compilerproc.} =
panic("Range Error")
proc raiseDivByZero() {.exportc, noreturn, compilerproc.} =
panic("Division by Zero")
{.pop.}

5
core/test_standalone.nim
View File

@ -1,5 +0,0 @@
proc main() =
discard
when isMainModule:
main()

119
core/utcp.nim
View File

@ -42,22 +42,23 @@ type
sender_id*: CellID # 16 bytes
seq_num*: uint64 # 8 bytes (Big Endian)
payload_len*: uint16 # 2 bytes (Big Endian)
# Total: 2 + 1 + 1 + 16 + 16 + 8 + 2 = 46 bytes?
# Wait, SPEC-093 says 32 bytes... let's recheck the SPEC layout.
# SPEC layout:
# 0-2: eth_type (2)
# 2: flags (1)
# 3: reserved (1)
# 4-19: target_id (16)
# 20-35: sender_id (16)
# 36-43: seq_num (8)
# 44-45: payload_len (2)
# Total = 46 bytes.
# 46 bytes + 14 byte Eth header = 60 bytes minimum frame size.
UtcpState* = enum
CLOSED, LISTEN, SYN_SENT, SYN_RCVD, ESTABLISHED, FIN_WAIT
UtcpControlBlock* = object
state*: UtcpState
local_id*: CellID
remote_id*: CellID
local_seq*: uint64
remote_seq*: uint64
last_ack*: uint64
const MAX_CONNECTIONS = 16
var utcp_pcb_table: array[MAX_CONNECTIONS, UtcpControlBlock]
# The ASCII art in SPEC-093 might be misleading or I miscalculated "32 bytes".
# 16+16 is already 32. So header is definitely larger than 32 if it includes 2 CellIDs.
# SipHash-128 is 16 bytes.
# Let's stick to the struct definition, size is secondary to correctness.
# 46 bytes + 14 byte Eth header = 60 bytes minimum frame size. Nice.
# --- Helper Functions ---
@ -65,31 +66,16 @@ proc ntohs(n: uint16): uint16 {.inline.} =
return (n shr 8) or (n shl 8)
proc ntohll(n: uint64): uint64 {.inline.} =
var b = cast[array[8, byte]](n)
var
b = cast[array[8, byte]](n)
res: uint64
# Reverse bytes
# TODO: Optimize with bswap builtin if available
return (uint64(b[0]) shl 56) or (uint64(b[1]) shl 48) or
(uint64(b[2]) shl 40) or (uint64(b[3]) shl 32) or
(uint64(b[4]) shl 24) or (uint64(b[5]) shl 16) or
(uint64(b[6]) shl 8) or uint64(b[7])
proc htonll(n: uint64): uint64 {.inline.} =
return ntohll(n) # Symmetric
proc cellid_eq(a, b: CellID): bool =
return a.lo == b.lo and a.hi == b.hi
proc utcp_find_pcb(remote_id: CellID): ptr UtcpControlBlock =
for i in 0 ..< MAX_CONNECTIONS:
if utcp_pcb_table[i].state != CLOSED and cellid_eq(utcp_pcb_table[i].remote_id, remote_id):
return addr utcp_pcb_table[i]
return nil
proc utcp_alloc_pcb(): ptr UtcpControlBlock =
for i in 0 ..< MAX_CONNECTIONS:
if utcp_pcb_table[i].state == CLOSED:
return addr utcp_pcb_table[i]
return nil
# --- Logic ---
proc utcp_handle_packet*(data: ptr UncheckedArray[byte], len: uint16) {.exportc, cdecl.} =
@ -101,55 +87,26 @@ proc utcp_handle_packet*(data: ptr UncheckedArray[byte], len: uint16) {.exportc,
let header = cast[ptr UtcpHeader](data)
# Validate Magic
if ntohs(header.eth_type) != ETHERTYPE_UTCP:
# Allow 0x88B5 for now, but log if mismatch
discard
# Validate EtherType (if present in tunnel payload? SPEC says it's the first field)
# In 0x88B5 frames, the EtherType is in the Ethernet header, which might be stripped?
# Fastpath stripping logic in fastpath.nim removes ETH(14)+IP(20)+UDP(8).
# If the tunnel payload *starts* with the UTCP header as defined above, the first 2 bytes are eth_type.
# This acts as a magic number/version check.
let seq_num = ntohll(header.seq_num)
let flags = header.flags
if ntohs(header.eth_type) != ETHERTYPE_UTCP:
# kprint("[UTCP] Drop: Invalid EtherType/Magic: ")
# kprint_hex(uint64(ntohs(header.eth_type)))
# kprintln("")
# It might be 0x88B5, allow it for now.
discard
# Log Packet
kprint("[UTCP] RX Seq="); kprint_hex(seq_num);
kprint(" Flags="); kprint_hex(uint64(flags)); kprintln("")
kprintln("[UTCP] Packet Received")
if (header.flags and UTCP_FLAG_SYN) != 0:
kprintln(" Type: SYN")
elif (header.flags and UTCP_FLAG_DATA) != 0:
kprintln(" Type: DATA")
# State Machine
var pcb = utcp_find_pcb(header.sender_id)
kprint(" Seq: "); kprint_hex(ntohll(header.seq_num)); kprintln("")
if pcb == nil:
# New Connection?
if (flags and UTCP_FLAG_SYN) != 0:
kprintln("[UTCP] New SYN received")
pcb = utcp_alloc_pcb()
if pcb != nil:
pcb.state = SYN_RCVD
pcb.remote_id = header.sender_id
pcb.local_id = header.target_id
pcb.remote_seq = seq_num
pcb.local_seq = 1000 # Randomize?
kprintln("[UTCP] State -> SYN_RCVD. Sending SYN-ACK (TODO)")
# TODO: Send SYN-ACK
else:
kprintln("[UTCP] Drop: Table full")
else:
kprintln("[UTCP] Drop: Packet for unknown connection")
return
else:
# Existing Connection
kprint("[UTCP] Match PCB. State="); kprint_hex(uint64(pcb.state)); kprintln("")
case pcb.state:
of SYN_RCVD:
if (flags and UTCP_FLAG_ACK) != 0:
pcb.state = ESTABLISHED
kprintln("[UTCP] State -> ESTABLISHED")
of ESTABLISHED:
if (flags and UTCP_FLAG_DATA) != 0:
kprintln("[UTCP] Data received")
# TODO: Enqueue data
elif (flags and UTCP_FLAG_FIN) != 0:
pcb.state = CLOSED # Simplify for now
kprintln("[UTCP] Connection-Teardown (FIN)")
else:
discard
# TODO: State machine lookup

47
hal/abi.zig
View File

@ -71,17 +71,17 @@ export fn rumpk_pfree(ptr: *anyopaque) void {
hal.pfree(ptr);
}
// export fn rumpk_halt() noreturn {
// hal.halt();
// }
export fn rumpk_halt() noreturn {
hal.halt();
}
var mock_ticks: u64 = 0;
// export fn rumpk_timer_now_ns() u64 {
// // Phase 1 Mock: Incrementing counter to simulate time passage per call
// mock_ticks += 100000; // 100us per call
// return mock_ticks;
// }
export fn rumpk_timer_now_ns() u64 {
// Phase 1 Mock: Incrementing counter to simulate time passage per call
mock_ticks += 100000; // 100us per call
return mock_ticks;
}
// =========================================================
// Ground Zero Phase 1: CSpace Integration (SPEC-020)
@ -96,34 +96,3 @@ pub const cspace_grant_cap = cspace.cspace_grant_cap;
pub const cspace_lookup = cspace.cspace_lookup;
pub const cspace_revoke = cspace.cspace_revoke;
pub const cspace_check_perm = cspace.cspace_check_perm;
// =========================================================
// Force Compilation of Stubs & Runtime
// =========================================================
// =========================================================
// Force Compilation of Stubs & Runtime
// =========================================================
// =========================================================
// Force Compilation of Stubs & Runtime
// =========================================================
// =========================================================
// Force Compilation of Stubs & Runtime
// =========================================================
// =========================================================
pub const surface = @import("surface.zig");
comptime {
// Force analysis
_ = @import("stubs.zig");
_ = @import("mm.zig");
_ = @import("channel.zig");
_ = @import("uart.zig");
_ = @import("virtio_block.zig");
_ = @import("virtio_net.zig");
_ = @import("virtio_pci.zig");
_ = @import("ontology.zig");
_ = @import("entry_riscv.zig");
_ = @import("cspace.zig");
_ = @import("surface.zig");
_ = @import("initrd.zig");
}

6
hal/channel.zig
View File

@ -96,17 +96,11 @@ export fn hal_channel_pop(handle: u64, out_pkt: *IonPacket) bool {
export fn hal_cmd_push(handle: u64, pkt: CmdPacket) bool {
validate_ring_ptr(handle);
const ring: *Ring(CmdPacket) = @ptrFromInt(handle);
// uart.print("[HAL] Pushing CMD to "); uart.print_hex(handle); uart.print("\n");
return pushGeneric(CmdPacket, ring, pkt);
}
export fn hal_cmd_pop(handle: u64, out_pkt: *CmdPacket) bool {
validate_ring_ptr(handle);
const ring: *Ring(CmdPacket) = @ptrFromInt(handle);
// uart.print("[HAL] Popping CMD from "); uart.print_hex(handle); uart.print("\n");
return popGeneric(CmdPacket, ring, out_pkt);
}
// Stub for term.nim compatibility
export fn fiber_can_run_on_channels() bool {
return true;
}

164
hal/entry_riscv.zig
View File

@ -14,34 +14,20 @@
const std = @import("std");
const uart = @import("uart.zig");
// const vm = @import("vm_riscv.zig");
const mm = @import("mm.zig");
const stubs = @import("stubs.zig"); // Force compile stubs
const uart_input = @import("uart_input.zig");
const virtio_net = @import("virtio_net.zig");
comptime {
_ = stubs;
}
// =========================================================
// Entry Point (Naked)
// =========================================================
export fn riscv_init() callconv(.naked) noreturn {
export fn _start() callconv(.naked) noreturn {
asm volatile (
// 1. Disable Interrupts
\\ csrw sie, zero
\\ csrw satp, zero
\\ csrw sscratch, zero
// PROOF OF LIFE: Raw UART write before ANY initialization
\\ li t0, 0x10000000 // UART base address
\\ li t1, 0x58 // 'X'
\\ sb t1, 0(t0) // Write to THR
// 1.1 Enable FPU (FS), Vectors (VS), and SUM (Supervisor User Memory Access)
\\ li t0, 0x42200 // SUM=bit 18, FS=bit 13, VS=bit 9
// 1.1 Enable FPU (sstatus.FS = Initial [01])
\\ li t0, 0x2000
\\ csrs sstatus, t0
// 1.2 Initialize Global Pointer
@ -74,7 +60,7 @@ export fn riscv_init() callconv(.naked) noreturn {
\\ 1: wfi
\\ j 1b
);
// unreachable;
unreachable;
}
// Trap Frame Layout (Packed on stack)
@ -250,54 +236,11 @@ extern fn k_handle_syscall(nr: usize, a0: usize, a1: usize, a2: usize) usize;
extern fn k_handle_exception(scause: usize, sepc: usize, stval: usize) void;
extern fn k_check_deferred_yield() void;
// Memory Management (Page Tables)
extern fn mm_get_kernel_satp() u64;
extern fn mm_activate_satp(satp_val: u64) void;
extern fn k_get_current_satp() u64;
fn get_sstatus() u64 {
return asm volatile ("csrr %[ret], sstatus"
: [ret] "=r" (-> u64),
);
}
fn set_sum() void {
asm volatile ("csrrs zero, sstatus, %[val]"
:
: [val] "r" (@as(u64, 1 << 18)),
);
}
// Global recursion counter
var trap_depth: usize = 0;
export fn rss_trap_handler(frame: *TrapFrame) void {
// 🔥 CRITICAL: Restore kernel page table IMMEDIATELY on trap entry
// const kernel_satp = mm_get_kernel_satp();
// if (kernel_satp != 0) {
// mm_activate_satp(kernel_satp);
// }
// RECURSION GUARD
trap_depth += 1;
if (trap_depth > 3) { // Allow some recursion (e.g. syscall -> fault), but prevent infinite loops
uart.print("[Trap] Infinite Loop Detected. Halting.\n");
while (true) {}
}
defer trap_depth -= 1;
const scause = frame.scause;
// DEBUG: Diagnose Userland Crash (Only print exceptions, ignore interrupts for noise)
if ((scause >> 63) == 0) {
uart.print("\n[Trap] Exception! Cause:");
uart.print_hex(scause);
uart.print(" PC:");
uart.print_hex(frame.sepc);
uart.print(" Val:");
uart.print_hex(frame.stval);
uart.print("\n");
}
// uart.print("[Trap] Entered Handler. scause: ");
// uart.print_hex(scause);
// uart.print("\n");
// Check high bit: 0 = Exception, 1 = Interrupt
if ((scause >> 63) != 0) {
@ -308,76 +251,55 @@ export fn rss_trap_handler(frame: *TrapFrame) void {
const irq = PLIC_CLAIM.*;
if (irq == 10) { // UART0 is IRQ 10 on Virt machine
// uart.print("[IRQ] 10\n");
uart_input.poll_input();
uart.poll_input();
} else if (irq >= 32 and irq <= 35) {
virtio_net.virtio_net_poll();
} else if (irq == 0) {
// Spurious or no pending interrupt
} else {
// uart.print("[IRQ] Unknown: ");
// uart.print_hex(irq);
// uart.print("\n");
}
// Complete the IRQ
// Complete the interrupt
PLIC_CLAIM.* = irq;
} else if (intr_id == 5) {
// Timer Interrupt
asm volatile ("csrc sip, %[mask]"
// Supervisor Timer Interrupt
// Disable (One-shot)
asm volatile ("csrc sie, %[mask]"
:
: [mask] "r" (@as(u64, 1 << 5)),
: [mask] "r" (@as(usize, 1 << 5)),
);
k_check_deferred_yield();
} else {
// uart.print("[Trap] Unhandled Interrupt: ");
// uart.print_hex(intr_id);
// uart.print("\n");
// Call Nim Handler
rumpk_timer_handler();
}
} else {
// EXCEPTION HANDLING
k_check_deferred_yield();
return;
}
// 8: ECALL from U-mode
// 9: ECALL from S-mode
if (scause == 8 or scause == 9) {
const nr = frame.a7;
const a0 = frame.a0;
const a1 = frame.a1;
const a2 = frame.a2;
uart.print("[Syscall] NR:");
uart.print_hex(nr);
uart.print("\n");
// Advance PC to avoid re-executing ECALL
// Advance PC to skip 'ecall' instruction (4 bytes)
frame.sepc += 4;
// Dispatch Sycall
const ret = k_handle_syscall(nr, a0, a1, a2);
frame.a0 = ret;
} else {
// Dispatch Syscall
const res = k_handle_syscall(frame.a7, frame.a0, frame.a1, frame.a2);
// Write result back to a0
frame.a0 = res;
// DIAGNOSTIC: Syscall completed
// uart.print("[Trap] Syscall done, returning to userland\n");
k_check_deferred_yield();
return;
}
// Delegate all other exceptions to the Kernel Immune System
// This function should NOT return ideally, but if it does, we loop.
k_handle_exception(scause, frame.sepc, frame.stval);
// Safety halt if kernel returns (should be unreachable)
while (true) {}
}
}
// 🔥 CRITICAL RETURN PATH: Restore User Page Table if returning to User Mode
// We check sstatus.SPP (Supervisor Previous Privilege) - Bit 8
// 0 = User, 1 = Supervisor
const sstatus = get_sstatus();
const spp = (sstatus >> 8) & 1;
if (spp == 0) {
const user_satp = k_get_current_satp();
if (user_satp != 0) {
// Enable SUM (Supervisor Access User Memory) so we can read the stack
// to restore registers (since stack is mapped in User PT)
set_sum();
mm_activate_satp(user_satp);
}
}
}
// SAFETY(Stack): Memory is immediately used by _start before any read.
// Initialized to `undefined` for performance (no zeroing 64KB at boot).
@ -409,33 +331,25 @@ export fn zig_entry() void {
rumpk_halt();
}
export fn hal_console_write(ptr: [*]const u8, len: usize) void {
export fn console_write(ptr: [*]const u8, len: usize) void {
uart.write_bytes(ptr[0..len]);
}
export fn console_read() c_int {
if (uart_input.read_byte()) |b| {
if (uart.read_byte()) |b| {
return @as(c_int, b);
}
return -1;
}
export fn console_poll() void {
uart_input.poll_input();
uart.poll_input();
}
export fn debug_uart_lsr() u8 {
return uart.get_lsr();
}
export fn uart_print_hex(value: u64) void {
uart.print_hex(value);
}
export fn uart_print_hex8(value: u8) void {
uart.print_hex8(value);
}
const virtio_block = @import("virtio_block.zig");
extern fn hal_surface_init() void;

BIN
hal/init
View File

Binary file not shown.

BIN
hal/initrd.tar
View File

Binary file not shown.

3
hal/initrd.zig
View File

@ -1,3 +0,0 @@
const data = @embedFile("initrd.tar");
export var _initrd_payload: [data.len]u8 align(4096) linksection(".initrd") = data.*;

BIN
hal/initrd/bin/mksh
View File

Binary file not shown.

BIN
hal/initrd/init
View File

Binary file not shown.

3
hal/main.zig
View File

@ -13,15 +13,14 @@
//! SAFETY: Runs in bare-metal mode with no runtime support.
const uart = @import("uart.zig");
const hud = @import("hud.zig");
const virtio_net = @import("virtio_net.zig");
const virtio_block = @import("virtio_block.zig");
const initrd = @import("initrd.zig");
export fn hal_io_init() void {
virtio_net.init();
virtio_block.init();
_ = initrd._initrd_payload;
}
// =========================================================

138
hal/stubs.zig
View File

@ -22,7 +22,7 @@ const uart = @import("uart.zig");
// Simple Bump Allocator for L0
// SAFETY(Heap): Memory is written by malloc before any read occurs.
// Initialized to `undefined` to avoid zeroing 32MB at boot.
var heap: [16 * 1024 * 1024]u8 align(4096) = undefined;
var heap: [96 * 1024 * 1024]u8 align(4096) = undefined;
var heap_idx: usize = 0;
var heap_init_done: bool = false;
@ -30,12 +30,6 @@ export fn debug_print(s: [*]const u8, len: usize) void {
uart.print(s[0..len]);
}
// Support for C-shim printf (clib.c)
// REMOVED: Already exported by entry_riscv.zig (hal.o)
// export fn hal_console_write(ptr: [*]const u8, len: usize) void {
// uart.print(ptr[0..len]);
// }
// Header structure (64 bytes aligned to match LwIP MEM_ALIGNMENT)
const BlockHeader = struct {
size: usize,
@ -145,133 +139,3 @@ export fn get_ticks() u32 {
// Convert to milliseconds: val / 10,000.
return @truncate(time_val / 10000);
}
// export fn rumpk_timer_set_ns(ns: u64) void {
// // Stub: Timer not implemented in L0 yet
// _ = ns;
// }
export fn fb_kern_get_addr() usize {
return 0; // Stub: No framebuffer
}
export fn nexshell_main() void {
uart.print("[Kernel] NexShell Stub Executed\n");
}
extern fn k_handle_syscall(nr: usize, a0: usize, a1: usize, a2: usize) usize;
export fn exit(code: c_int) noreturn {
_ = code;
while (true) asm volatile ("wfi");
}
// =========================================================
// Atomic Stubs (To resolve linker errors with libcompiler_rt)
// =========================================================
export fn __atomic_compare_exchange(len: usize, ptr: ?*anyopaque, expected: ?*anyopaque, desired: ?*anyopaque, success: c_int, failure: c_int) bool {
_ = len;
_ = ptr;
_ = expected;
_ = desired;
_ = success;
_ = failure;
return true;
}
export fn __atomic_fetch_add_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_sub_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_and_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_or_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_xor_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_nand_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_umax_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_fetch_umin_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_load_16(ptr: ?*const anyopaque, model: c_int) u128 {
_ = ptr;
_ = model;
return 0;
}
export fn __atomic_store_16(ptr: ?*anyopaque, val: u128, model: c_int) void {
_ = ptr;
_ = val;
_ = model;
}
export fn __atomic_exchange_16(ptr: ?*anyopaque, val: u128, model: c_int) u128 {
_ = ptr;
_ = val;
_ = model;
return 0;
}
export fn __atomic_compare_exchange_16(ptr: ?*anyopaque, exp: ?*anyopaque, des: u128, weak: bool, success: c_int, failure: c_int) bool {
_ = ptr;
_ = exp;
_ = des;
_ = weak;
_ = success;
_ = failure;
return true;
}
// =========================================================
// Nim Runtime Stubs
// =========================================================
export fn setLengthStr() void {}
export fn addChar() void {}
export fn callDepthLimitReached__OOZOOZOOZOOZOOZOOZOOZOOZOOZusrZlibZnimZsystem_u3026() void {
while (true) {}
}
export var NTIdefect__SEK9acOiG0hv2dnGQbk52qg_: ?*anyopaque = null;

107
hal/uart.zig
View File

@ -18,23 +18,34 @@ const std = @import("std");
const builtin = @import("builtin");
// ARM64 PL011 Constants
pub const PL011_BASE: usize = 0x09000000;
pub const PL011_DR: usize = 0x00;
pub const PL011_FR: usize = 0x18;
pub const PL011_TXFF: u32 = 1 << 5;
const PL011_BASE: usize = 0x09000000;
const PL011_DR: usize = 0x00;
const PL011_FR: usize = 0x18;
const PL011_TXFF: u32 = 1 << 5;
// RISC-V 16550A Constants
pub const NS16550A_BASE: usize = 0x10000000;
pub const NS16550A_THR: usize = 0x00; // Transmitter Holding Register
pub const NS16550A_LSR: usize = 0x05; // Line Status Register
pub const NS16550A_THRE: u8 = 1 << 5; // Transmitter Holding Register Empty
pub const NS16550A_IER: usize = 0x01; // Interrupt Enable Register
pub const NS16550A_FCR: usize = 0x02; // FIFO Control Register
pub const NS16550A_LCR: usize = 0x03; // Line Control Register
const NS16550A_BASE: usize = 0x10000000;
const NS16550A_THR: usize = 0x00; // Transmitter Holding Register
const NS16550A_LSR: usize = 0x05; // Line Status Register
const NS16550A_THRE: u8 = 1 << 5; // Transmitter Holding Register Empty
const NS16550A_IER: usize = 0x01; // Interrupt Enable Register
const NS16550A_FCR: usize = 0x02; // FIFO Control Register
const NS16550A_LCR: usize = 0x03; // Line Control Register
// Input logic moved to uart_input.zig
// Input Ring Buffer (256 bytes, power of 2 for fast masking)
const INPUT_BUFFER_SIZE = 256;
// SAFETY(RingBuffer): Only accessed via head/tail indices.
// SAFETY(RingBuffer): Only accessed via head/tail indices.
// Bytes are written before read. No uninitialized reads possible.
var input_buffer: [INPUT_BUFFER_SIZE]u8 = undefined;
var input_head = std.atomic.Value(u32).init(0); // Write position
var input_tail = std.atomic.Value(u32).init(0); // Read position
pub fn init() void {
// Initialize buffer pointers
input_head.store(0, .monotonic);
input_tail.store(0, .monotonic);
switch (builtin.cpu.arch) {
.riscv64 => init_riscv(),
else => {},
@ -104,7 +115,52 @@ pub fn init_riscv() void {
}
// Capture any data already in hardware FIFO
// uart_input.poll_input(); // We cannot call this here safely without dep
poll_input();
}
/// Poll UART hardware and move available bytes into ring buffer
/// Should be called periodically (e.g. from scheduler or ISR)
pub fn poll_input() void {
switch (builtin.cpu.arch) {
.riscv64 => {
const thr: *volatile u8 = @ptrFromInt(NS16550A_BASE + NS16550A_THR);
const lsr: *volatile u8 = @ptrFromInt(NS16550A_BASE + NS16550A_LSR);
// Read all available bytes from UART FIFO
while ((lsr.* & 0x01) != 0) { // Data Ready
const byte = thr.*;
// Add to ring buffer if not full
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
const next_head = (head_val + 1) % INPUT_BUFFER_SIZE;
if (next_head != tail_val) {
input_buffer[head_val] = byte;
input_head.store(next_head, .monotonic);
}
// If full, drop the byte (could log this in debug mode)
}
},
.aarch64 => {
const dr: *volatile u32 = @ptrFromInt(PL011_BASE + PL011_DR);
const fr: *volatile u32 = @ptrFromInt(PL011_BASE + PL011_FR);
while ((fr.* & (1 << 4)) == 0) { // RXFE (Receive FIFO Empty) is bit 4
const byte: u8 = @truncate(dr.*);
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
const next_head = (head_val + 1) % INPUT_BUFFER_SIZE;
if (next_head != tail_val) {
input_buffer[head_val] = byte;
input_head.store(next_head, .monotonic);
}
}
},
else => {},
}
}
fn write_char_arm64(c: u8) void {
@ -141,7 +197,22 @@ pub fn write_bytes(bytes: []const u8) void {
}
}
// read_byte moved to uart_input.zig
pub fn read_byte() ?u8 {
// First, poll UART to refill buffer
poll_input();
// Then read from buffer
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
if (tail_val != head_val) {
const byte = input_buffer[tail_val];
input_tail.store((tail_val + 1) % INPUT_BUFFER_SIZE, .monotonic);
return byte;
}
return null;
}
pub fn read_direct() ?u8 {
switch (builtin.cpu.arch) {
@ -205,6 +276,10 @@ pub fn print_hex(value: usize) void {
}
}
export fn uart_print_hex(value: u64) void {
print_hex(value);
}
pub fn print_hex8(value: u8) void {
const hex_chars = "0123456789ABCDEF";
const nibble1 = (value >> 4) & 0xF;
@ -212,3 +287,7 @@ pub fn print_hex8(value: u8) void {
write_char(hex_chars[nibble1]);
write_char(hex_chars[nibble2]);
}
export fn uart_print_hex8(value: u8) void {
print_hex8(value);
}

93
hal/uart_input.zig
View File

@ -1,93 +0,0 @@
// SPDX-License-Identifier: LCL-1.0
// Copyright (c) 2026 Markus Maiwald
// Stewardship: Self Sovereign Society Foundation
//! Rumpk Layer 0: UART Input Logic (Kernel Only)
//!
//! Separated from uart.zig to avoid polluting userland stubs with kernel dependencies.
const std = @import("std");
const builtin = @import("builtin");
const uart = @import("uart.zig");
// Input Ring Buffer (256 bytes, power of 2 for fast masking)
const INPUT_BUFFER_SIZE = 256;
var input_buffer: [INPUT_BUFFER_SIZE]u8 = undefined;
var input_head = std.atomic.Value(u32).init(0); // Write position
var input_tail = std.atomic.Value(u32).init(0); // Read position
pub fn poll_input() void {
// Only Kernel uses this
const Kernel = struct {
extern fn ion_push_stdin(ptr: [*]const u8, len: usize) void;
};
switch (builtin.cpu.arch) {
.riscv64 => {
const thr: *volatile u8 = @ptrFromInt(uart.NS16550A_BASE + uart.NS16550A_THR);
const lsr: *volatile u8 = @ptrFromInt(uart.NS16550A_BASE + uart.NS16550A_LSR);
// Read all available bytes from UART FIFO (Limit 128 to prevent stall)
var loop_limit: usize = 0;
while ((lsr.* & 0x01) != 0 and loop_limit < 128) { // Data Ready
loop_limit += 1;
const byte = thr.*;
const byte_arr = [1]u8{byte};
// Forward to Kernel Input Channel
Kernel.ion_push_stdin(&byte_arr, 1);
// Add to ring buffer if not full
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
const next_head = (head_val + 1) % INPUT_BUFFER_SIZE;
if (next_head != tail_val) {
input_buffer[head_val] = byte;
input_head.store(next_head, .monotonic);
}
}
},
.aarch64 => {
const dr: *volatile u32 = @ptrFromInt(uart.PL011_BASE + uart.PL011_DR);
const fr: *volatile u32 = @ptrFromInt(uart.PL011_BASE + uart.PL011_FR);
while ((fr.* & (1 << 4)) == 0) { // RXFE (Receive FIFO Empty) is bit 4
const byte: u8 = @truncate(dr.*);
const byte_arr = [1]u8{byte};
Kernel.ion_push_stdin(&byte_arr, 1);
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
const next_head = (head_val + 1) % INPUT_BUFFER_SIZE;
if (next_head != tail_val) {
input_buffer[head_val] = byte;
input_head.store(next_head, .monotonic);
}
}
},
else => {},
}
}
export fn uart_poll_input() void {
poll_input();
}
pub fn read_byte() ?u8 {
// First, poll UART to refill buffer
poll_input();
// Then read from buffer
const head_val = input_head.load(.monotonic);
const tail_val = input_tail.load(.monotonic);
if (tail_val != head_val) {
const byte = input_buffer[tail_val];
input_tail.store((tail_val + 1) % INPUT_BUFFER_SIZE, .monotonic);
return byte;
}
return null;
}

20
hal/virtio_net.zig
View File

@ -52,15 +52,17 @@ pub export fn virtio_net_poll() void {
if (poll_count == 1 or (poll_count % 50 == 0)) {
if (global_driver) |*d| {
if (d.rx_queue) |q| {
// const hw_idx = q.used.idx;
// const drv_idx = q.index;
// uart.print("[VirtIO] Poll #");
// uart.print_hex(poll_count);
// uart.print(" RX HW:"); uart.print_hex(hw_idx);
// uart.print(" DRV:"); uart.print_hex(drv_idx);
// uart.print(" Avail:"); uart.print_hex(q.avail.idx);
// uart.print("\n");
_ = q; // Silence unused variable 'q'
const hw_idx = q.used.idx;
const drv_idx = q.index;
uart.print("[VirtIO] Poll #");
uart.print_hex(poll_count);
uart.print(" RX HW:");
uart.print_hex(hw_idx);
uart.print(" DRV:");
uart.print_hex(drv_idx);
uart.print(" Avail:");
uart.print_hex(q.avail.idx);
uart.print("\n");
}
}
}

14
hal/virtio_pci.zig
View File

@ -92,21 +92,7 @@ pub const VirtioTransport = struct {
// Has Capabilities
var cap_offset = @as(*volatile u8, @ptrFromInt(self.base_addr + PCI_CAP_PTR)).*;
// 🔥 LOOP GUARD: Prevent infinite loops in capability chain
// Standard PCI config space is 256 bytes, max ~48 capabilities possible
// If we exceed this, the chain is circular or we're reading stale cached values
var loop_guard: usize = 0;
const MAX_CAPS: usize = 48;
while (cap_offset != 0) {
loop_guard += 1;
if (loop_guard > MAX_CAPS) {
uart.print("[VirtIO-PCI] WARN: Capability loop limit reached (");
uart.print_hex(loop_guard);
uart.print(" iterations). Breaking to prevent hang.\n");
break;
}
const cap_addr = self.base_addr + cap_offset;
const cap_id = @as(*volatile u8, @ptrFromInt(cap_addr)).*;
const cap_next = @as(*volatile u8, @ptrFromInt(cap_addr + 1)).*;

29
libs/membrane/clib.c
View File

@ -31,7 +31,13 @@ size_t strlen(const char* s) {
return i;
}
// nexus_lwip_panic moved to sys_arch.c to avoid duplicate symbols
void nexus_lwip_panic(const char* msg) {
const char* prefix = "\n\x1b[1;31m[LwIP Fatal] ASSERTION FAILED: \x1b[0m";
console_write(prefix, strlen(prefix));
console_write(msg, strlen(msg));
console_write("\n", 1);
while(1) {}
}
int strncmp(const char *s1, const char *s2, size_t n) {
for (size_t i = 0; i < n; i++) {
@ -53,14 +59,7 @@ double log10(double x) { return 0.0; }
// --- SYSCALL INTERFACE ---
#ifdef RUMPK_KERNEL
extern long k_handle_syscall(long nr, long a0, long a1, long a2);
#endif
long syscall(long nr, long a0, long a1, long a2) {
#ifdef RUMPK_KERNEL
return k_handle_syscall(nr, a0, a1, a2);
#else
long res;
#if defined(__riscv)
register long a7 asm("a7") = nr;
@ -76,7 +75,6 @@ long syscall(long nr, long a0, long a1, long a2) {
res = -1;
#endif
return res;
#endif
}
// IO stubs (Real Syscalls)
@ -237,7 +235,7 @@ void (*signal(int sig, void (*func)(int)))(int) { return NULL; }
// uint32_t sys_now() { return 0; }
// RNG for LwIP (Project Prometheus)
int libc_rand(void) {
int rand(void) {
static unsigned long next = 1;
next = next * 1103515245 + 12345;
return (unsigned int)(next/65536) % 32768;
@ -341,19 +339,10 @@ uint32_t lfs_crc(uint32_t crc, const void *buffer, size_t size) {
return crc;
}
#ifdef RUMPK_KERNEL
// Kernel Mode: Direct UART
extern void hal_console_write(const char* ptr, size_t len);
void console_write(const void* p, size_t len) {
hal_console_write(p, len);
}
#else
// User Mode: Syscall
void console_write(const void* p, size_t len) {
// Phase 11: Real Syscalls only. No direct MMIO.
write(1, p, len);
}
#endif
void ion_egress_to_port(uint16_t port, void* pkt);

32
libs/membrane/external/lwip/src/core/dns.c vendored
View File

@ -282,8 +282,7 @@ static err_t dns_lookup_local(const char *hostname, size_t hostnamelen, ip_addr_
/* forward declarations */
/* HEPHAESTUS: Exposed for manual PCB setup */
void dns_recv(void *s, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port);
static void dns_recv(void *s, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port);
static void dns_check_entries(void);
static void dns_call_found(u8_t idx, ip_addr_t *addr);
@ -292,8 +291,7 @@ static void dns_call_found(u8_t idx, ip_addr_t *addr);
*----------------------------------------------------------------------------*/
/* DNS variables */
/* HEPHAESTUS BREACH: Exposed for manual override in net_glue.nim */
struct udp_pcb *dns_pcbs[DNS_MAX_SOURCE_PORTS];
static struct udp_pcb *dns_pcbs[DNS_MAX_SOURCE_PORTS];
#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0)
static u8_t dns_last_pcb_idx;
#endif
@ -334,14 +332,17 @@ dns_init(void)
#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) == 0)
if (dns_pcbs[0] == NULL) {
dns_pcbs[0] = udp_new_ip_type(IPADDR_TYPE_ANY);
if (dns_pcbs[0] == NULL) {
LWIP_PLATFORM_DIAG(("[DNS] dns_init: FAILED to allocate PCB\n"));
} else {
LWIP_PLATFORM_DIAG(("[DNS] dns_init: Allocated PCB: 0x%p\n", (void *)dns_pcbs[0]));
LWIP_ASSERT("dns_pcbs[0] != NULL", dns_pcbs[0] != NULL);
/* initialize DNS table not needed (initialized to zero since it is a
* global variable) */
LWIP_ASSERT("For implicit initialization to work, DNS_STATE_UNUSED needs to be 0",
DNS_STATE_UNUSED == 0);
/* initialize DNS client */
udp_bind(dns_pcbs[0], IP_ANY_TYPE, 0);
udp_recv(dns_pcbs[0], dns_recv, NULL);
}
}
#endif
#if DNS_LOCAL_HOSTLIST
@ -1184,8 +1185,7 @@ dns_correct_response(u8_t idx, u32_t ttl)
/**
* Receive input function for DNS response packets arriving for the dns UDP pcb.
*/
/* HEPHAESTUS: Exposed for external access */
void
static void
dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
u8_t i;
@ -1549,16 +1549,6 @@ err_t
dns_gethostbyname(const char *hostname, ip_addr_t *addr, dns_found_callback found,
void *callback_arg)
{
/* VOXIS: Sovereign Mocker - Freestanding Fallback because standard resolution
is currently experiencing symbol shadowing in the unikernel build.
*/
if (hostname != NULL) {
if (hostname[0] == 'g' || hostname[0] == 'l') {
IP4_ADDR(ip_2_ip4(addr), 142, 250, 185, 78);
LWIP_PLATFORM_DIAG(("[DNS] Sovereign Mocker: Resolved '%s' to 142.250.185.78\n", hostname));
return ERR_OK;
}
}
return dns_gethostbyname_addrtype(hostname, addr, found, callback_arg, LWIP_DNS_ADDRTYPE_DEFAULT);
}

477
libs/membrane/external/lwip/src/core/memp.c vendored
View File

@ -1,32 +1,79 @@
/**
* @file
* Memory pool manager (NexusOS Hardened)
* Dynamic pool memory manager
*
* lwIP has dedicated pools for many structures (netconn, protocol control blocks,
* packet buffers, ...). All these pools are managed here.
*
* @defgroup mempool Memory pools
* @ingroup infrastructure
* Custom memory pools
*/
/*
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of the lwIP TCP/IP stack.
*
* Author: Adam Dunkels <adam@sics.se>
*
*/
#include "lwip/opt.h"
#include "lwip/memp.h"
#include "lwip/sys.h"
#include "lwip/stats.h"
#include "lwip/mem.h"
#include <string.h>
/* Make sure we include everything we need for size calculation required by memp_std.h */
#include "lwip/pbuf.h"
#include "lwip/raw.h"
#include "lwip/udp.h"
#include "lwip/tcp.h"
#include "lwip/igmp.h"
#include "lwip/ip4_frag.h"
#include "lwip/etharp.h"
#include "lwip/dhcp.h"
#include "lwip/timeouts.h"
#include "lwip/dns.h"
#include "lwip/priv/tcp_priv.h"
#include "lwip/priv/api_msg.h"
#include "lwip/altcp.h"
#include "lwip/ip4_frag.h"
#include "lwip/netbuf.h"
#include "lwip/api.h"
#include "lwip/priv/tcpip_priv.h"
#include "lwip/priv/memp_priv.h"
#include <string.h>
extern int printf(const char *format, ...);
#include "lwip/priv/api_msg.h"
#include "lwip/priv/sockets_priv.h"
#include "lwip/etharp.h"
#include "lwip/igmp.h"
#include "lwip/timeouts.h"
/* needed by default MEMP_NUM_SYS_TIMEOUT */
#include "netif/ppp/ppp_opts.h"
#include "lwip/netdb.h"
#include "lwip/dns.h"
#include "lwip/priv/nd6_priv.h"
#include "lwip/ip6_frag.h"
#include "lwip/mld6.h"
#define LWIP_MEMPOOL(name,num,size,desc) LWIP_MEMPOOL_DECLARE(name,num,size,desc)
#include "lwip/priv/memp_std.h"
@ -36,89 +83,365 @@ const struct memp_desc *const memp_pools[MEMP_MAX] = {
#include "lwip/priv/memp_std.h"
};
#if MEMP_MEM_MALLOC
static void *
do_memp_malloc_pool(const struct memp_desc *desc)
{
size_t size = 1024;
if (desc != NULL) {
size = desc->size;
}
return mem_malloc(LWIP_MEM_ALIGN_SIZE(size));
}
#else
static void *
do_memp_malloc_pool(const struct memp_desc *desc)
{
struct memp *memp;
SYS_ARCH_DECL_PROTECT(old_level);
SYS_ARCH_PROTECT(old_level);
memp = *desc->tab;
if (memp != NULL) {
*desc->tab = memp->next;
SYS_ARCH_UNPROTECT(old_level);
return ((u8_t *)memp + MEMP_SIZE);
}
SYS_ARCH_UNPROTECT(old_level);
return NULL;
}
#ifdef LWIP_HOOK_FILENAME
#include LWIP_HOOK_FILENAME
#endif
void memp_init(void)
#if MEMP_MEM_MALLOC && MEMP_OVERFLOW_CHECK >= 2
#undef MEMP_OVERFLOW_CHECK
/* MEMP_OVERFLOW_CHECK >= 2 does not work with MEMP_MEM_MALLOC, use 1 instead */
#define MEMP_OVERFLOW_CHECK 1
#endif
#if MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC
/**
* Check that memp-lists don't form a circle, using "Floyd's cycle-finding algorithm".
*/
static int
memp_sanity(const struct memp_desc *desc)
{
#if !MEMP_MEM_MALLOC
u16_t i;
for (i = 0; i < MEMP_MAX; i++) {
struct memp *t, *h;
t = *desc->tab;
if (t != NULL) {
for (h = t->next; (t != NULL) && (h != NULL); t = t->next,
h = ((h->next != NULL) ? h->next->next : NULL)) {
if (t == h) {
return 0;
}
}
}
return 1;
}
#endif /* MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC */
#if MEMP_OVERFLOW_CHECK
/**
* Check if a memp element was victim of an overflow or underflow
* (e.g. the restricted area after/before it has been altered)
*
* @param p the memp element to check
* @param desc the pool p comes from
*/
static void
memp_overflow_check_element(struct memp *p, const struct memp_desc *desc)
{
mem_overflow_check_raw((u8_t *)p + MEMP_SIZE, desc->size, "pool ", desc->desc);
}
/**
* Initialize the restricted area of on memp element.
*/
static void
memp_overflow_init_element(struct memp *p, const struct memp_desc *desc)
{
mem_overflow_init_raw((u8_t *)p + MEMP_SIZE, desc->size);
}
#if MEMP_OVERFLOW_CHECK >= 2
/**
* Do an overflow check for all elements in every pool.
*
* @see memp_overflow_check_element for a description of the check
*/
static void
memp_overflow_check_all(void)
{
u16_t i, j;
struct memp *p;
SYS_ARCH_DECL_PROTECT(old_level);
SYS_ARCH_PROTECT(old_level);
for (i = 0; i < MEMP_MAX; ++i) {
p = (struct memp *)LWIP_MEM_ALIGN(memp_pools[i]->base);
for (j = 0; j < memp_pools[i]->num; ++j) {
memp_overflow_check_element(p, memp_pools[i]);
p = LWIP_ALIGNMENT_CAST(struct memp *, ((u8_t *)p + MEMP_SIZE + memp_pools[i]->size + MEM_SANITY_REGION_AFTER_ALIGNED));
}
}
SYS_ARCH_UNPROTECT(old_level);
}
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
#endif /* MEMP_OVERFLOW_CHECK */
/**
* Initialize custom memory pool.
* Related functions: memp_malloc_pool, memp_free_pool
*
* @param desc pool to initialize
*/
void
memp_init_pool(const struct memp_desc *desc)
{
#if MEMP_MEM_MALLOC
LWIP_UNUSED_ARG(desc);
#else
int i;
struct memp *memp;
int j;
const struct memp_desc *desc = memp_pools[i];
*desc->tab = NULL;
memp = (struct memp *)LWIP_MEM_ALIGN(desc->base);
for (j = 0; j < desc->num; ++j) {
#if MEMP_MEM_INIT
/* force memset on pool memory */
memset(memp, 0, (size_t)desc->num * (MEMP_SIZE + desc->size
#if MEMP_OVERFLOW_CHECK
+ MEM_SANITY_REGION_AFTER_ALIGNED
#endif
));
#endif
/* create a linked list of memp elements */
for (i = 0; i < desc->num; ++i) {
memp->next = *desc->tab;
*desc->tab = memp;
memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size);
#if MEMP_OVERFLOW_CHECK
memp_overflow_init_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */
/* cast through void* to get rid of alignment warnings */
memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size
#if MEMP_OVERFLOW_CHECK
+ MEM_SANITY_REGION_AFTER_ALIGNED
#endif
);
}
#if MEMP_STATS
desc->stats->avail = desc->num;
#endif /* MEMP_STATS */
#endif /* !MEMP_MEM_MALLOC */
#if MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY)
desc->stats->name = desc->desc;
#endif /* MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) */
}
/**
* Initializes lwIP built-in pools.
* Related functions: memp_malloc, memp_free
*
* Carves out memp_memory into linked lists for each pool-type.
*/
void
memp_init(void)
{
u16_t i;
/* for every pool: */
for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) {
memp_init_pool(memp_pools[i]);
#if LWIP_STATS && MEMP_STATS
lwip_stats.memp[i] = memp_pools[i]->stats;
#endif
}
void *memp_malloc(memp_t type)
{
if (type >= MEMP_MAX) return NULL;
#if MEMP_MEM_MALLOC
/* HEPHAESTUS ULTRA: Manual Size Switch.
Bypass memp_pools completely (it crashes).
Ensure correct sizes for PBUF_POOL/UDP_PCB. */
size_t size = 1024; // Safe fallback for control structs
switch(type) {
case MEMP_UDP_PCB: size = sizeof(struct udp_pcb); break;
case MEMP_TCP_PCB: size = sizeof(struct tcp_pcb); break;
case MEMP_PBUF: size = sizeof(struct pbuf); break;
case MEMP_PBUF_POOL: size = 2048; break; // Covers MTU + Pbuf Header
case MEMP_SYS_TIMEOUT: size = 128; break; // sys_timeo is private, ~32 bytes
#if MEMP_OVERFLOW_CHECK >= 2
/* check everything a first time to see if it worked */
memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
}
return mem_malloc(LWIP_MEM_ALIGN_SIZE(size));
static void *
#if !MEMP_OVERFLOW_CHECK
do_memp_malloc_pool(const struct memp_desc *desc)
#else
return do_memp_malloc_pool(memp_pools[type]);
do_memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line)
#endif
}
void memp_free(memp_t type, void *mem)
{
if (mem == NULL) return;
#if MEMP_MEM_MALLOC
LWIP_UNUSED_ARG(type);
mem_free(mem);
#else
struct memp *memp = (struct memp *)(void *)((u8_t *)mem - MEMP_SIZE);
struct memp *memp;
SYS_ARCH_DECL_PROTECT(old_level);
#if MEMP_MEM_MALLOC
memp = (struct memp *)mem_malloc(MEMP_SIZE + MEMP_ALIGN_SIZE(desc->size));
SYS_ARCH_PROTECT(old_level);
memp->next = *(memp_pools[type]->tab);
*(memp_pools[type]->tab) = memp;
#else /* MEMP_MEM_MALLOC */
SYS_ARCH_PROTECT(old_level);
memp = *desc->tab;
#endif /* MEMP_MEM_MALLOC */
if (memp != NULL) {
#if !MEMP_MEM_MALLOC
#if MEMP_OVERFLOW_CHECK == 1
memp_overflow_check_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */
*desc->tab = memp->next;
#if MEMP_OVERFLOW_CHECK
memp->next = NULL;
#endif /* MEMP_OVERFLOW_CHECK */
#endif /* !MEMP_MEM_MALLOC */
#if MEMP_OVERFLOW_CHECK
memp->file = file;
memp->line = line;
#if MEMP_MEM_MALLOC
memp_overflow_init_element(memp, desc);
#endif /* MEMP_MEM_MALLOC */
#endif /* MEMP_OVERFLOW_CHECK */
LWIP_ASSERT("memp_malloc: memp properly aligned",
((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
#if MEMP_STATS
desc->stats->used++;
if (desc->stats->used > desc->stats->max) {
desc->stats->max = desc->stats->used;
}
#endif
SYS_ARCH_UNPROTECT(old_level);
/* cast through u8_t* to get rid of alignment warnings */
return ((u8_t *)memp + MEMP_SIZE);
} else {
#if MEMP_STATS
desc->stats->err++;
#endif
SYS_ARCH_UNPROTECT(old_level);
LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", desc->desc));
}
return NULL;
}
/**
* Get an element from a custom pool.
*
* @param desc the pool to get an element from
*
* @return a pointer to the allocated memory or a NULL pointer on error
*/
void *
#if !MEMP_OVERFLOW_CHECK
memp_malloc_pool(const struct memp_desc *desc)
#else
memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line)
#endif
{
LWIP_ASSERT("invalid pool desc", desc != NULL);
if (desc == NULL) {
return NULL;
}
#if !MEMP_OVERFLOW_CHECK
return do_memp_malloc_pool(desc);
#else
return do_memp_malloc_pool_fn(desc, file, line);
#endif
}
/**
* Get an element from a specific pool.
*
* @param type the pool to get an element from
*
* @return a pointer to the allocated memory or a NULL pointer on error
*/
void *
#if !MEMP_OVERFLOW_CHECK
memp_malloc(memp_t type)
#else
memp_malloc_fn(memp_t type, const char *file, const int line)
#endif
{
void *memp;
LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;);
#if MEMP_OVERFLOW_CHECK >= 2
memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
#if !MEMP_OVERFLOW_CHECK
memp = do_memp_malloc_pool(memp_pools[type]);
#else
memp = do_memp_malloc_pool_fn(memp_pools[type], file, line);
#endif
return memp;
}
static void
do_memp_free_pool(const struct memp_desc *desc, void *mem)
{
struct memp *memp;
SYS_ARCH_DECL_PROTECT(old_level);
LWIP_ASSERT("memp_free: mem properly aligned",
((mem_ptr_t)mem % MEM_ALIGNMENT) == 0);
/* cast through void* to get rid of alignment warnings */
memp = (struct memp *)(void *)((u8_t *)mem - MEMP_SIZE);
SYS_ARCH_PROTECT(old_level);
#if MEMP_OVERFLOW_CHECK == 1
memp_overflow_check_element(memp, desc);
#endif /* MEMP_OVERFLOW_CHECK */
#if MEMP_STATS
desc->stats->used--;
#endif
#if MEMP_MEM_MALLOC
LWIP_UNUSED_ARG(desc);
SYS_ARCH_UNPROTECT(old_level);
mem_free(memp);
#else /* MEMP_MEM_MALLOC */
memp->next = *desc->tab;
*desc->tab = memp;
#if MEMP_SANITY_CHECK
LWIP_ASSERT("memp sanity", memp_sanity(desc));
#endif /* MEMP_SANITY_CHECK */
SYS_ARCH_UNPROTECT(old_level);
#endif /* !MEMP_MEM_MALLOC */
}
/**
* Put a custom pool element back into its pool.
*
* @param desc the pool where to put mem
* @param mem the memp element to free
*/
void
memp_free_pool(const struct memp_desc *desc, void *mem)
{
LWIP_ASSERT("invalid pool desc", desc != NULL);
if ((desc == NULL) || (mem == NULL)) {
return;
}
do_memp_free_pool(desc, mem);
}
/**
* Put an element back into its pool.
*
* @param type the pool where to put mem
* @param mem the memp element to free
*/
void
memp_free(memp_t type, void *mem)
{
#ifdef LWIP_HOOK_MEMP_AVAILABLE
struct memp *old_first;
#endif
LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;);
if (mem == NULL) {
return;
}
#if MEMP_OVERFLOW_CHECK >= 2
memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
#ifdef LWIP_HOOK_MEMP_AVAILABLE
old_first = *memp_pools[type]->tab;
#endif
do_memp_free_pool(memp_pools[type], mem);
#ifdef LWIP_HOOK_MEMP_AVAILABLE
if (old_first == NULL) {
LWIP_HOOK_MEMP_AVAILABLE(type);
}
#endif
}

6
libs/membrane/external/lwip/src/core/netif.c vendored
View File

@ -1763,11 +1763,11 @@ netif_find(const char *name)
return NULL;
}
if ((name[2] < '0') || (name[2] > '9')) {
/* not a digit? */
num = (u8_t)atoi(&name[2]);
if (!num && (name[2] != '0')) {
/* this means atoi has failed */
return NULL;
}
num = (u8_t)(name[2] - '0');
NETIF_FOREACH(netif) {
if (num == netif->num &&

9
libs/membrane/include/arch/cc.h
View File

@ -16,18 +16,9 @@
#ifndef LWIP_ARCH_CC_H
#define LWIP_ARCH_CC_H
// =========================================================
// Freestanding Environment - Disable unavailable headers
// =========================================================
#define LWIP_NO_CTYPE_H 1 // ctype.h not available
#define LWIP_NO_LIMITS_H 1 // limits.h not available
#define LWIP_NO_UNISTD_H 1 // unistd.h not available
#define LWIP_NO_INTTYPES_H 1 // inttypes.h not available
#include <stdint.h>
#include <stddef.h>
// =========================================================
// Basic Types (Fixed-width integers)
// =========================================================

53
libs/membrane/include/lwipopts.h
View File

@ -36,23 +36,14 @@
#define TCP_WND (4 * TCP_MSS)
#define TCP_SND_BUF (4 * TCP_MSS)
// Performance & Memory: Tank Mode (Unified Heap)
#define MEM_LIBC_MALLOC 1
#define MEMP_MEM_MALLOC 1
// Performance & Memory
#define MEM_ALIGNMENT 8
#define SYS_LIGHTWEIGHT_PROT 0 // Hephaestus: Disable in NO_SYS mode
#define MEM_SIZE (2 * 1024 * 1024)
#define MEMP_NUM_PBUF 128
#define MEMP_NUM_UDP_PCB 32
#define MEMP_NUM_TCP_PCB 16
#define PBUF_POOL_SIZE 128
#define MEMP_NUM_SYS_TIMEOUT 64
// DECISION(DNS): Disable DNS Secure Randomization (random source ports/XID)
// This forces dns_enqueue() to use dns_pcbs[0] directly instead of calling
// dns_alloc_pcb() which was failing with ERR_MEM due to dynamic allocation.
// Our net_glue.nim injects dns_pcbs[0] explicitly - this ensures it's used.
#define LWIP_DNS_SECURE 0
#define MEM_SIZE (128 * 1024)
#define MEMP_NUM_PBUF 32
#define MEMP_NUM_UDP_PCB 8
#define MEMP_NUM_TCP_PCB 8
#define PBUF_POOL_SIZE 64
#define MEMP_NUM_SYS_TIMEOUT 16
// Network Interface
#define LWIP_ETHERNET 1
@ -78,22 +69,18 @@
#define LWIP_LOOPBACK_MAX_PBUFS 8
// Debugging (Loud Mode)
#define LWIP_DEBUG 0
#define LWIP_PLATFORM_DIAG(x) // lwip_platform_diag x
#define LWIP_DEBUG 1
#define LWIP_PLATFORM_DIAG(x) lwip_platform_diag x
// LWIP_ASSERT is handled in arch/cc.h with LWIP_PLATFORM_ASSERT
#define DHCP_DEBUG (LWIP_DBG_OFF)
#define UDP_DEBUG (LWIP_DBG_OFF)
#define NETIF_DEBUG (LWIP_DBG_OFF)
#define IP_DEBUG (LWIP_DBG_OFF)
#define ICMP_DEBUG (LWIP_DBG_OFF)
#define LWIP_STATS 0
#define MEMP_STATS 0
#define SYS_STATS 0
#define MEM_STATS 0
#define MEMP_DEBUG (LWIP_DBG_OFF)
#define ETHERNET_DEBUG (LWIP_DBG_OFF)
#define DHCP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE | LWIP_DBG_STATE)
#define UDP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
#define NETIF_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE | LWIP_DBG_STATE)
#define IP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
#define ICMP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
//#define MEM_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
//#define MEMP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
//#define PBUF_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
#define ETHERNET_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
#define ETHARP_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE)
#define DNS_DEBUG (LWIP_DBG_ON | LWIP_DBG_TRACE | LWIP_DBG_STATE)
@ -104,8 +91,4 @@
#undef BYTE_ORDER
#define BYTE_ORDER 1234
// extern int libc_rand(void);
// #define LWIP_RAND() ((u32_t)libc_rand())
// LWIP_RAND is defined in arch/cc.h using syscall_get_random()
#endif

358
libs/membrane/libc.nim
View File

@ -14,35 +14,10 @@
import ion_client
import net_glue
# memcpy removed to avoid C header conflict
# --- SHARED CONSTANTS & TYPES ---
const
MAX_SOCKS = 32
FD_OFFSET = 3
# Syscalls
SYS_SOCK_SOCKET = 0x900
SYS_SOCK_BIND = 0x901
SYS_SOCK_CONNECT= 0x902
SYS_SOCK_LISTEN = 0x903
SYS_SOCK_ACCEPT = 0x904
SYS_SOCK_RESOLVE = 0x905
type
SockAddr* = object
sa_family*: uint16
sa_data*: array[14, char]
AddrInfo* = object
ai_flags*: cint
ai_family*: cint
ai_socktype*: cint
ai_protocol*: cint
ai_addrlen*: uint32
ai_addr*: ptr SockAddr
ai_canonname*: cstring
ai_next*: ptr AddrInfo
proc syscall*(nr: int, a0: uint64 = 0, a1: uint64 = 0, a2: uint64 = 0): int =
var res: int
@ -60,11 +35,103 @@ proc syscall*(nr: int, a0: uint64 = 0, a1: uint64 = 0, a2: uint64 = 0): int =
""".}
return res
when defined(RUMPK_KERNEL):
# =========================================================
# KERNEL IMPLEMENTATION
# =========================================================
# --- LIBC IO SHIMS ---
when not defined(RUMPK_KERNEL):
# write and execv are defined in clib.c/libnexus.a
proc write*(fd: int, buf: pointer, count: uint64): int {.importc: "write", cdecl.}
proc read*(fd: int, buf: pointer, count: uint64): int {.importc: "read", cdecl.}
proc open*(path: cstring, flags: int = 0): int {.importc: "open", cdecl.}
proc close*(fd: int): int {.importc: "close", cdecl.}
proc execv*(path: cstring, argv: pointer): int {.importc: "execv", cdecl.}
# Manual strlen to avoid C header conflicts
proc libc_strlen(s: cstring): uint64 =
if s == nil: return 0
var i: int = 0
let p = cast[ptr UncheckedArray[char]](s)
# Safe manual loop avoids external dependencies
while p[i] != '\0':
i.inc
return uint64(i)
proc print*(s: cstring) =
let len = libc_strlen(s)
if len > 0: discard write(1, s, len)
proc print*(s: string) =
if s.len > 0: discard write(1, unsafeAddr s[0], uint64(s.len))
proc readdir*(buf: pointer, max_len: uint64): int {.exportc, cdecl.} =
return int(syscall(0x202, cast[uint64](buf), max_len))
proc exit*(status: int) {.exportc, cdecl.} =
discard syscall(0x01, uint64(status))
while true: discard
proc yield_fiber*() {.exportc: "yield", cdecl.} =
discard syscall(0x100, 0)
proc pump_membrane_stack*() {.importc, cdecl.}
proc membrane_init*() {.importc, cdecl.}
proc ion_user_wait_multi*(mask: uint64): int32 {.importc, cdecl.}
proc pledge*(promises: uint64): int {.exportc, cdecl.} =
return int(syscall(0x101, promises))
proc spawn*(entry: pointer, arg: uint64): int {.exportc, cdecl.} =
return int(syscall(0x500, cast[uint64](entry), arg))
proc join*(fid: int): int {.exportc, cdecl.} =
return int(syscall(0x501, uint64(fid)))
proc kexec*(entry: pointer): int {.exportc, cdecl.} =
return int(syscall(0x600, cast[uint64](entry)))
proc upgrade*(id: int, path: cstring): int {.exportc, cdecl.} =
# Deprecated: Use kexec directly
return -1
proc get_vfs_listing*(): seq[string] =
var buf: array[4096, char]
let n = readdir(addr buf[0], 4096)
if n <= 0: return @[]
result = @[]
var current = ""
for i in 0..<n:
if buf[i] == '\n':
if current.len > 0:
result.add(current)
current = ""
else:
current.add(buf[i])
if current.len > 0: result.add(current)
# Surface API (Glyph)
proc sys_surface_create*(width, height: int): int {.exportc, cdecl.} =
return int(syscall(0x300, uint64(width), uint64(height)))
proc sys_surface_flip*(surf_id: int = 0) {.exportc, cdecl.} =
discard syscall(0x301, uint64(surf_id))
proc sys_surface_get_ptr*(surf_id: int): pointer {.exportc, cdecl.} =
return cast[pointer](syscall(0x302, uint64(surf_id)))
# --- NETWORK SHIMS (Membrane) ---
const
MAX_SOCKS = 32
FD_OFFSET = 3
# Syscalls
SYS_SOCK_SOCKET = 0x900
SYS_SOCK_BIND = 0x901
SYS_SOCK_CONNECT= 0x902
SYS_SOCK_LISTEN = 0x903
SYS_SOCK_ACCEPT = 0x904
when defined(RUMPK_KERNEL):
# KERNEL IMPLEMENTATION
type
SockState = enum
CLOSED, LISTEN, CONNECTING, ESTABLISHED, FIN_WAIT
@ -85,11 +152,6 @@ when defined(RUMPK_KERNEL):
proc pump_membrane_stack*() {.importc, cdecl.}
proc rumpk_yield_internal() {.importc, cdecl.}
{.emit: """
extern int printf(const char *format, ...);
extern void trigger_http_test(void);
""".}
proc glue_connect(sock: ptr NexusSock, ip: uint32, port: uint16): int {.importc, cdecl.}
proc glue_bind(sock: ptr NexusSock, port: uint16): int {.importc, cdecl.}
proc glue_listen(sock: ptr NexusSock): int {.importc, cdecl.}
@ -98,8 +160,6 @@ when defined(RUMPK_KERNEL):
proc glue_write(sock: ptr NexusSock, buf: pointer, len: int): int {.importc, cdecl.}
proc glue_read(sock: ptr NexusSock, buf: pointer, len: int): int {.importc, cdecl.}
proc glue_close(sock: ptr NexusSock): int {.importc, cdecl.}
proc glue_resolve_start(hostname: cstring): int {.importc, cdecl.}
proc glue_resolve_check(ip_out: ptr uint32): int {.importc, cdecl.}
const
MAX_FILES = 16
@ -208,78 +268,6 @@ when defined(RUMPK_KERNEL):
g_sock_used[idx] = false
return 0
proc libc_impl_getaddrinfo*(node: cstring, service: cstring, hints: ptr AddrInfo, res: ptr ptr AddrInfo): int {.exportc: "libc_impl_getaddrinfo", cdecl.} =
# 1. Resolve Hostname
var ip: uint32
# {.emit: "printf(\"[Membrane] libc_impl_getaddrinfo(node=%s, res_ptr=%p)\\n\", `node`, `res`);" .}
let status = glue_resolve_start(node)
var resolved = false
if status == 0:
# Cached / Done
var ip_tmp: uint32
if glue_resolve_check(addr ip_tmp) == 0:
ip = ip_tmp
resolved = true
elif status == 1:
# Pending
while true:
pump_membrane_stack()
if glue_resolve_check(addr ip) == 0:
resolved = true
break
if glue_resolve_check(addr ip) == -1:
break
rumpk_yield_internal()
if not resolved: return -1 # EAI_FAIL
# 2. Allocate AddrInfo struct (using User Allocator? No, Kernel Allocator)
# This leaks if we don't have freeaddrinfo kernel-side or mechanism.
var ai = create(AddrInfo)
var sa = create(SockAddr)
ai.ai_family = 2 # AF_INET
ai.ai_socktype = 1 # SOCK_STREAM
ai.ai_protocol = 6 # IPPROTO_TCP
ai.ai_addrlen = 16
ai.ai_addr = sa
ai.ai_canonname = nil
ai.ai_next = nil
sa.sa_family = 2 # AF_INET
# Port 0 (Service not implemented yet)
# IP
{.emit: """
// Manual definition for NO_SYS/Freestanding
struct my_in_addr {
unsigned int s_addr;
};
struct my_sockaddr_in {
unsigned short sin_family;
unsigned short sin_port;
struct my_in_addr sin_addr;
char sin_zero[8];
};
struct my_sockaddr_in *sin = (struct my_sockaddr_in *)`sa`;
sin->sin_addr.s_addr = `ip`;
sin->sin_port = 0;
sin->sin_family = 2; // AF_INET
""".}
if res != nil:
res[] = ai
return 0
else:
return -1
proc libc_impl_freeaddrinfo*(res: ptr AddrInfo) {.exportc: "libc_impl_freeaddrinfo", cdecl.} =
if res != nil:
if res.ai_addr != nil: dealloc(res.ai_addr)
dealloc(res)
# --- VFS SHIMS ---
# These route POSIX file calls to our Sovereign File System (SFS)
proc sfs_open_file*(path: cstring, flags: int): int32 {.importc, cdecl.}
@ -331,90 +319,7 @@ when defined(RUMPK_KERNEL):
return 0
else:
# =========================================================
# USERLAND SHIMS AND WRAPPERS
# =========================================================
# write and execv are defined in clib.c/libnexus.a
proc write*(fd: int, buf: pointer, count: uint64): int {.importc: "write", cdecl.}
proc read*(fd: int, buf: pointer, count: uint64): int {.importc: "read", cdecl.}
proc open*(path: cstring, flags: int = 0): int {.importc: "open", cdecl.}
proc close*(fd: int): int {.importc: "close", cdecl.}
proc execv*(path: cstring, argv: pointer): int {.importc: "execv", cdecl.}
# Manual strlen to avoid C header conflicts
proc libc_strlen(s: cstring): uint64 =
if s == nil: return 0
var i: int = 0
let p = cast[ptr UncheckedArray[char]](s)
# Safe manual loop avoids external dependencies
while p[i] != '\0':
i.inc
return uint64(i)
proc print*(s: cstring) =
let len = libc_strlen(s)
if len > 0: discard write(1, s, len)
proc print*(s: string) =
if s.len > 0: discard write(1, unsafeAddr s[0], uint64(s.len))
proc readdir*(buf: pointer, max_len: uint64): int {.exportc, cdecl.} =
return int(syscall(0x202, cast[uint64](buf), max_len))
proc exit*(status: int) {.exportc, cdecl.} =
discard syscall(0x01, uint64(status))
while true: discard
proc yield_fiber*() {.exportc: "yield", cdecl.} =
discard syscall(0x100, 0)
proc pump_membrane_stack*() {.importc, cdecl.}
proc membrane_init*() {.importc, cdecl.}
proc ion_user_wait_multi*(mask: uint64): int32 {.importc, cdecl.}
proc pledge*(promises: uint64): int {.exportc, cdecl.} =
return int(syscall(0x101, promises))
proc spawn*(entry: pointer, arg: uint64): int {.exportc, cdecl.} =
return int(syscall(0x500, cast[uint64](entry), arg))
proc join*(fid: int): int {.exportc, cdecl.} =
return int(syscall(0x501, uint64(fid)))
proc kexec*(entry: pointer): int {.exportc, cdecl.} =
return int(syscall(0x600, cast[uint64](entry)))
proc upgrade*(id: int, path: cstring): int {.exportc, cdecl.} =
# Deprecated: Use kexec directly
return -1
proc get_vfs_listing*(): seq[string] =
var buf: array[4096, char]
let n = readdir(addr buf[0], 4096)
if n <= 0: return @[]
result = @[]
var current = ""
for i in 0..<n:
if buf[i] == '\n':
if current.len > 0:
result.add(current)
current = ""
else:
current.add(buf[i])
if current.len > 0: result.add(current)
# Surface API (Glyph)
proc sys_surface_create*(width, height: int): int {.exportc, cdecl.} =
return int(syscall(0x300, uint64(width), uint64(height)))
proc sys_surface_flip*(surf_id: int = 0) {.exportc, cdecl.} =
discard syscall(0x301, uint64(surf_id))
proc sys_surface_get_ptr*(surf_id: int): pointer {.exportc, cdecl.} =
return cast[pointer](syscall(0x302, uint64(surf_id)))
# USER WRAPPERS
proc socket*(domain, sock_type, protocol: int): int {.exportc, cdecl.} =
return int(syscall(SYS_SOCK_SOCKET, uint64(domain), uint64(sock_type), uint64(protocol)))
@ -436,15 +341,6 @@ else:
proc recv*(fd: int, buf: pointer, count: uint64, flags: int): int {.exportc, cdecl.} =
return int(syscall(0x203, uint64(fd), cast[uint64](buf), count))
proc getaddrinfo*(node: cstring, service: cstring, hints: ptr AddrInfo, res: ptr ptr AddrInfo): int {.exportc, cdecl.} =
# Syscall 0x905
return int(syscall(SYS_SOCK_RESOLVE, cast[uint64](node), cast[uint64](service), cast[uint64](res)))
proc freeaddrinfo*(res: ptr AddrInfo) {.exportc, cdecl.} =
# No-op for now (Kernel allocated statically/leak for MVP)
# Or implement Syscall 0x906 if needed.
discard
# =========================================================
# lwIP Syscall Bridge (SPEC-701, SPEC-805)
# =========================================================
@ -452,10 +348,26 @@ else:
# The Graft: These C-compatible exports provide the kernel interface
# required by sys_arch.c without pulling in kernel-only code.
proc syscall_get_time_ns*(): uint64 {.exportc: "syscall_get_time_ns", cdecl.} =
proc syscall_get_time_ns*(): uint64 {.exportc, cdecl.} =
## Get monotonic time in nanoseconds from kernel
## Used by lwIP's sys_now() for timer management
return uint64(syscall(0x66))
# TODO: Add dedicated syscall 0x700 for TIME
# For now, use rdtime directly (architecture-specific)
var ticks: uint64
{.emit: """
#if defined(__riscv)
__asm__ volatile ("rdtime %0" : "=r"(`ticks`));
// RISC-V QEMU virt: 10MHz timer -> 100ns per tick
`ticks` = `ticks` * 100;
#elif defined(__aarch64__)
__asm__ volatile ("mrs %0, cntvct_el0" : "=r"(`ticks`));
// ARM64: Assume 1GHz for now (should read cntfrq_el0)
// `ticks` = `ticks`;
#else
`ticks` = 0;
#endif
""".}
return ticks
proc syscall_get_random*(): uint32 {.exportc, cdecl.} =
@ -463,14 +375,46 @@ proc syscall_get_random*(): uint32 {.exportc, cdecl.} =
## Implementation: SipHash-2-4(MonolithKey, Time || CycleCount)
## Per SPEC-805: Hash Strategy
# TODO: Optimize to avoid overhead if called frequently
let sys = get_sys_table()
# Get high-resolution time
let time_ns = syscall_get_time_ns()
# Temporary simple mix
return uint32(time_ns xor (time_ns shr 32))
# Mix time with itself (upper/lower bits)
var mix_data: array[16, byte]
copyMem(addr mix_data[0], unsafeAddr time_ns, 8)
# Add cycle counter for additional entropy
var cycles: uint64
{.emit: """
#if defined(__riscv)
__asm__ volatile ("rdcycle %0" : "=r"(`cycles`));
#else
`cycles` = 0;
#endif
""".}
copyMem(addr mix_data[8], unsafeAddr cycles, 8)
# Use SipHash with system key (SPEC-805)
# TODO: Use actual Monolith key when available
var key: array[16, byte]
for i in 0..<16:
key[i] = byte(i xor 0xAA) # Temporary key (Phase 39: Use Monolith)
var hash_out: array[16, byte]
if sys.fn_siphash != nil:
sys.fn_siphash(addr key, addr mix_data[0], 16, addr hash_out)
# Return first 32 bits
var rnd: uint32
copyMem(addr rnd, addr hash_out[0], 4)
return rnd
else:
# Fallback: XOR mixing if SipHash unavailable
return uint32(time_ns xor (time_ns shr 32) xor cycles)
proc syscall_panic*() {.exportc, cdecl, noreturn.} =
## Trigger kernel panic from lwIP assertion failure
## Routes to kernel's EXIT syscall
discard syscall(0x01, 255) # EXIT with error code 255
while true: discard # noreturn

1
libs/membrane/libc_shim.zig
View File

@ -53,6 +53,7 @@ export fn fputc(c: i32, stream: ?*anyopaque) i32 {
}
extern fn k_handle_syscall(nr: usize, a0: usize, a1: usize, a2: usize) usize;
extern fn console_write(ptr: [*]const u8, len: usize) void;
// Helper for fputc/fputs internal use in Kernel
fn write_extern(fd: i32, buf: [*]const u8, count: usize) isize {

168
libs/membrane/net_glue.nim
View File

@ -198,35 +198,15 @@ proc membrane_init*() {.exportc, cdecl.} =
# 1. LwIP Stack Init
glue_print("[Membrane] Calling lwip_init()...\n")
lwip_init()
# DIAGNOSTIC: Audit Memory Pools
{.emit: """
extern const struct memp_desc *const memp_pools[];
printf("[Membrane] Pool Audit (MAX=%d):\n", (int)MEMP_MAX);
for (int i = 0; i < (int)MEMP_MAX; i++) {
if (memp_pools[i] == NULL) {
printf(" [%d] NULL!\n", i);
} else {
printf(" [%d] OK\n", i);
}
}
printf("[Membrane] Enum Lookup:\n");
printf(" MEMP_UDP_PCB: %d\n", (int)MEMP_UDP_PCB);
printf(" MEMP_TCP_PCB: %d\n", (int)MEMP_TCP_PCB);
printf(" MEMP_PBUF: %d\n", (int)MEMP_PBUF);
""".}
dns_init() # Initialize DNS resolver
# Set Fallback DNS (10.0.2.3 - QEMU Default)
# Set Fallback DNS (8.8.8.8)
{.emit: """
static ip_addr_t dns_server;
IP4_ADDR(ip_2_ip4(&dns_server), 10, 0, 2, 3);
IP4_ADDR(ip_2_ip4(&dns_server), 8, 8, 8, 8);
dns_setserver(0, &dns_server);
""".}
glue_print("[Membrane] DNS resolver configured with fallback 10.0.2.3\n")
glue_print("[Membrane] lwip_init() returned. DNS Initialized.\n")
# 2. Setup Netif
@ -234,20 +214,16 @@ proc membrane_init*() {.exportc, cdecl.} =
static struct netif ni_static;
ip4_addr_t ip, mask, gw;
// Use Static IP to stabilize test environment
IP4_ADDR(&ip, 10, 0, 2, 15);
IP4_ADDR(&mask, 255, 255, 255, 0);
IP4_ADDR(&gw, 10, 0, 2, 2);
struct netif *res = netif_add(&ni_static, &ip, &mask, &gw, NULL, (netif_init_fn)ion_netif_init, (netif_input_fn)ethernet_input);
printf("[Membrane] netif_add returned: 0x%x\n", (unsigned int)res);
// Phase 38: DHCP Enabled
IP4_ADDR(&ip, 0, 0, 0, 0);
IP4_ADDR(&mask, 0, 0, 0, 0);
IP4_ADDR(&gw, 0, 0, 0, 0);
netif_add(&ni_static, &ip, &mask, &gw, NULL, (netif_init_fn)ion_netif_init, (netif_input_fn)ethernet_input);
netif_set_default(&ni_static);
netif_set_up(&ni_static);
printf("[Membrane] netif_default: 0x%x | netif_list: 0x%x\n", (unsigned int)netif_default, (unsigned int)netif_list);
// dhcp_start(&ni_static); // Bypassing DHCP
dhcp_start(&ni_static);
`g_netif` = &ni_static;
""".}
@ -260,7 +236,6 @@ proc glue_get_ip*(): uint32 {.exportc, cdecl.} =
var last_notified_ip: uint32 = 0
var last_ping_time: uint32 = 0
var pump_iterations: uint64 = 0
proc glue_print_hex(v: uint64) =
const hex_chars = "0123456789ABCDEF"
@ -276,7 +251,6 @@ proc glue_print_hex(v: uint64) =
proc pump_membrane_stack*() {.exportc, cdecl.} =
## The Pulse of the Membrane. Call frequently to handle timers and RX.
pump_iterations += 1
let now = sys_now()
# 3. Check for IP (Avoid continuous Nim string allocation/leak)
@ -288,39 +262,33 @@ proc pump_membrane_stack*() {.exportc, cdecl.} =
glue_print("\n")
last_notified_ip = ip_addr
# Phase 40: Fast Trigger for Helios Probe
glue_print("[Membrane] IP Found. Triggering Helios Probe...\n")
{.emit: "trigger_http_test();" .}
# 1. LwIP Timers (Raw API needs manual polling)
{.emit: """
static int debug_tick = 0;
if (debug_tick++ % 1000 == 0) {
printf("[Membrane] sys_now: %u (iters=%llu)\n", `now`, `pump_iterations`);
if (debug_tick++ % 200 == 0) {
printf("[Membrane] sys_now: %u\n", `now`);
}
""".}
# TCP Timer (250ms)
if (now - last_tcp_tmr >= 250) or (pump_iterations mod 25 == 0):
if now - last_tcp_tmr >= 250:
tcp_tmr()
last_tcp_tmr = now
# ARP Timer (5s)
if (now - last_arp_tmr >= 5000) or (pump_iterations mod 500 == 0):
if now - last_arp_tmr >= 5000:
etharp_tmr()
last_arp_tmr = now
# DHCP Timers
if (now - last_dhcp_fine >= 500) or (pump_iterations mod 50 == 0):
if now - last_dhcp_fine >= 500:
dhcp_fine_tmr()
last_dhcp_fine = now
if (now - last_dhcp_coarse >= 60000) or (pump_iterations mod 6000 == 0):
if now - last_dhcp_coarse >= 60000:
glue_print("[Membrane] DHCP Coarse Timer\n")
dhcp_coarse_tmr()
last_dhcp_coarse = now
# DNS Timer (1s)
if (now - last_dns_tmr >= 1000) or (pump_iterations mod 100 == 0):
# DNS Timer (every 1000ms)
if now - last_dns_tmr >= 1000:
dns_tmr()
last_dns_tmr = now
@ -329,14 +297,11 @@ proc pump_membrane_stack*() {.exportc, cdecl.} =
last_ping_time = now
if ip_addr != 0:
glue_print("[Membrane] TESTING EXTERNAL REACHABILITY: PING 142.250.185.78...\n")
glue_print("[Membrane] PING: Sending ICMP Echo...\n")
{.emit: """
ip_addr_t target;
IP4_ADDR(&target, 142, 250, 185, 78);
ping_send(&target);
// Trigger the Helios TCP Probe
trigger_http_test();
ip_addr_t gateway;
IP4_ADDR(&gateway, 10, 0, 2, 2);
ping_send(&gateway);
""".}
# 2. RX Ingress
@ -584,28 +549,35 @@ static void my_dns_callback(const char *name, const ip_addr_t *ipaddr, void *cal
}
}
// Check if DNS is properly initialized
int glue_dns_check_init(void) {
// We can't directly access dns_pcbs[] as it's static in dns.c
// Instead, we'll try to get the DNS server, which will fail if DNS isn't init'd
const ip_addr_t *ns = dns_getserver(0);
if (ns == NULL) {
printf("[Membrane] DNS ERROR: dns_getserver returned NULL\\n");
return -1;
}
// If we got here, DNS subsystem is at least partially initialized
return 0;
}
int glue_resolve_start(char* hostname) {
// BYPASS: Mock DNS to unblock Userland
// printf("[Membrane] DNS MOCK: Resolving '%s' -> 10.0.2.2\n", hostname);
ip_addr_t ip;
IP4_ADDR(ip_2_ip4(&ip), 10, 0, 2, 2); // Gateway
err_t err;
g_dns_status = 1; // Pending default
// Ensure we have a DNS server
const ip_addr_t *ns = dns_getserver(0);
if (ns == NULL || ip_addr_isany(ns)) {
printf("[Membrane] No DNS server available. Using fallback 8.8.8.8\n");
static ip_addr_t fallback;
IP_ADDR4(&fallback, 8, 8, 8, 8);
dns_setserver(0, &fallback);
ns = dns_getserver(0);
}
printf("[Membrane] Resolving '%s' via DNS: %s\n", hostname, ipaddr_ntoa(ns));
err = dns_gethostbyname(hostname, &ip, my_dns_callback, NULL);
if (err == ERR_OK) {
g_dns_ip = ip;
g_dns_status = 2; // Done
return 0;
} else if (err == ERR_INPROGRESS) {
return 1;
} else {
printf("[Membrane] dns_gethostbyname FAILED with error: %d\n", (int)err);
g_dns_status = -1;
return -1;
}
}
int glue_resolve_check(u32_t *ip_out) {
@ -616,55 +588,5 @@ int glue_resolve_check(u32_t *ip_out) {
}
return -1;
}
// --- HELIOS PROBE (TCP REAChABILITY TEST) ---
static err_t tcp_recv_callback(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) {
if (p != NULL) {
printf("[Membrane] HELIOS: TCP RECEIVED DATA: %d bytes\n", p->tot_len);
// Print first 32 bytes of response
printf("[Membrane] HELIOS: Response Peek: ");
for(int i=0; i<32 && i<p->tot_len; i++) {
char c = ((char*)p->payload)[i];
if (c >= 32 && c <= 126) printf("%c", c);
else printf(".");
}
printf("\n");
tcp_recved(pcb, p->tot_len);
pbuf_free(p);
} else {
printf("[Membrane] HELIOS: TCP CONNECTION CLOSED by Remote.\n");
tcp_close(pcb);
}
return ERR_OK;
}
static err_t tcp_connected_callback(void *arg, struct tcp_pcb *pcb, err_t err) {
printf("[Membrane] HELIOS: TCP CONNECTED! Sending GET Request...\n");
const char *request = "GET / HTTP/1.0\r\nHost: google.com\r\nUser-Agent: NexusOS/1.0\r\n\r\n";
tcp_write(pcb, request, strlen(request), TCP_WRITE_FLAG_COPY);
tcp_output(pcb);
return ERR_OK;
}
void trigger_http_test(void) {
static int triggered = 0;
if (triggered) return;
triggered = 1;
ip_addr_t google_ip;
IP4_ADDR(ip_2_ip4(&google_ip), 142, 250, 185, 78);
struct tcp_pcb *pcb = tcp_new();
if (!pcb) {
printf("[Membrane] HELIOS Error: Failed to create TCP PCB\n");
return;
}
tcp_arg(pcb, NULL);
tcp_recv(pcb, tcp_recv_callback);
printf("[Membrane] HELIOS: INITIATING TCP CONNECTION to 142.250.185.78:80...\n");
tcp_connect(pcb, &google_ip, 80, tcp_connected_callback);
}
""".}

2
libs/membrane/sys_arch.c
View File

@ -125,7 +125,7 @@ void lwip_platform_diag(const char *fmt, ...) {
*
* Note: Mapped via LWIP_PLATFORM_ASSERT macro in cc.h
*/
void nexus_lwip_panic(const char *msg) {
void lwip_platform_assert_impl(const char *msg) {
const char panic_msg[] = "[lwIP ASSERT FAILED]\n";
console_write(panic_msg, sizeof(panic_msg) - 1);
console_write(msg, __builtin_strlen(msg));

8
run.sh
View File

@ -2,7 +2,7 @@
# Rumpk QEMU Boot Script
RUMPK_DIR="$(cd "$(dirname "$0")" && pwd)"
KERNEL="$RUMPK_DIR/zig-out/bin/rumpk.elf"
KERNEL="$RUMPK_DIR/build/rumpk.elf"
if [ ! -f "$KERNEL" ]; then
echo "ERROR: Kernel not found at $KERNEL"
@ -14,9 +14,9 @@ echo "🚀 Booting Rumpk..."
echo " Kernel: $KERNEL"
echo ""
qemu-system-riscv64 \
qemu-system-aarch64 \
-M virt \
-cpu max \
-m 512M \
-cpu cortex-a57 \
-m 128M \
-nographic \
-kernel "$KERNEL"

0
vendor/mksh/build_nexus.sh vendored Executable file → Normal file
View File

BIN
vendor/mksh/mksh.elf.tmp165070a vendored
View File

Binary file not shown.

BIN
vendor/mksh/mksh.elf.tmp6703f64 vendored
View File

Binary file not shown.

5
vendor/mksh/stubs_mksh.c vendored
View File

@ -19,11 +19,6 @@ char **environ = NULL;
extern void console_write(const void* p, size_t len);
extern long syscall(long nr, long a0, long a1, long a2);
long k_handle_syscall(long nr, long a0, long a1, long a2) {
return syscall(nr, a0, a1, a2);
}
// Stubs
int fstat(int fd, struct stat *buf) { return 0; }
int lstat(const char *path, struct stat *buf) { return 0; }