a653rs-linux-core 0.2.2

Core Library for a653rs-linux hypervisor and partition library
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

//! Implementation for shared memory
use std::marker::PhantomData;
use std::mem::size_of;

use anyhow::anyhow;
use memmap2::{Mmap, MmapMut};

use crate::error::{ResultExt, SystemError, TypedError, TypedResult};

#[derive(Debug)]
/// Internal data type for a mutable typed memory map
pub struct TypedMmapMut<'a, T: Send + Sized> {
    mmap: MmapMut,
    _p: PhantomData<&'a T>,
}

impl<'a, T: Send + Sized> TypedMmapMut<'a, T> {
    /// Returns the length of the memory map
    pub fn len(&self) -> usize {
        self.mmap.len()
    }

    /// Checks if the memory map is empty
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl<'a, T: Send + Sized> AsRef<T> for TypedMmapMut<'a, T> {
    fn as_ref(&self) -> &T {
        unsafe { (self.mmap.as_ptr() as *const T).as_ref() }.unwrap()
    }
}

impl<'a, T: Send + Sized> AsMut<T> for TypedMmapMut<'a, T> {
    fn as_mut(&mut self) -> &mut T {
        unsafe { (self.mmap.as_mut_ptr() as *mut T).as_mut() }.unwrap()
    }
}

impl<'a, T: Send + Sized> TryFrom<MmapMut> for TypedMmapMut<'a, T> {
    type Error = TypedError;

    fn try_from(mmap: MmapMut) -> TypedResult<Self> {
        let t_size = size_of::<T>();
        let is_size = mmap.len();

        if is_size != t_size {
            return Err(anyhow!("Size mismatch! Expected: {t_size}, Is: {is_size}"))
                .typ(SystemError::Panic);
        }

        Ok(Self {
            mmap,
            _p: PhantomData,
        })
    }
}

#[derive(Debug)]
/// Internal data type for a mutable typed memory map
pub struct TypedMmap<'a, T: Send + Sized> {
    mmap: Mmap,
    _p: PhantomData<&'a T>,
}

impl<'a, T: Send + Sized> TypedMmap<'a, T> {
    /// Returns the length of the memory map
    pub fn len(&self) -> usize {
        self.mmap.len()
    }

    /// Checks if the memory map is empty
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl<'a, T: Send + Sized> AsRef<T> for TypedMmap<'a, T> {
    fn as_ref(&self) -> &T {
        unsafe { (self.mmap.as_ptr() as *const T).as_ref() }.unwrap()
    }
}

impl<'a, T: Send + Sized> TryFrom<Mmap> for TypedMmap<'a, T> {
    type Error = TypedError;

    fn try_from(mmap: Mmap) -> TypedResult<Self> {
        let t_size = size_of::<T>();
        let is_size = mmap.len();

        if is_size != t_size {
            return Err(anyhow!("Size mismatch! Expected: {t_size}, Is: {is_size}"))
                .typ(SystemError::Panic);
        }

        Ok(Self {
            mmap,
            _p: PhantomData,
        })
    }
}