1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

pub mod apic;
mod handlers;

use crate::sync::{once::OnceLock, spin::mutex::Mutex};

use super::{
    gdt::USER_RING,
    idt::{BasicInterruptHandler, InterruptDescriptorTable, InterruptHandlerWithAllState},
};

static INTERRUPTS: OnceLock<Mutex<Interrupts>> = OnceLock::new();

pub(super) mod stack_index {
    pub const FAULTS_STACK: u8 = 0;
    pub const DOUBLE_FAULT_STACK: u8 = 1;
}

const USER_INTERRUPTS_START: u8 = 0x20;
const MAX_USER_INTERRUPTS: u8 = 0xe0 - 0x10;
pub const SPECIAL_SCHEDULER_INTERRUPT: u8 = 0xdf; // last one (0xFF)
pub const SPECIAL_SYSCALL_INTERRUPT: u8 =
    kernel_user_link::syscalls::SYSCALL_INTERRUPT_NUMBER - USER_INTERRUPTS_START;

struct Interrupts {
    idt: InterruptDescriptorTable,
    last_used_user_interrupt: u16,
}

impl Interrupts {
    // only apply init for static context
    fn init(&'static mut self) {
        self.idt.init_default_handlers();

        // this is only done once
        self.idt.apply_idt();
    }

    fn get_next_interrupt(&mut self) -> u8 {
        if self.last_used_user_interrupt >= MAX_USER_INTERRUPTS as u16 {
            panic!("No more user interrupts available");
        }

        let interrupt = self.last_used_user_interrupt;
        self.last_used_user_interrupt += 1;

        interrupt as u8
    }

    fn allocate_basic_user_interrupt(&mut self, handler: BasicInterruptHandler) -> u8 {
        let interrupt = self.get_next_interrupt();

        self.idt.user_defined[interrupt as usize].set_handler(handler);

        interrupt + USER_INTERRUPTS_START
    }

    fn allocate_user_interrupt_all_saved(&mut self, handler: InterruptHandlerWithAllState) -> u8 {
        let interrupt = self.get_next_interrupt();

        self.idt.user_defined[interrupt as usize]
            .set_handler_with_number(handler, interrupt + USER_INTERRUPTS_START);

        interrupt + USER_INTERRUPTS_START
    }
}

pub fn init_interrupts() {
    if INTERRUPTS.try_get().is_some() {
        panic!("Interrupts already initialized");
    }

    INTERRUPTS
        .get_or_init(|| {
            let interrupts = Interrupts {
                idt: InterruptDescriptorTable::empty(),
                last_used_user_interrupt: 0,
            };
            Mutex::new(interrupts)
        })
        .run_with_mut(|interrupts| {
            interrupts.init();
        });
}

// All Types of interrupt handlers
pub trait InterruptHandler {
    fn allocate_and_set_handler(val: Self) -> u8;
}

impl InterruptHandler for BasicInterruptHandler {
    fn allocate_and_set_handler(handler: Self) -> u8 {
        INTERRUPTS
            .get()
            .lock()
            .allocate_basic_user_interrupt(handler)
    }
}

impl InterruptHandler for InterruptHandlerWithAllState {
    fn allocate_and_set_handler(handler: Self) -> u8 {
        INTERRUPTS
            .get()
            .lock()
            .allocate_user_interrupt_all_saved(handler)
    }
}

/// Puts the handler in the IDT and returns the interrupt/vector number
pub(super) fn allocate_user_interrupt<F: InterruptHandler>(handler: F) -> u8 {
    F::allocate_and_set_handler(handler)
}

/// Puts the handler in the IDT and returns the interrupt/vector number
pub(super) fn allocate_basic_user_interrupt(handler: BasicInterruptHandler) -> u8 {
    BasicInterruptHandler::allocate_and_set_handler(handler)
}

/// Puts the handler in the IDT and returns the interrupt/vector number
pub(super) fn allocate_user_interrupt_all_saved(handler: InterruptHandlerWithAllState) -> u8 {
    InterruptHandlerWithAllState::allocate_and_set_handler(handler)
}

pub fn create_scheduler_interrupt(handler: InterruptHandlerWithAllState) {
    let mut interrupts = INTERRUPTS.get().lock();
    interrupts.idt.user_defined[SPECIAL_SCHEDULER_INTERRUPT as usize]
        .set_handler_with_number(handler, SPECIAL_SCHEDULER_INTERRUPT + USER_INTERRUPTS_START)
        .set_disable_interrupts(true);
}

pub fn create_syscall_interrupt(handler: InterruptHandlerWithAllState) {
    let mut interrupts = INTERRUPTS.get().lock();
    interrupts.idt.user_defined[SPECIAL_SYSCALL_INTERRUPT as usize]
        .set_handler_with_number(handler, SPECIAL_SYSCALL_INTERRUPT + USER_INTERRUPTS_START)
        .set_privilege_level(USER_RING)
        .set_disable_interrupts(false);
}