v4l2r 0.0.7

Safe and flexible abstraction over V4L2
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

use core::num::NonZeroUsize;
use std::{
    cmp::{max, min},
    ops::Deref,
    ptr::NonNull,
    slice,
};
use std::{ops::DerefMut, os::unix::io::AsFd};

use log::error;
use nix::{errno::Errno, libc::off_t, sys::mman};
use thiserror::Error;

pub struct PlaneMapping {
    // A mapping remains valid until we munmap it, that is, until the
    // PlaneMapping object is deleted. Hence the static lifetime.
    pub data: &'static mut [u8],

    start: usize,
    end: usize,
}

impl PlaneMapping {
    pub fn size(&self) -> usize {
        self.end - self.start
    }

    pub fn restrict(mut self, start: usize, end: usize) -> Self {
        self.start = max(self.start, start);
        self.end = min(self.end, end);

        self
    }
}

impl AsRef<[u8]> for PlaneMapping {
    fn as_ref(&self) -> &[u8] {
        &self.data[self.start..self.end]
    }
}

impl AsMut<[u8]> for PlaneMapping {
    fn as_mut(&mut self) -> &mut [u8] {
        &mut self.data[self.start..self.end]
    }
}

impl Deref for PlaneMapping {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.data[self.start..self.end]
    }
}

impl DerefMut for PlaneMapping {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.data[self.start..self.end]
    }
}

impl Drop for PlaneMapping {
    fn drop(&mut self) {
        // Safe because the pointer and length were constructed in mmap() and
        // are always valid.
        unsafe {
            mman::munmap(
                NonNull::new_unchecked(self.data.as_mut_ptr().cast()),
                self.data.len(),
            )
        }
        .unwrap_or_else(|e| {
            error!("Error while unmapping plane: {}", e);
        });
    }
}

#[derive(Debug, Error)]
pub enum MmapError {
    #[error("provided length was 0")]
    ZeroLength,
    #[error("ioctl error: {0}")]
    IoctlError(#[from] Errno),
}

impl From<MmapError> for Errno {
    fn from(err: MmapError) -> Self {
        match err {
            MmapError::ZeroLength => Errno::EINVAL,
            MmapError::IoctlError(e) => e,
        }
    }
}

// TODO should be unsafe because the mapping can be used after a buffer is queued?
// Or not, since this cannot cause a crash...
pub fn mmap(fd: &impl AsFd, mem_offset: u32, length: u32) -> Result<PlaneMapping, MmapError> {
    let non_zero_length = NonZeroUsize::new(length as usize).ok_or(MmapError::ZeroLength)?;
    let data = unsafe {
        mman::mmap(
            None,
            non_zero_length,
            mman::ProtFlags::PROT_READ | mman::ProtFlags::PROT_WRITE,
            mman::MapFlags::MAP_SHARED,
            fd,
            mem_offset as off_t,
        )
    }?;

    Ok(PlaneMapping {
        // Safe because we know the pointer is valid and has enough data mapped
        // to cover the length.
        data: unsafe { slice::from_raw_parts_mut(data.as_ptr().cast(), length as usize) },
        start: 0,
        end: length as usize,
    })
}