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_UNUSED,         /* link is unused */
  36         SMC_LNK_INACTIVE,       /* link is inactive */
  37         SMC_LNK_ACTIVATING,     /* link is being activated */
  38         SMC_LNK_ACTIVE,         /* link is active */
  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_rdma_sge {                           /* sges for RDMA writes */
  56         struct ib_sge           wr_tx_rdma_sge[SMC_IB_MAX_SEND_SGE];
  57 };
  58
  59 #define SMC_MAX_RDMA_WRITES     2               /* max. # of RDMA writes per
  60                                                  * message send
  61                                                  */
  62
  63 struct smc_rdma_sges {                          /* sges per message send */
  64         struct smc_rdma_sge     tx_rdma_sge[SMC_MAX_RDMA_WRITES];
  65 };
  66
  67 struct smc_rdma_wr {                            /* work requests per message
  68                                                  * send
  69                                                  */
  70         struct ib_rdma_wr       wr_tx_rdma[SMC_MAX_RDMA_WRITES];
  71 };
  72
  73 #define SMC_LGR_ID_SIZE         4
  74
  75 struct smc_link {
  76         struct smc_ib_device    *smcibdev;      /* ib-device */
  77         u8                      ibport;         /* port - values 1 | 2 */
  78         struct ib_pd            *roce_pd;       /* IB protection domain,
  79                                                  * unique for every RoCE QP
  80                                                  */
  81         struct ib_qp            *roce_qp;       /* IB queue pair */
  82         struct ib_qp_attr       qp_attr;        /* IB queue pair attributes */
  83
  84         struct smc_wr_buf       *wr_tx_bufs;    /* WR send payload buffers */
  85         struct ib_send_wr       *wr_tx_ibs;     /* WR send meta data */
  86         struct ib_sge           *wr_tx_sges;    /* WR send gather meta data */
  87         struct smc_rdma_sges    *wr_tx_rdma_sges;/*RDMA WRITE gather meta data*/
  88         struct smc_rdma_wr      *wr_tx_rdmas;   /* WR RDMA WRITE */
  89         struct smc_wr_tx_pend   *wr_tx_pends;   /* WR send waiting for CQE */
  90         struct completion       *wr_tx_compl;   /* WR send CQE completion */
  91         /* above four vectors have wr_tx_cnt elements and use the same index */
  92         dma_addr_t              wr_tx_dma_addr; /* DMA address of wr_tx_bufs */
  93         atomic_long_t           wr_tx_id;       /* seq # of last sent WR */
  94         unsigned long           *wr_tx_mask;    /* bit mask of used indexes */
  95         u32                     wr_tx_cnt;      /* number of WR send buffers */
  96         wait_queue_head_t       wr_tx_wait;     /* wait for free WR send buf */
  97
  98         struct smc_wr_buf       *wr_rx_bufs;    /* WR recv payload buffers */
  99         struct ib_recv_wr       *wr_rx_ibs;     /* WR recv meta data */
 100         struct ib_sge           *wr_rx_sges;    /* WR recv scatter meta data */
 101         /* above three vectors have wr_rx_cnt elements and use the same index */
 102         dma_addr_t              wr_rx_dma_addr; /* DMA address of wr_rx_bufs */
 103         u64                     wr_rx_id;       /* seq # of last recv WR */
 104         u32                     wr_rx_cnt;      /* number of WR recv buffers */
 105         unsigned long           wr_rx_tstamp;   /* jiffies when last buf rx */
 106
 107         struct ib_reg_wr        wr_reg;         /* WR register memory region */
 108         wait_queue_head_t       wr_reg_wait;    /* wait for wr_reg result */
 109         enum smc_wr_reg_state   wr_reg_state;   /* state of wr_reg request */
 110
 111         u8                      gid[SMC_GID_SIZE];/* gid matching used vlan id*/
 112         u8                      sgid_index;     /* gid index for vlan id      */
 113         u32                     peer_qpn;       /* QP number of peer */
 114         enum ib_mtu             path_mtu;       /* used mtu */
 115         enum ib_mtu             peer_mtu;       /* mtu size of peer */
 116         u32                     psn_initial;    /* QP tx initial packet seqno */
 117         u32                     peer_psn;       /* QP rx initial packet seqno */
 118         u8                      peer_mac[ETH_ALEN];     /* = gid[8:10||13:15] */
 119         u8                      peer_gid[SMC_GID_SIZE]; /* gid of peer*/
 120         u8                      link_id;        /* unique # within link group */
 121         u8                      link_uid[SMC_LGR_ID_SIZE]; /* unique lnk id */
 122         u8                      peer_link_uid[SMC_LGR_ID_SIZE]; /* peer uid */
 123         u8                      link_idx;       /* index in lgr link array */
 124         u8                      link_is_asym;   /* is link asymmetric? */
 125         struct smc_link_group   *lgr;           /* parent link group */
 126         struct work_struct      link_down_wrk;  /* wrk to bring link down */
 127
 128         enum smc_link_state     state;          /* state of link */
 129         struct delayed_work     llc_testlink_wrk; /* testlink worker */
 130         struct completion       llc_testlink_resp; /* wait for rx of testlink */
 131         int                     llc_testlink_time; /* testlink interval */
 132 };
 133
 134 /* For now we just allow one parallel link per link group. The SMC protocol
 135  * allows more (up to 8).
 136  */
 137 #define SMC_LINKS_PER_LGR_MAX   3
 138 #define SMC_SINGLE_LINK         0
 139
 140 /* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
 141 struct smc_buf_desc {
 142         struct list_head        list;
 143         void                    *cpu_addr;      /* virtual address of buffer */
 144         struct page             *pages;
 145         int                     len;            /* length of buffer */
 146         u32                     used;           /* currently used / unused */
 147         union {
 148                 struct { /* SMC-R */
 149                         struct sg_table sgt[SMC_LINKS_PER_LGR_MAX];
 150                                         /* virtual buffer */
 151                         struct ib_mr    *mr_rx[SMC_LINKS_PER_LGR_MAX];
 152                                         /* for rmb only: memory region
 153                                          * incl. rkey provided to peer
 154                                          */
 155                         u32             order;  /* allocation order */
 156
 157                         u8              is_conf_rkey;
 158                                         /* confirm_rkey done */
 159                         u8              is_reg_mr[SMC_LINKS_PER_LGR_MAX];
 160                                         /* mem region registered */
 161                         u8              is_map_ib[SMC_LINKS_PER_LGR_MAX];
 162                                         /* mem region mapped to lnk */
 163                         u8              is_reg_err;
 164                                         /* buffer registration err */
 165                 };
 166                 struct { /* SMC-D */
 167                         unsigned short  sba_idx;
 168                                         /* SBA index number */
 169                         u64             token;
 170                                         /* DMB token number */
 171                         dma_addr_t      dma_addr;
 172                                         /* DMA address */
 173                 };
 174         };
 175 };
 176
 177 struct smc_rtoken {                             /* address/key of remote RMB */
 178         u64                     dma_addr;
 179         u32                     rkey;
 180 };
 181
 182 #define SMC_BUF_MIN_SIZE        16384   /* minimum size of an RMB */
 183 #define SMC_RMBE_SIZES          16      /* number of distinct RMBE sizes */
 184 /* theoretically, the RFC states that largest size would be 512K,
 185  * i.e. compressed 5 and thus 6 sizes (0..5), despite
 186  * struct smc_clc_msg_accept_confirm.rmbe_size being a 4 bit value (0..15)
 187  */
 188
 189 struct smcd_dev;
 190
 191 enum smc_lgr_type {                             /* redundancy state of lgr */
 192         SMC_LGR_NONE,                   /* no active links, lgr to be deleted */
 193         SMC_LGR_SINGLE,                 /* 1 active RNIC on each peer */
 194         SMC_LGR_SYMMETRIC,              /* 2 active RNICs on each peer */
 195         SMC_LGR_ASYMMETRIC_PEER,        /* local has 2, peer 1 active RNICs */
 196         SMC_LGR_ASYMMETRIC_LOCAL,       /* local has 1, peer 2 active RNICs */
 197 };
 198
 199 enum smc_llc_flowtype {
 200         SMC_LLC_FLOW_NONE       = 0,
 201         SMC_LLC_FLOW_ADD_LINK   = 2,
 202         SMC_LLC_FLOW_DEL_LINK   = 4,
 203         SMC_LLC_FLOW_RKEY       = 6,
 204 };
 205
 206 struct smc_llc_qentry;
 207
 208 struct smc_llc_flow {
 209         enum smc_llc_flowtype type;
 210         struct smc_llc_qentry *qentry;
 211 };
 212
 213 struct smc_link_group {
 214         struct list_head        list;
 215         struct rb_root          conns_all;      /* connection tree */
 216         rwlock_t                conns_lock;     /* protects conns_all */
 217         unsigned int            conns_num;      /* current # of connections */
 218         unsigned short          vlan_id;        /* vlan id of link group */
 219
 220         struct list_head        sndbufs[SMC_RMBE_SIZES];/* tx buffers */
 221         struct mutex            sndbufs_lock;   /* protects tx buffers */
 222         struct list_head        rmbs[SMC_RMBE_SIZES];   /* rx buffers */
 223         struct mutex            rmbs_lock;      /* protects rx buffers */
 224
 225         u8                      id[SMC_LGR_ID_SIZE];    /* unique lgr id */
 226         struct delayed_work     free_work;      /* delayed freeing of an lgr */
 227         struct work_struct      terminate_work; /* abnormal lgr termination */
 228         struct workqueue_struct *tx_wq;         /* wq for conn. tx workers */
 229         u8                      sync_err : 1;   /* lgr no longer fits to peer */
 230         u8                      terminating : 1;/* lgr is terminating */
 231         u8                      freeing : 1;    /* lgr is being freed */
 232
 233         bool                    is_smcd;        /* SMC-R or SMC-D */
 234         u8                      smc_version;
 235         u8                      negotiated_eid[SMC_MAX_EID_LEN];
 236         u8                      peer_os;        /* peer operating system */
 237         u8                      peer_smc_release;
 238         u8                      peer_hostname[SMC_MAX_HOSTNAME_LEN];
 239         union {
 240                 struct { /* SMC-R */
 241                         enum smc_lgr_role       role;
 242                                                 /* client or server */
 243                         struct smc_link         lnk[SMC_LINKS_PER_LGR_MAX];
 244                                                 /* smc link */
 245                         char                    peer_systemid[SMC_SYSTEMID_LEN];
 246                                                 /* unique system_id of peer */
 247                         struct smc_rtoken       rtokens[SMC_RMBS_PER_LGR_MAX]
 248                                                 [SMC_LINKS_PER_LGR_MAX];
 249                                                 /* remote addr/key pairs */
 250                         DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
 251                                                 /* used rtoken elements */
 252                         u8                      next_link_id;
 253                         enum smc_lgr_type       type;
 254                                                 /* redundancy state */
 255                         u8                      pnet_id[SMC_MAX_PNETID_LEN + 1];
 256                                                 /* pnet id of this lgr */
 257                         struct list_head        llc_event_q;
 258                                                 /* queue for llc events */
 259                         spinlock_t              llc_event_q_lock;
 260                                                 /* protects llc_event_q */
 261                         struct mutex            llc_conf_mutex;
 262                                                 /* protects lgr reconfig. */
 263                         struct work_struct      llc_add_link_work;
 264                         struct work_struct      llc_del_link_work;
 265                         struct work_struct      llc_event_work;
 266                                                 /* llc event worker */
 267                         wait_queue_head_t       llc_flow_waiter;
 268                                                 /* w4 next llc event */
 269                         wait_queue_head_t       llc_msg_waiter;
 270                                                 /* w4 next llc msg */
 271                         struct smc_llc_flow     llc_flow_lcl;
 272                                                 /* llc local control field */
 273                         struct smc_llc_flow     llc_flow_rmt;
 274                                                 /* llc remote control field */
 275                         struct smc_llc_qentry   *delayed_event;
 276                                                 /* arrived when flow active */
 277                         spinlock_t              llc_flow_lock;
 278                                                 /* protects llc flow */
 279                         int                     llc_testlink_time;
 280                                                 /* link keep alive time */
 281                         u32                     llc_termination_rsn;
 282                                                 /* rsn code for termination */
 283                 };
 284                 struct { /* SMC-D */
 285                         u64                     peer_gid;
 286                                                 /* Peer GID (remote) */
 287                         struct smcd_dev         *smcd;
 288                                                 /* ISM device for VLAN reg. */
 289                         u8                      peer_shutdown : 1;
 290                                                 /* peer triggered shutdownn */
 291                 };
 292         };
 293 };
 294
 295 struct smc_clc_msg_local;
 296
 297 struct smc_init_info {
 298         u8                      is_smcd;
 299         u8                      smc_type_v1;
 300         u8                      smc_type_v2;
 301         u8                      first_contact_peer;
 302         u8                      first_contact_local;
 303         unsigned short          vlan_id;
 304         /* SMC-R */
 305         struct smc_clc_msg_local *ib_lcl;
 306         struct smc_ib_device    *ib_dev;
 307         u8                      ib_gid[SMC_GID_SIZE];
 308         u8                      ib_port;
 309         u32                     ib_clcqpn;
 310         /* SMC-D */
 311         u64                     ism_peer_gid[SMC_MAX_ISM_DEVS + 1];
 312         struct smcd_dev         *ism_dev[SMC_MAX_ISM_DEVS + 1];
 313         u16                     ism_chid[SMC_MAX_ISM_DEVS + 1];
 314         u8                      ism_offered_cnt; /* # of ISM devices offered */
 315         u8                      ism_selected;    /* index of selected ISM dev*/
 316         u8                      smcd_version;
 317 };
 318
 319 /* Find the connection associated with the given alert token in the link group.
 320  * To use rbtrees we have to implement our own search core.
 321  * Requires @conns_lock
 322  * @token       alert token to search for
 323  * @lgr          link group to search in
 324  * Returns connection associated with token if found, NULL otherwise.
 325  */
 326 static inline struct smc_connection *smc_lgr_find_conn(
 327         u32 token, struct smc_link_group *lgr)
 328 {
 329         struct smc_connection *res = NULL;
 330         struct rb_node *node;
 331
 332         node = lgr->conns_all.rb_node;
 333         while (node) {
 334                 struct smc_connection *cur = rb_entry(node,
 335                                         struct smc_connection, alert_node);
 336
 337                 if (cur->alert_token_local > token) {
 338                         node = node->rb_left;
 339                 } else {
 340                         if (cur->alert_token_local < token) {
 341                                 node = node->rb_right;
 342                         } else {
 343                                 res = cur;
 344                                 break;
 345                         }
 346                 }
 347         }
 348
 349         return res;
 350 }
 351
 352 /* returns true if the specified link is usable */
 353 static inline bool smc_link_usable(struct smc_link *lnk)
 354 {
 355         if (lnk->state == SMC_LNK_UNUSED || lnk->state == SMC_LNK_INACTIVE)
 356                 return false;
 357         return true;
 358 }
 359
 360 static inline bool smc_link_active(struct smc_link *lnk)
 361 {
 362         return lnk->state == SMC_LNK_ACTIVE;
 363 }
 364
 365 struct smc_sock;
 366 struct smc_clc_msg_accept_confirm;
 367 struct smc_clc_msg_local;
 368
 369 void smc_lgr_cleanup_early(struct smc_connection *conn);
 370 void smc_lgr_terminate_sched(struct smc_link_group *lgr);
 371 void smcr_port_add(struct smc_ib_device *smcibdev, u8 ibport);
 372 void smcr_port_err(struct smc_ib_device *smcibdev, u8 ibport);
 373 void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
 374                         unsigned short vlan);
 375 void smc_smcd_terminate_all(struct smcd_dev *dev);
 376 void smc_smcr_terminate_all(struct smc_ib_device *smcibdev);
 377 int smc_buf_create(struct smc_sock *smc, bool is_smcd);
 378 int smc_uncompress_bufsize(u8 compressed);
 379 int smc_rmb_rtoken_handling(struct smc_connection *conn, struct smc_link *link,
 380                             struct smc_clc_msg_accept_confirm *clc);
 381 int smc_rtoken_add(struct smc_link *lnk, __be64 nw_vaddr, __be32 nw_rkey);
 382 int smc_rtoken_delete(struct smc_link *lnk, __be32 nw_rkey);
 383 void smc_rtoken_set(struct smc_link_group *lgr, int link_idx, int link_idx_new,
 384                     __be32 nw_rkey_known, __be64 nw_vaddr, __be32 nw_rkey);
 385 void smc_rtoken_set2(struct smc_link_group *lgr, int rtok_idx, int link_id,
 386                      __be64 nw_vaddr, __be32 nw_rkey);
 387 void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
 388 void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
 389 void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
 390 void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
 391 int smc_vlan_by_tcpsk(struct socket *clcsock, struct smc_init_info *ini);
 392
 393 void smc_conn_free(struct smc_connection *conn);
 394 int smc_conn_create(struct smc_sock *smc, struct smc_init_info *ini);
 395 void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
 396 int smc_core_init(void);
 397 void smc_core_exit(void);
 398
 399 int smcr_link_init(struct smc_link_group *lgr, struct smc_link *lnk,
 400                    u8 link_idx, struct smc_init_info *ini);
 401 void smcr_link_clear(struct smc_link *lnk, bool log);
 402 int smcr_buf_map_lgr(struct smc_link *lnk);
 403 int smcr_buf_reg_lgr(struct smc_link *lnk);
 404 void smcr_lgr_set_type(struct smc_link_group *lgr, enum smc_lgr_type new_type);
 405 void smcr_lgr_set_type_asym(struct smc_link_group *lgr,
 406                             enum smc_lgr_type new_type, int asym_lnk_idx);
 407 int smcr_link_reg_rmb(struct smc_link *link, struct smc_buf_desc *rmb_desc);
 408 struct smc_link *smc_switch_conns(struct smc_link_group *lgr,
 409                                   struct smc_link *from_lnk, bool is_dev_err);
 410 void smcr_link_down_cond(struct smc_link *lnk);
 411 void smcr_link_down_cond_sched(struct smc_link *lnk);
 412
 413 static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
 414 {
 415         return link->lgr;
 416 }
 417 #endif