alioth/src/virtio/dev/entropy.rs - PR #438

entropy.rs85.06%

// 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::fs::{File, OpenOptions};
use std::os::unix::prelude::OpenOptionsExt;
use std::path::Path;
use std::sync::Arc;
use std::sync::mpsc::Receiver;
use std::thread::JoinHandle;
 
use libc::O_NONBLOCK;
use mio::Registry;
use mio::event::Event;
use serde::Deserialize;
use serde_aco::Help;
use snafu::ResultExt;
 
use crate::hv::IoeventFd;
use crate::mem::emulated::{Action, Mmio};
use crate::mem::mapped::RamBus;
use crate::sync::notifier::Notifier;
use crate::virtio::dev::{DevParam, DeviceId, Virtio, WakeEvent};
use crate::virtio::queue::{QueueReg, VirtQueue, copy_from_reader};
use crate::virtio::worker::mio::{ActiveMio, Mio, VirtioMio};
use crate::virtio::{FEATURE_BUILT_IN, IrqSender, Result, error};
use crate::{bitflags, mem};
 
#[derive(Debug, Clone)]
pub struct EntropyConfig;
 
impl Mmio for EntropyConfig {
    fn size(&self) -> u64 {3x
        03x
    }3x
 
    fn read(&self, _offset: u64, _size: u8) -> mem::Result<u64> {3x
        Ok(0)3x
    }3x
 
    fn write(&self, _offset: u64, _size: u8, _val: u64) -> mem::Result<Action> {3x
        Ok(Action::None)3x
    }3x
}
 
bitflags! {
    pub struct EntropyFeature(u128) { }
}
 
#[derive(Debug)]
pub struct Entropy {
    name: Arc<str>,
    source: File,
    config: Arc<EntropyConfig>,
}
 
impl Entropy {
    pub fn new(param: EntropyParam, name: impl Into<Arc<str>>) -> Result<Self> {3x
        let name = name.into();3x
        let mut options = OpenOptions::new();3x
        options.custom_flags(O_NONBLOCK).read(true);3x
        let path = param.source.as_deref().unwrap_or(Path::new("/dev/urandom"));3x
        let file = options.open(path).context(error::AccessFile { path })?;3x
        Ok(Entropy {3x
            name,3x
            source: file,3x
            config: Arc::new(EntropyConfig),3x
        })3x
    }3x
}
 
impl Virtio for Entropy {
    type Config = EntropyConfig;
    type Feature = EntropyFeature;
 
    fn id(&self) -> DeviceId {3x
        DeviceId::ENTROPY3x
    }3x
 
    fn name(&self) -> &str {12x
        &self.name12x
    }12x
 
    fn spawn_worker<S, E>(3x
        self,3x
        event_rx: Receiver<WakeEvent<S, E>>,3x
        memory: Arc<RamBus>,3x
        queue_regs: Arc<[QueueReg]>,3x
    ) -> Result<(JoinHandle<()>, Arc<Notifier>)>3x
    where3x
        S: IrqSender,3x
        E: IoeventFd,3x
    {
        Mio::spawn_worker(self, event_rx, memory, queue_regs)3x
    }3x
 
    fn num_queues(&self) -> u16 {3x
        13x
    }3x
 
    fn config(&self) -> Arc<EntropyConfig> {3x
        self.config.clone()3x
    }3x
 
    fn feature(&self) -> u128 {3x
        FEATURE_BUILT_IN3x
    }3x
}
 
impl VirtioMio for Entropy {
    fn activate<'m, Q, S, E>(3x
        &mut self,3x
        _feature: u128,3x
        _active_mio: &mut ActiveMio<'_, '_, 'm, Q, S, E>,3x
    ) -> Result<()>3x
    where3x
        Q: VirtQueue<'m>,3x
        S: IrqSender,3x
        E: IoeventFd,3x
    {
        Ok(())3x
    }3x
 
    fn handle_queue<'m, Q, S, E>(9x
        &mut self,9x
        index: u16,9x
        active_mio: &mut ActiveMio<'_, '_, 'm, Q, S, E>,9x
    ) -> Result<()>9x
    where9x
        Q: VirtQueue<'m>,9x
        S: IrqSender,9x
        E: IoeventFd,9x
    {
        let Some(Some(queue)) = active_mio.queues.get_mut(index as usize) else {9x
            log::error!("{}: invalid queue index {index}", self.name);
            return Ok(());
        };
        queue.handle_desc(index, active_mio.irq_sender, copy_from_reader(&self.source))9x
    }9x
 
    fn handle_event<'a, 'm, Q, S, E>(
        &mut self,
        _event: &Event,
        _active_mio: &mut ActiveMio<'_, '_, 'm, Q, S, E>,
    ) -> Result<()>
    where
        Q: VirtQueue<'m>,
        S: IrqSender,
        E: IoeventFd,
    {
        Ok(())
    }
 
    fn reset(&mut self, _registry: &Registry) {}3x
}
 
#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Help)]
pub struct EntropyParam {
    /// Source of entropy [default: /dev/urandom]
    pub source: Option<Box<Path>>,
}
 
impl DevParam for EntropyParam {
    type Device = Entropy;
 
    fn build(self, name: impl Into<Arc<str>>) -> Result<Self::Device> {3x
        Entropy::new(self, name)3x
    }3x
}
 
#[cfg(test)]
#[path = "entropy_test.rs"]
mod tests;
 