net/smc: use queue pair number when matching link group
[sfrench/cifs-2.6.git] / 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 };
113
114 /* For now we just allow one parallel link per link group. The SMC protocol
115  * allows more (up to 8).
116  */
117 #define SMC_LINKS_PER_LGR_MAX   1
118 #define SMC_SINGLE_LINK         0
119
120 #define SMC_FIRST_CONTACT       1               /* first contact to a peer */
121 #define SMC_REUSE_CONTACT       0               /* follow-on contact to a peer*/
122
123 /* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
124 struct smc_buf_desc {
125         struct list_head        list;
126         void                    *cpu_addr;      /* virtual address of buffer */
127         struct page             *pages;
128         int                     len;            /* length of buffer */
129         u32                     used;           /* currently used / unused */
130         u8                      reused  : 1;    /* new created / reused */
131         u8                      regerr  : 1;    /* err during registration */
132         union {
133                 struct { /* SMC-R */
134                         struct sg_table         sgt[SMC_LINKS_PER_LGR_MAX];
135                                                 /* virtual buffer */
136                         struct ib_mr            *mr_rx[SMC_LINKS_PER_LGR_MAX];
137                                                 /* for rmb only: memory region
138                                                  * incl. rkey provided to peer
139                                                  */
140                         u32                     order;  /* allocation order */
141                 };
142                 struct { /* SMC-D */
143                         unsigned short          sba_idx;
144                                                 /* SBA index number */
145                         u64                     token;
146                                                 /* DMB token number */
147                         dma_addr_t              dma_addr;
148                                                 /* DMA address */
149                 };
150         };
151 };
152
153 struct smc_rtoken {                             /* address/key of remote RMB */
154         u64                     dma_addr;
155         u32                     rkey;
156 };
157
158 #define SMC_LGR_ID_SIZE         4
159 #define SMC_BUF_MIN_SIZE        16384   /* minimum size of an RMB */
160 #define SMC_RMBE_SIZES          16      /* number of distinct RMBE sizes */
161 /* theoretically, the RFC states that largest size would be 512K,
162  * i.e. compressed 5 and thus 6 sizes (0..5), despite
163  * struct smc_clc_msg_accept_confirm.rmbe_size being a 4 bit value (0..15)
164  */
165
166 struct smcd_dev;
167
168 struct smc_link_group {
169         struct list_head        list;
170         struct rb_root          conns_all;      /* connection tree */
171         rwlock_t                conns_lock;     /* protects conns_all */
172         unsigned int            conns_num;      /* current # of connections */
173         unsigned short          vlan_id;        /* vlan id of link group */
174
175         struct list_head        sndbufs[SMC_RMBE_SIZES];/* tx buffers */
176         rwlock_t                sndbufs_lock;   /* protects tx buffers */
177         struct list_head        rmbs[SMC_RMBE_SIZES];   /* rx buffers */
178         rwlock_t                rmbs_lock;      /* protects rx buffers */
179
180         u8                      id[SMC_LGR_ID_SIZE];    /* unique lgr id */
181         struct delayed_work     free_work;      /* delayed freeing of an lgr */
182         u8                      sync_err : 1;   /* lgr no longer fits to peer */
183         u8                      terminating : 1;/* lgr is terminating */
184
185         bool                    is_smcd;        /* SMC-R or SMC-D */
186         union {
187                 struct { /* SMC-R */
188                         enum smc_lgr_role       role;
189                                                 /* client or server */
190                         struct smc_link         lnk[SMC_LINKS_PER_LGR_MAX];
191                                                 /* smc link */
192                         char                    peer_systemid[SMC_SYSTEMID_LEN];
193                                                 /* unique system_id of peer */
194                         struct smc_rtoken       rtokens[SMC_RMBS_PER_LGR_MAX]
195                                                 [SMC_LINKS_PER_LGR_MAX];
196                                                 /* remote addr/key pairs */
197                         DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
198                                                 /* used rtoken elements */
199                 };
200                 struct { /* SMC-D */
201                         u64                     peer_gid;
202                                                 /* Peer GID (remote) */
203                         struct smcd_dev         *smcd;
204                                                 /* ISM device for VLAN reg. */
205                 };
206         };
207 };
208
209 /* Find the connection associated with the given alert token in the link group.
210  * To use rbtrees we have to implement our own search core.
211  * Requires @conns_lock
212  * @token       alert token to search for
213  * @lgr          link group to search in
214  * Returns connection associated with token if found, NULL otherwise.
215  */
216 static inline struct smc_connection *smc_lgr_find_conn(
217         u32 token, struct smc_link_group *lgr)
218 {
219         struct smc_connection *res = NULL;
220         struct rb_node *node;
221
222         node = lgr->conns_all.rb_node;
223         while (node) {
224                 struct smc_connection *cur = rb_entry(node,
225                                         struct smc_connection, alert_node);
226
227                 if (cur->alert_token_local > token) {
228                         node = node->rb_left;
229                 } else {
230                         if (cur->alert_token_local < token) {
231                                 node = node->rb_right;
232                         } else {
233                                 res = cur;
234                                 break;
235                         }
236                 }
237         }
238
239         return res;
240 }
241
242 struct smc_sock;
243 struct smc_clc_msg_accept_confirm;
244 struct smc_clc_msg_local;
245
246 void smc_lgr_free(struct smc_link_group *lgr);
247 void smc_lgr_forget(struct smc_link_group *lgr);
248 void smc_lgr_terminate(struct smc_link_group *lgr);
249 void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
250 void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid);
251 int smc_buf_create(struct smc_sock *smc, bool is_smcd);
252 int smc_uncompress_bufsize(u8 compressed);
253 int smc_rmb_rtoken_handling(struct smc_connection *conn,
254                             struct smc_clc_msg_accept_confirm *clc);
255 int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
256 int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
257 void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
258 void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
259 void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
260 void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
261 int smc_vlan_by_tcpsk(struct socket *clcsock, unsigned short *vlan_id);
262
263 void smc_conn_free(struct smc_connection *conn);
264 int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
265                     struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
266                     struct smc_clc_msg_local *lcl, struct smcd_dev *smcd,
267                     u64 peer_gid);
268 void smcd_conn_free(struct smc_connection *conn);
269 void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
270 void smc_core_exit(void);
271
272 static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
273 {
274         return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
275 }
276 #endif