~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/smc/smc_core.h

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_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 struct 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 */
147 struct 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 
176 struct 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 
189 struct smcd_dev;
190 
191 struct 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         u8                      sync_err : 1;   /* lgr no longer fits to peer */
206         u8                      terminating : 1;/* lgr is terminating */
207 
208         bool                    is_smcd;        /* SMC-R or SMC-D */
209         union {
210                 struct { /* SMC-R */
211                         enum smc_lgr_role       role;
212                                                 /* client or server */
213                         struct smc_link         lnk[SMC_LINKS_PER_LGR_MAX];
214                                                 /* smc link */
215                         char                    peer_systemid[SMC_SYSTEMID_LEN];
216                                                 /* unique system_id of peer */
217                         struct smc_rtoken       rtokens[SMC_RMBS_PER_LGR_MAX]
218                                                 [SMC_LINKS_PER_LGR_MAX];
219                                                 /* remote addr/key pairs */
220                         DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
221                                                 /* used rtoken elements */
222                 };
223                 struct { /* SMC-D */
224                         u64                     peer_gid;
225                                                 /* Peer GID (remote) */
226                         struct smcd_dev         *smcd;
227                                                 /* ISM device for VLAN reg. */
228                 };
229         };
230 };
231 
232 struct smc_clc_msg_local;
233 
234 struct smc_init_info {
235         u8                      is_smcd;
236         unsigned short          vlan_id;
237         int                     srv_first_contact;
238         int                     cln_first_contact;
239         /* SMC-R */
240         struct smc_clc_msg_local *ib_lcl;
241         struct smc_ib_device    *ib_dev;
242         u8                      ib_gid[SMC_GID_SIZE];
243         u8                      ib_port;
244         u32                     ib_clcqpn;
245         /* SMC-D */
246         u64                     ism_gid;
247         struct smcd_dev         *ism_dev;
248 };
249 
250 /* Find the connection associated with the given alert token in the link group.
251  * To use rbtrees we have to implement our own search core.
252  * Requires @conns_lock
253  * @token       alert token to search for
254  * @lgr          link group to search in
255  * Returns connection associated with token if found, NULL otherwise.
256  */
257 static inline struct smc_connection *smc_lgr_find_conn(
258         u32 token, struct smc_link_group *lgr)
259 {
260         struct smc_connection *res = NULL;
261         struct rb_node *node;
262 
263         node = lgr->conns_all.rb_node;
264         while (node) {
265                 struct smc_connection *cur = rb_entry(node,
266                                         struct smc_connection, alert_node);
267 
268                 if (cur->alert_token_local > token) {
269                         node = node->rb_left;
270                 } else {
271                         if (cur->alert_token_local < token) {
272                                 node = node->rb_right;
273                         } else {
274                                 res = cur;
275                                 break;
276                         }
277                 }
278         }
279 
280         return res;
281 }
282 
283 struct smc_sock;
284 struct smc_clc_msg_accept_confirm;
285 struct smc_clc_msg_local;
286 
287 void smc_lgr_forget(struct smc_link_group *lgr);
288 void smc_lgr_terminate(struct smc_link_group *lgr);
289 void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
290 void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
291                         unsigned short vlan);
292 int smc_buf_create(struct smc_sock *smc, bool is_smcd);
293 int smc_uncompress_bufsize(u8 compressed);
294 int smc_rmb_rtoken_handling(struct smc_connection *conn,
295                             struct smc_clc_msg_accept_confirm *clc);
296 int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
297 int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
298 void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
299 void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
300 void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
301 void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
302 int smc_vlan_by_tcpsk(struct socket *clcsock, struct smc_init_info *ini);
303 
304 void smc_conn_free(struct smc_connection *conn);
305 int smc_conn_create(struct smc_sock *smc, struct smc_init_info *ini);
306 void smcd_conn_free(struct smc_connection *conn);
307 void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
308 void smc_core_exit(void);
309 
310 static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
311 {
312         return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
313 }
314 #endif
315 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp