ostd 0.17.2

Rust OS framework that facilitates the development of and innovation in OS kernels
Documentation 
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

// SPDX-License-Identifier: MPL-2.0

mod table;

use core::fmt::Debug;

use spin::Once;
pub(super) use table::IntRemappingTable;

use crate::{
    arch::iommu::registers::{ExtendedCapabilityFlags, IOMMU_REGS},
    info, warn,
};

pub struct IrtEntryHandle {
    index: u16,
    table: &'static IntRemappingTable,
}

impl IrtEntryHandle {
    pub fn index(&self) -> u16 {
        self.index
    }

    pub fn enable(&self, vector: u32) {
        self.table
            .set_entry(self.index, table::IrtEntry::new_enabled(vector));

        IOMMU_REGS
            .get()
            .unwrap()
            .lock()
            .invalidate_interrupt_cache();
    }
}

impl Debug for IrtEntryHandle {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("IrtEntryHandle")
            .field("index", &self.index)
            .finish_non_exhaustive()
    }
}

pub fn has_interrupt_remapping() -> bool {
    REMAPPING_TABLE.get().is_some()
}

pub fn alloc_irt_entry() -> Option<IrtEntryHandle> {
    let page_table = REMAPPING_TABLE.get()?;
    page_table.alloc()
}

pub(super) fn init() {
    let mut iommu_regs = IOMMU_REGS.get().unwrap().lock();

    // Check if interrupt remapping is supported
    let extend_cap = iommu_regs.read_extended_capability();
    if !extend_cap.flags().contains(ExtendedCapabilityFlags::IR) {
        warn!("Interrupt remapping not supported");
        return;
    }

    // Create interrupt remapping table
    REMAPPING_TABLE.call_once(IntRemappingTable::new);
    iommu_regs.enable_interrupt_remapping(REMAPPING_TABLE.get().unwrap());

    info!("Interrupt remapping enabled");
}

static REMAPPING_TABLE: Once<IntRemappingTable> = Once::new();