MaxOS::hardwarecommunication::InterruptManager Class Reference

Handles all interrupts and passes them to the correct handler. More...

#include <interrupts.h>

Public Member Functions
	InterruptManager ()
	Constructs the Interrupt Manager and sets up the interrupt descriptor table (does not activate interrupts)
	~InterruptManager ()
	Destroys the Interrupt Manager and deactivates interrupts.
void	set_interrupt_handler (uint8_t interrupt, InterruptHandler *handler)
	Sets the interrupt handler for the interrupt.
void	remove_interrupt_handler (uint8_t interrupt)
	Removes the interrupt handler for the interrupt.
void	set_apic (AdvancedProgrammableInterruptController *apic)
	Sets the APIC.
AdvancedProgrammableInterruptController *	active_apic ()
	Gets the APIC.
void	activate ()
	Activates the interrupt manager and starts interrupts (also deactivates the current interrupt manager)

Static Public Member Functions
static InterruptManager *	active_interrupt_manager ()
	Gets the active interrupt manager.
static void	load_current ()
	Tell the processor to use the current InterruptManager.
static void	deactivate ()
	Deactivates the interrupt manager and stops interrupts.
static void	ForceInterruptReturn (system::cpu_status_t *state)
	Force the CPU to return from an interrupt (see interrupts.s)

Protected Member Functions
system::cpu_status_t *	handle_interrupt_request (system::cpu_status_t *status)
	Handles the interrupt request by passing it to the appropriate handler.

Static Protected Member Functions
static void	set_interrupt_descriptor_table_entry (uint8_t interrupt, void(*handler)(), uint8_t descriptor_privilege_level)
	Sets an entry in the Interrupt Descriptor Table.
static void	HandleInterruptRequest0x00 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x01 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x02 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x03 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x04 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x05 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x06 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x07 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x08 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x09 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0A ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0B ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0C ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0D ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0E ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x80 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x0F ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x31 ()
	Stub (see interrupts.s)
static void	HandleInterruptRequest0x60 ()
	Stub (see interrupts.s)
static void	HandleException0x00 ()
	Stub (see interrupts.s)
static void	HandleException0x01 ()
	Stub (see interrupts.s)
static void	HandleException0x02 ()
	Stub (see interrupts.s)
static void	HandleException0x03 ()
	Stub (see interrupts.s)
static void	HandleException0x04 ()
	Stub (see interrupts.s)
static void	HandleException0x05 ()
	Stub (see interrupts.s)
static void	HandleException0x06 ()
	Stub (see interrupts.s)
static void	HandleException0x07 ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x08 ()
	Stub (see interrupts.s)
static void	HandleException0x09 ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x0A ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x0B ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x0C ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x0D ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x0E ()
	Stub (see interrupts.s)
static void	HandleException0x0F ()
	Stub (see interrupts.s)
static void	HandleException0x10 ()
	Stub (see interrupts.s)
static void	HandleInterruptError0x11 ()
	Stub (see interrupts.s)
static void	HandleException0x12 ()
	Stub (see interrupts.s)
static void	HandleException0x13 ()
	Stub (see interrupts.s)
static void	HandleException0x14 ()
	Stub (see interrupts.s)
static void	HandleException0x15 ()
	Stub (see interrupts.s)
static void	HandleException0x16 ()
	Stub (see interrupts.s)
static void	HandleException0x17 ()
	Stub (see interrupts.s)
static void	HandleException0x18 ()
	Stub (see interrupts.s)
static void	HandleException0x19 ()
	Stub (see interrupts.s)
static void	HandleException0x1A ()
	Stub (see interrupts.s)
static void	HandleException0x1B ()
	Stub (see interrupts.s)
static void	HandleException0x1C ()
	Stub (see interrupts.s)
static void	HandleException0x1D ()
	Stub (see interrupts.s)
static void	HandleException0x1E ()
	Stub (see interrupts.s)
static void	HandleException0x1F ()
	Stub (see interrupts.s)
static system::cpu_status_t *	HandleInterrupt (system::cpu_status_t *status)
	Handles the interrupt request by passing it to the interrupt manager.

Protected Attributes
InterruptHandler *	m_interrupt_handlers [MAX_INTERRUPT_HANDLERS] = { }
	A map of index-to-interrupt of interrupt handlers to fire when an interrupt occurs.

Static Protected Attributes
static InterruptManager *	s_active_interrupt_manager = nullptr
	The interrupt manger that is currently handling interrupts and is loaded into the IDTR.
static InterruptDescriptor	s_interrupt_descriptor_table [MAX_INTERRUPT_HANDLERS] = { }
	The Interrupt Descriptor Table (IDT)

Friends
class	InterruptHandler

Detailed Description

Handles all interrupts and passes them to the correct handler.

Todo:

Remove the max array of handler make vector, add static handlers for page faults and gpe. Make it so that multiple handlers can be registered for the same interrupt

Have a single stub so that we don't need to have 256 different functions for each interrupt

Definition at line 84 of file interrupts.h.

Constructor & Destructor Documentation

InterruptManager()

InterruptManager::InterruptManager

(

)

Constructs the Interrupt Manager and sets up the interrupt descriptor table (does not activate interrupts)

Definition at line 90 of file interrupts.cpp.

                                   {
 
    Logger::INFO() << "Setting up Interrupt Manager\n";
    s_active_interrupt_manager = this;
 
    // Clear the table
    for (auto& descriptor: s_interrupt_descriptor_table) {
        descriptor.address_low_bits = 0;
        descriptor.address_mid_bits = 0;
        descriptor.address_high_bits = 0;
        descriptor.segment_selector = 0;
        descriptor.ist = 0;
        descriptor.flags = 0;
    }
 
    //Set Up the base interrupts
    set_interrupt_descriptor_table_entry(0x00, &HandleException0x00, 0);   // Division by zero
    set_interrupt_descriptor_table_entry(0x01, &HandleException0x01, 0);   // Debug
    set_interrupt_descriptor_table_entry(0x02, &HandleException0x02, 0);   // Non-maskable interrupt
    set_interrupt_descriptor_table_entry(0x03, &HandleException0x03, 0);   // Breakpoint
    set_interrupt_descriptor_table_entry(0x04, &HandleException0x04, 0);   // Overflow
    set_interrupt_descriptor_table_entry(0x05, &HandleException0x05, 0);   // Bound Range Exceeded
    set_interrupt_descriptor_table_entry(0x06, &HandleException0x06, 0);   // Invalid Opcode
    set_interrupt_descriptor_table_entry(0x06, &HandleException0x07, 0);   // Device Not Available
    set_interrupt_descriptor_table_entry(0x08, &HandleInterruptError0x08, 0);   // Double Fault
    set_interrupt_descriptor_table_entry(0x09, &HandleException0x09, 0);   // Coprocessor Segment Overrun
    set_interrupt_descriptor_table_entry(0x0A, &HandleInterruptError0x0A, 0);   // Invalid TSS
    set_interrupt_descriptor_table_entry(0x0B, &HandleInterruptError0x0B, 0);   // Segment Not Present
    set_interrupt_descriptor_table_entry(0x0C, &HandleInterruptError0x0C, 0);   // Stack-Segment Fault
    set_interrupt_descriptor_table_entry(0x0D, &HandleInterruptError0x0D, 0);   // General Protection Fault
    set_interrupt_descriptor_table_entry(0x0E, &HandleInterruptError0x0E, 0);   // Page Fault
    set_interrupt_descriptor_table_entry(0x0F, &HandleException0x0F, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x10, &HandleException0x10, 0);   // x87 Floating-Point Exception
    set_interrupt_descriptor_table_entry(0x11, &HandleInterruptError0x11, 0);   // Alignment Check
    set_interrupt_descriptor_table_entry(0x12, &HandleException0x12, 0);   // Machine Check
    set_interrupt_descriptor_table_entry(0x13, &HandleException0x13, 0);   // SIMD Floating-Point Exception
    set_interrupt_descriptor_table_entry(0x14, &HandleException0x14, 0);   // Reserved: Virtualization Exception
    set_interrupt_descriptor_table_entry(0x15, &HandleException0x15, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x16, &HandleException0x16, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x17, &HandleException0x17, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x18, &HandleException0x18, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x19, &HandleException0x19, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x1A, &HandleException0x1A, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x1B, &HandleException0x1B, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x1C, &HandleException0x1C, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x1D, &HandleException0x1D, 0);   // Reserved
    set_interrupt_descriptor_table_entry(0x1E, &HandleException0x1E, 0);   // Security Exception
    set_interrupt_descriptor_table_entry(0x1F, &HandleException0x1F, 0);   // Reserved
 
    // Set up the hardware interrupts
    set_interrupt_descriptor_table_entry(HARDWARE_INTERRUPT_OFFSET + 0x00, &HandleInterruptRequest0x00, 0);   // APIC Timer Interrupt
    set_interrupt_descriptor_table_entry(HARDWARE_INTERRUPT_OFFSET + 0x01, &HandleInterruptRequest0x01, 0);   // Keyboard Interrupt
    set_interrupt_descriptor_table_entry(HARDWARE_INTERRUPT_OFFSET + 0x02, &HandleInterruptRequest0x02, 0);   // PIT Interrupt
    set_interrupt_descriptor_table_entry(HARDWARE_INTERRUPT_OFFSET + 0x0C, &HandleInterruptRequest0x0C, 0);   // Mouse Interrupt
 
    // Set up the system call interrupt
    set_interrupt_descriptor_table_entry(HARDWARE_INTERRUPT_OFFSET + 0x60, &HandleInterruptRequest0x60, 3);   // System Call Interrupt - Privilege Level 3 so that user space can call it
 
    // Tell the processor to use the IDT
    load_current();
}

References HandleException0x00(), HandleException0x01(), HandleException0x02(), HandleException0x03(), HandleException0x04(), HandleException0x05(), HandleException0x06(), HandleException0x07(), HandleException0x09(), HandleException0x0F(), HandleException0x10(), HandleException0x12(), HandleException0x13(), HandleException0x14(), HandleException0x15(), HandleException0x16(), HandleException0x17(), HandleException0x18(), HandleException0x19(), HandleException0x1A(), HandleException0x1B(), HandleException0x1C(), HandleException0x1D(), HandleException0x1E(), HandleException0x1F(), HandleInterruptError0x08(), HandleInterruptError0x0A(), HandleInterruptError0x0B(), HandleInterruptError0x0C(), HandleInterruptError0x0D(), HandleInterruptError0x0E(), HandleInterruptError0x11(), HandleInterruptRequest0x00(), HandleInterruptRequest0x01(), HandleInterruptRequest0x02(), HandleInterruptRequest0x0C(), HandleInterruptRequest0x60(), MaxOS::hardwarecommunication::HARDWARE_INTERRUPT_OFFSET, MaxOS::Logger::INFO(), load_current(), s_active_interrupt_manager, s_interrupt_descriptor_table, and set_interrupt_descriptor_table_entry().

~InterruptManager()

InterruptManager::~InterruptManager

(

)

Destroys the Interrupt Manager and deactivates interrupts.

Definition at line 155 of file interrupts.cpp.

                                    {
    deactivate();
}

References deactivate().

Member Function Documentation

activate()

void InterruptManager::activate

(

)

Activates the interrupt manager and starts interrupts (also deactivates the current interrupt manager)

Definition at line 201 of file interrupts.cpp.

                                {
 
    Logger::INFO() << "Activating Interrupts \n";
 
    // Deactivate the current (old) interrupt manager
    InterruptManager::deactivate();
 
    // Set the current interrupt manager and start interrupts
    s_active_interrupt_manager = this;
    asm("sti");
}

References deactivate(), MaxOS::Logger::INFO(), and s_active_interrupt_manager.

active_apic()

AdvancedProgrammableInterruptController * InterruptManager::active_apic

(

)

Gets the APIC.

Returns

The APIC

Definition at line 382 of file interrupts.cpp.

                                                                       {
 
    return m_apic;
}

active_interrupt_manager()

InterruptManager * InterruptManager::active_interrupt_manager ( )

static

Gets the active interrupt manager.

Returns

The active interrupt manager

Definition at line 392 of file interrupts.cpp.

                                                             {
 
    return s_active_interrupt_manager;
}

References s_active_interrupt_manager.

Referenced by MaxOS::hardwarecommunication::AdvancedProgrammableInterruptController::AdvancedProgrammableInterruptController().

deactivate()

void InterruptManager::deactivate ( )

static

Deactivates the interrupt manager and stops interrupts.

Definition at line 216 of file interrupts.cpp.

                                  {
 
    // Cant deactivate if it isn't the system one
    if (s_active_interrupt_manager != nullptr)
        return;
 
    // Prevent interrupts from firing when nothing is set up to handle them
    asm("cli");
    s_active_interrupt_manager = nullptr;
}

References s_active_interrupt_manager.

Referenced by activate(), and ~InterruptManager().

ForceInterruptReturn()

static void MaxOS::hardwarecommunication::InterruptManager::ForceInterruptReturn ( system::cpu_status_t *  state )

static

Force the CPU to return from an interrupt (see interrupts.s)

Parameters

state

the state to return to

Referenced by MaxOS::common::BlockingLock::acquire().

handle_interrupt_request()

cpu_status_t * InterruptManager::handle_interrupt_request ( system::cpu_status_t *  status )

protected

Handles the interrupt request by passing it to the appropriate handler.

Parameters

status

The current cpu status

Returns

The updated cpu status

Definition at line 284 of file interrupts.cpp.

                                                                             {
 
    // Where to go afterward
    cpu_status_t* new_status = status;
 
    // If there is an interrupt manager, handle the interrupt
    if (m_interrupt_handlers[status->interrupt_number] != nullptr)
        new_status = m_interrupt_handlers[status->interrupt_number]->handle_interrupt(status);
    else
        Logger::WARNING() << "Interrupt " << (int) status->interrupt_number << " not handled\n";
 
    // Send the EOI to the APIC
    if (HARDWARE_INTERRUPT_OFFSET <= status->interrupt_number && status->interrupt_number < HARDWARE_INTERRUPT_OFFSET + 16)
        CPU::executing_core()->local_apic->send_eoi();
 
    // Return the status
    return new_status;
}

References MaxOS::system::CPU::executing_core(), MaxOS::hardwarecommunication::InterruptHandler::handle_interrupt(), MaxOS::hardwarecommunication::HARDWARE_INTERRUPT_OFFSET, m_interrupt_handlers, and MaxOS::Logger::WARNING().

HandleInterrupt()

system::cpu_status_t * InterruptManager::HandleInterrupt ( system::cpu_status_t *  status )

staticprotected

Handles the interrupt request by passing it to the interrupt manager.

Parameters

status

The current cpu status

Returns

The updated cpu status

Definition at line 233 of file interrupts.cpp.

                                                                                {
 
    // Default Fault Handlers
    switch (status->interrupt_number) {
 
        case 0x7:
            CPU::PANIC("Device Not Available: FPU Not Enabled", status);
            break;
 
        case 0x0D:
            return general_protection_fault(status);
 
        case 0x0E:
            return page_fault(status);
    }
 
    // If there is an interrupt manager handle interrupt
    if (s_active_interrupt_manager != nullptr)
        return s_active_interrupt_manager->handle_interrupt_request(status);
 
    // CPU Can continue
    return status;
}

References MaxOS::system::CPU::PANIC(), and s_active_interrupt_manager.

load_current()

void InterruptManager::load_current ( )

static

Tell the processor to use the current InterruptManager.

Definition at line 190 of file interrupts.cpp.

                                    {
 
    IDTR idt = {};
    idt.limit = 256 * sizeof(InterruptDescriptor) - 1;
    idt.base = (uint64_t) s_interrupt_descriptor_table;
    asm volatile("lidt %0" : : "m" (idt));
}

References s_interrupt_descriptor_table.

Referenced by MaxOS::system::Core::init(), and InterruptManager().

remove_interrupt_handler()

void InterruptManager::remove_interrupt_handler

(

uint8_t

interrupt

)

Removes the interrupt handler for the interrupt.

Parameters

interrupt

The interrupt number

Definition at line 273 of file interrupts.cpp.

                                                                 {
 
    m_interrupt_handlers[interrupt] = nullptr;
}

References m_interrupt_handlers.

set_apic()

void InterruptManager::set_apic

(

AdvancedProgrammableInterruptController *

apic

)

Sets the APIC.

Parameters

apic

The APIC

Definition at line 308 of file interrupts.cpp.

                                                                             {
 
    m_apic = apic;
}

Referenced by MaxOS::hardwarecommunication::AdvancedProgrammableInterruptController::AdvancedProgrammableInterruptController().

set_interrupt_descriptor_table_entry()

void InterruptManager::set_interrupt_descriptor_table_entry ( uint8_t  interrupt, void(*)()  handler, uint8_t  descriptor_privilege_level  )

staticprotected

Sets an entry in the Interrupt Descriptor Table.

Parameters

interrupt	Interrupt number
handler	Interrupt Handler
descriptor_privilege_level	Descriptor Privilege Level

Definition at line 166 of file interrupts.cpp.

                                                                                                                                     {
 
    // Get the address of the handler and the entry in the IDT
    auto handler_address = (uint64_t) handler;
    InterruptDescriptor* interrupt_descriptor = &s_interrupt_descriptor_table[interrupt];
 
    // Set the handler address
    interrupt_descriptor->address_low_bits = handler_address & 0xFFFF;
    interrupt_descriptor->address_mid_bits = (handler_address >> 16) & 0xFFFF;
    interrupt_descriptor->address_high_bits = (handler_address >> 32) & 0xFFFFFFFF;
 
    // Set the kernel code segment offset
    interrupt_descriptor->segment_selector = 0x08;
 
    // Disable IST
    interrupt_descriptor->ist = 0;
 
    // Set the flags (Trap Gate, Present and the Descriptor Privilege Level)
    interrupt_descriptor->flags = 0b1110 | ((descriptor_privilege_level & 0b11) << 5) | (1 << 7);
}

References s_interrupt_descriptor_table.

Referenced by InterruptManager().

set_interrupt_handler()

void InterruptManager::set_interrupt_handler	(	uint8_t	interrupt,
		InterruptHandler *	handler
	)

Sets the interrupt handler for the interrupt.

Parameters

interrupt	The interrupt number
handler	The interrupt handler

Definition at line 263 of file interrupts.cpp.

                                                                                         {
 
    m_interrupt_handlers[interrupt] = handler;
}

References m_interrupt_handlers.

Friends And Related Symbol Documentation

InterruptHandler

friend class InterruptHandler

friend

Definition at line 85 of file interrupts.h.

Member Data Documentation

m_interrupt_handlers

InterruptHandler* MaxOS::hardwarecommunication::InterruptManager::m_interrupt_handlers[MAX_INTERRUPT_HANDLERS] = { }

protected

A map of index-to-interrupt of interrupt handlers to fire when an interrupt occurs.

Definition at line 97 of file interrupts.h.

{ };                                    

Referenced by handle_interrupt_request(), remove_interrupt_handler(), and set_interrupt_handler().

s_active_interrupt_manager

InterruptManager* MaxOS::hardwarecommunication::InterruptManager::s_active_interrupt_manager = nullptr

inlinestaticprotected

The interrupt manger that is currently handling interrupts and is loaded into the IDTR.

Definition at line 95 of file interrupts.h.

Referenced by activate(), active_interrupt_manager(), deactivate(), HandleInterrupt(), MaxOS::hardwarecommunication::InterruptHandler::InterruptHandler(), InterruptManager(), and MaxOS::hardwarecommunication::InterruptHandler::~InterruptHandler().

s_interrupt_descriptor_table

InterruptDescriptor MaxOS::hardwarecommunication::InterruptManager::s_interrupt_descriptor_table[MAX_INTERRUPT_HANDLERS] = { }

inlinestaticprotected

The Interrupt Descriptor Table (IDT)

Definition at line 98 of file interrupts.h.

{ };            

Referenced by InterruptManager(), load_current(), and set_interrupt_descriptor_table_entry().

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/hardwarecommunication/interrupts.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/hardwarecommunication/interrupts.cpp