net/smc/smc_llc.c

   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         u8 length;      /* 44 */
  27 #if defined(__BIG_ENDIAN_BITFIELD)
  28         u8 reserved:4,
  29            add_link_rej_rsn:4;
  30 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  31         u8 add_link_rej_rsn:4,
  32            reserved:4;
  33 #endif
  34         u8 flags;
  35 };
  36
  37 #define SMC_LLC_FLAG_NO_RMBE_EYEC       0x03
  38
  39 struct smc_llc_msg_confirm_link {       /* type 0x01 */
  40         struct smc_llc_hdr hd;
  41         u8 sender_mac[ETH_ALEN];
  42         u8 sender_gid[SMC_GID_SIZE];
  43         u8 sender_qp_num[3];
  44         u8 link_num;
  45         u8 link_uid[SMC_LGR_ID_SIZE];
  46         u8 max_links;
  47         u8 reserved[9];
  48 };
  49
  50 #define SMC_LLC_FLAG_ADD_LNK_REJ        0x40
  51 #define SMC_LLC_REJ_RSN_NO_ALT_PATH     1
  52
  53 #define SMC_LLC_ADD_LNK_MAX_LINKS       2
  54
  55 struct smc_llc_msg_add_link {           /* type 0x02 */
  56         struct smc_llc_hdr hd;
  57         u8 sender_mac[ETH_ALEN];
  58         u8 reserved2[2];
  59         u8 sender_gid[SMC_GID_SIZE];
  60         u8 sender_qp_num[3];
  61         u8 link_num;
  62 #if defined(__BIG_ENDIAN_BITFIELD)
  63         u8 reserved3 : 4,
  64            qp_mtu   : 4;
  65 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  66         u8 qp_mtu   : 4,
  67            reserved3 : 4;
  68 #endif
  69         u8 initial_psn[3];
  70         u8 reserved[8];
  71 };
  72
  73 struct smc_llc_msg_add_link_cont_rt {
  74         __be32 rmb_key;
  75         __be32 rmb_key_new;
  76         __be64 rmb_vaddr_new;
  77 };
  78
  79 #define SMC_LLC_RKEYS_PER_CONT_MSG      2
  80
  81 struct smc_llc_msg_add_link_cont {      /* type 0x03 */
  82         struct smc_llc_hdr hd;
  83         u8 link_num;
  84         u8 num_rkeys;
  85         u8 reserved2[2];
  86         struct smc_llc_msg_add_link_cont_rt rt[SMC_LLC_RKEYS_PER_CONT_MSG];
  87         u8 reserved[4];
  88 } __packed;                     /* format defined in RFC7609 */
  89
  90 #define SMC_LLC_FLAG_DEL_LINK_ALL       0x40
  91 #define SMC_LLC_FLAG_DEL_LINK_ORDERLY   0x20
  92
  93 struct smc_llc_msg_del_link {           /* type 0x04 */
  94         struct smc_llc_hdr hd;
  95         u8 link_num;
  96         __be32 reason;
  97         u8 reserved[35];
  98 } __packed;                     /* format defined in RFC7609 */
  99
 100 struct smc_llc_msg_test_link {          /* type 0x07 */
 101         struct smc_llc_hdr hd;
 102         u8 user_data[16];
 103         u8 reserved[24];
 104 };
 105
 106 struct smc_rmb_rtoken {
 107         union {
 108                 u8 num_rkeys;   /* first rtoken byte of CONFIRM LINK msg */
 109                                 /* is actually the num of rtokens, first */
 110                                 /* rtoken is always for the current link */
 111                 u8 link_id;     /* link id of the rtoken */
 112         };
 113         __be32 rmb_key;
 114         __be64 rmb_vaddr;
 115 } __packed;                     /* format defined in RFC7609 */
 116
 117 #define SMC_LLC_RKEYS_PER_MSG   3
 118
 119 struct smc_llc_msg_confirm_rkey {       /* type 0x06 */
 120         struct smc_llc_hdr hd;
 121         struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
 122         u8 reserved;
 123 };
 124
 125 #define SMC_LLC_DEL_RKEY_MAX    8
 126 #define SMC_LLC_FLAG_RKEY_RETRY 0x10
 127 #define SMC_LLC_FLAG_RKEY_NEG   0x20
 128
 129 struct smc_llc_msg_delete_rkey {        /* type 0x09 */
 130         struct smc_llc_hdr hd;
 131         u8 num_rkeys;
 132         u8 err_mask;
 133         u8 reserved[2];
 134         __be32 rkey[8];
 135         u8 reserved2[4];
 136 };
 137
 138 union smc_llc_msg {
 139         struct smc_llc_msg_confirm_link confirm_link;
 140         struct smc_llc_msg_add_link add_link;
 141         struct smc_llc_msg_add_link_cont add_link_cont;
 142         struct smc_llc_msg_del_link delete_link;
 143
 144         struct smc_llc_msg_confirm_rkey confirm_rkey;
 145         struct smc_llc_msg_delete_rkey delete_rkey;
 146
 147         struct smc_llc_msg_test_link test_link;
 148         struct {
 149                 struct smc_llc_hdr hdr;
 150                 u8 data[SMC_LLC_DATA_LEN];
 151         } raw;
 152 };
 153
 154 #define SMC_LLC_FLAG_RESP               0x80
 155
 156 struct smc_llc_qentry {
 157         struct list_head list;
 158         struct smc_link *link;
 159         union smc_llc_msg msg;
 160 };
 161
 162 struct smc_llc_qentry *smc_llc_flow_qentry_clr(struct smc_llc_flow *flow)
 163 {
 164         struct smc_llc_qentry *qentry = flow->qentry;
 165
 166         flow->qentry = NULL;
 167         return qentry;
 168 }
 169
 170 void smc_llc_flow_qentry_del(struct smc_llc_flow *flow)
 171 {
 172         struct smc_llc_qentry *qentry;
 173
 174         if (flow->qentry) {
 175                 qentry = flow->qentry;
 176                 flow->qentry = NULL;
 177                 kfree(qentry);
 178         }
 179 }
 180
 181 static inline void smc_llc_flow_qentry_set(struct smc_llc_flow *flow,
 182                                            struct smc_llc_qentry *qentry)
 183 {
 184         flow->qentry = qentry;
 185 }
 186
 187 /* try to start a new llc flow, initiated by an incoming llc msg */
 188 static bool smc_llc_flow_start(struct smc_llc_flow *flow,
 189                                struct smc_llc_qentry *qentry)
 190 {
 191         struct smc_link_group *lgr = qentry->link->lgr;
 192
 193         spin_lock_bh(&lgr->llc_flow_lock);
 194         if (flow->type) {
 195                 /* a flow is already active */
 196                 if ((qentry->msg.raw.hdr.common.type == SMC_LLC_ADD_LINK ||
 197                      qentry->msg.raw.hdr.common.type == SMC_LLC_DELETE_LINK) &&
 198                     !lgr->delayed_event) {
 199                         lgr->delayed_event = qentry;
 200                 } else {
 201                         /* forget this llc request */
 202                         kfree(qentry);
 203                 }
 204                 spin_unlock_bh(&lgr->llc_flow_lock);
 205                 return false;
 206         }
 207         switch (qentry->msg.raw.hdr.common.type) {
 208         case SMC_LLC_ADD_LINK:
 209                 flow->type = SMC_LLC_FLOW_ADD_LINK;
 210                 break;
 211         case SMC_LLC_DELETE_LINK:
 212                 flow->type = SMC_LLC_FLOW_DEL_LINK;
 213                 break;
 214         case SMC_LLC_CONFIRM_RKEY:
 215         case SMC_LLC_DELETE_RKEY:
 216                 flow->type = SMC_LLC_FLOW_RKEY;
 217                 break;
 218         default:
 219                 flow->type = SMC_LLC_FLOW_NONE;
 220         }
 221         if (qentry == lgr->delayed_event)
 222                 lgr->delayed_event = NULL;
 223         spin_unlock_bh(&lgr->llc_flow_lock);
 224         smc_llc_flow_qentry_set(flow, qentry);
 225         return true;
 226 }
 227
 228 /* start a new local llc flow, wait till current flow finished */
 229 int smc_llc_flow_initiate(struct smc_link_group *lgr,
 230                           enum smc_llc_flowtype type)
 231 {
 232         enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE;
 233         int rc;
 234
 235         /* all flows except confirm_rkey and delete_rkey are exclusive,
 236          * confirm/delete rkey flows can run concurrently (local and remote)
 237          */
 238         if (type == SMC_LLC_FLOW_RKEY)
 239                 allowed_remote = SMC_LLC_FLOW_RKEY;
 240 again:
 241         if (list_empty(&lgr->list))
 242                 return -ENODEV;
 243         spin_lock_bh(&lgr->llc_flow_lock);
 244         if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
 245             (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
 246              lgr->llc_flow_rmt.type == allowed_remote)) {
 247                 lgr->llc_flow_lcl.type = type;
 248                 spin_unlock_bh(&lgr->llc_flow_lock);
 249                 return 0;
 250         }
 251         spin_unlock_bh(&lgr->llc_flow_lock);
 252         rc = wait_event_interruptible_timeout(lgr->llc_waiter,
 253                         (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
 254                          (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
 255                           lgr->llc_flow_rmt.type == allowed_remote)),
 256                         SMC_LLC_WAIT_TIME);
 257         if (!rc)
 258                 return -ETIMEDOUT;
 259         goto again;
 260 }
 261
 262 /* finish the current llc flow */
 263 void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow)
 264 {
 265         spin_lock_bh(&lgr->llc_flow_lock);
 266         memset(flow, 0, sizeof(*flow));
 267         flow->type = SMC_LLC_FLOW_NONE;
 268         spin_unlock_bh(&lgr->llc_flow_lock);
 269         if (!list_empty(&lgr->list) && lgr->delayed_event &&
 270             flow == &lgr->llc_flow_lcl)
 271                 schedule_work(&lgr->llc_event_work);
 272         else
 273                 wake_up_interruptible(&lgr->llc_waiter);
 274 }
 275
 276 /* lnk is optional and used for early wakeup when link goes down, useful in
 277  * cases where we wait for a response on the link after we sent a request
 278  */
 279 struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr,
 280                                     struct smc_link *lnk,
 281                                     int time_out, u8 exp_msg)
 282 {
 283         struct smc_llc_flow *flow = &lgr->llc_flow_lcl;
 284
 285         wait_event_interruptible_timeout(lgr->llc_waiter,
 286                                          (flow->qentry ||
 287                                           (lnk && !smc_link_usable(lnk)) ||
 288                                           list_empty(&lgr->list)),
 289                                          time_out);
 290         if (!flow->qentry ||
 291             (lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) {
 292                 smc_llc_flow_qentry_del(flow);
 293                 goto out;
 294         }
 295         if (exp_msg && flow->qentry->msg.raw.hdr.common.type != exp_msg) {
 296                 if (exp_msg == SMC_LLC_ADD_LINK &&
 297                     flow->qentry->msg.raw.hdr.common.type ==
 298                     SMC_LLC_DELETE_LINK) {
 299                         /* flow_start will delay the unexpected msg */
 300                         smc_llc_flow_start(&lgr->llc_flow_lcl,
 301                                            smc_llc_flow_qentry_clr(flow));
 302                         return NULL;
 303                 }
 304                 smc_llc_flow_qentry_del(flow);
 305         }
 306 out:
 307         return flow->qentry;
 308 }
 309
 310 /********************************** send *************************************/
 311
 312 struct smc_llc_tx_pend {
 313 };
 314
 315 /* handler for send/transmission completion of an LLC msg */
 316 static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
 317                                struct smc_link *link,
 318                                enum ib_wc_status wc_status)
 319 {
 320         /* future work: handle wc_status error for recovery and failover */
 321 }
 322
 323 /**
 324  * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
 325  * @link: Pointer to SMC link used for sending LLC control message.
 326  * @wr_buf: Out variable returning pointer to work request payload buffer.
 327  * @pend: Out variable returning pointer to private pending WR tracking.
 328  *        It's the context the transmit complete handler will get.
 329  *
 330  * Reserves and pre-fills an entry for a pending work request send/tx.
 331  * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
 332  * Can sleep due to smc_get_ctrl_buf (if not in softirq context).
 333  *
 334  * Return: 0 on success, otherwise an error value.
 335  */
 336 static int smc_llc_add_pending_send(struct smc_link *link,
 337                                     struct smc_wr_buf **wr_buf,
 338                                     struct smc_wr_tx_pend_priv **pend)
 339 {
 340         int rc;
 341
 342         rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL,
 343                                      pend);
 344         if (rc < 0)
 345                 return rc;
 346         BUILD_BUG_ON_MSG(
 347                 sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
 348                 "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
 349         BUILD_BUG_ON_MSG(
 350                 sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
 351                 "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()");
 352         BUILD_BUG_ON_MSG(
 353                 sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
 354                 "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
 355         return 0;
 356 }
 357
 358 /* high-level API to send LLC confirm link */
 359 int smc_llc_send_confirm_link(struct smc_link *link,
 360                               enum smc_llc_reqresp reqresp)
 361 {
 362         struct smc_link_group *lgr = smc_get_lgr(link);
 363         struct smc_llc_msg_confirm_link *confllc;
 364         struct smc_wr_tx_pend_priv *pend;
 365         struct smc_wr_buf *wr_buf;
 366         int rc;
 367
 368         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 369         if (rc)
 370                 return rc;
 371         confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
 372         memset(confllc, 0, sizeof(*confllc));
 373         confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
 374         confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
 375         confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC;
 376         if (reqresp == SMC_LLC_RESP)
 377                 confllc->hd.flags |= SMC_LLC_FLAG_RESP;
 378         memcpy(confllc->sender_mac, link->smcibdev->mac[link->ibport - 1],
 379                ETH_ALEN);
 380         memcpy(confllc->sender_gid, link->gid, SMC_GID_SIZE);
 381         hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
 382         confllc->link_num = link->link_id;
 383         memcpy(confllc->link_uid, lgr->id, SMC_LGR_ID_SIZE);
 384         confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS;
 385         /* send llc message */
 386         rc = smc_wr_tx_send(link, pend);
 387         return rc;
 388 }
 389
 390 /* send LLC confirm rkey request */
 391 static int smc_llc_send_confirm_rkey(struct smc_link *send_link,
 392                                      struct smc_buf_desc *rmb_desc)
 393 {
 394         struct smc_llc_msg_confirm_rkey *rkeyllc;
 395         struct smc_wr_tx_pend_priv *pend;
 396         struct smc_wr_buf *wr_buf;
 397         struct smc_link *link;
 398         int i, rc, rtok_ix;
 399
 400         rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend);
 401         if (rc)
 402                 return rc;
 403         rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf;
 404         memset(rkeyllc, 0, sizeof(*rkeyllc));
 405         rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY;
 406         rkeyllc->hd.length = sizeof(struct smc_llc_msg_confirm_rkey);
 407
 408         rtok_ix = 1;
 409         for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
 410                 link = &send_link->lgr->lnk[i];
 411                 if (link->state == SMC_LNK_ACTIVE && link != send_link) {
 412                         rkeyllc->rtoken[rtok_ix].link_id = link->link_id;
 413                         rkeyllc->rtoken[rtok_ix].rmb_key =
 414                                 htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
 415                         rkeyllc->rtoken[rtok_ix].rmb_vaddr = cpu_to_be64(
 416                                 (u64)sg_dma_address(
 417                                         rmb_desc->sgt[link->link_idx].sgl));
 418                         rtok_ix++;
 419                 }
 420         }
 421         /* rkey of send_link is in rtoken[0] */
 422         rkeyllc->rtoken[0].num_rkeys = rtok_ix - 1;
 423         rkeyllc->rtoken[0].rmb_key =
 424                 htonl(rmb_desc->mr_rx[send_link->link_idx]->rkey);
 425         rkeyllc->rtoken[0].rmb_vaddr = cpu_to_be64(
 426                 (u64)sg_dma_address(rmb_desc->sgt[send_link->link_idx].sgl));
 427         /* send llc message */
 428         rc = smc_wr_tx_send(send_link, pend);
 429         return rc;
 430 }
 431
 432 /* send LLC delete rkey request */
 433 static int smc_llc_send_delete_rkey(struct smc_link *link,
 434                                     struct smc_buf_desc *rmb_desc)
 435 {
 436         struct smc_llc_msg_delete_rkey *rkeyllc;
 437         struct smc_wr_tx_pend_priv *pend;
 438         struct smc_wr_buf *wr_buf;
 439         int rc;
 440
 441         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 442         if (rc)
 443                 return rc;
 444         rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf;
 445         memset(rkeyllc, 0, sizeof(*rkeyllc));
 446         rkeyllc->hd.common.type = SMC_LLC_DELETE_RKEY;
 447         rkeyllc->hd.length = sizeof(struct smc_llc_msg_delete_rkey);
 448         rkeyllc->num_rkeys = 1;
 449         rkeyllc->rkey[0] = htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
 450         /* send llc message */
 451         rc = smc_wr_tx_send(link, pend);
 452         return rc;
 453 }
 454
 455 /* send ADD LINK request or response */
 456 int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[],
 457                           struct smc_link *link_new,
 458                           enum smc_llc_reqresp reqresp)
 459 {
 460         struct smc_llc_msg_add_link *addllc;
 461         struct smc_wr_tx_pend_priv *pend;
 462         struct smc_wr_buf *wr_buf;
 463         int rc;
 464
 465         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 466         if (rc)
 467                 return rc;
 468         addllc = (struct smc_llc_msg_add_link *)wr_buf;
 469
 470         memset(addllc, 0, sizeof(*addllc));
 471         addllc->hd.common.type = SMC_LLC_ADD_LINK;
 472         addllc->hd.length = sizeof(struct smc_llc_msg_add_link);
 473         if (reqresp == SMC_LLC_RESP)
 474                 addllc->hd.flags |= SMC_LLC_FLAG_RESP;
 475         memcpy(addllc->sender_mac, mac, ETH_ALEN);
 476         memcpy(addllc->sender_gid, gid, SMC_GID_SIZE);
 477         if (link_new) {
 478                 addllc->link_num = link_new->link_id;
 479                 hton24(addllc->sender_qp_num, link_new->roce_qp->qp_num);
 480                 hton24(addllc->initial_psn, link_new->psn_initial);
 481                 if (reqresp == SMC_LLC_REQ)
 482                         addllc->qp_mtu = link_new->path_mtu;
 483                 else
 484                         addllc->qp_mtu = min(link_new->path_mtu,
 485                                              link_new->peer_mtu);
 486         }
 487         /* send llc message */
 488         rc = smc_wr_tx_send(link, pend);
 489         return rc;
 490 }
 491
 492 /* send DELETE LINK request or response */
 493 int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id,
 494                              enum smc_llc_reqresp reqresp, bool orderly,
 495                              u32 reason)
 496 {
 497         struct smc_llc_msg_del_link *delllc;
 498         struct smc_wr_tx_pend_priv *pend;
 499         struct smc_wr_buf *wr_buf;
 500         int rc;
 501
 502         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 503         if (rc)
 504                 return rc;
 505         delllc = (struct smc_llc_msg_del_link *)wr_buf;
 506
 507         memset(delllc, 0, sizeof(*delllc));
 508         delllc->hd.common.type = SMC_LLC_DELETE_LINK;
 509         delllc->hd.length = sizeof(struct smc_llc_msg_del_link);
 510         if (reqresp == SMC_LLC_RESP)
 511                 delllc->hd.flags |= SMC_LLC_FLAG_RESP;
 512         if (orderly)
 513                 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
 514         if (link_del_id)
 515                 delllc->link_num = link_del_id;
 516         else
 517                 delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
 518         delllc->reason = htonl(reason);
 519         /* send llc message */
 520         rc = smc_wr_tx_send(link, pend);
 521         return rc;
 522 }
 523
 524 /* send LLC test link request */
 525 static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16])
 526 {
 527         struct smc_llc_msg_test_link *testllc;
 528         struct smc_wr_tx_pend_priv *pend;
 529         struct smc_wr_buf *wr_buf;
 530         int rc;
 531
 532         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 533         if (rc)
 534                 return rc;
 535         testllc = (struct smc_llc_msg_test_link *)wr_buf;
 536         memset(testllc, 0, sizeof(*testllc));
 537         testllc->hd.common.type = SMC_LLC_TEST_LINK;
 538         testllc->hd.length = sizeof(struct smc_llc_msg_test_link);
 539         memcpy(testllc->user_data, user_data, sizeof(testllc->user_data));
 540         /* send llc message */
 541         rc = smc_wr_tx_send(link, pend);
 542         return rc;
 543 }
 544
 545 /* schedule an llc send on link, may wait for buffers */
 546 static int smc_llc_send_message(struct smc_link *link, void *llcbuf)
 547 {
 548         struct smc_wr_tx_pend_priv *pend;
 549         struct smc_wr_buf *wr_buf;
 550         int rc;
 551
 552         if (!smc_link_usable(link))
 553                 return -ENOLINK;
 554         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 555         if (rc)
 556                 return rc;
 557         memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
 558         return smc_wr_tx_send(link, pend);
 559 }
 560
 561 /********************************* receive ***********************************/
 562
 563 static int smc_llc_alloc_alt_link(struct smc_link_group *lgr,
 564                                   enum smc_lgr_type lgr_new_t)
 565 {
 566         int i;
 567
 568         if (lgr->type == SMC_LGR_SYMMETRIC ||
 569             (lgr->type != SMC_LGR_SINGLE &&
 570              (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
 571               lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)))
 572                 return -EMLINK;
 573
 574         if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
 575             lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) {
 576                 for (i = SMC_LINKS_PER_LGR_MAX - 1; i >= 0; i--)
 577                         if (lgr->lnk[i].state == SMC_LNK_UNUSED)
 578                                 return i;
 579         } else {
 580                 for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++)
 581                         if (lgr->lnk[i].state == SMC_LNK_UNUSED)
 582                                 return i;
 583         }
 584         return -EMLINK;
 585 }
 586
 587 /* return first buffer from any of the next buf lists */
 588 static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr,
 589                                                   int *buf_lst)
 590 {
 591         struct smc_buf_desc *buf_pos;
 592
 593         while (*buf_lst < SMC_RMBE_SIZES) {
 594                 buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst],
 595                                                    struct smc_buf_desc, list);
 596                 if (buf_pos)
 597                         return buf_pos;
 598                 (*buf_lst)++;
 599         }
 600         return NULL;
 601 }
 602
 603 /* return next rmb from buffer lists */
 604 static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr,
 605                                                  int *buf_lst,
 606                                                  struct smc_buf_desc *buf_pos)
 607 {
 608         struct smc_buf_desc *buf_next;
 609
 610         if (!buf_pos || list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) {
 611                 (*buf_lst)++;
 612                 return _smc_llc_get_next_rmb(lgr, buf_lst);
 613         }
 614         buf_next = list_next_entry(buf_pos, list);
 615         return buf_next;
 616 }
 617
 618 static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr,
 619                                                   int *buf_lst)
 620 {
 621         *buf_lst = 0;
 622         return smc_llc_get_next_rmb(lgr, buf_lst, NULL);
 623 }
 624
 625 /* send one add_link_continue msg */
 626 static int smc_llc_add_link_cont(struct smc_link *link,
 627                                  struct smc_link *link_new, u8 *num_rkeys_todo,
 628                                  int *buf_lst, struct smc_buf_desc **buf_pos)
 629 {
 630         struct smc_llc_msg_add_link_cont *addc_llc;
 631         struct smc_link_group *lgr = link->lgr;
 632         int prim_lnk_idx, lnk_idx, i, rc;
 633         struct smc_wr_tx_pend_priv *pend;
 634         struct smc_wr_buf *wr_buf;
 635         struct smc_buf_desc *rmb;
 636         u8 n;
 637
 638         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
 639         if (rc)
 640                 return rc;
 641         addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf;
 642         memset(addc_llc, 0, sizeof(*addc_llc));
 643
 644         prim_lnk_idx = link->link_idx;
 645         lnk_idx = link_new->link_idx;
 646         addc_llc->link_num = link_new->link_id;
 647         addc_llc->num_rkeys = *num_rkeys_todo;
 648         n = *num_rkeys_todo;
 649         for (i = 0; i < min_t(u8, n, SMC_LLC_RKEYS_PER_CONT_MSG); i++) {
 650                 if (!*buf_pos) {
 651                         addc_llc->num_rkeys = addc_llc->num_rkeys -
 652                                               *num_rkeys_todo;
 653                         *num_rkeys_todo = 0;
 654                         break;
 655                 }
 656                 rmb = *buf_pos;
 657
 658                 addc_llc->rt[i].rmb_key = htonl(rmb->mr_rx[prim_lnk_idx]->rkey);
 659                 addc_llc->rt[i].rmb_key_new = htonl(rmb->mr_rx[lnk_idx]->rkey);
 660                 addc_llc->rt[i].rmb_vaddr_new =
 661                         cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl));
 662
 663                 (*num_rkeys_todo)--;
 664                 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
 665                 while (*buf_pos && !(*buf_pos)->used)
 666                         *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
 667         }
 668         addc_llc->hd.common.type = SMC_LLC_ADD_LINK_CONT;
 669         addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont);
 670         if (lgr->role == SMC_CLNT)
 671                 addc_llc->hd.flags |= SMC_LLC_FLAG_RESP;
 672         return smc_wr_tx_send(link, pend);
 673 }
 674
 675 static int smc_llc_cli_rkey_exchange(struct smc_link *link,
 676                                      struct smc_link *link_new)
 677 {
 678         struct smc_llc_msg_add_link_cont *addc_llc;
 679         struct smc_link_group *lgr = link->lgr;
 680         u8 max, num_rkeys_send, num_rkeys_recv;
 681         struct smc_llc_qentry *qentry;
 682         struct smc_buf_desc *buf_pos;
 683         int buf_lst;
 684         int rc = 0;
 685         int i;
 686
 687         mutex_lock(&lgr->rmbs_lock);
 688         num_rkeys_send = lgr->conns_num;
 689         buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
 690         do {
 691                 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME,
 692                                       SMC_LLC_ADD_LINK_CONT);
 693                 if (!qentry) {
 694                         rc = -ETIMEDOUT;
 695                         break;
 696                 }
 697                 addc_llc = &qentry->msg.add_link_cont;
 698                 num_rkeys_recv = addc_llc->num_rkeys;
 699                 max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
 700                 for (i = 0; i < max; i++) {
 701                         smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
 702                                        addc_llc->rt[i].rmb_key,
 703                                        addc_llc->rt[i].rmb_vaddr_new,
 704                                        addc_llc->rt[i].rmb_key_new);
 705                         num_rkeys_recv--;
 706                 }
 707                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 708                 rc = smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
 709                                            &buf_lst, &buf_pos);
 710                 if (rc)
 711                         break;
 712         } while (num_rkeys_send || num_rkeys_recv);
 713
 714         mutex_unlock(&lgr->rmbs_lock);
 715         return rc;
 716 }
 717
 718 /* prepare and send an add link reject response */
 719 static int smc_llc_cli_add_link_reject(struct smc_llc_qentry *qentry)
 720 {
 721         qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
 722         qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_ADD_LNK_REJ;
 723         qentry->msg.raw.hdr.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH;
 724         return smc_llc_send_message(qentry->link, &qentry->msg);
 725 }
 726
 727 static int smc_llc_cli_conf_link(struct smc_link *link,
 728                                  struct smc_init_info *ini,
 729                                  struct smc_link *link_new,
 730                                  enum smc_lgr_type lgr_new_t)
 731 {
 732         struct smc_link_group *lgr = link->lgr;
 733         struct smc_llc_msg_del_link *del_llc;
 734         struct smc_llc_qentry *qentry = NULL;
 735         int rc = 0;
 736
 737         /* receive CONFIRM LINK request over RoCE fabric */
 738         qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0);
 739         if (!qentry) {
 740                 rc = smc_llc_send_delete_link(link, link_new->link_id,
 741                                               SMC_LLC_REQ, false,
 742                                               SMC_LLC_DEL_LOST_PATH);
 743                 return -ENOLINK;
 744         }
 745         if (qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
 746                 /* received DELETE_LINK instead */
 747                 del_llc = &qentry->msg.delete_link;
 748                 qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
 749                 smc_llc_send_message(link, &qentry->msg);
 750                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 751                 return -ENOLINK;
 752         }
 753         smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 754
 755         rc = smc_ib_modify_qp_rts(link_new);
 756         if (rc) {
 757                 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
 758                                          false, SMC_LLC_DEL_LOST_PATH);
 759                 return -ENOLINK;
 760         }
 761         smc_wr_remember_qp_attr(link_new);
 762
 763         rc = smcr_buf_reg_lgr(link_new);
 764         if (rc) {
 765                 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
 766                                          false, SMC_LLC_DEL_LOST_PATH);
 767                 return -ENOLINK;
 768         }
 769
 770         /* send CONFIRM LINK response over RoCE fabric */
 771         rc = smc_llc_send_confirm_link(link_new, SMC_LLC_RESP);
 772         if (rc) {
 773                 smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
 774                                          false, SMC_LLC_DEL_LOST_PATH);
 775                 return -ENOLINK;
 776         }
 777         smc_llc_link_active(link_new);
 778         lgr->type = lgr_new_t;
 779         return 0;
 780 }
 781
 782 static void smc_llc_save_add_link_info(struct smc_link *link,
 783                                        struct smc_llc_msg_add_link *add_llc)
 784 {
 785         link->peer_qpn = ntoh24(add_llc->sender_qp_num);
 786         memcpy(link->peer_gid, add_llc->sender_gid, SMC_GID_SIZE);
 787         memcpy(link->peer_mac, add_llc->sender_mac, ETH_ALEN);
 788         link->peer_psn = ntoh24(add_llc->initial_psn);
 789         link->peer_mtu = add_llc->qp_mtu;
 790 }
 791
 792 /* as an SMC client, process an add link request */
 793 int smc_llc_cli_add_link(struct smc_link *link, struct smc_llc_qentry *qentry)
 794 {
 795         struct smc_llc_msg_add_link *llc = &qentry->msg.add_link;
 796         enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
 797         struct smc_link_group *lgr = smc_get_lgr(link);
 798         struct smc_link *lnk_new = NULL;
 799         struct smc_init_info ini;
 800         int lnk_idx, rc = 0;
 801
 802         ini.vlan_id = lgr->vlan_id;
 803         smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
 804         if (!memcmp(llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
 805             !memcmp(llc->sender_mac, link->peer_mac, ETH_ALEN)) {
 806                 if (!ini.ib_dev)
 807                         goto out_reject;
 808                 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
 809         }
 810         if (!ini.ib_dev) {
 811                 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
 812                 ini.ib_dev = link->smcibdev;
 813                 ini.ib_port = link->ibport;
 814         }
 815         lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
 816         if (lnk_idx < 0)
 817                 goto out_reject;
 818         lnk_new = &lgr->lnk[lnk_idx];
 819         rc = smcr_link_init(lgr, lnk_new, lnk_idx, &ini);
 820         if (rc)
 821                 goto out_reject;
 822         smc_llc_save_add_link_info(lnk_new, llc);
 823         lnk_new->link_id = llc->link_num;
 824
 825         rc = smc_ib_ready_link(lnk_new);
 826         if (rc)
 827                 goto out_clear_lnk;
 828
 829         rc = smcr_buf_map_lgr(lnk_new);
 830         if (rc)
 831                 goto out_clear_lnk;
 832
 833         rc = smc_llc_send_add_link(link,
 834                                    lnk_new->smcibdev->mac[ini.ib_port - 1],
 835                                    lnk_new->gid, lnk_new, SMC_LLC_RESP);
 836         if (rc)
 837                 goto out_clear_lnk;
 838         rc = smc_llc_cli_rkey_exchange(link, lnk_new);
 839         if (rc) {
 840                 rc = 0;
 841                 goto out_clear_lnk;
 842         }
 843         rc = smc_llc_cli_conf_link(link, &ini, lnk_new, lgr_new_t);
 844         if (!rc)
 845                 goto out;
 846 out_clear_lnk:
 847         smcr_link_clear(lnk_new);
 848 out_reject:
 849         smc_llc_cli_add_link_reject(qentry);
 850 out:
 851         kfree(qentry);
 852         return rc;
 853 }
 854
 855 static void smc_llc_process_cli_add_link(struct smc_link_group *lgr)
 856 {
 857         struct smc_llc_qentry *qentry;
 858
 859         qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
 860
 861         mutex_lock(&lgr->llc_conf_mutex);
 862         smc_llc_cli_add_link(qentry->link, qentry);
 863         mutex_unlock(&lgr->llc_conf_mutex);
 864 }
 865
 866 int smc_llc_srv_add_link(struct smc_link *link)
 867 {
 868         enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
 869         struct smc_link_group *lgr = link->lgr;
 870         struct smc_llc_msg_add_link *add_llc;
 871         struct smc_llc_qentry *qentry = NULL;
 872         struct smc_link *link_new;
 873         struct smc_init_info ini;
 874         int lnk_idx, rc = 0;
 875
 876         /* ignore client add link recommendation, start new flow */
 877         ini.vlan_id = lgr->vlan_id;
 878         smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
 879         if (!ini.ib_dev) {
 880                 lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
 881                 ini.ib_dev = link->smcibdev;
 882                 ini.ib_port = link->ibport;
 883         }
 884         lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
 885         if (lnk_idx < 0)
 886                 return 0;
 887
 888         rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, &ini);
 889         if (rc)
 890                 return rc;
 891         link_new = &lgr->lnk[lnk_idx];
 892         rc = smc_llc_send_add_link(link,
 893                                    link_new->smcibdev->mac[ini.ib_port - 1],
 894                                    link_new->gid, link_new, SMC_LLC_REQ);
 895         if (rc)
 896                 goto out_err;
 897         /* receive ADD LINK response over the RoCE fabric */
 898         qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK);
 899         if (!qentry) {
 900                 rc = -ETIMEDOUT;
 901                 goto out_err;
 902         }
 903         add_llc = &qentry->msg.add_link;
 904         if (add_llc->hd.flags & SMC_LLC_FLAG_ADD_LNK_REJ) {
 905                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 906                 rc = -ENOLINK;
 907                 goto out_err;
 908         }
 909         if (lgr->type == SMC_LGR_SINGLE &&
 910             (!memcmp(add_llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
 911              !memcmp(add_llc->sender_mac, link->peer_mac, ETH_ALEN))) {
 912                 lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
 913         }
 914         smc_llc_save_add_link_info(link_new, add_llc);
 915         smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 916
 917         rc = smc_ib_ready_link(link_new);
 918         if (rc)
 919                 goto out_err;
 920         rc = smcr_buf_map_lgr(link_new);
 921         if (rc)
 922                 goto out_err;
 923         rc = smcr_buf_reg_lgr(link_new);
 924         if (rc)
 925                 goto out_err;
 926         /* tbd: rc = smc_llc_srv_rkey_exchange(link, link_new); */
 927         if (rc)
 928                 goto out_err;
 929         /* tbd: rc = smc_llc_srv_conf_link(link, link_new, lgr_new_t); */
 930         if (rc)
 931                 goto out_err;
 932         return 0;
 933 out_err:
 934         smcr_link_clear(link_new);
 935         return rc;
 936 }
 937
 938 static void smc_llc_process_srv_add_link(struct smc_link_group *lgr)
 939 {
 940         struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
 941         int rc;
 942
 943         smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 944
 945         mutex_lock(&lgr->llc_conf_mutex);
 946         rc = smc_llc_srv_add_link(link);
 947         if (!rc && lgr->type == SMC_LGR_SYMMETRIC) {
 948                 /* delete any asymmetric link */
 949                 /* tbd: smc_llc_delete_asym_link(lgr); */
 950         }
 951         mutex_unlock(&lgr->llc_conf_mutex);
 952 }
 953
 954 /* worker to process an add link message */
 955 static void smc_llc_add_link_work(struct work_struct *work)
 956 {
 957         struct smc_link_group *lgr = container_of(work, struct smc_link_group,
 958                                                   llc_add_link_work);
 959
 960         if (list_empty(&lgr->list)) {
 961                 /* link group is terminating */
 962                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
 963                 goto out;
 964         }
 965
 966         if (lgr->role == SMC_CLNT)
 967                 smc_llc_process_cli_add_link(lgr);
 968         else
 969                 smc_llc_process_srv_add_link(lgr);
 970 out:
 971         smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
 972 }
 973
 974 static void smc_llc_rx_delete_link(struct smc_link *link,
 975                                    struct smc_llc_msg_del_link *llc)
 976 {
 977         struct smc_link_group *lgr = smc_get_lgr(link);
 978
 979         smc_lgr_forget(lgr);
 980         if (lgr->role == SMC_SERV) {
 981                 /* client asks to delete this link, send request */
 982                 smc_llc_send_delete_link(link, 0, SMC_LLC_REQ, true,
 983                                          SMC_LLC_DEL_PROG_INIT_TERM);
 984         } else {
 985                 /* server requests to delete this link, send response */
 986                 smc_llc_send_delete_link(link, 0, SMC_LLC_RESP, true,
 987                                          SMC_LLC_DEL_PROG_INIT_TERM);
 988         }
 989         smcr_link_down_cond(link);
 990 }
 991
 992 /* process a confirm_rkey request from peer, remote flow */
 993 static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr)
 994 {
 995         struct smc_llc_msg_confirm_rkey *llc;
 996         struct smc_llc_qentry *qentry;
 997         struct smc_link *link;
 998         int num_entries;
 999         int rk_idx;
1000         int i;
1001
1002         qentry = lgr->llc_flow_rmt.qentry;
1003         llc = &qentry->msg.confirm_rkey;
1004         link = qentry->link;
1005
1006         num_entries = llc->rtoken[0].num_rkeys;
1007         /* first rkey entry is for receiving link */
1008         rk_idx = smc_rtoken_add(link,
1009                                 llc->rtoken[0].rmb_vaddr,
1010                                 llc->rtoken[0].rmb_key);
1011         if (rk_idx < 0)
1012                 goto out_err;
1013
1014         for (i = 1; i <= min_t(u8, num_entries, SMC_LLC_RKEYS_PER_MSG - 1); i++)
1015                 smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id,
1016                                 llc->rtoken[i].rmb_vaddr,
1017                                 llc->rtoken[i].rmb_key);
1018         /* max links is 3 so there is no need to support conf_rkey_cont msgs */
1019         goto out;
1020 out_err:
1021         llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
1022         llc->hd.flags |= SMC_LLC_FLAG_RKEY_RETRY;
1023 out:
1024         llc->hd.flags |= SMC_LLC_FLAG_RESP;
1025         smc_llc_send_message(link, &qentry->msg);
1026         smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1027 }
1028
1029 /* process a delete_rkey request from peer, remote flow */
1030 static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr)
1031 {
1032         struct smc_llc_msg_delete_rkey *llc;
1033         struct smc_llc_qentry *qentry;
1034         struct smc_link *link;
1035         u8 err_mask = 0;
1036         int i, max;
1037
1038         qentry = lgr->llc_flow_rmt.qentry;
1039         llc = &qentry->msg.delete_rkey;
1040         link = qentry->link;
1041
1042         max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX);
1043         for (i = 0; i < max; i++) {
1044                 if (smc_rtoken_delete(link, llc->rkey[i]))
1045                         err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i);
1046         }
1047         if (err_mask) {
1048                 llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
1049                 llc->err_mask = err_mask;
1050         }
1051         llc->hd.flags |= SMC_LLC_FLAG_RESP;
1052         smc_llc_send_message(link, &qentry->msg);
1053         smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1054 }
1055
1056 /* flush the llc event queue */
1057 static void smc_llc_event_flush(struct smc_link_group *lgr)
1058 {
1059         struct smc_llc_qentry *qentry, *q;
1060
1061         spin_lock_bh(&lgr->llc_event_q_lock);
1062         list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) {
1063                 list_del_init(&qentry->list);
1064                 kfree(qentry);
1065         }
1066         spin_unlock_bh(&lgr->llc_event_q_lock);
1067 }
1068
1069 static void smc_llc_event_handler(struct smc_llc_qentry *qentry)
1070 {
1071         union smc_llc_msg *llc = &qentry->msg;
1072         struct smc_link *link = qentry->link;
1073         struct smc_link_group *lgr = link->lgr;
1074
1075         if (!smc_link_usable(link))
1076                 goto out;
1077
1078         switch (llc->raw.hdr.common.type) {
1079         case SMC_LLC_TEST_LINK:
1080                 llc->test_link.hd.flags |= SMC_LLC_FLAG_RESP;
1081                 smc_llc_send_message(link, llc);
1082                 break;
1083         case SMC_LLC_ADD_LINK:
1084                 if (list_empty(&lgr->list))
1085                         goto out;       /* lgr is terminating */
1086                 if (lgr->role == SMC_CLNT) {
1087                         if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK) {
1088                                 /* a flow is waiting for this message */
1089                                 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
1090                                                         qentry);
1091                                 wake_up_interruptible(&lgr->llc_waiter);
1092                         } else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
1093                                                       qentry)) {
1094                                 schedule_work(&lgr->llc_add_link_work);
1095                         }
1096                 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1097                         /* as smc server, handle client suggestion */
1098                         schedule_work(&lgr->llc_add_link_work);
1099                 }
1100                 return;
1101         case SMC_LLC_CONFIRM_LINK:
1102         case SMC_LLC_ADD_LINK_CONT:
1103                 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
1104                         /* a flow is waiting for this message */
1105                         smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
1106                         wake_up_interruptible(&lgr->llc_waiter);
1107                         return;
1108                 }
1109                 break;
1110         case SMC_LLC_DELETE_LINK:
1111                 smc_llc_rx_delete_link(link, &llc->delete_link);
1112                 break;
1113         case SMC_LLC_CONFIRM_RKEY:
1114                 /* new request from remote, assign to remote flow */
1115                 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1116                         /* process here, does not wait for more llc msgs */
1117                         smc_llc_rmt_conf_rkey(lgr);
1118                         smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1119                 }
1120                 return;
1121         case SMC_LLC_CONFIRM_RKEY_CONT:
1122                 /* not used because max links is 3, and 3 rkeys fit into
1123                  * one CONFIRM_RKEY message
1124                  */
1125                 break;
1126         case SMC_LLC_DELETE_RKEY:
1127                 /* new request from remote, assign to remote flow */
1128                 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1129                         /* process here, does not wait for more llc msgs */
1130                         smc_llc_rmt_delete_rkey(lgr);
1131                         smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1132                 }
1133                 return;
1134         }
1135 out:
1136         kfree(qentry);
1137 }
1138
1139 /* worker to process llc messages on the event queue */
1140 static void smc_llc_event_work(struct work_struct *work)
1141 {
1142         struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1143                                                   llc_event_work);
1144         struct smc_llc_qentry *qentry;
1145
1146         if (!lgr->llc_flow_lcl.type && lgr->delayed_event) {
1147                 if (smc_link_usable(lgr->delayed_event->link)) {
1148                         smc_llc_event_handler(lgr->delayed_event);
1149                 } else {
1150                         qentry = lgr->delayed_event;
1151                         lgr->delayed_event = NULL;
1152                         kfree(qentry);
1153                 }
1154         }
1155
1156 again:
1157         spin_lock_bh(&lgr->llc_event_q_lock);
1158         if (!list_empty(&lgr->llc_event_q)) {
1159                 qentry = list_first_entry(&lgr->llc_event_q,
1160                                           struct smc_llc_qentry, list);
1161                 list_del_init(&qentry->list);
1162                 spin_unlock_bh(&lgr->llc_event_q_lock);
1163                 smc_llc_event_handler(qentry);
1164                 goto again;
1165         }
1166         spin_unlock_bh(&lgr->llc_event_q_lock);
1167 }
1168
1169 /* process llc responses in tasklet context */
1170 static void smc_llc_rx_response(struct smc_link *link,
1171                                 struct smc_llc_qentry *qentry)
1172 {
1173         u8 llc_type = qentry->msg.raw.hdr.common.type;
1174
1175         switch (llc_type) {
1176         case SMC_LLC_TEST_LINK:
1177                 if (link->state == SMC_LNK_ACTIVE)
1178                         complete(&link->llc_testlink_resp);
1179                 break;
1180         case SMC_LLC_ADD_LINK:
1181         case SMC_LLC_CONFIRM_LINK:
1182         case SMC_LLC_ADD_LINK_CONT:
1183         case SMC_LLC_CONFIRM_RKEY:
1184         case SMC_LLC_DELETE_RKEY:
1185                 /* assign responses to the local flow, we requested them */
1186                 smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry);
1187                 wake_up_interruptible(&link->lgr->llc_waiter);
1188                 return;
1189         case SMC_LLC_DELETE_LINK:
1190                 if (link->lgr->role == SMC_SERV)
1191                         smc_lgr_schedule_free_work_fast(link->lgr);
1192                 break;
1193         case SMC_LLC_CONFIRM_RKEY_CONT:
1194                 /* not used because max links is 3 */
1195                 break;
1196         }
1197         kfree(qentry);
1198 }
1199
1200 static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc)
1201 {
1202         struct smc_link_group *lgr = link->lgr;
1203         struct smc_llc_qentry *qentry;
1204         unsigned long flags;
1205
1206         qentry = kmalloc(sizeof(*qentry), GFP_ATOMIC);
1207         if (!qentry)
1208                 return;
1209         qentry->link = link;
1210         INIT_LIST_HEAD(&qentry->list);
1211         memcpy(&qentry->msg, llc, sizeof(union smc_llc_msg));
1212
1213         /* process responses immediately */
1214         if (llc->raw.hdr.flags & SMC_LLC_FLAG_RESP) {
1215                 smc_llc_rx_response(link, qentry);
1216                 return;
1217         }
1218
1219         /* add requests to event queue */
1220         spin_lock_irqsave(&lgr->llc_event_q_lock, flags);
1221         list_add_tail(&qentry->list, &lgr->llc_event_q);
1222         spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags);
1223         schedule_work(&link->lgr->llc_event_work);
1224 }
1225
1226 /* copy received msg and add it to the event queue */
1227 static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
1228 {
1229         struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
1230         union smc_llc_msg *llc = buf;
1231
1232         if (wc->byte_len < sizeof(*llc))
1233                 return; /* short message */
1234         if (llc->raw.hdr.length != sizeof(*llc))
1235                 return; /* invalid message */
1236
1237         smc_llc_enqueue(link, llc);
1238 }
1239
1240 /***************************** worker, utils *********************************/
1241
1242 static void smc_llc_testlink_work(struct work_struct *work)
1243 {
1244         struct smc_link *link = container_of(to_delayed_work(work),
1245                                              struct smc_link, llc_testlink_wrk);
1246         unsigned long next_interval;
1247         unsigned long expire_time;
1248         u8 user_data[16] = { 0 };
1249         int rc;
1250
1251         if (link->state != SMC_LNK_ACTIVE)
1252                 return;         /* don't reschedule worker */
1253         expire_time = link->wr_rx_tstamp + link->llc_testlink_time;
1254         if (time_is_after_jiffies(expire_time)) {
1255                 next_interval = expire_time - jiffies;
1256                 goto out;
1257         }
1258         reinit_completion(&link->llc_testlink_resp);
1259         smc_llc_send_test_link(link, user_data);
1260         /* receive TEST LINK response over RoCE fabric */
1261         rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp,
1262                                                        SMC_LLC_WAIT_TIME);
1263         if (link->state != SMC_LNK_ACTIVE)
1264                 return;         /* link state changed */
1265         if (rc <= 0) {
1266                 smcr_link_down_cond_sched(link);
1267                 return;
1268         }
1269         next_interval = link->llc_testlink_time;
1270 out:
1271         schedule_delayed_work(&link->llc_testlink_wrk, next_interval);
1272 }
1273
1274 void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc)
1275 {
1276         struct net *net = sock_net(smc->clcsock->sk);
1277
1278         INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
1279         INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
1280         INIT_LIST_HEAD(&lgr->llc_event_q);
1281         spin_lock_init(&lgr->llc_event_q_lock);
1282         spin_lock_init(&lgr->llc_flow_lock);
1283         init_waitqueue_head(&lgr->llc_waiter);
1284         mutex_init(&lgr->llc_conf_mutex);
1285         lgr->llc_testlink_time = net->ipv4.sysctl_tcp_keepalive_time;
1286 }
1287
1288 /* called after lgr was removed from lgr_list */
1289 void smc_llc_lgr_clear(struct smc_link_group *lgr)
1290 {
1291         smc_llc_event_flush(lgr);
1292         wake_up_interruptible_all(&lgr->llc_waiter);
1293         cancel_work_sync(&lgr->llc_event_work);
1294         cancel_work_sync(&lgr->llc_add_link_work);
1295         if (lgr->delayed_event) {
1296                 kfree(lgr->delayed_event);
1297                 lgr->delayed_event = NULL;
1298         }
1299 }
1300
1301 int smc_llc_link_init(struct smc_link *link)
1302 {
1303         init_completion(&link->llc_testlink_resp);
1304         INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work);
1305         return 0;
1306 }
1307
1308 void smc_llc_link_active(struct smc_link *link)
1309 {
1310         link->state = SMC_LNK_ACTIVE;
1311         if (link->lgr->llc_testlink_time) {
1312                 link->llc_testlink_time = link->lgr->llc_testlink_time * HZ;
1313                 schedule_delayed_work(&link->llc_testlink_wrk,
1314                                       link->llc_testlink_time);
1315         }
1316 }
1317
1318 /* called in worker context */
1319 void smc_llc_link_clear(struct smc_link *link)
1320 {
1321         complete(&link->llc_testlink_resp);
1322         cancel_delayed_work_sync(&link->llc_testlink_wrk);
1323         smc_wr_wakeup_reg_wait(link);
1324         smc_wr_wakeup_tx_wait(link);
1325 }
1326
1327 /* register a new rtoken at the remote peer (for all links) */
1328 int smc_llc_do_confirm_rkey(struct smc_link *send_link,
1329                             struct smc_buf_desc *rmb_desc)
1330 {
1331         struct smc_link_group *lgr = send_link->lgr;
1332         struct smc_llc_qentry *qentry = NULL;
1333         int rc = 0;
1334
1335         rc = smc_llc_send_confirm_rkey(send_link, rmb_desc);
1336         if (rc)
1337                 goto out;
1338         /* receive CONFIRM RKEY response from server over RoCE fabric */
1339         qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
1340                               SMC_LLC_CONFIRM_RKEY);
1341         if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
1342                 rc = -EFAULT;
1343 out:
1344         if (qentry)
1345                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1346         return rc;
1347 }
1348
1349 /* unregister an rtoken at the remote peer */
1350 int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
1351                            struct smc_buf_desc *rmb_desc)
1352 {
1353         struct smc_llc_qentry *qentry = NULL;
1354         struct smc_link *send_link;
1355         int rc = 0;
1356
1357         send_link = smc_llc_usable_link(lgr);
1358         if (!send_link)
1359                 return -ENOLINK;
1360
1361         /* protected by llc_flow control */
1362         rc = smc_llc_send_delete_rkey(send_link, rmb_desc);
1363         if (rc)
1364                 goto out;
1365         /* receive DELETE RKEY response from server over RoCE fabric */
1366         qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
1367                               SMC_LLC_DELETE_RKEY);
1368         if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
1369                 rc = -EFAULT;
1370 out:
1371         if (qentry)
1372                 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1373         return rc;
1374 }
1375
1376 /* evaluate confirm link request or response */
1377 int smc_llc_eval_conf_link(struct smc_llc_qentry *qentry,
1378                            enum smc_llc_reqresp type)
1379 {
1380         if (type == SMC_LLC_REQ)        /* SMC server assigns link_id */
1381                 qentry->link->link_id = qentry->msg.confirm_link.link_num;
1382         if (!(qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_NO_RMBE_EYEC))
1383                 return -ENOTSUPP;
1384         return 0;
1385 }
1386
1387 /***************************** init, exit, misc ******************************/
1388
1389 static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
1390         {
1391                 .handler        = smc_llc_rx_handler,
1392                 .type           = SMC_LLC_CONFIRM_LINK
1393         },
1394         {
1395                 .handler        = smc_llc_rx_handler,
1396                 .type           = SMC_LLC_TEST_LINK
1397         },
1398         {
1399                 .handler        = smc_llc_rx_handler,
1400                 .type           = SMC_LLC_ADD_LINK
1401         },
1402         {
1403                 .handler        = smc_llc_rx_handler,
1404                 .type           = SMC_LLC_ADD_LINK_CONT
1405         },
1406         {
1407                 .handler        = smc_llc_rx_handler,
1408                 .type           = SMC_LLC_DELETE_LINK
1409         },
1410         {
1411                 .handler        = smc_llc_rx_handler,
1412                 .type           = SMC_LLC_CONFIRM_RKEY
1413         },
1414         {
1415                 .handler        = smc_llc_rx_handler,
1416                 .type           = SMC_LLC_CONFIRM_RKEY_CONT
1417         },
1418         {
1419                 .handler        = smc_llc_rx_handler,
1420                 .type           = SMC_LLC_DELETE_RKEY
1421         },
1422         {
1423                 .handler        = NULL,
1424         }
1425 };
1426
1427 int __init smc_llc_init(void)
1428 {
1429         struct smc_wr_rx_handler *handler;
1430         int rc = 0;
1431
1432         for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
1433                 INIT_HLIST_NODE(&handler->list);
1434                 rc = smc_wr_rx_register_handler(handler);
1435                 if (rc)
1436                         break;
1437         }
1438         return rc;
1439 }