modularise network drivers for e1000 and rtl8139

braindigitalis · braindigitalis · commit 53ddd16071d8 · 2025-09-06T18:01:17.000Z
diff --git a/include/kernel.h b/include/kernel.h
@@ -59,8 +59,6 @@
 #include "taskswitch.h"
 #include "acpi.h"
 #include "net.h"
-#include "rtl8139.h"
-#include "e1000.h"
 #include "arp.h"
 #include "ip.h"
 #include "ethernet.h"
diff --git a/modules/e1000/e1000.c b/modules/e1000/e1000.c
@@ -1,15 +1,16 @@
 #include <kernel.h>
+#include "e1000.h"
 #include <mmio.h>
 
-uint8_t bar_type = 0;		// Type of BAR0
-uint16_t io_base = 0;		// IO Base Address
-uint64_t mem_base = 0;		// MMIO Base Address
-bool eerprom_exists = false;	// A flag indicating if eeprom exists
-uint8_t mac[6] = {0};		// A buffer for storing the mack address
-e1000_rx_desc_t *rx_descs[E1000_NUM_RX_DESC] = {NULL}; // Receive Descriptor Buffers
-e1000_tx_desc_t *tx_descs[E1000_NUM_TX_DESC] = {NULL}; // Transmit Descriptor Buffers
-uint16_t rx_cur = 0;		// Current Receive Descriptor Buffer
-uint16_t tx_cur = 0;		// Current Transmit Descriptor Buffer
+static uint8_t bar_type = 0;		// Type of BAR0
+static uint16_t io_base = 0;		// IO Base Address
+static uint64_t mem_base = 0;		// MMIO Base Address
+static bool eerprom_exists = false;	// A flag indicating if eeprom exists
+static uint8_t mac[6] = {0};		// A buffer for storing the mack address
+static e1000_rx_desc_t *rx_descs[E1000_NUM_RX_DESC]; // Receive Descriptor Buffers
+static e1000_tx_desc_t *tx_descs[E1000_NUM_TX_DESC]; // Transmit Descriptor Buffers
+static uint16_t rx_cur = 0;		// Current Receive Descriptor Buffer
+static uint16_t tx_cur = 0;		// Current Transmit Descriptor Buffer
 
 static void *tx_buffers[E1000_NUM_TX_DESC];
 
@@ -181,6 +182,7 @@ void e1000_handle_receive() {
 	}
 	netdev_t* dev = get_active_network_device();
 	if (!dev || dev->deviceid != ((INTEL_VEND << 16) | e1000_device_id)) {
+		dprintf("invalid dev in handle receive\n");
 		return;
 	}
 
@@ -213,6 +215,7 @@ bool e1000_send_packet(void *p_data, uint16_t p_len) {
 	}
 
 	if (!tx_descs[tx_cur]) {
+		dprintf("e1000: Bad send buffer\n");
 		return false;
 	}
 
@@ -258,7 +261,6 @@ void e1000_up() {
  */
 void e1000_handler([[maybe_unused]] uint8_t isr, [[maybe_unused]] uint64_t error, [[maybe_unused]] uint64_t irq, void* opaque) {
 	uint32_t status = e1000_read_command(REG_ICR);
-
 	if (status & ICR_RXT0) {
 		e1000_handle_receive();
 	}
@@ -420,4 +422,16 @@ void init_e1000() {
 	eerprom_exists = false;
 
 	e1000_start(&pci_device);
+
+	dhcp_discover();
+}
+
+bool EXPORTED MOD_INIT_SYM(KMOD_ABI)(void) {
+	dprintf("e1000: loaded\n");
+	init_e1000();
+	return true;
+}
+
+void EXPORTED MOD_EXIT_SYM(KMOD_ABI)(void) {
+	dprintf("e1000: unloaded\n");
 }
diff --git a/modules/e1000/e1000.h b/modules/e1000/e1000.h
diff --git a/modules/rtl8139/rtl8139.c b/modules/rtl8139/rtl8139.c
@@ -1,4 +1,5 @@
 #include <kernel.h>
+#include "rtl8139.h"
 
 #define TX_BUF_COUNT  4
 #define TX_BUF_SIZE   2048   // More than enough for Ethernet frame
@@ -338,4 +339,17 @@ void init_rtl8139() {
 	register_network_device(net);
 
 	interrupts_on();
+
+	dhcp_discover();
+}
+
+
+bool EXPORTED MOD_INIT_SYM(KMOD_ABI)(void) {
+	dprintf("rtl8139: loaded\n");
+	init_rtl8139();
+	return true;
+}
+
+void EXPORTED MOD_EXIT_SYM(KMOD_ABI)(void) {
+	dprintf("rtl8139: unloaded\n");
 }
diff --git a/modules/rtl8139/rtl8139.h b/modules/rtl8139/rtl8139.h
diff --git a/src/basic/sockets.c b/src/basic/sockets.c
@@ -53,7 +53,9 @@ void sockread_statement(struct basic_ctx* ctx)
 
 	process_t* proc = proc_cur(logical_cpu_id());
 
-	int rv = recv((int)fd, input, MAX_STRINGLEN, false, 10);
+	int rv = recv((int)fd, input, MAX_STRINGLEN, false, 100);
+
+	dprintf("sockread recv=%d\n", rv);
 
 	if (rv == 0) {
 		// Not ready yet, yield and retry later
diff --git a/src/ethernet.c b/src/ethernet.c
@@ -13,6 +13,7 @@ int ethernet_send_packet(uint8_t* dst_mac_addr, uint8_t* data, uint32_t len, uin
 	netdev_t* dev = get_active_network_device();
 	uint64_t flags;
 	if (!dev) {
+		dprintf("no active network device, not sending packet\n");
 		return 0;
 	}
 	lock_spinlock_irq(&ethernet_lock, &flags);
@@ -32,7 +33,9 @@ int ethernet_send_packet(uint8_t* dst_mac_addr, uint8_t* data, uint32_t len, uin
 	memcpy(frame->dst_mac_addr, dst_mac_addr, 6);
 	memcpy(frame_data, data, len);
 	frame->type = htons(protocol);
-	dprintf("ethernet_send_packet frame=%08lx\n", (uint64_t)frame);
+	dprintf("ethernet_send_packet dest=%02x:%02x:%02x:%02x:%02x:%02x src=%02x:%02x:%02x:%02x:%02x:%02x len=%u\n",
+		dst_mac_addr[0], dst_mac_addr[1], dst_mac_addr[2], dst_mac_addr[3], dst_mac_addr[4], dst_mac_addr[5],
+		src_mac_addr[0], src_mac_addr[1], src_mac_addr[2], src_mac_addr[3], src_mac_addr[4], src_mac_addr[5], len);
 	dev->send_packet(frame, sizeof(ethernet_frame_t) + len);
 	unlock_spinlock_irq(&ethernet_lock, flags);
 	return len;
diff --git a/src/init.c b/src/init.c
@@ -10,7 +10,7 @@ init_func_t init_funcs[] = {
 	init_acpi, init_idt, boot_aps, init_pci, init_realtime_clock,
 	init_devicenames, init_keyboard, init_ide, init_ahci,
 	init_filesystem, init_devfs, init_iso9660, init_fat32,
-	init_rfs, init_modules, init_rtl8139, init_e1000,
+	init_rfs, init_modules, network_up,
 	NULL,
 };
 
@@ -19,7 +19,7 @@ char* init_funcs_names[] = {
 	"idt",			"cpus",			"pci",		"clock",
 	"devicenames",		"keyboard",		"ide",		"ahci",
 	"filesystem",		"devfs",		"iso9660",	"fat32",
-	"rfs",			"modules",		"rtl8139",	"e1000",
+	"rfs",			"modules",		"network",
 	NULL,
 };
 
diff --git a/src/kernel.c b/src/kernel.c
@@ -7,11 +7,6 @@ void kmain()
 {
 	init();
 
-	if (get_active_network_device()) {
-		kprintf("Bringing up network...");
-		network_up();
-	}
-
 	bool live_cd = false, root_fs_mounted = false;
 	if (rr_kfile_req.response) {
 		struct limine_kernel_file_response* kernel_info = rr_kfile_req.response;
@@ -28,7 +23,8 @@ void kmain()
 		preboot_fail("Failed to mount boot drive to VFS!");
 	}
 
-	//load_module("test");
+	// TODO: Don't hard code this, give BASIC facility to load it via /programs/init
+	load_module("e1000");
 
 	init_process();
 }
diff --git a/src/net/arp.c b/src/net/arp.c
@@ -1,9 +1,9 @@
 #include <kernel.h>
 
-arp_table_entry_t arp_table[512];
+static arp_table_entry_t arp_table[512] = {};
 static uint8_t zero_hardware_addr[6] = {0, 0, 0, 0, 0, 0};
-int arp_table_size = 0;
-int arp_table_curr = 0;
+static int arp_table_size = 0;
+static int arp_table_curr = 0;
 
 arp_table_entry_t* get_arp_entry(size_t index) {
 	if (index > 512) {
@@ -30,6 +30,7 @@ void arp_handle_packet(arp_packet_t* arp_packet, [[maybe_unused]] int len) {
 	memcpy(dst_hardware_addr, arp_packet->src_hardware_addr, 6);
 	memcpy(dst_protocol_addr, arp_packet->src_protocol_addr, 4);
 	if (ntohs(arp_packet->opcode) == ARP_REQUEST) {
+		dprintf("arp request\n");
 		unsigned char addr[4];
 		uint32_t my_ip = 0;
 		if (gethostaddr(addr)) {
@@ -39,6 +40,7 @@ void arp_handle_packet(arp_packet_t* arp_packet, [[maybe_unused]] int len) {
 
 			netdev_t* dev = get_active_network_device();
 			if (!dev) {
+				dprintf("No active net dev (arp handle packet)\n");
 				return;
 			}
 
@@ -60,12 +62,16 @@ void arp_handle_packet(arp_packet_t* arp_packet, [[maybe_unused]] int len) {
 			arp_packet->protocol = htons(ETHERNET_TYPE_IP);
 
 			ethernet_send_packet(dst_hardware_addr, (uint8_t*)arp_packet, sizeof(arp_packet_t), ETHERNET_TYPE_ARP);
+		} else {
+			dprintf("Invalid addr %08x\n", my_ip);
 		}
 	} else if(ntohs(arp_packet->opcode) == ARP_REPLY) {
+		dprintf("ARP_REPLY from: %08x hw %02x:%02x:%02x:%02x:%02x:%02x\n", *(uint32_t*)&dst_protocol_addr, dst_hardware_addr[0], dst_hardware_addr[1], dst_hardware_addr[2], dst_hardware_addr[3], dst_hardware_addr[4], dst_hardware_addr[5]);
 	}
 
 	uint8_t dummy[6];
 	if (!arp_lookup(dummy, dst_protocol_addr)) {
+		dprintf("not in arp table, storing at %d\n", arp_table_size);
 		memcpy(&arp_table[arp_table_curr].ip_addr, dst_protocol_addr, 4);
 		memcpy(&arp_table[arp_table_curr++].mac_addr, dst_hardware_addr, 6);
 		if(arp_table_size < 512) {
@@ -81,6 +87,7 @@ void arp_handle_packet(arp_packet_t* arp_packet, [[maybe_unused]] int len) {
 void arp_send_packet(uint8_t* dst_hardware_addr, uint8_t* dst_protocol_addr) {
 	netdev_t* dev = get_active_network_device();
 	if (!dev) {
+		dprintf("arp send packet: no active net dev\n");
 		return;
 	}
 	static arp_packet_t * arp_packet = NULL;
@@ -103,6 +110,7 @@ void arp_send_packet(uint8_t* dst_hardware_addr, uint8_t* dst_protocol_addr) {
 	arp_packet->hardware_type = htons(HARDWARE_TYPE_ETHERNET);
 	arp_packet->protocol = htons(ETHERNET_TYPE_IP);
 
+	dprintf("arp send (broadcast) for %08x\n", *(uint32_t*)&dst_protocol_addr);
 	ethernet_send_packet(broadcast_mac_address, (uint8_t*)arp_packet, sizeof(arp_packet_t), ETHERNET_TYPE_ARP);
 }
 
diff --git a/src/net/dhcp.c b/src/net/dhcp.c
@@ -86,6 +86,7 @@ void dhcp_handle_packet(uint32_t src_ip, uint16_t src_port, uint16_t dst_port, v
 
 		/* Commit the lease address */
 		sethostaddr((const unsigned char*)&packet->your_ip);
+		dprintf("DHCP: sethostaddr(%08x)\n", packet->your_ip);
 
 		/* Optional parameters */
 		uint32_t* dns = get_dhcp_options(packet, OPT_DNS);
@@ -106,13 +107,15 @@ void dhcp_handle_packet(uint32_t src_ip, uint16_t src_port, uint16_t dst_port, v
 			setdnsaddr(*dns);
 			get_ip_str(ip, (uint8_t*)dns);
 			dprintf("DHCP: Received DNS address: %s\n", ip);
+			arp_prediscover((uint8_t*)dns);
 			kfree_null(&dns);
 		}
 
 		if (gateway != NULL) {
 			setgatewayaddr(*gateway);
 			get_ip_str(ip, (uint8_t*)gateway);
 			dprintf("DHCP: Received gateway address: %s\n", ip);
+			arp_prediscover((uint8_t*)gateway);
 			kfree_null(&gateway);
 		}
 
@@ -446,7 +449,4 @@ void dhcp_init(void) {
 
 	/* Background task is called every 1 ms in interrupt context */
 	proc_register_idle(&dhcp_background, IDLE_BACKGROUND, 1);
-
-	/* Kick off initial discovery */
-	dhcp_discover();
 }
diff --git a/src/net/ip.c b/src/net/ip.c
@@ -464,10 +464,8 @@ void ip_handle_packet(ip_packet_t* packet, [[maybe_unused]] int n_len) {
 				frag_map = hashmap_new(sizeof(ip_fragmented_packet_parts_t), 0, 564364368549036, 67545346834, ip_frag_hash, ip_frag_compare, NULL, NULL);
 			}
 			if (packet->frag.more_fragments_follow) {
-				dprintf("Fragment is one of set (MF)\n");
 				/* Packet is part of a fragmented set */
 				if (frag_offset == 0) {
-					dprintf("First fragment\n");
 					/* First fragment */
 					ip_fragmented_packet_parts_t fragmented = { .id = packet->id, .size = data_len, .ordered_list = NULL, .last_seen_ticks = get_ticks() };
 					ip_packet_frag_t* fragment = kmalloc(sizeof(ip_packet_frag_t));
@@ -484,7 +482,6 @@ void ip_handle_packet(ip_packet_t* packet, [[maybe_unused]] int n_len) {
 					frag_list_insert(fragment, fragmented.ordered_list);
 					hashmap_set(frag_map, &fragmented);
 				} else {
-					dprintf("Middle fragment\n");
 					/* Middle fragment */
 					ip_packet_t findpacket = { .id = packet->id };
 					ip_fragmented_packet_parts_t* fragmented = (ip_fragmented_packet_parts_t*)hashmap_get(frag_map, &findpacket);
@@ -507,13 +504,11 @@ void ip_handle_packet(ip_packet_t* packet, [[maybe_unused]] int n_len) {
 					memcpy(fragment->packet, packet, ntohs(packet->length));
 					frag_list_insert(fragment, fragmented->ordered_list);
 				}
-				dprintf("Returning, fragmented packet incomplete!\n");
 				return;
 			} else if (packet->frag.more_fragments_follow == 0 && (frag_offset != 0)) {
 				/* Final fragment of fragmented set.
 				 * Once we get this fragment, we can deliver the reassembled packet.
 				 */
-				dprintf("Final fragment\n");
 				ip_packet_t findpacket = { .id = packet->id };
 				ip_fragmented_packet_parts_t* fragmented = (ip_fragmented_packet_parts_t*)hashmap_get(frag_map, &findpacket);
 				if (fragmented == NULL) {
@@ -560,7 +555,6 @@ void ip_handle_packet(ip_packet_t* packet, [[maybe_unused]] int n_len) {
 					cur = next;
 				}
 
-				dprintf("Removing list from frag_map\n");
 				hashmap_delete(frag_map, &findpacket);
 				/* Now we have reassembled the data portion, we can fall through and let the packet be handled... */
 			}
diff --git a/src/net/net.c b/src/net/net.c
@@ -95,17 +95,11 @@ uint32_t ntohl(uint32_t netlong) {
 
 void network_up()
 {
-	kprintf(" ARP,");
 	arp_init();
-	kprintf(" IP,");
 	ip_init();
-	kprintf(" TCP,");
 	tcp_init();
-	kprintf(" DHCP,");
 	dhcp_init();
-	kprintf(" DNS");
 	init_dns();
-	kprintf("\n");
 }
 
 void network_down()
diff --git a/src/net/tcp.c b/src/net/tcp.c
diff --git a/src/taskswitch.c b/src/taskswitch.c
diff --git a/src/timer.c b/src/timer.c

Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,6 @@ void kmain()`
`7`	`7`	`{`
`8`	`8`	`init();`
`9`	`9`
`10`		`- if (get_active_network_device()) {`
`11`		`- kprintf("Bringing up network...");`
`12`		`- network_up();`
`13`		`- }`
`14`		`-`
`15`	`10`	`bool live_cd = false, root_fs_mounted = false;`
`16`	`11`	`if (rr_kfile_req.response) {`
`17`	`12`	`struct limine_kernel_file_response* kernel_info = rr_kfile_req.response;`
`@@ -28,7 +23,8 @@ void kmain()`
`28`	`23`	`preboot_fail("Failed to mount boot drive to VFS!");`
`29`	`24`	`}`
`30`	`25`
`31`		`- //load_module("test");`
	`26`	`+ // TODO: Don't hard code this, give BASIC facility to load it via /programs/init`
	`27`	`+ load_module("e1000");`
`32`	`28`
`33`	`29`	`init_process();`
`34`	`30`	`}`