mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 17:59:32 +00:00
![YueHaibing](/assets/img/avatar_default.png)
Fixes gcc '-Wunused-but-set-variable' warning: net/smc/smc_llc.c: In function 'smc_llc_cli_conf_link': net/smc/smc_llc.c:753:31: warning: variable 'del_llc' set but not used [-Wunused-but-set-variable] struct smc_llc_msg_del_link *del_llc; ^ net/smc/smc_llc.c: In function 'smc_llc_process_srv_delete_link': net/smc/smc_llc.c:1311:33: warning: variable 'del_llc_resp' set but not used [-Wunused-but-set-variable] struct smc_llc_msg_del_link *del_llc_resp; ^ Signed-off-by: YueHaibing <yuehaibing@huawei.com> Signed-off-by: Karsten Graul <kgraul@linux.ibm.com> Signed-off-by: David S. Miller <davem@davemloft.net>
1867 lines
52 KiB
C
1867 lines
52 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Shared Memory Communications over RDMA (SMC-R) and RoCE
|
|
*
|
|
* Link Layer Control (LLC)
|
|
*
|
|
* Copyright IBM Corp. 2016
|
|
*
|
|
* Author(s): Klaus Wacker <Klaus.Wacker@de.ibm.com>
|
|
* Ursula Braun <ubraun@linux.vnet.ibm.com>
|
|
*/
|
|
|
|
#include <net/tcp.h>
|
|
#include <rdma/ib_verbs.h>
|
|
|
|
#include "smc.h"
|
|
#include "smc_core.h"
|
|
#include "smc_clc.h"
|
|
#include "smc_llc.h"
|
|
#include "smc_pnet.h"
|
|
|
|
#define SMC_LLC_DATA_LEN 40
|
|
|
|
struct smc_llc_hdr {
|
|
struct smc_wr_rx_hdr common;
|
|
u8 length; /* 44 */
|
|
#if defined(__BIG_ENDIAN_BITFIELD)
|
|
u8 reserved:4,
|
|
add_link_rej_rsn:4;
|
|
#elif defined(__LITTLE_ENDIAN_BITFIELD)
|
|
u8 add_link_rej_rsn:4,
|
|
reserved:4;
|
|
#endif
|
|
u8 flags;
|
|
};
|
|
|
|
#define SMC_LLC_FLAG_NO_RMBE_EYEC 0x03
|
|
|
|
struct smc_llc_msg_confirm_link { /* type 0x01 */
|
|
struct smc_llc_hdr hd;
|
|
u8 sender_mac[ETH_ALEN];
|
|
u8 sender_gid[SMC_GID_SIZE];
|
|
u8 sender_qp_num[3];
|
|
u8 link_num;
|
|
u8 link_uid[SMC_LGR_ID_SIZE];
|
|
u8 max_links;
|
|
u8 reserved[9];
|
|
};
|
|
|
|
#define SMC_LLC_FLAG_ADD_LNK_REJ 0x40
|
|
#define SMC_LLC_REJ_RSN_NO_ALT_PATH 1
|
|
|
|
#define SMC_LLC_ADD_LNK_MAX_LINKS 2
|
|
|
|
struct smc_llc_msg_add_link { /* type 0x02 */
|
|
struct smc_llc_hdr hd;
|
|
u8 sender_mac[ETH_ALEN];
|
|
u8 reserved2[2];
|
|
u8 sender_gid[SMC_GID_SIZE];
|
|
u8 sender_qp_num[3];
|
|
u8 link_num;
|
|
#if defined(__BIG_ENDIAN_BITFIELD)
|
|
u8 reserved3 : 4,
|
|
qp_mtu : 4;
|
|
#elif defined(__LITTLE_ENDIAN_BITFIELD)
|
|
u8 qp_mtu : 4,
|
|
reserved3 : 4;
|
|
#endif
|
|
u8 initial_psn[3];
|
|
u8 reserved[8];
|
|
};
|
|
|
|
struct smc_llc_msg_add_link_cont_rt {
|
|
__be32 rmb_key;
|
|
__be32 rmb_key_new;
|
|
__be64 rmb_vaddr_new;
|
|
};
|
|
|
|
#define SMC_LLC_RKEYS_PER_CONT_MSG 2
|
|
|
|
struct smc_llc_msg_add_link_cont { /* type 0x03 */
|
|
struct smc_llc_hdr hd;
|
|
u8 link_num;
|
|
u8 num_rkeys;
|
|
u8 reserved2[2];
|
|
struct smc_llc_msg_add_link_cont_rt rt[SMC_LLC_RKEYS_PER_CONT_MSG];
|
|
u8 reserved[4];
|
|
} __packed; /* format defined in RFC7609 */
|
|
|
|
#define SMC_LLC_FLAG_DEL_LINK_ALL 0x40
|
|
#define SMC_LLC_FLAG_DEL_LINK_ORDERLY 0x20
|
|
|
|
struct smc_llc_msg_del_link { /* type 0x04 */
|
|
struct smc_llc_hdr hd;
|
|
u8 link_num;
|
|
__be32 reason;
|
|
u8 reserved[35];
|
|
} __packed; /* format defined in RFC7609 */
|
|
|
|
struct smc_llc_msg_test_link { /* type 0x07 */
|
|
struct smc_llc_hdr hd;
|
|
u8 user_data[16];
|
|
u8 reserved[24];
|
|
};
|
|
|
|
struct smc_rmb_rtoken {
|
|
union {
|
|
u8 num_rkeys; /* first rtoken byte of CONFIRM LINK msg */
|
|
/* is actually the num of rtokens, first */
|
|
/* rtoken is always for the current link */
|
|
u8 link_id; /* link id of the rtoken */
|
|
};
|
|
__be32 rmb_key;
|
|
__be64 rmb_vaddr;
|
|
} __packed; /* format defined in RFC7609 */
|
|
|
|
#define SMC_LLC_RKEYS_PER_MSG 3
|
|
|
|
struct smc_llc_msg_confirm_rkey { /* type 0x06 */
|
|
struct smc_llc_hdr hd;
|
|
struct smc_rmb_rtoken rtoken[SMC_LLC_RKEYS_PER_MSG];
|
|
u8 reserved;
|
|
};
|
|
|
|
#define SMC_LLC_DEL_RKEY_MAX 8
|
|
#define SMC_LLC_FLAG_RKEY_RETRY 0x10
|
|
#define SMC_LLC_FLAG_RKEY_NEG 0x20
|
|
|
|
struct smc_llc_msg_delete_rkey { /* type 0x09 */
|
|
struct smc_llc_hdr hd;
|
|
u8 num_rkeys;
|
|
u8 err_mask;
|
|
u8 reserved[2];
|
|
__be32 rkey[8];
|
|
u8 reserved2[4];
|
|
};
|
|
|
|
union smc_llc_msg {
|
|
struct smc_llc_msg_confirm_link confirm_link;
|
|
struct smc_llc_msg_add_link add_link;
|
|
struct smc_llc_msg_add_link_cont add_link_cont;
|
|
struct smc_llc_msg_del_link delete_link;
|
|
|
|
struct smc_llc_msg_confirm_rkey confirm_rkey;
|
|
struct smc_llc_msg_delete_rkey delete_rkey;
|
|
|
|
struct smc_llc_msg_test_link test_link;
|
|
struct {
|
|
struct smc_llc_hdr hdr;
|
|
u8 data[SMC_LLC_DATA_LEN];
|
|
} raw;
|
|
};
|
|
|
|
#define SMC_LLC_FLAG_RESP 0x80
|
|
|
|
struct smc_llc_qentry {
|
|
struct list_head list;
|
|
struct smc_link *link;
|
|
union smc_llc_msg msg;
|
|
};
|
|
|
|
static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc);
|
|
|
|
struct smc_llc_qentry *smc_llc_flow_qentry_clr(struct smc_llc_flow *flow)
|
|
{
|
|
struct smc_llc_qentry *qentry = flow->qentry;
|
|
|
|
flow->qentry = NULL;
|
|
return qentry;
|
|
}
|
|
|
|
void smc_llc_flow_qentry_del(struct smc_llc_flow *flow)
|
|
{
|
|
struct smc_llc_qentry *qentry;
|
|
|
|
if (flow->qentry) {
|
|
qentry = flow->qentry;
|
|
flow->qentry = NULL;
|
|
kfree(qentry);
|
|
}
|
|
}
|
|
|
|
static inline void smc_llc_flow_qentry_set(struct smc_llc_flow *flow,
|
|
struct smc_llc_qentry *qentry)
|
|
{
|
|
flow->qentry = qentry;
|
|
}
|
|
|
|
/* try to start a new llc flow, initiated by an incoming llc msg */
|
|
static bool smc_llc_flow_start(struct smc_llc_flow *flow,
|
|
struct smc_llc_qentry *qentry)
|
|
{
|
|
struct smc_link_group *lgr = qentry->link->lgr;
|
|
|
|
spin_lock_bh(&lgr->llc_flow_lock);
|
|
if (flow->type) {
|
|
/* a flow is already active */
|
|
if ((qentry->msg.raw.hdr.common.type == SMC_LLC_ADD_LINK ||
|
|
qentry->msg.raw.hdr.common.type == SMC_LLC_DELETE_LINK) &&
|
|
!lgr->delayed_event) {
|
|
lgr->delayed_event = qentry;
|
|
} else {
|
|
/* forget this llc request */
|
|
kfree(qentry);
|
|
}
|
|
spin_unlock_bh(&lgr->llc_flow_lock);
|
|
return false;
|
|
}
|
|
switch (qentry->msg.raw.hdr.common.type) {
|
|
case SMC_LLC_ADD_LINK:
|
|
flow->type = SMC_LLC_FLOW_ADD_LINK;
|
|
break;
|
|
case SMC_LLC_DELETE_LINK:
|
|
flow->type = SMC_LLC_FLOW_DEL_LINK;
|
|
break;
|
|
case SMC_LLC_CONFIRM_RKEY:
|
|
case SMC_LLC_DELETE_RKEY:
|
|
flow->type = SMC_LLC_FLOW_RKEY;
|
|
break;
|
|
default:
|
|
flow->type = SMC_LLC_FLOW_NONE;
|
|
}
|
|
if (qentry == lgr->delayed_event)
|
|
lgr->delayed_event = NULL;
|
|
spin_unlock_bh(&lgr->llc_flow_lock);
|
|
smc_llc_flow_qentry_set(flow, qentry);
|
|
return true;
|
|
}
|
|
|
|
/* start a new local llc flow, wait till current flow finished */
|
|
int smc_llc_flow_initiate(struct smc_link_group *lgr,
|
|
enum smc_llc_flowtype type)
|
|
{
|
|
enum smc_llc_flowtype allowed_remote = SMC_LLC_FLOW_NONE;
|
|
int rc;
|
|
|
|
/* all flows except confirm_rkey and delete_rkey are exclusive,
|
|
* confirm/delete rkey flows can run concurrently (local and remote)
|
|
*/
|
|
if (type == SMC_LLC_FLOW_RKEY)
|
|
allowed_remote = SMC_LLC_FLOW_RKEY;
|
|
again:
|
|
if (list_empty(&lgr->list))
|
|
return -ENODEV;
|
|
spin_lock_bh(&lgr->llc_flow_lock);
|
|
if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
|
|
(lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
|
|
lgr->llc_flow_rmt.type == allowed_remote)) {
|
|
lgr->llc_flow_lcl.type = type;
|
|
spin_unlock_bh(&lgr->llc_flow_lock);
|
|
return 0;
|
|
}
|
|
spin_unlock_bh(&lgr->llc_flow_lock);
|
|
rc = wait_event_interruptible_timeout(lgr->llc_waiter,
|
|
(lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
|
|
(lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
|
|
lgr->llc_flow_rmt.type == allowed_remote)),
|
|
SMC_LLC_WAIT_TIME);
|
|
if (!rc)
|
|
return -ETIMEDOUT;
|
|
goto again;
|
|
}
|
|
|
|
/* finish the current llc flow */
|
|
void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow)
|
|
{
|
|
spin_lock_bh(&lgr->llc_flow_lock);
|
|
memset(flow, 0, sizeof(*flow));
|
|
flow->type = SMC_LLC_FLOW_NONE;
|
|
spin_unlock_bh(&lgr->llc_flow_lock);
|
|
if (!list_empty(&lgr->list) && lgr->delayed_event &&
|
|
flow == &lgr->llc_flow_lcl)
|
|
schedule_work(&lgr->llc_event_work);
|
|
else
|
|
wake_up_interruptible(&lgr->llc_waiter);
|
|
}
|
|
|
|
/* lnk is optional and used for early wakeup when link goes down, useful in
|
|
* cases where we wait for a response on the link after we sent a request
|
|
*/
|
|
struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr,
|
|
struct smc_link *lnk,
|
|
int time_out, u8 exp_msg)
|
|
{
|
|
struct smc_llc_flow *flow = &lgr->llc_flow_lcl;
|
|
|
|
wait_event_interruptible_timeout(lgr->llc_waiter,
|
|
(flow->qentry ||
|
|
(lnk && !smc_link_usable(lnk)) ||
|
|
list_empty(&lgr->list)),
|
|
time_out);
|
|
if (!flow->qentry ||
|
|
(lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) {
|
|
smc_llc_flow_qentry_del(flow);
|
|
goto out;
|
|
}
|
|
if (exp_msg && flow->qentry->msg.raw.hdr.common.type != exp_msg) {
|
|
if (exp_msg == SMC_LLC_ADD_LINK &&
|
|
flow->qentry->msg.raw.hdr.common.type ==
|
|
SMC_LLC_DELETE_LINK) {
|
|
/* flow_start will delay the unexpected msg */
|
|
smc_llc_flow_start(&lgr->llc_flow_lcl,
|
|
smc_llc_flow_qentry_clr(flow));
|
|
return NULL;
|
|
}
|
|
smc_llc_flow_qentry_del(flow);
|
|
}
|
|
out:
|
|
return flow->qentry;
|
|
}
|
|
|
|
/********************************** send *************************************/
|
|
|
|
struct smc_llc_tx_pend {
|
|
};
|
|
|
|
/* handler for send/transmission completion of an LLC msg */
|
|
static void smc_llc_tx_handler(struct smc_wr_tx_pend_priv *pend,
|
|
struct smc_link *link,
|
|
enum ib_wc_status wc_status)
|
|
{
|
|
/* future work: handle wc_status error for recovery and failover */
|
|
}
|
|
|
|
/**
|
|
* smc_llc_add_pending_send() - add LLC control message to pending WQE transmits
|
|
* @link: Pointer to SMC link used for sending LLC control message.
|
|
* @wr_buf: Out variable returning pointer to work request payload buffer.
|
|
* @pend: Out variable returning pointer to private pending WR tracking.
|
|
* It's the context the transmit complete handler will get.
|
|
*
|
|
* Reserves and pre-fills an entry for a pending work request send/tx.
|
|
* Used by mid-level smc_llc_send_msg() to prepare for later actual send/tx.
|
|
* Can sleep due to smc_get_ctrl_buf (if not in softirq context).
|
|
*
|
|
* Return: 0 on success, otherwise an error value.
|
|
*/
|
|
static int smc_llc_add_pending_send(struct smc_link *link,
|
|
struct smc_wr_buf **wr_buf,
|
|
struct smc_wr_tx_pend_priv **pend)
|
|
{
|
|
int rc;
|
|
|
|
rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL,
|
|
pend);
|
|
if (rc < 0)
|
|
return rc;
|
|
BUILD_BUG_ON_MSG(
|
|
sizeof(union smc_llc_msg) > SMC_WR_BUF_SIZE,
|
|
"must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_llc_msg)");
|
|
BUILD_BUG_ON_MSG(
|
|
sizeof(union smc_llc_msg) != SMC_WR_TX_SIZE,
|
|
"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()");
|
|
BUILD_BUG_ON_MSG(
|
|
sizeof(struct smc_llc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
|
|
"must increase SMC_WR_TX_PEND_PRIV_SIZE to at least sizeof(struct smc_llc_tx_pend)");
|
|
return 0;
|
|
}
|
|
|
|
/* high-level API to send LLC confirm link */
|
|
int smc_llc_send_confirm_link(struct smc_link *link,
|
|
enum smc_llc_reqresp reqresp)
|
|
{
|
|
struct smc_llc_msg_confirm_link *confllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
confllc = (struct smc_llc_msg_confirm_link *)wr_buf;
|
|
memset(confllc, 0, sizeof(*confllc));
|
|
confllc->hd.common.type = SMC_LLC_CONFIRM_LINK;
|
|
confllc->hd.length = sizeof(struct smc_llc_msg_confirm_link);
|
|
confllc->hd.flags |= SMC_LLC_FLAG_NO_RMBE_EYEC;
|
|
if (reqresp == SMC_LLC_RESP)
|
|
confllc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
memcpy(confllc->sender_mac, link->smcibdev->mac[link->ibport - 1],
|
|
ETH_ALEN);
|
|
memcpy(confllc->sender_gid, link->gid, SMC_GID_SIZE);
|
|
hton24(confllc->sender_qp_num, link->roce_qp->qp_num);
|
|
confllc->link_num = link->link_id;
|
|
memcpy(confllc->link_uid, link->link_uid, SMC_LGR_ID_SIZE);
|
|
confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS;
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* send LLC confirm rkey request */
|
|
static int smc_llc_send_confirm_rkey(struct smc_link *send_link,
|
|
struct smc_buf_desc *rmb_desc)
|
|
{
|
|
struct smc_llc_msg_confirm_rkey *rkeyllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
struct smc_link *link;
|
|
int i, rc, rtok_ix;
|
|
|
|
rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf;
|
|
memset(rkeyllc, 0, sizeof(*rkeyllc));
|
|
rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY;
|
|
rkeyllc->hd.length = sizeof(struct smc_llc_msg_confirm_rkey);
|
|
|
|
rtok_ix = 1;
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
|
|
link = &send_link->lgr->lnk[i];
|
|
if (link->state == SMC_LNK_ACTIVE && link != send_link) {
|
|
rkeyllc->rtoken[rtok_ix].link_id = link->link_id;
|
|
rkeyllc->rtoken[rtok_ix].rmb_key =
|
|
htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
|
|
rkeyllc->rtoken[rtok_ix].rmb_vaddr = cpu_to_be64(
|
|
(u64)sg_dma_address(
|
|
rmb_desc->sgt[link->link_idx].sgl));
|
|
rtok_ix++;
|
|
}
|
|
}
|
|
/* rkey of send_link is in rtoken[0] */
|
|
rkeyllc->rtoken[0].num_rkeys = rtok_ix - 1;
|
|
rkeyllc->rtoken[0].rmb_key =
|
|
htonl(rmb_desc->mr_rx[send_link->link_idx]->rkey);
|
|
rkeyllc->rtoken[0].rmb_vaddr = cpu_to_be64(
|
|
(u64)sg_dma_address(rmb_desc->sgt[send_link->link_idx].sgl));
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(send_link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* send LLC delete rkey request */
|
|
static int smc_llc_send_delete_rkey(struct smc_link *link,
|
|
struct smc_buf_desc *rmb_desc)
|
|
{
|
|
struct smc_llc_msg_delete_rkey *rkeyllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf;
|
|
memset(rkeyllc, 0, sizeof(*rkeyllc));
|
|
rkeyllc->hd.common.type = SMC_LLC_DELETE_RKEY;
|
|
rkeyllc->hd.length = sizeof(struct smc_llc_msg_delete_rkey);
|
|
rkeyllc->num_rkeys = 1;
|
|
rkeyllc->rkey[0] = htonl(rmb_desc->mr_rx[link->link_idx]->rkey);
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* send ADD LINK request or response */
|
|
int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[],
|
|
struct smc_link *link_new,
|
|
enum smc_llc_reqresp reqresp)
|
|
{
|
|
struct smc_llc_msg_add_link *addllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
addllc = (struct smc_llc_msg_add_link *)wr_buf;
|
|
|
|
memset(addllc, 0, sizeof(*addllc));
|
|
addllc->hd.common.type = SMC_LLC_ADD_LINK;
|
|
addllc->hd.length = sizeof(struct smc_llc_msg_add_link);
|
|
if (reqresp == SMC_LLC_RESP)
|
|
addllc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
memcpy(addllc->sender_mac, mac, ETH_ALEN);
|
|
memcpy(addllc->sender_gid, gid, SMC_GID_SIZE);
|
|
if (link_new) {
|
|
addllc->link_num = link_new->link_id;
|
|
hton24(addllc->sender_qp_num, link_new->roce_qp->qp_num);
|
|
hton24(addllc->initial_psn, link_new->psn_initial);
|
|
if (reqresp == SMC_LLC_REQ)
|
|
addllc->qp_mtu = link_new->path_mtu;
|
|
else
|
|
addllc->qp_mtu = min(link_new->path_mtu,
|
|
link_new->peer_mtu);
|
|
}
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* send DELETE LINK request or response */
|
|
int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id,
|
|
enum smc_llc_reqresp reqresp, bool orderly,
|
|
u32 reason)
|
|
{
|
|
struct smc_llc_msg_del_link *delllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
delllc = (struct smc_llc_msg_del_link *)wr_buf;
|
|
|
|
memset(delllc, 0, sizeof(*delllc));
|
|
delllc->hd.common.type = SMC_LLC_DELETE_LINK;
|
|
delllc->hd.length = sizeof(struct smc_llc_msg_del_link);
|
|
if (reqresp == SMC_LLC_RESP)
|
|
delllc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
if (orderly)
|
|
delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
|
|
if (link_del_id)
|
|
delllc->link_num = link_del_id;
|
|
else
|
|
delllc->hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
|
|
delllc->reason = htonl(reason);
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* send LLC test link request */
|
|
static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16])
|
|
{
|
|
struct smc_llc_msg_test_link *testllc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
testllc = (struct smc_llc_msg_test_link *)wr_buf;
|
|
memset(testllc, 0, sizeof(*testllc));
|
|
testllc->hd.common.type = SMC_LLC_TEST_LINK;
|
|
testllc->hd.length = sizeof(struct smc_llc_msg_test_link);
|
|
memcpy(testllc->user_data, user_data, sizeof(testllc->user_data));
|
|
/* send llc message */
|
|
rc = smc_wr_tx_send(link, pend);
|
|
return rc;
|
|
}
|
|
|
|
/* schedule an llc send on link, may wait for buffers */
|
|
static int smc_llc_send_message(struct smc_link *link, void *llcbuf)
|
|
{
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
if (!smc_link_usable(link))
|
|
return -ENOLINK;
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
|
|
return smc_wr_tx_send(link, pend);
|
|
}
|
|
|
|
/* schedule an llc send on link, may wait for buffers,
|
|
* and wait for send completion notification.
|
|
* @return 0 on success
|
|
*/
|
|
static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf)
|
|
{
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
int rc;
|
|
|
|
if (!smc_link_usable(link))
|
|
return -ENOLINK;
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg));
|
|
return smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME);
|
|
}
|
|
|
|
/********************************* receive ***********************************/
|
|
|
|
static int smc_llc_alloc_alt_link(struct smc_link_group *lgr,
|
|
enum smc_lgr_type lgr_new_t)
|
|
{
|
|
int i;
|
|
|
|
if (lgr->type == SMC_LGR_SYMMETRIC ||
|
|
(lgr->type != SMC_LGR_SINGLE &&
|
|
(lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
|
|
lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)))
|
|
return -EMLINK;
|
|
|
|
if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
|
|
lgr_new_t == SMC_LGR_ASYMMETRIC_PEER) {
|
|
for (i = SMC_LINKS_PER_LGR_MAX - 1; i >= 0; i--)
|
|
if (lgr->lnk[i].state == SMC_LNK_UNUSED)
|
|
return i;
|
|
} else {
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++)
|
|
if (lgr->lnk[i].state == SMC_LNK_UNUSED)
|
|
return i;
|
|
}
|
|
return -EMLINK;
|
|
}
|
|
|
|
/* return first buffer from any of the next buf lists */
|
|
static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr,
|
|
int *buf_lst)
|
|
{
|
|
struct smc_buf_desc *buf_pos;
|
|
|
|
while (*buf_lst < SMC_RMBE_SIZES) {
|
|
buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst],
|
|
struct smc_buf_desc, list);
|
|
if (buf_pos)
|
|
return buf_pos;
|
|
(*buf_lst)++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* return next rmb from buffer lists */
|
|
static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr,
|
|
int *buf_lst,
|
|
struct smc_buf_desc *buf_pos)
|
|
{
|
|
struct smc_buf_desc *buf_next;
|
|
|
|
if (!buf_pos || list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) {
|
|
(*buf_lst)++;
|
|
return _smc_llc_get_next_rmb(lgr, buf_lst);
|
|
}
|
|
buf_next = list_next_entry(buf_pos, list);
|
|
return buf_next;
|
|
}
|
|
|
|
static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr,
|
|
int *buf_lst)
|
|
{
|
|
*buf_lst = 0;
|
|
return smc_llc_get_next_rmb(lgr, buf_lst, NULL);
|
|
}
|
|
|
|
/* send one add_link_continue msg */
|
|
static int smc_llc_add_link_cont(struct smc_link *link,
|
|
struct smc_link *link_new, u8 *num_rkeys_todo,
|
|
int *buf_lst, struct smc_buf_desc **buf_pos)
|
|
{
|
|
struct smc_llc_msg_add_link_cont *addc_llc;
|
|
struct smc_link_group *lgr = link->lgr;
|
|
int prim_lnk_idx, lnk_idx, i, rc;
|
|
struct smc_wr_tx_pend_priv *pend;
|
|
struct smc_wr_buf *wr_buf;
|
|
struct smc_buf_desc *rmb;
|
|
u8 n;
|
|
|
|
rc = smc_llc_add_pending_send(link, &wr_buf, &pend);
|
|
if (rc)
|
|
return rc;
|
|
addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf;
|
|
memset(addc_llc, 0, sizeof(*addc_llc));
|
|
|
|
prim_lnk_idx = link->link_idx;
|
|
lnk_idx = link_new->link_idx;
|
|
addc_llc->link_num = link_new->link_id;
|
|
addc_llc->num_rkeys = *num_rkeys_todo;
|
|
n = *num_rkeys_todo;
|
|
for (i = 0; i < min_t(u8, n, SMC_LLC_RKEYS_PER_CONT_MSG); i++) {
|
|
if (!*buf_pos) {
|
|
addc_llc->num_rkeys = addc_llc->num_rkeys -
|
|
*num_rkeys_todo;
|
|
*num_rkeys_todo = 0;
|
|
break;
|
|
}
|
|
rmb = *buf_pos;
|
|
|
|
addc_llc->rt[i].rmb_key = htonl(rmb->mr_rx[prim_lnk_idx]->rkey);
|
|
addc_llc->rt[i].rmb_key_new = htonl(rmb->mr_rx[lnk_idx]->rkey);
|
|
addc_llc->rt[i].rmb_vaddr_new =
|
|
cpu_to_be64((u64)sg_dma_address(rmb->sgt[lnk_idx].sgl));
|
|
|
|
(*num_rkeys_todo)--;
|
|
*buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
|
|
while (*buf_pos && !(*buf_pos)->used)
|
|
*buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
|
|
}
|
|
addc_llc->hd.common.type = SMC_LLC_ADD_LINK_CONT;
|
|
addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont);
|
|
if (lgr->role == SMC_CLNT)
|
|
addc_llc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
return smc_wr_tx_send(link, pend);
|
|
}
|
|
|
|
static int smc_llc_cli_rkey_exchange(struct smc_link *link,
|
|
struct smc_link *link_new)
|
|
{
|
|
struct smc_llc_msg_add_link_cont *addc_llc;
|
|
struct smc_link_group *lgr = link->lgr;
|
|
u8 max, num_rkeys_send, num_rkeys_recv;
|
|
struct smc_llc_qentry *qentry;
|
|
struct smc_buf_desc *buf_pos;
|
|
int buf_lst;
|
|
int rc = 0;
|
|
int i;
|
|
|
|
mutex_lock(&lgr->rmbs_lock);
|
|
num_rkeys_send = lgr->conns_num;
|
|
buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
|
|
do {
|
|
qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_ADD_LINK_CONT);
|
|
if (!qentry) {
|
|
rc = -ETIMEDOUT;
|
|
break;
|
|
}
|
|
addc_llc = &qentry->msg.add_link_cont;
|
|
num_rkeys_recv = addc_llc->num_rkeys;
|
|
max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
|
|
for (i = 0; i < max; i++) {
|
|
smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
|
|
addc_llc->rt[i].rmb_key,
|
|
addc_llc->rt[i].rmb_vaddr_new,
|
|
addc_llc->rt[i].rmb_key_new);
|
|
num_rkeys_recv--;
|
|
}
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
rc = smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
|
|
&buf_lst, &buf_pos);
|
|
if (rc)
|
|
break;
|
|
} while (num_rkeys_send || num_rkeys_recv);
|
|
|
|
mutex_unlock(&lgr->rmbs_lock);
|
|
return rc;
|
|
}
|
|
|
|
/* prepare and send an add link reject response */
|
|
static int smc_llc_cli_add_link_reject(struct smc_llc_qentry *qentry)
|
|
{
|
|
qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
|
|
qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_ADD_LNK_REJ;
|
|
qentry->msg.raw.hdr.add_link_rej_rsn = SMC_LLC_REJ_RSN_NO_ALT_PATH;
|
|
return smc_llc_send_message(qentry->link, &qentry->msg);
|
|
}
|
|
|
|
static int smc_llc_cli_conf_link(struct smc_link *link,
|
|
struct smc_init_info *ini,
|
|
struct smc_link *link_new,
|
|
enum smc_lgr_type lgr_new_t)
|
|
{
|
|
struct smc_link_group *lgr = link->lgr;
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
int rc = 0;
|
|
|
|
/* receive CONFIRM LINK request over RoCE fabric */
|
|
qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0);
|
|
if (!qentry) {
|
|
rc = smc_llc_send_delete_link(link, link_new->link_id,
|
|
SMC_LLC_REQ, false,
|
|
SMC_LLC_DEL_LOST_PATH);
|
|
return -ENOLINK;
|
|
}
|
|
if (qentry->msg.raw.hdr.common.type != SMC_LLC_CONFIRM_LINK) {
|
|
/* received DELETE_LINK instead */
|
|
qentry->msg.raw.hdr.flags |= SMC_LLC_FLAG_RESP;
|
|
smc_llc_send_message(link, &qentry->msg);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
return -ENOLINK;
|
|
}
|
|
smc_llc_save_peer_uid(qentry);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
|
|
rc = smc_ib_modify_qp_rts(link_new);
|
|
if (rc) {
|
|
smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
|
|
false, SMC_LLC_DEL_LOST_PATH);
|
|
return -ENOLINK;
|
|
}
|
|
smc_wr_remember_qp_attr(link_new);
|
|
|
|
rc = smcr_buf_reg_lgr(link_new);
|
|
if (rc) {
|
|
smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
|
|
false, SMC_LLC_DEL_LOST_PATH);
|
|
return -ENOLINK;
|
|
}
|
|
|
|
/* send CONFIRM LINK response over RoCE fabric */
|
|
rc = smc_llc_send_confirm_link(link_new, SMC_LLC_RESP);
|
|
if (rc) {
|
|
smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
|
|
false, SMC_LLC_DEL_LOST_PATH);
|
|
return -ENOLINK;
|
|
}
|
|
smc_llc_link_active(link_new);
|
|
if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
|
|
lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
|
|
smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
|
|
else
|
|
smcr_lgr_set_type(lgr, lgr_new_t);
|
|
return 0;
|
|
}
|
|
|
|
static void smc_llc_save_add_link_info(struct smc_link *link,
|
|
struct smc_llc_msg_add_link *add_llc)
|
|
{
|
|
link->peer_qpn = ntoh24(add_llc->sender_qp_num);
|
|
memcpy(link->peer_gid, add_llc->sender_gid, SMC_GID_SIZE);
|
|
memcpy(link->peer_mac, add_llc->sender_mac, ETH_ALEN);
|
|
link->peer_psn = ntoh24(add_llc->initial_psn);
|
|
link->peer_mtu = add_llc->qp_mtu;
|
|
}
|
|
|
|
/* as an SMC client, process an add link request */
|
|
int smc_llc_cli_add_link(struct smc_link *link, struct smc_llc_qentry *qentry)
|
|
{
|
|
struct smc_llc_msg_add_link *llc = &qentry->msg.add_link;
|
|
enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
|
|
struct smc_link_group *lgr = smc_get_lgr(link);
|
|
struct smc_link *lnk_new = NULL;
|
|
struct smc_init_info ini;
|
|
int lnk_idx, rc = 0;
|
|
|
|
ini.vlan_id = lgr->vlan_id;
|
|
smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
|
|
if (!memcmp(llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
|
|
!memcmp(llc->sender_mac, link->peer_mac, ETH_ALEN)) {
|
|
if (!ini.ib_dev)
|
|
goto out_reject;
|
|
lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
|
|
}
|
|
if (!ini.ib_dev) {
|
|
lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
|
|
ini.ib_dev = link->smcibdev;
|
|
ini.ib_port = link->ibport;
|
|
}
|
|
lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
|
|
if (lnk_idx < 0)
|
|
goto out_reject;
|
|
lnk_new = &lgr->lnk[lnk_idx];
|
|
rc = smcr_link_init(lgr, lnk_new, lnk_idx, &ini);
|
|
if (rc)
|
|
goto out_reject;
|
|
smc_llc_save_add_link_info(lnk_new, llc);
|
|
lnk_new->link_id = llc->link_num; /* SMC server assigns link id */
|
|
smc_llc_link_set_uid(lnk_new);
|
|
|
|
rc = smc_ib_ready_link(lnk_new);
|
|
if (rc)
|
|
goto out_clear_lnk;
|
|
|
|
rc = smcr_buf_map_lgr(lnk_new);
|
|
if (rc)
|
|
goto out_clear_lnk;
|
|
|
|
rc = smc_llc_send_add_link(link,
|
|
lnk_new->smcibdev->mac[ini.ib_port - 1],
|
|
lnk_new->gid, lnk_new, SMC_LLC_RESP);
|
|
if (rc)
|
|
goto out_clear_lnk;
|
|
rc = smc_llc_cli_rkey_exchange(link, lnk_new);
|
|
if (rc) {
|
|
rc = 0;
|
|
goto out_clear_lnk;
|
|
}
|
|
rc = smc_llc_cli_conf_link(link, &ini, lnk_new, lgr_new_t);
|
|
if (!rc)
|
|
goto out;
|
|
out_clear_lnk:
|
|
smcr_link_clear(lnk_new, false);
|
|
out_reject:
|
|
smc_llc_cli_add_link_reject(qentry);
|
|
out:
|
|
kfree(qentry);
|
|
return rc;
|
|
}
|
|
|
|
static void smc_llc_process_cli_add_link(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_llc_qentry *qentry;
|
|
|
|
qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
|
|
|
|
mutex_lock(&lgr->llc_conf_mutex);
|
|
smc_llc_cli_add_link(qentry->link, qentry);
|
|
mutex_unlock(&lgr->llc_conf_mutex);
|
|
}
|
|
|
|
static int smc_llc_active_link_count(struct smc_link_group *lgr)
|
|
{
|
|
int i, link_count = 0;
|
|
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
|
|
if (!smc_link_usable(&lgr->lnk[i]))
|
|
continue;
|
|
link_count++;
|
|
}
|
|
return link_count;
|
|
}
|
|
|
|
/* find the asymmetric link when 3 links are established */
|
|
static struct smc_link *smc_llc_find_asym_link(struct smc_link_group *lgr)
|
|
{
|
|
int asym_idx = -ENOENT;
|
|
int i, j, k;
|
|
bool found;
|
|
|
|
/* determine asymmetric link */
|
|
found = false;
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
|
|
for (j = i + 1; j < SMC_LINKS_PER_LGR_MAX; j++) {
|
|
if (!smc_link_usable(&lgr->lnk[i]) ||
|
|
!smc_link_usable(&lgr->lnk[j]))
|
|
continue;
|
|
if (!memcmp(lgr->lnk[i].gid, lgr->lnk[j].gid,
|
|
SMC_GID_SIZE)) {
|
|
found = true; /* asym_lnk is i or j */
|
|
break;
|
|
}
|
|
}
|
|
if (found)
|
|
break;
|
|
}
|
|
if (!found)
|
|
goto out; /* no asymmetric link */
|
|
for (k = 0; k < SMC_LINKS_PER_LGR_MAX; k++) {
|
|
if (!smc_link_usable(&lgr->lnk[k]))
|
|
continue;
|
|
if (k != i &&
|
|
!memcmp(lgr->lnk[i].peer_gid, lgr->lnk[k].peer_gid,
|
|
SMC_GID_SIZE)) {
|
|
asym_idx = i;
|
|
break;
|
|
}
|
|
if (k != j &&
|
|
!memcmp(lgr->lnk[j].peer_gid, lgr->lnk[k].peer_gid,
|
|
SMC_GID_SIZE)) {
|
|
asym_idx = j;
|
|
break;
|
|
}
|
|
}
|
|
out:
|
|
return (asym_idx < 0) ? NULL : &lgr->lnk[asym_idx];
|
|
}
|
|
|
|
static void smc_llc_delete_asym_link(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_link *lnk_new = NULL, *lnk_asym;
|
|
struct smc_llc_qentry *qentry;
|
|
int rc;
|
|
|
|
lnk_asym = smc_llc_find_asym_link(lgr);
|
|
if (!lnk_asym)
|
|
return; /* no asymmetric link */
|
|
if (!smc_link_downing(&lnk_asym->state))
|
|
return;
|
|
lnk_new = smc_switch_conns(lgr, lnk_asym, false);
|
|
smc_wr_tx_wait_no_pending_sends(lnk_asym);
|
|
if (!lnk_new)
|
|
goto out_free;
|
|
/* change flow type from ADD_LINK into DEL_LINK */
|
|
lgr->llc_flow_lcl.type = SMC_LLC_FLOW_DEL_LINK;
|
|
rc = smc_llc_send_delete_link(lnk_new, lnk_asym->link_id, SMC_LLC_REQ,
|
|
true, SMC_LLC_DEL_NO_ASYM_NEEDED);
|
|
if (rc) {
|
|
smcr_link_down_cond(lnk_new);
|
|
goto out_free;
|
|
}
|
|
qentry = smc_llc_wait(lgr, lnk_new, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_DELETE_LINK);
|
|
if (!qentry) {
|
|
smcr_link_down_cond(lnk_new);
|
|
goto out_free;
|
|
}
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
out_free:
|
|
smcr_link_clear(lnk_asym, true);
|
|
}
|
|
|
|
static int smc_llc_srv_rkey_exchange(struct smc_link *link,
|
|
struct smc_link *link_new)
|
|
{
|
|
struct smc_llc_msg_add_link_cont *addc_llc;
|
|
struct smc_link_group *lgr = link->lgr;
|
|
u8 max, num_rkeys_send, num_rkeys_recv;
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
struct smc_buf_desc *buf_pos;
|
|
int buf_lst;
|
|
int rc = 0;
|
|
int i;
|
|
|
|
mutex_lock(&lgr->rmbs_lock);
|
|
num_rkeys_send = lgr->conns_num;
|
|
buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
|
|
do {
|
|
smc_llc_add_link_cont(link, link_new, &num_rkeys_send,
|
|
&buf_lst, &buf_pos);
|
|
qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_ADD_LINK_CONT);
|
|
if (!qentry) {
|
|
rc = -ETIMEDOUT;
|
|
goto out;
|
|
}
|
|
addc_llc = &qentry->msg.add_link_cont;
|
|
num_rkeys_recv = addc_llc->num_rkeys;
|
|
max = min_t(u8, num_rkeys_recv, SMC_LLC_RKEYS_PER_CONT_MSG);
|
|
for (i = 0; i < max; i++) {
|
|
smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
|
|
addc_llc->rt[i].rmb_key,
|
|
addc_llc->rt[i].rmb_vaddr_new,
|
|
addc_llc->rt[i].rmb_key_new);
|
|
num_rkeys_recv--;
|
|
}
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
} while (num_rkeys_send || num_rkeys_recv);
|
|
out:
|
|
mutex_unlock(&lgr->rmbs_lock);
|
|
return rc;
|
|
}
|
|
|
|
static int smc_llc_srv_conf_link(struct smc_link *link,
|
|
struct smc_link *link_new,
|
|
enum smc_lgr_type lgr_new_t)
|
|
{
|
|
struct smc_link_group *lgr = link->lgr;
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
int rc;
|
|
|
|
/* send CONFIRM LINK request over the RoCE fabric */
|
|
rc = smc_llc_send_confirm_link(link_new, SMC_LLC_REQ);
|
|
if (rc)
|
|
return -ENOLINK;
|
|
/* receive CONFIRM LINK response over the RoCE fabric */
|
|
qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_FIRST_TIME,
|
|
SMC_LLC_CONFIRM_LINK);
|
|
if (!qentry) {
|
|
/* send DELETE LINK */
|
|
smc_llc_send_delete_link(link, link_new->link_id, SMC_LLC_REQ,
|
|
false, SMC_LLC_DEL_LOST_PATH);
|
|
return -ENOLINK;
|
|
}
|
|
smc_llc_save_peer_uid(qentry);
|
|
smc_llc_link_active(link_new);
|
|
if (lgr_new_t == SMC_LGR_ASYMMETRIC_LOCAL ||
|
|
lgr_new_t == SMC_LGR_ASYMMETRIC_PEER)
|
|
smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
|
|
else
|
|
smcr_lgr_set_type(lgr, lgr_new_t);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
return 0;
|
|
}
|
|
|
|
int smc_llc_srv_add_link(struct smc_link *link)
|
|
{
|
|
enum smc_lgr_type lgr_new_t = SMC_LGR_SYMMETRIC;
|
|
struct smc_link_group *lgr = link->lgr;
|
|
struct smc_llc_msg_add_link *add_llc;
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
struct smc_link *link_new;
|
|
struct smc_init_info ini;
|
|
int lnk_idx, rc = 0;
|
|
|
|
/* ignore client add link recommendation, start new flow */
|
|
ini.vlan_id = lgr->vlan_id;
|
|
smc_pnet_find_alt_roce(lgr, &ini, link->smcibdev);
|
|
if (!ini.ib_dev) {
|
|
lgr_new_t = SMC_LGR_ASYMMETRIC_LOCAL;
|
|
ini.ib_dev = link->smcibdev;
|
|
ini.ib_port = link->ibport;
|
|
}
|
|
lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
|
|
if (lnk_idx < 0)
|
|
return 0;
|
|
|
|
rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, &ini);
|
|
if (rc)
|
|
return rc;
|
|
link_new = &lgr->lnk[lnk_idx];
|
|
rc = smc_llc_send_add_link(link,
|
|
link_new->smcibdev->mac[ini.ib_port - 1],
|
|
link_new->gid, link_new, SMC_LLC_REQ);
|
|
if (rc)
|
|
goto out_err;
|
|
/* receive ADD LINK response over the RoCE fabric */
|
|
qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK);
|
|
if (!qentry) {
|
|
rc = -ETIMEDOUT;
|
|
goto out_err;
|
|
}
|
|
add_llc = &qentry->msg.add_link;
|
|
if (add_llc->hd.flags & SMC_LLC_FLAG_ADD_LNK_REJ) {
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
rc = -ENOLINK;
|
|
goto out_err;
|
|
}
|
|
if (lgr->type == SMC_LGR_SINGLE &&
|
|
(!memcmp(add_llc->sender_gid, link->peer_gid, SMC_GID_SIZE) &&
|
|
!memcmp(add_llc->sender_mac, link->peer_mac, ETH_ALEN))) {
|
|
lgr_new_t = SMC_LGR_ASYMMETRIC_PEER;
|
|
}
|
|
smc_llc_save_add_link_info(link_new, add_llc);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
|
|
rc = smc_ib_ready_link(link_new);
|
|
if (rc)
|
|
goto out_err;
|
|
rc = smcr_buf_map_lgr(link_new);
|
|
if (rc)
|
|
goto out_err;
|
|
rc = smcr_buf_reg_lgr(link_new);
|
|
if (rc)
|
|
goto out_err;
|
|
rc = smc_llc_srv_rkey_exchange(link, link_new);
|
|
if (rc)
|
|
goto out_err;
|
|
rc = smc_llc_srv_conf_link(link, link_new, lgr_new_t);
|
|
if (rc)
|
|
goto out_err;
|
|
return 0;
|
|
out_err:
|
|
smcr_link_clear(link_new, false);
|
|
return rc;
|
|
}
|
|
|
|
static void smc_llc_process_srv_add_link(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
|
|
int rc;
|
|
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
|
|
mutex_lock(&lgr->llc_conf_mutex);
|
|
rc = smc_llc_srv_add_link(link);
|
|
if (!rc && lgr->type == SMC_LGR_SYMMETRIC) {
|
|
/* delete any asymmetric link */
|
|
smc_llc_delete_asym_link(lgr);
|
|
}
|
|
mutex_unlock(&lgr->llc_conf_mutex);
|
|
}
|
|
|
|
/* enqueue a local add_link req to trigger a new add_link flow, only as SERV */
|
|
void smc_llc_srv_add_link_local(struct smc_link *link)
|
|
{
|
|
struct smc_llc_msg_add_link add_llc = {0};
|
|
|
|
add_llc.hd.length = sizeof(add_llc);
|
|
add_llc.hd.common.type = SMC_LLC_ADD_LINK;
|
|
/* no dev and port needed, we as server ignore client data anyway */
|
|
smc_llc_enqueue(link, (union smc_llc_msg *)&add_llc);
|
|
}
|
|
|
|
/* worker to process an add link message */
|
|
static void smc_llc_add_link_work(struct work_struct *work)
|
|
{
|
|
struct smc_link_group *lgr = container_of(work, struct smc_link_group,
|
|
llc_add_link_work);
|
|
|
|
if (list_empty(&lgr->list)) {
|
|
/* link group is terminating */
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
goto out;
|
|
}
|
|
|
|
if (lgr->role == SMC_CLNT)
|
|
smc_llc_process_cli_add_link(lgr);
|
|
else
|
|
smc_llc_process_srv_add_link(lgr);
|
|
out:
|
|
smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
|
|
}
|
|
|
|
/* enqueue a local del_link msg to trigger a new del_link flow,
|
|
* called only for role SMC_SERV
|
|
*/
|
|
void smc_llc_srv_delete_link_local(struct smc_link *link, u8 del_link_id)
|
|
{
|
|
struct smc_llc_msg_del_link del_llc = {0};
|
|
|
|
del_llc.hd.length = sizeof(del_llc);
|
|
del_llc.hd.common.type = SMC_LLC_DELETE_LINK;
|
|
del_llc.link_num = del_link_id;
|
|
del_llc.reason = htonl(SMC_LLC_DEL_LOST_PATH);
|
|
del_llc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
|
|
smc_llc_enqueue(link, (union smc_llc_msg *)&del_llc);
|
|
}
|
|
|
|
static void smc_llc_process_cli_delete_link(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_link *lnk_del = NULL, *lnk_asym, *lnk;
|
|
struct smc_llc_msg_del_link *del_llc;
|
|
struct smc_llc_qentry *qentry;
|
|
int active_links;
|
|
int lnk_idx;
|
|
|
|
qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
|
|
lnk = qentry->link;
|
|
del_llc = &qentry->msg.delete_link;
|
|
|
|
if (del_llc->hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
|
|
smc_lgr_terminate_sched(lgr);
|
|
goto out;
|
|
}
|
|
mutex_lock(&lgr->llc_conf_mutex);
|
|
/* delete single link */
|
|
for (lnk_idx = 0; lnk_idx < SMC_LINKS_PER_LGR_MAX; lnk_idx++) {
|
|
if (lgr->lnk[lnk_idx].link_id != del_llc->link_num)
|
|
continue;
|
|
lnk_del = &lgr->lnk[lnk_idx];
|
|
break;
|
|
}
|
|
del_llc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
if (!lnk_del) {
|
|
/* link was not found */
|
|
del_llc->reason = htonl(SMC_LLC_DEL_NOLNK);
|
|
smc_llc_send_message(lnk, &qentry->msg);
|
|
goto out_unlock;
|
|
}
|
|
lnk_asym = smc_llc_find_asym_link(lgr);
|
|
|
|
del_llc->reason = 0;
|
|
smc_llc_send_message(lnk, &qentry->msg); /* response */
|
|
|
|
if (smc_link_downing(&lnk_del->state)) {
|
|
smc_switch_conns(lgr, lnk_del, false);
|
|
smc_wr_tx_wait_no_pending_sends(lnk_del);
|
|
}
|
|
smcr_link_clear(lnk_del, true);
|
|
|
|
active_links = smc_llc_active_link_count(lgr);
|
|
if (lnk_del == lnk_asym) {
|
|
/* expected deletion of asym link, don't change lgr state */
|
|
} else if (active_links == 1) {
|
|
smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
|
|
} else if (!active_links) {
|
|
smcr_lgr_set_type(lgr, SMC_LGR_NONE);
|
|
smc_lgr_terminate_sched(lgr);
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&lgr->llc_conf_mutex);
|
|
out:
|
|
kfree(qentry);
|
|
}
|
|
|
|
/* try to send a DELETE LINK ALL request on any active link,
|
|
* waiting for send completion
|
|
*/
|
|
void smc_llc_send_link_delete_all(struct smc_link_group *lgr, bool ord, u32 rsn)
|
|
{
|
|
struct smc_llc_msg_del_link delllc = {0};
|
|
int i;
|
|
|
|
delllc.hd.common.type = SMC_LLC_DELETE_LINK;
|
|
delllc.hd.length = sizeof(delllc);
|
|
if (ord)
|
|
delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ORDERLY;
|
|
delllc.hd.flags |= SMC_LLC_FLAG_DEL_LINK_ALL;
|
|
delllc.reason = htonl(rsn);
|
|
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
|
|
if (!smc_link_usable(&lgr->lnk[i]))
|
|
continue;
|
|
if (!smc_llc_send_message_wait(&lgr->lnk[i], &delllc))
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void smc_llc_process_srv_delete_link(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_llc_msg_del_link *del_llc;
|
|
struct smc_link *lnk, *lnk_del;
|
|
struct smc_llc_qentry *qentry;
|
|
int active_links;
|
|
int i;
|
|
|
|
mutex_lock(&lgr->llc_conf_mutex);
|
|
qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
|
|
lnk = qentry->link;
|
|
del_llc = &qentry->msg.delete_link;
|
|
|
|
if (qentry->msg.delete_link.hd.flags & SMC_LLC_FLAG_DEL_LINK_ALL) {
|
|
/* delete entire lgr */
|
|
smc_llc_send_link_delete_all(lgr, true, ntohl(
|
|
qentry->msg.delete_link.reason));
|
|
smc_lgr_terminate_sched(lgr);
|
|
goto out;
|
|
}
|
|
/* delete single link */
|
|
lnk_del = NULL;
|
|
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
|
|
if (lgr->lnk[i].link_id == del_llc->link_num) {
|
|
lnk_del = &lgr->lnk[i];
|
|
break;
|
|
}
|
|
}
|
|
if (!lnk_del)
|
|
goto out; /* asymmetric link already deleted */
|
|
|
|
if (smc_link_downing(&lnk_del->state)) {
|
|
smc_switch_conns(lgr, lnk_del, false);
|
|
smc_wr_tx_wait_no_pending_sends(lnk_del);
|
|
}
|
|
if (!list_empty(&lgr->list)) {
|
|
/* qentry is either a request from peer (send it back to
|
|
* initiate the DELETE_LINK processing), or a locally
|
|
* enqueued DELETE_LINK request (forward it)
|
|
*/
|
|
if (!smc_llc_send_message(lnk, &qentry->msg)) {
|
|
struct smc_llc_qentry *qentry2;
|
|
|
|
qentry2 = smc_llc_wait(lgr, lnk, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_DELETE_LINK);
|
|
if (qentry2)
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
}
|
|
}
|
|
smcr_link_clear(lnk_del, true);
|
|
|
|
active_links = smc_llc_active_link_count(lgr);
|
|
if (active_links == 1) {
|
|
smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
|
|
} else if (!active_links) {
|
|
smcr_lgr_set_type(lgr, SMC_LGR_NONE);
|
|
smc_lgr_terminate_sched(lgr);
|
|
}
|
|
|
|
if (lgr->type == SMC_LGR_SINGLE && !list_empty(&lgr->list)) {
|
|
/* trigger setup of asymm alt link */
|
|
smc_llc_srv_add_link_local(lnk);
|
|
}
|
|
out:
|
|
mutex_unlock(&lgr->llc_conf_mutex);
|
|
kfree(qentry);
|
|
}
|
|
|
|
static void smc_llc_delete_link_work(struct work_struct *work)
|
|
{
|
|
struct smc_link_group *lgr = container_of(work, struct smc_link_group,
|
|
llc_del_link_work);
|
|
|
|
if (list_empty(&lgr->list)) {
|
|
/* link group is terminating */
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
goto out;
|
|
}
|
|
|
|
if (lgr->role == SMC_CLNT)
|
|
smc_llc_process_cli_delete_link(lgr);
|
|
else
|
|
smc_llc_process_srv_delete_link(lgr);
|
|
out:
|
|
smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
|
|
}
|
|
|
|
/* process a confirm_rkey request from peer, remote flow */
|
|
static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_llc_msg_confirm_rkey *llc;
|
|
struct smc_llc_qentry *qentry;
|
|
struct smc_link *link;
|
|
int num_entries;
|
|
int rk_idx;
|
|
int i;
|
|
|
|
qentry = lgr->llc_flow_rmt.qentry;
|
|
llc = &qentry->msg.confirm_rkey;
|
|
link = qentry->link;
|
|
|
|
num_entries = llc->rtoken[0].num_rkeys;
|
|
/* first rkey entry is for receiving link */
|
|
rk_idx = smc_rtoken_add(link,
|
|
llc->rtoken[0].rmb_vaddr,
|
|
llc->rtoken[0].rmb_key);
|
|
if (rk_idx < 0)
|
|
goto out_err;
|
|
|
|
for (i = 1; i <= min_t(u8, num_entries, SMC_LLC_RKEYS_PER_MSG - 1); i++)
|
|
smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id,
|
|
llc->rtoken[i].rmb_vaddr,
|
|
llc->rtoken[i].rmb_key);
|
|
/* max links is 3 so there is no need to support conf_rkey_cont msgs */
|
|
goto out;
|
|
out_err:
|
|
llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
|
|
llc->hd.flags |= SMC_LLC_FLAG_RKEY_RETRY;
|
|
out:
|
|
llc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
smc_llc_send_message(link, &qentry->msg);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
|
|
}
|
|
|
|
/* process a delete_rkey request from peer, remote flow */
|
|
static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_llc_msg_delete_rkey *llc;
|
|
struct smc_llc_qentry *qentry;
|
|
struct smc_link *link;
|
|
u8 err_mask = 0;
|
|
int i, max;
|
|
|
|
qentry = lgr->llc_flow_rmt.qentry;
|
|
llc = &qentry->msg.delete_rkey;
|
|
link = qentry->link;
|
|
|
|
max = min_t(u8, llc->num_rkeys, SMC_LLC_DEL_RKEY_MAX);
|
|
for (i = 0; i < max; i++) {
|
|
if (smc_rtoken_delete(link, llc->rkey[i]))
|
|
err_mask |= 1 << (SMC_LLC_DEL_RKEY_MAX - 1 - i);
|
|
}
|
|
if (err_mask) {
|
|
llc->hd.flags |= SMC_LLC_FLAG_RKEY_NEG;
|
|
llc->err_mask = err_mask;
|
|
}
|
|
llc->hd.flags |= SMC_LLC_FLAG_RESP;
|
|
smc_llc_send_message(link, &qentry->msg);
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
|
|
}
|
|
|
|
static void smc_llc_protocol_violation(struct smc_link_group *lgr, u8 type)
|
|
{
|
|
pr_warn_ratelimited("smc: SMC-R lg %*phN LLC protocol violation: "
|
|
"llc_type %d\n", SMC_LGR_ID_SIZE, &lgr->id, type);
|
|
smc_llc_set_termination_rsn(lgr, SMC_LLC_DEL_PROT_VIOL);
|
|
smc_lgr_terminate_sched(lgr);
|
|
}
|
|
|
|
/* flush the llc event queue */
|
|
static void smc_llc_event_flush(struct smc_link_group *lgr)
|
|
{
|
|
struct smc_llc_qentry *qentry, *q;
|
|
|
|
spin_lock_bh(&lgr->llc_event_q_lock);
|
|
list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) {
|
|
list_del_init(&qentry->list);
|
|
kfree(qentry);
|
|
}
|
|
spin_unlock_bh(&lgr->llc_event_q_lock);
|
|
}
|
|
|
|
static void smc_llc_event_handler(struct smc_llc_qentry *qentry)
|
|
{
|
|
union smc_llc_msg *llc = &qentry->msg;
|
|
struct smc_link *link = qentry->link;
|
|
struct smc_link_group *lgr = link->lgr;
|
|
|
|
if (!smc_link_usable(link))
|
|
goto out;
|
|
|
|
switch (llc->raw.hdr.common.type) {
|
|
case SMC_LLC_TEST_LINK:
|
|
llc->test_link.hd.flags |= SMC_LLC_FLAG_RESP;
|
|
smc_llc_send_message(link, llc);
|
|
break;
|
|
case SMC_LLC_ADD_LINK:
|
|
if (list_empty(&lgr->list))
|
|
goto out; /* lgr is terminating */
|
|
if (lgr->role == SMC_CLNT) {
|
|
if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK) {
|
|
/* a flow is waiting for this message */
|
|
smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
|
|
qentry);
|
|
wake_up_interruptible(&lgr->llc_waiter);
|
|
} else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
|
|
qentry)) {
|
|
schedule_work(&lgr->llc_add_link_work);
|
|
}
|
|
} else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
|
|
/* as smc server, handle client suggestion */
|
|
schedule_work(&lgr->llc_add_link_work);
|
|
}
|
|
return;
|
|
case SMC_LLC_CONFIRM_LINK:
|
|
case SMC_LLC_ADD_LINK_CONT:
|
|
if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
|
|
/* a flow is waiting for this message */
|
|
smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
|
|
wake_up_interruptible(&lgr->llc_waiter);
|
|
return;
|
|
}
|
|
break;
|
|
case SMC_LLC_DELETE_LINK:
|
|
if (lgr->role == SMC_CLNT) {
|
|
/* server requests to delete this link, send response */
|
|
if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
|
|
/* DEL LINK REQ during ADD LINK SEQ */
|
|
smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
|
|
qentry);
|
|
wake_up_interruptible(&lgr->llc_waiter);
|
|
} else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
|
|
qentry)) {
|
|
schedule_work(&lgr->llc_del_link_work);
|
|
}
|
|
} else {
|
|
if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
|
|
!lgr->llc_flow_lcl.qentry) {
|
|
/* DEL LINK REQ during ADD LINK SEQ */
|
|
smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
|
|
qentry);
|
|
wake_up_interruptible(&lgr->llc_waiter);
|
|
} else if (smc_llc_flow_start(&lgr->llc_flow_lcl,
|
|
qentry)) {
|
|
schedule_work(&lgr->llc_del_link_work);
|
|
}
|
|
}
|
|
return;
|
|
case SMC_LLC_CONFIRM_RKEY:
|
|
/* new request from remote, assign to remote flow */
|
|
if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
|
|
/* process here, does not wait for more llc msgs */
|
|
smc_llc_rmt_conf_rkey(lgr);
|
|
smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
|
|
}
|
|
return;
|
|
case SMC_LLC_CONFIRM_RKEY_CONT:
|
|
/* not used because max links is 3, and 3 rkeys fit into
|
|
* one CONFIRM_RKEY message
|
|
*/
|
|
break;
|
|
case SMC_LLC_DELETE_RKEY:
|
|
/* new request from remote, assign to remote flow */
|
|
if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
|
|
/* process here, does not wait for more llc msgs */
|
|
smc_llc_rmt_delete_rkey(lgr);
|
|
smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
|
|
}
|
|
return;
|
|
default:
|
|
smc_llc_protocol_violation(lgr, llc->raw.hdr.common.type);
|
|
break;
|
|
}
|
|
out:
|
|
kfree(qentry);
|
|
}
|
|
|
|
/* worker to process llc messages on the event queue */
|
|
static void smc_llc_event_work(struct work_struct *work)
|
|
{
|
|
struct smc_link_group *lgr = container_of(work, struct smc_link_group,
|
|
llc_event_work);
|
|
struct smc_llc_qentry *qentry;
|
|
|
|
if (!lgr->llc_flow_lcl.type && lgr->delayed_event) {
|
|
if (smc_link_usable(lgr->delayed_event->link)) {
|
|
smc_llc_event_handler(lgr->delayed_event);
|
|
} else {
|
|
qentry = lgr->delayed_event;
|
|
lgr->delayed_event = NULL;
|
|
kfree(qentry);
|
|
}
|
|
}
|
|
|
|
again:
|
|
spin_lock_bh(&lgr->llc_event_q_lock);
|
|
if (!list_empty(&lgr->llc_event_q)) {
|
|
qentry = list_first_entry(&lgr->llc_event_q,
|
|
struct smc_llc_qentry, list);
|
|
list_del_init(&qentry->list);
|
|
spin_unlock_bh(&lgr->llc_event_q_lock);
|
|
smc_llc_event_handler(qentry);
|
|
goto again;
|
|
}
|
|
spin_unlock_bh(&lgr->llc_event_q_lock);
|
|
}
|
|
|
|
/* process llc responses in tasklet context */
|
|
static void smc_llc_rx_response(struct smc_link *link,
|
|
struct smc_llc_qentry *qentry)
|
|
{
|
|
u8 llc_type = qentry->msg.raw.hdr.common.type;
|
|
|
|
switch (llc_type) {
|
|
case SMC_LLC_TEST_LINK:
|
|
if (link->state == SMC_LNK_ACTIVE)
|
|
complete(&link->llc_testlink_resp);
|
|
break;
|
|
case SMC_LLC_ADD_LINK:
|
|
case SMC_LLC_DELETE_LINK:
|
|
case SMC_LLC_CONFIRM_LINK:
|
|
case SMC_LLC_ADD_LINK_CONT:
|
|
case SMC_LLC_CONFIRM_RKEY:
|
|
case SMC_LLC_DELETE_RKEY:
|
|
/* assign responses to the local flow, we requested them */
|
|
smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry);
|
|
wake_up_interruptible(&link->lgr->llc_waiter);
|
|
return;
|
|
case SMC_LLC_CONFIRM_RKEY_CONT:
|
|
/* not used because max links is 3 */
|
|
break;
|
|
default:
|
|
smc_llc_protocol_violation(link->lgr, llc_type);
|
|
break;
|
|
}
|
|
kfree(qentry);
|
|
}
|
|
|
|
static void smc_llc_enqueue(struct smc_link *link, union smc_llc_msg *llc)
|
|
{
|
|
struct smc_link_group *lgr = link->lgr;
|
|
struct smc_llc_qentry *qentry;
|
|
unsigned long flags;
|
|
|
|
qentry = kmalloc(sizeof(*qentry), GFP_ATOMIC);
|
|
if (!qentry)
|
|
return;
|
|
qentry->link = link;
|
|
INIT_LIST_HEAD(&qentry->list);
|
|
memcpy(&qentry->msg, llc, sizeof(union smc_llc_msg));
|
|
|
|
/* process responses immediately */
|
|
if (llc->raw.hdr.flags & SMC_LLC_FLAG_RESP) {
|
|
smc_llc_rx_response(link, qentry);
|
|
return;
|
|
}
|
|
|
|
/* add requests to event queue */
|
|
spin_lock_irqsave(&lgr->llc_event_q_lock, flags);
|
|
list_add_tail(&qentry->list, &lgr->llc_event_q);
|
|
spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags);
|
|
schedule_work(&link->lgr->llc_event_work);
|
|
}
|
|
|
|
/* copy received msg and add it to the event queue */
|
|
static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)
|
|
{
|
|
struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
|
|
union smc_llc_msg *llc = buf;
|
|
|
|
if (wc->byte_len < sizeof(*llc))
|
|
return; /* short message */
|
|
if (llc->raw.hdr.length != sizeof(*llc))
|
|
return; /* invalid message */
|
|
|
|
smc_llc_enqueue(link, llc);
|
|
}
|
|
|
|
/***************************** worker, utils *********************************/
|
|
|
|
static void smc_llc_testlink_work(struct work_struct *work)
|
|
{
|
|
struct smc_link *link = container_of(to_delayed_work(work),
|
|
struct smc_link, llc_testlink_wrk);
|
|
unsigned long next_interval;
|
|
unsigned long expire_time;
|
|
u8 user_data[16] = { 0 };
|
|
int rc;
|
|
|
|
if (link->state != SMC_LNK_ACTIVE)
|
|
return; /* don't reschedule worker */
|
|
expire_time = link->wr_rx_tstamp + link->llc_testlink_time;
|
|
if (time_is_after_jiffies(expire_time)) {
|
|
next_interval = expire_time - jiffies;
|
|
goto out;
|
|
}
|
|
reinit_completion(&link->llc_testlink_resp);
|
|
smc_llc_send_test_link(link, user_data);
|
|
/* receive TEST LINK response over RoCE fabric */
|
|
rc = wait_for_completion_interruptible_timeout(&link->llc_testlink_resp,
|
|
SMC_LLC_WAIT_TIME);
|
|
if (link->state != SMC_LNK_ACTIVE)
|
|
return; /* link state changed */
|
|
if (rc <= 0) {
|
|
smcr_link_down_cond_sched(link);
|
|
return;
|
|
}
|
|
next_interval = link->llc_testlink_time;
|
|
out:
|
|
schedule_delayed_work(&link->llc_testlink_wrk, next_interval);
|
|
}
|
|
|
|
void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc)
|
|
{
|
|
struct net *net = sock_net(smc->clcsock->sk);
|
|
|
|
INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
|
|
INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
|
|
INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work);
|
|
INIT_LIST_HEAD(&lgr->llc_event_q);
|
|
spin_lock_init(&lgr->llc_event_q_lock);
|
|
spin_lock_init(&lgr->llc_flow_lock);
|
|
init_waitqueue_head(&lgr->llc_waiter);
|
|
mutex_init(&lgr->llc_conf_mutex);
|
|
lgr->llc_testlink_time = net->ipv4.sysctl_tcp_keepalive_time;
|
|
}
|
|
|
|
/* called after lgr was removed from lgr_list */
|
|
void smc_llc_lgr_clear(struct smc_link_group *lgr)
|
|
{
|
|
smc_llc_event_flush(lgr);
|
|
wake_up_interruptible_all(&lgr->llc_waiter);
|
|
cancel_work_sync(&lgr->llc_event_work);
|
|
cancel_work_sync(&lgr->llc_add_link_work);
|
|
cancel_work_sync(&lgr->llc_del_link_work);
|
|
if (lgr->delayed_event) {
|
|
kfree(lgr->delayed_event);
|
|
lgr->delayed_event = NULL;
|
|
}
|
|
}
|
|
|
|
int smc_llc_link_init(struct smc_link *link)
|
|
{
|
|
init_completion(&link->llc_testlink_resp);
|
|
INIT_DELAYED_WORK(&link->llc_testlink_wrk, smc_llc_testlink_work);
|
|
return 0;
|
|
}
|
|
|
|
void smc_llc_link_active(struct smc_link *link)
|
|
{
|
|
pr_warn_ratelimited("smc: SMC-R lg %*phN link added: id %*phN, "
|
|
"peerid %*phN, ibdev %s, ibport %d\n",
|
|
SMC_LGR_ID_SIZE, &link->lgr->id,
|
|
SMC_LGR_ID_SIZE, &link->link_uid,
|
|
SMC_LGR_ID_SIZE, &link->peer_link_uid,
|
|
link->smcibdev->ibdev->name, link->ibport);
|
|
link->state = SMC_LNK_ACTIVE;
|
|
if (link->lgr->llc_testlink_time) {
|
|
link->llc_testlink_time = link->lgr->llc_testlink_time * HZ;
|
|
schedule_delayed_work(&link->llc_testlink_wrk,
|
|
link->llc_testlink_time);
|
|
}
|
|
}
|
|
|
|
/* called in worker context */
|
|
void smc_llc_link_clear(struct smc_link *link, bool log)
|
|
{
|
|
if (log)
|
|
pr_warn_ratelimited("smc: SMC-R lg %*phN link removed: id %*phN"
|
|
", peerid %*phN, ibdev %s, ibport %d\n",
|
|
SMC_LGR_ID_SIZE, &link->lgr->id,
|
|
SMC_LGR_ID_SIZE, &link->link_uid,
|
|
SMC_LGR_ID_SIZE, &link->peer_link_uid,
|
|
link->smcibdev->ibdev->name, link->ibport);
|
|
complete(&link->llc_testlink_resp);
|
|
cancel_delayed_work_sync(&link->llc_testlink_wrk);
|
|
smc_wr_wakeup_reg_wait(link);
|
|
smc_wr_wakeup_tx_wait(link);
|
|
}
|
|
|
|
/* register a new rtoken at the remote peer (for all links) */
|
|
int smc_llc_do_confirm_rkey(struct smc_link *send_link,
|
|
struct smc_buf_desc *rmb_desc)
|
|
{
|
|
struct smc_link_group *lgr = send_link->lgr;
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
int rc = 0;
|
|
|
|
rc = smc_llc_send_confirm_rkey(send_link, rmb_desc);
|
|
if (rc)
|
|
goto out;
|
|
/* receive CONFIRM RKEY response from server over RoCE fabric */
|
|
qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_CONFIRM_RKEY);
|
|
if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
|
|
rc = -EFAULT;
|
|
out:
|
|
if (qentry)
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
return rc;
|
|
}
|
|
|
|
/* unregister an rtoken at the remote peer */
|
|
int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
|
|
struct smc_buf_desc *rmb_desc)
|
|
{
|
|
struct smc_llc_qentry *qentry = NULL;
|
|
struct smc_link *send_link;
|
|
int rc = 0;
|
|
|
|
send_link = smc_llc_usable_link(lgr);
|
|
if (!send_link)
|
|
return -ENOLINK;
|
|
|
|
/* protected by llc_flow control */
|
|
rc = smc_llc_send_delete_rkey(send_link, rmb_desc);
|
|
if (rc)
|
|
goto out;
|
|
/* receive DELETE RKEY response from server over RoCE fabric */
|
|
qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
|
|
SMC_LLC_DELETE_RKEY);
|
|
if (!qentry || (qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_RKEY_NEG))
|
|
rc = -EFAULT;
|
|
out:
|
|
if (qentry)
|
|
smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
|
|
return rc;
|
|
}
|
|
|
|
void smc_llc_link_set_uid(struct smc_link *link)
|
|
{
|
|
__be32 link_uid;
|
|
|
|
link_uid = htonl(*((u32 *)link->lgr->id) + link->link_id);
|
|
memcpy(link->link_uid, &link_uid, SMC_LGR_ID_SIZE);
|
|
}
|
|
|
|
/* save peers link user id, used for debug purposes */
|
|
void smc_llc_save_peer_uid(struct smc_llc_qentry *qentry)
|
|
{
|
|
memcpy(qentry->link->peer_link_uid, qentry->msg.confirm_link.link_uid,
|
|
SMC_LGR_ID_SIZE);
|
|
}
|
|
|
|
/* evaluate confirm link request or response */
|
|
int smc_llc_eval_conf_link(struct smc_llc_qentry *qentry,
|
|
enum smc_llc_reqresp type)
|
|
{
|
|
if (type == SMC_LLC_REQ) { /* SMC server assigns link_id */
|
|
qentry->link->link_id = qentry->msg.confirm_link.link_num;
|
|
smc_llc_link_set_uid(qentry->link);
|
|
}
|
|
if (!(qentry->msg.raw.hdr.flags & SMC_LLC_FLAG_NO_RMBE_EYEC))
|
|
return -ENOTSUPP;
|
|
return 0;
|
|
}
|
|
|
|
/***************************** init, exit, misc ******************************/
|
|
|
|
static struct smc_wr_rx_handler smc_llc_rx_handlers[] = {
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_CONFIRM_LINK
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_TEST_LINK
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_ADD_LINK
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_ADD_LINK_CONT
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_DELETE_LINK
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_CONFIRM_RKEY
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_CONFIRM_RKEY_CONT
|
|
},
|
|
{
|
|
.handler = smc_llc_rx_handler,
|
|
.type = SMC_LLC_DELETE_RKEY
|
|
},
|
|
{
|
|
.handler = NULL,
|
|
}
|
|
};
|
|
|
|
int __init smc_llc_init(void)
|
|
{
|
|
struct smc_wr_rx_handler *handler;
|
|
int rc = 0;
|
|
|
|
for (handler = smc_llc_rx_handlers; handler->handler; handler++) {
|
|
INIT_HLIST_NODE(&handler->list);
|
|
rc = smc_wr_rx_register_handler(handler);
|
|
if (rc)
|
|
break;
|
|
}
|
|
return rc;
|
|
}
|