enable the virtual timer interrupt on application processors

The switch from the physical timer (CNTP_*) to the virtual timer
(CNTV_*) updated the FDT parsing in init(), which now selects the
third interrupt triplet of the "arm,armv8-timer" node (Virtual, PPI
11 / INTID 27). init_cpu() still selected the second triplet
(Non-secure Phys, PPI 14 / INTID 30), so every application processor
enabled the physical timer PPI in its redistributor while
set_oneshot_timer programs the virtual timer. Timer PPIs are per-core:
sleeping tasks on the secondary cores were never woken up again.

This is why thread_test with --smp 4 timed out: of eight threads only
the two scheduled on the boot core finished; the six on the secondary
cores slept forever.

Skip the same two triplets in init_cpu() so all cores enable the
virtual timer interrupt.

Author: stlankes

src/arch/aarch64/kernel/interrupts.rs

@@ -449,11 +449,19 @@ pub fn init_cpu() {
 
 	if let Some(timer_node) = fdt.find_compatible(&["arm,armv8-timer", "arm,armv7-timer"]) {
 		let irq_slice = timer_node.property("interrupts").unwrap().value;
-		/* Secure Phys IRQ */
+		// Select the Virtual Timer triplet, matching `init()`: the kernel
+		// programs the virtual timer (CNTV_*), and timer PPIs are per-core,
+		// so every application processor has to enable the *same* interrupt
+		// in its redistributor that the boot core selected.
+		/* Secure Phys IRQ — skip */
 		let (_irqtype, irq_slice) = irq_slice.split_at(size_of::<u32>());
 		let (_irq, irq_slice) = irq_slice.split_at(size_of::<u32>());
 		let (_irqflags, irq_slice) = irq_slice.split_at(size_of::<u32>());
-		/* Non-secure Phys IRQ */
+		/* Non-secure Phys IRQ — skip */
+		let (_irqtype, irq_slice) = irq_slice.split_at(size_of::<u32>());
+		let (_irq, irq_slice) = irq_slice.split_at(size_of::<u32>());
+		let (_irqflags, irq_slice) = irq_slice.split_at(size_of::<u32>());
+		/* Virtual Timer IRQ */
 		let (irqtype, irq_slice) = irq_slice.split_at(size_of::<u32>());
 		let (irq, irq_slice) = irq_slice.split_at(size_of::<u32>());
 		let (irqflags, _irq_slice) = irq_slice.split_at(size_of::<u32>());

src/executor/network.rs

@@ -402,7 +402,6 @@ impl<'a> NetworkInterface<'a> {
 	))]
 	fn handle_interrupt(&mut self) {
 		self.get_inner_device().handle_interrupt();
-<<<<<<< HEAD
 	}
 
 	#[cfg(all(
@@ -414,20 +413,14 @@ impl<'a> NetworkInterface<'a> {
 	fn handle_device_configuration_interrupt(&mut self) {
 		self.get_inner_device()
 			.handle_device_configuration_interrupt();
-=======
->>>>>>> 456cbb6b1 (feat(network): support packet capture file creation)
 	}
 
 	pub(crate) fn set_polling_mode(&mut self, value: bool) {
 		self.get_inner_device().set_polling_mode(value);
 	}
 
 	/// Gets the device inside the [smoltcp::phy::Tracer] and [smoltcp::phy::PcapWriter] layers.
-<<<<<<< HEAD
 	fn get_inner_device(&mut self) -> &mut NetworkDevice {
-=======
-	fn get_inner_device(&mut self) -> &mut impl NetworkDriver {
->>>>>>> 456cbb6b1 (feat(network): support packet capture file creation)
 		let device = &mut self.device;
 		#[cfg(feature = "net-trace")]
 		let device = device.get_mut();