Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
ac713874 UB |
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> | |
f38ba179 | 16 | #include <linux/compiler.h> /* __aligned */ |
ac713874 UB |
17 | #include <net/sock.h> |
18 | ||
0cfdd8f9 UB |
19 | #include "smc_ib.h" |
20 | ||
aaa4d33f KG |
21 | #define SMCPROTO_SMC 0 /* SMC protocol, IPv4 */ |
22 | #define SMCPROTO_SMC6 1 /* SMC protocol, IPv6 */ | |
ac713874 | 23 | |
a4cf0443 UB |
24 | #define SMC_MAX_PORTS 2 /* Max # of ports */ |
25 | ||
f16a7dd5 | 26 | extern struct proto smc_proto; |
aaa4d33f | 27 | extern struct proto smc_proto6; |
f16a7dd5 | 28 | |
5f08318f UB |
29 | #ifdef ATOMIC64_INIT |
30 | #define KERNEL_HAS_ATOMIC64 | |
31 | #endif | |
32 | ||
ac713874 UB |
33 | enum smc_state { /* possible states of an SMC socket */ |
34 | SMC_ACTIVE = 1, | |
35 | SMC_INIT = 2, | |
36 | SMC_CLOSED = 7, | |
37 | SMC_LISTEN = 10, | |
b38d7324 UB |
38 | /* normal close */ |
39 | SMC_PEERCLOSEWAIT1 = 20, | |
40 | SMC_PEERCLOSEWAIT2 = 21, | |
41 | SMC_APPFINCLOSEWAIT = 24, | |
42 | SMC_APPCLOSEWAIT1 = 22, | |
43 | SMC_APPCLOSEWAIT2 = 23, | |
44 | SMC_PEERFINCLOSEWAIT = 25, | |
45 | /* abnormal close */ | |
46 | SMC_PEERABORTWAIT = 26, | |
47 | SMC_PROCESSABORT = 27, | |
ac713874 UB |
48 | }; |
49 | ||
0cfdd8f9 UB |
50 | struct smc_link_group; |
51 | ||
f38ba179 UB |
52 | struct smc_wr_rx_hdr { /* common prefix part of LLC and CDC to demultiplex */ |
53 | u8 type; | |
54 | } __aligned(1); | |
55 | ||
5f08318f UB |
56 | struct smc_cdc_conn_state_flags { |
57 | #if defined(__BIG_ENDIAN_BITFIELD) | |
58 | u8 peer_done_writing : 1; /* Sending done indicator */ | |
59 | u8 peer_conn_closed : 1; /* Peer connection closed indicator */ | |
60 | u8 peer_conn_abort : 1; /* Abnormal close indicator */ | |
61 | u8 reserved : 5; | |
62 | #elif defined(__LITTLE_ENDIAN_BITFIELD) | |
63 | u8 reserved : 5; | |
64 | u8 peer_conn_abort : 1; | |
65 | u8 peer_conn_closed : 1; | |
66 | u8 peer_done_writing : 1; | |
67 | #endif | |
68 | }; | |
69 | ||
70 | struct smc_cdc_producer_flags { | |
71 | #if defined(__BIG_ENDIAN_BITFIELD) | |
72 | u8 write_blocked : 1; /* Writing Blocked, no rx buf space */ | |
73 | u8 urg_data_pending : 1; /* Urgent Data Pending */ | |
74 | u8 urg_data_present : 1; /* Urgent Data Present */ | |
75 | u8 cons_curs_upd_req : 1; /* cursor update requested */ | |
76 | u8 failover_validation : 1;/* message replay due to failover */ | |
77 | u8 reserved : 3; | |
78 | #elif defined(__LITTLE_ENDIAN_BITFIELD) | |
79 | u8 reserved : 3; | |
80 | u8 failover_validation : 1; | |
81 | u8 cons_curs_upd_req : 1; | |
82 | u8 urg_data_present : 1; | |
83 | u8 urg_data_pending : 1; | |
84 | u8 write_blocked : 1; | |
85 | #endif | |
86 | }; | |
87 | ||
88 | /* in host byte order */ | |
89 | union smc_host_cursor { /* SMC cursor - an offset in an RMBE */ | |
90 | struct { | |
91 | u16 reserved; | |
92 | u16 wrap; /* window wrap sequence number */ | |
93 | u32 count; /* cursor (= offset) part */ | |
94 | }; | |
95 | #ifdef KERNEL_HAS_ATOMIC64 | |
96 | atomic64_t acurs; /* for atomic processing */ | |
97 | #else | |
98 | u64 acurs; /* for atomic processing */ | |
99 | #endif | |
100 | } __aligned(8); | |
101 | ||
102 | /* in host byte order, except for flag bitfields in network byte order */ | |
103 | struct smc_host_cdc_msg { /* Connection Data Control message */ | |
104 | struct smc_wr_rx_hdr common; /* .type = 0xFE */ | |
105 | u8 len; /* length = 44 */ | |
106 | u16 seqno; /* connection seq # */ | |
107 | u32 token; /* alert_token */ | |
108 | union smc_host_cursor prod; /* producer cursor */ | |
109 | union smc_host_cursor cons; /* consumer cursor, | |
110 | * piggy backed "ack" | |
111 | */ | |
112 | struct smc_cdc_producer_flags prod_flags; /* conn. tx/rx status */ | |
113 | struct smc_cdc_conn_state_flags conn_state_flags; /* peer conn. status*/ | |
114 | u8 reserved[18]; | |
115 | } __aligned(8); | |
116 | ||
0cfdd8f9 UB |
117 | struct smc_connection { |
118 | struct rb_node alert_node; | |
119 | struct smc_link_group *lgr; /* link group of connection */ | |
120 | u32 alert_token_local; /* unique conn. id */ | |
121 | u8 peer_conn_idx; /* from tcp handshake */ | |
cd6851f3 UB |
122 | int peer_rmbe_size; /* size of peer rx buffer */ |
123 | atomic_t peer_rmbe_space;/* remaining free bytes in peer | |
124 | * rmbe | |
125 | */ | |
bd4ad577 | 126 | int rtoken_idx; /* idx to peer RMB rkey/addr */ |
cd6851f3 UB |
127 | |
128 | struct smc_buf_desc *sndbuf_desc; /* send buffer descriptor */ | |
129 | int sndbuf_size; /* sndbuf size <== sock wmem */ | |
130 | struct smc_buf_desc *rmb_desc; /* RMBE descriptor */ | |
131 | int rmbe_size; /* RMBE size <== sock rmem */ | |
132 | int rmbe_size_short;/* compressed notation */ | |
952310cc UB |
133 | int rmbe_update_limit; |
134 | /* lower limit for consumer | |
135 | * cursor update | |
136 | */ | |
5f08318f UB |
137 | |
138 | struct smc_host_cdc_msg local_tx_ctrl; /* host byte order staging | |
139 | * buffer for CDC msg send | |
140 | * .prod cf. TCP snd_nxt | |
141 | * .cons cf. TCP sends ack | |
142 | */ | |
143 | union smc_host_cursor tx_curs_prep; /* tx - prepared data | |
144 | * snd_max..wmem_alloc | |
145 | */ | |
146 | union smc_host_cursor tx_curs_sent; /* tx - sent data | |
147 | * snd_nxt ? | |
148 | */ | |
149 | union smc_host_cursor tx_curs_fin; /* tx - confirmed by peer | |
150 | * snd-wnd-begin ? | |
151 | */ | |
152 | atomic_t sndbuf_space; /* remaining space in sndbuf */ | |
153 | u16 tx_cdc_seq; /* sequence # for CDC send */ | |
154 | spinlock_t send_lock; /* protect wr_sends */ | |
18e537cd | 155 | struct delayed_work tx_work; /* retry of smc_cdc_msg_send */ |
5f08318f UB |
156 | |
157 | struct smc_host_cdc_msg local_rx_ctrl; /* filled during event_handl. | |
158 | * .prod cf. TCP rcv_nxt | |
159 | * .cons cf. TCP snd_una | |
160 | */ | |
161 | union smc_host_cursor rx_curs_confirmed; /* confirmed to peer | |
162 | * source of snd_una ? | |
163 | */ | |
164 | atomic_t bytes_to_rcv; /* arrived data, | |
165 | * not yet received | |
166 | */ | |
167 | #ifndef KERNEL_HAS_ATOMIC64 | |
168 | spinlock_t acurs_lock; /* protect cursors */ | |
169 | #endif | |
46c28dbd | 170 | struct work_struct close_work; /* peer sent some closing */ |
0cfdd8f9 UB |
171 | }; |
172 | ||
ac713874 UB |
173 | struct smc_sock { /* smc sock container */ |
174 | struct sock sk; | |
175 | struct socket *clcsock; /* internal tcp socket */ | |
0cfdd8f9 | 176 | struct smc_connection conn; /* smc connection */ |
a046d57d UB |
177 | struct smc_sock *listen_smc; /* listen parent */ |
178 | struct work_struct tcp_listen_work;/* handle tcp socket accepts */ | |
179 | struct work_struct smc_listen_work;/* prepare new accept socket */ | |
180 | struct list_head accept_q; /* sockets to be accepted */ | |
181 | spinlock_t accept_q_lock; /* protects accept_q */ | |
ac713874 | 182 | bool use_fallback; /* fallback to tcp */ |
b38d7324 UB |
183 | u8 wait_close_tx_prepared : 1; |
184 | /* shutdown wr or close | |
185 | * started, waiting for unsent | |
186 | * data to be sent | |
187 | */ | |
ac713874 UB |
188 | }; |
189 | ||
190 | static inline struct smc_sock *smc_sk(const struct sock *sk) | |
191 | { | |
192 | return (struct smc_sock *)sk; | |
193 | } | |
194 | ||
a4cf0443 UB |
195 | #define SMC_SYSTEMID_LEN 8 |
196 | ||
197 | extern u8 local_systemid[SMC_SYSTEMID_LEN]; /* unique system identifier */ | |
198 | ||
0cfdd8f9 UB |
199 | /* convert an u32 value into network byte order, store it into a 3 byte field */ |
200 | static inline void hton24(u8 *net, u32 host) | |
201 | { | |
202 | __be32 t; | |
203 | ||
204 | t = cpu_to_be32(host); | |
205 | memcpy(net, ((u8 *)&t) + 1, 3); | |
206 | } | |
207 | ||
208 | /* convert a received 3 byte field into host byte order*/ | |
209 | static inline u32 ntoh24(u8 *net) | |
210 | { | |
211 | __be32 t = 0; | |
212 | ||
213 | memcpy(((u8 *)&t) + 1, net, 3); | |
214 | return be32_to_cpu(t); | |
215 | } | |
216 | ||
cd6851f3 UB |
217 | #define SMC_BUF_MIN_SIZE 16384 /* minimum size of an RMB */ |
218 | ||
219 | #define SMC_RMBE_SIZES 16 /* number of distinct sizes for an RMBE */ | |
220 | /* theoretically, the RFC states that largest size would be 512K, | |
221 | * i.e. compressed 5 and thus 6 sizes (0..5), despite | |
222 | * struct smc_clc_msg_accept_confirm.rmbe_size being a 4 bit value (0..15) | |
223 | */ | |
224 | ||
225 | /* convert the RMB size into the compressed notation - minimum 16K. | |
226 | * In contrast to plain ilog2, this rounds towards the next power of 2, | |
227 | * so the socket application gets at least its desired sndbuf / rcvbuf size. | |
228 | */ | |
229 | static inline u8 smc_compress_bufsize(int size) | |
230 | { | |
231 | u8 compressed; | |
232 | ||
233 | if (size <= SMC_BUF_MIN_SIZE) | |
234 | return 0; | |
235 | ||
236 | size = (size - 1) >> 14; | |
237 | compressed = ilog2(size) + 1; | |
238 | if (compressed >= SMC_RMBE_SIZES) | |
239 | compressed = SMC_RMBE_SIZES - 1; | |
240 | return compressed; | |
241 | } | |
242 | ||
243 | /* convert the RMB size from compressed notation into integer */ | |
244 | static inline int smc_uncompress_bufsize(u8 compressed) | |
245 | { | |
246 | u32 size; | |
247 | ||
248 | size = 0x00000001 << (((int)compressed) + 14); | |
249 | return (int)size; | |
250 | } | |
251 | ||
a046d57d UB |
252 | #ifdef CONFIG_XFRM |
253 | static inline bool using_ipsec(struct smc_sock *smc) | |
254 | { | |
255 | return (smc->clcsock->sk->sk_policy[0] || | |
a8fbf8e7 | 256 | smc->clcsock->sk->sk_policy[1]) ? true : false; |
a046d57d UB |
257 | } |
258 | #else | |
259 | static inline bool using_ipsec(struct smc_sock *smc) | |
260 | { | |
a8fbf8e7 | 261 | return false; |
a046d57d UB |
262 | } |
263 | #endif | |
264 | ||
0cfdd8f9 UB |
265 | struct smc_clc_msg_local; |
266 | ||
0cfdd8f9 | 267 | void smc_conn_free(struct smc_connection *conn); |
be6d467b | 268 | int smc_conn_create(struct smc_sock *smc, |
0cfdd8f9 UB |
269 | struct smc_ib_device *smcibdev, u8 ibport, |
270 | struct smc_clc_msg_local *lcl, int srv_first_contact); | |
b38d7324 UB |
271 | struct sock *smc_accept_dequeue(struct sock *parent, struct socket *new_sock); |
272 | void smc_close_non_accepted(struct sock *sk); | |
a046d57d | 273 | |
ac713874 | 274 | #endif /* __SMC_H */ |