net/smc/smc_core.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Shared Memory Communications over RDMA (SMC-R) and RoCE
   4  *
   5  *  Definitions for SMC Connections, Link Groups and Links
   6  *
   7  *  Copyright IBM Corp. 2016
   8  *
   9  *  Author(s):  Ursula Braun <ubraun@linux.vnet.ibm.com>
  10  */
  11
  12 #ifndef _SMC_CORE_H
  13 #define _SMC_CORE_H
  14
  15 #include <linux/atomic.h>
  16 #include <rdma/ib_verbs.h>
  17
  18 #include "smc.h"
  19 #include "smc_ib.h"
  20
  21 #define SMC_RMBS_PER_LGR_MAX    255     /* max. # of RMBs per link group */
  22
  23 struct smc_lgr_list {                   /* list of link group definition */
  24         struct list_head        list;
  25         spinlock_t              lock;   /* protects list of link groups */
  26         u32                     num;    /* unique link group number */
  27 };
  28
  29 enum smc_lgr_role {             /* possible roles of a link group */
  30         SMC_CLNT,       /* client */
  31         SMC_SERV        /* server */
  32 };
  33
  34 enum smc_link_state {                   /* possible states of a link */
  35         SMC_LNK_INACTIVE,       /* link is inactive */
  36         SMC_LNK_ACTIVATING,     /* link is being activated */
  37         SMC_LNK_ACTIVE,         /* link is active */
  38         SMC_LNK_DELETING,       /* link is being deleted */
  39 };
  40
  41 #define SMC_WR_BUF_SIZE         48      /* size of work request buffer */
  42
  43 struct smc_wr_buf {
  44         u8      raw[SMC_WR_BUF_SIZE];
  45 };
  46
  47 #define SMC_WR_REG_MR_WAIT_TIME (5 * HZ)/* wait time for ib_wr_reg_mr result */
  48
  49 enum smc_wr_reg_state {
  50         POSTED,         /* ib_wr_reg_mr request posted */
  51         CONFIRMED,      /* ib_wr_reg_mr response: successful */
  52         FAILED          /* ib_wr_reg_mr response: failure */
  53 };
  54
  55 struct smc_link {
  56         struct smc_ib_device    *smcibdev;      /* ib-device */
  57         u8                      ibport;         /* port - values 1 | 2 */
  58         struct ib_pd            *roce_pd;       /* IB protection domain,
  59                                                  * unique for every RoCE QP
  60                                                  */
  61         struct ib_qp            *roce_qp;       /* IB queue pair */
  62         struct ib_qp_attr       qp_attr;        /* IB queue pair attributes */
  63
  64         struct smc_wr_buf       *wr_tx_bufs;    /* WR send payload buffers */
  65         struct ib_send_wr       *wr_tx_ibs;     /* WR send meta data */
  66         struct ib_sge           *wr_tx_sges;    /* WR send gather meta data */
  67         struct smc_wr_tx_pend   *wr_tx_pends;   /* WR send waiting for CQE */
  68         /* above four vectors have wr_tx_cnt elements and use the same index */
  69         dma_addr_t              wr_tx_dma_addr; /* DMA address of wr_tx_bufs */
  70         atomic_long_t           wr_tx_id;       /* seq # of last sent WR */
  71         unsigned long           *wr_tx_mask;    /* bit mask of used indexes */
  72         u32                     wr_tx_cnt;      /* number of WR send buffers */
  73         wait_queue_head_t       wr_tx_wait;     /* wait for free WR send buf */
  74
  75         struct smc_wr_buf       *wr_rx_bufs;    /* WR recv payload buffers */
  76         struct ib_recv_wr       *wr_rx_ibs;     /* WR recv meta data */
  77         struct ib_sge           *wr_rx_sges;    /* WR recv scatter meta data */
  78         /* above three vectors have wr_rx_cnt elements and use the same index */
  79         dma_addr_t              wr_rx_dma_addr; /* DMA address of wr_rx_bufs */
  80         u64                     wr_rx_id;       /* seq # of last recv WR */
  81         u32                     wr_rx_cnt;      /* number of WR recv buffers */
  82         unsigned long           wr_rx_tstamp;   /* jiffies when last buf rx */
  83
  84         struct ib_reg_wr        wr_reg;         /* WR register memory region */
  85         wait_queue_head_t       wr_reg_wait;    /* wait for wr_reg result */
  86         enum smc_wr_reg_state   wr_reg_state;   /* state of wr_reg request */
  87
  88         u8                      gid[SMC_GID_SIZE];/* gid matching used vlan id*/
  89         u8                      sgid_index;     /* gid index for vlan id      */
  90         u32                     peer_qpn;       /* QP number of peer */
  91         enum ib_mtu             path_mtu;       /* used mtu */
  92         enum ib_mtu             peer_mtu;       /* mtu size of peer */
  93         u32                     psn_initial;    /* QP tx initial packet seqno */
  94         u32                     peer_psn;       /* QP rx initial packet seqno */
  95         u8                      peer_mac[ETH_ALEN];     /* = gid[8:10||13:15] */
  96         u8                      peer_gid[SMC_GID_SIZE]; /* gid of peer*/
  97         u8                      link_id;        /* unique # within link group */
  98
  99         enum smc_link_state     state;          /* state of link */
 100         struct workqueue_struct *llc_wq;        /* single thread work queue */
 101         struct completion       llc_confirm;    /* wait for rx of conf link */
 102         struct completion       llc_confirm_resp; /* wait 4 rx of cnf lnk rsp */
 103         int                     llc_confirm_rc; /* rc from confirm link msg */
 104         int                     llc_confirm_resp_rc; /* rc from conf_resp msg */
 105         struct completion       llc_add;        /* wait for rx of add link */
 106         struct completion       llc_add_resp;   /* wait for rx of add link rsp*/
 107         struct delayed_work     llc_testlink_wrk; /* testlink worker */
 108         struct completion       llc_testlink_resp; /* wait for rx of testlink */
 109         int                     llc_testlink_time; /* testlink interval */
 110         struct completion       llc_confirm_rkey; /* wait 4 rx of cnf rkey */
 111         int                     llc_confirm_rkey_rc; /* rc from cnf rkey msg */
 112         struct completion       llc_delete_rkey; /* wait 4 rx of del rkey */
 113         int                     llc_delete_rkey_rc; /* rc from del rkey msg */
 114         struct mutex            llc_delete_rkey_mutex; /* serialize usage */
 115 };
 116
 117 /* For now we just allow one parallel link per link group. The SMC protocol
 118  * allows more (up to 8).
 119  */
 120 #define SMC_LINKS_PER_LGR_MAX   1
 121 #define SMC_SINGLE_LINK         0
 122
 123 #define SMC_FIRST_CONTACT       1               /* first contact to a peer */
 124 #define SMC_REUSE_CONTACT       0               /* follow-on contact to a peer*/
 125
 126 /* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
 127 struct smc_buf_desc {
 128         struct list_head        list;
 129         void                    *cpu_addr;      /* virtual address of buffer */
 130         struct page             *pages;
 131         int                     len;            /* length of buffer */
 132         u32                     used;           /* currently used / unused */
 133         u8                      wr_reg  : 1;    /* mem region registered */
 134         u8                      regerr  : 1;    /* err during registration */
 135         union {
 136                 struct { /* SMC-R */
 137                         struct sg_table         sgt[SMC_LINKS_PER_LGR_MAX];
 138                                                 /* virtual buffer */
 139                         struct ib_mr            *mr_rx[SMC_LINKS_PER_LGR_MAX];
 140                                                 /* for rmb only: memory region
 141                                                  * incl. rkey provided to peer
 142                                                  */
 143                         u32                     order;  /* allocation order */
 144                 };
 145                 struct { /* SMC-D */
 146                         unsigned short          sba_idx;
 147                                                 /* SBA index number */
 148                         u64                     token;
 149                                                 /* DMB token number */
 150                         dma_addr_t              dma_addr;
 151                                                 /* DMA address */
 152                 };
 153         };
 154 };
 155
 156 struct smc_rtoken {                             /* address/key of remote RMB */
 157         u64                     dma_addr;
 158         u32                     rkey;
 159 };
 160
 161 #define SMC_LGR_ID_SIZE         4
 162 #define SMC_BUF_MIN_SIZE        16384   /* minimum size of an RMB */
 163 #define SMC_RMBE_SIZES          16      /* number of distinct RMBE sizes */
 164 /* theoretically, the RFC states that largest size would be 512K,
 165  * i.e. compressed 5 and thus 6 sizes (0..5), despite
 166  * struct smc_clc_msg_accept_confirm.rmbe_size being a 4 bit value (0..15)
 167  */
 168
 169 struct smcd_dev;
 170
 171 struct smc_link_group {
 172         struct list_head        list;
 173         struct rb_root          conns_all;      /* connection tree */
 174         rwlock_t                conns_lock;     /* protects conns_all */
 175         unsigned int            conns_num;      /* current # of connections */
 176         unsigned short          vlan_id;        /* vlan id of link group */
 177
 178         struct list_head        sndbufs[SMC_RMBE_SIZES];/* tx buffers */
 179         rwlock_t                sndbufs_lock;   /* protects tx buffers */
 180         struct list_head        rmbs[SMC_RMBE_SIZES];   /* rx buffers */
 181         rwlock_t                rmbs_lock;      /* protects rx buffers */
 182
 183         u8                      id[SMC_LGR_ID_SIZE];    /* unique lgr id */
 184         struct delayed_work     free_work;      /* delayed freeing of an lgr */
 185         u8                      sync_err : 1;   /* lgr no longer fits to peer */
 186         u8                      terminating : 1;/* lgr is terminating */
 187
 188         bool                    is_smcd;        /* SMC-R or SMC-D */
 189         union {
 190                 struct { /* SMC-R */
 191                         enum smc_lgr_role       role;
 192                                                 /* client or server */
 193                         struct smc_link         lnk[SMC_LINKS_PER_LGR_MAX];
 194                                                 /* smc link */
 195                         char                    peer_systemid[SMC_SYSTEMID_LEN];
 196                                                 /* unique system_id of peer */
 197                         struct smc_rtoken       rtokens[SMC_RMBS_PER_LGR_MAX]
 198                                                 [SMC_LINKS_PER_LGR_MAX];
 199                                                 /* remote addr/key pairs */
 200                         DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
 201                                                 /* used rtoken elements */
 202                 };
 203                 struct { /* SMC-D */
 204                         u64                     peer_gid;
 205                                                 /* Peer GID (remote) */
 206                         struct smcd_dev         *smcd;
 207                                                 /* ISM device for VLAN reg. */
 208                 };
 209         };
 210 };
 211
 212 /* Find the connection associated with the given alert token in the link group.
 213  * To use rbtrees we have to implement our own search core.
 214  * Requires @conns_lock
 215  * @token       alert token to search for
 216  * @lgr          link group to search in
 217  * Returns connection associated with token if found, NULL otherwise.
 218  */
 219 static inline struct smc_connection *smc_lgr_find_conn(
 220         u32 token, struct smc_link_group *lgr)
 221 {
 222         struct smc_connection *res = NULL;
 223         struct rb_node *node;
 224
 225         node = lgr->conns_all.rb_node;
 226         while (node) {
 227                 struct smc_connection *cur = rb_entry(node,
 228                                         struct smc_connection, alert_node);
 229
 230                 if (cur->alert_token_local > token) {
 231                         node = node->rb_left;
 232                 } else {
 233                         if (cur->alert_token_local < token) {
 234                                 node = node->rb_right;
 235                         } else {
 236                                 res = cur;
 237                                 break;
 238                         }
 239                 }
 240         }
 241
 242         return res;
 243 }
 244
 245 struct smc_sock;
 246 struct smc_clc_msg_accept_confirm;
 247 struct smc_clc_msg_local;
 248
 249 void smc_lgr_forget(struct smc_link_group *lgr);
 250 void smc_lgr_terminate(struct smc_link_group *lgr);
 251 void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
 252 void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
 253                         unsigned short vlan);
 254 int smc_buf_create(struct smc_sock *smc, bool is_smcd);
 255 int smc_uncompress_bufsize(u8 compressed);
 256 int smc_rmb_rtoken_handling(struct smc_connection *conn,
 257                             struct smc_clc_msg_accept_confirm *clc);
 258 int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
 259 int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
 260 void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
 261 void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
 262 void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
 263 void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
 264 int smc_vlan_by_tcpsk(struct socket *clcsock, unsigned short *vlan_id);
 265
 266 void smc_conn_free(struct smc_connection *conn);
 267 int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
 268                     struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
 269                     struct smc_clc_msg_local *lcl, struct smcd_dev *smcd,
 270                     u64 peer_gid);
 271 void smcd_conn_free(struct smc_connection *conn);
 272 void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
 273 void smc_core_exit(void);
 274
 275 static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
 276 {
 277         return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
 278 }
 279 #endif