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 * Link Layer Control (LLC)
6 *
7 * Copyright IBM Corp. 2016
8 *
9 * Author(s): Klaus Wacker <Klaus.Wacker@de.ibm.com>
10 * Ursula Braun <ubraun@linux.vnet.ibm.com>
11 */
12
13#include <net/tcp.h>
14#include <rdma/ib_verbs.h>
15
16#include "smc.h"
17#include "smc_core.h"
18#include "smc_clc.h"
19#include "smc_llc.h"
20
21#define SMC_LLC_DATA_LEN 40
22
23struct smc_llc_hdr {
24 struct smc_wr_rx_hdr common;
25 u8 length; /* 44 */
26#if defined(__BIG_ENDIAN_BITFIELD)
27 u8 reserved:4,
28 add_link_rej_rsn:4;
29#elif defined(__LITTLE_ENDIAN_BITFIELD)
30 u8 add_link_rej_rsn:4,
31 reserved:4;
32#endif
33 u8 flags;
34};
35
36#define SMC_LLC_FLAG_NO_RMBE_EYEC 0x03
37
38struct smc_llc_msg_confirm_link { /* type 0x01 */
39 struct smc_llc_hdr hd;
40 u8 sender_mac[ETH_ALEN];
41 u8 sender_gid[SMC_GID_SIZE];
42 u8 sender_qp_num[3];
43 u8 link_num;
44 u8 link_uid[SMC_LGR_ID_SIZE];
45 u8 max_links;
46 u8 reserved[9];
47};
48
49#define SMC_LLC_FLAG_ADD_LNK_REJ 0x40
50#define SMC_LLC_REJ_RSN_NO_ALT_PATH 1
51
52#define SMC_LLC_ADD_LNK_MAX_LINKS 2
53
54struct smc_llc_msg_add_link { /* type 0x02 */
55 struct smc_llc_hdr hd;
56 u8 sender_mac[ETH_ALEN];
57 u8 reserved2[2];
58 u8 sender_gid[SMC_GID_SIZE];
59 u8 sender_qp_num[3];
60 u8 link_num;
61 u8 flags2; /* QP mtu */
62 u8 initial_psn[3];
63 u8 reserved[8];
64};
65
66#define SMC_LLC_FLAG_DEL_LINK_ALL 0x40
67#define SMC_LLC_FLAG_DEL_LINK_ORDERLY 0x20
68
69struct smc_llc_msg_del_link { /* type 0x04 */
70 struct smc_llc_hdr hd;
71 u8 link_num;
72 __be32 reason;
73 u8 reserved[35];
74} __packed; /* format defined in RFC7609 */
75
76struct smc_llc_msg_test_link { /* type 0x07 */
77 struct smc_llc_hdr hd;
78 u8 user_data[16];
79 u8 reserved[24];
80};
81
82struct smc_rmb_rtoken {
83 union {
84 u8 num_rkeys; /* first rtoken byte of CONFIRM LINK msg */
85 /* is actually the num of rtokens, first */
86 /* rtoken is always for the current link */
87 u8 link_id; /* link id of the rtoken */
88 };
89 __be32 rmb_key;
90 __be64 rmb_vaddr;
91} __packed; /* format defined in RFC7609 */
92
93#define SMC_LLC_RKEYS_PER_MSG 3
94
95struct smc_llc_msg_confirm_rkey { /* type 0x06 */
96 struct smc_llc_hdr hd;
97 struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
98 u8 reserved;
99};
100
101struct smc_llc_msg_confirm_rkey_cont { /* type 0x08 */
102 struct smc_llc_hdr hd;
103 u8 num_rkeys;
104 struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
105};
106
107#define SMC_LLC_DEL_RKEY_MAX 8
108#define SMC_LLC_FLAG_RKEY_NEG 0x20
109
110struct smc_llc_msg_delete_rkey { /* type 0x09 */
111 struct smc_llc_hdr hd;
112 u8 num_rkeys;
113 u8 err_mask;
114 u8 reserved[2];
115 __be32 rkey[8];
116 u8 reserved2[4];
117};
118
119union smc_llc_msg {
120 struct smc_llc_msg_confirm_link confirm_link;
121 struct smc_llc_msg_add_link add_link;
122 struct smc_llc_msg_del_link delete_link;
123
124 struct smc_llc_msg_confirm_rkey confirm_rkey;
125 struct smc_llc_msg_confirm_rkey_cont confirm_rkey_cont;
126 struct smc_llc_msg_delete_rkey delete_rkey;
127
128 struct smc_llc_msg_test_link test_link;
129 struct {
130 struct smc_llc_hdr hdr;
131 u8 data[SMC_LLC_DATA_LEN];
132 } raw;
133};
134
135#define SMC_LLC_FLAG_RESP 0x80
136
137/********************************** send *************************************/
138
139struct smc_llc_tx_pend {
140};
141
142/* handler for send/transmission completion of an LLC msg */
143static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
144 struct smc_link *link,
145 enum ib_wc_status wc_status)
146{
147 /* future work: handle wc_status error for recovery and failover */
148}
149
150/**
151 * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
152 * @link: Pointer to SMC link used for sending LLC control message.
153 * @wr_buf: Out variable returning pointer to work request payload buffer.
154 * @pend: Out variable returning pointer to private pending WR tracking.
155 * It's the context the transmit complete handler will get.
156 *
157 * Reserves and pre-fills an entry for a pending work request send/tx.
158 * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
159 * Can sleep due to smc_get_ctrl_buf (if not in softirq context).
160 *
161 * Return: 0 on success, otherwise an error value.
162 */
163static int smc_llc_add_pending_send(struct smc_link *link,
164 struct smc_wr_buf **wr_buf,
165 struct smc_wr_tx_pend_priv **pend)
166{
167 int rc;
168
169 rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, pend);
170 if (rc < 0)
171 return rc;
172 BUILD_BUG_ON_MSG(
173 sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
174 "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
175 BUILD_BUG_ON_MSG(
176 sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
177 "must adapt SMC_WR_TX_SIZE to sizeof(struct smc_llc_msg); if not all smc_wr upper layer protocols use the same message size any more, must start to set link->wr_tx_sges[i].length on each individual smc_wr_tx_send()");
178 BUILD_BUG_ON_MSG(
179 sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
180 "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
181 return 0;
182}
183
184/* high-level API to send LLC confirm link */
185int smc_llc_send_confirm_link(struct smc_link *link, u8 mac[],
186 union ib_gid *gid,
187 enum smc_llc_reqresp reqresp)
188{
189 struct smc_link_group *lgr = container_of(link, struct smc_link_group,
190 lnk[SMC_SINGLE_LINK]);
191 struct smc_llc_msg_confirm_link *confllc;
192 struct smc_wr_tx_pend_priv *pend;
193 struct smc_wr_buf *wr_buf;
194 int rc;
195
196 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
197 if (rc)
198 return rc;
199 confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
200 memset(confllc, 0, sizeof(*confllc));
201 confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
202 confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
203 confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC;
204 if (reqresp == SMC_LLC_RESP)
205 confllc->hd.flags |= SMC_LLC_FLAG_RESP;
206 memcpy(confllc->sender_mac, mac, ETH_ALEN);
207 memcpy(confllc->sender_gid, gid, SMC_GID_SIZE);
208 hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
209 confllc->link_num = link->link_id;
210 memcpy(confllc->link_uid, lgr->id, SMC_LGR_ID_SIZE);
211 confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS; /* enforce peer resp. */
212 /* send llc message */
213 rc = smc_wr_tx_send(link, pend);
214 return rc;
215}
216
217/* send ADD LINK request or response */
218int smc_llc_send_add_link(struct smc_link *link, u8 mac[],
219 union ib_gid *gid,
220 enum smc_llc_reqresp reqresp)
221{
222 struct smc_llc_msg_add_link *addllc;
223 struct smc_wr_tx_pend_priv *pend;
224 struct smc_wr_buf *wr_buf;
225 int rc;
226
227 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
228 if (rc)
229 return rc;
230 addllc = (struct smc_llc_msg_add_link *)wr_buf;
231 memset(addllc, 0, sizeof(*addllc));
232 addllc->hd.common.type = SMC_LLC_ADD_LINK;
233 addllc->hd.length = sizeof(struct smc_llc_msg_add_link);
234 if (reqresp == SMC_LLC_RESP) {
235 addllc->hd.flags |= SMC_LLC_FLAG_RESP;
236 /* always reject more links for now */
237 addllc->hd.flags |= SMC_LLC_FLAG_ADD_LNK_REJ;
238 addllc->hd.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH;
239 }
240 memcpy(addllc->sender_mac, mac, ETH_ALEN);
241 memcpy(addllc->sender_gid, gid, SMC_GID_SIZE);
242 /* send llc message */
243 rc = smc_wr_tx_send(link, pend);
244 return rc;
245}
246
247/* send DELETE LINK request or response */
248int smc_llc_send_delete_link(struct smc_link *link,
249 enum smc_llc_reqresp reqresp)
250{
251 struct smc_llc_msg_del_link *delllc;
252 struct smc_wr_tx_pend_priv *pend;
253 struct smc_wr_buf *wr_buf;
254 int rc;
255
256 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
257 if (rc)
258 return rc;
259 delllc = (struct smc_llc_msg_del_link *)wr_buf;
260 memset(delllc, 0, sizeof(*delllc));
261 delllc->hd.common.type = SMC_LLC_DELETE_LINK;
262 delllc->hd.length = sizeof(struct smc_llc_msg_add_link);
263 if (reqresp == SMC_LLC_RESP)
264 delllc->hd.flags |= SMC_LLC_FLAG_RESP;
265 /* DEL_LINK_ALL because only 1 link supported */
266 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
267 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
268 delllc->link_num = link->link_id;
269 /* send llc message */
270 rc = smc_wr_tx_send(link, pend);
271 return rc;
272}
273
274/* send LLC test link request or response */
275int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16],
276 enum smc_llc_reqresp reqresp)
277{
278 struct smc_llc_msg_test_link *testllc;
279 struct smc_wr_tx_pend_priv *pend;
280 struct smc_wr_buf *wr_buf;
281 int rc;
282
283 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
284 if (rc)
285 return rc;
286 testllc = (struct smc_llc_msg_test_link *)wr_buf;
287 memset(testllc, 0, sizeof(*testllc));
288 testllc->hd.common.type = SMC_LLC_TEST_LINK;
289 testllc->hd.length = sizeof(struct smc_llc_msg_test_link);
290 if (reqresp == SMC_LLC_RESP)
291 testllc->hd.flags |= SMC_LLC_FLAG_RESP;
292 memcpy(testllc->user_data, user_data, sizeof(testllc->user_data));
293 /* send llc message */
294 rc = smc_wr_tx_send(link, pend);
295 return rc;
296}
297
298/* send a prepared message */
299static int smc_llc_send_message(struct smc_link *link, void *llcbuf, int llclen)
300{
301 struct smc_wr_tx_pend_priv *pend;
302 struct smc_wr_buf *wr_buf;
303 int rc;
304
305 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
306 if (rc)
307 return rc;
308 memcpy(wr_buf, llcbuf, llclen);
309 /* send llc message */
310 rc = smc_wr_tx_send(link, pend);
311 return rc;
312}
313
314/********************************* receive ***********************************/
315
316static void smc_llc_rx_confirm_link(struct smc_link *link,
317 struct smc_llc_msg_confirm_link *llc)
318{
319 struct smc_link_group *lgr;
320 int conf_rc;
321
322 lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
323
324 /* RMBE eyecatchers are not supported */
325 if (llc->hd.flags & SMC_LLC_FLAG_NO_RMBE_EYEC)
326 conf_rc = 0;
327 else
328 conf_rc = ENOTSUPP;
329
330 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
331 if (lgr->role == SMC_SERV &&
332 link->state == SMC_LNK_ACTIVATING) {
333 link->llc_confirm_resp_rc = conf_rc;
334 complete(&link->llc_confirm_resp);
335 }
336 } else {
337 if (lgr->role == SMC_CLNT &&
338 link->state == SMC_LNK_ACTIVATING) {
339 link->llc_confirm_rc = conf_rc;
340 link->link_id = llc->link_num;
341 complete(&link->llc_confirm);
342 }
343 }
344}
345
346static void smc_llc_rx_add_link(struct smc_link *link,
347 struct smc_llc_msg_add_link *llc)
348{
349 struct smc_link_group *lgr = container_of(link, struct smc_link_group,
350 lnk[SMC_SINGLE_LINK]);
351
352 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
353 if (link->state == SMC_LNK_ACTIVATING)
354 complete(&link->llc_add_resp);
355 } else {
356 if (link->state == SMC_LNK_ACTIVATING) {
357 complete(&link->llc_add);
358 return;
359 }
360
361 if (lgr->role == SMC_SERV) {
362 smc_llc_send_add_link(link,
363 link->smcibdev->mac[link->ibport - 1],
364 &link->smcibdev->gid[link->ibport - 1],
365 SMC_LLC_REQ);
366
367 } else {
368 smc_llc_send_add_link(link,
369 link->smcibdev->mac[link->ibport - 1],
370 &link->smcibdev->gid[link->ibport - 1],
371 SMC_LLC_RESP);
372 }
373 }
374}
375
376static void smc_llc_rx_delete_link(struct smc_link *link,
377 struct smc_llc_msg_del_link *llc)
378{
379 struct smc_link_group *lgr = container_of(link, struct smc_link_group,
380 lnk[SMC_SINGLE_LINK]);
381
382 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
383 if (lgr->role == SMC_SERV)
384 smc_lgr_terminate(lgr);
385 } else {
386 if (lgr->role == SMC_SERV) {
387 smc_lgr_forget(lgr);
388 smc_llc_send_delete_link(link, SMC_LLC_REQ);
389 } else {
390 smc_llc_send_delete_link(link, SMC_LLC_RESP);
391 smc_lgr_terminate(lgr);
392 }
393 }
394}
395
396static void smc_llc_rx_test_link(struct smc_link *link,
397 struct smc_llc_msg_test_link *llc)
398{
399 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
400 /* unused as long as we don't send this type of msg */
401 } else {
402 smc_llc_send_test_link(link, llc->user_data, SMC_LLC_RESP);
403 }
404}
405
406static void smc_llc_rx_confirm_rkey(struct smc_link *link,
407 struct smc_llc_msg_confirm_rkey *llc)
408{
409 struct smc_link_group *lgr;
410 int rc;
411
412 lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
413
414 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
415 /* unused as long as we don't send this type of msg */
416 } else {
417 rc = smc_rtoken_add(lgr,
418 llc->rtoken[0].rmb_vaddr,
419 llc->rtoken[0].rmb_key);
420
421 /* ignore rtokens for other links, we have only one link */
422
423 llc->hd.flags |= SMC_LLC_FLAG_RESP;
424 if (rc < 0)
425 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
426 smc_llc_send_message(link, (void *)llc, sizeof(*llc));
427 }
428}
429
430static void smc_llc_rx_confirm_rkey_cont(struct smc_link *link,
431 struct smc_llc_msg_confirm_rkey_cont *llc)
432{
433 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
434 /* unused as long as we don't send this type of msg */
435 } else {
436 /* ignore rtokens for other links, we have only one link */
437 llc->hd.flags |= SMC_LLC_FLAG_RESP;
438 smc_llc_send_message(link, (void *)llc, sizeof(*llc));
439 }
440}
441
442static void smc_llc_rx_delete_rkey(struct smc_link *link,
443 struct smc_llc_msg_delete_rkey *llc)
444{
445 struct smc_link_group *lgr;
446 u8 err_mask = 0;
447 int i, max;
448
449 lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
450
451 if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
452 /* unused as long as we don't send this type of msg */
453 } else {
454 max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX);
455 for (i = 0; i < max; i++) {
456 if (smc_rtoken_delete(lgr, llc->rkey[i]))
457 err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i);
458 }
459
460 if (err_mask) {
461 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
462 llc->err_mask = err_mask;
463 }
464
465 llc->hd.flags |= SMC_LLC_FLAG_RESP;
466 smc_llc_send_message(link, (void *)llc, sizeof(*llc));
467 }
468}
469
470static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
471{
472 struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
473 union smc_llc_msg *llc = buf;
474
475 if (wc->byte_len < sizeof(*llc))
476 return; /* short message */
477 if (llc->raw.hdr.length != sizeof(*llc))
478 return; /* invalid message */
479
480 switch (llc->raw.hdr.common.type) {
481 case SMC_LLC_TEST_LINK:
482 smc_llc_rx_test_link(link, &llc->test_link);
483 break;
484 case SMC_LLC_CONFIRM_LINK:
485 smc_llc_rx_confirm_link(link, &llc->confirm_link);
486 break;
487 case SMC_LLC_ADD_LINK:
488 smc_llc_rx_add_link(link, &llc->add_link);
489 break;
490 case SMC_LLC_DELETE_LINK:
491 smc_llc_rx_delete_link(link, &llc->delete_link);
492 break;
493 case SMC_LLC_CONFIRM_RKEY:
494 smc_llc_rx_confirm_rkey(link, &llc->confirm_rkey);
495 break;
496 case SMC_LLC_CONFIRM_RKEY_CONT:
497 smc_llc_rx_confirm_rkey_cont(link, &llc->confirm_rkey_cont);
498 break;
499 case SMC_LLC_DELETE_RKEY:
500 smc_llc_rx_delete_rkey(link, &llc->delete_rkey);
501 break;
502 }
503}
504
505/***************************** init, exit, misc ******************************/
506
507static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
508 {
509 .handler = smc_llc_rx_handler,
510 .type = SMC_LLC_CONFIRM_LINK
511 },
512 {
513 .handler = smc_llc_rx_handler,
514 .type = SMC_LLC_TEST_LINK
515 },
516 {
517 .handler = smc_llc_rx_handler,
518 .type = SMC_LLC_ADD_LINK
519 },
520 {
521 .handler = smc_llc_rx_handler,
522 .type = SMC_LLC_DELETE_LINK
523 },
524 {
525 .handler = smc_llc_rx_handler,
526 .type = SMC_LLC_CONFIRM_RKEY
527 },
528 {
529 .handler = smc_llc_rx_handler,
530 .type = SMC_LLC_CONFIRM_RKEY_CONT
531 },
532 {
533 .handler = smc_llc_rx_handler,
534 .type = SMC_LLC_DELETE_RKEY
535 },
536 {
537 .handler = NULL,
538 }
539};
540
541int __init smc_llc_init(void)
542{
543 struct smc_wr_rx_handler *handler;
544 int rc = 0;
545
546 for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
547 INIT_HLIST_NODE(&handler->list);
548 rc = smc_wr_rx_register_handler(handler);
549 if (rc)
550 break;
551 }
552 return rc;
553}