RTL8139 + Netqueue: Ballsack aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa…

…aaaaaaa

kernel/include/net/stack.h

@@ -5,8 +5,15 @@
 #pragma once
 
 #include "common.h"
+#include "net/cards.h"
+
+typedef struct {
+	netcard_entry_t* card;
+	void* data;
+	size_t length;
+} netqueue_item_t;
 
 void netstack_init();
-void netstack_push(void* packet_data, size_t length);
-void* netstack_pop();
-void* netstack_poll();
+void netstack_push(netcard_entry_t* card, void* packet_data, size_t length);
+netqueue_item_t* netstack_pop();
+netqueue_item_t* netstack_poll();

kernel/src/drv/network/rtl8139.c

@@ -39,6 +39,8 @@ size_t rtl8139_transfer_buffer_phys;
 void rtl8139_send_packet(void* data, size_t length);
 void rtl8139_receive_packet();
 
+bool rtl8139_in_irq = false;
+
 #define NETCARD_NAME ("RTL8139")
 
 void rtl8139_netcard_get_mac(uint8_t mac[6]) {
@@ -157,6 +159,8 @@ void rtl8139_init_buffer() {
 void rtl8139_handler(__attribute__((unused)) registers_t regs) {
 	qemu_log("Received RTL8139 interrupt!");
 
+	rtl8139_in_irq = true;
+
 	uint16_t status = inw(rtl8139_io_base + 0x3e);
 
 	if(status & TOK) {
@@ -171,26 +175,34 @@ void rtl8139_handler(__attribute__((unused)) registers_t regs) {
 	}
 
 	outw(rtl8139_io_base + 0x3E, 0x05);
+
+	rtl8139_in_irq = false;
 }
 
 void rtl8139_send_packet(void *data, size_t length) {
 	// First, copy the data to a physically contiguous chunk of memory
 
+	//qemu_log("Waiting lock...");
+	//while(rtl8139_in_irq)
+	//	;
+
+	qemu_log("Sending packet");
+
 	memset(rtl8139_transfer_buffer, 0, 65535);
 
 	memcpy(rtl8139_transfer_buffer, data, length);
 
-	qemu_log("Send packet: Virtual memory at %x", (size_t)rtl8139_transfer_buffer);
-	qemu_log("Send packet: Physical memory at %x", rtl8139_transfer_buffer_phys);
+	//qemu_log("Send packet: Virtual memory at %x", (size_t)rtl8139_transfer_buffer);
+	//qemu_log("Send packet: Physical memory at %x", rtl8139_transfer_buffer_phys);
 
 	// Second, fill in physical address of data, and length
 
-	qemu_log("Before: %d",  rtl8139_current_tx_index);
+	//qemu_log("Before: %d",  rtl8139_current_tx_index);
 
 	outl(rtl8139_io_base + TSAD_array[rtl8139_current_tx_index], (uint32_t)rtl8139_transfer_buffer_phys);
 	outl(rtl8139_io_base + TSD_array[rtl8139_current_tx_index++], length);
 
-	qemu_log("After: %d",  rtl8139_current_tx_index);
+	//qemu_log("After: %d",  rtl8139_current_tx_index);
 
 	if(rtl8139_current_tx_index > 3)
 		rtl8139_current_tx_index = 0;
@@ -200,6 +212,7 @@ void rtl8139_send_packet(void *data, size_t length) {
 
 size_t rtl8139_current_packet_ptr = 0;
 
+// This function is a part of IRQ
 void rtl8139_receive_packet() {
 	uint16_t* packet = (uint16_t*)(rtl8139_virt_buffer + rtl8139_current_packet_ptr);
 
@@ -226,7 +239,7 @@ void rtl8139_receive_packet() {
 //	hexview_advanced((char *) packet_data, packet_length, 10, true, new_qemu_printf);
 
 	if(packet_header == HARDWARE_TYPE_ETHERNET) {
-//        netstack_push(packet_data, packet_length);
+		//netstack_push(&rtl8139_netcard, packet_data, packet_length);
 
 		qemu_note("Processing packet...");
 		ethernet_handle_packet(&rtl8139_netcard, (ethernet_frame_t *) packet_data, packet_length);

kernel/src/net/ethernet.c

@@ -4,7 +4,8 @@
 #include "net/arp.h"
 #include "net/ethernet.h"
 #include "mem/vmm.h"
-#include "debug/hexview.h"
+//#include "debug/hexview.h"
+#include "net/stack.h"
 
 void ethernet_dump(void* data, size_t size, uint16_t type){
 	qemu_log("Types: %x", type);
@@ -97,7 +98,8 @@ void ethernet_send_packet(netcard_entry_t* card, uint8_t* dest_mac, uint8_t* dat
 
     frame->type = htons(type);
 
-    card->send_packet(frame, sizeof(ethernet_frame_t) + len);
+    netstack_push(card, frame, sizeof(ethernet_frame_t) + len);
+    //card->send_packet(frame, sizeof(ethernet_frame_t) + len);
 
     kfree(frame);
 }
@@ -132,4 +134,4 @@ void ethernet_handle_packet(netcard_entry_t *card, ethernet_frame_t *packet, siz
 	} else if(ntohs(packet->type) == ETHERNET_TYPE_IPV4) {
 		ipv4_handle_packet(card, data, data_len);
 	}
-}
+}

kernel/src/net/stack.c

@@ -2,34 +2,61 @@
 // Created by maractus on 04.01.24.
 //
 
+#include "net/cards.h"
 #include "net/stack.h"
 #include "../lib/libvector/include/vector.h"
 #include "mem/vmm.h"
+#include "io/ports.h"
+#include "sys/scheduler.h"
+#include "net/ethernet.h"
 
 volatile vector_t* system_network_incoming_queue = 0;
-volatile vector_t* system_network_outgoing_queue = 0;
+
+void netstack_processor();
 
 void netstack_init() {
     system_network_incoming_queue = vector_new();
-    system_network_outgoing_queue = vector_new();
+
+	thread_create(get_current_proc(), netstack_processor, 0x10000, true, false);
 }
 
-void netstack_push(void* packet_data, size_t length) {
-    void* data = kcalloc(1, length);
+void netstack_push(netcard_entry_t* card, void* packet_data, size_t length) {
+	netqueue_item_t* item = kcalloc(sizeof(netqueue_item_t), 1);
+	void* data = kcalloc(1, length);
 
-    memcpy(data, packet_data, length);
+	memcpy(data, packet_data, length);
 
-    vector_push_back(system_network_stack, (size_t) data);
+	item->data = data;
+	item->card = card;
+	item->length = length;
+
+	vector_push_back(system_network_incoming_queue, (size_t) item);
 }
 
-void* netstack_pop() {
-    void* data = (void *) vector_pop_back(system_network_stack).element;
+netqueue_item_t* netstack_pop() {
+    netqueue_item_t* data = (void *) vector_pop_back(system_network_incoming_queue).element;
 
     return data;
 }
 
-void* netstack_poll() {
-    while(system_network_stack->size == 0);
+netqueue_item_t* netstack_poll() {
+    while(system_network_incoming_queue->size == 0);
 
     return netstack_pop();
 }
+
+
+void netstack_processor() {
+	qemu_note("NETWORK QUEUE IS WORKING NOW!");
+
+	while(1) {
+		qemu_note("WAITING FOR PACKET");
+		netqueue_item_t* item = netstack_poll();
+
+		qemu_note("SENDING PACKET");
+		item->card->send_packet(item->data, item->length);
+		//ethernet_handle_packet(item->card, item->data, item->length);
+
+		qemu_ok("PACKET SENT!");
+	}
+}