Loading...
Note: File does not exist in v3.5.6.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
4 *
5 * CLC (connection layer control) handshake over initial TCP socket to
6 * prepare for RDMA traffic
7 *
8 * Copyright IBM Corp. 2016, 2018
9 *
10 * Author(s): Ursula Braun <ubraun@linux.vnet.ibm.com>
11 */
12
13#include <linux/in.h>
14#include <linux/inetdevice.h>
15#include <linux/if_ether.h>
16#include <linux/sched/signal.h>
17
18#include <net/addrconf.h>
19#include <net/sock.h>
20#include <net/tcp.h>
21
22#include "smc.h"
23#include "smc_core.h"
24#include "smc_clc.h"
25#include "smc_ib.h"
26
27/* eye catcher "SMCR" EBCDIC for CLC messages */
28static const char SMC_EYECATCHER[4] = {'\xe2', '\xd4', '\xc3', '\xd9'};
29
30/* check if received message has a correct header length and contains valid
31 * heading and trailing eyecatchers
32 */
33static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm)
34{
35 struct smc_clc_msg_proposal_prefix *pclc_prfx;
36 struct smc_clc_msg_accept_confirm *clc;
37 struct smc_clc_msg_proposal *pclc;
38 struct smc_clc_msg_decline *dclc;
39 struct smc_clc_msg_trail *trl;
40
41 if (memcmp(clcm->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)))
42 return false;
43 switch (clcm->type) {
44 case SMC_CLC_PROPOSAL:
45 pclc = (struct smc_clc_msg_proposal *)clcm;
46 pclc_prfx = smc_clc_proposal_get_prefix(pclc);
47 if (ntohs(pclc->hdr.length) !=
48 sizeof(*pclc) + ntohs(pclc->iparea_offset) +
49 sizeof(*pclc_prfx) +
50 pclc_prfx->ipv6_prefixes_cnt *
51 sizeof(struct smc_clc_ipv6_prefix) +
52 sizeof(*trl))
53 return false;
54 trl = (struct smc_clc_msg_trail *)
55 ((u8 *)pclc + ntohs(pclc->hdr.length) - sizeof(*trl));
56 break;
57 case SMC_CLC_ACCEPT:
58 case SMC_CLC_CONFIRM:
59 clc = (struct smc_clc_msg_accept_confirm *)clcm;
60 if (ntohs(clc->hdr.length) != sizeof(*clc))
61 return false;
62 trl = &clc->trl;
63 break;
64 case SMC_CLC_DECLINE:
65 dclc = (struct smc_clc_msg_decline *)clcm;
66 if (ntohs(dclc->hdr.length) != sizeof(*dclc))
67 return false;
68 trl = &dclc->trl;
69 break;
70 default:
71 return false;
72 }
73 if (memcmp(trl->eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER)))
74 return false;
75 return true;
76}
77
78/* find ipv4 addr on device and get the prefix len, fill CLC proposal msg */
79static int smc_clc_prfx_set4_rcu(struct dst_entry *dst, __be32 ipv4,
80 struct smc_clc_msg_proposal_prefix *prop)
81{
82 struct in_device *in_dev = __in_dev_get_rcu(dst->dev);
83
84 if (!in_dev)
85 return -ENODEV;
86 for_ifa(in_dev) {
87 if (!inet_ifa_match(ipv4, ifa))
88 continue;
89 prop->prefix_len = inet_mask_len(ifa->ifa_mask);
90 prop->outgoing_subnet = ifa->ifa_address & ifa->ifa_mask;
91 /* prop->ipv6_prefixes_cnt = 0; already done by memset before */
92 return 0;
93 } endfor_ifa(in_dev);
94 return -ENOENT;
95}
96
97/* fill CLC proposal msg with ipv6 prefixes from device */
98static int smc_clc_prfx_set6_rcu(struct dst_entry *dst,
99 struct smc_clc_msg_proposal_prefix *prop,
100 struct smc_clc_ipv6_prefix *ipv6_prfx)
101{
102#if IS_ENABLED(CONFIG_IPV6)
103 struct inet6_dev *in6_dev = __in6_dev_get(dst->dev);
104 struct inet6_ifaddr *ifa;
105 int cnt = 0;
106
107 if (!in6_dev)
108 return -ENODEV;
109 /* use a maximum of 8 IPv6 prefixes from device */
110 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
111 if (ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)
112 continue;
113 ipv6_addr_prefix(&ipv6_prfx[cnt].prefix,
114 &ifa->addr, ifa->prefix_len);
115 ipv6_prfx[cnt].prefix_len = ifa->prefix_len;
116 cnt++;
117 if (cnt == SMC_CLC_MAX_V6_PREFIX)
118 break;
119 }
120 prop->ipv6_prefixes_cnt = cnt;
121 if (cnt)
122 return 0;
123#endif
124 return -ENOENT;
125}
126
127/* retrieve and set prefixes in CLC proposal msg */
128static int smc_clc_prfx_set(struct socket *clcsock,
129 struct smc_clc_msg_proposal_prefix *prop,
130 struct smc_clc_ipv6_prefix *ipv6_prfx)
131{
132 struct dst_entry *dst = sk_dst_get(clcsock->sk);
133 struct sockaddr_storage addrs;
134 struct sockaddr_in6 *addr6;
135 struct sockaddr_in *addr;
136 int rc = -ENOENT;
137
138 memset(prop, 0, sizeof(*prop));
139 if (!dst) {
140 rc = -ENOTCONN;
141 goto out;
142 }
143 if (!dst->dev) {
144 rc = -ENODEV;
145 goto out_rel;
146 }
147 /* get address to which the internal TCP socket is bound */
148 kernel_getsockname(clcsock, (struct sockaddr *)&addrs);
149 /* analyze IP specific data of net_device belonging to TCP socket */
150 addr6 = (struct sockaddr_in6 *)&addrs;
151 rcu_read_lock();
152 if (addrs.ss_family == PF_INET) {
153 /* IPv4 */
154 addr = (struct sockaddr_in *)&addrs;
155 rc = smc_clc_prfx_set4_rcu(dst, addr->sin_addr.s_addr, prop);
156 } else if (ipv6_addr_v4mapped(&addr6->sin6_addr)) {
157 /* mapped IPv4 address - peer is IPv4 only */
158 rc = smc_clc_prfx_set4_rcu(dst, addr6->sin6_addr.s6_addr32[3],
159 prop);
160 } else {
161 /* IPv6 */
162 rc = smc_clc_prfx_set6_rcu(dst, prop, ipv6_prfx);
163 }
164 rcu_read_unlock();
165out_rel:
166 dst_release(dst);
167out:
168 return rc;
169}
170
171/* match ipv4 addrs of dev against addr in CLC proposal */
172static int smc_clc_prfx_match4_rcu(struct net_device *dev,
173 struct smc_clc_msg_proposal_prefix *prop)
174{
175 struct in_device *in_dev = __in_dev_get_rcu(dev);
176
177 if (!in_dev)
178 return -ENODEV;
179 for_ifa(in_dev) {
180 if (prop->prefix_len == inet_mask_len(ifa->ifa_mask) &&
181 inet_ifa_match(prop->outgoing_subnet, ifa))
182 return 0;
183 } endfor_ifa(in_dev);
184
185 return -ENOENT;
186}
187
188/* match ipv6 addrs of dev against addrs in CLC proposal */
189static int smc_clc_prfx_match6_rcu(struct net_device *dev,
190 struct smc_clc_msg_proposal_prefix *prop)
191{
192#if IS_ENABLED(CONFIG_IPV6)
193 struct inet6_dev *in6_dev = __in6_dev_get(dev);
194 struct smc_clc_ipv6_prefix *ipv6_prfx;
195 struct inet6_ifaddr *ifa;
196 int i, max;
197
198 if (!in6_dev)
199 return -ENODEV;
200 /* ipv6 prefix list starts behind smc_clc_msg_proposal_prefix */
201 ipv6_prfx = (struct smc_clc_ipv6_prefix *)((u8 *)prop + sizeof(*prop));
202 max = min_t(u8, prop->ipv6_prefixes_cnt, SMC_CLC_MAX_V6_PREFIX);
203 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
204 if (ipv6_addr_type(&ifa->addr) & IPV6_ADDR_LINKLOCAL)
205 continue;
206 for (i = 0; i < max; i++) {
207 if (ifa->prefix_len == ipv6_prfx[i].prefix_len &&
208 ipv6_prefix_equal(&ifa->addr, &ipv6_prfx[i].prefix,
209 ifa->prefix_len))
210 return 0;
211 }
212 }
213#endif
214 return -ENOENT;
215}
216
217/* check if proposed prefixes match one of our device prefixes */
218int smc_clc_prfx_match(struct socket *clcsock,
219 struct smc_clc_msg_proposal_prefix *prop)
220{
221 struct dst_entry *dst = sk_dst_get(clcsock->sk);
222 int rc;
223
224 if (!dst) {
225 rc = -ENOTCONN;
226 goto out;
227 }
228 if (!dst->dev) {
229 rc = -ENODEV;
230 goto out_rel;
231 }
232 rcu_read_lock();
233 if (!prop->ipv6_prefixes_cnt)
234 rc = smc_clc_prfx_match4_rcu(dst->dev, prop);
235 else
236 rc = smc_clc_prfx_match6_rcu(dst->dev, prop);
237 rcu_read_unlock();
238out_rel:
239 dst_release(dst);
240out:
241 return rc;
242}
243
244/* Wait for data on the tcp-socket, analyze received data
245 * Returns:
246 * 0 if success and it was not a decline that we received.
247 * SMC_CLC_DECL_REPLY if decline received for fallback w/o another decl send.
248 * clcsock error, -EINTR, -ECONNRESET, -EPROTO otherwise.
249 */
250int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
251 u8 expected_type)
252{
253 struct sock *clc_sk = smc->clcsock->sk;
254 struct smc_clc_msg_hdr *clcm = buf;
255 struct msghdr msg = {NULL, 0};
256 int reason_code = 0;
257 struct kvec vec = {buf, buflen};
258 int len, datlen;
259 int krflags;
260
261 /* peek the first few bytes to determine length of data to receive
262 * so we don't consume any subsequent CLC message or payload data
263 * in the TCP byte stream
264 */
265 /*
266 * Caller must make sure that buflen is no less than
267 * sizeof(struct smc_clc_msg_hdr)
268 */
269 krflags = MSG_PEEK | MSG_WAITALL;
270 smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
271 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1,
272 sizeof(struct smc_clc_msg_hdr));
273 len = sock_recvmsg(smc->clcsock, &msg, krflags);
274 if (signal_pending(current)) {
275 reason_code = -EINTR;
276 clc_sk->sk_err = EINTR;
277 smc->sk.sk_err = EINTR;
278 goto out;
279 }
280 if (clc_sk->sk_err) {
281 reason_code = -clc_sk->sk_err;
282 smc->sk.sk_err = clc_sk->sk_err;
283 goto out;
284 }
285 if (!len) { /* peer has performed orderly shutdown */
286 smc->sk.sk_err = ECONNRESET;
287 reason_code = -ECONNRESET;
288 goto out;
289 }
290 if (len < 0) {
291 smc->sk.sk_err = -len;
292 reason_code = len;
293 goto out;
294 }
295 datlen = ntohs(clcm->length);
296 if ((len < sizeof(struct smc_clc_msg_hdr)) ||
297 (datlen > buflen) ||
298 ((clcm->type != SMC_CLC_DECLINE) &&
299 (clcm->type != expected_type))) {
300 smc->sk.sk_err = EPROTO;
301 reason_code = -EPROTO;
302 goto out;
303 }
304
305 /* receive the complete CLC message */
306 memset(&msg, 0, sizeof(struct msghdr));
307 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &vec, 1, datlen);
308 krflags = MSG_WAITALL;
309 smc->clcsock->sk->sk_rcvtimeo = CLC_WAIT_TIME;
310 len = sock_recvmsg(smc->clcsock, &msg, krflags);
311 if (len < datlen || !smc_clc_msg_hdr_valid(clcm)) {
312 smc->sk.sk_err = EPROTO;
313 reason_code = -EPROTO;
314 goto out;
315 }
316 if (clcm->type == SMC_CLC_DECLINE) {
317 reason_code = SMC_CLC_DECL_REPLY;
318 if (((struct smc_clc_msg_decline *)buf)->hdr.flag) {
319 smc->conn.lgr->sync_err = true;
320 smc_lgr_terminate(smc->conn.lgr);
321 }
322 }
323
324out:
325 return reason_code;
326}
327
328/* send CLC DECLINE message across internal TCP socket */
329int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info)
330{
331 struct smc_clc_msg_decline dclc;
332 struct msghdr msg;
333 struct kvec vec;
334 int len;
335
336 memset(&dclc, 0, sizeof(dclc));
337 memcpy(dclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
338 dclc.hdr.type = SMC_CLC_DECLINE;
339 dclc.hdr.length = htons(sizeof(struct smc_clc_msg_decline));
340 dclc.hdr.version = SMC_CLC_V1;
341 dclc.hdr.flag = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ? 1 : 0;
342 memcpy(dclc.id_for_peer, local_systemid, sizeof(local_systemid));
343 dclc.peer_diagnosis = htonl(peer_diag_info);
344 memcpy(dclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
345
346 memset(&msg, 0, sizeof(msg));
347 vec.iov_base = &dclc;
348 vec.iov_len = sizeof(struct smc_clc_msg_decline);
349 len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
350 sizeof(struct smc_clc_msg_decline));
351 if (len < sizeof(struct smc_clc_msg_decline))
352 smc->sk.sk_err = EPROTO;
353 if (len < 0)
354 smc->sk.sk_err = -len;
355 return sock_error(&smc->sk);
356}
357
358/* send CLC PROPOSAL message across internal TCP socket */
359int smc_clc_send_proposal(struct smc_sock *smc,
360 struct smc_ib_device *smcibdev,
361 u8 ibport)
362{
363 struct smc_clc_ipv6_prefix ipv6_prfx[SMC_CLC_MAX_V6_PREFIX];
364 struct smc_clc_msg_proposal_prefix pclc_prfx;
365 struct smc_clc_msg_proposal pclc;
366 struct smc_clc_msg_trail trl;
367 int len, i, plen, rc;
368 int reason_code = 0;
369 struct kvec vec[4];
370 struct msghdr msg;
371
372 /* retrieve ip prefixes for CLC proposal msg */
373 rc = smc_clc_prfx_set(smc->clcsock, &pclc_prfx, ipv6_prfx);
374 if (rc)
375 return SMC_CLC_DECL_CNFERR; /* configuration error */
376
377 /* send SMC Proposal CLC message */
378 plen = sizeof(pclc) + sizeof(pclc_prfx) +
379 (pclc_prfx.ipv6_prefixes_cnt * sizeof(ipv6_prfx[0])) +
380 sizeof(trl);
381 memset(&pclc, 0, sizeof(pclc));
382 memcpy(pclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
383 pclc.hdr.type = SMC_CLC_PROPOSAL;
384 pclc.hdr.length = htons(plen);
385 pclc.hdr.version = SMC_CLC_V1; /* SMC version */
386 memcpy(pclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
387 memcpy(&pclc.lcl.gid, &smcibdev->gid[ibport - 1], SMC_GID_SIZE);
388 memcpy(&pclc.lcl.mac, &smcibdev->mac[ibport - 1], ETH_ALEN);
389 pclc.iparea_offset = htons(0);
390
391 memcpy(trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
392 memset(&msg, 0, sizeof(msg));
393 i = 0;
394 vec[i].iov_base = &pclc;
395 vec[i++].iov_len = sizeof(pclc);
396 vec[i].iov_base = &pclc_prfx;
397 vec[i++].iov_len = sizeof(pclc_prfx);
398 if (pclc_prfx.ipv6_prefixes_cnt > 0) {
399 vec[i].iov_base = &ipv6_prfx[0];
400 vec[i++].iov_len = pclc_prfx.ipv6_prefixes_cnt *
401 sizeof(ipv6_prfx[0]);
402 }
403 vec[i].iov_base = &trl;
404 vec[i++].iov_len = sizeof(trl);
405 /* due to the few bytes needed for clc-handshake this cannot block */
406 len = kernel_sendmsg(smc->clcsock, &msg, vec, i, plen);
407 if (len < sizeof(pclc)) {
408 if (len >= 0) {
409 reason_code = -ENETUNREACH;
410 smc->sk.sk_err = -reason_code;
411 } else {
412 smc->sk.sk_err = smc->clcsock->sk->sk_err;
413 reason_code = -smc->sk.sk_err;
414 }
415 }
416
417 return reason_code;
418}
419
420/* send CLC CONFIRM message across internal TCP socket */
421int smc_clc_send_confirm(struct smc_sock *smc)
422{
423 struct smc_connection *conn = &smc->conn;
424 struct smc_clc_msg_accept_confirm cclc;
425 struct smc_link *link;
426 int reason_code = 0;
427 struct msghdr msg;
428 struct kvec vec;
429 int len;
430
431 link = &conn->lgr->lnk[SMC_SINGLE_LINK];
432 /* send SMC Confirm CLC msg */
433 memset(&cclc, 0, sizeof(cclc));
434 memcpy(cclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
435 cclc.hdr.type = SMC_CLC_CONFIRM;
436 cclc.hdr.length = htons(sizeof(cclc));
437 cclc.hdr.version = SMC_CLC_V1; /* SMC version */
438 memcpy(cclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
439 memcpy(&cclc.lcl.gid, &link->smcibdev->gid[link->ibport - 1],
440 SMC_GID_SIZE);
441 memcpy(&cclc.lcl.mac, &link->smcibdev->mac[link->ibport - 1], ETH_ALEN);
442 hton24(cclc.qpn, link->roce_qp->qp_num);
443 cclc.rmb_rkey =
444 htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
445 cclc.conn_idx = 1; /* for now: 1 RMB = 1 RMBE */
446 cclc.rmbe_alert_token = htonl(conn->alert_token_local);
447 cclc.qp_mtu = min(link->path_mtu, link->peer_mtu);
448 cclc.rmbe_size = conn->rmbe_size_short;
449 cclc.rmb_dma_addr = cpu_to_be64(
450 (u64)sg_dma_address(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
451 hton24(cclc.psn, link->psn_initial);
452
453 memcpy(cclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
454
455 memset(&msg, 0, sizeof(msg));
456 vec.iov_base = &cclc;
457 vec.iov_len = sizeof(cclc);
458 len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1, sizeof(cclc));
459 if (len < sizeof(cclc)) {
460 if (len >= 0) {
461 reason_code = -ENETUNREACH;
462 smc->sk.sk_err = -reason_code;
463 } else {
464 smc->sk.sk_err = smc->clcsock->sk->sk_err;
465 reason_code = -smc->sk.sk_err;
466 }
467 }
468 return reason_code;
469}
470
471/* send CLC ACCEPT message across internal TCP socket */
472int smc_clc_send_accept(struct smc_sock *new_smc, int srv_first_contact)
473{
474 struct smc_connection *conn = &new_smc->conn;
475 struct smc_clc_msg_accept_confirm aclc;
476 struct smc_link *link;
477 struct msghdr msg;
478 struct kvec vec;
479 int rc = 0;
480 int len;
481
482 link = &conn->lgr->lnk[SMC_SINGLE_LINK];
483 memset(&aclc, 0, sizeof(aclc));
484 memcpy(aclc.hdr.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
485 aclc.hdr.type = SMC_CLC_ACCEPT;
486 aclc.hdr.length = htons(sizeof(aclc));
487 aclc.hdr.version = SMC_CLC_V1; /* SMC version */
488 if (srv_first_contact)
489 aclc.hdr.flag = 1;
490 memcpy(aclc.lcl.id_for_peer, local_systemid, sizeof(local_systemid));
491 memcpy(&aclc.lcl.gid, &link->smcibdev->gid[link->ibport - 1],
492 SMC_GID_SIZE);
493 memcpy(&aclc.lcl.mac, link->smcibdev->mac[link->ibport - 1], ETH_ALEN);
494 hton24(aclc.qpn, link->roce_qp->qp_num);
495 aclc.rmb_rkey =
496 htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);
497 aclc.conn_idx = 1; /* as long as 1 RMB = 1 RMBE */
498 aclc.rmbe_alert_token = htonl(conn->alert_token_local);
499 aclc.qp_mtu = link->path_mtu;
500 aclc.rmbe_size = conn->rmbe_size_short,
501 aclc.rmb_dma_addr = cpu_to_be64(
502 (u64)sg_dma_address(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));
503 hton24(aclc.psn, link->psn_initial);
504 memcpy(aclc.trl.eyecatcher, SMC_EYECATCHER, sizeof(SMC_EYECATCHER));
505
506 memset(&msg, 0, sizeof(msg));
507 vec.iov_base = &aclc;
508 vec.iov_len = sizeof(aclc);
509 len = kernel_sendmsg(new_smc->clcsock, &msg, &vec, 1, sizeof(aclc));
510 if (len < sizeof(aclc)) {
511 if (len >= 0)
512 new_smc->sk.sk_err = EPROTO;
513 else
514 new_smc->sk.sk_err = new_smc->clcsock->sk->sk_err;
515 rc = sock_error(&new_smc->sk);
516 }
517
518 return rc;
519}