1 // SPDX-License-Identifier: GPL-2.0
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
5 * CLC (connection layer control) handshake over initial TCP socket to
6 * prepare for RDMA traffic
8 * Copyright IBM Corp. 2016
10 * Author(s): Ursula Braun <ubraun@linux.vnet.ibm.com>
14 #include <linux/inetdevice.h>
15 #include <linux/if_ether.h>
16 #include <linux/sched/signal.h>
26 /* eye catcher "SMCR" EBCDIC for CLC messages */
27 static const char SMC_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xd9'};
29 /* check if received message has a correct header length and contains valid
30 * heading and trailing eyecatchers
32 static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm)
34 struct smc_clc_msg_proposal_prefix *pclc_prfx;
35 struct smc_clc_msg_accept_confirm *clc;
36 struct smc_clc_msg_proposal *pclc;
37 struct smc_clc_msg_decline *dclc;
38 struct smc_clc_msg_trail *trl;
40 if (memcmp(clcm->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)))
43 case SMC_CLC_PROPOSAL:
44 pclc = (struct smc_clc_msg_proposal *)clcm;
45 pclc_prfx = smc_clc_proposal_get_prefix(pclc);
46 if (ntohs(pclc->hdr.length) !=
47 sizeof(*pclc) + ntohs(pclc->iparea_offset) +
49 pclc_prfx->ipv6_prefixes_cnt *
50 sizeof(struct smc_clc_ipv6_prefix) +
53 trl = (struct smc_clc_msg_trail *)
54 ((u8 *)pclc + ntohs(pclc->hdr.length) - sizeof(*trl));
58 clc = (struct smc_clc_msg_accept_confirm *)clcm;
59 if (ntohs(clc->hdr.length) != sizeof(*clc))
64 dclc = (struct smc_clc_msg_decline *)clcm;
65 if (ntohs(dclc->hdr.length) != sizeof(*dclc))
72 if (memcmp(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)))
77 /* find ipv4 addr on device and get the prefix len, fill CLC proposal msg */
78 static int smc_clc_prfx_set4_rcu(struct dst_entry *dst, __be32 ipv4,
79 struct smc_clc_msg_proposal_prefix *prop)
81 struct in_device *in_dev = __in_dev_get_rcu(dst->dev);
86 if (!inet_ifa_match(ipv4, ifa))
88 prop->prefix_len = inet_mask_len(ifa->ifa_mask);
89 prop->outgoing_subnet = ifa->ifa_address & ifa->ifa_mask;
90 /* prop->ipv6_prefixes_cnt = 0; already done by memset before */
96 /* retrieve and set prefixes in CLC proposal msg */
97 static int smc_clc_prfx_set(struct socket *clcsock,
98 struct smc_clc_msg_proposal_prefix *prop)
100 struct dst_entry *dst = sk_dst_get(clcsock->sk);
101 struct sockaddr_storage addrs;
102 struct sockaddr_in *addr;
105 memset(prop, 0, sizeof(*prop));
114 /* get address to which the internal TCP socket is bound */
115 kernel_getsockname(clcsock, (struct sockaddr *)&addrs);
116 /* analyze IP specific data of net_device belonging to TCP socket */
118 if (addrs.ss_family == PF_INET) {
120 addr = (struct sockaddr_in *)&addrs;
121 rc = smc_clc_prfx_set4_rcu(dst, addr->sin_addr.s_addr, prop);
130 /* match ipv4 addrs of dev against addr in CLC proposal */
131 static int smc_clc_prfx_match4_rcu(struct net_device *dev,
132 struct smc_clc_msg_proposal_prefix *prop)
134 struct in_device *in_dev = __in_dev_get_rcu(dev);
139 if (prop->prefix_len == inet_mask_len(ifa->ifa_mask) &&
140 inet_ifa_match(prop->outgoing_subnet, ifa))
142 } endfor_ifa(in_dev);
147 /* check if proposed prefixes match one of our device prefixes */
148 int smc_clc_prfx_match(struct socket *clcsock,
149 struct smc_clc_msg_proposal_prefix *prop)
151 struct dst_entry *dst = sk_dst_get(clcsock->sk);
163 if (!prop->ipv6_prefixes_cnt)
164 rc = smc_clc_prfx_match4_rcu(dst->dev, prop);
172 /* Wait for data on the tcp-socket, analyze received data
174 * 0 if success and it was not a decline that we received.
175 * SMC_CLC_DECL_REPLY if decline received for fallback w/o another decl send.
176 * clcsock error, -EINTR, -ECONNRESET, -EPROTO otherwise.
178 int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
181 struct sock *clc_sk = smc->clcsock->sk;
182 struct smc_clc_msg_hdr *clcm = buf;
183 struct msghdr msg = {NULL, 0};
185 struct kvec vec = {buf, buflen};
189 /* peek the first few bytes to determine length of data to receive
190 * so we don't consume any subsequent CLC message or payload data
191 * in the TCP byte stream
194 * Caller must make sure that buflen is no less than
195 * sizeof(struct smc_clc_msg_hdr)
197 krflags = MSG_PEEK | MSG_WAITALL;
198 smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
199 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1,
200 sizeof(struct smc_clc_msg_hdr));
201 len = sock_recvmsg(smc->clcsock, &msg, krflags);
202 if (signal_pending(current)) {
203 reason_code = -EINTR;
204 clc_sk->sk_err = EINTR;
205 smc->sk.sk_err = EINTR;
208 if (clc_sk->sk_err) {
209 reason_code = -clc_sk->sk_err;
210 smc->sk.sk_err = clc_sk->sk_err;
213 if (!len) { /* peer has performed orderly shutdown */
214 smc->sk.sk_err = ECONNRESET;
215 reason_code = -ECONNRESET;
219 smc->sk.sk_err = -len;
223 datlen = ntohs(clcm->length);
224 if ((len < sizeof(struct smc_clc_msg_hdr)) ||
226 ((clcm->type != SMC_CLC_DECLINE) &&
227 (clcm->type != expected_type))) {
228 smc->sk.sk_err = EPROTO;
229 reason_code = -EPROTO;
233 /* receive the complete CLC message */
234 memset(&msg, 0, sizeof(struct msghdr));
235 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1, buflen);
236 krflags = MSG_WAITALL;
237 smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
238 len = sock_recvmsg(smc->clcsock, &msg, krflags);
239 if (len < datlen || !smc_clc_msg_hdr_valid(clcm)) {
240 smc->sk.sk_err = EPROTO;
241 reason_code = -EPROTO;
244 if (clcm->type == SMC_CLC_DECLINE) {
245 reason_code = SMC_CLC_DECL_REPLY;
246 if (((struct smc_clc_msg_decline *)buf)->hdr.flag) {
247 smc->conn.lgr->sync_err = true;
248 smc_lgr_terminate(smc->conn.lgr);
256 /* send CLC DECLINE message across internal TCP socket */
257 int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info)
259 struct smc_clc_msg_decline dclc;
264 memset(&dclc, 0, sizeof(dclc));
265 memcpy(dclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
266 dclc.hdr.type = SMC_CLC_DECLINE;
267 dclc.hdr.length = htons(sizeof(struct smc_clc_msg_decline));
268 dclc.hdr.version = SMC_CLC_V1;
269 dclc.hdr.flag = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ? 1 : 0;
270 memcpy(dclc.id_for_peer, local_systemid, sizeof(local_systemid));
271 dclc.peer_diagnosis = htonl(peer_diag_info);
272 memcpy(dclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
274 memset(&msg, 0, sizeof(msg));
275 vec.iov_base = &dclc;
276 vec.iov_len = sizeof(struct smc_clc_msg_decline);
277 len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
278 sizeof(struct smc_clc_msg_decline));
279 if (len < sizeof(struct smc_clc_msg_decline))
280 smc->sk.sk_err = EPROTO;
282 smc->sk.sk_err = -len;
283 return sock_error(&smc->sk);
286 /* send CLC PROPOSAL message across internal TCP socket */
287 int smc_clc_send_proposal(struct smc_sock *smc,
288 struct smc_ib_device *smcibdev,
291 struct smc_clc_msg_proposal_prefix pclc_prfx;
292 struct smc_clc_msg_proposal pclc;
293 struct smc_clc_msg_trail trl;
299 /* retrieve ip prefixes for CLC proposal msg */
300 rc = smc_clc_prfx_set(smc->clcsock, &pclc_prfx);
302 return SMC_CLC_DECL_CNFERR; /* configuration error */
304 /* send SMC Proposal CLC message */
305 plen = sizeof(pclc) + sizeof(pclc_prfx) + sizeof(trl);
306 memset(&pclc, 0, sizeof(pclc));
307 memcpy(pclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
308 pclc.hdr.type = SMC_CLC_PROPOSAL;
309 pclc.hdr.length = htons(plen);
310 pclc.hdr.version = SMC_CLC_V1; /* SMC version */
311 memcpy(pclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
312 memcpy(&pclc.lcl.gid, &smcibdev->gid[ibport - 1], SMC_GID_SIZE);
313 memcpy(&pclc.lcl.mac, &smcibdev->mac[ibport - 1], ETH_ALEN);
314 pclc.iparea_offset = htons(0);
316 memcpy(trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
317 memset(&msg, 0, sizeof(msg));
318 vec[0].iov_base = &pclc;
319 vec[0].iov_len = sizeof(pclc);
320 vec[1].iov_base = &pclc_prfx;
321 vec[1].iov_len = sizeof(pclc_prfx);
322 vec[2].iov_base = &trl;
323 vec[2].iov_len = sizeof(trl);
324 /* due to the few bytes needed for clc-handshake this cannot block */
325 len = kernel_sendmsg(smc->clcsock, &msg, vec, 3, plen);
326 if (len < sizeof(pclc)) {
328 reason_code = -ENETUNREACH;
329 smc->sk.sk_err = -reason_code;
331 smc->sk.sk_err = smc->clcsock->sk->sk_err;
332 reason_code = -smc->sk.sk_err;
339 /* send CLC CONFIRM message across internal TCP socket */
340 int smc_clc_send_confirm(struct smc_sock *smc)
342 struct smc_connection *conn = &smc->conn;
343 struct smc_clc_msg_accept_confirm cclc;
344 struct smc_link *link;
350 link = &conn->lgr->lnk[SMC_SINGLE_LINK];
351 /* send SMC Confirm CLC msg */
352 memset(&cclc, 0, sizeof(cclc));
353 memcpy(cclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
354 cclc.hdr.type = SMC_CLC_CONFIRM;
355 cclc.hdr.length = htons(sizeof(cclc));
356 cclc.hdr.version = SMC_CLC_V1; /* SMC version */
357 memcpy(cclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
358 memcpy(&cclc.lcl.gid, &link->smcibdev->gid[link->ibport - 1],
360 memcpy(&cclc.lcl.mac, &link->smcibdev->mac[link->ibport - 1], ETH_ALEN);
361 hton24(cclc.qpn, link->roce_qp->qp_num);
363 htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
364 cclc.conn_idx = 1; /* for now: 1 RMB = 1 RMBE */
365 cclc.rmbe_alert_token = htonl(conn->alert_token_local);
366 cclc.qp_mtu = min(link->path_mtu, link->peer_mtu);
367 cclc.rmbe_size = conn->rmbe_size_short;
368 cclc.rmb_dma_addr = cpu_to_be64(
369 (u64)sg_dma_address(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
370 hton24(cclc.psn, link->psn_initial);
372 memcpy(cclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
374 memset(&msg, 0, sizeof(msg));
375 vec.iov_base = &cclc;
376 vec.iov_len = sizeof(cclc);
377 len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1, sizeof(cclc));
378 if (len < sizeof(cclc)) {
380 reason_code = -ENETUNREACH;
381 smc->sk.sk_err = -reason_code;
383 smc->sk.sk_err = smc->clcsock->sk->sk_err;
384 reason_code = -smc->sk.sk_err;
390 /* send CLC ACCEPT message across internal TCP socket */
391 int smc_clc_send_accept(struct smc_sock *new_smc, int srv_first_contact)
393 struct smc_connection *conn = &new_smc->conn;
394 struct smc_clc_msg_accept_confirm aclc;
395 struct smc_link *link;
401 link = &conn->lgr->lnk[SMC_SINGLE_LINK];
402 memset(&aclc, 0, sizeof(aclc));
403 memcpy(aclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
404 aclc.hdr.type = SMC_CLC_ACCEPT;
405 aclc.hdr.length = htons(sizeof(aclc));
406 aclc.hdr.version = SMC_CLC_V1; /* SMC version */
407 if (srv_first_contact)
409 memcpy(aclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
410 memcpy(&aclc.lcl.gid, &link->smcibdev->gid[link->ibport - 1],
412 memcpy(&aclc.lcl.mac, link->smcibdev->mac[link->ibport - 1], ETH_ALEN);
413 hton24(aclc.qpn, link->roce_qp->qp_num);
415 htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
416 aclc.conn_idx = 1; /* as long as 1 RMB = 1 RMBE */
417 aclc.rmbe_alert_token = htonl(conn->alert_token_local);
418 aclc.qp_mtu = link->path_mtu;
419 aclc.rmbe_size = conn->rmbe_size_short,
420 aclc.rmb_dma_addr = cpu_to_be64(
421 (u64)sg_dma_address(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
422 hton24(aclc.psn, link->psn_initial);
423 memcpy(aclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
425 memset(&msg, 0, sizeof(msg));
426 vec.iov_base = &aclc;
427 vec.iov_len = sizeof(aclc);
428 len = kernel_sendmsg(new_smc->clcsock, &msg, &vec, 1, sizeof(aclc));
429 if (len < sizeof(aclc)) {
431 new_smc->sk.sk_err = EPROTO;
433 new_smc->sk.sk_err = new_smc->clcsock->sk->sk_err;
434 rc = sock_error(&new_smc->sk);