rtipc 0.5.1

Real-Time IPC, based on a zero-copy, wait-free circular message queue implementation
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

use std::mem::size_of;

use crate::Index;
use crate::error::*;
use crate::max_cacheline_size;

const RTIC_MAGIC: u16 = 0x1f0c;
const RTIC_VERSION: u16 = 1;

#[repr(C)]
struct Header {
    magic: u16,
    version: u16,
    cacheline_size: u16,
    atomic_size: u16,
}

pub const HEADER_SIZE: usize = size_of::<Header>();

pub(crate) fn verify_header(buf: &[u8]) -> Result<(), HeaderError> {
    if buf.len() < size_of::<Header>() {
        return Err(HeaderError::SizeExceedsRequest);
    }

    let cacheline_size: u16 = max_cacheline_size().try_into().unwrap();
    let atomic_size: u16 = std::mem::size_of::<Index>().try_into().unwrap();

    let ptr: *const Header = buf.as_ptr() as *const Header;

    let header = unsafe { ptr.read_unaligned() };

    if header.magic != RTIC_MAGIC {
        return Err(HeaderError::MagicMismatch);
    }

    if header.version != RTIC_VERSION {
        return Err(HeaderError::VersionMismatch);
    }

    if header.cacheline_size != cacheline_size {
        return Err(HeaderError::CachelineSizeMismatch);
    }

    if header.atomic_size != atomic_size {
        return Err(HeaderError::AtomicSizeMismatch);
    }

    Ok(())
}

pub(crate) fn write_header(buf: &mut [u8]) {
    if buf.len() < size_of::<Header>() {
        return;
    }

    let cacheline_size: u16 = max_cacheline_size().try_into().unwrap();
    let atomic_size: u16 = std::mem::size_of::<Index>().try_into().unwrap();

    let header = Header {
        magic: RTIC_MAGIC,
        version: RTIC_VERSION,
        cacheline_size,
        atomic_size,
    };

    let ptr: *mut Header = buf.as_ptr() as *mut Header;

    unsafe {
        std::ptr::write(ptr, header);
    };
}