Fix Implicit Standard Declarations and Greatly Expand Test Suite

Makefile

@@ -25,6 +25,8 @@ KERNEL_OBJS = kernel/entry.o kernel/kernel.o src/app_ui.o \
               kernel/fatfs/ff.o kernel/fatfs/ffunicode.o \
               kernel/drivers/pci.o kernel/drivers/xhci.o kernel/drivers/ehci.o \
               kernel/drivers/virtio_net.o kernel/drivers/virtio_net_linux.o \
+              kernel/drivers/e1000_linux.o kernel/drivers/rtl8139_linux.o \
+              kernel/drivers/iwlwifi_stub.o \
               kernel/linux_compat.o kernel/linux_irq.o kernel/linux_pci_compat.o \
               kernel/drivers/nvme.o kernel/drivers/ahci.o kernel/drivers/ramdisk.o \
               kernel/drivers/ps2.o kernel/drivers/rtc.o \
@@ -33,8 +35,10 @@ KERNEL_OBJS = kernel/entry.o kernel/kernel.o src/app_ui.o \
               external/CherryUSB/class/hid/usbh_hid.o \
               external/CherryUSB/class/hub/usbh_hub.o \
               external/CherryUSB/port/ehci/usb_hc_ehci.o
-.PHONY: all clean environment iso run
+.PHONY: all clean environment iso run setup
 all: environment userland kernel/kernel iso
+setup:
+	sudo apt-get update && sudo apt-get install -y xorriso mtools gcc make python3 git binutils
 environment:
 	chmod +x build.sh
 	./build.sh
@@ -50,16 +54,29 @@ $(KERNEL_OBJS): environment
 	$(CC) $(CFLAGS) -x assembler-with-cpp -c $< -o $@
 iso: kernel/kernel
 	mkdir -p iso_root/boot/sys
+	mkdir -p iso_root/boot/limine
+	mkdir -p iso_root/EFI/BOOT
 	cp kernel/kernel iso_root/boot/sys/kernel.elf
 	cp kernel/ramdisk.img iso_root/boot/sys/ramdisk.img
 	cp kernel/limine.cfg iso_root/limine.conf
 	cp kernel/limine.cfg iso_root/limine.cfg
 	cp kernel/limine.cfg iso_root/boot/limine.conf
 	cp kernel/limine.cfg iso_root/boot/limine.cfg
+	cp kernel/limine.cfg iso_root/boot/limine/limine.conf
+	cp kernel/limine.cfg iso_root/boot/limine/limine.cfg
 	cp external/limine/limine-bios.sys iso_root/boot/
 	cp external/limine/limine-bios-cd.bin iso_root/boot/
-	xorriso -as mkisofs -b boot/limine-bios-cd.bin \
+	cp external/limine/limine-bios.sys iso_root/boot/limine/
+	cp external/limine/limine-bios-cd.bin iso_root/boot/limine/
+	cp external/limine/limine-uefi-cd.bin iso_root/boot/
+	cp external/limine/limine-uefi-cd.bin iso_root/boot/limine/
+	cp external/limine/BOOTX64.EFI iso_root/EFI/BOOT/
+	cp external/limine/BOOTIA32.EFI iso_root/EFI/BOOT/
+	xorriso -as mkisofs \
+		-b boot/limine-bios-cd.bin \
 		-no-emul-boot -boot-load-size 4 -boot-info-table \
+		--efi-boot boot/limine-uefi-cd.bin \
+		-efi-boot-part --efi-boot-image \
 		iso_root -o os.iso
 	./external/limine/limine bios-install os.iso
 run: all

apps/lib/user_rsl.c

@@ -3,13 +3,69 @@
 #include <stdio.h>
 
 /* Very minimal vsnprintf for userland apps if we don't link with kernel implementation */
-/* For now, just a dummy or we can try to reuse the kernel headers if we're careful. */
 /* Userland shouldn't ideally include kernel headers. */
 
+static void rsl_itoa(unsigned long long n, char* s, int base, int sign) {
+    (void)s;
+    char buf[64];
+    int i = 0;
+    if (sign && (long long)n < 0) {
+        syscall(SYS_SERIAL_WRITE, "-", NULL, 0);
+        n = -(long long)n;
+    }
+    if (n == 0) {
+        buf[i++] = '0';
+    } else {
+        while (n > 0) {
+            int rem = n % base;
+            buf[i++] = (rem < 10) ? (rem + '0') : (rem - 10 + 'a');
+            n /= base;
+        }
+    }
+    while (i > 0) {
+        char c[2] = {buf[--i], '\0'};
+        syscall(SYS_SERIAL_WRITE, c, NULL, 0);
+    }
+}
+
 void rsl_printf(const char* fmt, ...) {
-    /* For simplicity in this demo, just send the raw string to serial */
-    /* Real implementation would use vsnprintf */
-    syscall(SYS_SERIAL_WRITE, fmt, NULL, 0);
+    va_list args;
+    va_start(args, fmt);
+    const char *p = fmt;
+    while (*p) {
+        if (*p == '%') {
+            p++;
+            if (*p == '\0') break;
+            if (*p == 'd') {
+                int val = va_arg(args, int);
+                rsl_itoa((unsigned long long)val, NULL, 10, 1);
+            } else if (*p == 'u') {
+                unsigned int val = va_arg(args, unsigned int);
+                rsl_itoa((unsigned long long)val, NULL, 10, 0);
+            } else if (*p == 'x') {
+                unsigned int val = va_arg(args, unsigned int);
+                rsl_itoa((unsigned long long)val, NULL, 16, 0);
+            } else if (*p == 'p') {
+                void* val = va_arg(args, void*);
+                syscall(SYS_SERIAL_WRITE, "0x", NULL, 0);
+                rsl_itoa((unsigned long long)val, NULL, 16, 0);
+            } else if (*p == 's') {
+                const char* s = va_arg(args, const char*);
+                if (s) syscall(SYS_SERIAL_WRITE, s, NULL, 0);
+                else syscall(SYS_SERIAL_WRITE, "(null)", NULL, 0);
+            } else if (*p == '%') {
+                syscall(SYS_SERIAL_WRITE, "%", NULL, 0);
+            } else {
+                char c[2] = {*p, '\0'};
+                syscall(SYS_SERIAL_WRITE, c, NULL, 0);
+            }
+        } else {
+            char c[2] = {*p, '\0'};
+            syscall(SYS_SERIAL_WRITE, c, NULL, 0);
+        }
+        p++;
+    }
+    va_end(args);
 }
 
 int rsl_ls(const char* path, char* out, size_t sz) {
@@ -28,3 +84,66 @@ void rsl_exit(int code) {
     (void)code;
     syscall(SYS_EXIT, NULL, NULL, 0);
 }
+
+void* rsl_malloc(size_t size) {
+    return (void*)syscall(SYS_MALLOC, (const void*)size, NULL, 0);
+}
+
+void rsl_free(void* ptr) {
+    syscall(SYS_FREE, ptr, NULL, 0);
+}
+
+int rsl_cat(const char* path, char* out, size_t sz) {
+    return (int)syscall(SYS_VFS_CAT, path, out, sz);
+}
+
+int rsl_write(const char* path, const char* content) {
+    return (int)syscall(SYS_VFS_WRITE, path, (void*)(uintptr_t)content, 0);
+}
+
+int rsl_mounts(char* out, size_t sz) {
+    return (int)syscall(SYS_VFS_MOUNTS, out, NULL, sz);
+}
+
+int rsl_hw_list(char* out, size_t sz) {
+    return (int)syscall(SYS_DEVMGR_LIST, out, NULL, sz);
+}
+
+uint64_t rsl_uptime(void) {
+    uint64_t u = 0;
+    syscall(SYS_GET_UPTIME, NULL, &u, 0);
+    return u;
+}
+
+int rsl_cpu_load(void) {
+    return (int)syscall(SYS_GET_CPU_LOAD, NULL, NULL, 0);
+}
+
+int rsl_spawn(const char* name, void (*entry)(void*), void* arg) {
+    return (int)syscall(SYS_SPAWN, name, (void*)(uintptr_t)entry, (size_t)arg);
+}
+
+void rsl_yield(void) {
+    syscall(SYS_YIELD, NULL, NULL, 0);
+}
+
+const char* rsl_i18n(const char* key) {
+    return (const char*)syscall(SYS_I18N_TRANSLATE, key, NULL, 0);
+}
+
+void* memset(void* s, int c, size_t n) {
+    unsigned char* p = (unsigned char*)s;
+    for (size_t i = 0; i < n; i++) {
+        p[i] = (unsigned char)c;
+    }
+    return s;
+}
+
+void* memcpy(void* dest, const void* src, size_t n) {
+    unsigned char* d = (unsigned char*)dest;
+    const unsigned char* s = (const unsigned char*)src;
+    for (size_t i = 0; i < n; i++) {
+        d[i] = s[i];
+    }
+    return dest;
+}

apps/lib/user_rsl.h

@@ -40,4 +40,16 @@ int rsl_read(const char* path, void* buffer, size_t sz);
 int rsl_mkdir(const char* path);
 void rsl_exit(int code);
 
+void* rsl_malloc(size_t size);
+void  rsl_free(void* ptr);
+int rsl_cat(const char* path, char* out, size_t sz);
+int rsl_write(const char* path, const char* content);
+int rsl_mounts(char* out, size_t sz);
+int      rsl_hw_list(char* out, size_t sz);
+uint64_t rsl_uptime(void);
+int      rsl_cpu_load(void);
+int  rsl_spawn(const char* name, void (*entry)(void*), void* arg);
+void rsl_yield(void);
+const char* rsl_i18n(const char* key);
+
 #endif

apps/tests/app.c

@@ -26,8 +26,128 @@ void test_syscall_edge_cases() {
     rsl_printf("[TEST] Edge case testing complete.\n");
 }
 
+void test_malloc_operations() {
+    rsl_printf("[TEST] Starting User-space Heap Tests...\n");
+
+    rsl_printf("[TEST] Allocating block of 1024 bytes...\n");
+    char* ptr = (char*)rsl_malloc(1024);
+    rsl_printf("[TEST] Allocated pointer: %p\n", ptr);
+    if (!ptr) {
+        rsl_printf("[TEST] FAIL: rsl_malloc returned NULL!\n");
+        return;
+    }
+
+    rsl_printf("[TEST] Writing test sequence and checking memory block integrity...\n");
+    for (int i = 0; i < 1023; i++) {
+        ptr[i] = (char)('A' + (i % 26));
+    }
+    ptr[1023] = '\0';
+
+    bool match = true;
+    for (int i = 0; i < 1023; i++) {
+        if (ptr[i] != (char)('A' + (i % 26))) {
+            match = false;
+            break;
+        }
+    }
+
+    if (match) {
+        rsl_printf("[TEST] Memory block content verification: SUCCESS\n");
+    } else {
+        rsl_printf("[TEST] FAIL: Memory data corrupted!\n");
+    }
+
+    rsl_printf("[TEST] Freeing memory block...\n");
+    rsl_free(ptr);
+    rsl_printf("[TEST] Heap tests complete.\n");
+}
+
+void test_system_telemetry() {
+    rsl_printf("[TEST] Starting System Telemetry Tests...\n");
+
+    uint64_t t1 = rsl_uptime();
+    rsl_printf("[TEST] Current System Uptime: %d ms\n", (int)t1);
+
+    int cpu = rsl_cpu_load();
+    rsl_printf("[TEST] Current CPU Load: %d%%\n", cpu);
+    if (cpu >= 0 && cpu <= 100) {
+        rsl_printf("[TEST] CPU Load validation: SUCCESS\n");
+    } else {
+        rsl_printf("[TEST] FAIL: CPU Load invalid (%d)\n", cpu);
+    }
+
+    char hw_buf[256];
+    int hw_res = rsl_hw_list(hw_buf, sizeof(hw_buf));
+    rsl_printf("[TEST] Hardware List (Result=%d):\n%s\n", hw_res, hw_buf);
+
+    char mount_buf[256];
+    int mount_res = rsl_mounts(mount_buf, sizeof(mount_buf));
+    rsl_printf("[TEST] Mount points list (Result=%d):\n%s\n", mount_res, mount_buf);
+
+    rsl_printf("[TEST] System Telemetry tests complete.\n");
+}
+
+void test_vfs_io() {
+    rsl_printf("[TEST] Starting Executive VFS I/O Tests...\n");
+
+    const char* filepath = "/test_file.txt";
+    const char* content = "Sovereign Industrial System Test Run. Success!";
+    rsl_printf("[TEST] Writing content to file '%s'...\n", filepath);
+    int res = rsl_write(filepath, content);
+    rsl_printf("[TEST] Write Result: %d\n", res);
+
+    rsl_printf("[TEST] Reading back content using rsl_cat...\n");
+    char read_buf[128];
+    memset(read_buf, 0, sizeof(read_buf));
+    res = rsl_cat(filepath, read_buf, sizeof(read_buf));
+    rsl_printf("[TEST] Read Result (cat): %d\n", res);
+    rsl_printf("[TEST] Read Content: '%s'\n", read_buf);
+
+    int cmp = 0;
+    const char *p1 = content, *p2 = read_buf;
+    while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
+    if (*p1 == '\0' && *p2 == '\0') cmp = 0;
+    else cmp = (*p1 > *p2) ? 1 : -1;
+
+    if (cmp == 0) {
+        rsl_printf("[TEST] File content verification: SUCCESS\n");
+    } else {
+        rsl_printf("[TEST] FAIL: File content mismatch!\n");
+    }
+
+    rsl_printf("[TEST] Reading back content using rsl_read...\n");
+    char read_buf2[128];
+    memset(read_buf2, 0, sizeof(read_buf2));
+    res = rsl_read(filepath, read_buf2, sizeof(read_buf2));
+    rsl_printf("[TEST] Read Result (read): %d\n", res);
+    rsl_printf("[TEST] Read Content: '%s'\n", read_buf2);
+
+    rsl_printf("[TEST] VFS I/O tests complete.\n");
+}
+
+void test_i18n() {
+    rsl_printf("[TEST] Starting Internationalization Translation Tests...\n");
+    const char* key = "SYS_READY";
+    const char* translation = rsl_i18n(key);
+    rsl_printf("[TEST] Key: '%s' -> Translation: '%s'\n", key, translation);
+    rsl_printf("[TEST] I18n translation complete.\n");
+}
+
 int main(void) {
+    rsl_printf("===========================================\n");
+    rsl_printf("SOVEREIGN RTC64 INDUSTRIAL TEST SUITE\n");
+    rsl_printf("===========================================\n");
+
     test_syscall_edge_cases();
+    test_malloc_operations();
+    test_system_telemetry();
+    test_vfs_io();
+    test_i18n();
+
+    rsl_printf("===========================================\n");
+    rsl_printf("ALL INDUSTRIAL TESTS COMPLETE!\n");
+    rsl_printf("===========================================\n");
+
     rsl_exit(0);
     return 0;
 }

include/linux/netdevice.h

@@ -8,6 +8,9 @@
 #define ETH_ALEN 6
 #define IFNAMSIZ 16
 
+struct net_device;
+struct sk_buff;
+
 struct net_device_stats {
     unsigned long rx_packets;
     unsigned long tx_packets;
@@ -33,11 +36,22 @@ struct net_device {
     uint8_t dev_addr[ETH_ALEN];
     unsigned int mtu;
     unsigned int flags;
-    struct net_device_ops *netdev_ops;
+    const struct net_device_ops *netdev_ops;
     struct net_device_stats stats;
     void *ml_priv;
 };
 
+typedef int netdev_tx_t;
+#define NETDEV_TX_OK 0
+
+static inline void *netdev_priv(const struct net_device *dev) {
+    return (void *)(dev + 1);
+}
+
+static inline void ether_setup(struct net_device *dev) {
+    (void)dev;
+}
+
 struct net_device *alloc_netdev(int sizeof_priv, const char *name, void (*setup)(struct net_device *));
 void free_netdev(struct net_device *dev);
 int register_netdev(struct net_device *dev);

include/math.h

@@ -22,4 +22,15 @@ float  acosf(float x);
 int    isnan(double x);
 double fmod(double x, double y);
 
+float  fabsf(float x);
+float  sqrtf(float x);
+float  sinf(float x);
+float  cosf(float x);
+float  tanf(float x);
+float  fmodf(float x, float y);
+float  atan2f(float y, float x);
+float  ceilf(float x);
+float  floorf(float x);
+float  roundf(float x);
+
 #endif