Merge remote-tracking branch 'upstream/main' into refactored_net

CodeAnarchist · CodeAnarchist · commit b86e8d9d7b7b · 2025-08-05T20:50:48.000+02:00
diff --git a/kernel/audio/virtio_audio_pci.cpp b/kernel/audio/virtio_audio_pci.cpp
@@ -96,10 +96,10 @@ bool VirtioAudioDriver::init(){
             kprintf("[VIRTIO_AUDIO] Failed to setup interrupts");
             return false;
         case 1:
-            kprintf("[VIRTIO_AUDIO] Interrupts setup with MSI-X %i,%i",AUDIO_IRQ);
+            kprintf("[VIRTIO_AUDIO] Interrupts setup with MSI-X %i",AUDIO_IRQ);
             break;
         default:
-            kprintf("[VIRTIO_AUDIO] Interrupts setup with MSI %i,%i",AUDIO_IRQ);
+            kprintf("[VIRTIO_AUDIO] Interrupts setup with MSI %i",AUDIO_IRQ);
             break;
     }
     pci_enable_device(addr);
@@ -111,17 +111,17 @@ bool VirtioAudioDriver::init(){
 
     select_queue(&audio_dev, EVENT_QUEUE);
 
+    audio_dev.common_cfg->queue_msix_vector = 0;
+    if (audio_dev.common_cfg->queue_msix_vector != 0){
+        kprintf("[VIRTIO_AUDIO error] failed to setup interrupts for event queue");
+        return false;
+    }
     for (uint16_t i = 0; i < 128; i++){
         void* buf = kalloc(audio_dev.memory_page, sizeof(virtio_snd_event), ALIGN_64B, true, true);
         virtio_add_buffer(&audio_dev, i, (uintptr_t)buf, sizeof(virtio_snd_event));
     }
 
     select_queue(&audio_dev, CONTROL_QUEUE);
-    audio_dev.common_cfg->queue_msix_vector = 0;
-    if (audio_dev.common_cfg->queue_msix_vector != 0){
-        kprintf("[VIRTIO_AUDIO error] failed to setup interrupts for event queue");
-        return false;
-    }
 
     return get_config();
 }
diff --git a/kernel/networking/drivers/net_driver.hpp b/kernel/networking/drivers/net_driver.hpp
@@ -1,28 +1,21 @@
 #pragma once
 
 #include "types.h"
-#include "std/string.h"
-#include "ui/graphic_types.h"
-#include "net/network_types.h"
+#include "net/network_types.h" 
 
 class NetDriver {
 public:
-    NetDriver(){}
+    NetDriver() = default;
     virtual bool init() = 0;
 
     virtual sizedptr allocate_packet(size_t size) = 0;
-    
-    virtual sizedptr handle_receive_packet() = 0;
-
+    virtual sizedptr handle_receive_packet(void* buffer) = 0;
     virtual void handle_sent_packet() = 0;
-
     virtual void enable_verbose() = 0;
-
     virtual void send_packet(sizedptr packet) = 0;
-
     virtual void get_mac(net_l2l3_endpoint *context) = 0;
 
     virtual ~NetDriver() = default;
 
     uint16_t header_size;
-};
+};
diff --git a/kernel/networking/drivers/virtio_net_pci/virtio_net_pci.cpp b/kernel/networking/drivers/virtio_net_pci/virtio_net_pci.cpp
@@ -8,8 +8,6 @@
 
 #define RECEIVE_QUEUE 0
 #define TRANSMIT_QUEUE 1
-//TODO: review this number
-#define MAX_size 0x1000
 
 #define kprintfv(fmt, ...) \
     ({ \
@@ -84,8 +82,8 @@ bool VirtioNetDriver::init(){
     select_queue(&vnp_net_dev, RECEIVE_QUEUE);
 
     for (uint16_t i = 0; i < 128; i++){
-        void* buf = kalloc(vnp_net_dev.memory_page, MAX_size, ALIGN_64B, true, true);
-        virtio_add_buffer(&vnp_net_dev, i, (uintptr_t)buf, MAX_size);
+        void* buf = kalloc(vnp_net_dev.memory_page, MAX_PACKET_SIZE, ALIGN_64B, true, true);
+        virtio_add_buffer(&vnp_net_dev, i, (uintptr_t)buf, MAX_PACKET_SIZE);
     }
 
     vnp_net_dev.common_cfg->queue_msix_vector = 0;
@@ -123,7 +121,7 @@ sizedptr VirtioNetDriver::allocate_packet(size_t size){
     return (sizedptr){(uintptr_t)kalloc(vnp_net_dev.memory_page, size + header_size, ALIGN_64B, true, true),size + header_size};
 }
 
-sizedptr VirtioNetDriver::handle_receive_packet(){
+sizedptr VirtioNetDriver::handle_receive_packet(void* buffer){
     select_queue(&vnp_net_dev, RECEIVE_QUEUE);
     struct virtq_used* used = (struct virtq_used*)(uintptr_t)vnp_net_dev.common_cfg->queue_device;
     struct virtq_desc* desc = (struct virtq_desc*)(uintptr_t)vnp_net_dev.common_cfg->queue_desc;
@@ -141,11 +139,15 @@ sizedptr VirtioNetDriver::handle_receive_packet(){
         uintptr_t packet = desc[desc_index].addr;
         packet += sizeof(virtio_net_hdr_t);
 
+        memcpy(buffer, (void*)packet, len);
+
         avail->ring[avail->idx % 128] = desc_index;
         avail->idx++;
 
         *(volatile uint16_t*)(uintptr_t)(vnp_net_dev.notify_cfg + vnp_net_dev.notify_off_multiplier * RECEIVE_QUEUE) = 0;
 
+        kfree((void*)desc[desc_index].addr, MAX_PACKET_SIZE);
+
         return (sizedptr){packet,len};
     }
 
diff --git a/kernel/networking/drivers/virtio_net_pci/virtio_net_pci.hpp b/kernel/networking/drivers/virtio_net_pci/virtio_net_pci.hpp
@@ -14,8 +14,8 @@ class VirtioNetDriver : public NetDriver {
 
     sizedptr allocate_packet(size_t size) override;
 
-    sizedptr handle_receive_packet() override;
-    
+    sizedptr handle_receive_packet(void* buffer) override;
+
     void handle_sent_packet() override;
 
     void enable_verbose() override;
diff --git a/kernel/networking/network.h b/kernel/networking/network.h
@@ -8,6 +8,8 @@ extern "C" {
 #include "net/network_types.h"
 
 #define NET_IRQ 32
+//TODO: consider using the system MTU here
+#define MAX_PACKET_SIZE 0x1000
 
 void network_net_set_pid(uint16_t pid);
 uint16_t network_net_get_pid(void);
@@ -17,7 +19,6 @@ void network_handle_download_interrupt(void);
 void network_handle_upload_interrupt(void);
 void network_net_task_entry(void);
 
-
 int net_tx_frame(uintptr_t frame_ptr, uint32_t frame_len);
 int net_rx_frame(sizedptr *out_frame);
 
diff --git a/kernel/networking/network_dispatch.cpp b/kernel/networking/network_dispatch.cpp
@@ -1,28 +1,21 @@
 #include "network_dispatch.hpp"
+#include "network.h"
 #include "drivers/virtio_net_pci/virtio_net_pci.hpp"
 #include "memory/page_allocator.h"
 #include "net/link_layer/eth.h"
-#include "port_manager.h"
 #include "net/network_types.h"
-#include "net/link_layer/arp.h"
-#include "net/application_layer/dhcp_daemon.h"
+#include "port_manager.h"
 #include "std/memfunctions.h"
-#include "console/kio.h"
-#include "types.h"
-#include "process/scheduler.h"
-#include "std/string.h"
-
-#define QUEUE_CAPACITY 1024
-
 
-//TODO: takes a moment to responde to every request. smt is creating a variable delay in receiving and trasmission somewhere
 extern void      sleep(uint64_t ms);
 extern uintptr_t malloc(uint64_t size);
-extern void      free(void *ptr, uint64_t size); 
+extern void      free(void *ptr, uint64_t size);
 
 static uint16_t g_net_pid = 0xFFFF;
+static uint8_t recv_buffer[MAX_PACKET_SIZE];
 
-NetworkDispatch::NetworkDispatch() : ports(UINT16_MAX + 1),
+NetworkDispatch::NetworkDispatch()
+  : ports(UINT16_MAX + 1),
     driver(nullptr),
     tx_queue(QUEUE_CAPACITY),
     rx_queue(QUEUE_CAPACITY)
@@ -44,38 +37,40 @@ bool NetworkDispatch::init()
 void NetworkDispatch::handle_download_interrupt()
 {
     if (!driver) return;
+    
+    sizedptr raw = driver->handle_receive_packet(recv_buffer);
+    if (raw.size < sizeof(eth_hdr_t)) {
+        return;
+    }
 
-    sizedptr raw = driver->handle_receive_packet();
-    if (!raw.ptr) return;
+    sizedptr frame{0, raw.size};
+    frame.ptr = reinterpret_cast<uintptr_t>(
+        kalloc(reinterpret_cast<void*>(get_current_heap()),
+               raw.size, ALIGN_16B,
+               get_current_privilege(), false));
+    if (!frame.ptr) return;
 
-    sizedptr frame = make_copy(raw);
-    free_frame(raw);
+    memcpy(reinterpret_cast<void*>(frame.ptr), recv_buffer, raw.size);
 
-    if (frame.ptr && frame.size >= sizeof(eth_hdr_t)) {
-        if (!rx_queue.enqueue(frame))
-            free_frame(frame);
-    } else {
+    if (!rx_queue.enqueue(frame))
         free_frame(frame);
-    }
 }
 
 void NetworkDispatch::handle_upload_interrupt()
 {
-    if (driver) driver->handle_sent_packet();
+    if (driver)
+        driver->handle_sent_packet();
 }
 
 bool NetworkDispatch::enqueue_frame(const sizedptr &frame)
 {
-    if (frame.size == 0) {
-        kprintf("[NetworkDispatch] drop zero‑length frame\n");
-        return false;
-    }
+    if (frame.size == 0) return false;
 
     sizedptr pkt = driver->allocate_packet(frame.size);
     if (!pkt.ptr) return false;
 
-    void *dst = reinterpret_cast<void *>(pkt.ptr + driver->header_size);
-    memcpy(dst, reinterpret_cast<const void *>(frame.ptr), frame.size);
+    void* dst = reinterpret_cast<void*>(pkt.ptr + driver->header_size);
+    memcpy(dst, reinterpret_cast<const void*>(frame.ptr), frame.size);
 
     if (!tx_queue.enqueue(pkt)) {
         free_frame(pkt);
@@ -103,7 +98,8 @@ void NetworkDispatch::net_task()
             driver->send_packet(pkt);
         }
 
-        if (!did_work) sleep(10);
+        if (!did_work)
+            sleep(10);
     }
 }
 
@@ -118,17 +114,16 @@ bool NetworkDispatch::dequeue_packet_for(uint16_t pid, sizedptr *out)
     sizedptr stored = buf.entries[buf.read_index];
     buf.read_index = (buf.read_index + 1) % PACKET_BUFFER_CAPACITY;
 
-    void *dst = kalloc(reinterpret_cast<void *>(get_current_heap()),
-                                 stored.size, ALIGN_16B,
-                                 get_current_privilege(), false);
+    void *dst = kalloc(reinterpret_cast<void*>(get_current_heap()),
+                       stored.size, ALIGN_16B,
+                       get_current_privilege(), false);
     if (!dst) return false;
 
-    memcpy(dst, reinterpret_cast<void *>(stored.ptr), stored.size);
-    out->ptr = reinterpret_cast<uintptr_t>(dst);
+    memcpy(dst, reinterpret_cast<void*>(stored.ptr), stored.size);
+    out->ptr  = reinterpret_cast<uintptr_t>(dst);
     out->size = stored.size;
 
-    free(reinterpret_cast<void *>(stored.ptr), stored.size);
-    //free(reinterpret_cast<void*>(out->ptr), out->size);
+    free(reinterpret_cast<void*>(stored.ptr), stored.size);
     return true;
 }
 
@@ -138,25 +133,25 @@ static sizedptr make_user_copy(const sizedptr &src)
     uintptr_t mem = malloc(src.size);
     if (!mem) return out;
 
-    memcpy(reinterpret_cast<void *>(mem),
-           reinterpret_cast<const void *>(src.ptr),
+    memcpy(reinterpret_cast<void*>(mem),
+           reinterpret_cast<const void*>(src.ptr),
            src.size);
 
-    out.ptr = mem;
+    out.ptr  = mem;
     out.size = src.size;
     return out;
 }
 
 sizedptr NetworkDispatch::make_copy(const sizedptr &in)
 {
     sizedptr out{0, 0};
-    void *dst = kalloc(reinterpret_cast<void *>(get_current_heap()),
-                                 in.size, ALIGN_16B,
-                                 get_current_privilege(), false);
+    void *dst = kalloc(reinterpret_cast<void*>(get_current_heap()),
+                       in.size, ALIGN_16B,
+                       get_current_privilege(), false);
     if (!dst) return out;
 
-    memcpy(dst, reinterpret_cast<const void *>(in.ptr), in.size);
-    out.ptr = reinterpret_cast<uintptr_t>(dst);
+    memcpy(dst, reinterpret_cast<const void*>(in.ptr), in.size);
+    out.ptr  = reinterpret_cast<uintptr_t>(dst);
     out.size = in.size;
     return out;
 }
@@ -167,4 +162,4 @@ void NetworkDispatch::free_frame(const sizedptr &f)
 }
 
 void NetworkDispatch::set_net_pid(uint16_t pid) { g_net_pid = pid; }
-uint16_t NetworkDispatch::get_net_pid() const { return g_net_pid; }
+uint16_t NetworkDispatch::get_net_pid() const   { return g_net_pid; }
diff --git a/shared/std/memfunctions.c b/shared/std/memfunctions.c
@@ -33,8 +33,17 @@ void* memset(void* dest, uint32_t val, size_t count) {
 }
 
 void* memcpy(void *dest, const void *src, uint64_t count) {
-    uint64_t *d64 = (uint64_t *)dest;
-    const uint64_t *s64 = (const uint64_t *)src;
+    uint8_t *d8 = (uint8_t *)dest;
+    const uint8_t *s8 = (const uint8_t *)src;
+
+    while (count > 0 && 
+          (((uintptr_t)d8 & 7) != 0 || ((uintptr_t)s8 & 7) != 0)) {
+        *d8++ = *s8++;
+        count--;
+    }
+
+    uint64_t *d64 = (uint64_t *)d8;
+    const uint64_t *s64 = (const uint64_t *)s8;
 
     uint64_t blocks = count / 32;
     for (uint64_t i = 0; i < blocks; i++) {
@@ -49,8 +58,8 @@ void* memcpy(void *dest, const void *src, uint64_t count) {
     uint64_t remaining = (count % 32) / 8;
     for (uint64_t i = 0; i < remaining; i++) d64[i] = s64[i];
 
-    uint8_t *d8 = (uint8_t *)(d64 + remaining);
-    const uint8_t *s8 = (const uint8_t *)(s64 + remaining);
+    d8 = (uint8_t *)(d64 + remaining);
+    s8 = (const uint8_t *)(s64 + remaining);
     for (uint64_t i = 0; i < count % 8; i++) d8[i] = s8[i];
 
     return dest;
