beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/Arch/x86_64/InterruptManagement.cpp

231 lines
9 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 17:36:40 +00:00
/*
* Copyright (c) 2020, Liav A. <liavalb@hotmail.co.il>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
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 17:36:40 +00:00
*/
Kernel/Interrupts: Add ByteReaders to read possible unaligned MADT data The MADT data could be on unaligned boundary - for example, a GSI number (u32) on unaligned address which leads to a KUBSAN error and halting the system.
2021-11-28 17:23:58 +00:00
#include <AK/ByteReader.h>
Refactor: Replace usages of FixedArray with Array.
2020-09-06 19:40:46 +00:00
#include <Kernel/API/Syscall.h>
Kernel: Add GenericInterruptHandler.cpp to aarch64 build This requires us to add an Interrupts.h file in the Kernel/Arch directory, which includes the architecture specific files. The commit also stubs out the functions to be able to compile the aarch64 Kernel.
2022-05-11 14:54:03 +00:00
#include <Kernel/Arch/Interrupts.h>
Kernel: Move MultiProcessor parsing code to the Arch/x86_64 directory This code is very x86-specific, because Intel introduced the actual MultiProcessor specification back in 1993, qouted here as a proof: "The MP specification covers PC/AT-compatible MP platform designs based on Intel processor architectures and Advanced Programmable Interrupt Controller (APIC) architectures"
2023-06-09 18:24:25 +00:00
#include <Kernel/Arch/x86_64/Firmware/MultiProcessor/Parser.h>
Kernel: Reorganize Arch/x86 directory to Arch/x86_64 after i686 removal No functional change.
2022-10-04 10:46:11 +00:00
#include <Kernel/Arch/x86_64/InterruptManagement.h>
#include <Kernel/Arch/x86_64/Interrupts/APIC.h>
#include <Kernel/Arch/x86_64/Interrupts/IOAPIC.h>
#include <Kernel/Arch/x86_64/Interrupts/PIC.h>
Kernel: Move all boot-related code to the new Boot subdirectory
2023-02-24 18:21:53 +00:00
#include <Kernel/Boot/CommandLine.h>
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
#include <Kernel/Firmware/ACPI/StaticParsing.h>
Kernel: Move InterruptDisabler to the Interrupts subdirectory
2023-02-24 18:33:43 +00:00
#include <Kernel/Interrupts/InterruptDisabler.h>
Kernel/Interrupts: Enumerate nested handlers in a shared handler When asked to enumerate all interrupt handlers, display all shared handlers within it instead of just returning the responsible handler of them.
2021-06-05 04:50:27 +00:00
#include <Kernel/Interrupts/SharedIRQHandler.h>
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 16:26:44 +00:00
#include <Kernel/Interrupts/SpuriousInterruptHandler.h>
Kernel: Rename Kernel/VM/ to Kernel/Memory/ This directory isn't just about virtual memory, it's about all kinds of memory management.
2021-08-06 08:45:34 +00:00
#include <Kernel/Memory/TypedMapping.h>
Kernel: Move special sections into Sections.h This also removes a lot of CPU.h includes infavor for Sections.h
2021-06-22 15:40:16 +00:00
#include <Kernel/Sections.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 17:36:40 +00:00
#define PCAT_COMPAT_FLAG 0x1
namespace Kernel {
static InterruptManagement* s_interrupt_management;
bool InterruptManagement::initialized()
{
return (s_interrupt_management != nullptr);
}
InterruptManagement& InterruptManagement::the()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(InterruptManagement::initialized());
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 17:36:40 +00:00
return *s_interrupt_management;
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT void InterruptManagement::initialize()
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 17:36:40 +00:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(!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 20:33:41 +00:00
s_interrupt_management = new InterruptManagement();
Kernel: Ensure SMP mode is not enabled if IOAPIC mode is disabled We need to use the IOAPIC in SMP mode, so if the user requested to disable it, we can't enable SMP mode either.
2021-12-19 19:30:36 +00:00
if (!kernel_command_line().is_smp_enabled_without_ioapic_enabled()) {
dbgln("Can't enable SMP mode without IOAPIC mode being enabled");
}
Kernel: Allow switching to IOAPIC mode even without enabling SMP This small change allows to use the IOAPIC by default without to enable SMP mode, which emulates Uni-Processor setup with IOAPIC instead of using the PIC. This opens the opportunity to utilize other types of interrupts like MSI and MSI-X interrupts.
2021-11-28 15:38:10 +00:00
if (!kernel_command_line().is_ioapic_enabled() && !kernel_command_line().is_smp_enabled())
Kernel: Simplify the Interrupt management initialization
2020-04-09 17:16:51 +00:00
InterruptManagement::the().switch_to_pic_mode();
Kernel: Allow switching to IOAPIC mode even without enabling SMP This small change allows to use the IOAPIC by default without to enable SMP mode, which emulates Uni-Processor setup with IOAPIC instead of using the PIC. This opens the opportunity to utilize other types of interrupts like MSI and MSI-X interrupts.
2021-11-28 15:38:10 +00:00
else
InterruptManagement::the().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 17:36:40 +00:00
}
void InterruptManagement::enumerate_interrupt_handlers(Function<void(GenericInterruptHandler&)> callback)
{
Kernel: Stop using 'int's for indices in interrupt handling
2022-09-25 12:29:24 +00:00
for (size_t i = 0; i < GENERIC_INTERRUPT_HANDLERS_COUNT; i++) {
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 17:36:40 +00:00
auto& handler = get_interrupt_handler(i);
Kernel/Interrupts: Enumerate nested handlers in a shared handler When asked to enumerate all interrupt handlers, display all shared handlers within it instead of just returning the responsible handler of them.
2021-06-05 04:50:27 +00:00
if (handler.type() == HandlerType::SharedIRQHandler) {
static_cast<SharedIRQHandler&>(handler).enumerate_handlers(callback);
continue;
}
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 17:15:38 +00: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 17:36:40 +00:00
callback(handler);
}
}
Kernel: Stop using 'int's for indices in interrupt handling
2022-09-25 12:29:24 +00:00
IRQController& InterruptManagement::get_interrupt_controller(size_t 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 17:36:40 +00: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 20:33:41 +00:00
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 17:36:40 +00:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 00:34:46 +00: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 01:19:40 +00: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 00:34:46 +00: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 01:19:40 +00:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 00:34:46 +00: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 01:19:40 +00:00
}
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 00:34:46 +00:00
u8 InterruptManagement::acquire_irq_number(u8 mapped_interrupt_vector)
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(InterruptManagement::initialized());
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 00:34:46 +00:00
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 18:19:38 +00:00
// FIXME: Find a better way to handle conflict with Syscall interrupt gate.
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY((original_irq + IRQ_VECTOR_BASE) != syscall_vector);
Kernel: Create an interface for conversion between IRQs and interrupts
2020-03-08 00:34:46 +00: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 01:19:40 +00: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 00:34:46 +00: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 01:19:40 +00:00
}
Kernel: Store IRQControllers in NonnullRefPtrs instead of RefPtrs These are always non-null, so there's no point in storing them in a nullable container.
2022-09-25 12:25:14 +00:00
NonnullLockRefPtr<IRQController> InterruptManagement::get_responsible_irq_controller(IRQControllerType controller_type, u8 interrupt_vector)
Kernel/Interrupts: Initialize two spurious handlers when PIC is disabled Even if the PIC was disabled it can still generate noise (spurious IRQs) so we need to register two handlers for handling such cases. Also, we declare interrupt service routine offset 0x20 to 0x2f as reserved, so when the PIC is disabled, we can handle spurious IRQs from the PIC at separate handlers.
2022-01-28 16:18:14 +00:00
{
for (auto& irq_controller : m_interrupt_controllers) {
if (irq_controller->gsi_base() <= interrupt_vector && irq_controller->type() == controller_type)
return irq_controller;
}
VERIFY_NOT_REACHED();
}
Kernel: Store IRQControllers in NonnullRefPtrs instead of RefPtrs These are always non-null, so there's no point in storing them in a nullable container.
2022-09-25 12:25:14 +00:00
NonnullLockRefPtr<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 17:36:40 +00:00
{
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 16:26:44 +00: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 20:33:41 +00:00
return m_interrupt_controllers[0];
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 16:26:44 +00:00
}
Kernel: Avoid some un-necessary copies coming from range based for loops - The irq_controller was getting add_ref/released needlessly during enumeration. - Used ranges were also getting needlessly copied.
2021-02-15 11:56:39 +00: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 10:47:33 +00: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 17:36:40 +00: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 20:33:41 +00: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 17:36:40 +00:00
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_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 17:36:40 +00:00
}
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
UNMAP_AFTER_INIT ErrorOr<Optional<PhysicalAddress>> InterruptManagement::find_madt_physical_address()
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 17:36:40 +00:00
{
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything: The modifications in this commit were automatically made using the following command: find . -name '*.cpp' -exec sed -i -E 's/dbg\(\) << ("[^"{]*");/dbgln\(\1\);/' {} \;
2021-01-09 17:51:44 +00:00
dbgln("Early access to ACPI tables for interrupt setup");
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
auto possible_rsdp_physical_address = TRY(ACPI::StaticParsing::find_rsdp_in_platform_specific_memory_locations());
if (!possible_rsdp_physical_address.has_value())
return Optional<PhysicalAddress> {};
auto possible_apic_physical_address = TRY(ACPI::StaticParsing::find_table(possible_rsdp_physical_address.value(), "APIC"sv));
if (!possible_apic_physical_address.has_value())
return Optional<PhysicalAddress> {};
return possible_apic_physical_address.value();
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 17:36:40 +00:00
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT InterruptManagement::InterruptManagement()
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 17:36:40 +00:00
{
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT 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 17:36:40 +00:00
{
Kernel: Simplify InterruptManagement::switch_to_pic_mode() Since switch_to_pic_mode is only called if no IOAPIC is available, there's no need to try and and find it and disable it.
2022-09-25 12:11:28 +00:00
VERIFY(m_interrupt_controllers.is_empty());
Kernel: Convert klog() => AK::Format in InterruptManagement
2021-03-12 13:02:58 +00:00
dmesgln("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 01:19:40 +00:00
InterruptDisabler disabler;
Kernel: Use InterruptManagement::m_interrupt_controllers::append() There's no need to reinvent the wheel.
2022-09-25 12:09:10 +00:00
m_interrupt_controllers.append(adopt_lock_ref(*new PIC()));
Kernel: Initialize Spurious IRQ handlers in switch_to_pic_mode()
2020-02-28 16:26:44 +00:00
SpuriousInterruptHandler::initialize(7);
SpuriousInterruptHandler::initialize(15);
Kernel: Simplify InterruptManagement::switch_to_pic_mode() Since switch_to_pic_mode is only called if no IOAPIC is available, there's no need to try and and find it and disable it.
2022-09-25 12:11:28 +00:00
dbgln("Interrupts: Detected {}", m_interrupt_controllers[0]->model());
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 17:36:40 +00:00
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT 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 17:36:40 +00:00
{
Kernel: Convert klog() => AK::Format in InterruptManagement
2021-03-12 13:02:58 +00:00
dmesgln("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 01:19:40 +00:00
InterruptDisabler disabler;
Interrupts: Simplify initialization a bit more
2020-04-09 18:17:02 +00:00
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
m_madt_physical_address = MUST(find_madt_physical_address());
if (!m_madt_physical_address.has_value()) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything: The modifications in this commit were automatically made using the following command: find . -name '*.cpp' -exec sed -i -E 's/dbg\(\) << ("[^"{]*");/dbgln\(\1\);/' {} \;
2021-01-09 17:51:44 +00:00
dbgln("Interrupts: ACPI MADT is not available, reverting to PIC mode");
Interrupts: Simplify initialization a bit more
2020-04-09 18:17:02 +00:00
switch_to_pic_mode();
return;
}
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
dbgln("Interrupts: MADT @ P {}", m_madt_physical_address.value().as_ptr());
Interrupts: Simplify initialization a bit more
2020-04-09 18:17:02 +00:00
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 17:36:40 +00:00
if (m_interrupt_controllers.size() == 1) {
if (get_interrupt_controller(0).type() == IRQControllerType::i8259) {
Kernel: Convert klog() => AK::Format in InterruptManagement
2021-03-12 13:02:58 +00:00
dmesgln("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 17:36:40 +00:00
return;
}
}
for (auto& irq_controller : m_interrupt_controllers) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(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 17:36:40 +00:00
if (irq_controller->type() == IRQControllerType::i8259) {
irq_controller->hard_disable();
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("Interrupts: Detected {} - Disabled", irq_controller->model());
Kernel/Interrupts: Initialize two spurious handlers when PIC is disabled Even if the PIC was disabled it can still generate noise (spurious IRQs) so we need to register two handlers for handling such cases. Also, we declare interrupt service routine offset 0x20 to 0x2f as reserved, so when the PIC is disabled, we can handle spurious IRQs from the PIC at separate handlers.
2022-01-28 16:18:14 +00:00
SpuriousInterruptHandler::initialize_for_disabled_master_pic();
SpuriousInterruptHandler::initialize_for_disabled_slave_pic();
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 17:36:40 +00:00
} else {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("Interrupts: Detected {}", irq_controller->model());
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 17:36:40 +00:00
}
}
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 11:34:53 +00: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 13:27:22 +00:00
Kernel: Encapsulate APIC initialization inside InterruptManagement Currently the APIC class is constructed irrespective of whether it is used or not. So, move APIC initialization from init to the InterruptManagement class and construct the APIC class only when it is needed.
2021-12-25 04:08:58 +00:00
APIC::initialize();
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 13:27:22 +00: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 17:36:40 +00:00
}
Kernel: Slap UNMAP_AFTER_INIT on a whole bunch of functions There's no real system here, I just added it to various functions that I don't believe we ever want to call after initialization has finished. With these changes, we're able to unmap 60 KiB of kernel text after init. :^)
2021-02-19 17:41:50 +00:00
UNMAP_AFTER_INIT 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 17:36:40 +00:00
{
Kernel/ACPI: Make most of StaticParsing methods to be platform-agnostic Most of the ACPI static parsing methods (methods that can be called without initializing a full AML parser) are not tied to any specific platform or CPU architecture. The only method that is platform-specific is the one that finds the RSDP structure. Thus, each CPU architecture/platform needs to implement it. This means that now aarch64 can implement its own method to find the ACPI RSDP structure, which would be hooked into the rest of the ACPI code elegantly, but for now I just added a FIXME and that method returns empty value of Optional<PhysicalAddress>.
2023-06-09 19:50:11 +00:00
VERIFY(m_madt_physical_address.has_value());
auto madt = Memory::map_typed<ACPI::Structures::MADT>(m_madt_physical_address.value()).release_value_but_fixme_should_propagate_errors();
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 17:36:40 +00:00
Kernel: Use InterruptManagement::m_interrupt_controllers::append() There's no need to reinvent the wheel.
2022-09-25 12:09:10 +00:00
if (madt->flags & PCAT_COMPAT_FLAG)
m_interrupt_controllers.append(adopt_lock_ref(*new PIC()));
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 17:36:40 +00:00
size_t entry_index = 0;
Kernel: Use TypedMappings when looking for APIC information
2020-05-23 13:46:28 +00: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 17:36:40 +00: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 20:33:41 +00:00
if (madt_entry->type == (u8)ACPI::Structures::MADTEntryType::IOAPIC) {
auto* ioapic_entry = (const ACPI::Structures::MADTEntries::IOAPIC*)madt_entry;
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("IOAPIC found @ MADT entry {}, MMIO Registers @ {}", entry_index, PhysicalAddress(ioapic_entry->ioapic_address));
Kernel: Use InterruptManagement::m_interrupt_controllers::append() There's no need to reinvent the wheel.
2022-09-25 12:09:10 +00:00
m_interrupt_controllers.append(adopt_lock_ref(*new IOAPIC(PhysicalAddress(ioapic_entry->ioapic_address), ioapic_entry->gsi_base)));
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 17:36:40 +00: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 20:33:41 +00:00
if (madt_entry->type == (u8)ACPI::Structures::MADTEntryType::InterruptSourceOverride) {
auto* interrupt_override_entry = (const ACPI::Structures::MADTEntries::InterruptSourceOverride*)madt_entry;
Kernel/Interrupts: Add ByteReaders to read possible unaligned MADT data The MADT data could be on unaligned boundary - for example, a GSI number (u32) on unaligned address which leads to a KUBSAN error and halting the system.
2021-11-28 17:23:58 +00:00
u32 global_system_interrupt = 0;
ByteReader::load<u32>(reinterpret_cast<u8 const*>(&interrupt_override_entry->global_system_interrupt), global_system_interrupt);
u16 flags = 0;
ByteReader::load<u16>(reinterpret_cast<u8 const*>(&interrupt_override_entry->flags), flags);
Kernel: Use MUST + Vector::try_empend instead of Vector::empend In preparation for making Vector::empend unavailable during compilation of the Kernel.
2022-01-03 11:25:29 +00:00
MUST(m_isa_interrupt_overrides.try_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 17:36:40 +00:00
interrupt_override_entry->bus,
interrupt_override_entry->source,
Kernel/Interrupts: Add ByteReaders to read possible unaligned MADT data The MADT data could be on unaligned boundary - for example, a GSI number (u32) on unaligned address which leads to a KUBSAN error and halting the system.
2021-11-28 17:23:58 +00:00
global_system_interrupt,
Kernel: Use MUST + Vector::try_empend instead of Vector::empend In preparation for making Vector::empend unavailable during compilation of the Kernel.
2022-01-03 11:25:29 +00:00
flags));
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("Interrupts: Overriding INT {:#x} with GSI {}, for bus {:#x}",
interrupt_override_entry->source,
Kernel/Interrupts: Add ByteReaders to read possible unaligned MADT data The MADT data could be on unaligned boundary - for example, a GSI number (u32) on unaligned address which leads to a KUBSAN error and halting the system.
2021-11-28 17:23:58 +00:00
global_system_interrupt,
Kernel: Allow switching to IOAPIC mode even without enabling SMP This small change allows to use the IOAPIC by default without to enable SMP mode, which emulates Uni-Processor setup with IOAPIC instead of using the PIC. This opens the opportunity to utilize other types of interrupts like MSI and MSI-X interrupts.
2021-11-28 15:38:10 +00:00
interrupt_override_entry->bus);
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 17:36:40 +00:00
}
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 11:43:34 +00: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 17:36:40 +00: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 19:07:04 +00: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 17:36:40 +00:00
}
Reference in a new issue Copy permalink