libfab_internal.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2021 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_NET_LIBFAB_LIBFAB_INTERNAL_H__
#define __MOTR_NET_LIBFAB_LIBFAB_INTERNAL_H__

#ifdef ENABLE_LIBFAB

#include <netinet/in.h>                  /* INET_ADDRSTRLEN */

#include "rdma/fabric.h"
#include "rdma/fi_cm.h"
#include "rdma/fi_domain.h"
#include "rdma/fi_eq.h"
#include "rdma/fi_endpoint.h"
#include "rdma/fi_rma.h"

extern struct m0_net_xprt m0_net_libfab_xprt;

#define LIBFAB_VERSION FI_VERSION(1,11)

#define LIBFAB_ADDR_LEN_MAX     INET6_ADDRSTRLEN
#define LIBFAB_PORT_LEN_MAX     6

enum m0_fab__libfab_params {
        FAB_MR_ACCESS                  = (FI_READ | FI_WRITE | FI_RECV |
                                          FI_SEND | FI_REMOTE_READ |
                                          FI_REMOTE_WRITE),
        FAB_MR_OFFSET                  = 0,
        FAB_MR_FLAG                    = 0,
        FAB_MR_KEY                     = 0xABCD,
        FAB_VERBS_IOV_MAX              = 16,
        FAB_VERBS_MAX_BULK_SEG_SIZE    = 131072,
        FAB_VERBS_MAX_QUEUE_SIZE       = 224,

        FAB_TCP_SOCK_IOV_MAX           = 256,
        FAB_TCP_SOCK_MAX_BULK_SEG_SIZE = 4096,
        FAB_TCP_SOCK_MAX_QUEUE_SIZE    = 1024,

        FAB_MAX_RPC_SEG_SIZE           = (1 << 20),
        FAB_MAX_RPC_SEG_NR             = 1,
        FAB_MAX_RPC_RECV_MSG_NR        = 1,
        FAB_DUMMY_DATA                 = 0xFABC0DE,
        FAB_MAX_COMP_READ              = 256,
        FAB_WAIT_FD_TMOUT              = 1000,
        FAB_MAX_AEP_EQ_EV              = 8,
        FAB_MAX_PEP_EQ_EV              = 256,
        FAB_MAX_TX_CQ_EV               = 1024,
        FAB_MAX_RX_CQ_EV               = 256,
        FAB_MAX_SRX_SIZE               = 4096,
        FAB_NUM_BUCKETS_PER_QTYPE      = 128,
        FAB_BUF_TMOUT_CHK_INTERVAL     = 1,
        FAB_CONNECTING_TMOUT           = 5,
        FAB_TM_FID_MALLOC_STEP         = 1024
};

enum m0_fab__prov_type {
        FAB_FABRIC_PROV_VERBS,
        FAB_FABRIC_PROV_TCP,
        FAB_FABRIC_PROV_SOCK,
        /* Add all supported fabric providers above this line */
        FAB_FABRIC_PROV_MAX
};

enum m0_fab__conn_status {
        FAB_NOT_CONNECTED,
        FAB_CONNECTING,
        FAB_CONNECTED
};

enum m0_fab__tm_state {
        FAB_TM_INIT,
        FAB_TM_STARTED,
        FAB_TM_SHUTDOWN
};

enum m0_fab__buf_state {
        FAB_BUF_INITIALIZED,
        FAB_BUF_REGISTERED,
        FAB_BUF_QUEUED,
        FAB_BUF_CANCELED,
        FAB_BUF_TIMEDOUT,
        FAB_BUF_DEREGISTERED
};

enum m0_fab__event_type {
        FAB_COMMON_Q_EVENT,
        FAB_PRIVATE_Q_EVENT
};

enum m0_fab__connlink_status {
        FAB_CONNLINK_DOWN              = 0x00,
        FAB_CONNLINK_TXEP_RDY          = 0x01,
        FAB_CONNLINK_RXEP_RDY          = 0x02,
        FAB_CONNLINK_RDY_TO_SEND       = 0x03,
        FAB_CONNLINK_PENDING_SEND_DONE = 0x07
};

enum m0_fab__ep_iface {
        FAB_LO,
        FAB_TCP,
        FAB_O2IB
};

union m0_fab__token
{
        uint32_t t_val;
        struct {
                /* m0_log2(roundup_power2(M0_NET_QT_NR+1)) */
                uint32_t tf_queue_id  : 4;
                /* m0_log2(LIBFAB_AL_NUM_HASH_Q_PER_QUEUE) */
                uint32_t tf_queue_num : 8;
                /* 32 - m0_log2(LIBFAB_AL_NUM_HASH_Q_PER_QUEUE) - m0_log2(roundup_power2(M0_NET_QT_NR+1)) */
                uint32_t tf_tag       : 20;
        } t_Fields;
};

struct m0_fab__ev_ctx {
        /* Type of event (common queue/ private queue). */
        enum m0_fab__event_type  evctx_type;

        /* Endpoint context associated for event. */
        void                    *evctx_ep;

        /* Debug data. */
        char                    *evctx_dbg;

        /* Position in array of fids. */
        uint32_t                 evctx_pos;
};

struct m0_fab__bufht {
        uint64_t         bht_magic;

        struct m0_htable bht_hash;
};

struct m0_fab__ndom {

        struct m0_net_domain *fnd_ndom;

        struct m0_mutex       fnd_lock;

        struct m0_tl          fnd_fabrics;

        char                  fnd_loc_ip[INET_ADDRSTRLEN];

        uint32_t              fnd_seg_nr;

        uint32_t              fnd_seg_size;
};

struct m0_fab__fab {
        uint64_t               fab_magic;

        struct fi_info        *fab_fi;
        
        struct fid_fabric     *fab_fab;

        struct fid_domain     *fab_dom;

        struct m0_tlink        fab_link;

        enum m0_fab__prov_type fab_prov;

        uint32_t               fab_max_iov;
};

struct m0_fab__pep_res{
        struct fid_eq         *fpr_eq;
        
        struct m0_fab__ev_ctx  fpr_ctx;
};

struct m0_fab__tx_res{
        /* Event queue for transmit endpoint */
        struct fid_eq         *ftr_eq;
        
        struct m0_fab__ev_ctx  ftr_ctx;
};

struct m0_fab__rx_res{
        struct fid_eq         *frr_eq;

        struct fid_cq         *frr_cq;

        struct m0_fab__ev_ctx  frr_cq_ctx;

        struct m0_fab__ev_ctx  frr_eq_ctx;
};

struct m0_fab__active_ep {
        struct fid_ep            *aep_txep;

        struct fid_ep            *aep_rxep;

        struct m0_fab__tx_res     aep_tx_res;

        struct m0_fab__rx_res     aep_rx_res;

        enum m0_fab__conn_status  aep_tx_state;

        enum m0_fab__conn_status  aep_rx_state;

        volatile uint32_t         aep_bulk_cnt;

        bool                      aep_txq_full;

        m0_time_t                 aep_connecting_tmout;
};

struct m0_fab__passive_ep {
        struct fid_pep           *pep_pep;
        
        struct m0_fab__active_ep *pep_aep;
        
        struct m0_fab__pep_res    pep_res;
};

struct m0_fab__ep {
        struct m0_net_end_point    fep_nep;
        
        struct m0_net_ip_addr      fep_name;

        uint64_t                   fep_name_n;
        
        struct m0_fab__active_ep  *fep_aep;

        struct m0_fab__passive_ep *fep_listen;
        
        struct m0_tl               fep_sndbuf;

        uint8_t                    fep_connlink;
};

struct m0_fab__tm_fids {
        /* Pointer to the head of the list (array in this case) */
        struct fid            **ftf_head;

        /* Pointer to the ctx which is stored in this array */
        struct m0_fab__ev_ctx **ftf_ctx;

        /* Size of array used for storing fids */
        uint32_t                ftf_arr_size;

        /* Count of fids in the array */
        volatile uint32_t       ftf_cnt;
};

struct m0_fab__tm {
        struct m0_net_transfer_mc      *ftm_ntm;
        
        struct m0_thread                ftm_poller;
        
        int                             ftm_epfd;

        struct m0_fab__tm_fids          ftm_fids;

        struct m0_fab__fab             *ftm_fab;

        struct m0_fab__ep              *ftm_pep;
        
        struct fid_ep                  *ftm_rctx;
        
        struct fid_cq                  *ftm_tx_cq;

        struct m0_fab__ev_ctx           ftm_txcq_ctx;
        
        volatile enum m0_fab__tm_state  ftm_state;

        struct m0_tl                    ftm_done;
        
        struct m0_mutex                 ftm_endlock;
        
        struct m0_mutex                 ftm_evpost;

        struct m0_tl                    ftm_bulk;

        struct fi_rma_iov              *ftm_rem_iov;

        struct iovec                   *ftm_loc_iov;

        m0_time_t                       ftm_tmout_check;

        struct m0_fab__bufht            ftm_bufhash;

        uint64_t                        ftm_mr_key_idx;

        uint32_t                        ftm_rr_qt[M0_NET_QT_NR+1];

        uint32_t                        ftm_op_id;
};

struct m0_fab__buf_mr {
        void          **bm_desc;
        
        struct fid_mr **bm_mr;
};

struct m0_fab__bdesc {
        struct m0_net_ip_params fbd_netaddr;

        uint32_t                fbd_iov_cnt;

        uint32_t                fbd_buftoken;
};

struct m0_fab__buf_xfer_params {
        uint32_t bxp_loc_sidx;

        uint32_t bxp_rem_sidx;

        uint32_t bxp_xfer_len;

        uint32_t bxp_rem_soff;

        uint32_t bxp_loc_soff;
};

struct m0_fab__buf {
        uint64_t                         fb_magic;
        
        uint64_t                         fb_sndmagic;
        
        uint64_t                         fb_htmagic;
        
        uint32_t                         fb_dummy[2];
        
        struct m0_fab__bdesc            *fb_rbd;
        
        struct fi_rma_iov               *fb_riov;
        
        struct m0_fab__buf_mr            fb_mr;
        
        struct fid_domain               *fb_dp;
        
        struct m0_net_buffer            *fb_nb;
        
        struct m0_fab__ep               *fb_ev_ep;
        
        struct m0_fab__ep               *fb_txctx;
        
        struct m0_tlink                  fb_linkage;
        
        struct m0_tlink                  fb_snd_link;

        struct m0_hlink                  fb_htlink;

        int32_t                          fb_status;
        
        m0_bindex_t                      fb_length;
        
        volatile uint32_t                fb_wr_cnt;

        struct m0_fab__buf_xfer_params   fb_xfer_params;


        void*                            fb_bulk_op;

        volatile enum m0_fab__buf_state  fb_state;
        
        uint32_t                         fb_token;
};

struct m0_fab__conn_data {
        struct m0_net_ip_params fcd_addr;
};

struct m0_fab__bulk_op {
        uint64_t                   fbl_magic;
        
        struct m0_fab__buf        *fbl_buf;
        
        struct m0_fab__active_ep  *fbl_aep;
        
        struct m0_tlink            fbl_link;
};

#endif /* ENABLE_LIBFAB */

#endif /* __MOTR_NET_LIBFAB_LIBFAB_INTERNAL_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */