hermit-entry 0.10.9

Hermit's loading and entry API.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use core::mem;

use crate::HermitVersion;

/// Defines the hermit entry version in the note section.
///
/// This macro must be used in a module that is guaranteed to be linked.
/// See <https://github.com/rust-lang/rust/issues/99721>.
#[cfg_attr(docsrs, doc(cfg(feature = "kernel")))]
#[macro_export]
macro_rules! define_entry_version {
    () => {
        #[used]
        #[unsafe(link_section = ".note.hermit.entry-version")]
        static ENTRY_VERSION: $crate::_Note<1> = $crate::_Note::entry_version();
    };
}

/// Defines the Uhyve interface version in the note section.
///
/// This macro must be used in a module that is guaranteed to be linked.
/// See <https://github.com/rust-lang/rust/issues/99721>.
///
/// # Examples
///
/// ```
/// # mod uhyve_interface {
/// #     pub const UHYVE_INTERFACE_VERSION: u32 = 1;
/// # }
/// #
/// hermit_entry::define_uhyve_interface_version!(uhyve_interface::UHYVE_INTERFACE_VERSION);
/// ```
#[cfg_attr(docsrs, doc(cfg(feature = "kernel")))]
#[macro_export]
macro_rules! define_uhyve_interface_version {
    ($version:expr) => {
        #[used]
        #[unsafe(link_section = ".note.hermit.uhyve-interface-version")]
        static INTERFACE_VERSION: $crate::_Note<4> = $crate::_Note::uhyveif_version($version);
    };
}

#[repr(C)]
#[doc(hidden)]
pub struct _Note<const N: usize> {
    header: Nhdr32,
    name: [u8; 8],
    data: [u8; N],
}

impl _Note<1> {
    pub const fn entry_version() -> Self {
        Self {
            header: Nhdr32 {
                n_namesz: 7,
                n_descsz: 1,
                n_type: crate::NT_HERMIT_ENTRY_VERSION,
            },
            name: *b"HERMIT\0\0",
            data: [crate::HERMIT_ENTRY_VERSION],
        }
    }
}

impl _Note<4> {
    pub const fn uhyveif_version(ver: u32) -> Self {
        Self {
            header: Nhdr32 {
                n_namesz: 8,
                n_descsz: 4,
                n_type: crate::NT_UHYVE_INTERFACE_VERSION,
            },
            name: *b"UHYVEIF\0",
            data: ver.to_be_bytes(),
        }
    }
}

#[repr(C)]
struct Nhdr32 {
    n_namesz: u32,
    n_descsz: u32,
    n_type: u32,
}

/// Defines the current Hermit kernel version in the note section.
///
/// The version is saved in `.note.ABI-tag` in accordance with [LSB].
///
/// [LSB]: https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/noteabitag.html
#[cfg_attr(docsrs, doc(cfg(feature = "kernel")))]
#[macro_export]
macro_rules! define_abi_tag {
    () => {
        #[used]
        #[unsafe(link_section = ".note.ABI-tag")]
        static ABI_TAG: $crate::_AbiTag = $crate::_AbiTag::new($crate::HermitVersion {
            major: $crate::_parse_u128(::core::env!("CARGO_PKG_VERSION_MAJOR")) as u32,
            minor: $crate::_parse_u128(::core::env!("CARGO_PKG_VERSION_MINOR")) as u32,
            patch: $crate::_parse_u128(::core::env!("CARGO_PKG_VERSION_PATCH")) as u32,
        });
    };
}

#[repr(C)]
#[doc(hidden)]
pub struct _AbiTag {
    header: Nhdr32,
    name: [u8; 4],
    data: [u32; 4],
}

impl _AbiTag {
    pub const fn new(version: HermitVersion) -> Self {
        Self {
            header: Nhdr32 {
                n_namesz: mem::size_of::<[u8; 4]>() as u32,
                n_descsz: mem::size_of::<[u32; 4]>() as u32,
                n_type: crate::NT_GNU_ABI_TAG,
            },
            name: *b"GNU\0",
            data: [
                crate::ELF_NOTE_OS_HERMIT,
                version.major,
                version.minor,
                version.patch,
            ],
        }
    }
}