krata-daemon 0.0.21

Daemon for the krata isolation engine
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::{collections::HashMap, sync::Arc};

use anyhow::{anyhow, Result};
use log::warn;
use tokio::sync::RwLock;
use uuid::Uuid;

use crate::config::{DaemonConfig, DaemonPciDeviceConfig};

#[derive(Clone)]
pub struct DaemonDeviceState {
    pub pci: Option<DaemonPciDeviceConfig>,
    pub owner: Option<Uuid>,
}

#[derive(Clone)]
pub struct DaemonDeviceManager {
    config: Arc<DaemonConfig>,
    devices: Arc<RwLock<HashMap<String, DaemonDeviceState>>>,
}

impl DaemonDeviceManager {
    pub fn new(config: Arc<DaemonConfig>) -> Self {
        Self {
            config,
            devices: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    pub async fn claim(&self, device: &str, uuid: Uuid) -> Result<DaemonDeviceState> {
        let mut devices = self.devices.write().await;
        let Some(state) = devices.get_mut(device) else {
            return Err(anyhow!(
                "unable to claim unknown device '{}' for zone {}",
                device,
                uuid
            ));
        };

        if let Some(owner) = state.owner {
            return Err(anyhow!(
                "unable to claim device '{}' for zone {}: already claimed by {}",
                device,
                uuid,
                owner
            ));
        }

        state.owner = Some(uuid);
        Ok(state.clone())
    }

    pub async fn release_all(&self, uuid: Uuid) -> Result<()> {
        let mut devices = self.devices.write().await;
        for state in (*devices).values_mut() {
            if state.owner == Some(uuid) {
                state.owner = None;
            }
        }
        Ok(())
    }

    pub async fn release(&self, device: &str, uuid: Uuid) -> Result<()> {
        let mut devices = self.devices.write().await;
        let Some(state) = devices.get_mut(device) else {
            return Ok(());
        };

        if let Some(owner) = state.owner {
            if owner != uuid {
                return Ok(());
            }
        }

        state.owner = None;
        Ok(())
    }

    pub async fn update_claims(&self, claims: HashMap<String, Uuid>) -> Result<()> {
        let mut devices = self.devices.write().await;
        devices.clear();
        for (name, pci) in &self.config.pci.devices {
            let owner = claims.get(name).cloned();
            devices.insert(
                name.clone(),
                DaemonDeviceState {
                    owner,
                    pci: Some(pci.clone()),
                },
            );
        }

        for (name, uuid) in &claims {
            if !devices.contains_key(name) {
                warn!("unknown device '{}' assigned to zone {}", name, uuid);
            }
        }

        Ok(())
    }

    pub async fn copy(&self) -> Result<HashMap<String, DaemonDeviceState>> {
        let devices = self.devices.read().await;
        Ok(devices.clone())
    }
}