[mirror_ubuntu-bionic-kernel.git] / net / smc / smc_wr.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Shared Memory Communications over RDMA (SMC-R) and RoCE
 *
 * Work Requests exploiting Infiniband API
 *
 * Work requests (WR) of type ib_post_send or ib_post_recv respectively
 * are submitted to either RC SQ or RC RQ respectively
 * (reliably connected send/receive queue)
 * and become work queue entries (WQEs).
 * While an SQ WR/WQE is pending, we track it until transmission completion.
 * Through a send or receive completion queue (CQ) respectively,
 * we get completion queue entries (CQEs) [aka work completions (WCs)].
 * Since the CQ callback is called from IRQ context, we split work by using
 * bottom halves implemented by tasklets.
 *
 * SMC uses this to exchange LLC (link layer control)
 * and CDC (connection data control) messages.
 *
 * Copyright IBM Corp. 2016
 *
 * Author(s):  Steffen Maier <maier@linux.vnet.ibm.com>
 */

#include <linux/atomic.h>
#include <linux/hashtable.h>
#include <linux/wait.h>
#include <rdma/ib_verbs.h>
#include <asm/div64.h>

#include "smc.h"
#include "smc_wr.h"

#define SMC_WR_MAX_POLL_CQE 10	/* max. # of compl. queue elements in 1 poll */

#define SMC_WR_RX_HASH_BITS 4
static DEFINE_HASHTABLE(smc_wr_rx_hash, SMC_WR_RX_HASH_BITS);
static DEFINE_SPINLOCK(smc_wr_rx_hash_lock);

struct smc_wr_tx_pend {	/* control data for a pending send request */
	u64			wr_id;		/* work request id sent */
	smc_wr_tx_handler	handler;
	enum ib_wc_status	wc_status;	/* CQE status */
	struct smc_link		*link;
	u32			idx;
	struct smc_wr_tx_pend_priv priv;
};

/******************************** send queue *********************************/

/*------------------------------- completion --------------------------------*/

static inline int smc_wr_tx_find_pending_index(struct smc_link *link, u64 wr_id)
{
	u32 i;

	for (i = 0; i < link->wr_tx_cnt; i++) {
		if (link->wr_tx_pends[i].wr_id == wr_id)
			return i;
	}
	return link->wr_tx_cnt;
}

static inline void smc_wr_tx_process_cqe(struct ib_wc *wc)
{
	struct smc_wr_tx_pend pnd_snd;
	struct smc_link *link;
	u32 pnd_snd_idx;
	int i;

	link = wc->qp->qp_context;

	if (wc->opcode == IB_WC_REG_MR) {
		if (wc->status)
			link->wr_reg_state = FAILED;
		else
			link->wr_reg_state = CONFIRMED;
		wake_up(&link->wr_reg_wait);
		return;
	}

	pnd_snd_idx = smc_wr_tx_find_pending_index(link, wc->wr_id);
	if (pnd_snd_idx == link->wr_tx_cnt)
		return;
	link->wr_tx_pends[pnd_snd_idx].wc_status = wc->status;
	memcpy(&pnd_snd, &link->wr_tx_pends[pnd_snd_idx], sizeof(pnd_snd));
	/* clear the full struct smc_wr_tx_pend including .priv */
	memset(&link->wr_tx_pends[pnd_snd_idx], 0,
	       sizeof(link->wr_tx_pends[pnd_snd_idx]));
	memset(&link->wr_tx_bufs[pnd_snd_idx], 0,
	       sizeof(link->wr_tx_bufs[pnd_snd_idx]));
	if (!test_and_clear_bit(pnd_snd_idx, link->wr_tx_mask))
		return;
	if (wc->status) {
		struct smc_link_group *lgr;

		for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
			/* clear full struct smc_wr_tx_pend including .priv */
			memset(&link->wr_tx_pends[i], 0,
			       sizeof(link->wr_tx_pends[i]));
			memset(&link->wr_tx_bufs[i], 0,
			       sizeof(link->wr_tx_bufs[i]));
			clear_bit(i, link->wr_tx_mask);
		}
		/* terminate connections of this link group abnormally */
		lgr = container_of(link, struct smc_link_group,
				   lnk[SMC_SINGLE_LINK]);
		smc_lgr_terminate(lgr);
	}
	if (pnd_snd.handler)
		pnd_snd.handler(&pnd_snd.priv, link, wc->status);
	wake_up(&link->wr_tx_wait);
}

static void smc_wr_tx_tasklet_fn(unsigned long data)
{
	struct smc_ib_device *dev = (struct smc_ib_device *)data;
	struct ib_wc wc[SMC_WR_MAX_POLL_CQE];
	int i = 0, rc;
	int polled = 0;

again:
	polled++;
	do {
		rc = ib_poll_cq(dev->roce_cq_send, SMC_WR_MAX_POLL_CQE, wc);
		if (polled == 1) {
			ib_req_notify_cq(dev->roce_cq_send,
					 IB_CQ_NEXT_COMP |
					 IB_CQ_REPORT_MISSED_EVENTS);
		}
		if (!rc)
			break;
		for (i = 0; i < rc; i++)
			smc_wr_tx_process_cqe(&wc[i]);
	} while (rc > 0);
	if (polled == 1)
		goto again;
}

void smc_wr_tx_cq_handler(struct ib_cq *ib_cq, void *cq_context)
{
	struct smc_ib_device *dev = (struct smc_ib_device *)cq_context;

	tasklet_schedule(&dev->send_tasklet);
}

/*---------------------------- request submission ---------------------------*/

static inline int smc_wr_tx_get_free_slot_index(struct smc_link *link, u32 *idx)
{
	*idx = link->wr_tx_cnt;
	for_each_clear_bit(*idx, link->wr_tx_mask, link->wr_tx_cnt) {
		if (!test_and_set_bit(*idx, link->wr_tx_mask))
			return 0;
	}
	*idx = link->wr_tx_cnt;
	return -EBUSY;
}

/**
 * smc_wr_tx_get_free_slot() - returns buffer for message assembly,
 *			and sets info for pending transmit tracking
 * @link:		Pointer to smc_link used to later send the message.
 * @handler:		Send completion handler function pointer.
 * @wr_buf:		Out value returns pointer to message buffer.
 * @wr_pend_priv:	Out value returns pointer serving as handler context.
 *
 * Return: 0 on success, or -errno on error.
 */
int smc_wr_tx_get_free_slot(struct smc_link *link,
			    smc_wr_tx_handler handler,
			    struct smc_wr_buf **wr_buf,
			    struct smc_wr_tx_pend_priv **wr_pend_priv)
{
	struct smc_wr_tx_pend *wr_pend;
	struct ib_send_wr *wr_ib;
	u64 wr_id;
	u32 idx;
	int rc;

	*wr_buf = NULL;
	*wr_pend_priv = NULL;
	if (in_softirq()) {
		rc = smc_wr_tx_get_free_slot_index(link, &idx);
		if (rc)
			return rc;
	} else {
		rc = wait_event_interruptible_timeout(
			link->wr_tx_wait,
			(smc_wr_tx_get_free_slot_index(link, &idx) != -EBUSY),
			SMC_WR_TX_WAIT_FREE_SLOT_TIME);
		if (!rc) {
			/* timeout - terminate connections */
			struct smc_link_group *lgr;

			lgr = container_of(link, struct smc_link_group,
					   lnk[SMC_SINGLE_LINK]);
			smc_lgr_terminate(lgr);
			return -EPIPE;
		}
		if (rc == -ERESTARTSYS)
			return -EINTR;
		if (idx == link->wr_tx_cnt)
			return -EPIPE;
	}
	wr_id = smc_wr_tx_get_next_wr_id(link);
	wr_pend = &link->wr_tx_pends[idx];
	wr_pend->wr_id = wr_id;
	wr_pend->handler = handler;
	wr_pend->link = link;
	wr_pend->idx = idx;
	wr_ib = &link->wr_tx_ibs[idx];
	wr_ib->wr_id = wr_id;
	*wr_buf = &link->wr_tx_bufs[idx];
	*wr_pend_priv = &wr_pend->priv;
	return 0;
}

int smc_wr_tx_put_slot(struct smc_link *link,
		       struct smc_wr_tx_pend_priv *wr_pend_priv)
{
	struct smc_wr_tx_pend *pend;

	pend = container_of(wr_pend_priv, struct smc_wr_tx_pend, priv);
	if (pend->idx < link->wr_tx_cnt) {
		/* clear the full struct smc_wr_tx_pend including .priv */
		memset(&link->wr_tx_pends[pend->idx], 0,
		       sizeof(link->wr_tx_pends[pend->idx]));
		memset(&link->wr_tx_bufs[pend->idx], 0,
		       sizeof(link->wr_tx_bufs[pend->idx]));
		test_and_clear_bit(pend->idx, link->wr_tx_mask);
		return 1;
	}

	return 0;
}

/* Send prepared WR slot via ib_post_send.
 * @priv: pointer to smc_wr_tx_pend_priv identifying prepared message buffer
 */
int smc_wr_tx_send(struct smc_link *link, struct smc_wr_tx_pend_priv *priv)
{
	struct ib_send_wr *failed_wr = NULL;
	struct smc_wr_tx_pend *pend;
	int rc;

	ib_req_notify_cq(link->smcibdev->roce_cq_send,
			 IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS);
	pend = container_of(priv, struct smc_wr_tx_pend, priv);
	rc = ib_post_send(link->roce_qp, &link->wr_tx_ibs[pend->idx],
			  &failed_wr);
	if (rc)
		smc_wr_tx_put_slot(link, priv);
	return rc;
}

/* Register a memory region and wait for result. */
int smc_wr_reg_send(struct smc_link *link, struct ib_mr *mr)
{
	struct ib_send_wr *failed_wr = NULL;
	int rc;

	ib_req_notify_cq(link->smcibdev->roce_cq_send,
			 IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS);
	link->wr_reg_state = POSTED;
	link->wr_reg.wr.wr_id = (u64)(uintptr_t)mr;
	link->wr_reg.mr = mr;
	link->wr_reg.key = mr->rkey;
	failed_wr = &link->wr_reg.wr;
	rc = ib_post_send(link->roce_qp, &link->wr_reg.wr, &failed_wr);
	WARN_ON(failed_wr != &link->wr_reg.wr);
	if (rc)
		return rc;

	rc = wait_event_interruptible_timeout(link->wr_reg_wait,
					      (link->wr_reg_state != POSTED),
					      SMC_WR_REG_MR_WAIT_TIME);
	if (!rc) {
		/* timeout - terminate connections */
		struct smc_link_group *lgr;

		lgr = container_of(link, struct smc_link_group,
				   lnk[SMC_SINGLE_LINK]);
		smc_lgr_terminate(lgr);
		return -EPIPE;
	}
	if (rc == -ERESTARTSYS)
		return -EINTR;
	switch (link->wr_reg_state) {
	case CONFIRMED:
		rc = 0;
		break;
	case FAILED:
		rc = -EIO;
		break;
	case POSTED:
		rc = -EPIPE;
		break;
	}
	return rc;
}

void smc_wr_tx_dismiss_slots(struct smc_link *link, u8 wr_rx_hdr_type,
			     smc_wr_tx_filter filter,
			     smc_wr_tx_dismisser dismisser,
			     unsigned long data)
{
	struct smc_wr_tx_pend_priv *tx_pend;
	struct smc_wr_rx_hdr *wr_rx;
	int i;

	for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
		wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i];
		if (wr_rx->type != wr_rx_hdr_type)
			continue;
		tx_pend = &link->wr_tx_pends[i].priv;
		if (filter(tx_pend, data))
			dismisser(tx_pend);
	}
}

bool smc_wr_tx_has_pending(struct smc_link *link, u8 wr_rx_hdr_type,
			   smc_wr_tx_filter filter, unsigned long data)
{
	struct smc_wr_tx_pend_priv *tx_pend;
	struct smc_wr_rx_hdr *wr_rx;
	int i;

	for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
		wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i];
		if (wr_rx->type != wr_rx_hdr_type)
			continue;
		tx_pend = &link->wr_tx_pends[i].priv;
		if (filter(tx_pend, data))
			return true;
	}
	return false;
}

/****************************** receive queue ********************************/

int smc_wr_rx_register_handler(struct smc_wr_rx_handler *handler)
{
	struct smc_wr_rx_handler *h_iter;
	int rc = 0;

	spin_lock(&smc_wr_rx_hash_lock);
	hash_for_each_possible(smc_wr_rx_hash, h_iter, list, handler->type) {
		if (h_iter->type == handler->type) {
			rc = -EEXIST;
			goto out_unlock;
		}
	}
	hash_add(smc_wr_rx_hash, &handler->list, handler->type);
out_unlock:
	spin_unlock(&smc_wr_rx_hash_lock);
	return rc;
}

/* Demultiplex a received work request based on the message type to its handler.
 * Relies on smc_wr_rx_hash having been completely filled before any IB WRs,
 * and not being modified any more afterwards so we don't need to lock it.
 */
static inline void smc_wr_rx_demultiplex(struct ib_wc *wc)
{
	struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
	struct smc_wr_rx_handler *handler;
	struct smc_wr_rx_hdr *wr_rx;
	u64 temp_wr_id;
	u32 index;

	if (wc->byte_len < sizeof(*wr_rx))
		return; /* short message */
	temp_wr_id = wc->wr_id;
	index = do_div(temp_wr_id, link->wr_rx_cnt);
	wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[index];
	hash_for_each_possible(smc_wr_rx_hash, handler, list, wr_rx->type) {
		if (handler->type == wr_rx->type)
			handler->handler(wc, wr_rx);
	}
}

static inline void smc_wr_rx_process_cqes(struct ib_wc wc[], int num)
{
	struct smc_link *link;
	int i;

	for (i = 0; i < num; i++) {
		link = wc[i].qp->qp_context;
		if (wc[i].status == IB_WC_SUCCESS) {
			smc_wr_rx_demultiplex(&wc[i]);
			smc_wr_rx_post(link); /* refill WR RX */
		} else {
			struct smc_link_group *lgr;

			/* handle status errors */
			switch (wc[i].status) {
			case IB_WC_RETRY_EXC_ERR:
			case IB_WC_RNR_RETRY_EXC_ERR:
			case IB_WC_WR_FLUSH_ERR:
				/* terminate connections of this link group
				 * abnormally
				 */
				lgr = container_of(link, struct smc_link_group,
						   lnk[SMC_SINGLE_LINK]);
				smc_lgr_terminate(lgr);
				break;
			default:
				smc_wr_rx_post(link); /* refill WR RX */
				break;
			}
		}
	}
}

static void smc_wr_rx_tasklet_fn(unsigned long data)
{
	struct smc_ib_device *dev = (struct smc_ib_device *)data;
	struct ib_wc wc[SMC_WR_MAX_POLL_CQE];
	int polled = 0;
	int rc;

again:
	polled++;
	do {
		memset(&wc, 0, sizeof(wc));
		rc = ib_poll_cq(dev->roce_cq_recv, SMC_WR_MAX_POLL_CQE, wc);
		if (polled == 1) {
			ib_req_notify_cq(dev->roce_cq_recv,
					 IB_CQ_SOLICITED_MASK
					 | IB_CQ_REPORT_MISSED_EVENTS);
		}
		if (!rc)
			break;
		smc_wr_rx_process_cqes(&wc[0], rc);
	} while (rc > 0);
	if (polled == 1)
		goto again;
}

void smc_wr_rx_cq_handler(struct ib_cq *ib_cq, void *cq_context)
{
	struct smc_ib_device *dev = (struct smc_ib_device *)cq_context;

	tasklet_schedule(&dev->recv_tasklet);
}

int smc_wr_rx_post_init(struct smc_link *link)
{
	u32 i;
	int rc = 0;

	for (i = 0; i < link->wr_rx_cnt; i++)
		rc = smc_wr_rx_post(link);
	return rc;
}

/***************************** init, exit, misc ******************************/

void smc_wr_remember_qp_attr(struct smc_link *lnk)
{
	struct ib_qp_attr *attr = &lnk->qp_attr;
	struct ib_qp_init_attr init_attr;

	memset(attr, 0, sizeof(*attr));
	memset(&init_attr, 0, sizeof(init_attr));
	ib_query_qp(lnk->roce_qp, attr,
		    IB_QP_STATE |
		    IB_QP_CUR_STATE |
		    IB_QP_PKEY_INDEX |
		    IB_QP_PORT |
		    IB_QP_QKEY |
		    IB_QP_AV |
		    IB_QP_PATH_MTU |
		    IB_QP_TIMEOUT |
		    IB_QP_RETRY_CNT |
		    IB_QP_RNR_RETRY |
		    IB_QP_RQ_PSN |
		    IB_QP_ALT_PATH |
		    IB_QP_MIN_RNR_TIMER |
		    IB_QP_SQ_PSN |
		    IB_QP_PATH_MIG_STATE |
		    IB_QP_CAP |
		    IB_QP_DEST_QPN,
		    &init_attr);

	lnk->wr_tx_cnt = min_t(size_t, SMC_WR_BUF_CNT,
			       lnk->qp_attr.cap.max_send_wr);
	lnk->wr_rx_cnt = min_t(size_t, SMC_WR_BUF_CNT * 3,
			       lnk->qp_attr.cap.max_recv_wr);
}

static void smc_wr_init_sge(struct smc_link *lnk)
{
	u32 i;

	for (i = 0; i < lnk->wr_tx_cnt; i++) {
		lnk->wr_tx_sges[i].addr =
			lnk->wr_tx_dma_addr + i * SMC_WR_BUF_SIZE;
		lnk->wr_tx_sges[i].length = SMC_WR_TX_SIZE;
		lnk->wr_tx_sges[i].lkey = lnk->roce_pd->local_dma_lkey;
		lnk->wr_tx_ibs[i].next = NULL;
		lnk->wr_tx_ibs[i].sg_list = &lnk->wr_tx_sges[i];
		lnk->wr_tx_ibs[i].num_sge = 1;
		lnk->wr_tx_ibs[i].opcode = IB_WR_SEND;
		lnk->wr_tx_ibs[i].send_flags =
			IB_SEND_SIGNALED | IB_SEND_SOLICITED;
	}
	for (i = 0; i < lnk->wr_rx_cnt; i++) {
		lnk->wr_rx_sges[i].addr =
			lnk->wr_rx_dma_addr + i * SMC_WR_BUF_SIZE;
		lnk->wr_rx_sges[i].length = SMC_WR_BUF_SIZE;
		lnk->wr_rx_sges[i].lkey = lnk->roce_pd->local_dma_lkey;
		lnk->wr_rx_ibs[i].next = NULL;
		lnk->wr_rx_ibs[i].sg_list = &lnk->wr_rx_sges[i];
		lnk->wr_rx_ibs[i].num_sge = 1;
	}
	lnk->wr_reg.wr.next = NULL;
	lnk->wr_reg.wr.num_sge = 0;
	lnk->wr_reg.wr.send_flags = IB_SEND_SIGNALED;
	lnk->wr_reg.wr.opcode = IB_WR_REG_MR;
	lnk->wr_reg.access = IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_WRITE;
}

void smc_wr_free_link(struct smc_link *lnk)
{
	struct ib_device *ibdev;

	memset(lnk->wr_tx_mask, 0,
	       BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*lnk->wr_tx_mask));

	if (!lnk->smcibdev)
		return;
	ibdev = lnk->smcibdev->ibdev;

	if (lnk->wr_rx_dma_addr) {
		ib_dma_unmap_single(ibdev, lnk->wr_rx_dma_addr,
				    SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
				    DMA_FROM_DEVICE);
		lnk->wr_rx_dma_addr = 0;
	}
	if (lnk->wr_tx_dma_addr) {
		ib_dma_unmap_single(ibdev, lnk->wr_tx_dma_addr,
				    SMC_WR_BUF_SIZE * lnk->wr_tx_cnt,
				    DMA_TO_DEVICE);
		lnk->wr_tx_dma_addr = 0;
	}
}

void smc_wr_free_link_mem(struct smc_link *lnk)
{
	kfree(lnk->wr_tx_pends);
	lnk->wr_tx_pends = NULL;
	kfree(lnk->wr_tx_mask);
	lnk->wr_tx_mask = NULL;
	kfree(lnk->wr_tx_sges);
	lnk->wr_tx_sges = NULL;
	kfree(lnk->wr_rx_sges);
	lnk->wr_rx_sges = NULL;
	kfree(lnk->wr_rx_ibs);
	lnk->wr_rx_ibs = NULL;
	kfree(lnk->wr_tx_ibs);
	lnk->wr_tx_ibs = NULL;
	kfree(lnk->wr_tx_bufs);
	lnk->wr_tx_bufs = NULL;
	kfree(lnk->wr_rx_bufs);
	lnk->wr_rx_bufs = NULL;
}

int smc_wr_alloc_link_mem(struct smc_link *link)
{
	/* allocate link related memory */
	link->wr_tx_bufs = kcalloc(SMC_WR_BUF_CNT, SMC_WR_BUF_SIZE, GFP_KERNEL);
	if (!link->wr_tx_bufs)
		goto no_mem;
	link->wr_rx_bufs = kcalloc(SMC_WR_BUF_CNT * 3, SMC_WR_BUF_SIZE,
				   GFP_KERNEL);
	if (!link->wr_rx_bufs)
		goto no_mem_wr_tx_bufs;
	link->wr_tx_ibs = kcalloc(SMC_WR_BUF_CNT, sizeof(link->wr_tx_ibs[0]),
				  GFP_KERNEL);
	if (!link->wr_tx_ibs)
		goto no_mem_wr_rx_bufs;
	link->wr_rx_ibs = kcalloc(SMC_WR_BUF_CNT * 3,
				  sizeof(link->wr_rx_ibs[0]),
				  GFP_KERNEL);
	if (!link->wr_rx_ibs)
		goto no_mem_wr_tx_ibs;
	link->wr_tx_sges = kcalloc(SMC_WR_BUF_CNT, sizeof(link->wr_tx_sges[0]),
				   GFP_KERNEL);
	if (!link->wr_tx_sges)
		goto no_mem_wr_rx_ibs;
	link->wr_rx_sges = kcalloc(SMC_WR_BUF_CNT * 3,
				   sizeof(link->wr_rx_sges[0]),
				   GFP_KERNEL);
	if (!link->wr_rx_sges)
		goto no_mem_wr_tx_sges;
	link->wr_tx_mask = kzalloc(
		BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*link->wr_tx_mask),
		GFP_KERNEL);
	if (!link->wr_tx_mask)
		goto no_mem_wr_rx_sges;
	link->wr_tx_pends = kcalloc(SMC_WR_BUF_CNT,
				    sizeof(link->wr_tx_pends[0]),
				    GFP_KERNEL);
	if (!link->wr_tx_pends)
		goto no_mem_wr_tx_mask;
	return 0;

no_mem_wr_tx_mask:
	kfree(link->wr_tx_mask);
no_mem_wr_rx_sges:
	kfree(link->wr_rx_sges);
no_mem_wr_tx_sges:
	kfree(link->wr_tx_sges);
no_mem_wr_rx_ibs:
	kfree(link->wr_rx_ibs);
no_mem_wr_tx_ibs:
	kfree(link->wr_tx_ibs);
no_mem_wr_rx_bufs:
	kfree(link->wr_rx_bufs);
no_mem_wr_tx_bufs:
	kfree(link->wr_tx_bufs);
no_mem:
	return -ENOMEM;
}

void smc_wr_remove_dev(struct smc_ib_device *smcibdev)
{
	tasklet_kill(&smcibdev->recv_tasklet);
	tasklet_kill(&smcibdev->send_tasklet);
}

void smc_wr_add_dev(struct smc_ib_device *smcibdev)
{
	tasklet_init(&smcibdev->recv_tasklet, smc_wr_rx_tasklet_fn,
		     (unsigned long)smcibdev);
	tasklet_init(&smcibdev->send_tasklet, smc_wr_tx_tasklet_fn,
		     (unsigned long)smcibdev);
}

int smc_wr_create_link(struct smc_link *lnk)
{
	struct ib_device *ibdev = lnk->smcibdev->ibdev;
	int rc = 0;

	smc_wr_tx_set_wr_id(&lnk->wr_tx_id, 0);
	lnk->wr_rx_id = 0;
	lnk->wr_rx_dma_addr = ib_dma_map_single(
		ibdev, lnk->wr_rx_bufs,	SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
		DMA_FROM_DEVICE);
	if (ib_dma_mapping_error(ibdev, lnk->wr_rx_dma_addr)) {
		lnk->wr_rx_dma_addr = 0;
		rc = -EIO;
		goto out;
	}
	lnk->wr_tx_dma_addr = ib_dma_map_single(
		ibdev, lnk->wr_tx_bufs,	SMC_WR_BUF_SIZE * lnk->wr_tx_cnt,
		DMA_TO_DEVICE);
	if (ib_dma_mapping_error(ibdev, lnk->wr_tx_dma_addr)) {
		rc = -EIO;
		goto dma_unmap;
	}
	smc_wr_init_sge(lnk);
	memset(lnk->wr_tx_mask, 0,
	       BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*lnk->wr_tx_mask));
	init_waitqueue_head(&lnk->wr_tx_wait);
	init_waitqueue_head(&lnk->wr_reg_wait);
	return rc;

dma_unmap:
	ib_dma_unmap_single(ibdev, lnk->wr_rx_dma_addr,
			    SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
			    DMA_FROM_DEVICE);
	lnk->wr_rx_dma_addr = 0;
out:
	return rc;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
f38ba179 UB	2	/*
	3	* Shared Memory Communications over RDMA (SMC-R) and RoCE
	4	*
	5	* Work Requests exploiting Infiniband API
	6	*
	7	* Work requests (WR) of type ib_post_send or ib_post_recv respectively
	8	* are submitted to either RC SQ or RC RQ respectively
	9	* (reliably connected send/receive queue)
	10	* and become work queue entries (WQEs).
	11	* While an SQ WR/WQE is pending, we track it until transmission completion.
	12	* Through a send or receive completion queue (CQ) respectively,
	13	* we get completion queue entries (CQEs) [aka work completions (WCs)].
	14	* Since the CQ callback is called from IRQ context, we split work by using
	15	* bottom halves implemented by tasklets.
	16	*
	17	* SMC uses this to exchange LLC (link layer control)
	18	* and CDC (connection data control) messages.
	19	*
	20	* Copyright IBM Corp. 2016
	21	*
	22	* Author(s): Steffen Maier <maier@linux.vnet.ibm.com>
	23	*/
	24
	25	#include <linux/atomic.h>
	26	#include <linux/hashtable.h>
	27	#include <linux/wait.h>
	28	#include <rdma/ib_verbs.h>
	29	#include <asm/div64.h>
	30
	31	#include "smc.h"
	32	#include "smc_wr.h"
	33
	34	#define SMC_WR_MAX_POLL_CQE 10 /* max. # of compl. queue elements in 1 poll */
	35
	36	#define SMC_WR_RX_HASH_BITS 4
	37	static DEFINE_HASHTABLE(smc_wr_rx_hash, SMC_WR_RX_HASH_BITS);
	38	static DEFINE_SPINLOCK(smc_wr_rx_hash_lock);
	39
	40	struct smc_wr_tx_pend { /* control data for a pending send request */
	41	u64 wr_id; /* work request id sent */
	42	smc_wr_tx_handler handler;
	43	enum ib_wc_status wc_status; /* CQE status */
	44	struct smc_link *link;
	45	u32 idx;
	46	struct smc_wr_tx_pend_priv priv;
	47	};
	48
	49	/****************************** send queue *******************************/
	50
	51	/------------------------------- completion --------------------------------/
	52
	53	static inline int smc_wr_tx_find_pending_index(struct smc_link *link, u64 wr_id)
	54	{
	55	u32 i;
	56
	57	for (i = 0; i < link->wr_tx_cnt; i++) {
	58	if (link->wr_tx_pends[i].wr_id == wr_id)
	59	return i;
	60	}
	61	return link->wr_tx_cnt;
	62	}
	63
	64	static inline void smc_wr_tx_process_cqe(struct ib_wc *wc)
	65	{
66	struct smc_wr_tx_pend pnd_snd;
67	struct smc_link *link;
68	u32 pnd_snd_idx;
69	int i;
70
71	link = wc->qp->qp_context;
652a1e41 UB	72
	73	if (wc->opcode == IB_WC_REG_MR) {
	74	if (wc->status)
	75	link->wr_reg_state = FAILED;
	76	else
	77	link->wr_reg_state = CONFIRMED;
	78	wake_up(&link->wr_reg_wait);
	79	return;
	80	}
	81
f38ba179 UB	82	pnd_snd_idx = smc_wr_tx_find_pending_index(link, wc->wr_id);
	83	if (pnd_snd_idx == link->wr_tx_cnt)
	84	return;
	85	link->wr_tx_pends[pnd_snd_idx].wc_status = wc->status;
	86	memcpy(&pnd_snd, &link->wr_tx_pends[pnd_snd_idx], sizeof(pnd_snd));
	87	/* clear the full struct smc_wr_tx_pend including .priv */
	88	memset(&link->wr_tx_pends[pnd_snd_idx], 0,
	89	sizeof(link->wr_tx_pends[pnd_snd_idx]));
	90	memset(&link->wr_tx_bufs[pnd_snd_idx], 0,
	91	sizeof(link->wr_tx_bufs[pnd_snd_idx]));
	92	if (!test_and_clear_bit(pnd_snd_idx, link->wr_tx_mask))
	93	return;
	94	if (wc->status) {
b38d7324 UB	95	struct smc_link_group *lgr;
b38d7324 UB	96
f38ba179 UB	97	for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
	98	/* clear full struct smc_wr_tx_pend including .priv */
	99	memset(&link->wr_tx_pends[i], 0,
	100	sizeof(link->wr_tx_pends[i]));
	101	memset(&link->wr_tx_bufs[i], 0,
	102	sizeof(link->wr_tx_bufs[i]));
	103	clear_bit(i, link->wr_tx_mask);
	104	}
b38d7324 UB	105	/* terminate connections of this link group abnormally */
	106	lgr = container_of(link, struct smc_link_group,
	107	lnk[SMC_SINGLE_LINK]);
	108	smc_lgr_terminate(lgr);
f38ba179 UB	109	}
	110	if (pnd_snd.handler)
	111	pnd_snd.handler(&pnd_snd.priv, link, wc->status);
	112	wake_up(&link->wr_tx_wait);
	113	}
	114
	115	static void smc_wr_tx_tasklet_fn(unsigned long data)
	116	{
	117	struct smc_ib_device dev = (struct smc_ib_device )data;
	118	struct ib_wc wc[SMC_WR_MAX_POLL_CQE];
	119	int i = 0, rc;
	120	int polled = 0;
	121
	122	again:
	123	polled++;
	124	do {
	125	rc = ib_poll_cq(dev->roce_cq_send, SMC_WR_MAX_POLL_CQE, wc);
	126	if (polled == 1) {
	127	ib_req_notify_cq(dev->roce_cq_send,
	128	IB_CQ_NEXT_COMP \|
	129	IB_CQ_REPORT_MISSED_EVENTS);
	130	}
	131	if (!rc)
	132	break;
	133	for (i = 0; i < rc; i++)
	134	smc_wr_tx_process_cqe(&wc[i]);
	135	} while (rc > 0);
	136	if (polled == 1)
	137	goto again;
	138	}
	139
	140	void smc_wr_tx_cq_handler(struct ib_cq ib_cq, void cq_context)
	141	{
	142	struct smc_ib_device dev = (struct smc_ib_device )cq_context;
	143
	144	tasklet_schedule(&dev->send_tasklet);
	145	}
	146
	147	/---------------------------- request submission ---------------------------/
	148
	149	static inline int smc_wr_tx_get_free_slot_index(struct smc_link link, u32 idx)
	150	{
	151	*idx = link->wr_tx_cnt;
	152	for_each_clear_bit(*idx, link->wr_tx_mask, link->wr_tx_cnt) {
	153	if (!test_and_set_bit(*idx, link->wr_tx_mask))
	154	return 0;
	155	}
	156	*idx = link->wr_tx_cnt;
	157	return -EBUSY;
	158	}
	159
	160	/**
	161	* smc_wr_tx_get_free_slot() - returns buffer for message assembly,
	162	* and sets info for pending transmit tracking
	163	* @link: Pointer to smc_link used to later send the message.
	164	* @handler: Send completion handler function pointer.
	165	* @wr_buf: Out value returns pointer to message buffer.
	166	* @wr_pend_priv: Out value returns pointer serving as handler context.
	167	*
	168	* Return: 0 on success, or -errno on error.
	169	*/
	170	int smc_wr_tx_get_free_slot(struct smc_link *link,
	171	smc_wr_tx_handler handler,
	172	struct smc_wr_buf **wr_buf,
173	struct smc_wr_tx_pend_priv **wr_pend_priv)
174	{
175	struct smc_wr_tx_pend *wr_pend;
176	struct ib_send_wr *wr_ib;
177	u64 wr_id;
178	u32 idx;
179	int rc;
180
181	*wr_buf = NULL;
182	*wr_pend_priv = NULL;
183	if (in_softirq()) {
184	rc = smc_wr_tx_get_free_slot_index(link, &idx);
185	if (rc)
186	return rc;
187	} else {
188	rc = wait_event_interruptible_timeout(
189	link->wr_tx_wait,
190	(smc_wr_tx_get_free_slot_index(link, &idx) != -EBUSY),
191	SMC_WR_TX_WAIT_FREE_SLOT_TIME);
192	if (!rc) {
b38d7324 UB	193	/* timeout - terminate connections */
	194	struct smc_link_group *lgr;
	195
	196	lgr = container_of(link, struct smc_link_group,
	197	lnk[SMC_SINGLE_LINK]);
	198	smc_lgr_terminate(lgr);
f38ba179 UB	199	return -EPIPE;
	200	}
	201	if (rc == -ERESTARTSYS)
	202	return -EINTR;
	203	if (idx == link->wr_tx_cnt)
	204	return -EPIPE;
	205	}
	206	wr_id = smc_wr_tx_get_next_wr_id(link);
	207	wr_pend = &link->wr_tx_pends[idx];
	208	wr_pend->wr_id = wr_id;
	209	wr_pend->handler = handler;
	210	wr_pend->link = link;
	211	wr_pend->idx = idx;
	212	wr_ib = &link->wr_tx_ibs[idx];
	213	wr_ib->wr_id = wr_id;
	214	*wr_buf = &link->wr_tx_bufs[idx];
	215	*wr_pend_priv = &wr_pend->priv;
	216	return 0;
	217	}
	218
	219	int smc_wr_tx_put_slot(struct smc_link *link,
	220	struct smc_wr_tx_pend_priv *wr_pend_priv)
	221	{
	222	struct smc_wr_tx_pend *pend;
	223
	224	pend = container_of(wr_pend_priv, struct smc_wr_tx_pend, priv);
	225	if (pend->idx < link->wr_tx_cnt) {
	226	/* clear the full struct smc_wr_tx_pend including .priv */
	227	memset(&link->wr_tx_pends[pend->idx], 0,
	228	sizeof(link->wr_tx_pends[pend->idx]));
	229	memset(&link->wr_tx_bufs[pend->idx], 0,
	230	sizeof(link->wr_tx_bufs[pend->idx]));
	231	test_and_clear_bit(pend->idx, link->wr_tx_mask);
	232	return 1;
	233	}
	234
	235	return 0;
	236	}
	237
	238	/* Send prepared WR slot via ib_post_send.
	239	* @priv: pointer to smc_wr_tx_pend_priv identifying prepared message buffer
	240	*/
	241	int smc_wr_tx_send(struct smc_link link, struct smc_wr_tx_pend_priv priv)
	242	{
	243	struct ib_send_wr *failed_wr = NULL;
	244	struct smc_wr_tx_pend *pend;
	245	int rc;
	246
	247	ib_req_notify_cq(link->smcibdev->roce_cq_send,
8301fa44	248	IB_CQ_NEXT_COMP \| IB_CQ_REPORT_MISSED_EVENTS);
f38ba179 UB	249	pend = container_of(priv, struct smc_wr_tx_pend, priv);
	250	rc = ib_post_send(link->roce_qp, &link->wr_tx_ibs[pend->idx],
	251	&failed_wr);
	252	if (rc)
	253	smc_wr_tx_put_slot(link, priv);
	254	return rc;
	255	}
	256
652a1e41 UB	257	/* Register a memory region and wait for result. */
	258	int smc_wr_reg_send(struct smc_link link, struct ib_mr mr)
	259	{
	260	struct ib_send_wr *failed_wr = NULL;
	261	int rc;
	262
	263	ib_req_notify_cq(link->smcibdev->roce_cq_send,
	264	IB_CQ_NEXT_COMP \| IB_CQ_REPORT_MISSED_EVENTS);
	265	link->wr_reg_state = POSTED;
	266	link->wr_reg.wr.wr_id = (u64)(uintptr_t)mr;
	267	link->wr_reg.mr = mr;
	268	link->wr_reg.key = mr->rkey;
	269	failed_wr = &link->wr_reg.wr;
	270	rc = ib_post_send(link->roce_qp, &link->wr_reg.wr, &failed_wr);
	271	WARN_ON(failed_wr != &link->wr_reg.wr);
	272	if (rc)
	273	return rc;
	274
	275	rc = wait_event_interruptible_timeout(link->wr_reg_wait,
	276	(link->wr_reg_state != POSTED),
	277	SMC_WR_REG_MR_WAIT_TIME);
	278	if (!rc) {
	279	/* timeout - terminate connections */
	280	struct smc_link_group *lgr;
	281
	282	lgr = container_of(link, struct smc_link_group,
	283	lnk[SMC_SINGLE_LINK]);
	284	smc_lgr_terminate(lgr);
	285	return -EPIPE;
	286	}
	287	if (rc == -ERESTARTSYS)
	288	return -EINTR;
	289	switch (link->wr_reg_state) {
	290	case CONFIRMED:
	291	rc = 0;
	292	break;
	293	case FAILED:
	294	rc = -EIO;
	295	break;
	296	case POSTED:
	297	rc = -EPIPE;
	298	break;
	299	}
	300	return rc;
	301	}
	302
5f08318f UB	303	void smc_wr_tx_dismiss_slots(struct smc_link *link, u8 wr_rx_hdr_type,
	304	smc_wr_tx_filter filter,
	305	smc_wr_tx_dismisser dismisser,
	306	unsigned long data)
	307	{
	308	struct smc_wr_tx_pend_priv *tx_pend;
	309	struct smc_wr_rx_hdr *wr_rx;
	310	int i;
	311
	312	for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
	313	wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i];
	314	if (wr_rx->type != wr_rx_hdr_type)
	315	continue;
	316	tx_pend = &link->wr_tx_pends[i].priv;
	317	if (filter(tx_pend, data))
	318	dismisser(tx_pend);
	319	}
	320	}
	321
b38d7324 UB	322	bool smc_wr_tx_has_pending(struct smc_link *link, u8 wr_rx_hdr_type,
	323	smc_wr_tx_filter filter, unsigned long data)
	324	{
	325	struct smc_wr_tx_pend_priv *tx_pend;
	326	struct smc_wr_rx_hdr *wr_rx;
	327	int i;
	328
	329	for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) {
	330	wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i];
	331	if (wr_rx->type != wr_rx_hdr_type)
	332	continue;
	333	tx_pend = &link->wr_tx_pends[i].priv;
	334	if (filter(tx_pend, data))
	335	return true;
	336	}
	337	return false;
	338	}
	339
f38ba179 UB	340	/**************************** receive queue ******************************/
	341
	342	int smc_wr_rx_register_handler(struct smc_wr_rx_handler *handler)
	343	{
	344	struct smc_wr_rx_handler *h_iter;
	345	int rc = 0;
	346
	347	spin_lock(&smc_wr_rx_hash_lock);
	348	hash_for_each_possible(smc_wr_rx_hash, h_iter, list, handler->type) {
	349	if (h_iter->type == handler->type) {
	350	rc = -EEXIST;
	351	goto out_unlock;
	352	}
	353	}
	354	hash_add(smc_wr_rx_hash, &handler->list, handler->type);
	355	out_unlock:
	356	spin_unlock(&smc_wr_rx_hash_lock);
	357	return rc;
	358	}
	359
	360	/* Demultiplex a received work request based on the message type to its handler.
	361	* Relies on smc_wr_rx_hash having been completely filled before any IB WRs,
	362	* and not being modified any more afterwards so we don't need to lock it.
	363	*/
	364	static inline void smc_wr_rx_demultiplex(struct ib_wc *wc)
	365	{
	366	struct smc_link link = (struct smc_link )wc->qp->qp_context;
	367	struct smc_wr_rx_handler *handler;
	368	struct smc_wr_rx_hdr *wr_rx;
	369	u64 temp_wr_id;
	370	u32 index;
	371
	372	if (wc->byte_len < sizeof(*wr_rx))
	373	return; /* short message */
	374	temp_wr_id = wc->wr_id;
	375	index = do_div(temp_wr_id, link->wr_rx_cnt);
	376	wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[index];
	377	hash_for_each_possible(smc_wr_rx_hash, handler, list, wr_rx->type) {
	378	if (handler->type == wr_rx->type)
	379	handler->handler(wc, wr_rx);
	380	}
	381	}
	382
	383	static inline void smc_wr_rx_process_cqes(struct ib_wc wc[], int num)
	384	{
	385	struct smc_link *link;
	386	int i;
	387
	388	for (i = 0; i < num; i++) {
	389	link = wc[i].qp->qp_context;
	390	if (wc[i].status == IB_WC_SUCCESS) {
	391	smc_wr_rx_demultiplex(&wc[i]);
	392	smc_wr_rx_post(link); /* refill WR RX */
	393	} else {
b38d7324 UB	394	struct smc_link_group *lgr;
b38d7324 UB	395
f38ba179 UB	396	/* handle status errors */
	397	switch (wc[i].status) {
	398	case IB_WC_RETRY_EXC_ERR:
	399	case IB_WC_RNR_RETRY_EXC_ERR:
	400	case IB_WC_WR_FLUSH_ERR:
b38d7324 UB	401	/* terminate connections of this link group
	402	* abnormally
	403	*/
	404	lgr = container_of(link, struct smc_link_group,
	405	lnk[SMC_SINGLE_LINK]);
	406	smc_lgr_terminate(lgr);
f38ba179 UB	407	break;
	408	default:
	409	smc_wr_rx_post(link); /* refill WR RX */
	410	break;
	411	}
	412	}
	413	}
	414	}
	415
	416	static void smc_wr_rx_tasklet_fn(unsigned long data)
	417	{
	418	struct smc_ib_device dev = (struct smc_ib_device )data;
	419	struct ib_wc wc[SMC_WR_MAX_POLL_CQE];
	420	int polled = 0;
	421	int rc;
	422
	423	again:
	424	polled++;
	425	do {
	426	memset(&wc, 0, sizeof(wc));
	427	rc = ib_poll_cq(dev->roce_cq_recv, SMC_WR_MAX_POLL_CQE, wc);
	428	if (polled == 1) {
	429	ib_req_notify_cq(dev->roce_cq_recv,
	430	IB_CQ_SOLICITED_MASK
	431	\| IB_CQ_REPORT_MISSED_EVENTS);
	432	}
	433	if (!rc)
	434	break;
	435	smc_wr_rx_process_cqes(&wc[0], rc);
	436	} while (rc > 0);
	437	if (polled == 1)
	438	goto again;
	439	}
	440
	441	void smc_wr_rx_cq_handler(struct ib_cq ib_cq, void cq_context)
	442	{
	443	struct smc_ib_device dev = (struct smc_ib_device )cq_context;
	444
	445	tasklet_schedule(&dev->recv_tasklet);
	446	}
	447
	448	int smc_wr_rx_post_init(struct smc_link *link)
	449	{
	450	u32 i;
	451	int rc = 0;
	452
	453	for (i = 0; i < link->wr_rx_cnt; i++)
	454	rc = smc_wr_rx_post(link);
	455	return rc;
	456	}
	457
	458	/*************************** init, exit, misc ****************************/
	459
	460	void smc_wr_remember_qp_attr(struct smc_link *lnk)
	461	{
	462	struct ib_qp_attr *attr = &lnk->qp_attr;
	463	struct ib_qp_init_attr init_attr;
	464
	465	memset(attr, 0, sizeof(*attr));
	466	memset(&init_attr, 0, sizeof(init_attr));
	467	ib_query_qp(lnk->roce_qp, attr,
	468	IB_QP_STATE \|
	469	IB_QP_CUR_STATE \|
	470	IB_QP_PKEY_INDEX \|
471	IB_QP_PORT \|
472	IB_QP_QKEY \|
473	IB_QP_AV \|
474	IB_QP_PATH_MTU \|
475	IB_QP_TIMEOUT \|
476	IB_QP_RETRY_CNT \|
477	IB_QP_RNR_RETRY \|
478	IB_QP_RQ_PSN \|
479	IB_QP_ALT_PATH \|
480	IB_QP_MIN_RNR_TIMER \|
481	IB_QP_SQ_PSN \|
482	IB_QP_PATH_MIG_STATE \|
483	IB_QP_CAP \|
484	IB_QP_DEST_QPN,
485	&init_attr);
486
487	lnk->wr_tx_cnt = min_t(size_t, SMC_WR_BUF_CNT,
488	lnk->qp_attr.cap.max_send_wr);
489	lnk->wr_rx_cnt = min_t(size_t, SMC_WR_BUF_CNT * 3,
490	lnk->qp_attr.cap.max_recv_wr);
491	}
492
493	static void smc_wr_init_sge(struct smc_link *lnk)
494	{
495	u32 i;
496
497	for (i = 0; i < lnk->wr_tx_cnt; i++) {
498	lnk->wr_tx_sges[i].addr =
499	lnk->wr_tx_dma_addr + i * SMC_WR_BUF_SIZE;
500	lnk->wr_tx_sges[i].length = SMC_WR_TX_SIZE;
bd4ad577	501	lnk->wr_tx_sges[i].lkey = lnk->roce_pd->local_dma_lkey;
f38ba179 UB	502	lnk->wr_tx_ibs[i].next = NULL;
	503	lnk->wr_tx_ibs[i].sg_list = &lnk->wr_tx_sges[i];
	504	lnk->wr_tx_ibs[i].num_sge = 1;
	505	lnk->wr_tx_ibs[i].opcode = IB_WR_SEND;
	506	lnk->wr_tx_ibs[i].send_flags =
2c9c1682	507	IB_SEND_SIGNALED \| IB_SEND_SOLICITED;
f38ba179 UB	508	}
	509	for (i = 0; i < lnk->wr_rx_cnt; i++) {
	510	lnk->wr_rx_sges[i].addr =
	511	lnk->wr_rx_dma_addr + i * SMC_WR_BUF_SIZE;
	512	lnk->wr_rx_sges[i].length = SMC_WR_BUF_SIZE;
bd4ad577	513	lnk->wr_rx_sges[i].lkey = lnk->roce_pd->local_dma_lkey;
f38ba179 UB	514	lnk->wr_rx_ibs[i].next = NULL;
	515	lnk->wr_rx_ibs[i].sg_list = &lnk->wr_rx_sges[i];
	516	lnk->wr_rx_ibs[i].num_sge = 1;
	517	}
652a1e41 UB	518	lnk->wr_reg.wr.next = NULL;
	519	lnk->wr_reg.wr.num_sge = 0;
	520	lnk->wr_reg.wr.send_flags = IB_SEND_SIGNALED;
	521	lnk->wr_reg.wr.opcode = IB_WR_REG_MR;
	522	lnk->wr_reg.access = IB_ACCESS_LOCAL_WRITE \| IB_ACCESS_REMOTE_WRITE;
f38ba179 UB	523	}
	524
	525	void smc_wr_free_link(struct smc_link *lnk)
	526	{
	527	struct ib_device *ibdev;
	528
	529	memset(lnk->wr_tx_mask, 0,
	530	BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*lnk->wr_tx_mask));
	531
	532	if (!lnk->smcibdev)
	533	return;
	534	ibdev = lnk->smcibdev->ibdev;
	535
	536	if (lnk->wr_rx_dma_addr) {
	537	ib_dma_unmap_single(ibdev, lnk->wr_rx_dma_addr,
	538	SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
	539	DMA_FROM_DEVICE);
	540	lnk->wr_rx_dma_addr = 0;
	541	}
	542	if (lnk->wr_tx_dma_addr) {
	543	ib_dma_unmap_single(ibdev, lnk->wr_tx_dma_addr,
	544	SMC_WR_BUF_SIZE * lnk->wr_tx_cnt,
	545	DMA_TO_DEVICE);
	546	lnk->wr_tx_dma_addr = 0;
	547	}
	548	}
	549
	550	void smc_wr_free_link_mem(struct smc_link *lnk)
	551	{
	552	kfree(lnk->wr_tx_pends);
	553	lnk->wr_tx_pends = NULL;
	554	kfree(lnk->wr_tx_mask);
	555	lnk->wr_tx_mask = NULL;
	556	kfree(lnk->wr_tx_sges);
	557	lnk->wr_tx_sges = NULL;
	558	kfree(lnk->wr_rx_sges);
	559	lnk->wr_rx_sges = NULL;
	560	kfree(lnk->wr_rx_ibs);
	561	lnk->wr_rx_ibs = NULL;
	562	kfree(lnk->wr_tx_ibs);
	563	lnk->wr_tx_ibs = NULL;
	564	kfree(lnk->wr_tx_bufs);
	565	lnk->wr_tx_bufs = NULL;
	566	kfree(lnk->wr_rx_bufs);
	567	lnk->wr_rx_bufs = NULL;
	568	}
	569
	570	int smc_wr_alloc_link_mem(struct smc_link *link)
	571	{
	572	/* allocate link related memory */
	573	link->wr_tx_bufs = kcalloc(SMC_WR_BUF_CNT, SMC_WR_BUF_SIZE, GFP_KERNEL);
	574	if (!link->wr_tx_bufs)
	575	goto no_mem;
	576	link->wr_rx_bufs = kcalloc(SMC_WR_BUF_CNT * 3, SMC_WR_BUF_SIZE,
	577	GFP_KERNEL);
	578	if (!link->wr_rx_bufs)
	579	goto no_mem_wr_tx_bufs;
	580	link->wr_tx_ibs = kcalloc(SMC_WR_BUF_CNT, sizeof(link->wr_tx_ibs[0]),
	581	GFP_KERNEL);
	582	if (!link->wr_tx_ibs)
	583	goto no_mem_wr_rx_bufs;
	584	link->wr_rx_ibs = kcalloc(SMC_WR_BUF_CNT * 3,
	585	sizeof(link->wr_rx_ibs[0]),
	586	GFP_KERNEL);
587	if (!link->wr_rx_ibs)
588	goto no_mem_wr_tx_ibs;
589	link->wr_tx_sges = kcalloc(SMC_WR_BUF_CNT, sizeof(link->wr_tx_sges[0]),
590	GFP_KERNEL);
591	if (!link->wr_tx_sges)
592	goto no_mem_wr_rx_ibs;
593	link->wr_rx_sges = kcalloc(SMC_WR_BUF_CNT * 3,
594	sizeof(link->wr_rx_sges[0]),
595	GFP_KERNEL);
596	if (!link->wr_rx_sges)
597	goto no_mem_wr_tx_sges;
598	link->wr_tx_mask = kzalloc(
599	BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*link->wr_tx_mask),
600	GFP_KERNEL);
601	if (!link->wr_tx_mask)
602	goto no_mem_wr_rx_sges;
603	link->wr_tx_pends = kcalloc(SMC_WR_BUF_CNT,
604	sizeof(link->wr_tx_pends[0]),
605	GFP_KERNEL);
606	if (!link->wr_tx_pends)
607	goto no_mem_wr_tx_mask;
608	return 0;
609
610	no_mem_wr_tx_mask:
611	kfree(link->wr_tx_mask);
612	no_mem_wr_rx_sges:
613	kfree(link->wr_rx_sges);
614	no_mem_wr_tx_sges:
615	kfree(link->wr_tx_sges);
616	no_mem_wr_rx_ibs:
617	kfree(link->wr_rx_ibs);
618	no_mem_wr_tx_ibs:
619	kfree(link->wr_tx_ibs);
620	no_mem_wr_rx_bufs:
621	kfree(link->wr_rx_bufs);
622	no_mem_wr_tx_bufs:
623	kfree(link->wr_tx_bufs);
624	no_mem:
625	return -ENOMEM;
626	}
627
628	void smc_wr_remove_dev(struct smc_ib_device *smcibdev)
629	{
630	tasklet_kill(&smcibdev->recv_tasklet);
631	tasklet_kill(&smcibdev->send_tasklet);
632	}
633
634	void smc_wr_add_dev(struct smc_ib_device *smcibdev)
635	{
636	tasklet_init(&smcibdev->recv_tasklet, smc_wr_rx_tasklet_fn,
637	(unsigned long)smcibdev);
638	tasklet_init(&smcibdev->send_tasklet, smc_wr_tx_tasklet_fn,
639	(unsigned long)smcibdev);
640	}
641
642	int smc_wr_create_link(struct smc_link *lnk)
643	{
644	struct ib_device *ibdev = lnk->smcibdev->ibdev;
645	int rc = 0;
646
647	smc_wr_tx_set_wr_id(&lnk->wr_tx_id, 0);
648	lnk->wr_rx_id = 0;
649	lnk->wr_rx_dma_addr = ib_dma_map_single(
650	ibdev, lnk->wr_rx_bufs, SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
651	DMA_FROM_DEVICE);
652	if (ib_dma_mapping_error(ibdev, lnk->wr_rx_dma_addr)) {
653	lnk->wr_rx_dma_addr = 0;
654	rc = -EIO;
655	goto out;
656	}
657	lnk->wr_tx_dma_addr = ib_dma_map_single(
658	ibdev, lnk->wr_tx_bufs, SMC_WR_BUF_SIZE * lnk->wr_tx_cnt,
659	DMA_TO_DEVICE);
660	if (ib_dma_mapping_error(ibdev, lnk->wr_tx_dma_addr)) {
661	rc = -EIO;
662	goto dma_unmap;
663	}
664	smc_wr_init_sge(lnk);
665	memset(lnk->wr_tx_mask, 0,
666	BITS_TO_LONGS(SMC_WR_BUF_CNT) * sizeof(*lnk->wr_tx_mask));
652a1e41 UB	667	init_waitqueue_head(&lnk->wr_tx_wait);
652a1e41 UB	668	init_waitqueue_head(&lnk->wr_reg_wait);
f38ba179 UB	669	return rc;
	670
	671	dma_unmap:
	672	ib_dma_unmap_single(ibdev, lnk->wr_rx_dma_addr,
	673	SMC_WR_BUF_SIZE * lnk->wr_rx_cnt,
	674	DMA_FROM_DEVICE);
	675	lnk->wr_rx_dma_addr = 0;
	676	out:
	677	return rc;
	678	}