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 #include "smc_pnet.h" 21 22 #define SMC_LLC_DATA_LEN 40 23 24 struct smc_llc_hdr { 25 struct smc_wr_rx_hdr common; 26 union { 27 struct { 28 u8 length; /* 44 */ 29 #if defined(__BIG_ENDIAN_BITFIELD) 30 u8 reserved:4, 31 add_link_rej_rsn:4; 32 #elif defined(__LITTLE_ENDIAN_BITFIELD) 33 u8 add_link_rej_rsn:4, 34 reserved:4; 35 #endif 36 }; 37 u16 length_v2; /* 44 - 8192*/ 38 }; 39 u8 flags; 40 } __packed; /* format defined in 41 * IBM Shared Memory Communications Version 2 42 * (https://www.ibm.com/support/pages/node/6326337) 43 */ 44 45 #define SMC_LLC_FLAG_NO_RMBE_EYEC 0x03 46 47 struct smc_llc_msg_confirm_link { /* type 0x01 */ 48 struct smc_llc_hdr hd; 49 u8 sender_mac[ETH_ALEN]; 50 u8 sender_gid[SMC_GID_SIZE]; 51 u8 sender_qp_num[3]; 52 u8 link_num; 53 u8 link_uid[SMC_LGR_ID_SIZE]; 54 u8 max_links; 55 u8 max_conns; 56 u8 reserved[8]; 57 }; 58 59 #define SMC_LLC_FLAG_ADD_LNK_REJ 0x40 60 #define SMC_LLC_REJ_RSN_NO_ALT_PATH 1 61 62 struct smc_llc_msg_add_link { /* type 0x02 */ 63 struct smc_llc_hdr hd; 64 u8 sender_mac[ETH_ALEN]; 65 u8 reserved2[2]; 66 u8 sender_gid[SMC_GID_SIZE]; 67 u8 sender_qp_num[3]; 68 u8 link_num; 69 #if defined(__BIG_ENDIAN_BITFIELD) 70 u8 reserved3 : 4, 71 qp_mtu : 4; 72 #elif defined(__LITTLE_ENDIAN_BITFIELD) 73 u8 qp_mtu : 4, 74 reserved3 : 4; 75 #endif 76 u8 initial_psn[3]; 77 u8 reserved[8]; 78 }; 79 80 struct smc_llc_msg_add_link_cont_rt { 81 __be32 rmb_key; 82 __be32 rmb_key_new; 83 __be64 rmb_vaddr_new; 84 }; 85 86 struct smc_llc_msg_add_link_v2_ext { 87 #if defined(__BIG_ENDIAN_BITFIELD) 88 u8 v2_direct : 1, 89 reserved : 7; 90 #elif defined(__LITTLE_ENDIAN_BITFIELD) 91 u8 reserved : 7, 92 v2_direct : 1; 93 #endif 94 u8 reserved2; 95 u8 client_target_gid[SMC_GID_SIZE]; 96 u8 reserved3[8]; 97 u16 num_rkeys; 98 struct smc_llc_msg_add_link_cont_rt rt[]; 99 } __packed; /* format defined in 100 * IBM Shared Memory Communications Version 2 101 * (https://www.ibm.com/support/pages/node/6326337) 102 */ 103 104 struct smc_llc_msg_req_add_link_v2 { 105 struct smc_llc_hdr hd; 106 u8 reserved[20]; 107 u8 gid_cnt; 108 u8 reserved2[3]; 109 u8 gid[][SMC_GID_SIZE]; 110 }; 111 112 #define SMC_LLC_RKEYS_PER_CONT_MSG 2 113 114 struct smc_llc_msg_add_link_cont { /* type 0x03 */ 115 struct smc_llc_hdr hd; 116 u8 link_num; 117 u8 num_rkeys; 118 u8 reserved2[2]; 119 struct smc_llc_msg_add_link_cont_rt rt[SMC_LLC_RKEYS_PER_CONT_MSG]; 120 u8 reserved[4]; 121 } __packed; /* format defined in RFC7609 */ 122 123 #define SMC_LLC_FLAG_DEL_LINK_ALL 0x40 124 #define SMC_LLC_FLAG_DEL_LINK_ORDERLY 0x20 125 126 struct smc_llc_msg_del_link { /* type 0x04 */ 127 struct smc_llc_hdr hd; 128 u8 link_num; 129 __be32 reason; 130 u8 reserved[35]; 131 } __packed; /* format defined in RFC7609 */ 132 133 struct smc_llc_msg_test_link { /* type 0x07 */ 134 struct smc_llc_hdr hd; 135 u8 user_data[16]; 136 u8 reserved[24]; 137 }; 138 139 struct smc_rmb_rtoken { 140 union { 141 u8 num_rkeys; /* first rtoken byte of CONFIRM LINK msg */ 142 /* is actually the num of rtokens, first */ 143 /* rtoken is always for the current link */ 144 u8 link_id; /* link id of the rtoken */ 145 }; 146 __be32 rmb_key; 147 __be64 rmb_vaddr; 148 } __packed; /* format defined in RFC7609 */ 149 150 #define SMC_LLC_RKEYS_PER_MSG 3 151 #define SMC_LLC_RKEYS_PER_MSG_V2 255 152 153 struct smc_llc_msg_confirm_rkey { /* type 0x06 */ 154 struct smc_llc_hdr hd; 155 struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG]; 156 u8 reserved; 157 }; 158 159 #define SMC_LLC_DEL_RKEY_MAX 8 160 #define SMC_LLC_FLAG_RKEY_RETRY 0x10 161 #define SMC_LLC_FLAG_RKEY_NEG 0x20 162 163 struct smc_llc_msg_delete_rkey { /* type 0x09 */ 164 struct smc_llc_hdr hd; 165 u8 num_rkeys; 166 u8 err_mask; 167 u8 reserved[2]; 168 __be32 rkey[8]; 169 u8 reserved2[4]; 170 }; 171 172 struct smc_llc_msg_delete_rkey_v2 { /* type 0x29 */ 173 struct smc_llc_hdr hd; 174 u8 num_rkeys; 175 u8 num_inval_rkeys; 176 u8 reserved[2]; 177 __be32 rkey[]; 178 }; 179 180 union smc_llc_msg { 181 struct smc_llc_msg_confirm_link confirm_link; 182 struct smc_llc_msg_add_link add_link; 183 struct smc_llc_msg_req_add_link_v2 req_add_link; 184 struct smc_llc_msg_add_link_cont add_link_cont; 185 struct smc_llc_msg_del_link delete_link; 186 187 struct smc_llc_msg_confirm_rkey confirm_rkey; 188 struct smc_llc_msg_delete_rkey delete_rkey; 189 190 struct smc_llc_msg_test_link test_link; 191 struct { 192 struct smc_llc_hdr hdr; 193 u8 data[SMC_LLC_DATA_LEN]; 194 } raw; 195 }; 196 197 #define SMC_LLC_FLAG_RESP 0x80 198 199 struct smc_llc_qentry { 200 struct list_head list; 201 struct smc_link *link; 202 union smc_llc_msg msg; 203 }; 204 205 static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc); 206 207 struct smc_llc_qentry *smc_llc_flow_qentry_clr(struct smc_llc_flow *flow) 208 { 209 struct smc_llc_qentry *qentry = flow->qentry; 210 211 flow->qentry = NULL; 212 return qentry; 213 } 214 215 void smc_llc_flow_qentry_del(struct smc_llc_flow *flow) 216 { 217 struct smc_llc_qentry *qentry; 218 219 if (flow->qentry) { 220 qentry = flow->qentry; 221 flow->qentry = NULL; 222 kfree(qentry); 223 } 224 } 225 226 static inline void smc_llc_flow_qentry_set(struct smc_llc_flow *flow, 227 struct smc_llc_qentry *qentry) 228 { 229 flow->qentry = qentry; 230 } 231 232 static void smc_llc_flow_parallel(struct smc_link_group *lgr, u8 flow_type, 233 struct smc_llc_qentry *qentry) 234 { 235 u8 msg_type = qentry->msg.raw.hdr.common.llc_type; 236 237 if ((msg_type == SMC_LLC_ADD_LINK || msg_type == SMC_LLC_DELETE_LINK) && 238 flow_type != msg_type && !lgr->delayed_event) { 239 lgr->delayed_event = qentry; 240 return; 241 } 242 /* drop parallel or already-in-progress llc requests */ 243 if (flow_type != msg_type) 244 pr_warn_once("smc: SMC-R lg %*phN net %llu dropped parallel " 245 "LLC msg: msg %d flow %d role %d\n", 246 SMC_LGR_ID_SIZE, &lgr->id, 247 lgr->net->net_cookie, 248 qentry->msg.raw.hdr.common.type, 249 flow_type, lgr->role); 250 kfree(qentry); 251 } 252 253 /* try to start a new llc flow, initiated by an incoming llc msg */ 254 static bool smc_llc_flow_start(struct smc_llc_flow *flow, 255 struct smc_llc_qentry *qentry) 256 { 257 struct smc_link_group *lgr = qentry->link->lgr; 258 259 spin_lock_bh(&lgr->llc_flow_lock); 260 if (flow->type) { 261 /* a flow is already active */ 262 smc_llc_flow_parallel(lgr, flow->type, qentry); 263 spin_unlock_bh(&lgr->llc_flow_lock); 264 return false; 265 } 266 switch (qentry->msg.raw.hdr.common.llc_type) { 267 case SMC_LLC_ADD_LINK: 268 flow->type = SMC_LLC_FLOW_ADD_LINK; 269 break; 270 case SMC_LLC_DELETE_LINK: 271 flow->type = SMC_LLC_FLOW_DEL_LINK; 272 break; 273 case SMC_LLC_CONFIRM_RKEY: 274 case SMC_LLC_DELETE_RKEY: 275 flow->type = SMC_LLC_FLOW_RKEY; 276 break; 277 default: 278 flow->type = SMC_LLC_FLOW_NONE; 279 } 280 smc_llc_flow_qentry_set(flow, qentry); 281 spin_unlock_bh(&lgr->llc_flow_lock); 282 return true; 283 } 284 285 /* start a new local llc flow, wait till current flow finished */ 286 int smc_llc_flow_initiate(struct smc_link_group *lgr, 287 enum smc_llc_flowtype type) 288 { 289 enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE; 290 int rc; 291 292 /* all flows except confirm_rkey and delete_rkey are exclusive, 293 * confirm/delete rkey flows can run concurrently (local and remote) 294 */ 295 if (type == SMC_LLC_FLOW_RKEY) 296 allowed_remote = SMC_LLC_FLOW_RKEY; 297 again: 298 if (list_empty(&lgr->list)) 299 return -ENODEV; 300 spin_lock_bh(&lgr->llc_flow_lock); 301 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE && 302 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE || 303 lgr->llc_flow_rmt.type == allowed_remote)) { 304 lgr->llc_flow_lcl.type = type; 305 spin_unlock_bh(&lgr->llc_flow_lock); 306 return 0; 307 } 308 spin_unlock_bh(&lgr->llc_flow_lock); 309 rc = wait_event_timeout(lgr->llc_flow_waiter, (list_empty(&lgr->list) || 310 (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE && 311 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE || 312 lgr->llc_flow_rmt.type == allowed_remote))), 313 SMC_LLC_WAIT_TIME * 10); 314 if (!rc) 315 return -ETIMEDOUT; 316 goto again; 317 } 318 319 /* finish the current llc flow */ 320 void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow) 321 { 322 spin_lock_bh(&lgr->llc_flow_lock); 323 memset(flow, 0, sizeof(*flow)); 324 flow->type = SMC_LLC_FLOW_NONE; 325 spin_unlock_bh(&lgr->llc_flow_lock); 326 if (!list_empty(&lgr->list) && lgr->delayed_event && 327 flow == &lgr->llc_flow_lcl) 328 schedule_work(&lgr->llc_event_work); 329 else 330 wake_up(&lgr->llc_flow_waiter); 331 } 332 333 /* lnk is optional and used for early wakeup when link goes down, useful in 334 * cases where we wait for a response on the link after we sent a request 335 */ 336 struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr, 337 struct smc_link *lnk, 338 int time_out, u8 exp_msg) 339 { 340 struct smc_llc_flow *flow = &lgr->llc_flow_lcl; 341 u8 rcv_msg; 342 343 wait_event_timeout(lgr->llc_msg_waiter, 344 (flow->qentry || 345 (lnk && !smc_link_usable(lnk)) || 346 list_empty(&lgr->list)), 347 time_out); 348 if (!flow->qentry || 349 (lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) { 350 smc_llc_flow_qentry_del(flow); 351 goto out; 352 } 353 rcv_msg = flow->qentry->msg.raw.hdr.common.llc_type; 354 if (exp_msg && rcv_msg != exp_msg) { 355 if (exp_msg == SMC_LLC_ADD_LINK && 356 rcv_msg == SMC_LLC_DELETE_LINK) { 357 /* flow_start will delay the unexpected msg */ 358 smc_llc_flow_start(&lgr->llc_flow_lcl, 359 smc_llc_flow_qentry_clr(flow)); 360 return NULL; 361 } 362 pr_warn_once("smc: SMC-R lg %*phN net %llu dropped unexpected LLC msg: " 363 "msg %d exp %d flow %d role %d flags %x\n", 364 SMC_LGR_ID_SIZE, &lgr->id, lgr->net->net_cookie, 365 rcv_msg, exp_msg, 366 flow->type, lgr->role, 367 flow->qentry->msg.raw.hdr.flags); 368 smc_llc_flow_qentry_del(flow); 369 } 370 out: 371 return flow->qentry; 372 } 373 374 /********************************** send *************************************/ 375 376 struct smc_llc_tx_pend { 377 }; 378 379 /* handler for send/transmission completion of an LLC msg */ 380 static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend, 381 struct smc_link *link, 382 enum ib_wc_status wc_status) 383 { 384 /* future work: handle wc_status error for recovery and failover */ 385 } 386 387 /** 388 * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits 389 * @link: Pointer to SMC link used for sending LLC control message. 390 * @wr_buf: Out variable returning pointer to work request payload buffer. 391 * @pend: Out variable returning pointer to private pending WR tracking. 392 * It's the context the transmit complete handler will get. 393 * 394 * Reserves and pre-fills an entry for a pending work request send/tx. 395 * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx. 396 * Can sleep due to smc_get_ctrl_buf (if not in softirq context). 397 * 398 * Return: 0 on success, otherwise an error value. 399 */ 400 static int smc_llc_add_pending_send(struct smc_link *link, 401 struct smc_wr_buf **wr_buf, 402 struct smc_wr_tx_pend_priv **pend) 403 { 404 int rc; 405 406 rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL, 407 pend); 408 if (rc < 0) 409 return rc; 410 BUILD_BUG_ON_MSG( 411 sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE, 412 "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)"); 413 BUILD_BUG_ON_MSG( 414 sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE, 415 "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()"); 416 BUILD_BUG_ON_MSG( 417 sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE, 418 "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)"); 419 return 0; 420 } 421 422 static int smc_llc_add_pending_send_v2(struct smc_link *link, 423 struct smc_wr_v2_buf **wr_buf, 424 struct smc_wr_tx_pend_priv **pend) 425 { 426 int rc; 427 428 rc = smc_wr_tx_get_v2_slot(link, smc_llc_tx_handler, wr_buf, pend); 429 if (rc < 0) 430 return rc; 431 return 0; 432 } 433 434 static void smc_llc_init_msg_hdr(struct smc_llc_hdr *hdr, 435 struct smc_link_group *lgr, size_t len) 436 { 437 if (lgr->smc_version == SMC_V2) { 438 hdr->common.llc_version = SMC_V2; 439 hdr->length_v2 = len; 440 } else { 441 hdr->common.llc_version = 0; 442 hdr->length = len; 443 } 444 } 445 446 /* high-level API to send LLC confirm link */ 447 int smc_llc_send_confirm_link(struct smc_link *link, 448 enum smc_llc_reqresp reqresp) 449 { 450 struct smc_llc_msg_confirm_link *confllc; 451 struct smc_wr_tx_pend_priv *pend; 452 struct smc_wr_buf *wr_buf; 453 int rc; 454 455 if (!smc_wr_tx_link_hold(link)) 456 return -ENOLINK; 457 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 458 if (rc) 459 goto put_out; 460 confllc = (struct smc_llc_msg_confirm_link *)wr_buf; 461 memset(confllc, 0, sizeof(*confllc)); 462 confllc->hd.common.llc_type = SMC_LLC_CONFIRM_LINK; 463 smc_llc_init_msg_hdr(&confllc->hd, link->lgr, sizeof(*confllc)); 464 confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC; 465 if (reqresp == SMC_LLC_RESP) 466 confllc->hd.flags |= SMC_LLC_FLAG_RESP; 467 memcpy(confllc->sender_mac, link->smcibdev->mac[link->ibport - 1], 468 ETH_ALEN); 469 memcpy(confllc->sender_gid, link->gid, SMC_GID_SIZE); 470 hton24(confllc->sender_qp_num, link->roce_qp->qp_num); 471 confllc->link_num = link->link_id; 472 memcpy(confllc->link_uid, link->link_uid, SMC_LGR_ID_SIZE); 473 confllc->max_links = SMC_LINKS_ADD_LNK_MAX; 474 if (link->lgr->smc_version == SMC_V2 && 475 link->lgr->peer_smc_release >= SMC_RELEASE_1) { 476 confllc->max_conns = link->lgr->max_conns; 477 confllc->max_links = link->lgr->max_links; 478 } 479 /* send llc message */ 480 rc = smc_wr_tx_send(link, pend); 481 put_out: 482 smc_wr_tx_link_put(link); 483 return rc; 484 } 485 486 /* send LLC confirm rkey request */ 487 static int smc_llc_send_confirm_rkey(struct smc_link *send_link, 488 struct smc_buf_desc *rmb_desc) 489 { 490 struct smc_llc_msg_confirm_rkey *rkeyllc; 491 struct smc_wr_tx_pend_priv *pend; 492 struct smc_wr_buf *wr_buf; 493 struct smc_link *link; 494 int i, rc, rtok_ix; 495 496 if (!smc_wr_tx_link_hold(send_link)) 497 return -ENOLINK; 498 rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend); 499 if (rc) 500 goto put_out; 501 rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf; 502 memset(rkeyllc, 0, sizeof(*rkeyllc)); 503 rkeyllc->hd.common.llc_type = SMC_LLC_CONFIRM_RKEY; 504 smc_llc_init_msg_hdr(&rkeyllc->hd, send_link->lgr, sizeof(*rkeyllc)); 505 506 rtok_ix = 1; 507 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) { 508 link = &send_link->lgr->lnk[i]; 509 if (smc_link_active(link) && link != send_link) { 510 rkeyllc->rtoken[rtok_ix].link_id = link->link_id; 511 rkeyllc->rtoken[rtok_ix].rmb_key = 512 htonl(rmb_desc->mr[link->link_idx]->rkey); 513 rkeyllc->rtoken[rtok_ix].rmb_vaddr = rmb_desc->is_vm ? 514 cpu_to_be64((uintptr_t)rmb_desc->cpu_addr) : 515 cpu_to_be64((u64)sg_dma_address 516 (rmb_desc->sgt[link->link_idx].sgl)); 517 rtok_ix++; 518 } 519 } 520 /* rkey of send_link is in rtoken[0] */ 521 rkeyllc->rtoken[0].num_rkeys = rtok_ix - 1; 522 rkeyllc->rtoken[0].rmb_key = 523 htonl(rmb_desc->mr[send_link->link_idx]->rkey); 524 rkeyllc->rtoken[0].rmb_vaddr = rmb_desc->is_vm ? 525 cpu_to_be64((uintptr_t)rmb_desc->cpu_addr) : 526 cpu_to_be64((u64)sg_dma_address 527 (rmb_desc->sgt[send_link->link_idx].sgl)); 528 /* send llc message */ 529 rc = smc_wr_tx_send(send_link, pend); 530 put_out: 531 smc_wr_tx_link_put(send_link); 532 return rc; 533 } 534 535 /* send LLC delete rkey request */ 536 static int smc_llc_send_delete_rkey(struct smc_link *link, 537 struct smc_buf_desc *rmb_desc) 538 { 539 struct smc_llc_msg_delete_rkey *rkeyllc; 540 struct smc_wr_tx_pend_priv *pend; 541 struct smc_wr_buf *wr_buf; 542 int rc; 543 544 if (!smc_wr_tx_link_hold(link)) 545 return -ENOLINK; 546 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 547 if (rc) 548 goto put_out; 549 rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf; 550 memset(rkeyllc, 0, sizeof(*rkeyllc)); 551 rkeyllc->hd.common.llc_type = SMC_LLC_DELETE_RKEY; 552 smc_llc_init_msg_hdr(&rkeyllc->hd, link->lgr, sizeof(*rkeyllc)); 553 rkeyllc->num_rkeys = 1; 554 rkeyllc->rkey[0] = htonl(rmb_desc->mr[link->link_idx]->rkey); 555 /* send llc message */ 556 rc = smc_wr_tx_send(link, pend); 557 put_out: 558 smc_wr_tx_link_put(link); 559 return rc; 560 } 561 562 /* return first buffer from any of the next buf lists */ 563 static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr, 564 int *buf_lst) 565 { 566 struct smc_buf_desc *buf_pos; 567 568 while (*buf_lst < SMC_RMBE_SIZES) { 569 buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst], 570 struct smc_buf_desc, list); 571 if (buf_pos) 572 return buf_pos; 573 (*buf_lst)++; 574 } 575 return NULL; 576 } 577 578 /* return next rmb from buffer lists */ 579 static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr, 580 int *buf_lst, 581 struct smc_buf_desc *buf_pos) 582 { 583 struct smc_buf_desc *buf_next; 584 585 if (!buf_pos) 586 return _smc_llc_get_next_rmb(lgr, buf_lst); 587 588 if (list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) { 589 (*buf_lst)++; 590 return _smc_llc_get_next_rmb(lgr, buf_lst); 591 } 592 buf_next = list_next_entry(buf_pos, list); 593 return buf_next; 594 } 595 596 static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr, 597 int *buf_lst) 598 { 599 *buf_lst = 0; 600 return smc_llc_get_next_rmb(lgr, buf_lst, NULL); 601 } 602 603 static int smc_llc_fill_ext_v2(struct smc_llc_msg_add_link_v2_ext *ext, 604 struct smc_link *link, struct smc_link *link_new) 605 { 606 struct smc_link_group *lgr = link->lgr; 607 struct smc_buf_desc *buf_pos; 608 int prim_lnk_idx, lnk_idx, i; 609 struct smc_buf_desc *rmb; 610 int len = sizeof(*ext); 611 int buf_lst; 612 613 ext->v2_direct = !lgr->uses_gateway; 614 memcpy(ext->client_target_gid, link_new->gid, SMC_GID_SIZE); 615 616 prim_lnk_idx = link->link_idx; 617 lnk_idx = link_new->link_idx; 618 down_write(&lgr->rmbs_lock); 619 ext->num_rkeys = lgr->conns_num; 620 if (!ext->num_rkeys) 621 goto out; 622 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst); 623 for (i = 0; i < ext->num_rkeys; i++) { 624 while (buf_pos && !(buf_pos)->used) 625 buf_pos = smc_llc_get_next_rmb(lgr, &buf_lst, buf_pos); 626 if (!buf_pos) 627 break; 628 rmb = buf_pos; 629 ext->rt[i].rmb_key = htonl(rmb->mr[prim_lnk_idx]->rkey); 630 ext->rt[i].rmb_key_new = htonl(rmb->mr[lnk_idx]->rkey); 631 ext->rt[i].rmb_vaddr_new = rmb->is_vm ? 632 cpu_to_be64((uintptr_t)rmb->cpu_addr) : 633 cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl)); 634 buf_pos = smc_llc_get_next_rmb(lgr, &buf_lst, buf_pos); 635 } 636 len += i * sizeof(ext->rt[0]); 637 out: 638 up_write(&lgr->rmbs_lock); 639 return len; 640 } 641 642 /* send ADD LINK request or response */ 643 int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[], 644 struct smc_link *link_new, 645 enum smc_llc_reqresp reqresp) 646 { 647 struct smc_llc_msg_add_link_v2_ext *ext = NULL; 648 struct smc_llc_msg_add_link *addllc; 649 struct smc_wr_tx_pend_priv *pend; 650 int len = sizeof(*addllc); 651 int rc; 652 653 if (!smc_wr_tx_link_hold(link)) 654 return -ENOLINK; 655 if (link->lgr->smc_version == SMC_V2) { 656 struct smc_wr_v2_buf *wr_buf; 657 658 rc = smc_llc_add_pending_send_v2(link, &wr_buf, &pend); 659 if (rc) 660 goto put_out; 661 addllc = (struct smc_llc_msg_add_link *)wr_buf; 662 ext = (struct smc_llc_msg_add_link_v2_ext *) 663 &wr_buf->raw[sizeof(*addllc)]; 664 memset(ext, 0, SMC_WR_TX_SIZE); 665 } else { 666 struct smc_wr_buf *wr_buf; 667 668 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 669 if (rc) 670 goto put_out; 671 addllc = (struct smc_llc_msg_add_link *)wr_buf; 672 } 673 674 memset(addllc, 0, sizeof(*addllc)); 675 addllc->hd.common.llc_type = SMC_LLC_ADD_LINK; 676 if (reqresp == SMC_LLC_RESP) 677 addllc->hd.flags |= SMC_LLC_FLAG_RESP; 678 memcpy(addllc->sender_mac, mac, ETH_ALEN); 679 memcpy(addllc->sender_gid, gid, SMC_GID_SIZE); 680 if (link_new) { 681 addllc->link_num = link_new->link_id; 682 hton24(addllc->sender_qp_num, link_new->roce_qp->qp_num); 683 hton24(addllc->initial_psn, link_new->psn_initial); 684 if (reqresp == SMC_LLC_REQ) 685 addllc->qp_mtu = link_new->path_mtu; 686 else 687 addllc->qp_mtu = min(link_new->path_mtu, 688 link_new->peer_mtu); 689 } 690 if (ext && link_new) 691 len += smc_llc_fill_ext_v2(ext, link, link_new); 692 smc_llc_init_msg_hdr(&addllc->hd, link->lgr, len); 693 /* send llc message */ 694 if (link->lgr->smc_version == SMC_V2) 695 rc = smc_wr_tx_v2_send(link, pend, len); 696 else 697 rc = smc_wr_tx_send(link, pend); 698 put_out: 699 smc_wr_tx_link_put(link); 700 return rc; 701 } 702 703 /* send DELETE LINK request or response */ 704 int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id, 705 enum smc_llc_reqresp reqresp, bool orderly, 706 u32 reason) 707 { 708 struct smc_llc_msg_del_link *delllc; 709 struct smc_wr_tx_pend_priv *pend; 710 struct smc_wr_buf *wr_buf; 711 int rc; 712 713 if (!smc_wr_tx_link_hold(link)) 714 return -ENOLINK; 715 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 716 if (rc) 717 goto put_out; 718 delllc = (struct smc_llc_msg_del_link *)wr_buf; 719 720 memset(delllc, 0, sizeof(*delllc)); 721 delllc->hd.common.llc_type = SMC_LLC_DELETE_LINK; 722 smc_llc_init_msg_hdr(&delllc->hd, link->lgr, sizeof(*delllc)); 723 if (reqresp == SMC_LLC_RESP) 724 delllc->hd.flags |= SMC_LLC_FLAG_RESP; 725 if (orderly) 726 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY; 727 if (link_del_id) 728 delllc->link_num = link_del_id; 729 else 730 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL; 731 delllc->reason = htonl(reason); 732 /* send llc message */ 733 rc = smc_wr_tx_send(link, pend); 734 put_out: 735 smc_wr_tx_link_put(link); 736 return rc; 737 } 738 739 /* send LLC test link request */ 740 static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16]) 741 { 742 struct smc_llc_msg_test_link *testllc; 743 struct smc_wr_tx_pend_priv *pend; 744 struct smc_wr_buf *wr_buf; 745 int rc; 746 747 if (!smc_wr_tx_link_hold(link)) 748 return -ENOLINK; 749 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 750 if (rc) 751 goto put_out; 752 testllc = (struct smc_llc_msg_test_link *)wr_buf; 753 memset(testllc, 0, sizeof(*testllc)); 754 testllc->hd.common.llc_type = SMC_LLC_TEST_LINK; 755 smc_llc_init_msg_hdr(&testllc->hd, link->lgr, sizeof(*testllc)); 756 memcpy(testllc->user_data, user_data, sizeof(testllc->user_data)); 757 /* send llc message */ 758 rc = smc_wr_tx_send(link, pend); 759 put_out: 760 smc_wr_tx_link_put(link); 761 return rc; 762 } 763 764 /* schedule an llc send on link, may wait for buffers */ 765 static int smc_llc_send_message(struct smc_link *link, void *llcbuf) 766 { 767 struct smc_wr_tx_pend_priv *pend; 768 struct smc_wr_buf *wr_buf; 769 int rc; 770 771 if (!smc_wr_tx_link_hold(link)) 772 return -ENOLINK; 773 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 774 if (rc) 775 goto put_out; 776 memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg)); 777 rc = smc_wr_tx_send(link, pend); 778 put_out: 779 smc_wr_tx_link_put(link); 780 return rc; 781 } 782 783 /* schedule an llc send on link, may wait for buffers, 784 * and wait for send completion notification. 785 * @return 0 on success 786 */ 787 static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf) 788 { 789 struct smc_wr_tx_pend_priv *pend; 790 struct smc_wr_buf *wr_buf; 791 int rc; 792 793 if (!smc_wr_tx_link_hold(link)) 794 return -ENOLINK; 795 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 796 if (rc) 797 goto put_out; 798 memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg)); 799 rc = smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME); 800 put_out: 801 smc_wr_tx_link_put(link); 802 return rc; 803 } 804 805 /********************************* receive ***********************************/ 806 807 static int smc_llc_alloc_alt_link(struct smc_link_group *lgr, 808 enum smc_lgr_type lgr_new_t) 809 { 810 int i; 811 812 if (lgr->type == SMC_LGR_SYMMETRIC || 813 (lgr->type != SMC_LGR_SINGLE && 814 (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL || 815 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER))) 816 return -EMLINK; 817 818 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL || 819 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) { 820 for (i = SMC_LINKS_PER_LGR_MAX - 1; i >= 0; i--) 821 if (lgr->lnk[i].state == SMC_LNK_UNUSED) 822 return i; 823 } else { 824 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) 825 if (lgr->lnk[i].state == SMC_LNK_UNUSED) 826 return i; 827 } 828 return -EMLINK; 829 } 830 831 /* send one add_link_continue msg */ 832 static int smc_llc_add_link_cont(struct smc_link *link, 833 struct smc_link *link_new, u8 *num_rkeys_todo, 834 int *buf_lst, struct smc_buf_desc **buf_pos) 835 { 836 struct smc_llc_msg_add_link_cont *addc_llc; 837 struct smc_link_group *lgr = link->lgr; 838 int prim_lnk_idx, lnk_idx, i, rc; 839 struct smc_wr_tx_pend_priv *pend; 840 struct smc_wr_buf *wr_buf; 841 struct smc_buf_desc *rmb; 842 u8 n; 843 844 if (!smc_wr_tx_link_hold(link)) 845 return -ENOLINK; 846 rc = smc_llc_add_pending_send(link, &wr_buf, &pend); 847 if (rc) 848 goto put_out; 849 addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf; 850 memset(addc_llc, 0, sizeof(*addc_llc)); 851 852 prim_lnk_idx = link->link_idx; 853 lnk_idx = link_new->link_idx; 854 addc_llc->link_num = link_new->link_id; 855 addc_llc->num_rkeys = *num_rkeys_todo; 856 n = *num_rkeys_todo; 857 for (i = 0; i < min_t(u8, n, SMC_LLC_RKEYS_PER_CONT_MSG); i++) { 858 while (*buf_pos && !(*buf_pos)->used) 859 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos); 860 if (!*buf_pos) { 861 addc_llc->num_rkeys = addc_llc->num_rkeys - 862 *num_rkeys_todo; 863 *num_rkeys_todo = 0; 864 break; 865 } 866 rmb = *buf_pos; 867 868 addc_llc->rt[i].rmb_key = htonl(rmb->mr[prim_lnk_idx]->rkey); 869 addc_llc->rt[i].rmb_key_new = htonl(rmb->mr[lnk_idx]->rkey); 870 addc_llc->rt[i].rmb_vaddr_new = rmb->is_vm ? 871 cpu_to_be64((uintptr_t)rmb->cpu_addr) : 872 cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl)); 873 874 (*num_rkeys_todo)--; 875 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos); 876 } 877 addc_llc->hd.common.llc_type = SMC_LLC_ADD_LINK_CONT; 878 addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont); 879 if (lgr->role == SMC_CLNT) 880 addc_llc->hd.flags |= SMC_LLC_FLAG_RESP; 881 rc = smc_wr_tx_send(link, pend); 882 put_out: 883 smc_wr_tx_link_put(link); 884 return rc; 885 } 886 887 static int smc_llc_cli_rkey_exchange(struct smc_link *link, 888 struct smc_link *link_new) 889 { 890 struct smc_llc_msg_add_link_cont *addc_llc; 891 struct smc_link_group *lgr = link->lgr; 892 u8 max, num_rkeys_send, num_rkeys_recv; 893 struct smc_llc_qentry *qentry; 894 struct smc_buf_desc *buf_pos; 895 int buf_lst; 896 int rc = 0; 897 int i; 898 899 down_write(&lgr->rmbs_lock); 900 num_rkeys_send = lgr->conns_num; 901 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst); 902 do { 903 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME, 904 SMC_LLC_ADD_LINK_CONT); 905 if (!qentry) { 906 rc = -ETIMEDOUT; 907 break; 908 } 909 addc_llc = &qentry->msg.add_link_cont; 910 num_rkeys_recv = addc_llc->num_rkeys; 911 max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG); 912 for (i = 0; i < max; i++) { 913 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx, 914 addc_llc->rt[i].rmb_key, 915 addc_llc->rt[i].rmb_vaddr_new, 916 addc_llc->rt[i].rmb_key_new); 917 num_rkeys_recv--; 918 } 919 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 920 rc = smc_llc_add_link_cont(link, link_new, &num_rkeys_send, 921 &buf_lst, &buf_pos); 922 if (rc) 923 break; 924 } while (num_rkeys_send || num_rkeys_recv); 925 926 up_write(&lgr->rmbs_lock); 927 return rc; 928 } 929 930 /* prepare and send an add link reject response */ 931 static int smc_llc_cli_add_link_reject(struct smc_llc_qentry *qentry) 932 { 933 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP; 934 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_ADD_LNK_REJ; 935 qentry->msg.raw.hdr.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH; 936 smc_llc_init_msg_hdr(&qentry->msg.raw.hdr, qentry->link->lgr, 937 sizeof(qentry->msg)); 938 return smc_llc_send_message(qentry->link, &qentry->msg); 939 } 940 941 static int smc_llc_cli_conf_link(struct smc_link *link, 942 struct smc_init_info *ini, 943 struct smc_link *link_new, 944 enum smc_lgr_type lgr_new_t) 945 { 946 struct smc_link_group *lgr = link->lgr; 947 struct smc_llc_qentry *qentry = NULL; 948 int rc = 0; 949 950 /* receive CONFIRM LINK request over RoCE fabric */ 951 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0); 952 if (!qentry) { 953 rc = smc_llc_send_delete_link(link, link_new->link_id, 954 SMC_LLC_REQ, false, 955 SMC_LLC_DEL_LOST_PATH); 956 return -ENOLINK; 957 } 958 if (qentry->msg.raw.hdr.common.llc_type != SMC_LLC_CONFIRM_LINK) { 959 /* received DELETE_LINK instead */ 960 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP; 961 smc_llc_send_message(link, &qentry->msg); 962 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 963 return -ENOLINK; 964 } 965 smc_llc_save_peer_uid(qentry); 966 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 967 968 rc = smc_ib_modify_qp_rts(link_new); 969 if (rc) { 970 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ, 971 false, SMC_LLC_DEL_LOST_PATH); 972 return -ENOLINK; 973 } 974 smc_wr_remember_qp_attr(link_new); 975 976 rc = smcr_buf_reg_lgr(link_new); 977 if (rc) { 978 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ, 979 false, SMC_LLC_DEL_LOST_PATH); 980 return -ENOLINK; 981 } 982 983 /* send CONFIRM LINK response over RoCE fabric */ 984 rc = smc_llc_send_confirm_link(link_new, SMC_LLC_RESP); 985 if (rc) { 986 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ, 987 false, SMC_LLC_DEL_LOST_PATH); 988 return -ENOLINK; 989 } 990 smc_llc_link_active(link_new); 991 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL || 992 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) 993 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx); 994 else 995 smcr_lgr_set_type(lgr, lgr_new_t); 996 return 0; 997 } 998 999 static void smc_llc_save_add_link_rkeys(struct smc_link *link, 1000 struct smc_link *link_new, 1001 u8 *llc_msg) 1002 { 1003 struct smc_llc_msg_add_link_v2_ext *ext; 1004 struct smc_link_group *lgr = link->lgr; 1005 int max, i; 1006 1007 ext = (struct smc_llc_msg_add_link_v2_ext *)(llc_msg + 1008 SMC_WR_TX_SIZE); 1009 max = min_t(u8, ext->num_rkeys, SMC_LLC_RKEYS_PER_MSG_V2); 1010 down_write(&lgr->rmbs_lock); 1011 for (i = 0; i < max; i++) { 1012 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx, 1013 ext->rt[i].rmb_key, 1014 ext->rt[i].rmb_vaddr_new, 1015 ext->rt[i].rmb_key_new); 1016 } 1017 up_write(&lgr->rmbs_lock); 1018 } 1019 1020 static void smc_llc_save_add_link_info(struct smc_link *link, 1021 struct smc_llc_msg_add_link *add_llc) 1022 { 1023 link->peer_qpn = ntoh24(add_llc->sender_qp_num); 1024 memcpy(link->peer_gid, add_llc->sender_gid, SMC_GID_SIZE); 1025 memcpy(link->peer_mac, add_llc->sender_mac, ETH_ALEN); 1026 link->peer_psn = ntoh24(add_llc->initial_psn); 1027 link->peer_mtu = add_llc->qp_mtu; 1028 } 1029 1030 /* as an SMC client, process an add link request */ 1031 int smc_llc_cli_add_link(struct smc_link *link, struct smc_llc_qentry *qentry) 1032 { 1033 struct smc_llc_msg_add_link *llc = &qentry->msg.add_link; 1034 enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC; 1035 struct smc_link_group *lgr = smc_get_lgr(link); 1036 struct smc_init_info *ini = NULL; 1037 struct smc_link *lnk_new = NULL; 1038 int lnk_idx, rc = 0; 1039 1040 if (!llc->qp_mtu) 1041 goto out_reject; 1042 1043 ini = kzalloc(sizeof(*ini), GFP_KERNEL); 1044 if (!ini) { 1045 rc = -ENOMEM; 1046 goto out_reject; 1047 } 1048 1049 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1) { 1050 rc = 0; 1051 goto out_reject; 1052 } 1053 1054 ini->vlan_id = lgr->vlan_id; 1055 if (lgr->smc_version == SMC_V2) { 1056 ini->check_smcrv2 = true; 1057 ini->smcrv2.saddr = lgr->saddr; 1058 ini->smcrv2.daddr = smc_ib_gid_to_ipv4(llc->sender_gid); 1059 } 1060 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev); 1061 if (!memcmp(llc->sender_gid, link->peer_gid, SMC_GID_SIZE) && 1062 (lgr->smc_version == SMC_V2 || 1063 !memcmp(llc->sender_mac, link->peer_mac, ETH_ALEN))) { 1064 if (!ini->ib_dev && !ini->smcrv2.ib_dev_v2) 1065 goto out_reject; 1066 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER; 1067 } 1068 if (lgr->smc_version == SMC_V2 && !ini->smcrv2.ib_dev_v2) { 1069 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL; 1070 ini->smcrv2.ib_dev_v2 = link->smcibdev; 1071 ini->smcrv2.ib_port_v2 = link->ibport; 1072 } else if (lgr->smc_version < SMC_V2 && !ini->ib_dev) { 1073 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL; 1074 ini->ib_dev = link->smcibdev; 1075 ini->ib_port = link->ibport; 1076 } 1077 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t); 1078 if (lnk_idx < 0) 1079 goto out_reject; 1080 lnk_new = &lgr->lnk[lnk_idx]; 1081 rc = smcr_link_init(lgr, lnk_new, lnk_idx, ini); 1082 if (rc) 1083 goto out_reject; 1084 smc_llc_save_add_link_info(lnk_new, llc); 1085 lnk_new->link_id = llc->link_num; /* SMC server assigns link id */ 1086 smc_llc_link_set_uid(lnk_new); 1087 1088 rc = smc_ib_ready_link(lnk_new); 1089 if (rc) 1090 goto out_clear_lnk; 1091 1092 rc = smcr_buf_map_lgr(lnk_new); 1093 if (rc) 1094 goto out_clear_lnk; 1095 1096 rc = smc_llc_send_add_link(link, 1097 lnk_new->smcibdev->mac[lnk_new->ibport - 1], 1098 lnk_new->gid, lnk_new, SMC_LLC_RESP); 1099 if (rc) 1100 goto out_clear_lnk; 1101 if (lgr->smc_version == SMC_V2) { 1102 u8 *llc_msg = smc_link_shared_v2_rxbuf(link) ? 1103 (u8 *)lgr->wr_rx_buf_v2 : (u8 *)llc; 1104 smc_llc_save_add_link_rkeys(link, lnk_new, llc_msg); 1105 } else { 1106 rc = smc_llc_cli_rkey_exchange(link, lnk_new); 1107 if (rc) { 1108 rc = 0; 1109 goto out_clear_lnk; 1110 } 1111 } 1112 rc = smc_llc_cli_conf_link(link, ini, lnk_new, lgr_new_t); 1113 if (!rc) 1114 goto out; 1115 out_clear_lnk: 1116 lnk_new->state = SMC_LNK_INACTIVE; 1117 smcr_link_clear(lnk_new, false); 1118 out_reject: 1119 smc_llc_cli_add_link_reject(qentry); 1120 out: 1121 kfree(ini); 1122 kfree(qentry); 1123 return rc; 1124 } 1125 1126 static void smc_llc_send_request_add_link(struct smc_link *link) 1127 { 1128 struct smc_llc_msg_req_add_link_v2 *llc; 1129 struct smc_wr_tx_pend_priv *pend; 1130 struct smc_wr_v2_buf *wr_buf; 1131 struct smc_gidlist gidlist; 1132 int rc, len, i; 1133 1134 if (!smc_wr_tx_link_hold(link)) 1135 return; 1136 if (link->lgr->type == SMC_LGR_SYMMETRIC || 1137 link->lgr->type == SMC_LGR_ASYMMETRIC_PEER) 1138 goto put_out; 1139 1140 smc_fill_gid_list(link->lgr, &gidlist, link->smcibdev, link->gid); 1141 if (gidlist.len <= 1) 1142 goto put_out; 1143 1144 rc = smc_llc_add_pending_send_v2(link, &wr_buf, &pend); 1145 if (rc) 1146 goto put_out; 1147 llc = (struct smc_llc_msg_req_add_link_v2 *)wr_buf; 1148 memset(llc, 0, SMC_WR_TX_SIZE); 1149 1150 llc->hd.common.llc_type = SMC_LLC_REQ_ADD_LINK; 1151 for (i = 0; i < gidlist.len; i++) 1152 memcpy(llc->gid[i], gidlist.list[i], sizeof(gidlist.list[0])); 1153 llc->gid_cnt = gidlist.len; 1154 len = sizeof(*llc) + (gidlist.len * sizeof(gidlist.list[0])); 1155 smc_llc_init_msg_hdr(&llc->hd, link->lgr, len); 1156 rc = smc_wr_tx_v2_send(link, pend, len); 1157 if (!rc) 1158 /* set REQ_ADD_LINK flow and wait for response from peer */ 1159 link->lgr->llc_flow_lcl.type = SMC_LLC_FLOW_REQ_ADD_LINK; 1160 put_out: 1161 smc_wr_tx_link_put(link); 1162 } 1163 1164 /* as an SMC client, invite server to start the add_link processing */ 1165 static void smc_llc_cli_add_link_invite(struct smc_link *link, 1166 struct smc_llc_qentry *qentry) 1167 { 1168 struct smc_link_group *lgr = smc_get_lgr(link); 1169 struct smc_init_info *ini = NULL; 1170 1171 if (lgr->smc_version == SMC_V2) { 1172 smc_llc_send_request_add_link(link); 1173 goto out; 1174 } 1175 1176 if (lgr->type == SMC_LGR_SYMMETRIC || 1177 lgr->type == SMC_LGR_ASYMMETRIC_PEER) 1178 goto out; 1179 1180 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1) 1181 goto out; 1182 1183 ini = kzalloc(sizeof(*ini), GFP_KERNEL); 1184 if (!ini) 1185 goto out; 1186 1187 ini->vlan_id = lgr->vlan_id; 1188 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev); 1189 if (!ini->ib_dev) 1190 goto out; 1191 1192 smc_llc_send_add_link(link, ini->ib_dev->mac[ini->ib_port - 1], 1193 ini->ib_gid, NULL, SMC_LLC_REQ); 1194 out: 1195 kfree(ini); 1196 kfree(qentry); 1197 } 1198 1199 static bool smc_llc_is_empty_llc_message(union smc_llc_msg *llc) 1200 { 1201 int i; 1202 1203 for (i = 0; i < ARRAY_SIZE(llc->raw.data); i++) 1204 if (llc->raw.data[i]) 1205 return false; 1206 return true; 1207 } 1208 1209 static bool smc_llc_is_local_add_link(union smc_llc_msg *llc) 1210 { 1211 if (llc->raw.hdr.common.llc_type == SMC_LLC_ADD_LINK && 1212 smc_llc_is_empty_llc_message(llc)) 1213 return true; 1214 return false; 1215 } 1216 1217 static void smc_llc_process_cli_add_link(struct smc_link_group *lgr) 1218 { 1219 struct smc_llc_qentry *qentry; 1220 1221 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl); 1222 1223 down_write(&lgr->llc_conf_mutex); 1224 if (smc_llc_is_local_add_link(&qentry->msg)) 1225 smc_llc_cli_add_link_invite(qentry->link, qentry); 1226 else 1227 smc_llc_cli_add_link(qentry->link, qentry); 1228 up_write(&lgr->llc_conf_mutex); 1229 } 1230 1231 static int smc_llc_active_link_count(struct smc_link_group *lgr) 1232 { 1233 int i, link_count = 0; 1234 1235 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) { 1236 if (!smc_link_active(&lgr->lnk[i])) 1237 continue; 1238 link_count++; 1239 } 1240 return link_count; 1241 } 1242 1243 /* find the asymmetric link when 3 links are established */ 1244 static struct smc_link *smc_llc_find_asym_link(struct smc_link_group *lgr) 1245 { 1246 int asym_idx = -ENOENT; 1247 int i, j, k; 1248 bool found; 1249 1250 /* determine asymmetric link */ 1251 found = false; 1252 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) { 1253 for (j = i + 1; j < SMC_LINKS_PER_LGR_MAX; j++) { 1254 if (!smc_link_usable(&lgr->lnk[i]) || 1255 !smc_link_usable(&lgr->lnk[j])) 1256 continue; 1257 if (!memcmp(lgr->lnk[i].gid, lgr->lnk[j].gid, 1258 SMC_GID_SIZE)) { 1259 found = true; /* asym_lnk is i or j */ 1260 break; 1261 } 1262 } 1263 if (found) 1264 break; 1265 } 1266 if (!found) 1267 goto out; /* no asymmetric link */ 1268 for (k = 0; k < SMC_LINKS_PER_LGR_MAX; k++) { 1269 if (!smc_link_usable(&lgr->lnk[k])) 1270 continue; 1271 if (k != i && 1272 !memcmp(lgr->lnk[i].peer_gid, lgr->lnk[k].peer_gid, 1273 SMC_GID_SIZE)) { 1274 asym_idx = i; 1275 break; 1276 } 1277 if (k != j && 1278 !memcmp(lgr->lnk[j].peer_gid, lgr->lnk[k].peer_gid, 1279 SMC_GID_SIZE)) { 1280 asym_idx = j; 1281 break; 1282 } 1283 } 1284 out: 1285 return (asym_idx < 0) ? NULL : &lgr->lnk[asym_idx]; 1286 } 1287 1288 static void smc_llc_delete_asym_link(struct smc_link_group *lgr) 1289 { 1290 struct smc_link *lnk_new = NULL, *lnk_asym; 1291 struct smc_llc_qentry *qentry; 1292 int rc; 1293 1294 lnk_asym = smc_llc_find_asym_link(lgr); 1295 if (!lnk_asym) 1296 return; /* no asymmetric link */ 1297 if (!smc_link_downing(&lnk_asym->state)) 1298 return; 1299 lnk_new = smc_switch_conns(lgr, lnk_asym, false); 1300 smc_wr_tx_wait_no_pending_sends(lnk_asym); 1301 if (!lnk_new) 1302 goto out_free; 1303 /* change flow type from ADD_LINK into DEL_LINK */ 1304 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_DEL_LINK; 1305 rc = smc_llc_send_delete_link(lnk_new, lnk_asym->link_id, SMC_LLC_REQ, 1306 true, SMC_LLC_DEL_NO_ASYM_NEEDED); 1307 if (rc) { 1308 smcr_link_down_cond(lnk_new); 1309 goto out_free; 1310 } 1311 qentry = smc_llc_wait(lgr, lnk_new, SMC_LLC_WAIT_TIME, 1312 SMC_LLC_DELETE_LINK); 1313 if (!qentry) { 1314 smcr_link_down_cond(lnk_new); 1315 goto out_free; 1316 } 1317 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1318 out_free: 1319 smcr_link_clear(lnk_asym, true); 1320 } 1321 1322 static int smc_llc_srv_rkey_exchange(struct smc_link *link, 1323 struct smc_link *link_new) 1324 { 1325 struct smc_llc_msg_add_link_cont *addc_llc; 1326 struct smc_link_group *lgr = link->lgr; 1327 u8 max, num_rkeys_send, num_rkeys_recv; 1328 struct smc_llc_qentry *qentry = NULL; 1329 struct smc_buf_desc *buf_pos; 1330 int buf_lst; 1331 int rc = 0; 1332 int i; 1333 1334 down_write(&lgr->rmbs_lock); 1335 num_rkeys_send = lgr->conns_num; 1336 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst); 1337 do { 1338 smc_llc_add_link_cont(link, link_new, &num_rkeys_send, 1339 &buf_lst, &buf_pos); 1340 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, 1341 SMC_LLC_ADD_LINK_CONT); 1342 if (!qentry) { 1343 rc = -ETIMEDOUT; 1344 goto out; 1345 } 1346 addc_llc = &qentry->msg.add_link_cont; 1347 num_rkeys_recv = addc_llc->num_rkeys; 1348 max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG); 1349 for (i = 0; i < max; i++) { 1350 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx, 1351 addc_llc->rt[i].rmb_key, 1352 addc_llc->rt[i].rmb_vaddr_new, 1353 addc_llc->rt[i].rmb_key_new); 1354 num_rkeys_recv--; 1355 } 1356 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1357 } while (num_rkeys_send || num_rkeys_recv); 1358 out: 1359 up_write(&lgr->rmbs_lock); 1360 return rc; 1361 } 1362 1363 static int smc_llc_srv_conf_link(struct smc_link *link, 1364 struct smc_link *link_new, 1365 enum smc_lgr_type lgr_new_t) 1366 { 1367 struct smc_link_group *lgr = link->lgr; 1368 struct smc_llc_qentry *qentry = NULL; 1369 int rc; 1370 1371 /* send CONFIRM LINK request over the RoCE fabric */ 1372 rc = smc_llc_send_confirm_link(link_new, SMC_LLC_REQ); 1373 if (rc) 1374 return -ENOLINK; 1375 /* receive CONFIRM LINK response over the RoCE fabric */ 1376 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_FIRST_TIME, 0); 1377 if (!qentry || 1378 qentry->msg.raw.hdr.common.llc_type != SMC_LLC_CONFIRM_LINK) { 1379 /* send DELETE LINK */ 1380 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ, 1381 false, SMC_LLC_DEL_LOST_PATH); 1382 if (qentry) 1383 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1384 return -ENOLINK; 1385 } 1386 smc_llc_save_peer_uid(qentry); 1387 smc_llc_link_active(link_new); 1388 if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL || 1389 lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) 1390 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx); 1391 else 1392 smcr_lgr_set_type(lgr, lgr_new_t); 1393 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1394 return 0; 1395 } 1396 1397 static void smc_llc_send_req_add_link_response(struct smc_llc_qentry *qentry) 1398 { 1399 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP; 1400 smc_llc_init_msg_hdr(&qentry->msg.raw.hdr, qentry->link->lgr, 1401 sizeof(qentry->msg)); 1402 memset(&qentry->msg.raw.data, 0, sizeof(qentry->msg.raw.data)); 1403 smc_llc_send_message(qentry->link, &qentry->msg); 1404 } 1405 1406 int smc_llc_srv_add_link(struct smc_link *link, 1407 struct smc_llc_qentry *req_qentry) 1408 { 1409 enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC; 1410 struct smc_link_group *lgr = link->lgr; 1411 struct smc_llc_msg_add_link *add_llc; 1412 struct smc_llc_qentry *qentry = NULL; 1413 bool send_req_add_link_resp = false; 1414 struct smc_link *link_new = NULL; 1415 struct smc_init_info *ini = NULL; 1416 int lnk_idx, rc = 0; 1417 1418 if (req_qentry && 1419 req_qentry->msg.raw.hdr.common.llc_type == SMC_LLC_REQ_ADD_LINK) 1420 send_req_add_link_resp = true; 1421 1422 ini = kzalloc(sizeof(*ini), GFP_KERNEL); 1423 if (!ini) { 1424 rc = -ENOMEM; 1425 goto out; 1426 } 1427 1428 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1) { 1429 rc = 0; 1430 goto out; 1431 } 1432 1433 /* ignore client add link recommendation, start new flow */ 1434 ini->vlan_id = lgr->vlan_id; 1435 if (lgr->smc_version == SMC_V2) { 1436 ini->check_smcrv2 = true; 1437 ini->smcrv2.saddr = lgr->saddr; 1438 if (send_req_add_link_resp) { 1439 struct smc_llc_msg_req_add_link_v2 *req_add = 1440 &req_qentry->msg.req_add_link; 1441 1442 ini->smcrv2.daddr = smc_ib_gid_to_ipv4(req_add->gid[0]); 1443 } 1444 } 1445 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev); 1446 if (lgr->smc_version == SMC_V2 && !ini->smcrv2.ib_dev_v2) { 1447 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL; 1448 ini->smcrv2.ib_dev_v2 = link->smcibdev; 1449 ini->smcrv2.ib_port_v2 = link->ibport; 1450 } else if (lgr->smc_version < SMC_V2 && !ini->ib_dev) { 1451 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL; 1452 ini->ib_dev = link->smcibdev; 1453 ini->ib_port = link->ibport; 1454 } 1455 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t); 1456 if (lnk_idx < 0) { 1457 rc = 0; 1458 goto out; 1459 } 1460 1461 rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, ini); 1462 if (rc) 1463 goto out; 1464 link_new = &lgr->lnk[lnk_idx]; 1465 1466 rc = smcr_buf_map_lgr(link_new); 1467 if (rc) 1468 goto out_err; 1469 1470 rc = smc_llc_send_add_link(link, 1471 link_new->smcibdev->mac[link_new->ibport-1], 1472 link_new->gid, link_new, SMC_LLC_REQ); 1473 if (rc) 1474 goto out_err; 1475 send_req_add_link_resp = false; 1476 /* receive ADD LINK response over the RoCE fabric */ 1477 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK); 1478 if (!qentry) { 1479 rc = -ETIMEDOUT; 1480 goto out_err; 1481 } 1482 add_llc = &qentry->msg.add_link; 1483 if (add_llc->hd.flags & SMC_LLC_FLAG_ADD_LNK_REJ) { 1484 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1485 rc = -ENOLINK; 1486 goto out_err; 1487 } 1488 if (lgr->type == SMC_LGR_SINGLE && 1489 (!memcmp(add_llc->sender_gid, link->peer_gid, SMC_GID_SIZE) && 1490 (lgr->smc_version == SMC_V2 || 1491 !memcmp(add_llc->sender_mac, link->peer_mac, ETH_ALEN)))) { 1492 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER; 1493 } 1494 smc_llc_save_add_link_info(link_new, add_llc); 1495 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1496 1497 rc = smc_ib_ready_link(link_new); 1498 if (rc) 1499 goto out_err; 1500 rc = smcr_buf_reg_lgr(link_new); 1501 if (rc) 1502 goto out_err; 1503 if (lgr->smc_version == SMC_V2) { 1504 u8 *llc_msg = smc_link_shared_v2_rxbuf(link) ? 1505 (u8 *)lgr->wr_rx_buf_v2 : (u8 *)add_llc; 1506 smc_llc_save_add_link_rkeys(link, link_new, llc_msg); 1507 } else { 1508 rc = smc_llc_srv_rkey_exchange(link, link_new); 1509 if (rc) 1510 goto out_err; 1511 } 1512 rc = smc_llc_srv_conf_link(link, link_new, lgr_new_t); 1513 if (rc) 1514 goto out_err; 1515 kfree(ini); 1516 return 0; 1517 out_err: 1518 if (link_new) { 1519 link_new->state = SMC_LNK_INACTIVE; 1520 smcr_link_clear(link_new, false); 1521 } 1522 out: 1523 kfree(ini); 1524 if (send_req_add_link_resp) 1525 smc_llc_send_req_add_link_response(req_qentry); 1526 return rc; 1527 } 1528 1529 static void smc_llc_process_srv_add_link(struct smc_link_group *lgr) 1530 { 1531 struct smc_link *link = lgr->llc_flow_lcl.qentry->link; 1532 struct smc_llc_qentry *qentry; 1533 int rc; 1534 1535 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl); 1536 1537 down_write(&lgr->llc_conf_mutex); 1538 rc = smc_llc_srv_add_link(link, qentry); 1539 if (!rc && lgr->type == SMC_LGR_SYMMETRIC) { 1540 /* delete any asymmetric link */ 1541 smc_llc_delete_asym_link(lgr); 1542 } 1543 up_write(&lgr->llc_conf_mutex); 1544 kfree(qentry); 1545 } 1546 1547 /* enqueue a local add_link req to trigger a new add_link flow */ 1548 void smc_llc_add_link_local(struct smc_link *link) 1549 { 1550 struct smc_llc_msg_add_link add_llc = {}; 1551 1552 add_llc.hd.common.llc_type = SMC_LLC_ADD_LINK; 1553 smc_llc_init_msg_hdr(&add_llc.hd, link->lgr, sizeof(add_llc)); 1554 /* no dev and port needed */ 1555 smc_llc_enqueue(link, (union smc_llc_msg *)&add_llc); 1556 } 1557 1558 /* worker to process an add link message */ 1559 static void smc_llc_add_link_work(struct work_struct *work) 1560 { 1561 struct smc_link_group *lgr = container_of(work, struct smc_link_group, 1562 llc_add_link_work); 1563 1564 if (list_empty(&lgr->list)) { 1565 /* link group is terminating */ 1566 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1567 goto out; 1568 } 1569 1570 if (lgr->role == SMC_CLNT) 1571 smc_llc_process_cli_add_link(lgr); 1572 else 1573 smc_llc_process_srv_add_link(lgr); 1574 out: 1575 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_REQ_ADD_LINK) 1576 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl); 1577 } 1578 1579 /* enqueue a local del_link msg to trigger a new del_link flow, 1580 * called only for role SMC_SERV 1581 */ 1582 void smc_llc_srv_delete_link_local(struct smc_link *link, u8 del_link_id) 1583 { 1584 struct smc_llc_msg_del_link del_llc = {}; 1585 1586 del_llc.hd.common.llc_type = SMC_LLC_DELETE_LINK; 1587 smc_llc_init_msg_hdr(&del_llc.hd, link->lgr, sizeof(del_llc)); 1588 del_llc.link_num = del_link_id; 1589 del_llc.reason = htonl(SMC_LLC_DEL_LOST_PATH); 1590 del_llc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY; 1591 smc_llc_enqueue(link, (union smc_llc_msg *)&del_llc); 1592 } 1593 1594 static void smc_llc_process_cli_delete_link(struct smc_link_group *lgr) 1595 { 1596 struct smc_link *lnk_del = NULL, *lnk_asym, *lnk; 1597 struct smc_llc_msg_del_link *del_llc; 1598 struct smc_llc_qentry *qentry; 1599 int active_links; 1600 int lnk_idx; 1601 1602 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl); 1603 lnk = qentry->link; 1604 del_llc = &qentry->msg.delete_link; 1605 1606 if (del_llc->hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) { 1607 smc_lgr_terminate_sched(lgr); 1608 goto out; 1609 } 1610 down_write(&lgr->llc_conf_mutex); 1611 /* delete single link */ 1612 for (lnk_idx = 0; lnk_idx < SMC_LINKS_PER_LGR_MAX; lnk_idx++) { 1613 if (lgr->lnk[lnk_idx].link_id != del_llc->link_num) 1614 continue; 1615 lnk_del = &lgr->lnk[lnk_idx]; 1616 break; 1617 } 1618 del_llc->hd.flags |= SMC_LLC_FLAG_RESP; 1619 if (!lnk_del) { 1620 /* link was not found */ 1621 del_llc->reason = htonl(SMC_LLC_DEL_NOLNK); 1622 smc_llc_send_message(lnk, &qentry->msg); 1623 goto out_unlock; 1624 } 1625 lnk_asym = smc_llc_find_asym_link(lgr); 1626 1627 del_llc->reason = 0; 1628 smc_llc_send_message(lnk, &qentry->msg); /* response */ 1629 1630 if (smc_link_downing(&lnk_del->state)) 1631 smc_switch_conns(lgr, lnk_del, false); 1632 smcr_link_clear(lnk_del, true); 1633 1634 active_links = smc_llc_active_link_count(lgr); 1635 if (lnk_del == lnk_asym) { 1636 /* expected deletion of asym link, don't change lgr state */ 1637 } else if (active_links == 1) { 1638 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE); 1639 } else if (!active_links) { 1640 smcr_lgr_set_type(lgr, SMC_LGR_NONE); 1641 smc_lgr_terminate_sched(lgr); 1642 } 1643 out_unlock: 1644 up_write(&lgr->llc_conf_mutex); 1645 out: 1646 kfree(qentry); 1647 } 1648 1649 /* try to send a DELETE LINK ALL request on any active link, 1650 * waiting for send completion 1651 */ 1652 void smc_llc_send_link_delete_all(struct smc_link_group *lgr, bool ord, u32 rsn) 1653 { 1654 struct smc_llc_msg_del_link delllc = {}; 1655 int i; 1656 1657 delllc.hd.common.llc_type = SMC_LLC_DELETE_LINK; 1658 smc_llc_init_msg_hdr(&delllc.hd, lgr, sizeof(delllc)); 1659 if (ord) 1660 delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY; 1661 delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL; 1662 delllc.reason = htonl(rsn); 1663 1664 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) { 1665 if (!smc_link_sendable(&lgr->lnk[i])) 1666 continue; 1667 if (!smc_llc_send_message_wait(&lgr->lnk[i], &delllc)) 1668 break; 1669 } 1670 } 1671 1672 static void smc_llc_process_srv_delete_link(struct smc_link_group *lgr) 1673 { 1674 struct smc_llc_msg_del_link *del_llc; 1675 struct smc_link *lnk, *lnk_del; 1676 struct smc_llc_qentry *qentry; 1677 int active_links; 1678 int i; 1679 1680 down_write(&lgr->llc_conf_mutex); 1681 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl); 1682 lnk = qentry->link; 1683 del_llc = &qentry->msg.delete_link; 1684 1685 if (qentry->msg.delete_link.hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) { 1686 /* delete entire lgr */ 1687 smc_llc_send_link_delete_all(lgr, true, ntohl( 1688 qentry->msg.delete_link.reason)); 1689 smc_lgr_terminate_sched(lgr); 1690 goto out; 1691 } 1692 /* delete single link */ 1693 lnk_del = NULL; 1694 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) { 1695 if (lgr->lnk[i].link_id == del_llc->link_num) { 1696 lnk_del = &lgr->lnk[i]; 1697 break; 1698 } 1699 } 1700 if (!lnk_del) 1701 goto out; /* asymmetric link already deleted */ 1702 1703 if (smc_link_downing(&lnk_del->state)) { 1704 if (smc_switch_conns(lgr, lnk_del, false)) 1705 smc_wr_tx_wait_no_pending_sends(lnk_del); 1706 } 1707 if (!list_empty(&lgr->list)) { 1708 /* qentry is either a request from peer (send it back to 1709 * initiate the DELETE_LINK processing), or a locally 1710 * enqueued DELETE_LINK request (forward it) 1711 */ 1712 if (!smc_llc_send_message(lnk, &qentry->msg)) { 1713 struct smc_llc_qentry *qentry2; 1714 1715 qentry2 = smc_llc_wait(lgr, lnk, SMC_LLC_WAIT_TIME, 1716 SMC_LLC_DELETE_LINK); 1717 if (qentry2) 1718 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1719 } 1720 } 1721 smcr_link_clear(lnk_del, true); 1722 1723 active_links = smc_llc_active_link_count(lgr); 1724 if (active_links == 1) { 1725 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE); 1726 } else if (!active_links) { 1727 smcr_lgr_set_type(lgr, SMC_LGR_NONE); 1728 smc_lgr_terminate_sched(lgr); 1729 } 1730 1731 if (lgr->type == SMC_LGR_SINGLE && !list_empty(&lgr->list)) { 1732 /* trigger setup of asymm alt link */ 1733 smc_llc_add_link_local(lnk); 1734 } 1735 out: 1736 up_write(&lgr->llc_conf_mutex); 1737 kfree(qentry); 1738 } 1739 1740 static void smc_llc_delete_link_work(struct work_struct *work) 1741 { 1742 struct smc_link_group *lgr = container_of(work, struct smc_link_group, 1743 llc_del_link_work); 1744 1745 if (list_empty(&lgr->list)) { 1746 /* link group is terminating */ 1747 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 1748 goto out; 1749 } 1750 1751 if (lgr->role == SMC_CLNT) 1752 smc_llc_process_cli_delete_link(lgr); 1753 else 1754 smc_llc_process_srv_delete_link(lgr); 1755 out: 1756 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl); 1757 } 1758 1759 /* process a confirm_rkey request from peer, remote flow */ 1760 static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr) 1761 { 1762 struct smc_llc_msg_confirm_rkey *llc; 1763 struct smc_llc_qentry *qentry; 1764 struct smc_link *link; 1765 int num_entries; 1766 int rk_idx; 1767 int i; 1768 1769 qentry = lgr->llc_flow_rmt.qentry; 1770 llc = &qentry->msg.confirm_rkey; 1771 link = qentry->link; 1772 1773 num_entries = llc->rtoken[0].num_rkeys; 1774 if (num_entries > SMC_LLC_RKEYS_PER_MSG) 1775 goto out_err; 1776 /* first rkey entry is for receiving link */ 1777 rk_idx = smc_rtoken_add(link, 1778 llc->rtoken[0].rmb_vaddr, 1779 llc->rtoken[0].rmb_key); 1780 if (rk_idx < 0) 1781 goto out_err; 1782 1783 for (i = 1; i <= min_t(u8, num_entries, SMC_LLC_RKEYS_PER_MSG - 1); i++) 1784 smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id, 1785 llc->rtoken[i].rmb_vaddr, 1786 llc->rtoken[i].rmb_key); 1787 /* max links is 3 so there is no need to support conf_rkey_cont msgs */ 1788 goto out; 1789 out_err: 1790 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG; 1791 llc->hd.flags |= SMC_LLC_FLAG_RKEY_RETRY; 1792 out: 1793 llc->hd.flags |= SMC_LLC_FLAG_RESP; 1794 smc_llc_init_msg_hdr(&llc->hd, link->lgr, sizeof(*llc)); 1795 smc_llc_send_message(link, &qentry->msg); 1796 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt); 1797 } 1798 1799 /* process a delete_rkey request from peer, remote flow */ 1800 static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr) 1801 { 1802 struct smc_llc_msg_delete_rkey *llc; 1803 struct smc_llc_qentry *qentry; 1804 struct smc_link *link; 1805 u8 err_mask = 0; 1806 int i, max; 1807 1808 qentry = lgr->llc_flow_rmt.qentry; 1809 llc = &qentry->msg.delete_rkey; 1810 link = qentry->link; 1811 1812 if (lgr->smc_version == SMC_V2) { 1813 struct smc_llc_msg_delete_rkey_v2 *llcv2; 1814 1815 if (smc_link_shared_v2_rxbuf(link)) { 1816 memcpy(lgr->wr_rx_buf_v2, llc, sizeof(*llc)); 1817 llcv2 = (struct smc_llc_msg_delete_rkey_v2 *)lgr->wr_rx_buf_v2; 1818 } else { 1819 llcv2 = (struct smc_llc_msg_delete_rkey_v2 *)llc; 1820 } 1821 llcv2->num_inval_rkeys = 0; 1822 1823 max = min_t(u8, llcv2->num_rkeys, SMC_LLC_RKEYS_PER_MSG_V2); 1824 for (i = 0; i < max; i++) { 1825 if (smc_rtoken_delete(link, llcv2->rkey[i])) 1826 llcv2->num_inval_rkeys++; 1827 } 1828 memset(&llc->rkey[0], 0, sizeof(llc->rkey)); 1829 memset(&llc->reserved2, 0, sizeof(llc->reserved2)); 1830 smc_llc_init_msg_hdr(&llc->hd, link->lgr, sizeof(*llc)); 1831 if (llcv2->num_inval_rkeys) { 1832 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG; 1833 llc->err_mask = llcv2->num_inval_rkeys; 1834 } 1835 goto finish; 1836 } 1837 1838 max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX); 1839 for (i = 0; i < max; i++) { 1840 if (smc_rtoken_delete(link, llc->rkey[i])) 1841 err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i); 1842 } 1843 if (err_mask) { 1844 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG; 1845 llc->err_mask = err_mask; 1846 } 1847 finish: 1848 llc->hd.flags |= SMC_LLC_FLAG_RESP; 1849 smc_llc_send_message(link, &qentry->msg); 1850 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt); 1851 } 1852 1853 static void smc_llc_protocol_violation(struct smc_link_group *lgr, u8 type) 1854 { 1855 pr_warn_ratelimited("smc: SMC-R lg %*phN net %llu LLC protocol violation: " 1856 "llc_type %d\n", SMC_LGR_ID_SIZE, &lgr->id, 1857 lgr->net->net_cookie, type); 1858 smc_llc_set_termination_rsn(lgr, SMC_LLC_DEL_PROT_VIOL); 1859 smc_lgr_terminate_sched(lgr); 1860 } 1861 1862 /* flush the llc event queue */ 1863 static void smc_llc_event_flush(struct smc_link_group *lgr) 1864 { 1865 struct smc_llc_qentry *qentry, *q; 1866 1867 spin_lock_bh(&lgr->llc_event_q_lock); 1868 list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) { 1869 list_del_init(&qentry->list); 1870 kfree(qentry); 1871 } 1872 spin_unlock_bh(&lgr->llc_event_q_lock); 1873 } 1874 1875 static void smc_llc_event_handler(struct smc_llc_qentry *qentry) 1876 { 1877 union smc_llc_msg *llc = &qentry->msg; 1878 struct smc_link *link = qentry->link; 1879 struct smc_link_group *lgr = link->lgr; 1880 1881 if (!smc_link_usable(link)) 1882 goto out; 1883 1884 switch (llc->raw.hdr.common.llc_type) { 1885 case SMC_LLC_TEST_LINK: 1886 llc->test_link.hd.flags |= SMC_LLC_FLAG_RESP; 1887 smc_llc_send_message(link, llc); 1888 break; 1889 case SMC_LLC_ADD_LINK: 1890 if (list_empty(&lgr->list)) 1891 goto out; /* lgr is terminating */ 1892 if (lgr->role == SMC_CLNT) { 1893 if (smc_llc_is_local_add_link(llc)) { 1894 if (lgr->llc_flow_lcl.type == 1895 SMC_LLC_FLOW_ADD_LINK) 1896 break; /* add_link in progress */ 1897 if (smc_llc_flow_start(&lgr->llc_flow_lcl, 1898 qentry)) { 1899 schedule_work(&lgr->llc_add_link_work); 1900 } 1901 return; 1902 } 1903 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK && 1904 !lgr->llc_flow_lcl.qentry) { 1905 /* a flow is waiting for this message */ 1906 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, 1907 qentry); 1908 wake_up(&lgr->llc_msg_waiter); 1909 return; 1910 } 1911 if (lgr->llc_flow_lcl.type == 1912 SMC_LLC_FLOW_REQ_ADD_LINK) { 1913 /* server started add_link processing */ 1914 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_ADD_LINK; 1915 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, 1916 qentry); 1917 schedule_work(&lgr->llc_add_link_work); 1918 return; 1919 } 1920 if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) { 1921 schedule_work(&lgr->llc_add_link_work); 1922 } 1923 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) { 1924 /* as smc server, handle client suggestion */ 1925 schedule_work(&lgr->llc_add_link_work); 1926 } 1927 return; 1928 case SMC_LLC_CONFIRM_LINK: 1929 case SMC_LLC_ADD_LINK_CONT: 1930 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) { 1931 /* a flow is waiting for this message */ 1932 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry); 1933 wake_up(&lgr->llc_msg_waiter); 1934 return; 1935 } 1936 break; 1937 case SMC_LLC_DELETE_LINK: 1938 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK && 1939 !lgr->llc_flow_lcl.qentry) { 1940 /* DEL LINK REQ during ADD LINK SEQ */ 1941 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry); 1942 wake_up(&lgr->llc_msg_waiter); 1943 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) { 1944 schedule_work(&lgr->llc_del_link_work); 1945 } 1946 return; 1947 case SMC_LLC_CONFIRM_RKEY: 1948 /* new request from remote, assign to remote flow */ 1949 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) { 1950 /* process here, does not wait for more llc msgs */ 1951 smc_llc_rmt_conf_rkey(lgr); 1952 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt); 1953 } 1954 return; 1955 case SMC_LLC_CONFIRM_RKEY_CONT: 1956 /* not used because max links is 3, and 3 rkeys fit into 1957 * one CONFIRM_RKEY message 1958 */ 1959 break; 1960 case SMC_LLC_DELETE_RKEY: 1961 /* new request from remote, assign to remote flow */ 1962 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) { 1963 /* process here, does not wait for more llc msgs */ 1964 smc_llc_rmt_delete_rkey(lgr); 1965 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt); 1966 } 1967 return; 1968 case SMC_LLC_REQ_ADD_LINK: 1969 /* handle response here, smc_llc_flow_stop() cannot be called 1970 * in tasklet context 1971 */ 1972 if (lgr->role == SMC_CLNT && 1973 lgr->llc_flow_lcl.type == SMC_LLC_FLOW_REQ_ADD_LINK && 1974 (llc->raw.hdr.flags & SMC_LLC_FLAG_RESP)) { 1975 smc_llc_flow_stop(link->lgr, &lgr->llc_flow_lcl); 1976 } else if (lgr->role == SMC_SERV) { 1977 if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) { 1978 /* as smc server, handle client suggestion */ 1979 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_ADD_LINK; 1980 schedule_work(&lgr->llc_add_link_work); 1981 } 1982 return; 1983 } 1984 break; 1985 default: 1986 smc_llc_protocol_violation(lgr, llc->raw.hdr.common.type); 1987 break; 1988 } 1989 out: 1990 kfree(qentry); 1991 } 1992 1993 /* worker to process llc messages on the event queue */ 1994 static void smc_llc_event_work(struct work_struct *work) 1995 { 1996 struct smc_link_group *lgr = container_of(work, struct smc_link_group, 1997 llc_event_work); 1998 struct smc_llc_qentry *qentry; 1999 2000 if (!lgr->llc_flow_lcl.type && lgr->delayed_event) { 2001 qentry = lgr->delayed_event; 2002 lgr->delayed_event = NULL; 2003 if (smc_link_usable(qentry->link)) 2004 smc_llc_event_handler(qentry); 2005 else 2006 kfree(qentry); 2007 } 2008 2009 again: 2010 spin_lock_bh(&lgr->llc_event_q_lock); 2011 if (!list_empty(&lgr->llc_event_q)) { 2012 qentry = list_first_entry(&lgr->llc_event_q, 2013 struct smc_llc_qentry, list); 2014 list_del_init(&qentry->list); 2015 spin_unlock_bh(&lgr->llc_event_q_lock); 2016 smc_llc_event_handler(qentry); 2017 goto again; 2018 } 2019 spin_unlock_bh(&lgr->llc_event_q_lock); 2020 } 2021 2022 /* process llc responses in tasklet context */ 2023 static void smc_llc_rx_response(struct smc_link *link, 2024 struct smc_llc_qentry *qentry) 2025 { 2026 enum smc_llc_flowtype flowtype = link->lgr->llc_flow_lcl.type; 2027 struct smc_llc_flow *flow = &link->lgr->llc_flow_lcl; 2028 u8 llc_type = qentry->msg.raw.hdr.common.llc_type; 2029 2030 switch (llc_type) { 2031 case SMC_LLC_TEST_LINK: 2032 if (smc_link_active(link)) 2033 complete(&link->llc_testlink_resp); 2034 break; 2035 case SMC_LLC_ADD_LINK: 2036 case SMC_LLC_ADD_LINK_CONT: 2037 case SMC_LLC_CONFIRM_LINK: 2038 if (flowtype != SMC_LLC_FLOW_ADD_LINK || flow->qentry) 2039 break; /* drop out-of-flow response */ 2040 goto assign; 2041 case SMC_LLC_DELETE_LINK: 2042 if (flowtype != SMC_LLC_FLOW_DEL_LINK || flow->qentry) 2043 break; /* drop out-of-flow response */ 2044 goto assign; 2045 case SMC_LLC_CONFIRM_RKEY: 2046 case SMC_LLC_DELETE_RKEY: 2047 if (flowtype != SMC_LLC_FLOW_RKEY || flow->qentry) 2048 break; /* drop out-of-flow response */ 2049 goto assign; 2050 case SMC_LLC_CONFIRM_RKEY_CONT: 2051 /* not used because max links is 3 */ 2052 break; 2053 default: 2054 smc_llc_protocol_violation(link->lgr, 2055 qentry->msg.raw.hdr.common.type); 2056 break; 2057 } 2058 kfree(qentry); 2059 return; 2060 assign: 2061 /* assign responses to the local flow, we requested them */ 2062 smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry); 2063 wake_up(&link->lgr->llc_msg_waiter); 2064 } 2065 2066 static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc) 2067 { 2068 struct smc_link_group *lgr = link->lgr; 2069 struct smc_llc_qentry *qentry; 2070 unsigned long flags; 2071 2072 qentry = kmalloc(sizeof(*qentry), GFP_ATOMIC); 2073 if (!qentry) 2074 return; 2075 qentry->link = link; 2076 INIT_LIST_HEAD(&qentry->list); 2077 memcpy(&qentry->msg, llc, sizeof(union smc_llc_msg)); 2078 2079 /* process responses immediately */ 2080 if ((llc->raw.hdr.flags & SMC_LLC_FLAG_RESP) && 2081 llc->raw.hdr.common.llc_type != SMC_LLC_REQ_ADD_LINK) { 2082 smc_llc_rx_response(link, qentry); 2083 return; 2084 } 2085 2086 /* add requests to event queue */ 2087 spin_lock_irqsave(&lgr->llc_event_q_lock, flags); 2088 list_add_tail(&qentry->list, &lgr->llc_event_q); 2089 spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags); 2090 queue_work(system_highpri_wq, &lgr->llc_event_work); 2091 } 2092 2093 /* copy received msg and add it to the event queue */ 2094 static void smc_llc_rx_handler(struct ib_wc *wc, void *buf) 2095 { 2096 struct smc_link *link = (struct smc_link *)wc->qp->qp_context; 2097 union smc_llc_msg *llc = buf; 2098 2099 if (wc->byte_len < sizeof(*llc)) 2100 return; /* short message */ 2101 if (!llc->raw.hdr.common.llc_version) { 2102 if (llc->raw.hdr.length != sizeof(*llc)) 2103 return; /* invalid message */ 2104 } else { 2105 if (llc->raw.hdr.length_v2 < sizeof(*llc)) 2106 return; /* invalid message */ 2107 } 2108 2109 smc_llc_enqueue(link, llc); 2110 } 2111 2112 /***************************** worker, utils *********************************/ 2113 2114 static void smc_llc_testlink_work(struct work_struct *work) 2115 { 2116 struct smc_link *link = container_of(to_delayed_work(work), 2117 struct smc_link, llc_testlink_wrk); 2118 unsigned long next_interval; 2119 unsigned long expire_time; 2120 u8 user_data[16] = { 0 }; 2121 int rc; 2122 2123 if (!smc_link_active(link)) 2124 return; /* don't reschedule worker */ 2125 expire_time = link->wr_rx_tstamp + link->llc_testlink_time; 2126 if (time_is_after_jiffies(expire_time)) { 2127 next_interval = expire_time - jiffies; 2128 goto out; 2129 } 2130 reinit_completion(&link->llc_testlink_resp); 2131 smc_llc_send_test_link(link, user_data); 2132 /* receive TEST LINK response over RoCE fabric */ 2133 rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp, 2134 SMC_LLC_WAIT_TIME); 2135 if (!smc_link_active(link)) 2136 return; /* link state changed */ 2137 if (rc <= 0) { 2138 smcr_link_down_cond_sched(link); 2139 return; 2140 } 2141 next_interval = link->llc_testlink_time; 2142 out: 2143 schedule_delayed_work(&link->llc_testlink_wrk, next_interval); 2144 } 2145 2146 void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc) 2147 { 2148 struct net *net = sock_net(smc->clcsock->sk); 2149 2150 INIT_WORK(&lgr->llc_event_work, smc_llc_event_work); 2151 INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work); 2152 INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work); 2153 INIT_LIST_HEAD(&lgr->llc_event_q); 2154 spin_lock_init(&lgr->llc_event_q_lock); 2155 spin_lock_init(&lgr->llc_flow_lock); 2156 init_waitqueue_head(&lgr->llc_flow_waiter); 2157 init_waitqueue_head(&lgr->llc_msg_waiter); 2158 init_rwsem(&lgr->llc_conf_mutex); 2159 lgr->llc_testlink_time = READ_ONCE(net->smc.sysctl_smcr_testlink_time); 2160 } 2161 2162 /* called after lgr was removed from lgr_list */ 2163 void smc_llc_lgr_clear(struct smc_link_group *lgr) 2164 { 2165 smc_llc_event_flush(lgr); 2166 wake_up_all(&lgr->llc_flow_waiter); 2167 wake_up_all(&lgr->llc_msg_waiter); 2168 cancel_work_sync(&lgr->llc_event_work); 2169 cancel_work_sync(&lgr->llc_add_link_work); 2170 cancel_work_sync(&lgr->llc_del_link_work); 2171 if (lgr->delayed_event) { 2172 kfree(lgr->delayed_event); 2173 lgr->delayed_event = NULL; 2174 } 2175 } 2176 2177 int smc_llc_link_init(struct smc_link *link) 2178 { 2179 init_completion(&link->llc_testlink_resp); 2180 INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work); 2181 return 0; 2182 } 2183 2184 void smc_llc_link_active(struct smc_link *link) 2185 { 2186 pr_warn_ratelimited("smc: SMC-R lg %*phN net %llu link added: id %*phN, " 2187 "peerid %*phN, ibdev %s, ibport %d\n", 2188 SMC_LGR_ID_SIZE, &link->lgr->id, 2189 link->lgr->net->net_cookie, 2190 SMC_LGR_ID_SIZE, &link->link_uid, 2191 SMC_LGR_ID_SIZE, &link->peer_link_uid, 2192 link->smcibdev->ibdev->name, link->ibport); 2193 link->state = SMC_LNK_ACTIVE; 2194 if (link->lgr->llc_testlink_time) { 2195 link->llc_testlink_time = link->lgr->llc_testlink_time; 2196 schedule_delayed_work(&link->llc_testlink_wrk, 2197 link->llc_testlink_time); 2198 } 2199 } 2200 2201 /* called in worker context */ 2202 void smc_llc_link_clear(struct smc_link *link, bool log) 2203 { 2204 if (log) 2205 pr_warn_ratelimited("smc: SMC-R lg %*phN net %llu link removed: id %*phN" 2206 ", peerid %*phN, ibdev %s, ibport %d\n", 2207 SMC_LGR_ID_SIZE, &link->lgr->id, 2208 link->lgr->net->net_cookie, 2209 SMC_LGR_ID_SIZE, &link->link_uid, 2210 SMC_LGR_ID_SIZE, &link->peer_link_uid, 2211 link->smcibdev->ibdev->name, link->ibport); 2212 complete(&link->llc_testlink_resp); 2213 cancel_delayed_work_sync(&link->llc_testlink_wrk); 2214 } 2215 2216 /* register a new rtoken at the remote peer (for all links) */ 2217 int smc_llc_do_confirm_rkey(struct smc_link *send_link, 2218 struct smc_buf_desc *rmb_desc) 2219 { 2220 struct smc_link_group *lgr = send_link->lgr; 2221 struct smc_llc_qentry *qentry = NULL; 2222 int rc = 0; 2223 2224 rc = smc_llc_send_confirm_rkey(send_link, rmb_desc); 2225 if (rc) 2226 goto out; 2227 /* receive CONFIRM RKEY response from server over RoCE fabric */ 2228 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME, 2229 SMC_LLC_CONFIRM_RKEY); 2230 if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG)) 2231 rc = -EFAULT; 2232 out: 2233 if (qentry) 2234 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 2235 return rc; 2236 } 2237 2238 /* unregister an rtoken at the remote peer */ 2239 int smc_llc_do_delete_rkey(struct smc_link_group *lgr, 2240 struct smc_buf_desc *rmb_desc) 2241 { 2242 struct smc_llc_qentry *qentry = NULL; 2243 struct smc_link *send_link; 2244 int rc = 0; 2245 2246 send_link = smc_llc_usable_link(lgr); 2247 if (!send_link) 2248 return -ENOLINK; 2249 2250 /* protected by llc_flow control */ 2251 rc = smc_llc_send_delete_rkey(send_link, rmb_desc); 2252 if (rc) 2253 goto out; 2254 /* receive DELETE RKEY response from server over RoCE fabric */ 2255 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME, 2256 SMC_LLC_DELETE_RKEY); 2257 if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG)) 2258 rc = -EFAULT; 2259 out: 2260 if (qentry) 2261 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl); 2262 return rc; 2263 } 2264 2265 void smc_llc_link_set_uid(struct smc_link *link) 2266 { 2267 __be32 link_uid; 2268 2269 link_uid = htonl(*((u32 *)link->lgr->id) + link->link_id); 2270 memcpy(link->link_uid, &link_uid, SMC_LGR_ID_SIZE); 2271 } 2272 2273 /* save peers link user id, used for debug purposes */ 2274 void smc_llc_save_peer_uid(struct smc_llc_qentry *qentry) 2275 { 2276 memcpy(qentry->link->peer_link_uid, qentry->msg.confirm_link.link_uid, 2277 SMC_LGR_ID_SIZE); 2278 } 2279 2280 /* evaluate confirm link request or response */ 2281 int smc_llc_eval_conf_link(struct smc_llc_qentry *qentry, 2282 enum smc_llc_reqresp type) 2283 { 2284 if (type == SMC_LLC_REQ) { /* SMC server assigns link_id */ 2285 qentry->link->link_id = qentry->msg.confirm_link.link_num; 2286 smc_llc_link_set_uid(qentry->link); 2287 } 2288 if (!(qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_NO_RMBE_EYEC)) 2289 return -ENOTSUPP; 2290 return 0; 2291 } 2292 2293 /***************************** init, exit, misc ******************************/ 2294 2295 static struct smc_wr_rx_handler smc_llc_rx_handlers[] = { 2296 { 2297 .handler = smc_llc_rx_handler, 2298 .type = SMC_LLC_CONFIRM_LINK 2299 }, 2300 { 2301 .handler = smc_llc_rx_handler, 2302 .type = SMC_LLC_TEST_LINK 2303 }, 2304 { 2305 .handler = smc_llc_rx_handler, 2306 .type = SMC_LLC_ADD_LINK 2307 }, 2308 { 2309 .handler = smc_llc_rx_handler, 2310 .type = SMC_LLC_ADD_LINK_CONT 2311 }, 2312 { 2313 .handler = smc_llc_rx_handler, 2314 .type = SMC_LLC_DELETE_LINK 2315 }, 2316 { 2317 .handler = smc_llc_rx_handler, 2318 .type = SMC_LLC_CONFIRM_RKEY 2319 }, 2320 { 2321 .handler = smc_llc_rx_handler, 2322 .type = SMC_LLC_CONFIRM_RKEY_CONT 2323 }, 2324 { 2325 .handler = smc_llc_rx_handler, 2326 .type = SMC_LLC_DELETE_RKEY 2327 }, 2328 /* V2 types */ 2329 { 2330 .handler = smc_llc_rx_handler, 2331 .type = SMC_LLC_CONFIRM_LINK_V2 2332 }, 2333 { 2334 .handler = smc_llc_rx_handler, 2335 .type = SMC_LLC_TEST_LINK_V2 2336 }, 2337 { 2338 .handler = smc_llc_rx_handler, 2339 .type = SMC_LLC_ADD_LINK_V2 2340 }, 2341 { 2342 .handler = smc_llc_rx_handler, 2343 .type = SMC_LLC_DELETE_LINK_V2 2344 }, 2345 { 2346 .handler = smc_llc_rx_handler, 2347 .type = SMC_LLC_REQ_ADD_LINK_V2 2348 }, 2349 { 2350 .handler = smc_llc_rx_handler, 2351 .type = SMC_LLC_CONFIRM_RKEY_V2 2352 }, 2353 { 2354 .handler = smc_llc_rx_handler, 2355 .type = SMC_LLC_DELETE_RKEY_V2 2356 }, 2357 { 2358 .handler = NULL, 2359 } 2360 }; 2361 2362 int __init smc_llc_init(void) 2363 { 2364 struct smc_wr_rx_handler *handler; 2365 int rc = 0; 2366 2367 for (handler = smc_llc_rx_handlers; handler->handler; handler++) { 2368 INIT_HLIST_NODE(&handler->list); 2369 rc = smc_wr_rx_register_handler(handler); 2370 if (rc) 2371 break; 2372 } 2373 return rc; 2374 } 2375