interrupts.h

Go to the documentation of this file.

 
#ifndef MAX_OS_HARDWARECOMMUNICATION_INTERRUPTS_H
#define MAX_OS_HARDWARECOMMUNICATION_INTERRUPTS_H
 
#include <cstdint>
 
#include <libcommon/port.h>
#include <libcommon/inputStream.h>
#include <libcommon/outputStream.h>
#include <libcommon/map.h>
 
#include <system/gdt.h>
#include <system/cpu.h>
#include <hardwarecommunication/apic.h>
 
 
namespace MaxOS::hardwarecommunication {
 
    class InterruptManager;
 
    enum class InterruptPrivilegeLevel
    {
        KERNEL_ONLY,
        RING_1,
        RING_2,
        USERSPACE
    };
 
    class InterruptHandler {
        protected:
            uint8_t m_interrupt_number;     
 
            explicit InterruptHandler(uint8_t interrupt_number, int64_t redirect = -1, uint64_t redirect_index = 0);
            virtual ~InterruptHandler();
 
        public:
            virtual void handle_interrupt();
            virtual system::cpu_status_t* handle_interrupt(system::cpu_status_t* status);
 
    };
 
    class ExceptionHandler : public InterruptHandler {
 
        public:
        ExceptionHandler(uint8_t interrupt_number);
            ~ExceptionHandler();
 
            virtual string get_message(system::cpu_status_t* status);
            virtual system::cpu_status_t* handle_interrupt(system::cpu_status_t* status);
 
    };
 
    class DivideByZeroHandler : public ExceptionHandler {
        public:
 
            DivideByZeroHandler() : ExceptionHandler(0x00) {    }
 
            string get_message(system::cpu_status_t* status) final;
    };
 
    class InvaildOpCodeHandler : public ExceptionHandler {
        public:
 
            InvaildOpCodeHandler() : ExceptionHandler(0x06) {   }
 
            string get_message(system::cpu_status_t* status) final;
    };
 
    class GeneralProtectionHandler : public ExceptionHandler {
        public:
 
            GeneralProtectionHandler() : ExceptionHandler(0x0D) { }
 
            string get_message(system::cpu_status_t* status) final;
    };
 
    class PageFaultHandler : public ExceptionHandler {
        public:
 
            PageFaultHandler() : ExceptionHandler(0x0E) { }
 
            string get_message(system::cpu_status_t* status) final;
    };
 
    class CPUStopHandler : public InterruptHandler {
        public:
 
            CPUStopHandler() : InterruptHandler(0x81) { }
 
            system::cpu_status_t* handle_interrupt(system::cpu_status_t* status) final;
    };
 
 
    typedef struct PACKED IDTR {
        uint16_t limit; 
        uint64_t base;  
    } idtr_t;
 
    typedef struct PACKED InterruptDescriptor {
 
        uint16_t address_low_bits;    
        uint16_t segment_selector;    
        uint8_t ist;                  
        uint8_t flags;                
        uint16_t address_mid_bits;    
        uint32_t address_high_bits;   
        uint32_t reserved;            
 
    } interrupt_descriptor_t;
 
    constexpr uint16_t HARDWARE_INTERRUPT_OFFSET = 0x20;    
    constexpr uint16_t MAX_INTERRUPT_HANDLERS = 256;        
 
    class ExceptionHandlers {
 
        private:
 
            // Exception handles
            DivideByZeroHandler m_db0_handler;
            InvaildOpCodeHandler m_opce_handler;
            GeneralProtectionHandler m_gpe_handler;
            PageFaultHandler m_page_fault_handler;
            CPUStopHandler m_cpu_stop_handler;
 
        public:
            ExceptionHandlers();
            ~ExceptionHandlers();
 
    };
 
    class InterruptManager {
            friend class InterruptHandler;
 
        private:
            AdvancedProgrammableInterruptController* m_apic = nullptr;
 
            static system::cpu_status_t* page_fault(system::cpu_status_t* status);
            static system::cpu_status_t* general_protection_fault(system::cpu_status_t* status);
 
        protected:
 
            inline static InterruptManager* s_active_interrupt_manager = nullptr;                                   
 
            InterruptHandler* m_interrupt_handlers[MAX_INTERRUPT_HANDLERS] = { };                                    
            inline static InterruptDescriptor s_interrupt_descriptor_table[MAX_INTERRUPT_HANDLERS] = { };            
 
            static void set_interrupt_descriptor_table_entry(uint8_t interrupt, void (* handler)(), InterruptPrivilegeLevel descriptor_privilege_level);
 
            //Various Interrupts
            static void HandleInterruptRequest0x00();   
            static void HandleInterruptRequest0x01();   
            static void HandleInterruptRequest0x02();   
            static void HandleInterruptRequest0x03();   
            static void HandleInterruptRequest0x04();   
            static void HandleInterruptRequest0x05();   
            static void HandleInterruptRequest0x06();   
            static void HandleInterruptRequest0x07();   
            static void HandleInterruptRequest0x08();   
            static void HandleInterruptRequest0x09();   
            static void HandleInterruptRequest0x0A();   
            static void HandleInterruptRequest0x0B();   
            static void HandleInterruptRequest0x0C();   
            static void HandleInterruptRequest0x0D();   
            static void HandleInterruptRequest0x0E();   
            static void HandleInterruptRequest0x80();   
            static void HandleInterruptRequest0x0F();   
            static void HandleInterruptRequest0x31();   
            static void HandleInterruptRequest0x60();   
            static void HandleInterruptRequest0x61();   
 
            // Exceptions
            static void HandleException0x00();          
            static void HandleException0x01();          
            static void HandleException0x02();          
            static void HandleException0x03();          
            static void HandleException0x04();          
            static void HandleException0x05();          
            static void HandleException0x06();          
            static void HandleException0x07();          
            static void HandleInterruptError0x08();     
            static void HandleException0x09();          
            static void HandleInterruptError0x0A();     
            static void HandleInterruptError0x0B();     
            static void HandleInterruptError0x0C();     
            static void HandleInterruptError0x0D();     
            static void HandleInterruptError0x0E();     
            static void HandleException0x0F();          
            static void HandleException0x10();          
            static void HandleInterruptError0x11();     
            static void HandleException0x12();          
            static void HandleException0x13();          
            static void HandleException0x14();          
            static void HandleException0x15();          
            static void HandleException0x16();          
            static void HandleException0x17();          
            static void HandleException0x18();          
            static void HandleException0x19();          
            static void HandleException0x1A();          
            static void HandleException0x1B();          
            static void HandleException0x1C();          
            static void HandleException0x1D();          
            static void HandleException0x1E();          
            static void HandleException0x1F();          
 
            static system::cpu_status_t* HandleInterrupt(system::cpu_status_t* status);
            system::cpu_status_t* handle_interrupt_request(system::cpu_status_t* status);
 
        public:
            InterruptManager();
            ~InterruptManager();
 
            static InterruptManager* active_interrupt_manager();
 
            void set_interrupt_handler(uint8_t interrupt, InterruptHandler* handler);
            void remove_interrupt_handler(uint8_t interrupt);
 
            void set_apic(AdvancedProgrammableInterruptController* apic);
            AdvancedProgrammableInterruptController* active_apic();
 
            static void load_current();
            void activate();
            static void deactivate();
 
            static void ForceInterruptReturn(system::cpu_status_t* state);
 
    };
}
 
 
#endif //MAX_OS_HARDWARECOMMUNICATION_INTERRUPTS_H