Kernel: Change HandlerPurpose to HandlerType

supercomputer7 · awesomekling · commit 773afefe7c44 · 2020-03-06T11:19:51.000+01:00
Also, GenericInterruptHandler class requires to implement two new
methods.
diff --git a/Kernel/ACPI/ACPIDynamicParser.h b/Kernel/ACPI/ACPIDynamicParser.h
@@ -47,6 +47,7 @@ namespace ACPI {
         virtual void disable_aml_interpretation() override;
         virtual void try_acpi_shutdown() override;
         virtual bool can_shutdown() override { return true; }
+        virtual const char* purpose() const override { return "ACPI Parser"; }
 
     protected:
         DynamicParser();
diff --git a/Kernel/Arch/i386/CPU.cpp b/Kernel/Arch/i386/CPU.cpp
@@ -410,17 +410,17 @@ static void revert_to_unused_handler(u8 interrupt_number)
 void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler)
 {
     if (s_interrupt_handler[interrupt_number] != nullptr) {
-        if (s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::UnhandledInterruptHandler) {
+        if (s_interrupt_handler[interrupt_number]->type() == HandlerType::UnhandledInterruptHandler) {
             s_interrupt_handler[interrupt_number] = &handler;
             return;
         }
         if (s_interrupt_handler[interrupt_number]->is_shared_handler() && !s_interrupt_handler[interrupt_number]->is_sharing_with_others()) {
-            ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::SharedIRQHandler);
+            ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::SharedIRQHandler);
             static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->register_handler(handler);
             return;
         }
         if (!s_interrupt_handler[interrupt_number]->is_shared_handler()) {
-            ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::IRQHandler);
+            ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::IRQHandler);
             auto& previous_handler = *s_interrupt_handler[interrupt_number];
             s_interrupt_handler[interrupt_number] = nullptr;
             SharedIRQHandler::initialize(interrupt_number);
@@ -437,20 +437,20 @@ void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHan
 void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler)
 {
     ASSERT(s_interrupt_handler[interrupt_number] != nullptr);
-    if (s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::UnhandledInterruptHandler) {
+    if (s_interrupt_handler[interrupt_number]->type() == HandlerType::UnhandledInterruptHandler) {
         dbg() << "Trying to unregister unused handler (?)";
         return;
     }
     if (s_interrupt_handler[interrupt_number]->is_shared_handler() && !s_interrupt_handler[interrupt_number]->is_sharing_with_others()) {
-        ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::SharedIRQHandler);
+        ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::SharedIRQHandler);
         static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->unregister_handler(handler);
         if (!static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->sharing_devices_count()) {
             revert_to_unused_handler(interrupt_number);
         }
         return;
     }
     if (!s_interrupt_handler[interrupt_number]->is_shared_handler()) {
-        ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::IRQHandler);
+        ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::IRQHandler);
         revert_to_unused_handler(interrupt_number);
         return;
     }
diff --git a/Kernel/Devices/FloppyDiskDevice.h b/Kernel/Devices/FloppyDiskDevice.h
@@ -172,6 +172,8 @@ class FloppyDiskDevice final
     virtual ssize_t write(FileDescription&, const u8*, ssize_t) override { return 0; }
     virtual bool can_write(const FileDescription&) const override { return true; }
 
+    virtual const char* purpose() const override { return "Floppy Disk Controller"; }
+
 protected:
     explicit FloppyDiskDevice(DriveType);
 
diff --git a/Kernel/Devices/HardwareTimer.h b/Kernel/Devices/HardwareTimer.h
@@ -32,7 +32,6 @@ namespace Kernel {
 class HardwareTimer : public IRQHandler {
 public:
     u32 seconds_since_boot();
-
 protected:
     HardwareTimer(u8 irq_number);
     u32 m_seconds_since_boot { 0 };
diff --git a/Kernel/Devices/KeyboardDevice.h b/Kernel/Devices/KeyboardDevice.h
@@ -57,6 +57,8 @@ class KeyboardDevice final : public IRQHandler
     virtual ssize_t write(FileDescription&, const u8* buffer, ssize_t) override;
     virtual bool can_write(const FileDescription&) const override { return true; }
 
+    virtual const char* purpose() const override { return class_name(); }
+
 private:
     // ^IRQHandler
     virtual void handle_irq(RegisterState&) override;
diff --git a/Kernel/Devices/PATAChannel.h b/Kernel/Devices/PATAChannel.h
@@ -72,6 +72,8 @@ class PATAChannel final : public PCI::Device {
     RefPtr<PATADiskDevice> master_device() { return m_master; };
     RefPtr<PATADiskDevice> slave_device() { return m_slave; };
 
+    virtual const char* purpose() const override { return "PATA Channel"; }
+
 private:
     //^ IRQHandler
     virtual void handle_irq(RegisterState&) override;
diff --git a/Kernel/Devices/PIT.h b/Kernel/Devices/PIT.h
@@ -58,6 +58,8 @@ class PIT : public HardwareTimer {
     static PIT& the();
     u32 ticks_this_second() const;
 
+    virtual const char* purpose() const override { return "System Timer"; }
+
 private:
     PIT();
     // ^IRQHandler
diff --git a/Kernel/Devices/PS2MouseDevice.h b/Kernel/Devices/PS2MouseDevice.h
@@ -47,6 +47,8 @@ class PS2MouseDevice final : public IRQHandler
     virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
     virtual bool can_write(const FileDescription&) const override { return true; }
 
+    virtual const char* purpose() const override { return class_name(); }
+
 private:
     // ^IRQHandler
     void handle_vmmouse_absolute_pointer();
diff --git a/Kernel/Devices/SB16.h b/Kernel/Devices/SB16.h
@@ -50,6 +50,8 @@ class SB16 final : public IRQHandler
     virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
     virtual bool can_write(const FileDescription&) const override { return true; }
 
+    virtual const char* purpose() const override { return class_name(); }
+
 private:
     // ^IRQHandler
     virtual void handle_irq(RegisterState&) override;
diff --git a/Kernel/Interrupts/GenericInterruptHandler.h b/Kernel/Interrupts/GenericInterruptHandler.h
@@ -33,7 +33,7 @@
 
 namespace Kernel {
 
-enum class HandlerPurpose : u8 {
+enum class HandlerType : u8 {
     IRQHandler = 1,
     SharedIRQHandler = 2,
     UnhandledInterruptHandler = 3,
@@ -56,7 +56,9 @@ class GenericInterruptHandler {
     virtual bool is_shared_handler() const = 0;
     virtual bool is_sharing_with_others() const = 0;
 
-    virtual HandlerPurpose purpose() const = 0;
+    virtual HandlerType type() const = 0;
+    virtual const char* purpose() const = 0;
+    virtual const char* controller() const = 0;
 
     virtual bool eoi() = 0;
     void increment_invoking_counter();
diff --git a/Kernel/Interrupts/IRQHandler.h b/Kernel/Interrupts/IRQHandler.h
@@ -47,7 +47,9 @@ class IRQHandler : public GenericInterruptHandler {
 
     virtual bool eoi() override;
 
-    virtual HandlerPurpose purpose() const override { return HandlerPurpose::IRQHandler; }
+    virtual HandlerType type() const override { return HandlerType::IRQHandler; }
+    virtual const char* purpose() const override { return "IRQ Handler"; }
+    virtual const char* controller() const override { return m_responsible_irq_controller->model(); }
 
     virtual size_t sharing_devices_count() const override { return 0; }
     virtual bool is_shared_handler() const override { return false; }
diff --git a/Kernel/Interrupts/SharedIRQHandler.h b/Kernel/Interrupts/SharedIRQHandler.h
@@ -50,7 +50,9 @@ class SharedIRQHandler final : public GenericInterruptHandler {
     virtual bool is_shared_handler() const override { return true; }
     virtual bool is_sharing_with_others() const override { return false; }
 
-    virtual HandlerPurpose purpose() const override { return HandlerPurpose::SharedIRQHandler; }
+    virtual HandlerType type() const override { return HandlerType::SharedIRQHandler; }
+    virtual const char* purpose() const override { return "Shared IRQ Handler"; }
+    virtual const char* controller() const override { return m_responsible_irq_controller->model(); }
 
 private:
     void enable_interrupt_vector();
diff --git a/Kernel/Interrupts/SpuriousInterruptHandler.h b/Kernel/Interrupts/SpuriousInterruptHandler.h
@@ -50,7 +50,9 @@ class SpuriousInterruptHandler final : public GenericInterruptHandler {
     virtual bool is_shared_handler() const override { return false; }
     virtual bool is_sharing_with_others() const override { return false; }
 
-    virtual HandlerPurpose purpose() const override { return HandlerPurpose::SpuriousInterruptHandler; }
+    virtual HandlerType type() const override { return HandlerType::SpuriousInterruptHandler; }
+    virtual const char* purpose() const override { return "Spurious Interrupt Handler"; }
+    virtual const char* controller() const override { return m_responsible_irq_controller->model(); }
 
 private:
     void enable_interrupt_vector();
diff --git a/Kernel/Interrupts/UnhandledInterruptHandler.h b/Kernel/Interrupts/UnhandledInterruptHandler.h
@@ -41,7 +41,9 @@ class UnhandledInterruptHandler final : public GenericInterruptHandler {
 
     virtual bool eoi() override;
 
-    virtual HandlerPurpose purpose() const override { return HandlerPurpose::UnhandledInterruptHandler; }
+    virtual HandlerType type() const override { return HandlerType::UnhandledInterruptHandler; }
+    virtual const char* purpose() const override { return "Unhandled Interrupt Handler"; }
+    virtual const char* controller() const override { ASSERT_NOT_REACHED(); }
 
     virtual size_t sharing_devices_count() const override { return 0; }
     virtual bool is_shared_handler() const override { return false; }
diff --git a/Kernel/Net/E1000NetworkAdapter.h b/Kernel/Net/E1000NetworkAdapter.h
@@ -46,6 +46,8 @@ class E1000NetworkAdapter final : public NetworkAdapter
     virtual void send_raw(const u8*, size_t) override;
     virtual bool link_up() override;
 
+    virtual const char* purpose() const override { return class_name(); }
+
 private:
     virtual void handle_irq(RegisterState&) override;
     virtual const char* class_name() const override { return "E1000NetworkAdapter"; }
diff --git a/Kernel/Net/RTL8139NetworkAdapter.h b/Kernel/Net/RTL8139NetworkAdapter.h
@@ -47,6 +47,8 @@ class RTL8139NetworkAdapter final : public NetworkAdapter
     virtual void send_raw(const u8*, size_t) override;
     virtual bool link_up() override { return m_link_up; }
 
+    virtual const char* purpose() const override { return class_name(); }
+
 private:
     virtual void handle_irq(RegisterState&) override;
     virtual const char* class_name() const override { return "RTL8139NetworkAdapter"; }

Original file line number	Diff line number	Diff line change
`@@ -410,17 +410,17 @@ static void revert_to_unused_handler(u8 interrupt_number)`
`410`	`410`	`void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler)`
`411`	`411`	`{`
`412`	`412`	`if (s_interrupt_handler[interrupt_number] != nullptr) {`
`413`		`- if (s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::UnhandledInterruptHandler) {`
	`413`	`+ if (s_interrupt_handler[interrupt_number]->type() == HandlerType::UnhandledInterruptHandler) {`
`414`	`414`	`s_interrupt_handler[interrupt_number] = &handler;`
`415`	`415`	`return;`
`416`	`416`	`}`
`417`	`417`	`if (s_interrupt_handler[interrupt_number]->is_shared_handler() && !s_interrupt_handler[interrupt_number]->is_sharing_with_others()) {`
`418`		`- ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::SharedIRQHandler);`
	`418`	`+ ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::SharedIRQHandler);`
`419`	`419`	`static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->register_handler(handler);`
`420`	`420`	`return;`
`421`	`421`	`}`
`422`	`422`	`if (!s_interrupt_handler[interrupt_number]->is_shared_handler()) {`
`423`		`- ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::IRQHandler);`
	`423`	`+ ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::IRQHandler);`
`424`	`424`	`auto& previous_handler = *s_interrupt_handler[interrupt_number];`
`425`	`425`	`s_interrupt_handler[interrupt_number] = nullptr;`
`426`	`426`	`SharedIRQHandler::initialize(interrupt_number);`
`@@ -437,20 +437,20 @@ void register_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHan`
`437`	`437`	`void unregister_generic_interrupt_handler(u8 interrupt_number, GenericInterruptHandler& handler)`
`438`	`438`	`{`
`439`	`439`	`ASSERT(s_interrupt_handler[interrupt_number] != nullptr);`
`440`		`- if (s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::UnhandledInterruptHandler) {`
	`440`	`+ if (s_interrupt_handler[interrupt_number]->type() == HandlerType::UnhandledInterruptHandler) {`
`441`	`441`	`dbg() << "Trying to unregister unused handler (?)";`
`442`	`442`	`return;`
`443`	`443`	`}`
`444`	`444`	`if (s_interrupt_handler[interrupt_number]->is_shared_handler() && !s_interrupt_handler[interrupt_number]->is_sharing_with_others()) {`
`445`		`- ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::SharedIRQHandler);`
	`445`	`+ ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::SharedIRQHandler);`
`446`	`446`	`static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->unregister_handler(handler);`
`447`	`447`	`if (!static_cast<SharedIRQHandler*>(s_interrupt_handler[interrupt_number])->sharing_devices_count()) {`
`448`	`448`	`revert_to_unused_handler(interrupt_number);`
`449`	`449`	`}`
`450`	`450`	`return;`
`451`	`451`	`}`
`452`	`452`	`if (!s_interrupt_handler[interrupt_number]->is_shared_handler()) {`
`453`		`- ASSERT(s_interrupt_handler[interrupt_number]->purpose() == HandlerPurpose::IRQHandler);`
	`453`	`+ ASSERT(s_interrupt_handler[interrupt_number]->type() == HandlerType::IRQHandler);`
`454`	`454`	`revert_to_unused_handler(interrupt_number);`
`455`	`455`	`return;`
`456`	`456`	`}`