[linux.git] / net / smc / smc_core.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Shared Memory Communications over RDMA (SMC-R) and RoCE
 *
 *  Definitions for SMC Connections, Link Groups and Links
 *
 *  Copyright IBM Corp. 2016
 *
 *  Author(s):  Ursula Braun <[email protected]>
 */

#ifndef _SMC_CORE_H
#define _SMC_CORE_H

#include <linux/atomic.h>
#include <rdma/ib_verbs.h>

#include "smc.h"
#include "smc_ib.h"

#define SMC_RMBS_PER_LGR_MAX	255	/* max. # of RMBs per link group */

struct smc_lgr_list {			/* list of link group definition */
	struct list_head	list;
	spinlock_t		lock;	/* protects list of link groups */
	u32			num;	/* unique link group number */
};

enum smc_lgr_role {		/* possible roles of a link group */
	SMC_CLNT,	/* client */
	SMC_SERV	/* server */
};

enum smc_link_state {			/* possible states of a link */
	SMC_LNK_INACTIVE,	/* link is inactive */
	SMC_LNK_ACTIVATING,	/* link is being activated */
	SMC_LNK_ACTIVE,		/* link is active */
	SMC_LNK_DELETING,	/* link is being deleted */
};

#define SMC_WR_BUF_SIZE		48	/* size of work request buffer */

struct smc_wr_buf {
	u8	raw[SMC_WR_BUF_SIZE];
};

#define SMC_WR_REG_MR_WAIT_TIME	(5 * HZ)/* wait time for ib_wr_reg_mr result */

enum smc_wr_reg_state {
	POSTED,		/* ib_wr_reg_mr request posted */
	CONFIRMED,	/* ib_wr_reg_mr response: successful */
	FAILED		/* ib_wr_reg_mr response: failure */
};

struct smc_link {
	struct smc_ib_device	*smcibdev;	/* ib-device */
	u8			ibport;		/* port - values 1 | 2 */
	struct ib_pd		*roce_pd;	/* IB protection domain,
						 * unique for every RoCE QP
						 */
	struct ib_qp		*roce_qp;	/* IB queue pair */
	struct ib_qp_attr	qp_attr;	/* IB queue pair attributes */

	struct smc_wr_buf	*wr_tx_bufs;	/* WR send payload buffers */
	struct ib_send_wr	*wr_tx_ibs;	/* WR send meta data */
	struct ib_sge		*wr_tx_sges;	/* WR send gather meta data */
	struct smc_wr_tx_pend	*wr_tx_pends;	/* WR send waiting for CQE */
	/* above four vectors have wr_tx_cnt elements and use the same index */
	dma_addr_t		wr_tx_dma_addr;	/* DMA address of wr_tx_bufs */
	atomic_long_t		wr_tx_id;	/* seq # of last sent WR */
	unsigned long		*wr_tx_mask;	/* bit mask of used indexes */
	u32			wr_tx_cnt;	/* number of WR send buffers */
	wait_queue_head_t	wr_tx_wait;	/* wait for free WR send buf */

	struct smc_wr_buf	*wr_rx_bufs;	/* WR recv payload buffers */
	struct ib_recv_wr	*wr_rx_ibs;	/* WR recv meta data */
	struct ib_sge		*wr_rx_sges;	/* WR recv scatter meta data */
	/* above three vectors have wr_rx_cnt elements and use the same index */
	dma_addr_t		wr_rx_dma_addr;	/* DMA address of wr_rx_bufs */
	u64			wr_rx_id;	/* seq # of last recv WR */
	u32			wr_rx_cnt;	/* number of WR recv buffers */
	unsigned long		wr_rx_tstamp;	/* jiffies when last buf rx */

	struct ib_reg_wr	wr_reg;		/* WR register memory region */
	wait_queue_head_t	wr_reg_wait;	/* wait for wr_reg result */
	enum smc_wr_reg_state	wr_reg_state;	/* state of wr_reg request */

	u8			gid[SMC_GID_SIZE];/* gid matching used vlan id*/
	u8			sgid_index;	/* gid index for vlan id      */
	u32			peer_qpn;	/* QP number of peer */
	enum ib_mtu		path_mtu;	/* used mtu */
	enum ib_mtu		peer_mtu;	/* mtu size of peer */
	u32			psn_initial;	/* QP tx initial packet seqno */
	u32			peer_psn;	/* QP rx initial packet seqno */
	u8			peer_mac[ETH_ALEN];	/* = gid[8:10||13:15] */
	u8			peer_gid[SMC_GID_SIZE];	/* gid of peer*/
	u8			link_id;	/* unique # within link group */

	enum smc_link_state	state;		/* state of link */
	struct workqueue_struct *llc_wq;	/* single thread work queue */
	struct completion	llc_confirm;	/* wait for rx of conf link */
	struct completion	llc_confirm_resp; /* wait 4 rx of cnf lnk rsp */
	int			llc_confirm_rc; /* rc from confirm link msg */
	int			llc_confirm_resp_rc; /* rc from conf_resp msg */
	struct completion	llc_add;	/* wait for rx of add link */
	struct completion	llc_add_resp;	/* wait for rx of add link rsp*/
	struct delayed_work	llc_testlink_wrk; /* testlink worker */
	struct completion	llc_testlink_resp; /* wait for rx of testlink */
	int			llc_testlink_time; /* testlink interval */
	struct completion	llc_confirm_rkey; /* wait 4 rx of cnf rkey */
	int			llc_confirm_rkey_rc; /* rc from cnf rkey msg */
};

/* For now we just allow one parallel link per link group. The SMC protocol
 * allows more (up to 8).
 */
#define SMC_LINKS_PER_LGR_MAX	1
#define SMC_SINGLE_LINK		0

#define SMC_FIRST_CONTACT	1		/* first contact to a peer */
#define SMC_REUSE_CONTACT	0		/* follow-on contact to a peer*/

/* tx/rx buffer list element for sndbufs list and rmbs list of a lgr */
struct smc_buf_desc {
	struct list_head	list;
	void			*cpu_addr;	/* virtual address of buffer */
	struct page		*pages;
	int			len;		/* length of buffer */
	u32			used;		/* currently used / unused */
	u8			reused	: 1;	/* new created / reused */
	u8			regerr	: 1;	/* err during registration */
	union {
		struct { /* SMC-R */
			struct sg_table		sgt[SMC_LINKS_PER_LGR_MAX];
						/* virtual buffer */
			struct ib_mr		*mr_rx[SMC_LINKS_PER_LGR_MAX];
						/* for rmb only: memory region
						 * incl. rkey provided to peer
						 */
			u32			order;	/* allocation order */
		};
		struct { /* SMC-D */
			unsigned short		sba_idx;
						/* SBA index number */
			u64			token;
						/* DMB token number */
			dma_addr_t		dma_addr;
						/* DMA address */
		};
	};
};

struct smc_rtoken {				/* address/key of remote RMB */
	u64			dma_addr;
	u32			rkey;
};

#define SMC_LGR_ID_SIZE		4
#define SMC_BUF_MIN_SIZE	16384	/* minimum size of an RMB */
#define SMC_RMBE_SIZES		16	/* number of distinct RMBE sizes */
/* theoretically, the RFC states that largest size would be 512K,
 * i.e. compressed 5 and thus 6 sizes (0..5), despite
 * struct smc_clc_msg_accept_confirm.rmbe_size being a 4 bit value (0..15)
 */

struct smcd_dev;

struct smc_link_group {
	struct list_head	list;
	struct rb_root		conns_all;	/* connection tree */
	rwlock_t		conns_lock;	/* protects conns_all */
	unsigned int		conns_num;	/* current # of connections */
	unsigned short		vlan_id;	/* vlan id of link group */

	struct list_head	sndbufs[SMC_RMBE_SIZES];/* tx buffers */
	rwlock_t		sndbufs_lock;	/* protects tx buffers */
	struct list_head	rmbs[SMC_RMBE_SIZES];	/* rx buffers */
	rwlock_t		rmbs_lock;	/* protects rx buffers */

	u8			id[SMC_LGR_ID_SIZE];	/* unique lgr id */
	struct delayed_work	free_work;	/* delayed freeing of an lgr */
	u8			sync_err : 1;	/* lgr no longer fits to peer */
	u8			terminating : 1;/* lgr is terminating */

	bool			is_smcd;	/* SMC-R or SMC-D */
	union {
		struct { /* SMC-R */
			enum smc_lgr_role	role;
						/* client or server */
			struct smc_link		lnk[SMC_LINKS_PER_LGR_MAX];
						/* smc link */
			char			peer_systemid[SMC_SYSTEMID_LEN];
						/* unique system_id of peer */
			struct smc_rtoken	rtokens[SMC_RMBS_PER_LGR_MAX]
						[SMC_LINKS_PER_LGR_MAX];
						/* remote addr/key pairs */
			DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
						/* used rtoken elements */
		};
		struct { /* SMC-D */
			u64			peer_gid;
						/* Peer GID (remote) */
			struct smcd_dev		*smcd;
						/* ISM device for VLAN reg. */
		};
	};
};

/* Find the connection associated with the given alert token in the link group.
 * To use rbtrees we have to implement our own search core.
 * Requires @conns_lock
 * @token	alert token to search for
 * @lgr		 link group to search in
 * Returns connection associated with token if found, NULL otherwise.
 */
static inline struct smc_connection *smc_lgr_find_conn(
	u32 token, struct smc_link_group *lgr)
{
	struct smc_connection *res = NULL;
	struct rb_node *node;

	node = lgr->conns_all.rb_node;
	while (node) {
		struct smc_connection *cur = rb_entry(node,
					struct smc_connection, alert_node);

		if (cur->alert_token_local > token) {
			node = node->rb_left;
		} else {
			if (cur->alert_token_local < token) {
				node = node->rb_right;
			} else {
				res = cur;
				break;
			}
		}
	}

	return res;
}

struct smc_sock;
struct smc_clc_msg_accept_confirm;
struct smc_clc_msg_local;

void smc_lgr_free(struct smc_link_group *lgr);
void smc_lgr_forget(struct smc_link_group *lgr);
void smc_lgr_terminate(struct smc_link_group *lgr);
void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
			unsigned short vlan);
int smc_buf_create(struct smc_sock *smc, bool is_smcd);
int smc_uncompress_bufsize(u8 compressed);
int smc_rmb_rtoken_handling(struct smc_connection *conn,
			    struct smc_clc_msg_accept_confirm *clc);
int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
int smc_vlan_by_tcpsk(struct socket *clcsock, unsigned short *vlan_id);

void smc_conn_free(struct smc_connection *conn);
int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
		    struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
		    struct smc_clc_msg_local *lcl, struct smcd_dev *smcd,
		    u64 peer_gid);
void smcd_conn_free(struct smc_connection *conn);
void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
void smc_core_exit(void);

static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)
{
	return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
}
#endif
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
0cfdd8f9 UB	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 <[email protected]>
	10	*/
	11
	12	#ifndef _SMC_CORE_H
	13	#define _SMC_CORE_H
	14
f38ba179	15	#include <linux/atomic.h>
0cfdd8f9 UB	16	#include <rdma/ib_verbs.h>
	17
	18	#include "smc.h"
	19	#include "smc_ib.h"
	20
cd6851f3 UB	21	#define SMC_RMBS_PER_LGR_MAX 255 /* max. # of RMBs per link group */
cd6851f3 UB	22
0cfdd8f9 UB	23	struct smc_lgr_list { /* list of link group definition */
	24	struct list_head list;
	25	spinlock_t lock; /* protects list of link groups */
9fda3510	26	u32 num; /* unique link group number */
0cfdd8f9 UB	27	};
0cfdd8f9 UB	28
0cfdd8f9 UB	29	enum smc_lgr_role { /* possible roles of a link group */
	30	SMC_CLNT, /* client */
	31	SMC_SERV /* server */
	32	};
	33
52bedf37 KG	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 */
0d18a0cb KG	37	SMC_LNK_ACTIVE, /* link is active */
0d18a0cb KG	38	SMC_LNK_DELETING, /* link is being deleted */
52bedf37 KG	39	};
52bedf37 KG	40
f38ba179 UB	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
652a1e41 UB	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
0cfdd8f9 UB	55	struct smc_link {
	56	struct smc_ib_device smcibdev; / ib-device */
	57	u8 ibport; /* port - values 1 \| 2 */
f38ba179 UB	58	struct ib_pd roce_pd; / IB protection domain,
	59	* unique for every RoCE QP
	60	*/
0cfdd8f9 UB	61	struct ib_qp roce_qp; / IB queue pair */
0cfdd8f9 UB	62	struct ib_qp_attr qp_attr; /* IB queue pair attributes */
f38ba179 UB	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 */
877ae5be	82	unsigned long wr_rx_tstamp; /* jiffies when last buf rx */
f38ba179	83
652a1e41 UB	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
7005ada6 UB	88	u8 gid[SMC_GID_SIZE];/* gid matching used vlan id*/
7005ada6 UB	89	u8 sgid_index; /* gid index for vlan id */
0cfdd8f9 UB	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] */
7005ada6	96	u8 peer_gid[SMC_GID_SIZE]; /* gid of peer*/
9bf9abea	97	u8 link_id; /* unique # within link group */
52bedf37 KG	98
52bedf37 KG	99	enum smc_link_state state; /* state of link */
2a4c57a9	100	struct workqueue_struct llc_wq; / single thread work queue */
9bf9abea UB	101	struct completion llc_confirm; /* wait for rx of conf link */
9bf9abea UB	102	struct completion llc_confirm_resp; /* wait 4 rx of cnf lnk rsp */
75d320d6 KG	103	int llc_confirm_rc; /* rc from confirm link msg */
75d320d6 KG	104	int llc_confirm_resp_rc; /* rc from conf_resp msg */
52bedf37 KG	105	struct completion llc_add; /* wait for rx of add link */
52bedf37 KG	106	struct completion llc_add_resp; /* wait for rx of add link rsp*/
877ae5be KG	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 */
44aa81ce KG	110	struct completion llc_confirm_rkey; /* wait 4 rx of cnf rkey */
44aa81ce KG	111	int llc_confirm_rkey_rc; /* rc from cnf rkey msg */
0cfdd8f9 UB	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
cd6851f3 UB	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;
cd6851f3	126	void cpu_addr; / virtual address of buffer */
2ef4f27a	127	struct page *pages;
69cb7dc0	128	int len; /* length of buffer */
cd6851f3	129	u32 used; /* currently used / unused */
a6920d1d KG	130	u8 reused : 1; /* new created / reused */
a6920d1d KG	131	u8 regerr : 1; /* err during registration */
c6ba7c9b HW	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	};
cd6851f3 UB	151	};
cd6851f3 UB	152
bd4ad577 UB	153	struct smc_rtoken { /* address/key of remote RMB */
	154	u64 dma_addr;
	155	u32 rkey;
	156	};
	157
9bf9abea	158	#define SMC_LGR_ID_SIZE 4
2f6becaf HW	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	*/
9bf9abea	165
c6ba7c9b HW	166	struct smcd_dev;
c6ba7c9b HW	167
0cfdd8f9 UB	168	struct smc_link_group {
0cfdd8f9 UB	169	struct list_head list;
0cfdd8f9 UB	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 */
cd6851f3 UB	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 */
bd4ad577	179
9bf9abea	180	u8 id[SMC_LGR_ID_SIZE]; /* unique lgr id */
0cfdd8f9	181	struct delayed_work free_work; /* delayed freeing of an lgr */
517c300e KG	182	u8 sync_err : 1; /* lgr no longer fits to peer */
517c300e KG	183	u8 terminating : 1;/* lgr is terminating */
c6ba7c9b HW	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 */
144ce4b9	197	DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);
c6ba7c9b HW	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	};
0cfdd8f9 UB	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
cd6851f3 UB	242	struct smc_sock;
cd6851f3 UB	243	struct smc_clc_msg_accept_confirm;
2f6becaf	244	struct smc_clc_msg_local;
cd6851f3	245
0cfdd8f9	246	void smc_lgr_free(struct smc_link_group *lgr);
9651b934	247	void smc_lgr_forget(struct smc_link_group *lgr);
0cfdd8f9	248	void smc_lgr_terminate(struct smc_link_group *lgr);
9fda3510	249	void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
0512f69e HW	250	void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
0512f69e HW	251	unsigned short vlan);
c6ba7c9b	252	int smc_buf_create(struct smc_sock *smc, bool is_smcd);
2f6becaf	253	int smc_uncompress_bufsize(u8 compressed);
bd4ad577 UB	254	int smc_rmb_rtoken_handling(struct smc_connection *conn,
bd4ad577 UB	255	struct smc_clc_msg_accept_confirm *clc);
4ed75de5 KG	256	int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey);
4ed75de5 KG	257	int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey);
10428dd8 UB	258	void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn);
	259	void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn);
	260	void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn);
	261	void smc_rmb_sync_sg_for_device(struct smc_connection *conn);
41349844	262	int smc_vlan_by_tcpsk(struct socket clcsock, unsigned short vlan_id);
c6ba7c9b	263
2f6becaf	264	void smc_conn_free(struct smc_connection *conn);
c6ba7c9b	265	int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
ee05ff7a	266	struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
c6ba7c9b HW	267	struct smc_clc_msg_local lcl, struct smcd_dev smcd,
	268	u64 peer_gid);
	269	void smcd_conn_free(struct smc_connection *conn);
0d18a0cb	270	void smc_lgr_schedule_free_work_fast(struct smc_link_group *lgr);
9fda3510	271	void smc_core_exit(void);
00e5fb26 SR	272
	273	static inline struct smc_link_group smc_get_lgr(struct smc_link link)
	274	{
	275	return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
	276	}
0cfdd8f9	277	#endif