LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-14 22:31:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
e8ed7f829e
ladybird/Kernel/Interrupts/InterruptManagement.cpp

237 lines
9.0 KiB
C++
Raw Normal View History

Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
/*
* Copyright (c) 2020, Liav A. <liavalb@hotmail.co.il>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <AK/FixedArray.h>
AK: Reduce header dependency graph of String.h String.h no longer pulls in StringView.h. We do this by moving a bunch of String functions out-of-line.
2020-03-23 15:45:10 +03:00
#include <AK/StringView.h>
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
#include <Kernel/ACPI/MultiProcessorParser.h>
#include <Kernel/Arch/i386/CPU.h>
Kernel: Simplify the Interrupt management initialization
2020-04-09 20:16:51 +03:00
#include <Kernel/CommandLine.h>
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
#include <Kernel/IO.h>
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
#include <Kernel/Interrupts/APIC.h>
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
#include <Kernel/Interrupts/IOAPIC.h>
#include <Kernel/Interrupts/InterruptManagement.h>
#include <Kernel/Interrupts/PIC.h>
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 19:26:44 +03:00
#include <Kernel/Interrupts/SpuriousInterruptHandler.h>
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
#include <Kernel/Interrupts/UnhandledInterruptHandler.h>
Kernel: Move headers intended for userspace use into Kernel/API/
2020-07-04 18:22:23 +03:00
#include <Kernel/API/Syscall.h>
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
#include <Kernel/VM/MemoryManager.h>
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
#include <Kernel/VM/TypedMapping.h>
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
#define PCAT_COMPAT_FLAG 0x1
namespace Kernel {
static InterruptManagement* s_interrupt_management;
bool InterruptManagement::initialized()
{
return (s_interrupt_management != nullptr);
}
InterruptManagement& InterruptManagement::the()
{
ASSERT(InterruptManagement::initialized());
return *s_interrupt_management;
}
void InterruptManagement::initialize()
{
ASSERT(!InterruptManagement::initialized());
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
s_interrupt_management = new InterruptManagement();
Kernel: Simplify the Interrupt management initialization
2020-04-09 20:16:51 +03:00
if (kernel_command_line().lookup("smp").value_or("off") == "on")
InterruptManagement::the().switch_to_ioapic_mode();
else
InterruptManagement::the().switch_to_pic_mode();
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
void InterruptManagement::enumerate_interrupt_handlers(Function<void(GenericInterruptHandler&)> callback)
{
for (int i = 0; i < GENERIC_INTERRUPT_HANDLERS_COUNT; i++) {
auto& handler = get_interrupt_handler(i);
Kernel: Change data in /proc/interrupts to be more richer Also, during interrupt handlers' enumeration, we call all interrupts handlers that are not UnhandledInterruptHandler.
2020-03-05 20:15:38 +03:00
if (handler.type() != HandlerType::UnhandledInterruptHandler)
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
callback(handler);
}
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
IRQController& InterruptManagement::get_interrupt_controller(int index)
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
ASSERT(index >= 0);
ASSERT(!m_interrupt_controllers[index].is_null());
return *m_interrupt_controllers[index];
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
u8 InterruptManagement::acquire_mapped_interrupt_number(u8 original_irq)
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
{
if (!InterruptManagement::initialized()) {
// This is necessary, because we install UnhandledInterruptHandlers before we actually initialize the Interrupt Management object...
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
return original_irq;
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
return InterruptManagement::the().get_mapped_interrupt_vector(original_irq);
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
u8 InterruptManagement::acquire_irq_number(u8 mapped_interrupt_vector)
{
ASSERT(InterruptManagement::initialized());
return InterruptManagement::the().get_irq_vector(mapped_interrupt_vector);
}
u8 InterruptManagement::get_mapped_interrupt_vector(u8 original_irq)
{
// FIXME: For SMP configuration (with IOAPICs) use a better routing scheme to make redirections more efficient.
Interrupts: Assert if trying to install an handler on syscall vector Installing an interrupt handler on the syscall IDT vector can lead to fatal results, so we must assert if that happens.
2020-03-14 21:19:38 +03:00
// FIXME: Find a better way to handle conflict with Syscall interrupt gate.
ASSERT((original_irq + IRQ_VECTOR_BASE) != syscall_vector);
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
return original_irq;
}
u8 InterruptManagement::get_irq_vector(u8 mapped_interrupt_vector)
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
{
// FIXME: For SMP configuration (with IOAPICs) use a better routing scheme to make redirections more efficient.
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 03:34:46 +03:00
return mapped_interrupt_vector;
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
RefPtr<IRQController> InterruptManagement::get_responsible_irq_controller(u8 interrupt_vector)
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 19:26:44 +03:00
if (m_interrupt_controllers.size() == 1 && m_interrupt_controllers[0]->type() == IRQControllerType::i8259) {
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
return m_interrupt_controllers[0];
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 19:26:44 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
for (auto irq_controller : m_interrupt_controllers) {
Kernel: Abstract IRQ controller handling from Interrupt handlers Now we don't send raw numbers, but we let the IRQController object to figure out the correct IRQ number. This helps in a situation when we have 2 or more IOAPICs, so if IOAPIC 1 is assigned for IRQs 0-23 and IOAPIC 2 is assigned for IRQs 24-47, if an IRQHandler of IRQ 25 invokes disable() for example, it will call his responsible IRQController (IOAPIC 2), and the IRQController will subtract the IRQ number with his assigned offset, and the result is that the second redirection entry in IOAPIC 2 will be masked.
2020-03-08 13:47:33 +03:00
if (irq_controller->gsi_base() <= interrupt_vector)
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
if (!irq_controller->is_hard_disabled())
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
return irq_controller;
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
ASSERT_NOT_REACHED();
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
PhysicalAddress InterruptManagement::search_for_madt()
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
dbg() << "Early access to ACPI tables for interrupt setup";
Kernel: Add typed_map<T>(PhysicalAddress) and use it in ACPI parsing There was a frequently occurring pattern of "map this physical address into kernel VM, then read from it, then unmap it again". This new typed_map() encapsulates that logic by giving you back a typed pointer to the kind of structure you're interested in accessing. It returns a TypedMapping<T> that can be used mostly like a pointer. When destroyed, the TypedMapping object will unmap the memory. :^)
2020-04-09 18:12:58 +03:00
auto rsdp = ACPI::StaticParsing::find_rsdp();
Kernel: Simplify scanning BIOS/EBDA and MP parser initialization Add a MappedROM::find_chunk_starting_with() helper since that's a very common usage pattern in clients of this code. Also convert MultiProcessorParser from a persistent singleton object to a temporary object constructed via a failable factory function.
2020-05-22 14:34:53 +03:00
if (!rsdp.has_value())
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
return {};
Kernel: Simplify scanning BIOS/EBDA and MP parser initialization Add a MappedROM::find_chunk_starting_with() helper since that's a very common usage pattern in clients of this code. Also convert MultiProcessorParser from a persistent singleton object to a temporary object constructed via a failable factory function.
2020-05-22 14:34:53 +03:00
return ACPI::StaticParsing::find_table(rsdp.value(), "APIC");
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
InterruptManagement::InterruptManagement()
: m_madt(search_for_madt())
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
void InterruptManagement::switch_to_pic_mode()
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "Interrupts: Switch to Legacy PIC mode";
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
InterruptDisabler disabler;
m_smp_enabled = false;
Interrupts: Simplify initialization a bit more
2020-04-09 21:17:02 +03:00
m_interrupt_controllers[0] = adopt(*new PIC());
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 19:26:44 +03:00
SpuriousInterruptHandler::initialize(7);
SpuriousInterruptHandler::initialize(15);
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
for (auto& irq_controller : m_interrupt_controllers) {
ASSERT(irq_controller);
if (irq_controller->type() == IRQControllerType::i82093AA) {
irq_controller->hard_disable();
dbg() << "Interrupts: Detected " << irq_controller->model() << " - Disabled";
} else {
dbg() << "Interrupts: Detected " << irq_controller->model();
}
}
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
void InterruptManagement::switch_to_ioapic_mode()
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "Interrupts: Switch to IOAPIC mode";
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
InterruptDisabler disabler;
Interrupts: Simplify initialization a bit more
2020-04-09 21:17:02 +03:00
if (m_madt.is_null()) {
dbg() << "Interrupts: ACPI MADT is not available, reverting to PIC mode";
switch_to_pic_mode();
return;
}
dbg() << "Interrupts: MADT @ P " << m_madt.as_ptr();
locate_apic_data();
Kernel: Acquire ISA interrupt overrides from Interrupt Management Also, InterruptDisabler were added to prevent critical function from being interrupted. In addition, the interrupt numbers are abstracted from IDT offsets, thus, allowing to create a better routing scheme when using IOAPICs for interrupt redirection.
2020-03-06 04:19:40 +03:00
m_smp_enabled = true;
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
if (m_interrupt_controllers.size() == 1) {
if (get_interrupt_controller(0).type() == IRQControllerType::i8259) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "Interrupts: NO IOAPIC detected, Reverting to PIC mode.";
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
return;
}
}
for (auto& irq_controller : m_interrupt_controllers) {
ASSERT(irq_controller);
if (irq_controller->type() == IRQControllerType::i8259) {
irq_controller->hard_disable();
dbg() << "Interrupts: Detected " << irq_controller->model() << " Disabled";
} else {
dbg() << "Interrupts: Detected " << irq_controller->model();
}
}
Kernel: Simplify scanning BIOS/EBDA and MP parser initialization Add a MappedROM::find_chunk_starting_with() helper since that's a very common usage pattern in clients of this code. Also convert MultiProcessorParser from a persistent singleton object to a temporary object constructed via a failable factory function.
2020-05-22 14:34:53 +03:00
if (auto mp_parser = MultiProcessorParser::autodetect()) {
m_pci_interrupt_overrides = mp_parser->get_pci_interrupt_redirections();
}
Kernel: Add SMP IPI support We can now properly initialize all processors without crashing by sending SMP IPI messages to synchronize memory between processors. We now initialize the APs once we have the scheduler running. This is so that we can process IPI messages from the other cores. Also rework interrupt handling a bit so that it's more of a 1:1 mapping. We need to allocate non-sharable interrupts for IPIs. This also fixes the occasional hang/crash because all CPUs now synchronize memory with each other.
2020-07-06 16:27:22 +03:00
APIC::the().init_bsp();
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
void InterruptManagement::locate_apic_data()
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
{
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
ASSERT(!m_madt.is_null());
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
auto madt = map_typed<ACPI::Structures::MADT>(m_madt);
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
int irq_controller_count = 0;
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
if (madt->flags & PCAT_COMPAT_FLAG) {
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
m_interrupt_controllers[0] = adopt(*new PIC());
irq_controller_count++;
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
size_t entry_index = 0;
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
size_t entries_length = madt->h.length - sizeof(ACPI::Structures::MADT);
auto* madt_entry = madt->entries;
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
while (entries_length > 0) {
size_t entry_length = madt_entry->length;
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
if (madt_entry->type == (u8)ACPI::Structures::MADTEntryType::IOAPIC) {
auto* ioapic_entry = (const ACPI::Structures::MADTEntries::IOAPIC*)madt_entry;
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 16:46:28 +03:00
dbg() << "IOAPIC found @ MADT entry " << entry_index << ", MMIO Registers @ " << PhysicalAddress(ioapic_entry->ioapic_address);
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
m_interrupt_controllers.resize(1 + irq_controller_count);
Kernel: Use TypedMapping for accessing IOAPIC registers
2020-05-23 16:57:48 +03:00
m_interrupt_controllers[irq_controller_count] = adopt(*new IOAPIC(PhysicalAddress(ioapic_entry->ioapic_address), ioapic_entry->gsi_base));
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
irq_controller_count++;
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Kernel: Simplify interrupt management The IRQController object is RefCounted, and is shared between the InterruptManagement class & IRQ handlers' classes. IRQHandler, SharedIRQHandler & SpuriousInterruptHandler classes use a responsible IRQ controller directly instead of calling InterruptManagement for disable(), enable() or eoi(). Also, the initialization process of InterruptManagement is simplified, so it doesn't rely on an ACPI parser to be initialized.
2020-02-28 23:33:41 +03:00
if (madt_entry->type == (u8)ACPI::Structures::MADTEntryType::InterruptSourceOverride) {
auto* interrupt_override_entry = (const ACPI::Structures::MADTEntries::InterruptSourceOverride*)madt_entry;
Kernel: Remove ref-counting from interrupt override metadata I don't see a reason for these to be reference-counted, and removing it simplifies a bunch of surrounding data structures.
2020-05-08 22:07:04 +03:00
m_isa_interrupt_overrides.empend(
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
interrupt_override_entry->bus,
interrupt_override_entry->source,
interrupt_override_entry->global_system_interrupt,
Kernel: Remove ref-counting from interrupt override metadata I don't see a reason for these to be reference-counted, and removing it simplifies a bunch of surrounding data structures.
2020-05-08 22:07:04 +03:00
interrupt_override_entry->flags);
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
dbg() << "Interrupts: Overriding INT 0x" << String::format("%x", interrupt_override_entry->source) << " with GSI " << interrupt_override_entry->global_system_interrupt << ", for bus 0x" << String::format("%x", interrupt_override_entry->bus);
}
Kernel: Tweak some suspicious casts in InterruptManagement This code needs a closer looking-into at some point. It doesn't seem entirely safe to be casting u32's to pointers like it does.
2020-05-23 14:43:34 +03:00
madt_entry = (ACPI::Structures::MADTEntryHeader*)(VirtualAddress(madt_entry).offset(entry_length).get());
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
entries_length -= entry_length;
entry_index++;
}
}
Kernel: Remove ref-counting from interrupt override metadata I don't see a reason for these to be reference-counted, and removing it simplifies a bunch of surrounding data structures.
2020-05-08 22:07:04 +03:00
Kernel: Add Interrupt Management and Generic Interrupt Handler The GenericInterruptHandler class will be used to represent an abstract interrupt handler. The InterruptManagement class will represent a centralized component to manage interrupts.
2020-02-22 20:36:40 +03:00
}
Reference in New Issue Copy Permalink