net: rtl and e1000 can reply to ARP

Author: tyler569

include/ng/net.h

@@ -17,11 +17,13 @@ struct net_if {
 	struct net_if_vtbl *vtbl;
 };
 
+#define NET_SEND(nif, pk) (nif)->vtbl->send(nif, pk)
+
 uint16_t net_checksum_add(uint16_t *addr, int count, uint16_t sum);
 uint16_t net_checksum_finish(uint16_t sum);
 uint16_t net_checksum_begin(uint16_t *addr, int count);
 uint16_t net_checksum(uint16_t *addr, int count);
 
-void print_ip4_addr(struct in_addr *);
-void print_ip6_addr(struct in6_addr *);
-void print_ip6_addr_abbrev(struct in6_addr *);
+void net_ingress(struct pk *pk);
+
+void net_worker();

kernel/CMakeLists.txt

@@ -87,6 +87,8 @@ add_executable(nightingale_kernel
     net/ip_ingress.c
     net/arp.c
     net/net_ingress.c
+    net/worker.c
+    net/ip_egress.c
 )
 
 if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "X86_64")

kernel/drv/e1000.c

@@ -166,7 +166,7 @@ static void e1000_reset(struct e1000 *e) {
 
 	w32(IMC, INT_ALL);
 
-	__atomic_thread_fence(__ATOMIC_SEQ_CST);
+	__atomic_thread_fence(memory_order_seq_cst);
 }
 
 static uint16_t e1000_eeprom_read(struct e1000 *e, uint8_t addr) {
@@ -265,8 +265,7 @@ static void e1000_log_link_status(struct e1000 *e) {
 }
 
 static void e1000_send(struct e1000 *e, void *data, size_t len) {
-	int i = 0;
-	uint32_t tail = e->tx;
+	int tail = e->tx;
 
 	struct e1000_tx_desc *desc = &e->tx_descs[tail];
 	memcpy(e->tx_buffer + tail * TX_BUFFER_SIZE, data, len);
@@ -277,17 +276,15 @@ static void e1000_send(struct e1000 *e, void *data, size_t len) {
 
 	printf("e1000: sending %zu bytes, tail is now %u\n", len, tail);
 
-	__atomic_thread_fence(__ATOMIC_RELEASE);
+	__atomic_thread_fence(memory_order_release);
 
 	e->tx = tail;
 	w32(TDT, tail);
 }
 
-void net_ingress(struct pk *pk);
-
 static void e1000_receive(struct e1000 *e) {
-	uint32_t head = r32(RDH);
-	uint32_t tail = e->rx;
+	int head = r32(RDH);
+	int tail = e->rx;
 
 	while (head != tail) {
 		printf("head: %u, tail: %u\n", head, tail);
@@ -297,14 +294,19 @@ static void e1000_receive(struct e1000 *e) {
 			break;
 
 		void *data = e->rx_buffer + tail * RX_BUFFER_SIZE;
+
+		// TODO: don't call ingress in the interrupt,
+		// this has to go to a queue.
 		struct pk *pk = pk_alloc();
 		pk->len = desc->length;
+		pk->origin_if = &e->nif;
 		memcpy(pk->data, data, desc->length);
 		net_ingress(pk);
 
 		desc->status = 0;
+		desc->length = RX_BUFFER_SIZE;
 
-		__atomic_thread_fence(__ATOMIC_RELEASE);
+		__atomic_thread_fence(memory_order_release);
 
 		w32(RDT, tail);
 
@@ -313,7 +315,12 @@ static void e1000_receive(struct e1000 *e) {
 	}
 }
 
-static void e1000_init(struct e1000 *e) {
+static struct net_if_vtbl net_e1000_vtbl;
+
+static void e1000_init(struct e1000 *e, pci_address_t addr) {
+	e->addr = addr;
+	e->nif.vtbl = &net_e1000_vtbl;
+
 	pci_enable_bus_mastering(e->addr);
 
 	for (int i = 0; i < 2; i++) {
@@ -393,11 +400,18 @@ static void e1000_handle_interrupt(interrupt_frame *, void *data) {
 	e1000_acknowledge_interrupts(e, icr);
 }
 
+static void e1000_send_pk(struct net_if *nif, struct pk *pk) {
+	struct e1000 *e = container_of(struct e1000, nif, nif);
+	e1000_send(e, pk->data, pk->len);
+}
+
+static struct net_if_vtbl net_e1000_vtbl = {
+	.send = e1000_send_pk,
+};
+
 void e1000_test(pci_address_t addr) {
 	struct e1000 *e = calloc(1, sizeof(struct e1000));
-	e->addr = addr;
-
-	e1000_init(e);
+	e1000_init(e, addr);
 	e1000_log_link_status(e);
 
 	uint32_t interrupt_state = r32(IMS);

kernel/drv/rtl8139.c

@@ -3,7 +3,9 @@
 #include <ng/debug.h>
 #include <ng/irq.h>
 #include <ng/limine.h>
+#include <ng/net.h>
 #include <ng/pci.h>
+#include <ng/pk.h>
 #include <ng/pmm.h>
 #include <ng/vmm.h>
 #include <stdio.h>
@@ -18,6 +20,8 @@
 #endif
 
 struct rtl8139 {
+	struct net_if nif;
+
 	struct eth_addr mac;
 
 	uint16_t io_base;
@@ -76,10 +80,14 @@ static void enable_interrupts(struct rtl8139 *r, int);
 static void enable_txrx(struct rtl8139 *r);
 static void tx_write(struct rtl8139 *r, uint32_t data, size_t size);
 static bool rx_empty(struct rtl8139 *r);
+static void rtl8139_send_pk(struct net_if *nif, struct pk *pk);
+static struct net_if_vtbl net_rtl8139_vtbl = { .send = rtl8139_send_pk };
 
 void rtl8139_init(struct rtl8139 *r, pci_address_t pci_address) {
 	verbose_printf("rtl8139: init\n");
 
+	r->nif.vtbl = &net_rtl8139_vtbl;
+
 	uint32_t bar0 = pci_read32(pci_address, PCI_BAR0);
 	uint32_t bar1 = pci_read32(pci_address, PCI_BAR1);
 	if ((bar0 & 1) == 1) {
@@ -192,6 +200,11 @@ void rtl8139_send(struct rtl8139 *r, void *data, size_t size) {
 	tx_write(r, data_phy, size);
 }
 
+static void rtl8139_send_pk(struct net_if *nif, struct pk *pk) {
+	struct rtl8139 *r = container_of(struct rtl8139, nif, nif);
+	rtl8139_send(r, pk->data, pk->len);
+}
+
 uint16_t *read_packet_header(struct rtl8139 *r) {
 	return (uint16_t *)(r->rx_buffer + r->rx_index);
 }
@@ -219,13 +232,6 @@ ssize_t rtl8139_receive(struct rtl8139 *r, void *data, size_t len) {
 	return result;
 }
 
-void net_debug(int, const void *, size_t);
-
-void print_packet(const void *data, size_t len) {
-	printf("rtl8139: received packet of length %zu\n", len);
-	net_debug(0, data, len);
-}
-
 void rtl8139_interrupt_handler(interrupt_frame *_, void *rtl) {
 	struct rtl8139 *r = rtl;
 
@@ -239,12 +245,11 @@ void rtl8139_interrupt_handler(interrupt_frame *_, void *rtl) {
 		verbose_printf("rtl8139: rx ok\n");
 
 		while (!rx_empty(r)) {
-			char buffer[2048];
-			ssize_t len = rtl8139_receive(r, buffer, sizeof(buffer));
-#ifdef VERBOSE
-			if (len > 0)
-				print_packet(buffer, len);
-#endif
+			struct pk *pk = pk_alloc();
+			ssize_t len = rtl8139_receive(r, pk->data, sizeof(pk->data));
+			pk->len = len;
+			pk->origin_if = &r->nif;
+			net_ingress(pk);
 		}
 
 	} else if ((int_flag & INTR_RX_ERR) != 0) {
@@ -271,12 +276,5 @@ void rtl_test() {
 		int irq = pci_read8(pci_address, PCI_INTERRUPT_LINE);
 
 		irq_install(irq, rtl8139_interrupt_handler, r);
-
-		unsigned char ethernet_frame[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-			0x52, 0x54, 0x00, 0x12, 0x34, 0x56, 0x08, 0x06, 0x00, 0x01, 0x08,
-			0x00, 0x06, 0x04, 0x00, 0x01, 0x52, 0x54, 0x00, 0x12, 0x34, 0x56,
-			0x0a, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
-			0x00, 0x02, 0x02 };
-		rtl8139_send(r, ethernet_frame, sizeof(ethernet_frame));
 	}
 }

kernel/net/arp.c

@@ -2,6 +2,7 @@
 #include <netinet/debug.h>
 #include <netinet/hdr.h>
 #include <netinet/in.h>
+#include <ng/net.h>
 #include <ng/pk.h>
 #include <stdio.h>
 #include <string.h>
@@ -102,8 +103,10 @@ void arp_ingress(struct pk *pk) {
 
 		reply->len = reply->l3_offset + sizeof(struct arp_hdr);
 
-		printf("want to send:\n");
+		printf("sending:\n");
 		net_debug_pk(reply);
+
+		NET_SEND(pk->origin_if, reply);
 	}
 
 	pk_drop(pk);

kernel/net/ip_egress.c

@@ -1,5 +1,28 @@
+#include <arpa/inet.h>
+#include <netinet/hdr.h>
 #include <ng/net.h>
 #include <ng/pk.h>
-#include <rbtree.h>
 
-void ip_egress(struct pk *pk) { }
+struct ip_output {
+	struct net_if *interface;
+	in_addr_t src_ip;
+};
+
+struct ip_output outputs[8];
+
+void ip_egress(struct pk *pk) {
+	struct ipv4_hdr *ip = (struct ipv4_hdr *)(pk->data + pk->l3_offset);
+	in_addr_t src_ip = ntohl(ip->src.s_addr);
+
+	for (int i = 0; i < 8; i++) {
+		if (outputs[i].interface == nullptr) {
+			break;
+		}
+
+		if (outputs[i].src_ip == src_ip) {
+			struct net_if *net_if = outputs[i].interface;
+			NET_SEND(net_if, pk);
+			return;
+		}
+	}
+}

kernel/net/worker.c

@@ -0,0 +1,11 @@
+#include <arpa/inet.h>
+#include <netinet/hdr.h>
+#include <ng/net.h>
+#include <ng/pk.h>
+
+struct pk *net_ingress_head = nullptr;
+struct pk *net_ingress_tail = nullptr;
+
+void net_worker() {
+	while (true) { }
+}

run.rb

@@ -8,7 +8,7 @@
   stdio: "serial",
   tee: true,
   smp: 2,
-  network: "e1000",
+  network: "rtl",
   debug_wait: false,
   disk_image: "none",
   video: false,