Struct rstubs::arch::int::lapic::LApic

pub struct LApic {
    pub base: AtomicPtr<u32>,
    timer_ticks: AtomicUsize,
}

Abstracts the local APICs (which is integrated into every CPU core)

In modern (x86) PCs, every CPU core has its own Local APIC (LAPIC). The LAPIC is the link between the local CPU core and the I/O APIC (that takes care about external interrupt sources. Interrupt messages received by the LAPIC will be passed to the corresponding CPU core and trigger the interrupt handler on this core.

See https://wiki.osdev.org/APIC

Fields

base: AtomicPtr<u32>

Base of the memory mapped lapic registers

timer_ticks: AtomicUsize

Latency of the lapic timer. This is measured an set when the first timer is created.

Implementations

impl LApic

pub const BASE: usize = 4_276_092_928usize

Default base address for the memory-mapped registers.

pub const fn new() -> LApic

Creates a new instance that has to be initialized with Self::init.

pub fn init(&self, cpu_id: u8)

Initialize the LAPIC fo the given cpu_id.

pub fn eoi(&self)

Signalizes the LAPIC that the handling of the current interrupt finished. This function must be called at the end of interrupt handling before ireting.

pub fn version(&self) -> u8

Get version number of local APIC.

pub fn id(&self) -> u8

Get the ID of the current core’s LAPIC.

This id is also used to identify the core.

pub fn timer(&self, us: usize, vector: u8, periodic: bool, masked: bool)

Setup the lapic timer

pub fn timer_enable(&self, enable: bool)

fn calculate_ticks(&self) -> usize

Determines the LAPIC timer divider.

This function will calculate the number of LAPIC-timer ticks passing in the course of one millisecond. To do so, this function will rely on PIT timer functionality and measure the tick delta between start and end of waiting for a predefined period.

For measurement, the LAPIC-timer single-shot mode (without interrupts) is used; after measurement, the timer is disabled again.

Steps taken for precise measurement of LAPIC-timer ticks per ms:

1. Disable Interrupts to ensure measurement is not disturbed
2. Configure a timeout of 50 ms (nearly PIT’s maximum possible delay) Using a “large” value decreases the overhead induced by measurement and thereby increases the accuracy.
3. Now measure the number of passed LAPIC-timer ticks while waiting for the PIT Note that configuring the PIT takes quite some time and therefore should be done prior to starting LAPIC-timer measurement.
4. Restore previous state (disable PIT, LAPIC timer, restore interrupts)
5. Derive the ticks per millisecond (take care, the counter is counting towards zero)

pub fn ipi_delivered(&self) -> bool

Check if the previously sent IPI has reached its destination.

pub fn ipi_send(&self, destination: IPIDestination, vector: Vector)

Send an Inter-Processor Interrupt (IPI).

pub fn ipi_send_init(&self, core: u8)

Send an INIT request IPI to all other processors.

pub fn ipi_send_startup(&self, core: u8, vector: u8)

Send an Startup IPI to all other processors.

fn raw_timer( &self, counter: u32, divide: u32, vector: u8, periodic: bool, masked: bool )

fn update<T: IOMem>(&self, f: impl FnOnce(T) -> T)

fn update2<A: IOMem, B: IOMem>(&self, f: impl FnOnce(A, B) -> (A, B))

fn write<T: IOMem>(&self, value: T)

fn read<T: IOMem>(&self) -> T

Trait Implementations

impl Debug for LApic

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.