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  *  For now, we only support the necessary "confirm link" functionality
   8  *  which happens for the first RoCE link after successful CLC handshake.
   9  *
  10  *  Copyright IBM Corp. 2016
  11  *
  12  *  Author(s):  Klaus Wacker <Klaus.Wacker@de.ibm.com>
  13  *              Ursula Braun <ubraun@linux.vnet.ibm.com>
  14  */
  15
  16 #include <net/tcp.h>
  17 #include <rdma/ib_verbs.h>
  18
  19 #include "smc.h"
  20 #include "smc_core.h"
  21 #include "smc_clc.h"
  22 #include "smc_llc.h"
  23
  24 /********************************** send *************************************/
  25
  26 struct smc_llc_tx_pend {
  27 };
  28
  29 /* handler for send/transmission completion of an LLC msg */
  30 static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
  31                                struct smc_link *link,
  32                                enum ib_wc_status wc_status)
  33 {
  34         /* future work: handle wc_status error for recovery and failover */
  35 }
  36
  37 /**
  38  * smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
  39  * @link: Pointer to SMC link used for sending LLC control message.
  40  * @wr_buf: Out variable returning pointer to work request payload buffer.
  41  * @pend: Out variable returning pointer to private pending WR tracking.
  42  *        It's the context the transmit complete handler will get.
  43  *
  44  * Reserves and pre-fills an entry for a pending work request send/tx.
  45  * Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
  46  * Can sleep due to smc_get_ctrl_buf (if not in softirq context).
  47  *
  48  * Return: 0 on success, otherwise an error value.
  49  */
  50 static int smc_llc_add_pending_send(struct smc_link *link,
  51                                     struct smc_wr_buf **wr_buf,
  52                                     struct smc_wr_tx_pend_priv **pend)
  53 {
  54         int rc;
  55
  56         rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, pend);
  57         if (rc < 0)
  58                 return rc;
  59         BUILD_BUG_ON_MSG(
  60                 sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
  61                 "must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
  62         BUILD_BUG_ON_MSG(
  63                 sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
  64                 "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()");
  65         BUILD_BUG_ON_MSG(
  66                 sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
  67                 "must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
  68         return 0;
  69 }
  70
  71 /* high-level API to send LLC confirm link */
  72 int smc_llc_send_confirm_link(struct smc_link *link, u8 mac[],
  73                               union ib_gid *gid,
  74                               enum smc_llc_reqresp reqresp)
  75 {
  76         struct smc_link_group *lgr = container_of(link, struct smc_link_group,
  77                                                   lnk[SMC_SINGLE_LINK]);
  78         struct smc_llc_msg_confirm_link *confllc;
  79         struct smc_wr_tx_pend_priv *pend;
  80         struct smc_wr_buf *wr_buf;
  81         int rc;
  82
  83         rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
  84         if (rc)
  85                 return rc;
  86         confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
  87         memset(confllc, 0, sizeof(*confllc));
  88         confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
  89         confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
  90         if (reqresp == SMC_LLC_RESP)
  91                 confllc->hd.flags |= SMC_LLC_FLAG_RESP;
  92         memcpy(confllc->sender_mac, mac, ETH_ALEN);
  93         memcpy(confllc->sender_gid, gid, SMC_GID_SIZE);
  94         hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
  95         /* confllc->link_num = SMC_SINGLE_LINK; already done by memset above */
  96         memcpy(confllc->link_uid, lgr->id, SMC_LGR_ID_SIZE);
  97         confllc->max_links = SMC_LINKS_PER_LGR_MAX;
  98         /* send llc message */
  99         rc = smc_wr_tx_send(link, pend);
 100         return rc;
 101 }
 102
 103 /********************************* receive ***********************************/
 104
 105 static void smc_llc_rx_confirm_link(struct smc_link *link,
 106                                     struct smc_llc_msg_confirm_link *llc)
 107 {
 108         struct smc_link_group *lgr;
 109
 110         lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);
 111         if (llc->hd.flags & SMC_LLC_FLAG_RESP) {
 112                 if (lgr->role == SMC_SERV)
 113                         complete(&link->llc_confirm_resp);
 114         } else {
 115                 if (lgr->role == SMC_CLNT) {
 116                         link->link_id = llc->link_num;
 117                         complete(&link->llc_confirm);
 118                 }
 119         }
 120 }
 121
 122 static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
 123 {
 124         struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
 125         union smc_llc_msg *llc = buf;
 126
 127         if (wc->byte_len < sizeof(*llc))
 128                 return; /* short message */
 129         if (llc->raw.hdr.length != sizeof(*llc))
 130                 return; /* invalid message */
 131         if (llc->raw.hdr.common.type == SMC_LLC_CONFIRM_LINK)
 132                 smc_llc_rx_confirm_link(link, &llc->confirm_link);
 133 }
 134
 135 /***************************** init, exit, misc ******************************/
 136
 137 static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
 138         {
 139                 .handler        = smc_llc_rx_handler,
 140                 .type           = SMC_LLC_CONFIRM_LINK
 141         },
 142         {
 143                 .handler        = NULL,
 144         }
 145 };
 146
 147 int __init smc_llc_init(void)
 148 {
 149         struct smc_wr_rx_handler *handler;
 150         int rc = 0;
 151
 152         for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
 153                 INIT_HLIST_NODE(&handler->list);
 154                 rc = smc_wr_rx_register_handler(handler);
 155                 if (rc)
 156                         break;
 157         }
 158         return rc;
 159 }