LXR linux/net/smc/smc

   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
  23struct 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
  29enum smc_lgr_role {             /* possible roles of a link group */
  30        SMC_CLNT,       /* client */
  31        SMC_SERV        /* server */
  32};
  33
  34enum 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
  43struct 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
  49enum 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
  55struct 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
  63struct smc_rdma_sges {                          /* sges per message send */
  64        struct smc_rdma_sge     tx_rdma_sge[SMC_MAX_RDMA_WRITES];
  65};
  66
  67struct smc_rdma_wr {                            /* work requests per message
  68                                                 * send
  69                                                 */
  70        struct ib_rdma_wr       wr_tx_rdma[SMC_MAX_RDMA_WRITES];
  71};
  72
  73struct smc_link {
  74        struct smc_ib_device    *smcibdev;      /* ib-device */
  75        u8                      ibport;         /* port - values 1 | 2 */
  76        struct ib_pd            *roce_pd;       /* IB protection domain,
  77                                                 * unique for every RoCE QP
  78                                                 */
  79        struct ib_qp            *roce_qp;       /* IB queue pair */
  80        struct ib_qp_attr       qp_attr;        /* IB queue pair attributes */
  81
  82        struct smc_wr_buf       *wr_tx_bufs;    /* WR send payload buffers */
  83        struct ib_send_wr       *wr_tx_ibs;     /* WR send meta data */
  84        struct ib_sge           *wr_tx_sges;    /* WR send gather meta data */
  85        struct smc_rdma_sges    *wr_tx_rdma_sges;/*RDMA WRITE gather meta data*/
  86        struct smc_rdma_wr      *wr_tx_rdmas;   /* WR RDMA WRITE */
  87        struct smc_wr_tx_pend   *wr_tx_pends;   /* WR send waiting for CQE */
  88        /* above four vectors have wr_tx_cnt elements and use the same index */
  89        dma_addr_t              wr_tx_dma_addr; /* DMA address of wr_tx_bufs */
  90        atomic_long_t           wr_tx_id;       /* seq # of last sent WR */
  91        unsigned long           *wr_tx_mask;    /* bit mask of used indexes */
  92        u32                     wr_tx_cnt;      /* number of WR send buffers */
  93        wait_queue_head_t       wr_tx_wait;     /* wait for free WR send buf */
  94
  95        struct smc_wr_buf       *wr_rx_bufs;    /* WR recv payload buffers */
  96        struct ib_recv_wr       *wr_rx_ibs;     /* WR recv meta data */
  97        struct ib_sge           *wr_rx_sges;    /* WR recv scatter meta data */
  98        /* above three vectors have wr_rx_cnt elements and use the same index */
  99        dma_addr_t              wr_rx_dma_addr; /* DMA address of wr_rx_bufs */
 100        u64                     wr_rx_id;       /* seq # of last recv WR */
 101        u32                     wr_rx_cnt;      /* number of WR recv buffers */
 102        unsigned long           wr_rx_tstamp;   /* jiffies when last buf rx */
 103
 104        struct ib_reg_wr        wr_reg;         /* WR register memory region */
 105        wait_queue_head_t       wr_reg_wait;    /* wait for wr_reg result */
 106        enum smc_wr_reg_state   wr_reg_state;   /* state of wr_reg request */
 107
 108        u8                      gid[SMC_GID_SIZE];/* gid matching used vlan id*/
 109        u8                      sgid_index;     /* gid index for vlan id      */
 110        u32                     peer_qpn;       /* QP number of peer */
 111        enum ib_mtu             path_mtu;       /* used mtu */
 112        enum ib_mtu             peer_mtu;       /* mtu size of peer */
 113        u32                     psn_initial;    /* QP tx initial packet seqno */
 114        u32                     peer_psn;       /* QP rx initial packet seqno */
 115        u8                      peer_mac[ETH_ALEN];     /* = gid[8:10||13:15] */
 116        u8                      peer_gid[SMC_GID_SIZE]; /* gid of peer*/
 117        u8                      link_id;        /* unique # within link group */
 118
 119        enum smc_link_state     state;          /* state of link */
 120        struct workqueue_struct *llc_wq;        /* single thread work queue */
 121        struct completion       llc_confirm;    /* wait for rx of conf link */
 122        struct completion       llc_confirm_resp; /* wait 4 rx of cnf lnk rsp */
 123        int                     llc_confirm_rc; /* rc from confirm link msg */
 124        int                     llc_confirm_resp_rc; /* rc from conf_resp msg */
 125        struct completion       llc_add;        /* wait for rx of add link */
 126        struct completion       llc_add_resp;   /* wait for rx of add link rsp*/
 127        struct delayed_work     llc_testlink_wrk; /* testlink worker */
 128        struct completion       llc_testlink_resp; /* wait for rx of testlink */
 129        int                     llc_testlink_time; /* testlink interval */
 130        struct completion       llc_confirm_rkey; /* wait 4 rx of cnf rkey */
 131        int                     llc_confirm_rkey_rc; /* rc from cnf rkey msg */
 132        struct completion       llc_delete_rkey; /* wait 4 rx of del rkey */
 133        int                     llc_delete_rkey_rc; /* rc from del rkey msg */
 134        struct mutex            llc_delete_rkey_mutex; /* serialize usage */
 135};
 136
 137/* For now we just allow one parallel link per link group. The SMC protocol
 138 * allows more (up to 8).
 139 */
 140#define SMC_LINKS_PER_LGR_MAX   1
 141#define SMC_SINGLE_LINK         0
 142
 143#define SMC_FIRST_CONTACT       1               /* first contact to a peer */
 144#define SMC_REUSE_CONTACT       0               /* follow-on contact to a peer*/
 145
 146/* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
 147struct smc_buf_desc {
 148        struct list_head        list;
 149        void                    *cpu_addr;      /* virtual address of buffer */
 150        struct page             *pages;
 151        int                     len;            /* length of buffer */
 152        u32                     used;           /* currently used / unused */
 153        u8                      wr_reg  : 1;    /* mem region registered */
 154        u8                      regerr  : 1;    /* err during registration */
 155        union {
 156                struct { /* SMC-R */
 157                        struct sg_table         sgt[SMC_LINKS_PER_LGR_MAX];
 158                                                /* virtual buffer */
 159                        struct ib_mr            *mr_rx[SMC_LINKS_PER_LGR_MAX];
 160                                                /* for rmb only: memory region
 161                                                 * incl. rkey provided to peer
 162                                                 */
 163                        u32                     order;  /* allocation order */
 164                };
 165                struct { /* SMC-D */
 166                        unsigned short          sba_idx;
 167                                                /* SBA index number */
 168                        u64                     token;
 169                                                /* DMB token number */
 170                        dma_addr_t              dma_addr;
 171                                                /* DMA address */
 172                };
 173        };
 174};
 175
 176struct smc_rtoken {                             /* address/key of remote RMB */
 177        u64                     dma_addr;
 178        u32                     rkey;
 179};
 180
 181#define SMC_LGR_ID_SIZE         4
 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
 189struct smcd_dev;
 190
 191struct smc_link_group {
 192        struct list_head        list;
 193        struct rb_root          conns_all;      /* connection tree */
 194        rwlock_t                conns_lock;     /* protects conns_all */
 195        unsigned int            conns_num;      /* current # of connections */
 196        unsigned short          vlan_id;        /* vlan id of link group */
 197
 198        struct list_head        sndbufs[SMC_RMBE_SIZES];/* tx buffers */
 199        rwlock_t                sndbufs_lock;   /* protects tx buffers */
 200        struct list_head        rmbs[SMC_RMBE_SIZES];   /* rx buffers */
 201        rwlock_t                rmbs_lock;      /* protects rx buffers */
 202
 203        u8                      id[SMC_LGR_ID_SIZE];    /* unique lgr id */
 204        struct delayed_work     free_work;      /* delayed freeing of an lgr */
 205        struct work_struct      terminate_work; /* abnormal lgr termination */
 206        u8                      sync_err : 1;   /* lgr no longer fits to peer */
 207        u8                      terminating : 1;/* lgr is terminating */
 208        u8                      freefast : 1;   /* free worker scheduled fast */
 209        u8                      freeing : 1;    /* lgr is being freed */
 210
 211        bool                    is_smcd;        /* SMC-R or SMC-D */
 212        union {
 213                struct { /* SMC-R */
 214                        enum smc_lgr_role       role;
 215                                                /* client or server */
 216                        struct smc_link         lnk[SMC_LINKS_PER_LGR_MAX];
 217                                                /* smc link */
 218                        char                    peer_systemid[SMC_SYSTEMID_LEN];
 219                                                /* unique system_id of peer */
 220                        struct smc_rtoken       rtokens[SMC_RMBS_PER_LGR_MAX]
 221                                                [SMC_LINKS_PER_LGR_MAX];
 222                                                /* remote addr/key pairs */
 223                        DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
 224                                                /* used rtoken elements */
 225                };
 226                struct { /* SMC-D */
 227                        u64                     peer_gid;
 228                                                /* Peer GID (remote) */
 229                        struct smcd_dev         *smcd;
 230                                                /* ISM device for VLAN reg. */
 231                        u8                      peer_shutdown : 1;
 232                                                /* peer triggered shutdownn */
 233                };
 234        };
 235};
 236
 237struct smc_clc_msg_local;
 238
 239struct smc_init_info {
 240        u8                      is_smcd;
 241        unsigned short          vlan_id;
 242        int                     srv_first_contact;
 243        int                     cln_first_contact;
 244        /* SMC-R */
 245        struct smc_clc_msg_local *ib_lcl;
 246        struct smc_ib_device    *ib_dev;
 247        u8                      ib_gid[SMC_GID_SIZE];
 248        u8                      ib_port;
 249        u32                     ib_clcqpn;
 250        /* SMC-D */
 251        u64                     ism_gid;
 252        struct smcd_dev         *ism_dev;
 253};
 254
 255/* Find the connection associated with the given alert token in the link group.
 256 * To use rbtrees we have to implement our own search core.
 257 * Requires @conns_lock
 258 * @token       alert token to search for
 259 * @lgr          link group to search in
 260 * Returns connection associated with token if found, NULL otherwise.
 261 */
 262static inline struct smc_connection *smc_lgr_find_conn(
 263        u32 token, struct smc_link_group *lgr)
 264{
 265        struct smc_connection *res = NULL;
 266        struct rb_node *node;
 267
 268        node = lgr->conns_all.rb_node;
 269        while (node) {
 270                struct smc_connection *cur = rb_entry(node,
 271                                        struct smc_connection, alert_node);
 272
 273                if (cur->alert_token_local > token) {
 274                        node = node->rb_left;
 275                } else {
 276                        if (cur->alert_token_local < token) {
 277                                node = node->rb_right;
 278                        } else {
 279                                res = cur;
 280                                break;
 281                        }
 282                }
 283        }
 284
 285        return res;
 286}
 287
 288static inline void smc_lgr_terminate_sched(struct smc_link_group *lgr)
 289{
 290        if (!lgr->terminating && !lgr->freeing)
 291                schedule_work(&lgr->terminate_work);
 292}
 293
 294struct smc_sock;
 295struct smc_clc_msg_accept_confirm;
 296struct smc_clc_msg_local;
 297
 298void smc_lgr_forget(struct smc_link_group *lgr);
 299void smc_lgr_terminate(struct smc_link_group *lgr, bool soft);
 300void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
 301void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
 302                        unsigned short vlan);
 303void smc_smcd_terminate_all(struct smcd_dev *dev);
 304void smc_smcr_terminate_all(struct smc_ib_device *smcibdev);
 305int smc_buf_create(struct smc_sock *smc, bool is_smcd);
 306int smc_uncompress_bufsize(u8 compressed);
 307int smc_rmb_rtoken_handling(struct smc_connection *conn,
 308                            struct smc_clc_msg_accept_confirm *clc);
 309int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
 310int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
 311void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
 312void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
 313void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
 314void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
 315int smc_vlan_by_tcpsk(struct socket *clcsock, struct smc_init_info *ini);
 316
 317void smc_conn_free(struct smc_connection *conn);
 318int smc_conn_create(struct smc_sock *smc, struct smc_init_info *ini);
 319void smcd_conn_free(struct smc_connection *conn);
 320void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
 321int smc_core_init(void);
 322void smc_core_exit(void);
 323
 324static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
 325{
 326        return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
 327}
 328#endif
 329