alioth/src/device/ioapic.rs - 4575b33

ioapic.rs62.50%

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
//! Emulated x86 IO APIC device.
//! See: https://download.intel.com/design/chipsets/datashts/29056601.pdf chapter 3.2
 
use parking_lot::Mutex;
 
use crate::arch::x86_64::intr::{DestinationMode, MsiAddrLo, MsiData, TriggerMode};
use crate::arch::x86_64::ioapic::{
    IOAPIC_VER, IOAPICARB, IOAPICID, IOAPICVER, IOREDTBL_BASE, IOREDTBL_MAX, IOREGSEL, IOWIN,
    NUM_PINS, RedirectEntry, RegId, RegVer,
};
use crate::arch::x86_64::layout::{APIC_START, IOAPIC_END, IOAPIC_START};
use crate::device::{self, MmioDev, Pause};
use crate::hv::MsiSender;
use crate::mem;
use crate::mem::emulated::{Action, Mmio};
 
#[derive(Debug, Default)]
struct IoApicRegs {
    id: RegId,
    redirtbl: [RedirectEntry; NUM_PINS as usize],
    select: u8,
}
 
#[derive(Debug)]
pub struct IoApic<M: MsiSender> {
    regs: Mutex<IoApicRegs>,
    msi_sender: M,
}
 
impl<M: MsiSender> IoApic<M> {
    pub fn new(msi_sender: M) -> Self {24x
        Self {24x
            regs: Mutex::new(IoApicRegs::default()),24x
            msi_sender,24x
        }24x
    }24x
 
    pub fn service_pin(&self, pin: u8) -> crate::hv::Result<()> {12x
        let regs = self.regs.lock();12x
        let Some(entry) = regs.redirtbl.get(pin as usize) else {12x
            log::warn!("IOAPIC: invalid pin {pin}");
            return Ok(());
        };
 
        if entry.masked() {12x
            return Ok(());
        }12x
 
        if entry.dest_mode() == DestinationMode::LOGICAL.raw() {12x
            log::warn!("IOAPIC: logical destination is not supported");
            return Ok(());
        }12x
        if entry.trigger_mode() == TriggerMode::LEVEL.raw() {12x
            log::warn!("IOAPIC: level-triggered interrupts are not supported");
            return Ok(());
        }12x
 
        let mut addr_lo = MsiAddrLo(APIC_START as u32);12x
        addr_lo.set_dest_id(entry.dest_id());12x
        addr_lo.set_virt_dest_id_hi(entry.virt_dest_id_hi());12x
 
        let data = MsiData::new(12x
            entry.vector(),12x
            entry.delivery_mode(),12x
            false,
            entry.trigger_mode(),12x
        );
 
        self.msi_sender.send(addr_lo.0 as u64, data.0)12x
    }12x
 
    fn read_reg(&self, regs: &IoApicRegs) -> u32 {6x
        match regs.select {6x
            IOAPICID | IOAPICARB => regs.id.0,
            IOAPICVER => RegVer::new(IOAPIC_VER, NUM_PINS - 1).0,
            select @ IOREDTBL_BASE..=IOREDTBL_MAX => {6x
                let pin = ((select - IOREDTBL_BASE) >> 1) as usize;6x
                let Some(entry) = regs.redirtbl.get(pin) else {6x
                    log::warn!("IOAPIC: read from unknown pin {pin:#x}");
                    return 0;
                };
                if select % 2 == 0 {6x
                    entry.0 as u323x
                } else {
                    (entry.0 >> 32) as u323x
                }
            }
            unknown => {
                log::warn!("IOAPCI: read from unknown register {unknown:#x}");
                0
            }
        }
    }6x
 
    fn write_reg(&self, regs: &mut IoApicRegs, val: u32) {30x
        match regs.select {30x
            IOAPICID => regs.id.set_id(RegId(val).id()),
            IOAPICVER | IOAPICARB => log::warn!("IOAPIC: IOAPICVER and IOAPICARB are read-only"),
            select @ IOREDTBL_BASE..=IOREDTBL_MAX => {30x
                let pin = ((select - IOREDTBL_BASE) >> 1) as usize;30x
                let Some(entry) = regs.redirtbl.get_mut(pin) else {30x
                    log::warn!("IOAPIC: write to unknown pin {pin:#x}");
                    return;
                };
                entry.0 = if select % 2 == 0 {30x
                    (entry.0 & 0xffffffff00000000) | (val as u64)15x
                } else {
                    (entry.0 & 0x00000000ffffffff) | ((val as u64) << 32)15x
                };
            }
            unknown => {
                log::warn!("IOAPIC: write to unknown register {unknown:#x} with value {val:#x}");
            }
        }
    }30x
}
 
impl<M: MsiSender> Mmio for IoApic<M> {
    fn size(&self) -> u64 {
        IOAPIC_END - IOAPIC_START
    }
 
    fn read(&self, offset: u64, size: u8) -> mem::Result<u64> {9x
        if size != 4 {9x
            log::warn!("IOAPIC: unaligned read: offset={offset:#x} size={size}");
            return Ok(0);
        }9x
        let regs = self.regs.lock();9x
        let val = match offset {9x
            IOREGSEL => regs.select as u32,3x
            IOWIN => self.read_reg(&regs),6x
            _ => {
                log::warn!("IOAPIC: read from unknown offset {offset:#x}");
                0
            }
        };
        Ok(val as u64)9x
    }9x
 
    fn write(&self, offset: u64, size: u8, val: u64) -> mem::Result<Action> {60x
        if size != 4 {60x
            log::warn!("IOAPIC: unaligned write: offset={offset:#x} size={size}");
            return Ok(Action::None);
        }60x
        let mut regs = self.regs.lock();60x
        match offset {60x
            IOREGSEL => regs.select = val as u8,30x
            IOWIN => self.write_reg(&mut regs, val as u32),30x
            _ => {
                log::warn!("IOAPIC: write to unknown offset {offset:#x} with value {val:#x}");
            }
        }
        Ok(Action::None)60x
    }60x
}
 
impl<M: MsiSender> Pause for IoApic<M> {
    fn pause(&self) -> device::Result<()> {
        Ok(())
    }
 
    fn resume(&self) -> device::Result<()> {
        Ok(())
    }
}
 
impl<M: MsiSender> MmioDev for IoApic<M> {}
 
#[cfg(test)]
#[path = "ioapic_test.rs"]
pub mod tests;
 