1 // SPDX-License-Identifier: GPL-2.0
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
5 * Link Layer Control (LLC)
7 * Copyright IBM Corp. 2016
9 * Author(s): Klaus Wacker <Klaus.Wacker@de.ibm.com>
10 * Ursula Braun <ubraun@linux.vnet.ibm.com>
14 #include <rdma/ib_verbs.h>
22 #define SMC_LLC_DATA_LEN 40
25 struct smc_wr_rx_hdr common;
27 #if defined(__BIG_ENDIAN_BITFIELD)
30 #elif defined(__LITTLE_ENDIAN_BITFIELD)
31 u8 add_link_rej_rsn:4,
37 #define SMC_LLC_FLAG_NO_RMBE_EYEC 0x03
39 struct smc_llc_msg_confirm_link { /* type 0x01 */
40 struct smc_llc_hdr hd;
41 u8 sender_mac[ETH_ALEN];
42 u8 sender_gid[SMC_GID_SIZE];
45 u8 link_uid[SMC_LGR_ID_SIZE];
50 #define SMC_LLC_FLAG_ADD_LNK_REJ 0x40
51 #define SMC_LLC_REJ_RSN_NO_ALT_PATH 1
53 #define SMC_LLC_ADD_LNK_MAX_LINKS 2
55 struct smc_llc_msg_add_link { /* type 0x02 */
56 struct smc_llc_hdr hd;
57 u8 sender_mac[ETH_ALEN];
59 u8 sender_gid[SMC_GID_SIZE];
62 #if defined(__BIG_ENDIAN_BITFIELD)
65 #elif defined(__LITTLE_ENDIAN_BITFIELD)
73 struct smc_llc_msg_add_link_cont_rt {
79 #define SMC_LLC_RKEYS_PER_CONT_MSG 2
81 struct smc_llc_msg_add_link_cont { /* type 0x03 */
82 struct smc_llc_hdr hd;
86 struct smc_llc_msg_add_link_cont_rt rt[SMC_LLC_RKEYS_PER_CONT_MSG];
88 } __packed; /* format defined in RFC7609 */
90 #define SMC_LLC_FLAG_DEL_LINK_ALL 0x40
91 #define SMC_LLC_FLAG_DEL_LINK_ORDERLY 0x20
93 struct smc_llc_msg_del_link { /* type 0x04 */
94 struct smc_llc_hdr hd;
98 } __packed; /* format defined in RFC7609 */
100 struct smc_llc_msg_test_link { /* type 0x07 */
101 struct smc_llc_hdr hd;
106 struct smc_rmb_rtoken {
108 u8 num_rkeys; /* first rtoken byte of CONFIRM LINK msg */
109 /* is actually the num of rtokens, first */
110 /* rtoken is always for the current link */
111 u8 link_id; /* link id of the rtoken */
115 } __packed; /* format defined in RFC7609 */
117 #define SMC_LLC_RKEYS_PER_MSG 3
119 struct smc_llc_msg_confirm_rkey { /* type 0x06 */
120 struct smc_llc_hdr hd;
121 struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
125 #define SMC_LLC_DEL_RKEY_MAX 8
126 #define SMC_LLC_FLAG_RKEY_RETRY 0x10
127 #define SMC_LLC_FLAG_RKEY_NEG 0x20
129 struct smc_llc_msg_delete_rkey { /* type 0x09 */
130 struct smc_llc_hdr hd;
139 struct smc_llc_msg_confirm_link confirm_link;
140 struct smc_llc_msg_add_link add_link;
141 struct smc_llc_msg_add_link_cont add_link_cont;
142 struct smc_llc_msg_del_link delete_link;
144 struct smc_llc_msg_confirm_rkey confirm_rkey;
145 struct smc_llc_msg_delete_rkey delete_rkey;
147 struct smc_llc_msg_test_link test_link;
149 struct smc_llc_hdr hdr;
150 u8 data[SMC_LLC_DATA_LEN];
154 #define SMC_LLC_FLAG_RESP 0x80
156 struct smc_llc_qentry {
157 struct list_head list;
158 struct smc_link *link;
159 union smc_llc_msg msg;
162 static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc);
164 struct smc_llc_qentry *smc_llc_flow_qentry_clr(struct smc_llc_flow *flow)
166 struct smc_llc_qentry *qentry = flow->qentry;
172 void smc_llc_flow_qentry_del(struct smc_llc_flow *flow)
174 struct smc_llc_qentry *qentry;
177 qentry = flow->qentry;
183 static inline void smc_llc_flow_qentry_set(struct smc_llc_flow *flow,
184 struct smc_llc_qentry *qentry)
186 flow->qentry = qentry;
189 static void smc_llc_flow_parallel(struct smc_link_group *lgr, u8 flow_type,
190 struct smc_llc_qentry *qentry)
192 u8 msg_type = qentry->msg.raw.hdr.common.type;
194 if ((msg_type == SMC_LLC_ADD_LINK || msg_type == SMC_LLC_DELETE_LINK) &&
195 flow_type != msg_type && !lgr->delayed_event) {
196 lgr->delayed_event = qentry;
199 /* drop parallel or already-in-progress llc requests */
200 if (flow_type != msg_type)
201 pr_warn_once("smc: SMC-R lg %*phN dropped parallel "
202 "LLC msg: msg %d flow %d role %d\n",
203 SMC_LGR_ID_SIZE, &lgr->id,
204 qentry->msg.raw.hdr.common.type,
205 flow_type, lgr->role);
209 /* try to start a new llc flow, initiated by an incoming llc msg */
210 static bool smc_llc_flow_start(struct smc_llc_flow *flow,
211 struct smc_llc_qentry *qentry)
213 struct smc_link_group *lgr = qentry->link->lgr;
215 spin_lock_bh(&lgr->llc_flow_lock);
217 /* a flow is already active */
218 smc_llc_flow_parallel(lgr, flow->type, qentry);
219 spin_unlock_bh(&lgr->llc_flow_lock);
222 switch (qentry->msg.raw.hdr.common.type) {
223 case SMC_LLC_ADD_LINK:
224 flow->type = SMC_LLC_FLOW_ADD_LINK;
226 case SMC_LLC_DELETE_LINK:
227 flow->type = SMC_LLC_FLOW_DEL_LINK;
229 case SMC_LLC_CONFIRM_RKEY:
230 case SMC_LLC_DELETE_RKEY:
231 flow->type = SMC_LLC_FLOW_RKEY;
234 flow->type = SMC_LLC_FLOW_NONE;
236 if (qentry == lgr->delayed_event)
237 lgr->delayed_event = NULL;
238 smc_llc_flow_qentry_set(flow, qentry);
239 spin_unlock_bh(&lgr->llc_flow_lock);
243 /* start a new local llc flow, wait till current flow finished */
244 int smc_llc_flow_initiate(struct smc_link_group *lgr,
245 enum smc_llc_flowtype type)
247 enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE;
250 /* all flows except confirm_rkey and delete_rkey are exclusive,
251 * confirm/delete rkey flows can run concurrently (local and remote)
253 if (type == SMC_LLC_FLOW_RKEY)
254 allowed_remote = SMC_LLC_FLOW_RKEY;
256 if (list_empty(&lgr->list))
258 spin_lock_bh(&lgr->llc_flow_lock);
259 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
260 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
261 lgr->llc_flow_rmt.type == allowed_remote)) {
262 lgr->llc_flow_lcl.type = type;
263 spin_unlock_bh(&lgr->llc_flow_lock);
266 spin_unlock_bh(&lgr->llc_flow_lock);
267 rc = wait_event_timeout(lgr->llc_flow_waiter, (list_empty(&lgr->list) ||
268 (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
269 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
270 lgr->llc_flow_rmt.type == allowed_remote))),
271 SMC_LLC_WAIT_TIME * 10);
277 /* finish the current llc flow */
278 void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow)
280 spin_lock_bh(&lgr->llc_flow_lock);
281 memset(flow, 0, sizeof(*flow));
282 flow->type = SMC_LLC_FLOW_NONE;
283 spin_unlock_bh(&lgr->llc_flow_lock);
284 if (!list_empty(&lgr->list) && lgr->delayed_event &&
285 flow == &lgr->llc_flow_lcl)
286 schedule_work(&lgr->llc_event_work);
288 wake_up(&lgr->llc_flow_waiter);
291 /* lnk is optional and used for early wakeup when link goes down, useful in
292 * cases where we wait for a response on the link after we sent a request
294 struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr,
295 struct smc_link *lnk,
296 int time_out, u8 exp_msg)
298 struct smc_llc_flow *flow = &lgr->llc_flow_lcl;
301 wait_event_timeout(lgr->llc_msg_waiter,
303 (lnk && !smc_link_usable(lnk)) ||
304 list_empty(&lgr->list)),
307 (lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) {
308 smc_llc_flow_qentry_del(flow);
311 rcv_msg = flow->qentry->msg.raw.hdr.common.type;
312 if (exp_msg && rcv_msg != exp_msg) {
313 if (exp_msg == SMC_LLC_ADD_LINK &&
314 rcv_msg == SMC_LLC_DELETE_LINK) {
315 /* flow_start will delay the unexpected msg */
316 smc_llc_flow_start(&lgr->llc_flow_lcl,
317 smc_llc_flow_qentry_clr(flow));
320 pr_warn_once("smc: SMC-R lg %*phN dropped unexpected LLC msg: "
321 "msg %d exp %d flow %d role %d flags %x\n",
322 SMC_LGR_ID_SIZE, &lgr->id, rcv_msg, exp_msg,
323 flow->type, lgr->role,
324 flow->qentry->msg.raw.hdr.flags);
325 smc_llc_flow_qentry_del(flow);
331 /********************************** send *************************************/
333 struct smc_llc_tx_pend {
336 /* handler for send/transmission completion of an LLC msg */
337 static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
338 struct smc_link *link,
339 enum ib_wc_status wc_status)
341 /* future work: handle wc_status error for recovery and failover */
345 * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
346 * @link: Pointer to SMC link used for sending LLC control message.
347 * @wr_buf: Out variable returning pointer to work request payload buffer.
348 * @pend: Out variable returning pointer to private pending WR tracking.
349 * It's the context the transmit complete handler will get.
351 * Reserves and pre-fills an entry for a pending work request send/tx.
352 * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
353 * Can sleep due to smc_get_ctrl_buf (if not in softirq context).
355 * Return: 0 on success, otherwise an error value.
357 static int smc_llc_add_pending_send(struct smc_link *link,
358 struct smc_wr_buf **wr_buf,
359 struct smc_wr_tx_pend_priv **pend)
363 rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL,
368 sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
369 "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
371 sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
372 "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()");
374 sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
375 "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
379 /* high-level API to send LLC confirm link */
380 int smc_llc_send_confirm_link(struct smc_link *link,
381 enum smc_llc_reqresp reqresp)
383 struct smc_llc_msg_confirm_link *confllc;
384 struct smc_wr_tx_pend_priv *pend;
385 struct smc_wr_buf *wr_buf;
388 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
391 confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
392 memset(confllc, 0, sizeof(*confllc));
393 confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
394 confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
395 confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC;
396 if (reqresp == SMC_LLC_RESP)
397 confllc->hd.flags |= SMC_LLC_FLAG_RESP;
398 memcpy(confllc->sender_mac, link->smcibdev->mac[link->ibport - 1],
400 memcpy(confllc->sender_gid, link->gid, SMC_GID_SIZE);
401 hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
402 confllc->link_num = link->link_id;
403 memcpy(confllc->link_uid, link->link_uid, SMC_LGR_ID_SIZE);
404 confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS;
405 /* send llc message */
406 rc = smc_wr_tx_send(link, pend);
410 /* send LLC confirm rkey request */
411 static int smc_llc_send_confirm_rkey(struct smc_link *send_link,
412 struct smc_buf_desc *rmb_desc)
414 struct smc_llc_msg_confirm_rkey *rkeyllc;
415 struct smc_wr_tx_pend_priv *pend;
416 struct smc_wr_buf *wr_buf;
417 struct smc_link *link;
420 rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend);
423 rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf;
424 memset(rkeyllc, 0, sizeof(*rkeyllc));
425 rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY;
426 rkeyllc->hd.length = sizeof(struct smc_llc_msg_confirm_rkey);
429 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
430 link = &send_link->lgr->lnk[i];
431 if (smc_link_active(link) && link != send_link) {
432 rkeyllc->rtoken[rtok_ix].link_id = link->link_id;
433 rkeyllc->rtoken[rtok_ix].rmb_key =
434 htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
435 rkeyllc->rtoken[rtok_ix].rmb_vaddr = cpu_to_be64(
437 rmb_desc->sgt[link->link_idx].sgl));
441 /* rkey of send_link is in rtoken[0] */
442 rkeyllc->rtoken[0].num_rkeys = rtok_ix - 1;
443 rkeyllc->rtoken[0].rmb_key =
444 htonl(rmb_desc->mr_rx[send_link->link_idx]->rkey);
445 rkeyllc->rtoken[0].rmb_vaddr = cpu_to_be64(
446 (u64)sg_dma_address(rmb_desc->sgt[send_link->link_idx].sgl));
447 /* send llc message */
448 rc = smc_wr_tx_send(send_link, pend);
452 /* send LLC delete rkey request */
453 static int smc_llc_send_delete_rkey(struct smc_link *link,
454 struct smc_buf_desc *rmb_desc)
456 struct smc_llc_msg_delete_rkey *rkeyllc;
457 struct smc_wr_tx_pend_priv *pend;
458 struct smc_wr_buf *wr_buf;
461 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
464 rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf;
465 memset(rkeyllc, 0, sizeof(*rkeyllc));
466 rkeyllc->hd.common.type = SMC_LLC_DELETE_RKEY;
467 rkeyllc->hd.length = sizeof(struct smc_llc_msg_delete_rkey);
468 rkeyllc->num_rkeys = 1;
469 rkeyllc->rkey[0] = htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
470 /* send llc message */
471 rc = smc_wr_tx_send(link, pend);
475 /* send ADD LINK request or response */
476 int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[],
477 struct smc_link *link_new,
478 enum smc_llc_reqresp reqresp)
480 struct smc_llc_msg_add_link *addllc;
481 struct smc_wr_tx_pend_priv *pend;
482 struct smc_wr_buf *wr_buf;
485 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
488 addllc = (struct smc_llc_msg_add_link *)wr_buf;
490 memset(addllc, 0, sizeof(*addllc));
491 addllc->hd.common.type = SMC_LLC_ADD_LINK;
492 addllc->hd.length = sizeof(struct smc_llc_msg_add_link);
493 if (reqresp == SMC_LLC_RESP)
494 addllc->hd.flags |= SMC_LLC_FLAG_RESP;
495 memcpy(addllc->sender_mac, mac, ETH_ALEN);
496 memcpy(addllc->sender_gid, gid, SMC_GID_SIZE);
498 addllc->link_num = link_new->link_id;
499 hton24(addllc->sender_qp_num, link_new->roce_qp->qp_num);
500 hton24(addllc->initial_psn, link_new->psn_initial);
501 if (reqresp == SMC_LLC_REQ)
502 addllc->qp_mtu = link_new->path_mtu;
504 addllc->qp_mtu = min(link_new->path_mtu,
507 /* send llc message */
508 rc = smc_wr_tx_send(link, pend);
512 /* send DELETE LINK request or response */
513 int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id,
514 enum smc_llc_reqresp reqresp, bool orderly,
517 struct smc_llc_msg_del_link *delllc;
518 struct smc_wr_tx_pend_priv *pend;
519 struct smc_wr_buf *wr_buf;
522 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
525 delllc = (struct smc_llc_msg_del_link *)wr_buf;
527 memset(delllc, 0, sizeof(*delllc));
528 delllc->hd.common.type = SMC_LLC_DELETE_LINK;
529 delllc->hd.length = sizeof(struct smc_llc_msg_del_link);
530 if (reqresp == SMC_LLC_RESP)
531 delllc->hd.flags |= SMC_LLC_FLAG_RESP;
533 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
535 delllc->link_num = link_del_id;
537 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
538 delllc->reason = htonl(reason);
539 /* send llc message */
540 rc = smc_wr_tx_send(link, pend);
544 /* send LLC test link request */
545 static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16])
547 struct smc_llc_msg_test_link *testllc;
548 struct smc_wr_tx_pend_priv *pend;
549 struct smc_wr_buf *wr_buf;
552 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
555 testllc = (struct smc_llc_msg_test_link *)wr_buf;
556 memset(testllc, 0, sizeof(*testllc));
557 testllc->hd.common.type = SMC_LLC_TEST_LINK;
558 testllc->hd.length = sizeof(struct smc_llc_msg_test_link);
559 memcpy(testllc->user_data, user_data, sizeof(testllc->user_data));
560 /* send llc message */
561 rc = smc_wr_tx_send(link, pend);
565 /* schedule an llc send on link, may wait for buffers */
566 static int smc_llc_send_message(struct smc_link *link, void *llcbuf)
568 struct smc_wr_tx_pend_priv *pend;
569 struct smc_wr_buf *wr_buf;
572 if (!smc_link_usable(link))
574 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
577 memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
578 return smc_wr_tx_send(link, pend);
581 /* schedule an llc send on link, may wait for buffers,
582 * and wait for send completion notification.
583 * @return 0 on success
585 static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf)
587 struct smc_wr_tx_pend_priv *pend;
588 struct smc_wr_buf *wr_buf;
591 if (!smc_link_usable(link))
593 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
596 memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
597 return smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME);
600 /********************************* receive ***********************************/
602 static int smc_llc_alloc_alt_link(struct smc_link_group *lgr,
603 enum smc_lgr_type lgr_new_t)
607 if (lgr->type == SMC_LGR_SYMMETRIC ||
608 (lgr->type != SMC_LGR_SINGLE &&
609 (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
610 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)))
613 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
614 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) {
615 for (i = SMC_LINKS_PER_LGR_MAX - 1; i >= 0; i--)
616 if (lgr->lnk[i].state == SMC_LNK_UNUSED)
619 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++)
620 if (lgr->lnk[i].state == SMC_LNK_UNUSED)
626 /* return first buffer from any of the next buf lists */
627 static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr,
630 struct smc_buf_desc *buf_pos;
632 while (*buf_lst < SMC_RMBE_SIZES) {
633 buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst],
634 struct smc_buf_desc, list);
642 /* return next rmb from buffer lists */
643 static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr,
645 struct smc_buf_desc *buf_pos)
647 struct smc_buf_desc *buf_next;
649 if (!buf_pos || list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) {
651 return _smc_llc_get_next_rmb(lgr, buf_lst);
653 buf_next = list_next_entry(buf_pos, list);
657 static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr,
661 return smc_llc_get_next_rmb(lgr, buf_lst, NULL);
664 /* send one add_link_continue msg */
665 static int smc_llc_add_link_cont(struct smc_link *link,
666 struct smc_link *link_new, u8 *num_rkeys_todo,
667 int *buf_lst, struct smc_buf_desc **buf_pos)
669 struct smc_llc_msg_add_link_cont *addc_llc;
670 struct smc_link_group *lgr = link->lgr;
671 int prim_lnk_idx, lnk_idx, i, rc;
672 struct smc_wr_tx_pend_priv *pend;
673 struct smc_wr_buf *wr_buf;
674 struct smc_buf_desc *rmb;
677 rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
680 addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf;
681 memset(addc_llc, 0, sizeof(*addc_llc));
683 prim_lnk_idx = link->link_idx;
684 lnk_idx = link_new->link_idx;
685 addc_llc->link_num = link_new->link_id;
686 addc_llc->num_rkeys = *num_rkeys_todo;
688 for (i = 0; i < min_t(u8, n, SMC_LLC_RKEYS_PER_CONT_MSG); i++) {
690 addc_llc->num_rkeys = addc_llc->num_rkeys -
697 addc_llc->rt[i].rmb_key = htonl(rmb->mr_rx[prim_lnk_idx]->rkey);
698 addc_llc->rt[i].rmb_key_new = htonl(rmb->mr_rx[lnk_idx]->rkey);
699 addc_llc->rt[i].rmb_vaddr_new =
700 cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl));
703 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
704 while (*buf_pos && !(*buf_pos)->used)
705 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
707 addc_llc->hd.common.type = SMC_LLC_ADD_LINK_CONT;
708 addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont);
709 if (lgr->role == SMC_CLNT)
710 addc_llc->hd.flags |= SMC_LLC_FLAG_RESP;
711 return smc_wr_tx_send(link, pend);
714 static int smc_llc_cli_rkey_exchange(struct smc_link *link,
715 struct smc_link *link_new)
717 struct smc_llc_msg_add_link_cont *addc_llc;
718 struct smc_link_group *lgr = link->lgr;
719 u8 max, num_rkeys_send, num_rkeys_recv;
720 struct smc_llc_qentry *qentry;
721 struct smc_buf_desc *buf_pos;
726 mutex_lock(&lgr->rmbs_lock);
727 num_rkeys_send = lgr->conns_num;
728 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
730 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME,
731 SMC_LLC_ADD_LINK_CONT);
736 addc_llc = &qentry->msg.add_link_cont;
737 num_rkeys_recv = addc_llc->num_rkeys;
738 max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
739 for (i = 0; i < max; i++) {
740 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
741 addc_llc->rt[i].rmb_key,
742 addc_llc->rt[i].rmb_vaddr_new,
743 addc_llc->rt[i].rmb_key_new);
746 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
747 rc = smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
751 } while (num_rkeys_send || num_rkeys_recv);
753 mutex_unlock(&lgr->rmbs_lock);
757 /* prepare and send an add link reject response */
758 static int smc_llc_cli_add_link_reject(struct smc_llc_qentry *qentry)
760 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
761 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_ADD_LNK_REJ;
762 qentry->msg.raw.hdr.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH;
763 return smc_llc_send_message(qentry->link, &qentry->msg);
766 static int smc_llc_cli_conf_link(struct smc_link *link,
767 struct smc_init_info *ini,
768 struct smc_link *link_new,
769 enum smc_lgr_type lgr_new_t)
771 struct smc_link_group *lgr = link->lgr;
772 struct smc_llc_qentry *qentry = NULL;
775 /* receive CONFIRM LINK request over RoCE fabric */
776 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0);
778 rc = smc_llc_send_delete_link(link, link_new->link_id,
780 SMC_LLC_DEL_LOST_PATH);
783 if (qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
784 /* received DELETE_LINK instead */
785 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
786 smc_llc_send_message(link, &qentry->msg);
787 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
790 smc_llc_save_peer_uid(qentry);
791 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
793 rc = smc_ib_modify_qp_rts(link_new);
795 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
796 false, SMC_LLC_DEL_LOST_PATH);
799 smc_wr_remember_qp_attr(link_new);
801 rc = smcr_buf_reg_lgr(link_new);
803 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
804 false, SMC_LLC_DEL_LOST_PATH);
808 /* send CONFIRM LINK response over RoCE fabric */
809 rc = smc_llc_send_confirm_link(link_new, SMC_LLC_RESP);
811 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
812 false, SMC_LLC_DEL_LOST_PATH);
815 smc_llc_link_active(link_new);
816 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
817 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
818 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
820 smcr_lgr_set_type(lgr, lgr_new_t);
824 static void smc_llc_save_add_link_info(struct smc_link *link,
825 struct smc_llc_msg_add_link *add_llc)
827 link->peer_qpn = ntoh24(add_llc->sender_qp_num);
828 memcpy(link->peer_gid, add_llc->sender_gid, SMC_GID_SIZE);
829 memcpy(link->peer_mac, add_llc->sender_mac, ETH_ALEN);
830 link->peer_psn = ntoh24(add_llc->initial_psn);
831 link->peer_mtu = add_llc->qp_mtu;
834 /* as an SMC client, process an add link request */
835 int smc_llc_cli_add_link(struct smc_link *link, struct smc_llc_qentry *qentry)
837 struct smc_llc_msg_add_link *llc = &qentry->msg.add_link;
838 enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
839 struct smc_link_group *lgr = smc_get_lgr(link);
840 struct smc_link *lnk_new = NULL;
841 struct smc_init_info ini;
847 ini.vlan_id = lgr->vlan_id;
848 smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
849 if (!memcmp(llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
850 !memcmp(llc->sender_mac, link->peer_mac, ETH_ALEN)) {
853 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
856 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
857 ini.ib_dev = link->smcibdev;
858 ini.ib_port = link->ibport;
860 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
863 lnk_new = &lgr->lnk[lnk_idx];
864 rc = smcr_link_init(lgr, lnk_new, lnk_idx, &ini);
867 smc_llc_save_add_link_info(lnk_new, llc);
868 lnk_new->link_id = llc->link_num; /* SMC server assigns link id */
869 smc_llc_link_set_uid(lnk_new);
871 rc = smc_ib_ready_link(lnk_new);
875 rc = smcr_buf_map_lgr(lnk_new);
879 rc = smc_llc_send_add_link(link,
880 lnk_new->smcibdev->mac[ini.ib_port - 1],
881 lnk_new->gid, lnk_new, SMC_LLC_RESP);
884 rc = smc_llc_cli_rkey_exchange(link, lnk_new);
889 rc = smc_llc_cli_conf_link(link, &ini, lnk_new, lgr_new_t);
893 smcr_link_clear(lnk_new, false);
895 smc_llc_cli_add_link_reject(qentry);
901 /* as an SMC client, invite server to start the add_link processing */
902 static void smc_llc_cli_add_link_invite(struct smc_link *link,
903 struct smc_llc_qentry *qentry)
905 struct smc_link_group *lgr = smc_get_lgr(link);
906 struct smc_init_info ini;
908 if (lgr->type == SMC_LGR_SYMMETRIC ||
909 lgr->type == SMC_LGR_ASYMMETRIC_PEER)
912 ini.vlan_id = lgr->vlan_id;
913 smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
917 smc_llc_send_add_link(link, ini.ib_dev->mac[ini.ib_port - 1],
918 ini.ib_gid, NULL, SMC_LLC_REQ);
923 static bool smc_llc_is_empty_llc_message(union smc_llc_msg *llc)
927 for (i = 0; i < ARRAY_SIZE(llc->raw.data); i++)
928 if (llc->raw.data[i])
933 static bool smc_llc_is_local_add_link(union smc_llc_msg *llc)
935 if (llc->raw.hdr.common.type == SMC_LLC_ADD_LINK &&
936 smc_llc_is_empty_llc_message(llc))
941 static void smc_llc_process_cli_add_link(struct smc_link_group *lgr)
943 struct smc_llc_qentry *qentry;
945 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
947 mutex_lock(&lgr->llc_conf_mutex);
948 if (smc_llc_is_local_add_link(&qentry->msg))
949 smc_llc_cli_add_link_invite(qentry->link, qentry);
951 smc_llc_cli_add_link(qentry->link, qentry);
952 mutex_unlock(&lgr->llc_conf_mutex);
955 static int smc_llc_active_link_count(struct smc_link_group *lgr)
957 int i, link_count = 0;
959 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
960 if (!smc_link_active(&lgr->lnk[i]))
967 /* find the asymmetric link when 3 links are established */
968 static struct smc_link *smc_llc_find_asym_link(struct smc_link_group *lgr)
970 int asym_idx = -ENOENT;
974 /* determine asymmetric link */
976 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
977 for (j = i + 1; j < SMC_LINKS_PER_LGR_MAX; j++) {
978 if (!smc_link_usable(&lgr->lnk[i]) ||
979 !smc_link_usable(&lgr->lnk[j]))
981 if (!memcmp(lgr->lnk[i].gid, lgr->lnk[j].gid,
983 found = true; /* asym_lnk is i or j */
991 goto out; /* no asymmetric link */
992 for (k = 0; k < SMC_LINKS_PER_LGR_MAX; k++) {
993 if (!smc_link_usable(&lgr->lnk[k]))
996 !memcmp(lgr->lnk[i].peer_gid, lgr->lnk[k].peer_gid,
1002 !memcmp(lgr->lnk[j].peer_gid, lgr->lnk[k].peer_gid,
1009 return (asym_idx < 0) ? NULL : &lgr->lnk[asym_idx];
1012 static void smc_llc_delete_asym_link(struct smc_link_group *lgr)
1014 struct smc_link *lnk_new = NULL, *lnk_asym;
1015 struct smc_llc_qentry *qentry;
1018 lnk_asym = smc_llc_find_asym_link(lgr);
1020 return; /* no asymmetric link */
1021 if (!smc_link_downing(&lnk_asym->state))
1023 lnk_new = smc_switch_conns(lgr, lnk_asym, false);
1024 smc_wr_tx_wait_no_pending_sends(lnk_asym);
1027 /* change flow type from ADD_LINK into DEL_LINK */
1028 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_DEL_LINK;
1029 rc = smc_llc_send_delete_link(lnk_new, lnk_asym->link_id, SMC_LLC_REQ,
1030 true, SMC_LLC_DEL_NO_ASYM_NEEDED);
1032 smcr_link_down_cond(lnk_new);
1035 qentry = smc_llc_wait(lgr, lnk_new, SMC_LLC_WAIT_TIME,
1036 SMC_LLC_DELETE_LINK);
1038 smcr_link_down_cond(lnk_new);
1041 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1043 smcr_link_clear(lnk_asym, true);
1046 static int smc_llc_srv_rkey_exchange(struct smc_link *link,
1047 struct smc_link *link_new)
1049 struct smc_llc_msg_add_link_cont *addc_llc;
1050 struct smc_link_group *lgr = link->lgr;
1051 u8 max, num_rkeys_send, num_rkeys_recv;
1052 struct smc_llc_qentry *qentry = NULL;
1053 struct smc_buf_desc *buf_pos;
1058 mutex_lock(&lgr->rmbs_lock);
1059 num_rkeys_send = lgr->conns_num;
1060 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
1062 smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
1063 &buf_lst, &buf_pos);
1064 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME,
1065 SMC_LLC_ADD_LINK_CONT);
1070 addc_llc = &qentry->msg.add_link_cont;
1071 num_rkeys_recv = addc_llc->num_rkeys;
1072 max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
1073 for (i = 0; i < max; i++) {
1074 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
1075 addc_llc->rt[i].rmb_key,
1076 addc_llc->rt[i].rmb_vaddr_new,
1077 addc_llc->rt[i].rmb_key_new);
1080 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1081 } while (num_rkeys_send || num_rkeys_recv);
1083 mutex_unlock(&lgr->rmbs_lock);
1087 static int smc_llc_srv_conf_link(struct smc_link *link,
1088 struct smc_link *link_new,
1089 enum smc_lgr_type lgr_new_t)
1091 struct smc_link_group *lgr = link->lgr;
1092 struct smc_llc_qentry *qentry = NULL;
1095 /* send CONFIRM LINK request over the RoCE fabric */
1096 rc = smc_llc_send_confirm_link(link_new, SMC_LLC_REQ);
1099 /* receive CONFIRM LINK response over the RoCE fabric */
1100 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_FIRST_TIME, 0);
1102 qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
1103 /* send DELETE LINK */
1104 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
1105 false, SMC_LLC_DEL_LOST_PATH);
1107 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1110 smc_llc_save_peer_uid(qentry);
1111 smc_llc_link_active(link_new);
1112 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
1113 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
1114 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
1116 smcr_lgr_set_type(lgr, lgr_new_t);
1117 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1121 int smc_llc_srv_add_link(struct smc_link *link)
1123 enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
1124 struct smc_link_group *lgr = link->lgr;
1125 struct smc_llc_msg_add_link *add_llc;
1126 struct smc_llc_qentry *qentry = NULL;
1127 struct smc_link *link_new;
1128 struct smc_init_info ini;
1129 int lnk_idx, rc = 0;
1131 /* ignore client add link recommendation, start new flow */
1132 ini.vlan_id = lgr->vlan_id;
1133 smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
1135 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
1136 ini.ib_dev = link->smcibdev;
1137 ini.ib_port = link->ibport;
1139 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
1143 rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, &ini);
1146 link_new = &lgr->lnk[lnk_idx];
1147 rc = smc_llc_send_add_link(link,
1148 link_new->smcibdev->mac[ini.ib_port - 1],
1149 link_new->gid, link_new, SMC_LLC_REQ);
1152 /* receive ADD LINK response over the RoCE fabric */
1153 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK);
1158 add_llc = &qentry->msg.add_link;
1159 if (add_llc->hd.flags & SMC_LLC_FLAG_ADD_LNK_REJ) {
1160 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1164 if (lgr->type == SMC_LGR_SINGLE &&
1165 (!memcmp(add_llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
1166 !memcmp(add_llc->sender_mac, link->peer_mac, ETH_ALEN))) {
1167 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
1169 smc_llc_save_add_link_info(link_new, add_llc);
1170 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1172 rc = smc_ib_ready_link(link_new);
1175 rc = smcr_buf_map_lgr(link_new);
1178 rc = smcr_buf_reg_lgr(link_new);
1181 rc = smc_llc_srv_rkey_exchange(link, link_new);
1184 rc = smc_llc_srv_conf_link(link, link_new, lgr_new_t);
1189 smcr_link_clear(link_new, false);
1193 static void smc_llc_process_srv_add_link(struct smc_link_group *lgr)
1195 struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
1198 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1200 mutex_lock(&lgr->llc_conf_mutex);
1201 rc = smc_llc_srv_add_link(link);
1202 if (!rc && lgr->type == SMC_LGR_SYMMETRIC) {
1203 /* delete any asymmetric link */
1204 smc_llc_delete_asym_link(lgr);
1206 mutex_unlock(&lgr->llc_conf_mutex);
1209 /* enqueue a local add_link req to trigger a new add_link flow */
1210 void smc_llc_add_link_local(struct smc_link *link)
1212 struct smc_llc_msg_add_link add_llc = {0};
1214 add_llc.hd.length = sizeof(add_llc);
1215 add_llc.hd.common.type = SMC_LLC_ADD_LINK;
1216 /* no dev and port needed */
1217 smc_llc_enqueue(link, (union smc_llc_msg *)&add_llc);
1220 /* worker to process an add link message */
1221 static void smc_llc_add_link_work(struct work_struct *work)
1223 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1226 if (list_empty(&lgr->list)) {
1227 /* link group is terminating */
1228 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1232 if (lgr->role == SMC_CLNT)
1233 smc_llc_process_cli_add_link(lgr);
1235 smc_llc_process_srv_add_link(lgr);
1237 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
1240 /* enqueue a local del_link msg to trigger a new del_link flow,
1241 * called only for role SMC_SERV
1243 void smc_llc_srv_delete_link_local(struct smc_link *link, u8 del_link_id)
1245 struct smc_llc_msg_del_link del_llc = {0};
1247 del_llc.hd.length = sizeof(del_llc);
1248 del_llc.hd.common.type = SMC_LLC_DELETE_LINK;
1249 del_llc.link_num = del_link_id;
1250 del_llc.reason = htonl(SMC_LLC_DEL_LOST_PATH);
1251 del_llc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
1252 smc_llc_enqueue(link, (union smc_llc_msg *)&del_llc);
1255 static void smc_llc_process_cli_delete_link(struct smc_link_group *lgr)
1257 struct smc_link *lnk_del = NULL, *lnk_asym, *lnk;
1258 struct smc_llc_msg_del_link *del_llc;
1259 struct smc_llc_qentry *qentry;
1263 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1265 del_llc = &qentry->msg.delete_link;
1267 if (del_llc->hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
1268 smc_lgr_terminate_sched(lgr);
1271 mutex_lock(&lgr->llc_conf_mutex);
1272 /* delete single link */
1273 for (lnk_idx = 0; lnk_idx < SMC_LINKS_PER_LGR_MAX; lnk_idx++) {
1274 if (lgr->lnk[lnk_idx].link_id != del_llc->link_num)
1276 lnk_del = &lgr->lnk[lnk_idx];
1279 del_llc->hd.flags |= SMC_LLC_FLAG_RESP;
1281 /* link was not found */
1282 del_llc->reason = htonl(SMC_LLC_DEL_NOLNK);
1283 smc_llc_send_message(lnk, &qentry->msg);
1286 lnk_asym = smc_llc_find_asym_link(lgr);
1288 del_llc->reason = 0;
1289 smc_llc_send_message(lnk, &qentry->msg); /* response */
1291 if (smc_link_downing(&lnk_del->state)) {
1292 if (smc_switch_conns(lgr, lnk_del, false))
1293 smc_wr_tx_wait_no_pending_sends(lnk_del);
1295 smcr_link_clear(lnk_del, true);
1297 active_links = smc_llc_active_link_count(lgr);
1298 if (lnk_del == lnk_asym) {
1299 /* expected deletion of asym link, don't change lgr state */
1300 } else if (active_links == 1) {
1301 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
1302 } else if (!active_links) {
1303 smcr_lgr_set_type(lgr, SMC_LGR_NONE);
1304 smc_lgr_terminate_sched(lgr);
1307 mutex_unlock(&lgr->llc_conf_mutex);
1312 /* try to send a DELETE LINK ALL request on any active link,
1313 * waiting for send completion
1315 void smc_llc_send_link_delete_all(struct smc_link_group *lgr, bool ord, u32 rsn)
1317 struct smc_llc_msg_del_link delllc = {0};
1320 delllc.hd.common.type = SMC_LLC_DELETE_LINK;
1321 delllc.hd.length = sizeof(delllc);
1323 delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
1324 delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
1325 delllc.reason = htonl(rsn);
1327 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
1328 if (!smc_link_usable(&lgr->lnk[i]))
1330 if (!smc_llc_send_message_wait(&lgr->lnk[i], &delllc))
1335 static void smc_llc_process_srv_delete_link(struct smc_link_group *lgr)
1337 struct smc_llc_msg_del_link *del_llc;
1338 struct smc_link *lnk, *lnk_del;
1339 struct smc_llc_qentry *qentry;
1343 mutex_lock(&lgr->llc_conf_mutex);
1344 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1346 del_llc = &qentry->msg.delete_link;
1348 if (qentry->msg.delete_link.hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
1349 /* delete entire lgr */
1350 smc_llc_send_link_delete_all(lgr, true, ntohl(
1351 qentry->msg.delete_link.reason));
1352 smc_lgr_terminate_sched(lgr);
1355 /* delete single link */
1357 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
1358 if (lgr->lnk[i].link_id == del_llc->link_num) {
1359 lnk_del = &lgr->lnk[i];
1364 goto out; /* asymmetric link already deleted */
1366 if (smc_link_downing(&lnk_del->state)) {
1367 if (smc_switch_conns(lgr, lnk_del, false))
1368 smc_wr_tx_wait_no_pending_sends(lnk_del);
1370 if (!list_empty(&lgr->list)) {
1371 /* qentry is either a request from peer (send it back to
1372 * initiate the DELETE_LINK processing), or a locally
1373 * enqueued DELETE_LINK request (forward it)
1375 if (!smc_llc_send_message(lnk, &qentry->msg)) {
1376 struct smc_llc_qentry *qentry2;
1378 qentry2 = smc_llc_wait(lgr, lnk, SMC_LLC_WAIT_TIME,
1379 SMC_LLC_DELETE_LINK);
1381 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1384 smcr_link_clear(lnk_del, true);
1386 active_links = smc_llc_active_link_count(lgr);
1387 if (active_links == 1) {
1388 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
1389 } else if (!active_links) {
1390 smcr_lgr_set_type(lgr, SMC_LGR_NONE);
1391 smc_lgr_terminate_sched(lgr);
1394 if (lgr->type == SMC_LGR_SINGLE && !list_empty(&lgr->list)) {
1395 /* trigger setup of asymm alt link */
1396 smc_llc_add_link_local(lnk);
1399 mutex_unlock(&lgr->llc_conf_mutex);
1403 static void smc_llc_delete_link_work(struct work_struct *work)
1405 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1408 if (list_empty(&lgr->list)) {
1409 /* link group is terminating */
1410 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1414 if (lgr->role == SMC_CLNT)
1415 smc_llc_process_cli_delete_link(lgr);
1417 smc_llc_process_srv_delete_link(lgr);
1419 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
1422 /* process a confirm_rkey request from peer, remote flow */
1423 static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr)
1425 struct smc_llc_msg_confirm_rkey *llc;
1426 struct smc_llc_qentry *qentry;
1427 struct smc_link *link;
1432 qentry = lgr->llc_flow_rmt.qentry;
1433 llc = &qentry->msg.confirm_rkey;
1434 link = qentry->link;
1436 num_entries = llc->rtoken[0].num_rkeys;
1437 /* first rkey entry is for receiving link */
1438 rk_idx = smc_rtoken_add(link,
1439 llc->rtoken[0].rmb_vaddr,
1440 llc->rtoken[0].rmb_key);
1444 for (i = 1; i <= min_t(u8, num_entries, SMC_LLC_RKEYS_PER_MSG - 1); i++)
1445 smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id,
1446 llc->rtoken[i].rmb_vaddr,
1447 llc->rtoken[i].rmb_key);
1448 /* max links is 3 so there is no need to support conf_rkey_cont msgs */
1451 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
1452 llc->hd.flags |= SMC_LLC_FLAG_RKEY_RETRY;
1454 llc->hd.flags |= SMC_LLC_FLAG_RESP;
1455 smc_llc_send_message(link, &qentry->msg);
1456 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1459 /* process a delete_rkey request from peer, remote flow */
1460 static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr)
1462 struct smc_llc_msg_delete_rkey *llc;
1463 struct smc_llc_qentry *qentry;
1464 struct smc_link *link;
1468 qentry = lgr->llc_flow_rmt.qentry;
1469 llc = &qentry->msg.delete_rkey;
1470 link = qentry->link;
1472 max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX);
1473 for (i = 0; i < max; i++) {
1474 if (smc_rtoken_delete(link, llc->rkey[i]))
1475 err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i);
1478 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
1479 llc->err_mask = err_mask;
1481 llc->hd.flags |= SMC_LLC_FLAG_RESP;
1482 smc_llc_send_message(link, &qentry->msg);
1483 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1486 static void smc_llc_protocol_violation(struct smc_link_group *lgr, u8 type)
1488 pr_warn_ratelimited("smc: SMC-R lg %*phN LLC protocol violation: "
1489 "llc_type %d\n", SMC_LGR_ID_SIZE, &lgr->id, type);
1490 smc_llc_set_termination_rsn(lgr, SMC_LLC_DEL_PROT_VIOL);
1491 smc_lgr_terminate_sched(lgr);
1494 /* flush the llc event queue */
1495 static void smc_llc_event_flush(struct smc_link_group *lgr)
1497 struct smc_llc_qentry *qentry, *q;
1499 spin_lock_bh(&lgr->llc_event_q_lock);
1500 list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) {
1501 list_del_init(&qentry->list);
1504 spin_unlock_bh(&lgr->llc_event_q_lock);
1507 static void smc_llc_event_handler(struct smc_llc_qentry *qentry)
1509 union smc_llc_msg *llc = &qentry->msg;
1510 struct smc_link *link = qentry->link;
1511 struct smc_link_group *lgr = link->lgr;
1513 if (!smc_link_usable(link))
1516 switch (llc->raw.hdr.common.type) {
1517 case SMC_LLC_TEST_LINK:
1518 llc->test_link.hd.flags |= SMC_LLC_FLAG_RESP;
1519 smc_llc_send_message(link, llc);
1521 case SMC_LLC_ADD_LINK:
1522 if (list_empty(&lgr->list))
1523 goto out; /* lgr is terminating */
1524 if (lgr->role == SMC_CLNT) {
1525 if (smc_llc_is_local_add_link(llc)) {
1526 if (lgr->llc_flow_lcl.type ==
1527 SMC_LLC_FLOW_ADD_LINK)
1528 break; /* add_link in progress */
1529 if (smc_llc_flow_start(&lgr->llc_flow_lcl,
1531 schedule_work(&lgr->llc_add_link_work);
1535 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
1536 !lgr->llc_flow_lcl.qentry) {
1537 /* a flow is waiting for this message */
1538 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
1540 wake_up(&lgr->llc_msg_waiter);
1541 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
1543 schedule_work(&lgr->llc_add_link_work);
1545 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1546 /* as smc server, handle client suggestion */
1547 schedule_work(&lgr->llc_add_link_work);
1550 case SMC_LLC_CONFIRM_LINK:
1551 case SMC_LLC_ADD_LINK_CONT:
1552 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
1553 /* a flow is waiting for this message */
1554 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
1555 wake_up(&lgr->llc_msg_waiter);
1559 case SMC_LLC_DELETE_LINK:
1560 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
1561 !lgr->llc_flow_lcl.qentry) {
1562 /* DEL LINK REQ during ADD LINK SEQ */
1563 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
1564 wake_up(&lgr->llc_msg_waiter);
1565 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1566 schedule_work(&lgr->llc_del_link_work);
1569 case SMC_LLC_CONFIRM_RKEY:
1570 /* new request from remote, assign to remote flow */
1571 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1572 /* process here, does not wait for more llc msgs */
1573 smc_llc_rmt_conf_rkey(lgr);
1574 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1577 case SMC_LLC_CONFIRM_RKEY_CONT:
1578 /* not used because max links is 3, and 3 rkeys fit into
1579 * one CONFIRM_RKEY message
1582 case SMC_LLC_DELETE_RKEY:
1583 /* new request from remote, assign to remote flow */
1584 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1585 /* process here, does not wait for more llc msgs */
1586 smc_llc_rmt_delete_rkey(lgr);
1587 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1591 smc_llc_protocol_violation(lgr, llc->raw.hdr.common.type);
1598 /* worker to process llc messages on the event queue */
1599 static void smc_llc_event_work(struct work_struct *work)
1601 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1603 struct smc_llc_qentry *qentry;
1605 if (!lgr->llc_flow_lcl.type && lgr->delayed_event) {
1606 if (smc_link_usable(lgr->delayed_event->link)) {
1607 smc_llc_event_handler(lgr->delayed_event);
1609 qentry = lgr->delayed_event;
1610 lgr->delayed_event = NULL;
1616 spin_lock_bh(&lgr->llc_event_q_lock);
1617 if (!list_empty(&lgr->llc_event_q)) {
1618 qentry = list_first_entry(&lgr->llc_event_q,
1619 struct smc_llc_qentry, list);
1620 list_del_init(&qentry->list);
1621 spin_unlock_bh(&lgr->llc_event_q_lock);
1622 smc_llc_event_handler(qentry);
1625 spin_unlock_bh(&lgr->llc_event_q_lock);
1628 /* process llc responses in tasklet context */
1629 static void smc_llc_rx_response(struct smc_link *link,
1630 struct smc_llc_qentry *qentry)
1632 enum smc_llc_flowtype flowtype = link->lgr->llc_flow_lcl.type;
1633 struct smc_llc_flow *flow = &link->lgr->llc_flow_lcl;
1634 u8 llc_type = qentry->msg.raw.hdr.common.type;
1637 case SMC_LLC_TEST_LINK:
1638 if (smc_link_active(link))
1639 complete(&link->llc_testlink_resp);
1641 case SMC_LLC_ADD_LINK:
1642 case SMC_LLC_ADD_LINK_CONT:
1643 case SMC_LLC_CONFIRM_LINK:
1644 if (flowtype != SMC_LLC_FLOW_ADD_LINK || flow->qentry)
1645 break; /* drop out-of-flow response */
1647 case SMC_LLC_DELETE_LINK:
1648 if (flowtype != SMC_LLC_FLOW_DEL_LINK || flow->qentry)
1649 break; /* drop out-of-flow response */
1651 case SMC_LLC_CONFIRM_RKEY:
1652 case SMC_LLC_DELETE_RKEY:
1653 if (flowtype != SMC_LLC_FLOW_RKEY || flow->qentry)
1654 break; /* drop out-of-flow response */
1656 case SMC_LLC_CONFIRM_RKEY_CONT:
1657 /* not used because max links is 3 */
1660 smc_llc_protocol_violation(link->lgr, llc_type);
1666 /* assign responses to the local flow, we requested them */
1667 smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry);
1668 wake_up(&link->lgr->llc_msg_waiter);
1671 static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc)
1673 struct smc_link_group *lgr = link->lgr;
1674 struct smc_llc_qentry *qentry;
1675 unsigned long flags;
1677 qentry = kmalloc(sizeof(*qentry), GFP_ATOMIC);
1680 qentry->link = link;
1681 INIT_LIST_HEAD(&qentry->list);
1682 memcpy(&qentry->msg, llc, sizeof(union smc_llc_msg));
1684 /* process responses immediately */
1685 if (llc->raw.hdr.flags & SMC_LLC_FLAG_RESP) {
1686 smc_llc_rx_response(link, qentry);
1690 /* add requests to event queue */
1691 spin_lock_irqsave(&lgr->llc_event_q_lock, flags);
1692 list_add_tail(&qentry->list, &lgr->llc_event_q);
1693 spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags);
1694 schedule_work(&lgr->llc_event_work);
1697 /* copy received msg and add it to the event queue */
1698 static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
1700 struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
1701 union smc_llc_msg *llc = buf;
1703 if (wc->byte_len < sizeof(*llc))
1704 return; /* short message */
1705 if (llc->raw.hdr.length != sizeof(*llc))
1706 return; /* invalid message */
1708 smc_llc_enqueue(link, llc);
1711 /***************************** worker, utils *********************************/
1713 static void smc_llc_testlink_work(struct work_struct *work)
1715 struct smc_link *link = container_of(to_delayed_work(work),
1716 struct smc_link, llc_testlink_wrk);
1717 unsigned long next_interval;
1718 unsigned long expire_time;
1719 u8 user_data[16] = { 0 };
1722 if (!smc_link_active(link))
1723 return; /* don't reschedule worker */
1724 expire_time = link->wr_rx_tstamp + link->llc_testlink_time;
1725 if (time_is_after_jiffies(expire_time)) {
1726 next_interval = expire_time - jiffies;
1729 reinit_completion(&link->llc_testlink_resp);
1730 smc_llc_send_test_link(link, user_data);
1731 /* receive TEST LINK response over RoCE fabric */
1732 rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp,
1734 if (!smc_link_active(link))
1735 return; /* link state changed */
1737 smcr_link_down_cond_sched(link);
1740 next_interval = link->llc_testlink_time;
1742 schedule_delayed_work(&link->llc_testlink_wrk, next_interval);
1745 void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc)
1747 struct net *net = sock_net(smc->clcsock->sk);
1749 INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
1750 INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
1751 INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work);
1752 INIT_LIST_HEAD(&lgr->llc_event_q);
1753 spin_lock_init(&lgr->llc_event_q_lock);
1754 spin_lock_init(&lgr->llc_flow_lock);
1755 init_waitqueue_head(&lgr->llc_flow_waiter);
1756 init_waitqueue_head(&lgr->llc_msg_waiter);
1757 mutex_init(&lgr->llc_conf_mutex);
1758 lgr->llc_testlink_time = net->ipv4.sysctl_tcp_keepalive_time;
1761 /* called after lgr was removed from lgr_list */
1762 void smc_llc_lgr_clear(struct smc_link_group *lgr)
1764 smc_llc_event_flush(lgr);
1765 wake_up_all(&lgr->llc_flow_waiter);
1766 wake_up_all(&lgr->llc_msg_waiter);
1767 cancel_work_sync(&lgr->llc_event_work);
1768 cancel_work_sync(&lgr->llc_add_link_work);
1769 cancel_work_sync(&lgr->llc_del_link_work);
1770 if (lgr->delayed_event) {
1771 kfree(lgr->delayed_event);
1772 lgr->delayed_event = NULL;
1776 int smc_llc_link_init(struct smc_link *link)
1778 init_completion(&link->llc_testlink_resp);
1779 INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work);
1783 void smc_llc_link_active(struct smc_link *link)
1785 pr_warn_ratelimited("smc: SMC-R lg %*phN link added: id %*phN, "
1786 "peerid %*phN, ibdev %s, ibport %d\n",
1787 SMC_LGR_ID_SIZE, &link->lgr->id,
1788 SMC_LGR_ID_SIZE, &link->link_uid,
1789 SMC_LGR_ID_SIZE, &link->peer_link_uid,
1790 link->smcibdev->ibdev->name, link->ibport);
1791 link->state = SMC_LNK_ACTIVE;
1792 if (link->lgr->llc_testlink_time) {
1793 link->llc_testlink_time = link->lgr->llc_testlink_time * HZ;
1794 schedule_delayed_work(&link->llc_testlink_wrk,
1795 link->llc_testlink_time);
1799 /* called in worker context */
1800 void smc_llc_link_clear(struct smc_link *link, bool log)
1803 pr_warn_ratelimited("smc: SMC-R lg %*phN link removed: id %*phN"
1804 ", peerid %*phN, ibdev %s, ibport %d\n",
1805 SMC_LGR_ID_SIZE, &link->lgr->id,
1806 SMC_LGR_ID_SIZE, &link->link_uid,
1807 SMC_LGR_ID_SIZE, &link->peer_link_uid,
1808 link->smcibdev->ibdev->name, link->ibport);
1809 complete(&link->llc_testlink_resp);
1810 cancel_delayed_work_sync(&link->llc_testlink_wrk);
1811 smc_wr_wakeup_reg_wait(link);
1812 smc_wr_wakeup_tx_wait(link);
1815 /* register a new rtoken at the remote peer (for all links) */
1816 int smc_llc_do_confirm_rkey(struct smc_link *send_link,
1817 struct smc_buf_desc *rmb_desc)
1819 struct smc_link_group *lgr = send_link->lgr;
1820 struct smc_llc_qentry *qentry = NULL;
1823 rc = smc_llc_send_confirm_rkey(send_link, rmb_desc);
1826 /* receive CONFIRM RKEY response from server over RoCE fabric */
1827 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
1828 SMC_LLC_CONFIRM_RKEY);
1829 if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
1833 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1837 /* unregister an rtoken at the remote peer */
1838 int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
1839 struct smc_buf_desc *rmb_desc)
1841 struct smc_llc_qentry *qentry = NULL;
1842 struct smc_link *send_link;
1845 send_link = smc_llc_usable_link(lgr);
1849 /* protected by llc_flow control */
1850 rc = smc_llc_send_delete_rkey(send_link, rmb_desc);
1853 /* receive DELETE RKEY response from server over RoCE fabric */
1854 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
1855 SMC_LLC_DELETE_RKEY);
1856 if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
1860 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1864 void smc_llc_link_set_uid(struct smc_link *link)
1868 link_uid = htonl(*((u32 *)link->lgr->id) + link->link_id);
1869 memcpy(link->link_uid, &link_uid, SMC_LGR_ID_SIZE);
1872 /* save peers link user id, used for debug purposes */
1873 void smc_llc_save_peer_uid(struct smc_llc_qentry *qentry)
1875 memcpy(qentry->link->peer_link_uid, qentry->msg.confirm_link.link_uid,
1879 /* evaluate confirm link request or response */
1880 int smc_llc_eval_conf_link(struct smc_llc_qentry *qentry,
1881 enum smc_llc_reqresp type)
1883 if (type == SMC_LLC_REQ) { /* SMC server assigns link_id */
1884 qentry->link->link_id = qentry->msg.confirm_link.link_num;
1885 smc_llc_link_set_uid(qentry->link);
1887 if (!(qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_NO_RMBE_EYEC))
1892 /***************************** init, exit, misc ******************************/
1894 static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
1896 .handler = smc_llc_rx_handler,
1897 .type = SMC_LLC_CONFIRM_LINK
1900 .handler = smc_llc_rx_handler,
1901 .type = SMC_LLC_TEST_LINK
1904 .handler = smc_llc_rx_handler,
1905 .type = SMC_LLC_ADD_LINK
1908 .handler = smc_llc_rx_handler,
1909 .type = SMC_LLC_ADD_LINK_CONT
1912 .handler = smc_llc_rx_handler,
1913 .type = SMC_LLC_DELETE_LINK
1916 .handler = smc_llc_rx_handler,
1917 .type = SMC_LLC_CONFIRM_RKEY
1920 .handler = smc_llc_rx_handler,
1921 .type = SMC_LLC_CONFIRM_RKEY_CONT
1924 .handler = smc_llc_rx_handler,
1925 .type = SMC_LLC_DELETE_RKEY
1932 int __init smc_llc_init(void)
1934 struct smc_wr_rx_handler *handler;
1937 for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
1938 INIT_HLIST_NODE(&handler->list);
1939 rc = smc_wr_rx_register_handler(handler);