rshm 0.1.0

A library to use Linux's shm shared memory facilities in Rust
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

use std::{
    io::{Read, Write},
    mem::size_of,
};

use rshm::shm::{OwnedShmMap, ShmMap};

/// An ShmReader reads bytes from a shared memory buffer.
/// There is no notification or wake-up mechanism built-in. This would have to be built
/// separately. See the [LogConsumer] and [LogProducer] examples for a possible implementation.
pub struct ShmReader {
    _shm: ShmMap,
    written_bytes_ptr: *const u8,
    last_read_ptr: *const u8,
    read: usize,
}

impl ShmReader {
    pub fn new(shm: ShmMap) -> Self {
        // We keep the number of written bytes of the beginning
        let written_bytes_ptr = shm.head();
        let last_read_ptr = unsafe { written_bytes_ptr.add(1) };
        Self {
            _shm: shm,
            written_bytes_ptr: written_bytes_ptr,
            last_read_ptr: last_read_ptr,
            read: 0,
        }
    }
}

impl Read for ShmReader {
    fn read(&mut self, out: &mut [u8]) -> std::result::Result<usize, std::io::Error> {
        let readable_size = out
            .len()
            .min(unsafe { *self.written_bytes_ptr as usize } - self.read);
        if readable_size > 0 {
            unsafe {
                self.last_read_ptr.copy_to(out.as_mut_ptr(), readable_size);
                self.last_read_ptr = self.last_read_ptr.add(readable_size);
            }
            self.read = self.read + readable_size;
            Ok(readable_size)
        } else {
            Ok(0)
        }
    }
}

pub struct ShmWriter {
    _shm: OwnedShmMap,
    written_bytes_ptr: *mut u8,
    end_ptr: *mut u8,
    available: usize,
}

impl ShmWriter {
    pub fn new(shm: OwnedShmMap) -> Self {
        let available = shm.definition.size - size_of::<u8>();

        // We keep the number of written bytes of the beginning
        let written_bytes_ptr = shm.head() as *mut u8;
        let end_ptr = unsafe { written_bytes_ptr.add(1) } as *mut u8;
        unsafe { *written_bytes_ptr = 0 };
        Self {
            _shm: shm,
            written_bytes_ptr,
            end_ptr,
            available,
        }
    }
}

impl Write for ShmWriter {
    fn write(&mut self, value: &[u8]) -> std::result::Result<usize, std::io::Error> {
        let writable_size = self.available.min(value.len());
        if writable_size > 0 {
            unsafe {
                self.end_ptr.copy_from(value.as_ptr(), writable_size);
                self.end_ptr = self.end_ptr.add(writable_size);
                *self.written_bytes_ptr += writable_size as u8;
            }
            self.available = self.available - writable_size;
            Ok(writable_size)
        } else {
            Ok(0)
        }
    }

    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::io::{Read, Write};

    use crate::{ShmReader, ShmWriter};
    use rshm::shm::ShmDefinition;

    #[test]
    fn reader_reads_what_writer_wrote() {
        let writer_definition = ShmDefinition {
            path: "test_writer".to_string(),
            size: 10,
        };
        let writer_shm = writer_definition.create().unwrap();
        let mut writer = ShmWriter::new(writer_shm);

        writer.write("test1".as_bytes()).unwrap();
        writer.flush().unwrap();

        let reader_definition = ShmDefinition {
            path: "test_writer".to_string(),
            size: 10,
        };
        let reader_shm = reader_definition.open().unwrap();
        let mut reader = ShmReader::new(reader_shm);
        let mut reader_buffer = vec![0 as u8; 1024];
        let count = reader.read(&mut reader_buffer).unwrap();

        assert_eq!(
            format!("{}", std::str::from_utf8(&reader_buffer[0..count]).unwrap()),
            "test1"
        )
    }
}