Network

README.md

@@ -23,8 +23,8 @@ Once the system is initialized, most of the system's functionality is provided b
 Certain parts of the system initialization, such as GPU initialization and XHCI input code initialization rely on some syscalls that expect a process to be running, so an initial kernel.c process is created to hold their data. In the future they'll each have their own process.
 Everything about kernel processes and the pseudo-processes mentioned for GPU/XHCI will most likley be improved in the future, to make the system more modular, and kernel processes might get loaded from filesystem, in a similar way to how user processes are loaded. In order to do this, they either need to not rely on any kernel-only code (as several of them currently do) and rely on syscalls entirely, or (less ideal) dynamically link to the kernel. Doing this will increase the kernel's modularity.
 
-The system currently heavily relies on symbols defined in the linker to run, and these symbols are not available in the stripped binary version of the kernel, so REDACTED OS must be run through the kernel.elf file rather than the kernel.bin file.
-This limitation will be lifted in the future, removing reliance on these symbols altogether when possible, and creating alternatives for them when they're needed.
+The system must be run through the .elf file, since the .img file overwrites the device's DTB, making it impossible to detect certain features of the system.
+This limitation will be lifted in the future.
 
 ### Shared
 
@@ -64,3 +64,8 @@ In order to run the OS, you'll need to create a folder called fs inside the proj
 
 Github Actions should automatically compile changes made to the `main` branch using Mac, so a compiled version of the system with all the files needed to run it should be found there. This includes the fs folder, containing the filesystem, but you'll need to recompile the `disk.img` filesystem with `createfs` for any changes made to this folder to be reflected.
 
+## Networking
+
+The system has basic networking support. Currently, it performs DHCP a discovery and request to receive an IP address on the local network, is capable of responding to Ping and ARP, and can connect to a server running on ports 8080 and 80, though it currently does nothing noteworthy.
+An implementation of the server can be found at the [RedactedOS Firmware Server Repository](https://github.com/differrari/RedactedOS_firmware_server/tree/main)
+

kernel/exceptions/exception_handler.c

@@ -66,7 +66,7 @@ void panic(const char* panic_msg) {
         kstring s = kstring_format("%s\n%s\nSystem Halted",(uint64_t)PANIC_TEXT,(uint64_t)panic_msg);
         draw_panic_screen(s);
     }
-    while (1);
+    while (1);//TODO: OPT
 }
 
 void panic_with_info(const char* msg, uint64_t info) {
@@ -92,5 +92,5 @@ void panic_with_info(const char* msg, uint64_t info) {
         kstring s = kstring_format("%s\n%s\nError code: %x\nSystem Halted",(uint64_t)PANIC_TEXT,(uint64_t)msg,info);
         draw_panic_screen(s);
     }
-    while (1);
+    while (1);//TODO: OPT
 }

kernel/exceptions/irq.c

@@ -6,6 +6,7 @@
 #include "pci.h"
 #include "input/xhci.h"
 #include "console/serial/uart.h"
+#include "networking/network.h"
 
 #define IRQ_TIMER 30
 #define SLEEP_TIMER 27
@@ -36,6 +37,8 @@ void irq_init() {
 
     gic_enable_irq(IRQ_TIMER, 0x80, 0);
     gic_enable_irq(MSI_OFFSET + XHCI_IRQ, 0x80, 0);
+    gic_enable_irq(MSI_OFFSET + NET_IRQ, 0x80, 0);
+    gic_enable_irq(MSI_OFFSET + NET_IRQ + 1, 0x80, 0);
     gic_enable_irq(SLEEP_TIMER, 0x80, 0);
 
     write32(GICC_BASE + 0x004, 0xF0); //Priority
@@ -75,6 +78,14 @@ void irq_el1_handler() {
         wake_processes();
         write32(GICC_BASE + 0x10, irq);
         process_restore();
+    } else if (irq == MSI_OFFSET + NET_IRQ){
+        network_handle_download_interrupt();
+        write32(GICC_BASE + 0x10, irq);
+        process_restore();
+    }  else if (irq == MSI_OFFSET + NET_IRQ + 1){
+        network_handle_upload_interrupt();
+        write32(GICC_BASE + 0x10, irq);
+        process_restore();
     } else {
         kprintf_raw("[GIC error] Received unknown interrupt");
         write32(GICC_BASE + 0x10, irq);

kernel/input/xhci.c

@@ -93,53 +93,35 @@ void make_ring_link(trb* ring, bool cycle){
     make_ring_link_control(ring, cycle);
 }
 
-
-uint8_t xhci_init_interrupts(uint64_t pci_addr){
-#define MSIX_IRQ_LENGTH 1
-    msix_irq_line irq_lines[MSIX_IRQ_LENGTH] = {(msix_irq_line){.addr_offset=0,.irq_num=XHCI_IRQ}};
-    bool msix_ok = pci_setup_msix(pci_addr, irq_lines, MSIX_IRQ_LENGTH);
-
-    if(msix_ok){
-        return 1;
-    }
-
-    bool msi_ok = pci_setup_msi(pci_addr, XHCI_IRQ);
-    if(msi_ok){
-        return 2;
-    }
-
-    return 0;
-}
-
 bool xhci_init(xhci_device *xhci, uint64_t pci_addr) {
     kprintfv("[xHCI] init");
     if (!(read16(pci_addr + 0x06) & (1 << 4))){
         kprintfv("[xHCI] Wrong capabilities list");
         return false;
     }
 
+    pci_enable_device(pci_addr);
+
     if (!pci_setup_bar(pci_addr, 0, &xhci->mmio, &xhci->mmio_size)){
         kprintfv("[xHCI] BARs not set up");
         return false;
     }
 
     pci_register(xhci->mmio, xhci->mmio_size);
 
-    uint8_t interrupts_ok = xhci_init_interrupts(pci_addr);
+    uint8_t interrupts_ok = pci_setup_interrupts(pci_addr, XHCI_IRQ, 1);
     switch(interrupts_ok){
         case 0:
-            kprintf_raw("[xHCI] Failed to setup interrupts\n");
+            kprintf_raw("[xHCI] Failed to setup interrupts");
             return false;
         case 1:
-            kprintf_raw("[xHCI] Interrupts setup with MSI-X");
+            kprintf_raw("[xHCI] Interrupts setup with MSI-X %i",XHCI_IRQ);
             break;
         default:
-            kprintf_raw("[xHCI] Interrupts setup with MSI");
+            kprintf_raw("[xHCI] Interrupts setup with MSI %i",XHCI_IRQ);
             break;
     }
 
-    pci_enable_device(pci_addr);
-
     kprintfv("[xHCI] BARs set up @ %x (%x)",xhci->mmio,xhci->mmio_size);
 
     xhci->cap = (xhci_cap_regs*)(uintptr_t)xhci->mmio;

kernel/kernel.c

@@ -14,9 +14,9 @@
 #include "input/xhci_bridge.h"
 #include "input/xhci.h"
 #include "kernel_processes/monitor/monitor_processes.h"
+#include "networking/processes/net_proc.h"
 #include "memory/page_allocator.h"
-
-#include "networking/virtio_net_pci.h"
+#include "networking/network.h"
 
 void kernel_main() {
 
@@ -46,18 +46,18 @@ void kernel_main() {
 
     kprintf("GPU initialized");
 
-    // xhci_enable_verbose();
-    if (!xhci_input_init()){
-        panic("Input initialization failure");
-    }
-
     kprintf("Initializing disk...");
 
     // disk_verbose();
     if (!find_disk())
         panic("Disk initialization failure");
 
-    if (!vnp_find_network())
+    // xhci_enable_verbose();
+    if (!xhci_input_init()){
+        panic("Input initialization failure");
+    }
+
+    if (!network_init())
         panic("Network initialization failure");
 
     mmu_init();
@@ -72,6 +72,8 @@ void kernel_main() {
 
     // translate_enable_verbose();
 
+    launch_net_process();
+
     init_bootprocess();
 
     kprintf("Starting scheduler");

kernel/kernel_processes/monitor/monitor_processes.c

@@ -43,7 +43,7 @@ void print_process_info(){
     for (int i = 0; i < MAX_PROCS; i++){
         process_t *proc = &processes[i];
         if (proc->id != 0 && proc->state != STOPPED){
-            printf("Process [%i]: %s [pid = %i | status = %s]",i,(uintptr_t)proc->name,proc->id,(uint64_t)parse_proc_state(proc->state));
+            printf("Process [%i]: %s [pid = %i | status = %s]",i,(uintptr_t)proc->name,proc->id,(uintptr_t)parse_proc_state(proc->state));
             printf("Stack: %x (%x). SP: %x",proc->stack, proc->stack_size, proc->sp);
             printf("Heap: %x (%x)",proc->heap, calc_heap(proc->heap));
             printf("Flags: %x", proc->spsr);

kernel/memory/kalloc.c

@@ -32,6 +32,9 @@ uint64_t alloc_mmio_region(uint64_t size) {
     return addr;
 }
 
+bool is_mmio_allocated(uint64_t addr){
+    return addr > PCI_MMIO_BASE && addr < next_mmio_base;
+}
 
 extern uint64_t kernel_start;
 extern uint64_t heap_bottom;

kernel/memory/kalloc.h

@@ -22,4 +22,6 @@ uint64_t get_user_ram_end();
 uint64_t get_shared_start();
 uint64_t get_shared_end();
 
-uint64_t alloc_mmio_region(uint64_t size);
+uint64_t alloc_mmio_region(uint64_t size);
+
+bool is_mmio_allocated(uint64_t addr);

kernel/memory/page_allocator.c

@@ -170,4 +170,8 @@ void free_from_page(void* ptr, uint64_t size) {
     block->next = page->free_list;
     page->free_list = block;
     page->size -= size;
+}
+
+void free_sized(sizedptr ptr){
+    free_from_page((void*)ptr.ptr, ptr.size);
 }

kernel/memory/page_allocator.h

@@ -19,6 +19,8 @@ void free_page(void* ptr, uint64_t size);
 void* allocate_in_page(void *page, uint64_t size, uint16_t alignment, bool kernel, bool device);
 void free_from_page(void* ptr, uint64_t size);
 
+void free_sized(sizedptr ptr);
+
 #ifdef __cplusplus
 }
 #endif

kernel/networking/drivers/net_driver.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "types.h"
+#include "std/string.h"
+#include "ui/graphic_types.h"
+#include "net/network_types.h"
+
+class NetDriver {
+public:
+    NetDriver(){}
+    virtual bool init() = 0;
+
+    virtual sizedptr allocate_packet(size_t size) = 0;
+
+    virtual sizedptr handle_receive_packet() = 0;
+
+    virtual void handle_sent_packet() = 0;
+
+    virtual void enable_verbose() = 0;
+
+    virtual void send_packet(sizedptr packet) = 0;
+
+    virtual void get_mac(network_connection_ctx *context) = 0;
+
+    virtual ~NetDriver() = default;
+
+    uint16_t header_size;
+};