alioth/src/mem/emulated.rs - 71d66ab

emulated.rs90.67%

// Copyright 2024 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.
 
use std::fmt::Debug;
use std::sync::Arc;
 
use crate::mem::addressable::{Addressable, SlotBackend};
use crate::mem::{Memory, Result};
 
#[cfg(not(test))]
pub trait ChangeLayout: Debug + Send + Sync + 'static {
    fn change(&self, memory: &Memory) -> Result<()>;
}
#[cfg(test)]
pub trait ChangeLayout: Debug + Send + Sync + std::any::Any + 'static {
    fn change(&self, memory: &Memory) -> Result<()>;
}
 
#[derive(Debug)]
pub enum Action {
    None,
    Shutdown,
    Reset,
    ChangeLayout { callback: Box<dyn ChangeLayout> },
}
 
pub trait Mmio: Debug + Send + Sync + 'static {
    fn read(&self, offset: u64, size: u8) -> Result<u64>;
    fn write(&self, offset: u64, size: u8, val: u64) -> Result<Action>;
    fn size(&self) -> u64;
}
 
impl Mmio for Arc<dyn Mmio> {
    fn read(&self, offset: u64, size: u8) -> Result<u64> {81x
        Mmio::read(self.as_ref(), offset, size)81x
    }81x
 
    fn write(&self, offset: u64, size: u8, val: u64) -> Result<Action> {36x
        Mmio::write(self.as_ref(), offset, size, val)36x
    }36x
 
    fn size(&self) -> u64 {231x
        Mmio::size(self.as_ref())231x
    }231x
}
 
impl SlotBackend for Arc<dyn Mmio> {
    fn size(&self) -> u64 {1347x
        Mmio::size(self.as_ref())1347x
    }1347x
}
 
#[macro_export]
macro_rules! impl_mmio_for_zerocopy {
    ($ty:ident) => {
        impl $crate::mem::emulated::Mmio for $ty {
            fn size(&self) -> u64 {3x
                ::core::mem::size_of::<Self>() as u643x
            }3x
 
            fn read(&self, offset: u64, size: u8) -> $crate::mem::Result<u64> {205x
                fn read_from_prefix<T: ::zerocopy::FromBytes + Into<u64>>(159x
                    bytes: &[u8],159x
                ) -> ::core::option::Option<u64> {159x
                    let (n, _) = T::read_from_prefix(bytes).ok()?;159x
                    Some(n.into())159x
                }159x
 
                let bytes = ::zerocopy::IntoBytes::as_bytes(self);205x
                let offset = offset as usize;205x
                let val = match size {205x
                    1 => bytes.get(offset).map(|b| *b as u64),46x
                    2 => bytes.get(offset..).and_then(read_from_prefix::<u16>),75x
                    4 => bytes.get(offset..).and_then(read_from_prefix::<u32>),81x
                    8 => bytes.get(offset..).and_then(read_from_prefix::<u64>),3x
                    _ => ::core::option::Option::None,
                };
 
                if let ::core::option::Option::Some(val) = val {205x
                    ::core::result::Result::Ok(val)205x
                } else {
                    ::log::error!(
                        "{}: invalid read access, offset = {offset:#x}, size = {size}.",
                        ::core::any::type_name::<Self>()
                    );
                    ::core::result::Result::Ok(0)
                }
            }205x
 
            fn write(3x
                &self,3x
                offset: u64,3x
                size: u8,3x
                val: u64,3x
            ) -> $crate::mem::Result<$crate::mem::emulated::Action> {3x
                ::log::error!(3x
                    "{}: write 0x{val:0width$x} to readonly offset 0x{offset:x}.",
                    ::core::any::type_name::<Self>(),3x
                    width = 2 * size as usize3x
                );
                Ok($crate::mem::emulated::Action::None)3x
            }3x
        }
    };
}
 
#[derive(Debug)]
pub struct MmioBus<R = Arc<dyn Mmio>>
where
    R: Debug + SlotBackend,
{
    pub(crate) inner: Addressable<R>,
}
 
impl<R> Default for MmioBus<R>
where
    R: Debug + SlotBackend + Mmio,
{
    fn default() -> Self {
        Self::new()
    }
}
 
impl<R> MmioBus<R>
where
    R: Debug + SlotBackend + Mmio,
{
    pub fn new() -> MmioBus<R> {187x
        Self {187x
            inner: Addressable::new(),187x
        }187x
    }187x
 
    pub fn is_empty(&self) -> bool {89x
        self.inner.is_empty()89x
    }89x
 
    pub fn add(&mut self, addr: u64, range: R) -> Result<()> {480x
        self.inner.add(addr, range)?;480x
        Ok(())480x
    }480x
 
    pub(super) fn remove(&mut self, addr: u64) -> Result<R> {18x
        self.inner.remove(addr)18x
    }18x
 
    pub fn read(&self, addr: u64, size: u8) -> Result<u64> {126x
        match self.inner.search(addr) {126x
            Some((start, dev)) => dev.read(addr - start, size),117x
            None => Ok(u64::MAX),9x
        }
    }126x
 
    pub fn write(&self, addr: u64, size: u8, val: u64) -> Result<Action> {45x
        match self.inner.search(addr) {45x
            Some((start, dev)) => dev.write(addr - start, size, val),42x
            None => Ok(Action::None),3x
        }
    }45x
}
 
#[cfg(test)]
#[path = "emulated_test.rs"]
mod tests;
 