From b646115dfcc2699e947b218e17c23c6a829aea82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Gr=C3=A9goire?= <loic@gregoire.dev>
Date: Sun, 19 Apr 2026 08:41:26 -0400
Subject: [PATCH] refactor(ke): read_time_nano -> read_time

---
 src/kern/log.zig   |  2 +-
 src/kern/root.zig  |  2 +-
 src/kern/sched.zig |  4 ++--
 src/kern/time.zig  | 12 ++++++------
 src/kern/timer.zig |  6 +++---
 5 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/kern/log.zig b/src/kern/log.zig
index 88ff268..a67c896 100644
--- a/src/kern/log.zig
+++ b/src/kern/log.zig
@@ -55,7 +55,7 @@ pub fn log(
     // Reserve space in the ring buffer.
     var res = ringbuffer.reserve(required_len) catch return;
 
-    res.info.timestamp = ke.time.read_time_nano();
+    res.info.timestamp = ke.time.read_time();
     res.info.length = @truncate(required_len);
 
     // Format the log message into the reserved buffer.
diff --git a/src/kern/root.zig b/src/kern/root.zig
index a9fe9fa..8710f2f 100644
--- a/src/kern/root.zig
+++ b/src/kern/root.zig
@@ -37,7 +37,7 @@ pub const dpc = struct {
 
 pub const time = struct {
     pub const register_source = p.time.register_source;
-    pub const read_time_nano = p.time.read_time_nano;
+    pub const read_time = p.time.read_time;
     pub const best = p.time.best;
     pub const sleep = p.time.sleep;
 };
diff --git a/src/kern/sched.zig b/src/kern/sched.zig
index 7fd7845..93f7b87 100644
--- a/src/kern/sched.zig
+++ b/src/kern/sched.zig
@@ -246,7 +246,7 @@ pub fn block() void {
     td.lock.acquire_no_ipl();
 
     td.state = .Blocked;
-    td.sleep_start = ke.time.read_time_nano();
+    td.sleep_start = ke.time.read_time();
     td.runq = null;
 
     yield(ke.cpu.current());
@@ -259,7 +259,7 @@ pub fn block() void {
 pub fn unblock(td: *ke.Thread) void {
     const ipl = td.lock.acquire();
 
-    td.sleep_time = (ke.time.read_time_nano() - td.sleep_start) / std.time.ns_per_ms;
+    td.sleep_time = (ke.time.read_time() - td.sleep_start) / std.time.ns_per_ms;
 
     if (td.sleep_time >= config.CONFIG_SCHED_TIMESLICE and td.priority_class == .Batch) {
         // If we have slept for more than a tick, update interactivity.
diff --git a/src/kern/time.zig b/src/kern/time.zig
index 7661147..e2449a3 100644
--- a/src/kern/time.zig
+++ b/src/kern/time.zig
@@ -28,7 +28,7 @@ pub const TimeCounter = struct {
 
 var best_tc: ?*TimeCounter = null;
 
-const TimeState = struct {
+const State = struct {
     // Counter value at the time the current TimeCounter was selected.
     // Used as the baseline for elapsed time calculation.
     initial_count: u64,
@@ -39,7 +39,7 @@ const TimeState = struct {
 
 // SeqLock-protected time state.
 // Avoids a race on `initial_count` and `offset` with `update_overflow`.
-var state = rtl.SeqLock(TimeState).init(.{
+var state = rtl.SeqLock(State).init(.{
     .initial_count = 0,
     .offset = 0,
 });
@@ -88,7 +88,7 @@ pub fn register_source(tc: *TimeCounter) void {
 }
 
 /// Return the time elapsed since boot in nanoseconds.
-pub fn read_time_nano() r.Nanoseconds {
+pub fn read_time() r.Nanoseconds {
     const tc = best_tc orelse return 0;
 
     const s = state.load();
@@ -104,15 +104,15 @@ pub fn best() ?*TimeCounter {
 
 /// Do a busy sleep of `ns` nanoseconds using TimeCounter.
 pub fn sleep(ns: r.Nanoseconds) void {
-    const start = read_time_nano();
+    const start = read_time();
 
     while (true) {
-        var cur = read_time_nano();
+        var cur = read_time();
 
         if (cur < start) continue;
 
         if (cur - start >= ns) {
-            cur = read_time_nano();
+            cur = read_time();
 
             // Check again as we may have overflowed and read a bogus value..
             // This is kinda hacky but oh well.
diff --git a/src/kern/timer.zig b/src/kern/timer.zig
index a30907c..bc561d7 100644
--- a/src/kern/timer.zig
+++ b/src/kern/timer.zig
@@ -75,7 +75,7 @@ pub fn set(timer: *Timer, time: r.Nanoseconds, dpc: ?*ke.Dpc) void {
     defer cpu.lock.release_no_ipl();
 
     // Initialize the timer.
-    timer.deadline = ke.time.read_time_nano() + time;
+    timer.deadline = ke.time.read_time() + time;
 
     timer.cpu = cpu;
     timer.dpc = dpc;
@@ -143,7 +143,7 @@ fn handle_expiry(_: ?*anyopaque) void {
     const cpu = percpu.local();
 
     while (true) {
-        const curtime = ke.time.read_time_nano();
+        const curtime = ke.time.read_time();
 
         cpu.lock.acquire_no_ipl();
 
@@ -162,7 +162,7 @@ fn handle_expiry(_: ?*anyopaque) void {
             cpu.lock.release_no_ipl();
 
             // Re-check in case the timer expired while we were here.
-            const now = ke.time.read_time_nano();
+            const now = ke.time.read_time();
             if (next.deadline <= now or next.deadline - now <= std.time.ns_per_ms) {
                 continue; // expired in the meantime, loop again
             }