Add KInterruptEvent skeleton; remove useless funcs

mesosphere/include/mesosphere/core/KAutoObject.hpp

@@ -19,6 +19,10 @@ namespace mesosphere
 class KProcess;
 class KResourceLimit;
 class KThread;
+class KEvent;
+class KReadableEvent;
+class KWritableEvent;
+class KInterruptEvent;
 
 void intrusive_ptr_add_ref(KProcess *obj);
 void intrusive_ptr_release(KProcess *obj);
@@ -26,6 +30,18 @@ void intrusive_ptr_release(KProcess *obj);
 void intrusive_ptr_add_ref(KResourceLimit *obj);
 void intrusive_ptr_release(KResourceLimit *obj);
 
+void intrusive_ptr_add_ref(KEvent *obj);
+void intrusive_ptr_release(KEvent *obj);
+
+void intrusive_ptr_add_ref(KReadableEvent *obj);
+void intrusive_ptr_release(KReadableEvent *obj);
+
+void intrusive_ptr_add_ref(KWritableEvent *obj);
+void intrusive_ptr_release(KWritableEvent *obj);
+
+void intrusive_ptr_add_ref(KInterruptEvent *obj);
+void intrusive_ptr_release(KInterruptEvent *obj);
+
 class KAutoObject {
     public:
 

mesosphere/include/mesosphere/interfaces/IClient.hpp

@@ -21,11 +21,6 @@ class IClient : public IClientTag {
     void *operator new(size_t sz) noexcept = delete;
     void operator delete(void *ptr) noexcept {}
 
-    ~IClient()
-    {
-        parent->HandleClientDestroyed();
-    }
-
     const SharedPtr<Parent>& GetParent() const { return parent; }
 
     void SetParent(SharedPtr<Parent> parent)

mesosphere/include/mesosphere/interfaces/IServer.hpp

@@ -21,11 +21,6 @@ class IServer : public IServerTag {
     void *operator new(size_t sz) noexcept = delete;
     void operator delete(void *ptr) noexcept {};
 
-    ~IServer()
-    {
-        parent->HandleServerDestroyed();
-    }
-
     const SharedPtr<Parent> &GetParent() const { return parent; }
 
     void SetParentAndClient(SharedPtr<Parent> parent, SharedPtr<Client> client)

mesosphere/include/mesosphere/interrupts/KInterruptEvent.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <mesosphere/processes/KReadableEvent.hpp>
+#include <mesosphere/interfaces/ISetAllocated.hpp>
+
+namespace mesosphere
+{
+
+class KInterruptEvent final : public KReadableEvent, public ISetAllocated<KInterruptEvent> {
+    public:
+    MESOSPHERE_AUTO_OBJECT_TRAITS(ReadableEvent, InterruptEvent);
+
+    void *operator new(size_t sz) noexcept { return ISetAllocated<KInterruptEvent>::operator new(sz); }
+    void operator delete(void *ptr) noexcept { ISetAllocated<KInterruptEvent>::operator delete(ptr); }
+
+    virtual ~KInterruptEvent();
+    Result Initialize(int irqId, u32 flags);
+
+    // KAutoObject
+    virtual bool IsAlive() const override;
+
+    private:
+    // TODO: receiver
+    int irqId = -1;
+    bool isInitialized = false;
+};
+
+inline void intrusive_ptr_add_ref(KInterruptEvent *obj)
+{
+    intrusive_ptr_add_ref((KAutoObject *)obj);
+}
+
+inline void intrusive_ptr_release(KInterruptEvent *obj)
+{
+    intrusive_ptr_release((KAutoObject *)obj);
+}
+
+}

mesosphere/include/mesosphere/processes/KEvent.hpp

@@ -31,10 +31,6 @@ class KEvent final :
     /* KAutoObject */
     virtual bool IsAlive() const override;
 
-    /* IClientServerParent */
-    void HandleServerDestroyed() { }
-    void HandleClientDestroyed() { }
-    
     private:
     bool isInitialized = false;
 };

mesosphere/include/mesosphere/processes/KReadableEvent.hpp

@@ -4,7 +4,6 @@
 #include <mesosphere/core/Result.hpp>
 #include <mesosphere/core/KAutoObject.hpp>
 #include <mesosphere/core/KSynchronizationObject.hpp>
-#include <mesosphere/interfaces/ISetAllocated.hpp>
 #include <mesosphere/interfaces/IClient.hpp>
 
 namespace mesosphere

mesosphere/source/interrupts/KInterruptEvent.cpp

@@ -0,0 +1,25 @@
+#include <mesosphere/interrupts/KInterruptEvent.hpp>
+
+namespace mesosphere
+{
+
+KInterruptEvent::~KInterruptEvent()
+{
+    // delete receiver? 
+}
+
+Result KInterruptEvent::Initialize(int irqId, u32 flags)
+{
+    // TODO implement
+    (void)flags;
+    this->irqId = irqId;
+    isInitialized = true;
+    return ResultSuccess();
+}
+
+bool KInterruptEvent::IsAlive() const
+{
+    return isInitialized;
+}
+
+}

mesosphere/source/test.cpp

@@ -1,11 +1,11 @@
 #include <mesosphere/core/make_object.hpp>
-#include <mesosphere/processes/KEvent.hpp>
+#include <mesosphere/interrupts/KInterruptEvent.hpp>
 
 using namespace mesosphere;
 
 int main(void) {
-    auto [res, h1, h2] = MakeObjectWithHandle<KEvent>();
-    (void)res; (void)h1; (void)h2;
+    auto [res, h1] = MakeObjectWithHandle<KInterruptEvent>(3, -1);
+    (void)res; (void)h1; //(void)h2;
     for(;;);
     return 0;
 }