sys/interrupts: support shared interrupts

Some devices (e.g. PCI devices) share a common IRQ line. Allow
installing more than one IRQ handler per vector.

When a vector has more than one installed handler, interrupt_handle()
tries to execute each and everyone of them until one returns
the newly defined INTERRUPT_HANDLED constant.

Update the now unneeded guard inside pci_device_register_interrupt_handler()
and interrupts_has_been_installed().

Closes #58

Author: d4ilyrun

include/kernel/devices/pci.h

@@ -84,7 +84,7 @@ error_t pci_device_register(struct pci_device *);
  *  @param interrupt_handler The interrupt handler function
  *  @param data The data passed to the interrupt handler
  */
-error_t pci_device_register_interrupt_handler(struct pci_device *,
+error_t pci_device_install_interrupt_handler(struct pci_device *,
                                               interrupt_handler_func_t, void *data);
 
 /** Enable/Disable a device's response to I/O space accesses */

include/kernel/interrupts.h

@@ -28,6 +28,16 @@
 #include <kernel/error.h>
 #include <kernel/types.h>
 
+#include <libalgo/linked_list.h>
+
+/**
+ *  Values returned by an interrupt handler.
+ */
+typedef enum interrupt_return {
+    INTERRUPT_HANDLED, /*!< Interrupt was handled by the handler. */
+    INTERRUPT_IGNORED, /*!< Interrupt was for another handler. */
+} interrupt_return_t;
+
 /**
  *  @brief Frame passed onto the interrupt handlers when triggering an interrupt
  *  @note This is a only a forward declaration. The actual definition
@@ -36,13 +46,18 @@
 typedef struct interrupt_frame interrupt_frame;
 
 /** Function pointer to an interrupt handler */
-typedef u32 (*interrupt_handler_func_t)(void *);
+typedef interrupt_return_t (*interrupt_handler_func_t)(void *);
+
+struct interrupt_handler {
+    interrupt_handler_func_t    handler;
+    void                        *data;
+    node_t                      this; /* used by interrupt_vector->handlers */
+};
 
 /** A single hardware IRQ vector. */
 struct interrupt_vector {
-    interrupt_handler_func_t handler;
-    void *data;
-    const char *name;
+    const char  *name;
+    llist_t     handlers;
 };
 
 struct interrupt_chip {
@@ -56,24 +71,32 @@ struct interrupt_chip {
  *  @param handler The handler function called when the interrupt occurs
  *  @param data Data passed to the interrupt handler
  */
-error_t interrupts_set_handler(unsigned int irq, interrupt_handler_func_t, void *);
+error_t
+interrupts_install_handler(unsigned int irq, interrupt_handler_func_t, void *);
+
+/** Install a pre-configured interrupt handler.
+ *
+ *  This function must be used only when configuring an interrupt handler
+ *  at before the virtual memory subsystem is initialized (INIT_BOOTSTRAP).
+ *
+ *  The interrupt_handler strcuture is initialized and provided by the caller.
+ */
+error_t
+interrupts_install_static_handler(unsigned int nr, struct interrupt_handler *);
 
 /** Retreive the current handler for a given IRQ
  *
  * @param irq The interrupt number
  * @param[out] pdata If not NULL, the handler's associated data is stored inside
  *                   this pointer (optional)
  *
+ * @note In the case of shared interrupts this function always returns the first
+ *       installed handler.
+ *
  * @return The current handler function fo the IRQ
  */
 interrupt_handler_func_t interrupts_get_handler(unsigned int irq, void **);
 
-/** Return wether a custom interrupt has been installed for the given vector */
-static inline bool interrupts_has_been_installed(unsigned int irq)
-{
-    return interrupts_get_handler(irq, NULL) != NULL;
-}
-
 error_t interrupt_handle(unsigned int nr);
 const char *interrupt_name(unsigned int nr);
 
@@ -85,7 +108,7 @@ const char *interrupt_name(unsigned int nr);
  * You must always use this function when defining an interrupt handler.
  */
 #define INTERRUPT_HANDLER_FUNCTION(_interrupt) \
-    u32 INTERRUPT_HANDLER(_interrupt)(void *data)
+    interrupt_return_t INTERRUPT_HANDLER(_interrupt)(void *data)
 
 /** @brief Disable interrupts on the current CPU. */
 static inline void interrupts_disable(void)

kernel/arch/i686/devices/pic.c

@@ -57,8 +57,8 @@ void pic_reset()
     log_info("Setting up custom IRQs handlers");
     pic_enable_irq(IRQ_CASCADE); /* Allow IRQs on slave to be triggered */
     pic_enable_irq(IRQ_KEYBOARD);
-    interrupts_set_handler(PIC_MASTER_VECTOR + IRQ_KEYBOARD,
-                           INTERRUPT_HANDLER(irq_keyboard), NULL);
+    interrupts_install_handler(PIC_MASTER_VECTOR + IRQ_KEYBOARD,
+                               INTERRUPT_HANDLER(irq_keyboard), NULL);
 }
 
 void pic_eoi(pic_irq irq)
@@ -109,5 +109,5 @@ static INTERRUPT_HANDLER_FUNCTION(irq_keyboard)
 
     pic_eoi(IRQ_KEYBOARD);
 
-    return E_SUCCESS;
+    return INTERRUPT_HANDLED;
 }

kernel/arch/i686/interrupts.c

@@ -144,9 +144,8 @@ error_t arch_interrupts_init(struct interrupt_chip *root_chip)
      * every the custom interrupt vector.
      */
     for (int i = 0; i < IDT_LENGTH; ++i) {
-        idt_interrupt_vectors[i].data = NULL;
-        idt_interrupt_vectors[i].handler = NULL;
         idt_interrupt_vectors[i].name = idt_interrupt_names[i];
+        INIT_LLIST(idt_interrupt_vectors[i].handlers);
         configure_idt_entry(&idt[i], INTERRUPT_GATE_32B,
                             interrupt_handler_stubs[i]);
     }

kernel/arch/i686/mmu.c

@@ -80,7 +80,15 @@
 #include <stddef.h>
 #include <string.h>
 
+/*
+ * Page fault handler must be statically defined since it is registered
+ * before the virtual memory API has been initialized.
+ */
 static INTERRUPT_HANDLER_FUNCTION(page_fault);
+static struct interrupt_handler page_fault_interrupt_handler = {
+    .handler = INTERRUPT_HANDLER(page_fault),
+    .data = NULL,
+};
 
 /** Number of entries inside the page directory */
 #define MMU_PDE_COUNT (1024)
@@ -701,7 +709,8 @@ bool mmu_init(void)
         return false;
     }
 
-    interrupts_set_handler(PAGE_FAULT, INTERRUPT_HANDLER(page_fault), NULL);
+    interrupts_install_static_handler(PAGE_FAULT,
+                                      &page_fault_interrupt_handler);
 
     /* Initialize caching structures. */
     mmu_init_pat();
@@ -783,7 +792,7 @@ static INTERRUPT_HANDLER_FUNCTION(page_fault)
         }
 
         if (!address_space_fault(as, faulty_address, is_cow))
-            return E_SUCCESS;
+            return INTERRUPT_HANDLED;
     }
 
 page_fault_panic:

kernel/arch/i686/timer.c

@@ -39,8 +39,8 @@ error_t arch_timer_start(u32 frequency)
         return err;
     }
 
-    interrupts_set_handler(PIC_MASTER_VECTOR + IRQ_TIMER,
-                           INTERRUPT_HANDLER(irq_timer), NULL);
+    interrupts_install_handler(PIC_MASTER_VECTOR + IRQ_TIMER,
+                               INTERRUPT_HANDLER(irq_timer), NULL);
     pic_enable_irq(IRQ_TIMER);
 
     return E_SUCCESS;
@@ -56,7 +56,7 @@ static INTERRUPT_HANDLER_FUNCTION(irq_timer)
     pic_eoi(IRQ_TIMER);
 
     if (!scheduler_initialized)
-        return E_SUCCESS;
+        return INTERRUPT_HANDLED;
 
     // TODO: Use a separate and more modern timer for scheduler (LAPIC, HPET)
     //
@@ -75,5 +75,5 @@ static INTERRUPT_HANDLER_FUNCTION(irq_timer)
     if (current->running.preempt <= timer_ticks_counter)
         schedule();
 
-    return E_SUCCESS;
+    return INTERRUPT_HANDLED;
 }

kernel/devices/pci.c

@@ -208,13 +208,18 @@ static void pci_device_setup_bars(struct pci_device *device)
     }
 }
 
-static u32 __pci_device_handle_interrupt(void *device)
+static interrupt_return_t __pci_device_handle_interrupt(void *device)
 {
     struct pci_device *pdev = device;
-    error_t ret;
+    interrupt_return_t ret;
 
-    if (!pdev->interrupt_handler)
-        return E_SUCCESS;
+    /*
+     * NOTE: What if the interrupt line is shared with a non-pci interrupt?
+     *       BIOS should configure the IRQ lines properly for this to never
+     *       happen I guess...
+     */
+    if (!pdev || !pdev->interrupt_handler)
+        return INTERRUPT_IGNORED;
 
     interrupts_disable();
 
@@ -226,9 +231,12 @@ static u32 __pci_device_handle_interrupt(void *device)
     return ret;
 }
 
-error_t pci_device_register_interrupt_handler(struct pci_device *pdev,
-                                              interrupt_handler_func_t handler,
-                                              void *data)
+/*
+ *
+ */
+error_t pci_device_install_interrupt_handler(struct pci_device *pdev,
+                                             interrupt_handler_func_t handler,
+                                             void *data)
 {
     uint8_t interrupt;
 
@@ -238,18 +246,11 @@ error_t pci_device_register_interrupt_handler(struct pci_device *pdev,
     if (!pdev->interrupt_line)
         return E_SUCCESS;
 
-    /* TODO: Implement MSI (+ remove dependency on arch-specifi IRQ) */
-    if (interrupts_has_been_installed(interrupt)) {
-        log_warn("another interrupt has already been installed on the "
-                 "interrupt line (" FMT8 ")",
-                 interrupt);
-        return E_BUSY;
-    }
-
     pdev->interrupt_data = data;
     pdev->interrupt_handler = handler;
 
-    interrupts_set_handler(interrupt, __pci_device_handle_interrupt, pdev);
+    /* TODO: Implement MSI + remove dependency on arch-specifi PIC IRQ. */
+    interrupts_install_handler(interrupt, __pci_device_handle_interrupt, pdev);
     pic_enable_irq(pdev->interrupt_line);
 
     pci_device_enable_interrupts(pdev, true);

kernel/devices/rtl8139.c

@@ -242,19 +242,22 @@ static error_t rtl8139_receive_packet(struct rtl8139 *rtl8139)
     return ret;
 }
 
-static u32 rtl8139_interrupt_handler(void *data)
+static interrupt_return_t rtl8139_interrupt_handler(void *data)
 {
     struct rtl8139 *rtl8139 = data;
     uint16_t isr = rtl8139_readw(rtl8139, INTERRUPT_STATUS);
 
-    if (isr & INT_RX_OK) {
+    isr &= ~RTL8139_SUPPORTED_INTERRUPTS;
+    if (isr == 0)
+        return INTERRUPT_IGNORED; /* not for us. */
+
+    if (isr & INT_RX_OK)
         rtl8139_receive_packet(rtl8139);
-    }
 
     /* clear interrupt source bit by writing one to the ISR (6.7) */
     rtl8139_writew(rtl8139, INTERRUPT_STATUS, isr);
 
-    return E_SUCCESS;
+    return INTERRUPT_HANDLED;
 }
 
 static error_t rtl8139_enable_capability(struct ethernet_device *device,
@@ -377,7 +380,7 @@ static error_t rtl8139_probe(struct device *dev)
                        mmu_find_physical((vaddr_t)tx));
     }
 
-    ret = pci_device_register_interrupt_handler(pdev, rtl8139_interrupt_handler,
+    ret = pci_device_install_interrupt_handler(pdev, rtl8139_interrupt_handler,
                                                 rtl8139);
     if (ret)
         goto probe_failed;

kernel/misc/uacpi.c

@@ -356,7 +356,7 @@ uacpi_kernel_install_interrupt_handler(uacpi_u32 irq,
     handle->handler = interrupts_get_handler(irq, &handle->data);
     *out_irq_handle = handle;
 
-    err = interrupts_set_handler(irq, handler, ctx);
+    err = interrupts_install_handler(irq, handler, ctx);
     if (err) {
         kfree(handle);
         *out_irq_handle = NULL;
@@ -373,7 +373,7 @@ uacpi_kernel_uninstall_interrupt_handler(uacpi_interrupt_handler handler,
     UNUSED(handler);
 
     uacpi_irq_handle *irq = irq_handle;
-    interrupts_set_handler(irq->irq, irq->handler, irq->data);
+    interrupts_install_handler(irq->irq, irq->handler, irq->data);
 
     return UACPI_STATUS_OK;
 }