hjert: Added clock object.

sleepy-monax · sleepy-monax · commit b162bcb22ea8 · 2026-05-29T09:47:50.000+02:00
diff --git a/src/kernel/hjert/api/types.cpp b/src/kernel/hjert/api/types.cpp
@@ -16,15 +16,16 @@ export enum struct Mode : u8 {
 };
 
 #define FOREACH_TYPE(TYPE) \
+    TYPE(CHANNEL)          \
+    TYPE(CLOCK)            \
     TYPE(DOMAIN)           \
-    TYPE(TASK)             \
-    TYPE(SPACE)            \
-    TYPE(VMO)              \
     TYPE(IOP)              \
-    TYPE(CHANNEL)          \
     TYPE(IRQ)              \
     TYPE(LISTENER)         \
-    TYPE(PIPE)
+    TYPE(PIPE)             \
+    TYPE(SPACE)            \
+    TYPE(TASK)             \
+    TYPE(VMO)
 
 // clang-format off
 
@@ -296,6 +297,10 @@ export struct PipeProps {
     usize bufCap; //< The capacity of the data buffer (in bytes, must be >= 1)
 };
 
+export struct ClockProps {
+    static constexpr Type TYPE = Type::CLOCK;
+};
+
 export using _Props = Union<
     DomainProps,
     TaskProps,
@@ -305,7 +310,8 @@ export using _Props = Union<
     ChannelProps,
     IrqProps,
     ListenerProps,
-    PipeProps>;
+    PipeProps,
+    ClockProps>;
 
 export struct Props : _Props {
     using _Props::_Props;
diff --git a/src/kernel/hjert/core/clock.cpp b/src/kernel/hjert/core/clock.cpp
@@ -1,22 +1,64 @@
+module;
+
+#include <hal/mem.h>
+#include <hal/pmm.h>
+#include <karm/macros>
+
 export module Hjert.Core:clock;
 
 import Karm.Core;
 
+import :vmo;
+import :object;
+import :mem;
+
 using namespace Karm;
 
 namespace Hjert::Core {
 
-static Lock _lock{};
-static Instant _stamp{};
+export struct Clock;
+
+static Lock _clocksLock;
+static Vec<Clock*> _clocks = {};
+static Instant _monotonicClock{};
+
+export struct Clock : BaseObject<Clock, Hj::Type::CLOCK> {
+    Arc<Vmo> _vmo;
+    Atomic<_TimeVal>* _reg = nullptr;
+
+    static Res<Arc<Clock>> create() {
+        auto vmo = try$(Vmo::alloc(Hal::PAGE_SIZE, Hal::PmmFlags::LOWER));
+        auto addr = try$(kmm().pmm2Kmm(vmo->range())).start;
+        auto reg = reinterpret_cast<Atomic<Karm::_TimeVal>*>(addr);
+        return Ok(makeArc<Clock>(vmo, reg));
+    }
+
+    static Instant monotonicInstant() {
+        LockScope _{_clocksLock};
+        return _monotonicClock;
+    }
+
+    static void monotonicTick(Duration span) {
+        LockScope _{_clocksLock};
+        _monotonicClock += span;
+        for (auto* clock : _clocks)
+            clock->tick(span);
+    }
+
+    Clock(Arc<Vmo> vmo, Atomic<_TimeVal>* reg)
+        : _vmo(vmo), _reg(reg) {
+        LockScope _{_clocksLock};
+        _clocks.pushBack(this);
+    }
 
-export Instant clockNow() {
-    LockScope _{_lock};
-    return _stamp;
-}
+    ~Clock() {
+        LockScope _{_clocksLock};
+        _clocks.removeAll(this);
+    }
 
-export void clockTick(Duration span) {
-    LockScope _{_lock};
-    _stamp += span;
-}
+    void tick(Duration span) {
+        _reg->fetchAdd(span.val());
+    }
+};
 
 } // namespace Hjert::Core
diff --git a/src/kernel/hjert/core/init.cpp b/src/kernel/hjert/core/init.cpp
@@ -21,7 +21,7 @@ namespace Hjert::Core {
 Res<Arc<Vmo>> _locateInit(Handover::Payload& payload, Str path) {
     logInfo("locating {#}...", path);
 
-    auto const* record = payload.fileByName("file:/skift/init.bootfs");
+    auto const* record = payload.blobByName("file:/skift/init.bootfs");
     if (not record) {
         logError("handover: could not find bootfs");
         return Error::invalidInput("could not find bootfs");
@@ -52,7 +52,7 @@ Res<> enterUserspace(Handover::Payload& payload) {
     auto elfVmo = try$(_locateInit(payload, "bundles/strata-cm/bin/strata-cm.elf"));
     elfVmo->label("elf-shared");
     auto elfRange = try$(kmm().pmm2Kmm(elfVmo->range()));
-    Elf::ElfObject<Elf::Elf64LeAbi> object{elfRange.bytes()};
+    Elf::ElfObject<Elf::CurrentAbi> object{elfRange.bytes()};
     try$(object.validate());
 
     for (Elf::ElfProgram prog : object.iterProgram()) {
diff --git a/src/kernel/hjert/core/mem.cpp b/src/kernel/hjert/core/mem.cpp
@@ -106,9 +106,8 @@ struct Kmm : Hal::Kmm {
     }
 
     Res<Hal::PmmRange> kmm2Pmm(Hal::KmmRange range) override {
-        if (range.start < Hal::UPPER_HALF) {
+        if (range.start < Hal::UPPER_HALF)
             return Error::invalidInput("Invalid heap range");
-        }
 
         return Ok(Hal::PmmRange{
             range.start - Hal::UPPER_HALF,
diff --git a/src/kernel/hjert/core/object.cpp b/src/kernel/hjert/core/object.cpp
@@ -66,7 +66,7 @@ struct BaseObject : Object {
     }
 };
 
-export struct [[nodiscard]] ObjectLockScope : LockScope<Lock> {
+export struct [[nodiscard]] ObjectLockScope : LockScope<> {
     ObjectLockScope(Object& obj)
         : LockScope(obj._lock) {
     }
diff --git a/src/kernel/hjert/core/sched.cpp b/src/kernel/hjert/core/sched.cpp
@@ -41,7 +41,7 @@ struct Sched {
     void schedule() {
         LockScope _{_lock};
 
-        auto now = clockNow();
+        auto now = Clock::monotonicInstant();
         _prev = _curr;
         _curr->_sliceEnd = now;
 
diff --git a/src/kernel/hjert/core/syscalls.cpp b/src/kernel/hjert/core/syscalls.cpp
@@ -25,7 +25,7 @@ namespace Hjert::Core {
 static constexpr bool DEBUG_SYSCALLS = false;
 
 Res<> doNow(Task& self, User<Instant> ts) {
-    return ts.store(self.space(), clockNow());
+    return ts.store(self.space(), Clock::monotonicInstant());
 }
 
 Res<> doLog(Task& self, UserSlice<Str> msg) {
@@ -55,70 +55,70 @@ Res<> doCreate(Task& self, Hj::Cap dest, User<Hj::Cap> out, User<Hj::Props> p) {
         return Error::invalidInput("invalid props");
 
     auto obj = try$(props.visit(
-        Visitor{
-            [&](Hj::DomainProps&) -> Res<Arc<Object>> {
-                return Ok(try$(Domain::create()));
-            },
-            [&](Hj::TaskProps& props) -> Res<Arc<Object>> {
-                try$(self.ensure(Hj::Pledge::TASK));
-
-                auto dom = props.domain.isRoot()
-                               ? try$(self._domain)
-                               : try$(self.domain().get<Domain>(props.domain));
-
-                auto spa = props.space.isRoot()
-                               ? try$(self._space)
-                               : try$(self.domain().get<Space>(props.space));
-
-                auto obj = try$(Task::create(Hj::Mode::USER, spa, dom));
-
-                auto pledges = self.pledges();
-                try$(obj->pledge(pledges));
-
-                return Ok(obj);
-            },
-            [&](Hj::SpaceProps&) -> Res<Arc<Object>> {
-                try$(self.ensure(Hj::Pledge::MEM));
-
-                return Ok(try$(Space::create()));
-            },
-            [&](Hj::VmoProps& props) -> Res<Arc<Object>> {
-                try$(self.ensure(Hj::Pledge::MEM));
-
-                if (not props.vmo.isRoot()) {
-                    auto vmo = try$(self.domain().get<Vmo>(props.vmo));
-                    return Ok(try$(Vmo::makeSlice(vmo, {props.phys, props.len})));
-                }
-
-                bool isDma = props.flags.has(Hj::VmoFlags::DMA);
-                if (isDma) {
-                    try$(self.ensure(Hj::Pledge::HW));
-                    return Ok(try$(Vmo::makeDma({props.phys, props.len})));
-                }
-
-                if (props.len > 2_GiB) {
-                    return Error::invalidInput("Vmo size too large");
-                }
-
-                return Ok(try$(Vmo::alloc(props.len, props.flags)));
-            },
-            [&](Hj::IopProps& props) -> Res<Arc<Object>> {
-                try$(self.ensure(Hj::Pledge::HW));
-                return Ok(try$(Iop::create({props.base, props.len})));
-            },
-            [&](Hj::ChannelProps& props) -> Res<Arc<Object>> {
-                return Ok(try$(Channel::create(props.bufCap, props.capsCap)));
-            },
-            [&](Hj::IrqProps& props) -> Res<Arc<Object>> {
+        [&](Hj::DomainProps&) -> Res<Arc<Object>> {
+            return Ok(try$(Domain::create()));
+        },
+        [&](Hj::TaskProps& props) -> Res<Arc<Object>> {
+            try$(self.ensure(Hj::Pledge::TASK));
+
+            auto dom = props.domain.isRoot()
+                           ? try$(self._domain)
+                           : try$(self.domain().get<Domain>(props.domain));
+
+            auto spa = props.space.isRoot()
+                           ? try$(self._space)
+                           : try$(self.domain().get<Space>(props.space));
+
+            auto obj = try$(Task::create(Hj::Mode::USER, spa, dom));
+
+            auto pledges = self.pledges();
+            try$(obj->pledge(pledges));
+
+            return Ok(obj);
+        },
+        [&](Hj::SpaceProps&) -> Res<Arc<Object>> {
+            try$(self.ensure(Hj::Pledge::MEM));
+
+            return Space::create();
+        },
+        [&](Hj::VmoProps& props) -> Res<Arc<Object>> {
+            try$(self.ensure(Hj::Pledge::MEM));
+
+            if (not props.vmo.isRoot()) {
+                auto vmo = try$(self.domain().get<Vmo>(props.vmo));
+                return Vmo::makeSlice(vmo, {props.phys, props.len});
+            }
+
+            bool isDma = props.flags.has(Hj::VmoFlags::DMA);
+            if (isDma) {
                 try$(self.ensure(Hj::Pledge::HW));
-                return Ok(try$(Irq::create(props.irq)));
-            },
-            [&](Hj::ListenerProps&) -> Res<Arc<Object>> {
-                return Ok(try$(Listener::create()));
-            },
-            [&](Hj::PipeProps& props) -> Res<Arc<Object>> {
-                return Ok(try$(Pipe::create(props.bufCap)));
-            },
+                return Vmo::makeDma({props.phys, props.len});
+            }
+
+            if (props.len > 2_GiB)
+                return Error::invalidInput("Vmo size too large");
+
+            return Vmo::alloc(props.len, props.flags);
+        },
+        [&](Hj::IopProps& props) -> Res<Arc<Object>> {
+            try$(self.ensure(Hj::Pledge::HW));
+            return Iop::create({props.base, props.len});
+        },
+        [&](Hj::ChannelProps& props) -> Res<Arc<Object>> {
+            return Channel::create(props.bufCap, props.capsCap);
+        },
+        [&](Hj::IrqProps& props) -> Res<Arc<Object>> {
+            try$(self.ensure(Hj::Pledge::HW));
+            return Irq::create(props.irq);
+        },
+        [&](Hj::ListenerProps&) -> Res<Arc<Object>> {
+            return Listener::create();
+        },
+        [&](Hj::PipeProps& props) -> Res<Arc<Object>> {
+            return Pipe::create(props.bufCap);
+        },
+        [&](Hj::ClockProps&) -> Res<Arc<Object>> {
+            return Clock::create();
         }
     ));
 
@@ -141,9 +141,8 @@ Res<> doDrop(Task& self, Hj::Cap cap) {
 }
 
 Res<> doPledge(Task& self, Hj::Cap cap, Flags<Hj::Pledge> pledges) {
-    if (cap.isRoot()) {
+    if (cap.isRoot())
         return self.pledge(pledges);
-    }
 
     auto obj = try$(self.domain().get<Task>(cap));
     return obj->pledge(pledges);
diff --git a/src/kernel/hjert/core/task.cpp b/src/kernel/hjert/core/task.cpp
@@ -95,7 +95,7 @@ export struct Task : BaseObject<Task, Hj::Type::TASK> {
 
     Res<> block(Blocker blocker) {
         // NOTE: If the blocker is already expired, don't block.
-        if (blocker() <= clockNow())
+        if (blocker() <= Clock::monotonicInstant())
             return Ok();
 
         // NOTE: Can't use ObjectLockScope here because
diff --git a/src/kernel/hjert/core/vmo.cpp b/src/kernel/hjert/core/vmo.cpp
@@ -53,17 +53,15 @@ export struct Vmo : BaseObject<Vmo, Hj::Type::VMO> {
 
     Hal::PmmRange range() const {
         return _mem.visit(
-            Visitor{
-                [](Hal::PmmMem const& mem) {
-                    return mem.range();
-                },
-                [](Hal::DmaRange const& range) {
-                    return range.into<Hal::PmmRange>();
-                },
-                [](_Slice const& slice) {
-                    auto range = slice.range.into<Hal::PmmRange>();
-                    return slice.vmo->range().slice(range);
-                }
+            [](Hal::PmmMem const& mem) {
+                return mem.range();
+            },
+            [](Hal::DmaRange const& range) {
+                return range.into<Hal::PmmRange>();
+            },
+            [](_Slice const& slice) {
+                auto range = slice.range.into<Hal::PmmRange>();
+                return slice.vmo->range().slice(range);
             }
         );
     }
diff --git a/src/kernel/hjert/x86_64/arch.cpp b/src/kernel/hjert/x86_64/arch.cpp
@@ -174,7 +174,7 @@ void backtrace(usize rbp) {
 
 void switchTask(Duration span, Frame& frame) {
     Core::globalSched().currentTask().save(frame);
-    Core::clockTick(span);
+    Core::Clock::monotonicTick(span);
     Core::globalSched().schedule();
     Core::globalSched().currentTask().load(frame);
 }
diff --git a/src/kernel/opstart/menu.cpp b/src/kernel/opstart/menu.cpp

Original file line number	Diff line number	Diff line change
`@@ -106,9 +106,8 @@ struct Kmm : Hal::Kmm {`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`Res<Hal::PmmRange> kmm2Pmm(Hal::KmmRange range) override {`
`109`		`- if (range.start < Hal::UPPER_HALF) {`
	`109`	`+ if (range.start < Hal::UPPER_HALF)`
`110`	`110`	`return Error::invalidInput("Invalid heap range");`
`111`		`- }`
`112`	`111`
`113`	`112`	`return Ok(Hal::PmmRange{`
`114`	`113`	`range.start - Hal::UPPER_HALF,`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ struct BaseObject : Object {`
`66`	`66`	`}`
`67`	`67`	`};`
`68`	`68`
`69`		`-export struct [[nodiscard]] ObjectLockScope : LockScope<Lock> {`
	`69`	`+export struct [[nodiscard]] ObjectLockScope : LockScope<> {`
`70`	`70`	`ObjectLockScope(Object& obj)`
`71`	`71`	`: LockScope(obj._lock) {`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ void backtrace(usize rbp) {`
`174`	`174`
`175`	`175`	`void switchTask(Duration span, Frame& frame) {`
`176`	`176`	`Core::globalSched().currentTask().save(frame);`
`177`		`- Core::clockTick(span);`
	`177`	`+ Core::Clock::monotonicTick(span);`
`178`	`178`	`Core::globalSched().schedule();`
`179`	`179`	`Core::globalSched().currentTask().load(frame);`
`180`	`180`	`}`