everywhere: New IPC framework and IRQ delivery.

Author: sleepy-monax

meta/plugins/__init__.py

@@ -1,5 +1,5 @@
 from cutekit import ensure
 
-ensure((0, 10, 0))
+ensure((0, 11, 0))
 
 from . import start, tools  # noqa E402, F401: Needed for side effect

src/kernel/hjert-api/api.h

@@ -48,6 +48,12 @@ struct Object {
             _drop(_cap).unwrap();
     }
 
+    Res<Hj::Cap> dup(Hj::Cap dest) {
+        Hj::Cap out;
+        try$(Hj::_dup(dest, &out, _cap));
+        return Ok(out);
+    }
+
     Res<> drop() {
         try$(_drop(_cap));
         _cap = {};
@@ -258,6 +264,28 @@ struct Channel : Object {
     }
 };
 
+struct Pipe : Object {
+    using Props = PipeProps;
+
+    using Object::Object;
+
+    static Res<Pipe> create(Cap dest, usize bufLen) {
+        return create<Pipe>(dest, bufLen);
+    }
+
+    Res<usize> write(Bytes buf) {
+        usize bufLen = buf.len();
+        try$(_write(_cap, buf.buf(), &bufLen));
+        return Ok(bufLen);
+    }
+
+    Res<usize> read(MutBytes buf) {
+        usize bufLen = buf.len();
+        try$(_read(_cap, buf.buf(), &bufLen));
+        return Ok(bufLen);
+    }
+};
+
 struct Irq : Object {
     using Props = IrqProps;
 
@@ -266,6 +294,14 @@ struct Irq : Object {
     static Res<Irq> create(Cap dest, usize irq) {
         return create<Irq>(dest, irq);
     }
+
+    Res<> eoi() {
+        return _eoi(cap());
+    }
+
+    Res<> bind(Cap pipeCap) {
+        return _bind(cap(), pipeCap);
+    }
 };
 
 struct Listener : Object {

src/kernel/hjert-api/syscalls.cpp

@@ -140,12 +140,20 @@ Res<> _poll(Cap cap, Event* ev, usize evCap, usize* evLen, Instant until) {
     return _syscall(Syscall::POLL, cap.raw(), (Arg)ev, evCap, (usize)evLen, until.val());
 }
 
-Res<> _write(Cap cap, u8 const* buf, usize bufLen) {
-    return _syscall(Syscall::WRITE, cap.raw(), (Arg)buf, bufLen);
+Res<> _write(Cap cap, u8 const* buf, usize* bufLen) {
+    return _syscall(Syscall::WRITE, cap.raw(), (Arg)buf, (Arg)bufLen);
 }
 
 Res<> _read(Cap cap, u8* buf, usize* bufLen) {
     return _syscall(Syscall::READ, cap.raw(), (Arg)buf, (Arg)bufLen);
 }
 
+Res<> _bind(Cap cap, Cap pipeCap) {
+    return _syscall(Syscall::BIND, cap.raw(), pipeCap.raw());
+}
+
+Res<> _eoi(Cap cap) {
+    return _syscall(Syscall::EOI, cap.raw());
+}
+
 } //  namespace Hj

src/kernel/hjert-api/syscalls.h

@@ -40,4 +40,12 @@ Res<> _listen(Cap cap, Cap target, Flags<Sigs> set, Flags<Sigs> unset);
 
 Res<> _poll(Cap cap, Event* ev, usize evCap, usize* evLen, Instant until);
 
+Res<> _write(Cap cap, u8 const* buf, usize* bufLen);
+
+Res<> _read(Cap cap, u8* buf, usize* bufLen);
+
+Res<> _bind(Cap cap, Cap pipeCap);
+
+Res<> _eoi(Cap cap);
+
 } // namespace Hj

src/kernel/hjert-api/types.h

@@ -61,7 +61,9 @@ static inline char const* toStr(Type type) {
     SYSCALL(LISTEN)              \
     SYSCALL(POLL)                \
     SYSCALL(READ)                \
-    SYSCALL(WRITE)
+    SYSCALL(WRITE)               \
+    SYSCALL(BIND)                \
+    SYSCALL(EOI)
 
 // clang-format off
 

src/kernel/hjert-core/irq.cpp

@@ -11,12 +11,11 @@ Res<Arc<Irq>> Irq::create(usize irq) {
     return Ok(makeArc<Irq>(irq));
 }
 
-void Irq::trigger(usize irqNum) {
+void Irq::dispatch(usize irqNum) {
     LockScope _{_irqsLock};
     for (auto* irq : _irqs) {
-        if (irq->_irq == irqNum) {
-            irq->signal(Hj::Sigs::TRIGGERED, Hj::Sigs::NONE);
-        }
+        if (irq->_irq == irqNum)
+            irq->trigger();
     }
 }
 
@@ -30,4 +29,23 @@ Irq::~Irq() {
     _irqs.removeAll(this);
 }
 
+void Irq::trigger() {
+    ObjectLockScope _{*this};
+    _signalUnlock(Hj::Sigs::TRIGGERED, Hj::Sigs::NONE);
+    if (_eoi and _pipe) {
+        if ((*_pipe)->write({reinterpret_cast<u8*>(&_irq), sizeof(u64)}))
+            _eoi = false;
+    }
+}
+
+void Irq::bind(Arc<Pipe> pipe) {
+    ObjectLockScope _{*this};
+    _pipe = pipe;
+}
+
+void Irq::eoi() {
+    ObjectLockScope _{*this};
+    _eoi = true;
+}
+
 } // namespace Hjert::Core

src/kernel/hjert-core/irq.h

@@ -1,19 +1,28 @@
 #pragma once
 
 #include "object.h"
+#include "pipe.h"
 
 namespace Hjert::Core {
 
 struct Irq : BaseObject<Irq, Hj::Type::IRQ> {
     usize _irq;
+    bool _eoi = true;
+    Opt<Arc<Pipe>> _pipe;
 
     static Res<Arc<Irq>> create(usize irq);
 
-    static void trigger(usize irq);
+    static void dispatch(usize irq);
 
     Irq(usize irq);
 
     ~Irq() override;
+
+    void trigger();
+
+    void bind(Arc<Pipe> pipe);
+
+    void eoi();
 };
 
 } // namespace Hjert::Core

src/kernel/hjert-core/syscalls.cpp

@@ -292,6 +292,19 @@ Res<> doRead(Task& self, Hj::Cap cap, UserSlice<MutBytes> buf, User<Hj::Arg> buf
     );
 }
 
+Res<> doBind(Task& self, Hj::Cap cap, Hj::Cap pipeCap) {
+    auto irq = try$(self.domain().get<Irq>(cap));
+    auto pipe = try$(self.domain().get<Pipe>(pipeCap));
+    irq->bind(pipe);
+    return Ok();
+}
+
+Res<> doEoi(Task& self, Hj::Cap cap) {
+    auto irq = try$(self.domain().get<Irq>(cap));
+    irq->eoi();
+    return Ok();
+}
+
 Res<> dispatchSyscall(Task& self, Hj::Syscall id, Hj::Args args) {
     switch (id) {
     case Hj::Syscall::NOW:
@@ -385,6 +398,21 @@ Res<> dispatchSyscall(Task& self, Hj::Syscall id, Hj::Args args) {
         );
     }
 
+    case Hj::Syscall::BIND: {
+        return doBind(
+            self,
+            Hj::Cap{args[0]},
+            Hj::Cap{args[1]}
+        );
+    }
+
+    case Hj::Syscall::EOI: {
+        return doEoi(
+            self,
+            Hj::Cap{args[0]}
+        );
+    }
+
     default:
         return Error::invalidInput("invalid syscall id");
     }

src/kernel/hjert-x86_64/arch.cpp

@@ -200,7 +200,7 @@ extern "C" void _intDispatch(usize sp) {
         if (irq == 0)
             switchTask(1_ms, frame);
         else
-            Core::Irq::trigger(irq);
+            Core::Irq::dispatch(irq);
 
         _pic.ack(frame.intNo)
             .unwrap("pic ack failed");

src/libs/karm-app/skift/app.cpp

@@ -7,6 +7,7 @@ module Karm.App;
 import Karm.Core;
 import Karm.Gfx;
 import Karm.Sys;
+import Karm.Ref;
 import Strata.Protos;
 import Karm.Logger;
 
@@ -58,22 +59,20 @@ struct SkiftWindow : Window {
 };
 
 struct SkiftApplication : Application {
-    Rc<Sys::Endpoint> _endpoint;
-    Sys::Port _shell;
+    Sys::IpcClient _shell;
     Map<usize, SkiftWindow*> _windows;
     bool _exited = false;
 
-    explicit SkiftApplication(Rc<Sys::Endpoint> endpoint, Sys::Port shell)
-        : _endpoint(endpoint), _shell(shell) {}
+    explicit SkiftApplication(Sys::IpcClient shell)
+        : _shell(std::move(shell)) {}
 
     void detachWindow(Strata::IShell::WindowId id) {
-        (void)_endpoint->send(_shell, Strata::IShell::WindowDestroy{id});
+        (void)_shell.notify(Strata::IShell::WindowDestroy{id});
         _windows.del((usize)id);
     }
 
     Async::Task<Rc<Window>> createWindowAsync(WindowProps const& props, Async::CancellationToken ct) override {
-        auto [id, actual] = co_trya$(_endpoint->callAsync(
-            _shell,
+        auto [id, actual] = co_trya$(_shell.callAsync(
             Strata::IShell::WindowCreate{
                 props.size,
                 App::formFactor
@@ -85,8 +84,7 @@ struct SkiftApplication : Application {
 
         auto surface = co_try$(Strata::Protos::Surface::create(actual.size));
 
-        co_trya$(_endpoint->callAsync(
-            _shell,
+        co_trya$(_shell.callAsync(
             Strata::IShell::WindowAttach{
                 id,
                 surface,
@@ -100,7 +98,7 @@ struct SkiftApplication : Application {
         co_return Ok(window);
     }
 
-    Res<> _handleWindowEvent(Sys::Message& message, Rc<Handler> handler) {
+    Res<> _handleWindowEvent(Sys::IpcMessage& message, Rc<Handler> handler) {
         auto [windowId, payload] = try$(message.unpack<Strata::IShell::WindowEvent>());
         payload.visit([&]<typename E>(E const& event) {
             using T = Meta::RemoveConstVolatileRef<E>;
@@ -114,7 +112,7 @@ struct SkiftApplication : Application {
         return Ok();
     }
 
-    Res<> _handleWindowUpdate(Sys::Message& message, Rc<Handler> handler) {
+    Res<> _handleWindowUpdate(Sys::IpcMessage& message, Rc<Handler> handler) {
         auto [windowId, props] = try$(message.unpack<Strata::IShell::WindowUpdate>());
         auto* window = try$(_windows.tryGet(windowId).okOr(Error::invalidInput("no such window")));
         // FIXME: We should probably have a separated hello message that pass stuff like color scheme and form factor
@@ -127,7 +125,7 @@ struct SkiftApplication : Application {
     }
 
     Res<> _pollMessages(Rc<Handler> handler) {
-        while (auto maybeMessage = _endpoint->tryRecv()) {
+        while (auto maybeMessage = _shell.poll()) {
             auto& message = maybeMessage.unwrap();
             if (message.is<Strata::IShell::WindowEvent>())
                 try$(_handleWindowEvent(message, handler));
@@ -153,8 +151,7 @@ struct SkiftApplication : Application {
 
             auto newSurface = co_try$(Strata::Protos::Surface::create(size));
 
-            co_trya$(_endpoint->callAsync(
-                _shell,
+            co_trya$(_shell.callAsync(
                 Strata::IShell::WindowAttach{
                     id,
                     newSurface,
@@ -188,8 +185,7 @@ struct SkiftApplication : Application {
                 if (not window->_dirty)
                     continue;
 
-                co_trya$(_endpoint->callAsync(
-                    _shell,
+                co_trya$(_shell.callAsync(
                     Strata::IShell::WindowFlip{
                         id,
                         window->bound(),
@@ -220,30 +216,16 @@ void SkiftWindow::releaseSurface(Slice<Math::Recti>) {
 
 void SkiftWindow::drag(DragEvent e) {
     if (e.type == DragEvent::START)
-        (void)_application._endpoint->send(_application._shell, Strata::IShell::WindowMove{_id});
+        (void)_application._shell.notify(Strata::IShell::WindowMove{_id});
 }
 
 void SkiftWindow::snap(Snap s) {
-    (void)_application._endpoint->send(_application._shell, Strata::IShell::WindowSnap{_id, s});
+    (void)_application._shell.notify(Strata::IShell::WindowSnap{_id, s});
 }
 
-Async::Task<Rc<Application>> createAppAsync(Sys::Context& ctx, ApplicationProps const&, Async::CancellationToken ct) {
-    auto endpoint = makeRc<Sys::Endpoint>(
-        std::move(Sys::useChannel(ctx).con)
-    );
-
-    auto maybeShellPort = co_await endpoint->callAsync(
-        Sys::Port::BUS,
-        Strata::IBus::Locate{
-            "strata-shell"s,
-        },
-        ct
-    );
-
-    if (not maybeShellPort)
-        co_return maybeShellPort.none();
-
-    co_return Ok(makeRc<SkiftApplication>(endpoint, maybeShellPort.unwrap()));
+Async::Task<Rc<Application>> createAppAsync(Sys::Context&, ApplicationProps const&, Async::CancellationToken ct) {
+    auto shell = co_trya$(Sys::IpcClient::connectAsync("ipc://strata-shell"_url, ct));
+    co_return Ok(makeRc<SkiftApplication>(std::move(shell)));
 }
 
 } // namespace Karm::App::_Embed