rrddmma 0.7.3

A Rust library for RDMA.
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

use super::*;
use std::ops::{Bound, Range, RangeBounds};

/// Clip a range to the given upper-bound.
#[inline]
fn clip_range(r: impl RangeBounds<usize>, upper: usize) -> Range<usize> {
    let start = match r.start_bound() {
        Bound::Included(&s) => s,
        Bound::Excluded(&s) => s + 1,
        Bound::Unbounded => 0,
    };
    let end = match r.end_bound() {
        Bound::Included(&e) => e + 1,
        Bound::Excluded(&e) => e,
        Bound::Unbounded => upper,
    };

    start..end
}

/// A slicable memory region.
///
/// The trait is sealed and cannot be implemented outside of this crate.
///
/// # Safety
///
/// - `Self::addr()` must return the correct starting address of the memory region.
/// - `Self::len()` must return the correct length of the memory region.
///
/// Safe methods of this trait rely on these contracts to be upheld.
#[allow(private_bounds)]
#[allow(clippy::len_without_is_empty)]
pub unsafe trait Slicing<'s>: private::Sealed {
    type Output: 's;

    /// Get the starting address of the memory region.
    fn addr(&'s self) -> *mut u8;

    /// Get the length of the memory region.
    fn len(&'s self) -> usize;

    /// Get a slice that represents the entire memory region.
    fn as_slice(&'s self) -> Self::Output {
        // SAFETY: bounds guaranteed to be valid.
        unsafe { self.slice_unchecked(0, self.len()) }
    }

    /// Get a slice from an offset and a length.
    /// Return `None` if the range is out of bounds.
    fn slice(&'s self, offset: usize, len: usize) -> Option<Self::Output> {
        // SAFETY: bounds checked.
        if offset < self.len() && len <= self.len() - offset {
            Some(unsafe { self.slice_unchecked(offset, len) })
        } else {
            None
        }
    }

    /// Get a slice from a range.
    /// Return `None` if the range is out of bounds.
    fn slice_by_range(&'s self, range: impl RangeBounds<usize>) -> Option<Self::Output> {
        let r = clip_range(range, self.len());
        self.slice(r.start, r.len())
    }

    /// Get a slice from a pointer and a length.
    /// Return `None` if the range is out of bounds.
    fn slice_by_ptr(&'s self, pointer: *mut u8, len: usize) -> Option<Self::Output> {
        if pointer >= self.addr() {
            self.slice((pointer as usize) - (self.addr() as usize), len)
        } else {
            None
        }
    }

    /// Get a slice from an offset and a length.
    ///
    /// # Safety
    ///
    /// - The specified range must be within the bounds of the memory region.
    unsafe fn slice_unchecked(&'s self, offset: usize, len: usize) -> Self::Output;

    /// Get a slice from a range.
    ///
    /// # Safety
    ///
    /// - The specified range must be within the bounds of the memory region.
    unsafe fn slice_by_range_unchecked(&'s self, range: impl RangeBounds<usize>) -> Self::Output {
        let r = clip_range(range, self.len());
        self.slice_unchecked(r.start, r.len())
    }

    /// Get a slice from a pointer and a length.
    ///
    /// # Safety
    ///
    /// - The specified range must be within the bounds of the memory region.
    unsafe fn slice_by_ptr_unchecked(&'s self, pointer: *mut u8, len: usize) -> Self::Output {
        self.slice_unchecked((pointer as usize) - (self.addr() as usize), len)
    }
}

mod private {
    pub trait Sealed {}
}

impl private::Sealed for Mr {}
impl private::Sealed for MrSlice<'_> {}
impl private::Sealed for MrRemote {}
impl private::Sealed for crate::wrap::RegisteredMem {}