rrppcc 0.4.0

A high-performance userspace RDMA RPC engine.
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

//! Define types used by RPC request handlers.

use std::future::Future;
use std::pin::Pin;

use crate::msgbuf::MsgBuf;
use crate::rpc::Rpc;
use crate::session::SSlot;
use crate::type_alias::*;

/// RPC request handler function return type.
pub(crate) type ReqHandlerFuture = Pin<Box<dyn Future<Output = MsgBuf> + 'static>>;

/// RPC request handler function trait.
///
/// Every handler function take two parameters.
/// The first is a [`Pin<&Rpc>`], which refers to the [`Rpc`] instance that calls
/// this handler function due to a client RPC request.
/// The second is a  [`ReqHandle`] that contains pointers to.
/// The handler should` ` return a future that resolves to the length of the response.
/// The response should be filled in the buffer pointed by `resp_buf`.
pub(crate) type ReqHandler = Box<dyn Fn(RequestHandle) -> ReqHandlerFuture + 'static>;

/// RPC request handle exposed to request handlers.
///
/// An instance of this type passed to a request handler function only represents
/// valid state during the lifetime of the handler function call, and must be dropped
/// when/before the handler returns. Failing to do so will result in a panic.
pub struct RequestHandle {
    /// Pointer to the `Rpc` instance that calls this handler function.
    rpc: *const Rpc,

    /// Pointer to the SSlot of this request.
    sslot: *mut SSlot,
}

impl RequestHandle {
    /// Construct a request handle.
    #[inline(always)]
    pub(crate) fn new<'a>(rpc: &'a Rpc, sslot: &'a mut SSlot) -> Self {
        // Mark the SSlot as having a handle.
        debug_assert!(!sslot.has_handle);
        sslot.has_handle = true;

        Self { rpc, sslot }
    }
}

impl RequestHandle {
    /// Return the `Rpc` instance that called this handler function.
    #[inline(always)]
    pub fn rpc(&self) -> &Rpc {
        // SAFETY: the pointer is always valid.
        unsafe { &*self.rpc }
    }

    /// Return the type of this request.
    #[inline(always)]
    pub fn req_type(&self) -> ReqType {
        // SAFETY: the pointer is always valid.
        unsafe { (*self.sslot).req_type }
    }

    /// Return the request buffer.
    #[inline(always)]
    pub fn req_buf(&self) -> &MsgBuf {
        // SAFETY: the pointer is always valid.
        unsafe { (*self.sslot).req_buf() }
    }

    /// Return the prepared response buffer.
    ///
    /// This buffer can only accommodate MTU-sized data (usually 4KiB). If you
    /// need larger responses, you should use `Rpc::alloc_msgbuf()`.
    #[inline(always)]
    pub fn pre_resp_buf(&self) -> MsgBuf {
        // SAFETY: the pointer is always valid.
        unsafe { (*self.sslot).pre_resp_msgbuf.clone_borrowed() }
    }
}

impl Drop for RequestHandle {
    fn drop(&mut self) {
        // SAFETY: the pointer is always valid.
        let sslot = unsafe { &mut *self.sslot };

        // Mark the SSlot as not having a handle.
        debug_assert!(sslot.has_handle);
        sslot.has_handle = false;
    }
}