xref: /openbmc/linux/net/smc/smc.h (revision 021ed9f5)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  *  Shared Memory Communications over RDMA (SMC-R) and RoCE
4  *
5  *  Definitions for the SMC module (socket related)
6  *
7  *  Copyright IBM Corp. 2016
8  *
9  *  Author(s):  Ursula Braun <ubraun@linux.vnet.ibm.com>
10  */
11 #ifndef __SMC_H
12 #define __SMC_H
13 
14 #include <linux/socket.h>
15 #include <linux/types.h>
16 #include <linux/compiler.h> /* __aligned */
17 #include <net/sock.h>
18 
19 #include "smc_ib.h"
20 
21 #define SMCPROTO_SMC		0	/* SMC protocol, IPv4 */
22 #define SMCPROTO_SMC6		1	/* SMC protocol, IPv6 */
23 
24 extern struct proto smc_proto;
25 extern struct proto smc_proto6;
26 
27 #ifdef ATOMIC64_INIT
28 #define KERNEL_HAS_ATOMIC64
29 #endif
30 
31 enum smc_state {		/* possible states of an SMC socket */
32 	SMC_ACTIVE	= 1,
33 	SMC_INIT	= 2,
34 	SMC_CLOSED	= 7,
35 	SMC_LISTEN	= 10,
36 	/* normal close */
37 	SMC_PEERCLOSEWAIT1	= 20,
38 	SMC_PEERCLOSEWAIT2	= 21,
39 	SMC_APPFINCLOSEWAIT	= 24,
40 	SMC_APPCLOSEWAIT1	= 22,
41 	SMC_APPCLOSEWAIT2	= 23,
42 	SMC_PEERFINCLOSEWAIT	= 25,
43 	/* abnormal close */
44 	SMC_PEERABORTWAIT	= 26,
45 	SMC_PROCESSABORT	= 27,
46 };
47 
48 struct smc_link_group;
49 
50 struct smc_wr_rx_hdr {	/* common prefix part of LLC and CDC to demultiplex */
51 	u8			type;
52 } __aligned(1);
53 
54 struct smc_cdc_conn_state_flags {
55 #if defined(__BIG_ENDIAN_BITFIELD)
56 	u8	peer_done_writing : 1;	/* Sending done indicator */
57 	u8	peer_conn_closed : 1;	/* Peer connection closed indicator */
58 	u8	peer_conn_abort : 1;	/* Abnormal close indicator */
59 	u8	reserved : 5;
60 #elif defined(__LITTLE_ENDIAN_BITFIELD)
61 	u8	reserved : 5;
62 	u8	peer_conn_abort : 1;
63 	u8	peer_conn_closed : 1;
64 	u8	peer_done_writing : 1;
65 #endif
66 };
67 
68 struct smc_cdc_producer_flags {
69 #if defined(__BIG_ENDIAN_BITFIELD)
70 	u8	write_blocked : 1;	/* Writing Blocked, no rx buf space */
71 	u8	urg_data_pending : 1;	/* Urgent Data Pending */
72 	u8	urg_data_present : 1;	/* Urgent Data Present */
73 	u8	cons_curs_upd_req : 1;	/* cursor update requested */
74 	u8	failover_validation : 1;/* message replay due to failover */
75 	u8	reserved : 3;
76 #elif defined(__LITTLE_ENDIAN_BITFIELD)
77 	u8	reserved : 3;
78 	u8	failover_validation : 1;
79 	u8	cons_curs_upd_req : 1;
80 	u8	urg_data_present : 1;
81 	u8	urg_data_pending : 1;
82 	u8	write_blocked : 1;
83 #endif
84 };
85 
86 /* in host byte order */
87 union smc_host_cursor {	/* SMC cursor - an offset in an RMBE */
88 	struct {
89 		u16	reserved;
90 		u16	wrap;		/* window wrap sequence number */
91 		u32	count;		/* cursor (= offset) part */
92 	};
93 #ifdef KERNEL_HAS_ATOMIC64
94 	atomic64_t		acurs;	/* for atomic processing */
95 #else
96 	u64			acurs;	/* for atomic processing */
97 #endif
98 } __aligned(8);
99 
100 /* in host byte order, except for flag bitfields in network byte order */
101 struct smc_host_cdc_msg {		/* Connection Data Control message */
102 	struct smc_wr_rx_hdr		common; /* .type = 0xFE */
103 	u8				len;	/* length = 44 */
104 	u16				seqno;	/* connection seq # */
105 	u32				token;	/* alert_token */
106 	union smc_host_cursor		prod;		/* producer cursor */
107 	union smc_host_cursor		cons;		/* consumer cursor,
108 							 * piggy backed "ack"
109 							 */
110 	struct smc_cdc_producer_flags	prod_flags;	/* conn. tx/rx status */
111 	struct smc_cdc_conn_state_flags	conn_state_flags; /* peer conn. status*/
112 	u8				reserved[18];
113 } __aligned(8);
114 
115 enum smc_urg_state {
116 	SMC_URG_VALID	= 1,			/* data present */
117 	SMC_URG_NOTYET	= 2,			/* data pending */
118 	SMC_URG_READ	= 3,			/* data was already read */
119 };
120 
121 struct smc_connection {
122 	struct rb_node		alert_node;
123 	struct smc_link_group	*lgr;		/* link group of connection */
124 	u32			alert_token_local; /* unique conn. id */
125 	u8			peer_rmbe_idx;	/* from tcp handshake */
126 	int			peer_rmbe_size;	/* size of peer rx buffer */
127 	atomic_t		peer_rmbe_space;/* remaining free bytes in peer
128 						 * rmbe
129 						 */
130 	int			rtoken_idx;	/* idx to peer RMB rkey/addr */
131 
132 	struct smc_buf_desc	*sndbuf_desc;	/* send buffer descriptor */
133 	struct smc_buf_desc	*rmb_desc;	/* RMBE descriptor */
134 	int			rmbe_size_short;/* compressed notation */
135 	int			rmbe_update_limit;
136 						/* lower limit for consumer
137 						 * cursor update
138 						 */
139 
140 	struct smc_host_cdc_msg	local_tx_ctrl;	/* host byte order staging
141 						 * buffer for CDC msg send
142 						 * .prod cf. TCP snd_nxt
143 						 * .cons cf. TCP sends ack
144 						 */
145 	union smc_host_cursor	tx_curs_prep;	/* tx - prepared data
146 						 * snd_max..wmem_alloc
147 						 */
148 	union smc_host_cursor	tx_curs_sent;	/* tx - sent data
149 						 * snd_nxt ?
150 						 */
151 	union smc_host_cursor	tx_curs_fin;	/* tx - confirmed by peer
152 						 * snd-wnd-begin ?
153 						 */
154 	atomic_t		sndbuf_space;	/* remaining space in sndbuf */
155 	u16			tx_cdc_seq;	/* sequence # for CDC send */
156 	spinlock_t		send_lock;	/* protect wr_sends */
157 	struct delayed_work	tx_work;	/* retry of smc_cdc_msg_send */
158 	u32			tx_off;		/* base offset in peer rmb */
159 
160 	struct smc_host_cdc_msg	local_rx_ctrl;	/* filled during event_handl.
161 						 * .prod cf. TCP rcv_nxt
162 						 * .cons cf. TCP snd_una
163 						 */
164 	union smc_host_cursor	rx_curs_confirmed; /* confirmed to peer
165 						    * source of snd_una ?
166 						    */
167 	union smc_host_cursor	urg_curs;	/* points at urgent byte */
168 	enum smc_urg_state	urg_state;
169 	bool			urg_tx_pend;	/* urgent data staged */
170 	bool			urg_rx_skip_pend;
171 						/* indicate urgent oob data
172 						 * read, but previous regular
173 						 * data still pending
174 						 */
175 	char			urg_rx_byte;	/* urgent byte */
176 	atomic_t		bytes_to_rcv;	/* arrived data,
177 						 * not yet received
178 						 */
179 	atomic_t		splice_pending;	/* number of spliced bytes
180 						 * pending processing
181 						 */
182 #ifndef KERNEL_HAS_ATOMIC64
183 	spinlock_t		acurs_lock;	/* protect cursors */
184 #endif
185 	struct work_struct	close_work;	/* peer sent some closing */
186 	struct tasklet_struct	rx_tsklet;	/* Receiver tasklet for SMC-D */
187 	u8			rx_off;		/* receive offset:
188 						 * 0 for SMC-R, 32 for SMC-D
189 						 */
190 	u64			peer_token;	/* SMC-D token of peer */
191 	u8			killed : 1;	/* abnormal termination */
192 };
193 
194 struct smc_sock {				/* smc sock container */
195 	struct sock		sk;
196 	struct socket		*clcsock;	/* internal tcp socket */
197 	struct smc_connection	conn;		/* smc connection */
198 	struct smc_sock		*listen_smc;	/* listen parent */
199 	struct work_struct	connect_work;	/* handle non-blocking connect*/
200 	struct work_struct	tcp_listen_work;/* handle tcp socket accepts */
201 	struct work_struct	smc_listen_work;/* prepare new accept socket */
202 	struct list_head	accept_q;	/* sockets to be accepted */
203 	spinlock_t		accept_q_lock;	/* protects accept_q */
204 	bool			use_fallback;	/* fallback to tcp */
205 	int			fallback_rsn;	/* reason for fallback */
206 	u32			peer_diagnosis; /* decline reason from peer */
207 	int			sockopt_defer_accept;
208 						/* sockopt TCP_DEFER_ACCEPT
209 						 * value
210 						 */
211 	u8			wait_close_tx_prepared : 1;
212 						/* shutdown wr or close
213 						 * started, waiting for unsent
214 						 * data to be sent
215 						 */
216 	u8			connect_nonblock : 1;
217 						/* non-blocking connect in
218 						 * flight
219 						 */
220 	struct mutex            clcsock_release_lock;
221 						/* protects clcsock of a listen
222 						 * socket
223 						 * */
224 };
225 
226 static inline struct smc_sock *smc_sk(const struct sock *sk)
227 {
228 	return (struct smc_sock *)sk;
229 }
230 
231 #define SMC_SYSTEMID_LEN		8
232 
233 extern u8	local_systemid[SMC_SYSTEMID_LEN]; /* unique system identifier */
234 
235 /* convert an u32 value into network byte order, store it into a 3 byte field */
236 static inline void hton24(u8 *net, u32 host)
237 {
238 	__be32 t;
239 
240 	t = cpu_to_be32(host);
241 	memcpy(net, ((u8 *)&t) + 1, 3);
242 }
243 
244 /* convert a received 3 byte field into host byte order*/
245 static inline u32 ntoh24(u8 *net)
246 {
247 	__be32 t = 0;
248 
249 	memcpy(((u8 *)&t) + 1, net, 3);
250 	return be32_to_cpu(t);
251 }
252 
253 #ifdef CONFIG_XFRM
254 static inline bool using_ipsec(struct smc_sock *smc)
255 {
256 	return (smc->clcsock->sk->sk_policy[0] ||
257 		smc->clcsock->sk->sk_policy[1]) ? true : false;
258 }
259 #else
260 static inline bool using_ipsec(struct smc_sock *smc)
261 {
262 	return false;
263 }
264 #endif
265 
266 struct sock *smc_accept_dequeue(struct sock *parent, struct socket *new_sock);
267 void smc_close_non_accepted(struct sock *sk);
268 
269 #endif	/* __SMC_H */
270