rrddmma 0.7.3

#![macro_use]

use libc::*;

use super::*;

#[repr(C)]
#[derive(Clone, Copy)]
pub union ibv_gid {
    pub raw: [u8; 16],
    pub global: ibv_gid_global_t,
}

#[repr(C)]
pub struct ibv_async_event {
    pub element: ibv_async_event_element_union_t,
    pub event_type: ibv_event_type,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct ibv_global_route {
    pub dgid: ibv_gid,
    pub flow_label: u32,
    pub sgid_index: u8,
    pub hop_limit: u8,
    pub traffic_class: u8,
}

// ibv_send_wr related union and struct types
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct rdma_t {
    pub remote_addr: u64,
    pub rkey: u32,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct atomic_t {
    pub remote_addr: u64,
    pub compare_add: u64,
    pub swap: u64,
    pub rkey: u32,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct ud_t {
    pub ah: *mut ibv_ah,
    pub remote_qpn: u32,
    pub remote_qkey: u32,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub union wr_t {
    pub rdma: rdma_t,
    pub atomic: atomic_t,
    pub ud: ud_t,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct xrc_t {
    pub remote_srqn: u32,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub union qp_type_t {
    pub xrc: xrc_t,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub union qp_type_xrc_remote_srq_num_union_t {
    pub qp_type: qp_type_t,
    pub xrc_remote_srq_num: u32,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct bind_mw_t {
    pub mw: *mut ibv_mw,
    pub rkey: u32,
    pub bind_info: ibv_mw_bind_info,
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct tso_t {
    pub hdr: *mut c_void,
    pub hdr_sz: u16,
    pub mss: u16,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub union mw_rkey_bind_info_union_t {
    pub mw: *mut ibv_mw,
    pub rkey: u32,
    pub bind_info: ibv_mw_bind_info,
}

// ibv_flow_spec related union and struct types
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct hdr_t {
    pub type_: ibv_flow_spec_type::Type,
    pub size: u16,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub union ibv_flow_spec_union_t {
    pub hdr: hdr_t,
    pub eth: ibv_flow_spec_eth,
    pub ipv4: ibv_flow_spec_ipv4,
    pub tcp_udp: ibv_flow_spec_tcp_udp,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct ibv_ah_attr {
    pub grh: ibv_global_route,
    pub dlid: u16,
    pub sl: u8,
    pub src_path_bits: u8,
    pub static_rate: u8,
    pub is_global: u8,
    pub port_num: u8,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct ibv_flow_spec {
    pub ibv_flow_spec_union: ibv_flow_spec_union_t,
}

pub const IBV_LINK_LAYER_UNSPECIFIED: ::std::os::raw::c_int = 0;
pub const IBV_LINK_LAYER_INFINIBAND: ::std::os::raw::c_int = 1;
pub const IBV_LINK_LAYER_ETHERNET: ::std::os::raw::c_int = 2;
pub const IBV_EXP_LINK_LAYER_START: ::std::os::raw::c_int = 32;
pub const IBV_EXP_LINK_LAYER_SCIF: ::std::os::raw::c_int = IBV_EXP_LINK_LAYER_START;

macro_rules! container_of {
    ($ptr:expr, $container:path, $field:ident) => {{
        ($ptr as *const _ as *const u8 as *mut u8).sub(memoffset::offset_of!($container, $field))
            as *mut $container
    }};
}

macro_rules! verbs_get_ctx_op {
    ($ctx:expr, $op:ident) => {{
        let vctx = verbs_get_ctx($ctx);
        if vctx.is_null()
            || (*vctx).sz
                < ::std::mem::size_of_val(&*vctx) - memoffset::offset_of!(verbs_context, $op)
            || (*vctx).$op.is_none()
        {
            std::ptr::null_mut()
        } else {
            vctx
        }
    }};
}

/// Close an extended connection domain.
#[inline]
pub unsafe fn ibv_close_xrcd(xrcd: *mut ibv_xrcd) -> ::std::os::raw::c_int {
    let vctx = verbs_get_ctx((*xrcd).context);
    (*vctx).close_xrcd.unwrap()(xrcd)
}

/// Free a memory window.
#[inline]
pub unsafe fn ibv_dealloc_mw(mw: *mut ibv_mw) -> ::std::os::raw::c_int {
    (*(*mw).context).ops.dealloc_mw.unwrap()(mw)
}

/// Increment the 8 lsb in the given rkey.
#[inline]
pub fn ibv_inc_rkey(rkey: u32) -> u32 {
    const MASK: u32 = 0x000000FF;
    let newtag = ((rkey + 1) & MASK) as u8;

    (rkey & !MASK) | newtag as u32
}

/// Bind a memory window to a region.
#[inline]
pub unsafe fn ibv_bind_mw(
    qp: *mut ibv_qp,
    mw: *mut ibv_mw,
    mw_bind: *mut ibv_mw_bind,
) -> ::std::os::raw::c_int {
    if (*mw).type_ != ibv_mw_type::IBV_MW_TYPE_1 {
        EINVAL
    } else {
        (*(*mw).context).ops.bind_mw.unwrap()(qp, mw, mw_bind)
    }
}

#[cfg(mlnx4)]
const ENOSYS_OR_EOPNOTSUPP: ::std::os::raw::c_int = ENOSYS;

#[cfg(mlnx5)]
const ENOSYS_OR_EOPNOTSUPP: ::std::os::raw::c_int = EOPNOTSUPP;

/// Open an extended connection domain.
#[inline]
pub unsafe fn ibv_open_xrcd(
    context: *mut ibv_context,
    xrcd_init_attr: *mut ibv_xrcd_init_attr,
) -> *mut ibv_xrcd {
    let vctx = verbs_get_ctx_op!(context, open_xrcd);
    if vctx.is_null() {
        *__errno_location() = ENOSYS_OR_EOPNOTSUPP;
        std::ptr::null_mut()
    } else {
        (*vctx).open_xrcd.unwrap()(context, xrcd_init_attr)
    }
}

/// Allocate a memory window.
#[inline]
pub unsafe fn ibv_alloc_mw(pd: *mut ibv_pd, type_: ibv_mw_type::Type) -> *mut ibv_mw {
    if let Some(alloc_mw) = (*(*pd).context).ops.alloc_mw {
        alloc_mw(pd, type_)
    } else {
        *__errno_location() = ENOSYS_OR_EOPNOTSUPP;
        std::ptr::null_mut()
    }
}

/// Get SRQ number.
#[inline]
pub unsafe fn ibv_get_srq_num(srq: *mut ibv_srq, srq_num: *mut u32) -> ::std::os::raw::c_int {
    let vctx = verbs_get_ctx_op!((*srq).context, get_srq_num);
    if vctx.is_null() {
        ENOSYS_OR_EOPNOTSUPP
    } else {
        (*vctx).get_srq_num.unwrap()(srq, srq_num)
    }
}

#[inline]
pub unsafe fn ibv_create_qp_ex(
    context: *mut ibv_context,
    qp_init_attr_ex: *mut ibv_qp_init_attr_ex,
) -> *mut ibv_qp {
    let mask = (*qp_init_attr_ex).comp_mask;

    if mask == ibv_qp_init_attr_mask::IBV_QP_INIT_ATTR_PD.0 {
        ibv_create_qp(
            (*qp_init_attr_ex).pd,
            qp_init_attr_ex as *mut ibv_qp_init_attr,
        )
    } else {
        let vctx = verbs_get_ctx_op!(context, create_qp_ex);
        if vctx.is_null() {
            *__errno_location() = ENOSYS_OR_EOPNOTSUPP;
            std::ptr::null_mut()
        } else {
            (*vctx).create_qp_ex.unwrap()(context, qp_init_attr_ex)
        }
    }
}

/// Post a list of work requests to the specified SRQ.
///
/// # Arguments
///
/// - `srq`: the SRQ to post the work request on.
/// - `recv_wr`: a A list of work requests to post on the receive queue.
/// - `bad_recv_wr`: on an immediate failure, this parameter will reference
///                  the work request that failed to be posted on the QP.
#[inline]
pub unsafe fn ibv_post_srq_recv(
    srq: *mut ibv_srq,
    recv_wr: *mut ibv_recv_wr,
    bad_recv_wr: *mut *mut ibv_recv_wr,
) -> ::std::os::raw::c_int {
    (*(*srq).context).ops.post_srq_recv.unwrap()(srq, recv_wr, bad_recv_wr)
}

/// Poll a CQ for work completions.
///
/// Poll a CQ for (possibly multiple) completions. If the return value
/// is < 0, an error occurred. If the return value is >= 0, it is the
/// number of completions returned. If the return value is
/// non-negative and strictly less than num_entries, then the CQ was
/// emptied.
///
/// # Arguments
///
/// - `cq`: the CQ being polled.
/// - `num_entries`: maximum number of completions to return.
/// - `wc`: array of at least @num_entries of &struct ibv_wc where completions
///   will be returned.
#[inline]
pub unsafe fn ibv_poll_cq(
    cq: *mut ibv_cq,
    num_entries: ::std::os::raw::c_int,
    wc: *mut ibv_wc,
) -> ::std::os::raw::c_int {
    (*(*cq).context).ops.poll_cq.unwrap()(cq, num_entries, wc)
}

/// Post a list of work requests to a send queue.
///
/// If IBV_SEND_INLINE flag is set, the data buffers can be reused
/// immediately after the call returns.
#[inline]
pub unsafe fn ibv_post_send(
    qp: *mut ibv_qp,
    wr: *mut ibv_send_wr,
    bad_wr: *mut *mut ibv_send_wr,
) -> ::std::os::raw::c_int {
    (*(*qp).context).ops.post_send.unwrap()(qp, wr, bad_wr)
}

/// Post a list of work requests to a receive queue.
#[inline]
pub unsafe fn ibv_post_recv(
    qp: *mut ibv_qp,
    wr: *mut ibv_recv_wr,
    bad_wr: *mut *mut ibv_recv_wr,
) -> ::std::os::raw::c_int {
    (*(*qp).context).ops.post_recv.unwrap()(qp, wr, bad_wr)
}