WIP

Author: Gelbpunkt

src/arch/aarch64/kernel/interrupts.rs

@@ -22,6 +22,8 @@ use crate::drivers::mmio::get_interrupt_handlers;
 #[cfg(feature = "pci")]
 use crate::drivers::pci::get_interrupt_handlers;
 use crate::drivers::{InterruptHandlerQueue, InterruptLine};
+#[cfg(feature = "net")]
+use crate::executor::network::NETWORK_WAKER;
 use crate::kernel::serial::handle_uart_interrupt;
 use crate::mm::{PageAlloc, PageRangeAllocator};
 use crate::scheduler::{self, CoreId};
@@ -94,6 +96,11 @@ pub(crate) fn install_handlers() {
 	fn timer_handler() {
 		debug!("Handle timer interrupt");
 
+		// FIXME this is ugly as hell
+		debug!("Waking network waker");
+		#[cfg(feature = "net")]
+		NETWORK_WAKER.lock().wake();
+
 		// disable timer
 		CNTP_CVAL_EL0.set(0);
 		CNTP_CTL_EL0.write(CNTP_CTL_EL0::ENABLE::CLEAR);

src/drivers/net/gem.rs

@@ -32,6 +32,7 @@ use crate::drivers::net::{NetworkDriver, mtu};
 #[cfg(feature = "pci")]
 use crate::drivers::pci as hardware;
 use crate::drivers::{Driver, InterruptLine};
+use crate::executor::network::NETWORK_WAKER;
 use crate::mm::device_alloc::DeviceAlloc;
 use crate::{BasePageSize, PageSize};
 
@@ -276,6 +277,9 @@ impl NetworkDriver for GEMDriver {
 
 	fn handle_interrupt(&mut self) {
 		self.tx_fields.handle_interrupt();
+
+		debug!("Waking network waker");
+		NETWORK_WAKER.lock().wake();
 	}
 }
 

src/drivers/net/virtio/mod.rs

@@ -41,6 +41,7 @@ use crate::drivers::virtio::virtqueue::{
 	AvailBufferToken, BufferElem, BufferType, UsedBufferToken, VirtQueue, Virtq,
 };
 use crate::drivers::{Driver, InterruptLine};
+use crate::executor::network::{NETWORK_WAKER, NIC};
 use crate::mm::device_alloc::DeviceAlloc;
 
 /// A wrapper struct for the raw configuration structure.
@@ -415,7 +416,14 @@ impl NetworkDriver for VirtioNetDriver<Init> {
 			todo!("Implement possibility to change config on the fly...")
 		}
 
+		error!("virtio interrupt");
+
 		self.isr_stat.acknowledge();
+
+		debug!("Waking network waker");
+		NETWORK_WAKER.lock().wake();
+
+		error!("meow after");
 	}
 }
 

src/executor/mod.rs

@@ -155,48 +155,12 @@ where
 
 		let now = crate::arch::kernel::systemtime::now_micros();
 		if let Poll::Ready(t) = result {
-			// allow network interrupts
-			#[cfg(feature = "net")]
-			{
-				if let Some(mut guard) = crate::executor::network::NIC.try_lock() {
-					let delay = if let Ok(nic) = guard.as_nic_mut() {
-						nic.set_polling_mode(false);
-
-						nic.poll_delay(Instant::from_micros_const(now.try_into().unwrap()))
-							.map(|d| d.total_micros())
-					} else {
-						None
-					};
-					core_local::core_scheduler().add_network_timer(
-						delay.map(|d| crate::arch::processor::get_timer_ticks() + d),
-					);
-				}
-			}
-
 			return t;
 		}
 
 		if let Some(duration) = timeout
 			&& Duration::from_micros(now - start) >= duration
 		{
-			// allow network interrupts
-			#[cfg(feature = "net")]
-			{
-				if let Some(mut guard) = crate::executor::network::NIC.try_lock() {
-					let delay = if let Ok(nic) = guard.as_nic_mut() {
-						nic.set_polling_mode(false);
-
-						nic.poll_delay(Instant::from_micros_const(now.try_into().unwrap()))
-							.map(|d| d.total_micros())
-					} else {
-						None
-					};
-					core_local::core_scheduler().add_network_timer(
-						delay.map(|d| crate::arch::processor::get_timer_ticks() + d),
-					);
-				}
-			}
-
 			return Err(Errno::Time);
 		}
 
@@ -227,7 +191,7 @@ where
 
 				// restore default values
 				if let Ok(nic) = crate::executor::network::NIC.lock().as_nic_mut() {
-					nic.set_polling_mode(true);
+					//nic.set_polling_mode(true);
 				}
 
 				backoff.reset();

src/executor/network.rs

@@ -26,7 +26,7 @@ use crate::arch;
 use crate::drivers::net::{NetworkDevice, NetworkDriver};
 #[cfg(feature = "dns")]
 use crate::errno::Errno;
-use crate::executor::spawn;
+use crate::executor::{WakerRegistration, spawn};
 #[cfg(feature = "dns")]
 use crate::io;
 use crate::scheduler::PerCoreSchedulerExt;
@@ -189,14 +189,36 @@ async fn dhcpv4_run() {
 	.await;
 }
 
+pub(crate) static NETWORK_WAKER: InterruptTicketMutex<WakerRegistration> =
+	InterruptTicketMutex::new(WakerRegistration::new());
+
 async fn network_run() {
 	future::poll_fn(|cx| {
 		if let Some(mut guard) = NIC.try_lock() {
 			match &mut *guard {
 				NetworkState::Initialized(nic) => {
-					nic.poll_common(now());
-					// FIXME: only wake when progress can be made
-					cx.waker().wake_by_ref();
+					let now = now();
+
+					// TODO: smoltcp is probably not exposing enough information here
+					// Well, how could it! Impossible :)
+					match nic.poll_common(now) {
+						PollResult::SocketStateChanged => {
+							// Progress was made
+							cx.waker().wake_by_ref();
+						}
+						PollResult::None => {
+							// Very likely no progress can be made, so set up a timer interrupt to wake the waker
+							NETWORK_WAKER.lock().register(cx.waker());
+							nic.set_polling_mode(false);
+							let wakeup_time = nic.poll_delay(now).map(|d| {
+								crate::arch::processor::get_timer_ticks() + d.total_micros()
+							});
+							crate::core_scheduler().add_network_timer(wakeup_time);
+							info!("Configured an interrupt for {wakeup_time:?}");
+							//cx.waker().wake_by_ref();
+						}
+					}
+
 					Poll::Pending
 				}
 				_ => Poll::Ready(()),

src/fd/socket/tcp.rs

@@ -13,7 +13,7 @@ use smoltcp::wire::{IpEndpoint, Ipv4Address, Ipv6Address};
 
 use crate::errno::Errno;
 use crate::executor::block_on;
-use crate::executor::network::{Handle, NIC};
+use crate::executor::network::{Handle, NETWORK_WAKER, NIC};
 use crate::fd::{self, Endpoint, ListenEndpoint, ObjectInterface, PollEvent, SocketOption};
 use crate::syscalls::socket::Af;
 use crate::{DEFAULT_KEEP_ALIVE_INTERVAL, io};
@@ -65,14 +65,20 @@ impl Socket {
 	fn with<R>(&self, f: impl FnOnce(&mut tcp::Socket<'_>) -> R) -> R {
 		let mut guard = NIC.lock();
 		let nic = guard.as_nic_mut().unwrap();
-		f(nic.get_mut_socket::<tcp::Socket<'_>>(*self.handle.first().unwrap()))
+		let r = f(nic.get_mut_socket::<tcp::Socket<'_>>(*self.handle.first().unwrap()));
+		// FIXME: Ideally this would be our send/recv waker, but we can only have one
+		NETWORK_WAKER.lock().wake();
+		r
 	}
 
 	fn with_context<R>(&self, f: impl FnOnce(&mut tcp::Socket<'_>, &mut iface::Context) -> R) -> R {
 		let mut guard = NIC.lock();
 		let nic = guard.as_nic_mut().unwrap();
 		let (s, cx) = nic.get_socket_and_context::<tcp::Socket<'_>>(*self.handle.first().unwrap());
-		f(s, cx)
+		let r = f(s, cx);
+		// FIXME: Ideally this would be our send/recv waker, but we can only have one
+		NETWORK_WAKER.lock().wake();
+		r
 	}
 
 	async fn close(&self) -> io::Result<()> {

src/fd/socket/udp.rs

@@ -10,7 +10,7 @@ use smoltcp::wire::{IpEndpoint, Ipv4Address, Ipv6Address};
 
 use crate::errno::Errno;
 use crate::executor::block_on;
-use crate::executor::network::{Handle, NIC};
+use crate::executor::network::{Handle, NETWORK_WAKER, NIC};
 use crate::fd::{self, Endpoint, ListenEndpoint, ObjectInterface, PollEvent};
 use crate::io;
 use crate::syscalls::socket::Af;
@@ -44,7 +44,9 @@ impl Socket {
 	fn with<R>(&self, f: impl FnOnce(&mut udp::Socket<'_>) -> R) -> R {
 		let mut guard = NIC.lock();
 		let nic = guard.as_nic_mut().unwrap();
-		f(nic.get_mut_socket::<udp::Socket<'_>>(self.handle))
+		let r = f(nic.get_mut_socket::<udp::Socket<'_>>(self.handle));
+		NETWORK_WAKER.lock().wake();
+		r
 	}
 
 	async fn close(&self) -> io::Result<()> {