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};
 27
 28extern struct smc_lgr_list	smc_lgr_list; /* list of link groups */
 29
 30enum smc_lgr_role {		/* possible roles of a link group */
 31	SMC_CLNT,	/* client */
 32	SMC_SERV	/* server */
 33};
 34
 35enum smc_link_state {			/* possible states of a link */
 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
 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_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
 83	struct ib_reg_wr	wr_reg;		/* WR register memory region */
 84	wait_queue_head_t	wr_reg_wait;	/* wait for wr_reg result */
 85	enum smc_wr_reg_state	wr_reg_state;	/* state of wr_reg request */
 86
 87	union ib_gid		gid;		/* gid matching used vlan id */
 88	u32			peer_qpn;	/* QP number of peer */
 89	enum ib_mtu		path_mtu;	/* used mtu */
 90	enum ib_mtu		peer_mtu;	/* mtu size of peer */
 91	u32			psn_initial;	/* QP tx initial packet seqno */
 92	u32			peer_psn;	/* QP rx initial packet seqno */
 93	u8			peer_mac[ETH_ALEN];	/* = gid[8:10||13:15] */
 94	u8			peer_gid[sizeof(union ib_gid)];	/* gid of peer*/
 95	u8			link_id;	/* unique # within link group */
 96
 97	enum smc_link_state	state;		/* state of link */
 98	struct completion	llc_confirm;	/* wait for rx of conf link */
 99	struct completion	llc_confirm_resp; /* wait 4 rx of cnf lnk rsp */
100	int			llc_confirm_rc; /* rc from confirm link msg */
101	int			llc_confirm_resp_rc; /* rc from conf_resp msg */
102	struct completion	llc_add;	/* wait for rx of add link */
103	struct completion	llc_add_resp;	/* wait for rx of add link rsp*/
104};
105
106/* For now we just allow one parallel link per link group. The SMC protocol
107 * allows more (up to 8).
108 */
109#define SMC_LINKS_PER_LGR_MAX	1
110#define SMC_SINGLE_LINK		0
111
112#define SMC_FIRST_CONTACT	1		/* first contact to a peer */
113#define SMC_REUSE_CONTACT	0		/* follow-on contact to a peer*/
114
115/* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
116struct smc_buf_desc {
117	struct list_head	list;
118	void			*cpu_addr;	/* virtual address of buffer */
119	struct sg_table		sgt[SMC_LINKS_PER_LGR_MAX];/* virtual buffer */
120	struct ib_mr		*mr_rx[SMC_LINKS_PER_LGR_MAX];
121						/* for rmb only: memory region
122						 * incl. rkey provided to peer
123						 */
124	u32			order;		/* allocation order */
125	u32			used;		/* currently used / unused */
126	u8			reused	: 1;	/* new created / reused */
127	u8			regerr	: 1;	/* err during registration */
128};
129
130struct smc_rtoken {				/* address/key of remote RMB */
131	u64			dma_addr;
132	u32			rkey;
133};
134
135#define SMC_LGR_ID_SIZE		4
136
137struct smc_link_group {
138	struct list_head	list;
139	enum smc_lgr_role	role;		/* client or server */
140	struct smc_link		lnk[SMC_LINKS_PER_LGR_MAX];	/* smc link */
141	char			peer_systemid[SMC_SYSTEMID_LEN];
142						/* unique system_id of peer */
143	struct rb_root		conns_all;	/* connection tree */
144	rwlock_t		conns_lock;	/* protects conns_all */
145	unsigned int		conns_num;	/* current # of connections */
146	unsigned short		vlan_id;	/* vlan id of link group */
147
148	struct list_head	sndbufs[SMC_RMBE_SIZES];/* tx buffers */
149	rwlock_t		sndbufs_lock;	/* protects tx buffers */
150	struct list_head	rmbs[SMC_RMBE_SIZES];	/* rx buffers */
151	rwlock_t		rmbs_lock;	/* protects rx buffers */
152	struct smc_rtoken	rtokens[SMC_RMBS_PER_LGR_MAX]
153				       [SMC_LINKS_PER_LGR_MAX];
154						/* remote addr/key pairs */
155	unsigned long		rtokens_used_mask[BITS_TO_LONGS(
156							SMC_RMBS_PER_LGR_MAX)];
157						/* used rtoken elements */
158
159	u8			id[SMC_LGR_ID_SIZE];	/* unique lgr id */
160	struct delayed_work	free_work;	/* delayed freeing of an lgr */
161	bool			sync_err;	/* lgr no longer fits to peer */
162};
163
164/* Find the connection associated with the given alert token in the link group.
165 * To use rbtrees we have to implement our own search core.
166 * Requires @conns_lock
167 * @token	alert token to search for
168 * @lgr		 link group to search in
169 * Returns connection associated with token if found, NULL otherwise.
170 */
171static inline struct smc_connection *smc_lgr_find_conn(
172	u32 token, struct smc_link_group *lgr)
173{
174	struct smc_connection *res = NULL;
175	struct rb_node *node;
176
177	node = lgr->conns_all.rb_node;
178	while (node) {
179		struct smc_connection *cur = rb_entry(node,
180					struct smc_connection, alert_node);
181
182		if (cur->alert_token_local > token) {
183			node = node->rb_left;
184		} else {
185			if (cur->alert_token_local < token) {
186				node = node->rb_right;
187			} else {
188				res = cur;
189				break;
190			}
191		}
192	}
193
194	return res;
195}
196
197struct smc_sock;
198struct smc_clc_msg_accept_confirm;
199
200void smc_lgr_free(struct smc_link_group *lgr);
201void smc_lgr_forget(struct smc_link_group *lgr);
202void smc_lgr_terminate(struct smc_link_group *lgr);
203int smc_buf_create(struct smc_sock *smc);
204int smc_rmb_rtoken_handling(struct smc_connection *conn,
205			    struct smc_clc_msg_accept_confirm *clc);
206int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
207int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
208void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
209void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
210void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
211void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
212#endif