rdma 0.3.0

Low-level RDMA 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

use crate::bindings as C;
use crate::ctx::Context;
use crate::error::create_resource;
use crate::pd::ProtectionDomain;
use crate::utils::usize_to_void_ptr;

use std::io;
use std::mem;
use std::ptr::NonNull;
use std::sync::Arc;

#[derive(Clone)]
pub struct SharedReceiveQueue(Arc<Owner>);

impl SharedReceiveQueue {
    pub(crate) fn ffi_ptr(&self) -> *mut C::ibv_srq {
        self.0.ffi_ptr()
    }

    #[inline]
    #[must_use]
    pub fn options() -> SharedReceiveQueueOptions {
        SharedReceiveQueueOptions::default()
    }

    /// # Panics
    /// + if `ctx` is not the same as the context of the specified protection domain in `options`.
    #[inline]
    pub fn create(ctx: &Context, mut options: SharedReceiveQueueOptions) -> io::Result<Self> {
        // SAFETY: ffi
        let owner = unsafe {
            let context = ctx.ffi_ptr();
            let attr = &mut options.attr;

            if let Some(ref pd) = options.pd {
                let pd_context = (*pd.ffi_ptr()).context;
                assert_eq!(pd_context, context, "context mismatch");
            }

            let srq = create_resource(
                || C::ibv_create_srq_ex(context, attr),
                || "failed to create shared receive queue",
            )?;

            Arc::new(Owner {
                srq,
                _ctx: ctx.clone(),
                _pd: options.pd,
            })
        };
        Ok(Self(owner))
    }
}

struct Owner {
    srq: NonNull<C::ibv_srq>,

    _ctx: Context,
    _pd: Option<ProtectionDomain>,
}

/// SAFETY: owned type
unsafe impl Send for Owner {}
/// SAFETY: owned type
unsafe impl Sync for Owner {}

impl Owner {
    fn ffi_ptr(&self) -> *mut C::ibv_srq {
        self.srq.as_ptr()
    }
}

impl Drop for Owner {
    fn drop(&mut self) {
        // SAFETY: ffi
        unsafe {
            let srq = self.ffi_ptr();
            let ret = C::ibv_destroy_srq(srq);
            assert_eq!(ret, 0);
        }
    }
}

pub struct SharedReceiveQueueOptions {
    attr: C::ibv_srq_init_attr_ex,
    pd: Option<ProtectionDomain>,
}

impl Default for SharedReceiveQueueOptions {
    #[inline]
    fn default() -> Self {
        Self {
            // SAFETY: POD ffi type
            attr: unsafe { mem::zeroed() },
            pd: None,
        }
    }
}

impl SharedReceiveQueueOptions {
    #[inline]
    pub fn protection_domain(&mut self, pd: &ProtectionDomain) -> &mut Self {
        self.attr.pd = pd.ffi_ptr();
        self.attr.comp_mask |= C::IBV_SRQ_INIT_ATTR_PD;
        self.pd = Some(pd.clone());
        self
    }

    #[inline]
    pub fn user_data(&mut self, user_data: usize) -> &mut Self {
        self.attr.srq_context = usize_to_void_ptr(user_data);
        self
    }
}