drivers: timer: native_sim_timer: keep the model ticking at the tick period

hwtimer_enable() sets the period the timer model free-runs at, so arming
the next announce with it stretched that period out to the whole span and
let the model reach the deadline in a single step.

The model paces simulated time against real time once per tick expiry, so
one step of the whole span leaves nothing to pace it. Under
CONFIG_NATIVE_SIM_SLOWDOWN_TO_REAL_TIME an idle with no timeout arms
0x7fffffff ticks, simulated time leaves the wall clock ~248 days behind in
one go, and the model then tries to sleep off the difference. Simulated
time is no longer related to real time and anything sharing the simulation
with a real-world peer stalls: CI hit this on the native offloaded sockets
tests that talk to a host TLS server (net.sockets.tls12.ec_kex,
net.sockets.tls12.psk_kex and sample.net.sockets.http_get.nsos.https all
hung in connect()).

Arm through hwtimer_set_silent_ticks() instead, as the driver did before
the conversion: the period stays at one tick, the model keeps stepping --
and pacing -- a tick at a time, and the ticks up to the deadline are passed
over without raising an interrupt. hwtimer_enable() goes back to the single
call at init that sets that period.

Fixes: 0342c93 ("drivers: timer: native_sim_timer: use the generic timer core")

Signed-off-by: Benjamin Cabé <benjamin@zephyrproject.org>
Assisted-by: Claude:opus-5

Author: kartben

drivers/timer/native_sim_timer.c

@@ -13,6 +13,7 @@
 #include <zephyr/init.h>
 #include <zephyr/drivers/timer/system_timer.h>
 #include <zephyr/sys/clock.h>
+#include <zephyr/sys/util.h>
 #include "nsi_hw_scheduler.h"
 #include "nsi_timer_model.h"
 #include "soc.h"
@@ -26,13 +27,27 @@ static uint64_t timer_driver_cycle_get(void)
 	return nsi_hws_get_time();
 }
 
+/* Microseconds per kernel tick, the core's TIMER_CORE_CYC_PER_TICK, needed here
+ * before the core is included.
+ */
+#define NP_TICK_PERIOD_US (CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC)
+
 /**
- * Program the next tick interrupt <cycles> microseconds from now.
- * hwtimer_enable() re-anchors the tick period at the current time.
+ * Program the next tick interrupt <cycles> microseconds from now, by passing over
+ * the tick expiries in between.
+ *
+ * Stretching the model's tick period with hwtimer_enable() instead would let it
+ * reach the deadline in a single step, which leaves CONFIG_NATIVE_SIM_SLOWDOWN_TO_REAL_TIME
+ * with nothing to pace simulated time against: that runs once per tick expiry.
+ *
+ * Skipping lands on the model's tick grid, so this can fire up to a tick early.
+ * The core announces what actually elapsed and the kernel re-arms.
  */
 static void timer_driver_set_reload(uint64_t cycles)
 {
-	hwtimer_enable(cycles);
+	int64_t silent_ticks = (int64_t)(cycles / NP_TICK_PERIOD_US) - 1;
+
+	hwtimer_set_silent_ticks(MAX(silent_ticks, 0));
 }
 
 /*
@@ -44,6 +59,9 @@ static void timer_driver_set_reload(uint64_t cycles)
 
 #include "system_timer_generic.h"
 
+BUILD_ASSERT(NP_TICK_PERIOD_US == TIMER_CORE_CYC_PER_TICK,
+	     "the tick period used to arm the model must match the core's");
+
 /**
  * Interrupt handler for the timer interrupt
  * Announce to the kernel that a number of ticks have passed
@@ -81,7 +99,7 @@ void sys_clock_disable(void)
  */
 static int sys_clock_driver_init(void)
 {
-	hwtimer_enable(TIMER_CORE_CYC_PER_TICK);
+	hwtimer_enable(NP_TICK_PERIOD_US);
 
 	IRQ_CONNECT(TIMER_TICK_IRQ, 1, np_timer_isr, 0, 0);
 	irq_enable(TIMER_TICK_IRQ);