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 23 struct 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 38 struct 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 54 struct 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 69 struct 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 76 struct smc_llc_msg_test_link { /* type 0x07 */ 77 struct smc_llc_hdr hd; 78 u8 user_data[16]; 79 u8 reserved[24]; 80 }; 81 82 struct 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 95 struct 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 101 struct 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 110 struct 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 119 union 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 139 struct smc_llc_tx_pend { 140 }; 141 142 /* handler for send/transmission completion of an LLC msg */ 143 static 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 */ 163 static 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 */ 185 int 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 = smc_get_lgr(link); 190 struct smc_llc_msg_confirm_link *confllc; 191 struct smc_wr_tx_pend_priv *pend; 192 struct smc_wr_buf *wr_buf; 193 int rc; 194 195 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 196 if (rc) 197 return rc; 198 confllc = (struct smc_llc_msg_confirm_link *)wr_buf; 199 memset(confllc, 0, sizeof(*confllc)); 200 confllc->hd.common.type = SMC_LLC_CONFIRM_LINK; 201 confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link); 202 confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC; 203 if (reqresp == SMC_LLC_RESP) 204 confllc->hd.flags |= SMC_LLC_FLAG_RESP; 205 memcpy(confllc->sender_mac, mac, ETH_ALEN); 206 memcpy(confllc->sender_gid, gid, SMC_GID_SIZE); 207 hton24(confllc->sender_qp_num, link->roce_qp->qp_num); 208 confllc->link_num = link->link_id; 209 memcpy(confllc->link_uid, lgr->id, SMC_LGR_ID_SIZE); 210 confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS; /* enforce peer resp. */ 211 /* send llc message */ 212 rc = smc_wr_tx_send(link, pend); 213 return rc; 214 } 215 216 /* send LLC confirm rkey request */ 217 static int smc_llc_send_confirm_rkey(struct smc_link *link, 218 struct smc_buf_desc *rmb_desc) 219 { 220 struct smc_llc_msg_confirm_rkey *rkeyllc; 221 struct smc_wr_tx_pend_priv *pend; 222 struct smc_wr_buf *wr_buf; 223 int rc; 224 225 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 226 if (rc) 227 return rc; 228 rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf; 229 memset(rkeyllc, 0, sizeof(*rkeyllc)); 230 rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY; 231 rkeyllc->hd.length = sizeof(struct smc_llc_msg_confirm_rkey); 232 rkeyllc->rtoken[0].rmb_key = 233 htonl(rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey); 234 rkeyllc->rtoken[0].rmb_vaddr = cpu_to_be64( 235 (u64)sg_dma_address(rmb_desc->sgt[SMC_SINGLE_LINK].sgl)); 236 /* send llc message */ 237 rc = smc_wr_tx_send(link, pend); 238 return rc; 239 } 240 241 /* prepare an add link message */ 242 static void smc_llc_prep_add_link(struct smc_llc_msg_add_link *addllc, 243 struct smc_link *link, u8 mac[], 244 union ib_gid *gid, 245 enum smc_llc_reqresp reqresp) 246 { 247 memset(addllc, 0, sizeof(*addllc)); 248 addllc->hd.common.type = SMC_LLC_ADD_LINK; 249 addllc->hd.length = sizeof(struct smc_llc_msg_add_link); 250 if (reqresp == SMC_LLC_RESP) { 251 addllc->hd.flags |= SMC_LLC_FLAG_RESP; 252 /* always reject more links for now */ 253 addllc->hd.flags |= SMC_LLC_FLAG_ADD_LNK_REJ; 254 addllc->hd.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH; 255 } 256 memcpy(addllc->sender_mac, mac, ETH_ALEN); 257 memcpy(addllc->sender_gid, gid, SMC_GID_SIZE); 258 } 259 260 /* send ADD LINK request or response */ 261 int smc_llc_send_add_link(struct smc_link *link, u8 mac[], 262 union ib_gid *gid, 263 enum smc_llc_reqresp reqresp) 264 { 265 struct smc_llc_msg_add_link *addllc; 266 struct smc_wr_tx_pend_priv *pend; 267 struct smc_wr_buf *wr_buf; 268 int rc; 269 270 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 271 if (rc) 272 return rc; 273 addllc = (struct smc_llc_msg_add_link *)wr_buf; 274 smc_llc_prep_add_link(addllc, link, mac, gid, reqresp); 275 /* send llc message */ 276 rc = smc_wr_tx_send(link, pend); 277 return rc; 278 } 279 280 /* prepare a delete link message */ 281 static void smc_llc_prep_delete_link(struct smc_llc_msg_del_link *delllc, 282 struct smc_link *link, 283 enum smc_llc_reqresp reqresp) 284 { 285 memset(delllc, 0, sizeof(*delllc)); 286 delllc->hd.common.type = SMC_LLC_DELETE_LINK; 287 delllc->hd.length = sizeof(struct smc_llc_msg_add_link); 288 if (reqresp == SMC_LLC_RESP) 289 delllc->hd.flags |= SMC_LLC_FLAG_RESP; 290 /* DEL_LINK_ALL because only 1 link supported */ 291 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL; 292 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY; 293 delllc->link_num = link->link_id; 294 } 295 296 /* send DELETE LINK request or response */ 297 int smc_llc_send_delete_link(struct smc_link *link, 298 enum smc_llc_reqresp reqresp) 299 { 300 struct smc_llc_msg_del_link *delllc; 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 delllc = (struct smc_llc_msg_del_link *)wr_buf; 309 smc_llc_prep_delete_link(delllc, link, reqresp); 310 /* send llc message */ 311 rc = smc_wr_tx_send(link, pend); 312 return rc; 313 } 314 315 /* send LLC test link request */ 316 static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16]) 317 { 318 struct smc_llc_msg_test_link *testllc; 319 struct smc_wr_tx_pend_priv *pend; 320 struct smc_wr_buf *wr_buf; 321 int rc; 322 323 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 324 if (rc) 325 return rc; 326 testllc = (struct smc_llc_msg_test_link *)wr_buf; 327 memset(testllc, 0, sizeof(*testllc)); 328 testllc->hd.common.type = SMC_LLC_TEST_LINK; 329 testllc->hd.length = sizeof(struct smc_llc_msg_test_link); 330 memcpy(testllc->user_data, user_data, sizeof(testllc->user_data)); 331 /* send llc message */ 332 rc = smc_wr_tx_send(link, pend); 333 return rc; 334 } 335 336 struct smc_llc_send_work { 337 struct work_struct work; 338 struct smc_link *link; 339 int llclen; 340 union smc_llc_msg llcbuf; 341 }; 342 343 /* worker that sends a prepared message */ 344 static void smc_llc_send_message_work(struct work_struct *work) 345 { 346 struct smc_llc_send_work *llcwrk = container_of(work, 347 struct smc_llc_send_work, work); 348 struct smc_wr_tx_pend_priv *pend; 349 struct smc_wr_buf *wr_buf; 350 int rc; 351 352 if (llcwrk->link->state == SMC_LNK_INACTIVE) 353 goto out; 354 rc = smc_llc_add_pending_send(llcwrk->link, &wr_buf, &pend); 355 if (rc) 356 goto out; 357 memcpy(wr_buf, &llcwrk->llcbuf, llcwrk->llclen); 358 smc_wr_tx_send(llcwrk->link, pend); 359 out: 360 kfree(llcwrk); 361 } 362 363 /* copy llcbuf and schedule an llc send on link */ 364 static int smc_llc_send_message(struct smc_link *link, void *llcbuf, int llclen) 365 { 366 struct smc_llc_send_work *wrk = kmalloc(sizeof(*wrk), GFP_ATOMIC); 367 368 if (!wrk) 369 return -ENOMEM; 370 INIT_WORK(&wrk->work, smc_llc_send_message_work); 371 wrk->link = link; 372 wrk->llclen = llclen; 373 memcpy(&wrk->llcbuf, llcbuf, llclen); 374 queue_work(link->llc_wq, &wrk->work); 375 return 0; 376 } 377 378 /********************************* receive ***********************************/ 379 380 static void smc_llc_rx_confirm_link(struct smc_link *link, 381 struct smc_llc_msg_confirm_link *llc) 382 { 383 struct smc_link_group *lgr = smc_get_lgr(link); 384 int conf_rc; 385 386 /* RMBE eyecatchers are not supported */ 387 if (llc->hd.flags & SMC_LLC_FLAG_NO_RMBE_EYEC) 388 conf_rc = 0; 389 else 390 conf_rc = ENOTSUPP; 391 392 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 393 if (lgr->role == SMC_SERV && 394 link->state == SMC_LNK_ACTIVATING) { 395 link->llc_confirm_resp_rc = conf_rc; 396 complete(&link->llc_confirm_resp); 397 } 398 } else { 399 if (lgr->role == SMC_CLNT && 400 link->state == SMC_LNK_ACTIVATING) { 401 link->llc_confirm_rc = conf_rc; 402 link->link_id = llc->link_num; 403 complete(&link->llc_confirm); 404 } 405 } 406 } 407 408 static void smc_llc_rx_add_link(struct smc_link *link, 409 struct smc_llc_msg_add_link *llc) 410 { 411 struct smc_link_group *lgr = smc_get_lgr(link); 412 413 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 414 if (link->state == SMC_LNK_ACTIVATING) 415 complete(&link->llc_add_resp); 416 } else { 417 if (link->state == SMC_LNK_ACTIVATING) { 418 complete(&link->llc_add); 419 return; 420 } 421 422 if (lgr->role == SMC_SERV) { 423 smc_llc_prep_add_link(llc, link, 424 link->smcibdev->mac[link->ibport - 1], 425 &link->smcibdev->gid[link->ibport - 1], 426 SMC_LLC_REQ); 427 428 } else { 429 smc_llc_prep_add_link(llc, link, 430 link->smcibdev->mac[link->ibport - 1], 431 &link->smcibdev->gid[link->ibport - 1], 432 SMC_LLC_RESP); 433 } 434 smc_llc_send_message(link, llc, sizeof(*llc)); 435 } 436 } 437 438 static void smc_llc_rx_delete_link(struct smc_link *link, 439 struct smc_llc_msg_del_link *llc) 440 { 441 struct smc_link_group *lgr = smc_get_lgr(link); 442 443 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 444 if (lgr->role == SMC_SERV) 445 smc_lgr_terminate(lgr); 446 } else { 447 if (lgr->role == SMC_SERV) { 448 smc_lgr_forget(lgr); 449 smc_llc_prep_delete_link(llc, link, SMC_LLC_REQ); 450 smc_llc_send_message(link, llc, sizeof(*llc)); 451 } else { 452 smc_llc_prep_delete_link(llc, link, SMC_LLC_RESP); 453 smc_llc_send_message(link, llc, sizeof(*llc)); 454 smc_lgr_terminate(lgr); 455 } 456 } 457 } 458 459 static void smc_llc_rx_test_link(struct smc_link *link, 460 struct smc_llc_msg_test_link *llc) 461 { 462 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 463 if (link->state == SMC_LNK_ACTIVE) 464 complete(&link->llc_testlink_resp); 465 } else { 466 llc->hd.flags |= SMC_LLC_FLAG_RESP; 467 smc_llc_send_message(link, llc, sizeof(*llc)); 468 } 469 } 470 471 static void smc_llc_rx_confirm_rkey(struct smc_link *link, 472 struct smc_llc_msg_confirm_rkey *llc) 473 { 474 int rc; 475 476 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 477 link->llc_confirm_rkey_rc = llc->hd.flags & 478 SMC_LLC_FLAG_RKEY_NEG; 479 complete(&link->llc_confirm_rkey); 480 } else { 481 rc = smc_rtoken_add(smc_get_lgr(link), 482 llc->rtoken[0].rmb_vaddr, 483 llc->rtoken[0].rmb_key); 484 485 /* ignore rtokens for other links, we have only one link */ 486 487 llc->hd.flags |= SMC_LLC_FLAG_RESP; 488 if (rc < 0) 489 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG; 490 smc_llc_send_message(link, llc, sizeof(*llc)); 491 } 492 } 493 494 static void smc_llc_rx_confirm_rkey_cont(struct smc_link *link, 495 struct smc_llc_msg_confirm_rkey_cont *llc) 496 { 497 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 498 /* unused as long as we don't send this type of msg */ 499 } else { 500 /* ignore rtokens for other links, we have only one link */ 501 llc->hd.flags |= SMC_LLC_FLAG_RESP; 502 smc_llc_send_message(link, llc, sizeof(*llc)); 503 } 504 } 505 506 static void smc_llc_rx_delete_rkey(struct smc_link *link, 507 struct smc_llc_msg_delete_rkey *llc) 508 { 509 u8 err_mask = 0; 510 int i, max; 511 512 if (llc->hd.flags & SMC_LLC_FLAG_RESP) { 513 /* unused as long as we don't send this type of msg */ 514 } else { 515 max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX); 516 for (i = 0; i < max; i++) { 517 if (smc_rtoken_delete(smc_get_lgr(link), llc->rkey[i])) 518 err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i); 519 } 520 521 if (err_mask) { 522 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG; 523 llc->err_mask = err_mask; 524 } 525 526 llc->hd.flags |= SMC_LLC_FLAG_RESP; 527 smc_llc_send_message(link, llc, sizeof(*llc)); 528 } 529 } 530 531 static void smc_llc_rx_handler(struct ib_wc *wc, void *buf) 532 { 533 struct smc_link *link = (struct smc_link *)wc->qp->qp_context; 534 union smc_llc_msg *llc = buf; 535 536 if (wc->byte_len < sizeof(*llc)) 537 return; /* short message */ 538 if (llc->raw.hdr.length != sizeof(*llc)) 539 return; /* invalid message */ 540 if (link->state == SMC_LNK_INACTIVE) 541 return; /* link not active, drop msg */ 542 543 switch (llc->raw.hdr.common.type) { 544 case SMC_LLC_TEST_LINK: 545 smc_llc_rx_test_link(link, &llc->test_link); 546 break; 547 case SMC_LLC_CONFIRM_LINK: 548 smc_llc_rx_confirm_link(link, &llc->confirm_link); 549 break; 550 case SMC_LLC_ADD_LINK: 551 smc_llc_rx_add_link(link, &llc->add_link); 552 break; 553 case SMC_LLC_DELETE_LINK: 554 smc_llc_rx_delete_link(link, &llc->delete_link); 555 break; 556 case SMC_LLC_CONFIRM_RKEY: 557 smc_llc_rx_confirm_rkey(link, &llc->confirm_rkey); 558 break; 559 case SMC_LLC_CONFIRM_RKEY_CONT: 560 smc_llc_rx_confirm_rkey_cont(link, &llc->confirm_rkey_cont); 561 break; 562 case SMC_LLC_DELETE_RKEY: 563 smc_llc_rx_delete_rkey(link, &llc->delete_rkey); 564 break; 565 } 566 } 567 568 /***************************** worker, utils *********************************/ 569 570 static void smc_llc_testlink_work(struct work_struct *work) 571 { 572 struct smc_link *link = container_of(to_delayed_work(work), 573 struct smc_link, llc_testlink_wrk); 574 unsigned long next_interval; 575 unsigned long expire_time; 576 u8 user_data[16] = { 0 }; 577 int rc; 578 579 if (link->state != SMC_LNK_ACTIVE) 580 return; /* don't reschedule worker */ 581 expire_time = link->wr_rx_tstamp + link->llc_testlink_time; 582 if (time_is_after_jiffies(expire_time)) { 583 next_interval = expire_time - jiffies; 584 goto out; 585 } 586 reinit_completion(&link->llc_testlink_resp); 587 smc_llc_send_test_link(link, user_data); 588 /* receive TEST LINK response over RoCE fabric */ 589 rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp, 590 SMC_LLC_WAIT_TIME); 591 if (rc <= 0) { 592 smc_lgr_terminate(smc_get_lgr(link)); 593 return; 594 } 595 next_interval = link->llc_testlink_time; 596 out: 597 queue_delayed_work(link->llc_wq, &link->llc_testlink_wrk, 598 next_interval); 599 } 600 601 int smc_llc_link_init(struct smc_link *link) 602 { 603 struct smc_link_group *lgr = smc_get_lgr(link); 604 link->llc_wq = alloc_ordered_workqueue("llc_wq-%x:%x)", WQ_MEM_RECLAIM, 605 *((u32 *)lgr->id), 606 link->link_id); 607 if (!link->llc_wq) 608 return -ENOMEM; 609 init_completion(&link->llc_confirm); 610 init_completion(&link->llc_confirm_resp); 611 init_completion(&link->llc_add); 612 init_completion(&link->llc_add_resp); 613 init_completion(&link->llc_confirm_rkey); 614 init_completion(&link->llc_testlink_resp); 615 INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work); 616 return 0; 617 } 618 619 void smc_llc_link_active(struct smc_link *link, int testlink_time) 620 { 621 link->state = SMC_LNK_ACTIVE; 622 if (testlink_time) { 623 link->llc_testlink_time = testlink_time * HZ; 624 queue_delayed_work(link->llc_wq, &link->llc_testlink_wrk, 625 link->llc_testlink_time); 626 } 627 } 628 629 /* called in tasklet context */ 630 void smc_llc_link_inactive(struct smc_link *link) 631 { 632 link->state = SMC_LNK_INACTIVE; 633 cancel_delayed_work(&link->llc_testlink_wrk); 634 } 635 636 /* called in worker context */ 637 void smc_llc_link_clear(struct smc_link *link) 638 { 639 flush_workqueue(link->llc_wq); 640 destroy_workqueue(link->llc_wq); 641 } 642 643 /* register a new rtoken at the remote peer */ 644 int smc_llc_do_confirm_rkey(struct smc_link *link, 645 struct smc_buf_desc *rmb_desc) 646 { 647 int rc; 648 649 reinit_completion(&link->llc_confirm_rkey); 650 smc_llc_send_confirm_rkey(link, rmb_desc); 651 /* receive CONFIRM RKEY response from server over RoCE fabric */ 652 rc = wait_for_completion_interruptible_timeout(&link->llc_confirm_rkey, 653 SMC_LLC_WAIT_TIME); 654 if (rc <= 0 || link->llc_confirm_rkey_rc) 655 return -EFAULT; 656 return 0; 657 } 658 659 /***************************** init, exit, misc ******************************/ 660 661 static struct smc_wr_rx_handler smc_llc_rx_handlers[] = { 662 { 663 .handler = smc_llc_rx_handler, 664 .type = SMC_LLC_CONFIRM_LINK 665 }, 666 { 667 .handler = smc_llc_rx_handler, 668 .type = SMC_LLC_TEST_LINK 669 }, 670 { 671 .handler = smc_llc_rx_handler, 672 .type = SMC_LLC_ADD_LINK 673 }, 674 { 675 .handler = smc_llc_rx_handler, 676 .type = SMC_LLC_DELETE_LINK 677 }, 678 { 679 .handler = smc_llc_rx_handler, 680 .type = SMC_LLC_CONFIRM_RKEY 681 }, 682 { 683 .handler = smc_llc_rx_handler, 684 .type = SMC_LLC_CONFIRM_RKEY_CONT 685 }, 686 { 687 .handler = smc_llc_rx_handler, 688 .type = SMC_LLC_DELETE_RKEY 689 }, 690 { 691 .handler = NULL, 692 } 693 }; 694 695 int __init smc_llc_init(void) 696 { 697 struct smc_wr_rx_handler *handler; 698 int rc = 0; 699 700 for (handler = smc_llc_rx_handlers; handler->handler; handler++) { 701 INIT_HLIST_NODE(&handler->list); 702 rc = smc_wr_rx_register_handler(handler); 703 if (rc) 704 break; 705 } 706 return rc; 707 } 708