WIP

Author: Gelbpunkt

src/arch/aarch64/kernel/interrupts.rs

@@ -17,11 +17,14 @@ use memory_addresses::arch::aarch64::PhysAddr;
 use crate::arch::aarch64::kernel::core_local::increment_irq_counter;
 use crate::arch::aarch64::kernel::scheduler::State;
 use crate::arch::aarch64::mm::paging::{self, BasePageSize, PageSize, PageTableEntryFlags};
+use crate::arch::timer_interrupts;
 #[cfg(not(feature = "pci"))]
 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,9 +97,12 @@ pub(crate) fn install_handlers() {
 	fn timer_handler() {
 		debug!("Handle timer interrupt");
 
-		// disable timer
-		CNTP_CVAL_EL0.set(0);
-		CNTP_CTL_EL0.write(CNTP_CTL_EL0::ENABLE::CLEAR);
+		timer_interrupts::clear_active();
+		if !timer_interrupts::set_next_timer() {
+			// disable timer
+			CNTP_CVAL_EL0.set(0);
+			CNTP_CTL_EL0.write(CNTP_CTL_EL0::ENABLE::CLEAR);
+		}
 	}
 
 	for (key, value) in get_interrupt_handlers().into_iter() {

src/arch/mod.rs

@@ -1,5 +1,7 @@
 //! Architecture-specific architecture abstraction.
 
+pub(crate) mod timer_interrupts;
+
 cfg_if::cfg_if! {
 	if #[cfg(target_arch = "aarch64")] {
 		pub(crate) mod aarch64;

src/arch/timer_interrupts.rs

@@ -0,0 +1,93 @@
+use core::sync::atomic::{AtomicU64, Ordering};
+
+use crate::set_oneshot_timer;
+
+/// A possible timer interrupt source (i.e. reason the timer interrupt was set
+/// up).
+#[derive(PartialEq, Eq)]
+pub enum Source {
+	Network,
+	Scheduler,
+}
+
+/// A slot in the timer list. Each source is represented once. This is so that
+/// we can have multiple timers at the same time with only one hardware timer.
+struct Slot {
+	/// Timer source.
+	source: Source,
+	/// Point in time at which to wake up (in microsecond precision).
+	/// A value of [`u64::MAX`] means the timer is not set.
+	wakeup_time: AtomicU64,
+}
+
+/// The actual timer list with one entry for each source.
+static TIMERS: [Slot; 2] = [
+	Slot {
+		source: Source::Network,
+		wakeup_time: AtomicU64::new(u64::MAX),
+	},
+	Slot {
+		source: Source::Scheduler,
+		wakeup_time: AtomicU64::new(u64::MAX),
+	},
+];
+
+/// Create a new timer, overriding any previous timer for the source.
+pub fn create_timer(source: Source, wakeup_micros: u64) {
+	let wakeup_time = crate::arch::processor::get_timer_ticks() + wakeup_micros;
+
+	{
+		// SAFETY: Our timer list has an entry for every possible source
+		let previous_entry = TIMERS.iter().find(|slot| slot.source == source).unwrap();
+
+		// Overwite the wakeup time
+		previous_entry
+			.wakeup_time
+			.store(wakeup_time, Ordering::Relaxed);
+	}
+
+	// If this timer is the one closest in the future, set the real timer to it
+	// SAFETY: There's more than 1 slot
+	if TIMERS
+		.iter()
+		.map(|slot| slot.wakeup_time.load(Ordering::Relaxed))
+		.min_by(|a, b| a.cmp(b))
+		.unwrap()
+		== wakeup_time
+	{
+		set_oneshot_timer(Some(wakeup_time));
+	}
+}
+
+/// Sets the next timer, returns `false` if no timer is set.
+pub fn set_next_timer() -> bool {
+	// SAFETY: There's more than 1 slot
+	let lowest_timer = TIMERS
+		.iter()
+		.map(|slot| slot.wakeup_time.load(Ordering::Relaxed))
+		.min_by(|a, b| a.cmp(b))
+		.unwrap();
+
+	if lowest_timer == u64::MAX {
+		false
+	} else {
+		set_oneshot_timer(Some(lowest_timer));
+
+		true
+	}
+}
+
+/// Clears the timer slot for the currently active timer.
+pub fn clear_active() {
+	// SAFETY: There's more than 1 slot
+	let lowest_timer = TIMERS
+		.iter()
+		.min_by(|a, b| {
+			a.wakeup_time
+				.load(Ordering::Relaxed)
+				.cmp(&b.wakeup_time.load(Ordering::Relaxed))
+		})
+		.unwrap();
+
+	lowest_timer.wakeup_time.store(u64::MAX, Ordering::Relaxed);
+}

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/loopback.rs

@@ -8,6 +8,7 @@ use smoltcp::time::Instant;
 
 use crate::drivers::net::NetworkDriver;
 use crate::drivers::{Driver, InterruptLine};
+use crate::executor::network::NETWORK_WAKER;
 use crate::mm::device_alloc::DeviceAlloc;
 
 pub(crate) struct LoopbackDriver {
@@ -122,7 +123,8 @@ impl NetworkDriver for LoopbackDriver {
 	}
 
 	fn handle_interrupt(&mut self) {
-		// no-op
+		debug!("Waking network waker");
+		NETWORK_WAKER.lock().wake();
 	}
 }
 

src/drivers/net/rtl8139.rs

@@ -21,6 +21,7 @@ use crate::drivers::Driver;
 use crate::drivers::error::DriverError;
 use crate::drivers::net::{NetworkDriver, mtu};
 use crate::drivers::pci::PciDevice;
+use crate::executor::network::NETWORK_WAKER;
 use crate::mm::device_alloc::DeviceAlloc;
 
 /// size of the receive buffer
@@ -687,6 +688,9 @@ impl NetworkDriver for RTL8139Driver {
 		self.regs.as_mut_ptr().isr().write(le16::from(
 			isr_contents & (ISR_RXOVW | ISR_TER | ISR_RER | ISR_TOK | ISR_ROK),
 		));
+
+		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;
 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

@@ -18,15 +18,11 @@ use core::time::Duration;
 
 use crossbeam_utils::Backoff;
 use hermit_sync::without_interrupts;
-#[cfg(feature = "net")]
-use smoltcp::time::Instant;
 
 use crate::arch::core_local;
 use crate::errno::Errno;
 use crate::executor::task::AsyncTask;
 use crate::io;
-#[cfg(feature = "net")]
-use crate::scheduler::PerCoreSchedulerExt;
 use crate::synch::futex::*;
 
 /// WakerRegistration is derived from smoltcp's
@@ -155,101 +151,27 @@ 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);
 		}
 
-		#[cfg(feature = "net")]
+		// TODO: I have no idea whether this is correct
 		if backoff.is_completed() {
-			let delay = if let Some(mut guard) = crate::executor::network::NIC.try_lock() {
-				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
-				}
-			} else {
-				None
-			};
-
-			if delay.unwrap_or(10_000_000) > 10_000 {
-				core_local::core_scheduler().add_network_timer(
-					delay.map(|d| crate::arch::processor::get_timer_ticks() + d),
-				);
-				let wakeup_time =
-					timeout.map(|duration| start + u64::try_from(duration.as_micros()).unwrap());
-
-				// switch to another task
-				task_notify.wait(wakeup_time);
-
-				// restore default values
-				if let Ok(nic) = crate::executor::network::NIC.lock().as_nic_mut() {
-					nic.set_polling_mode(true);
-				}
-
-				backoff.reset();
-			}
-		} else {
-			backoff.snooze();
-		}
-
-		#[cfg(not(feature = "net"))]
-		{
-			if backoff.is_completed() {
-				let wakeup_time =
-					timeout.map(|duration| start + u64::try_from(duration.as_micros()).unwrap());
+			let wakeup_time =
+				timeout.map(|duration| start + u64::try_from(duration.as_micros()).unwrap());
 
-				// switch to another task
-				task_notify.wait(wakeup_time);
+			// switch to another task
+			task_notify.wait(wakeup_time);
 
-				// restore default values
-				backoff.reset();
-			} else {
-				backoff.snooze();
-			}
+			// restore default values
+			backoff.reset();
+		} else {
+			backoff.snooze();
 		}
 	}
 }

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(()),