rdma.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * NVMe over Fabrics RDMA target.
   4 * Copyright (c) 2015-2016 HGST, a Western Digital Company.
   5 */
   6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7#include <linux/atomic.h>
   8#include <linux/blk-integrity.h>
   9#include <linux/ctype.h>
  10#include <linux/delay.h>
  11#include <linux/err.h>
  12#include <linux/init.h>
  13#include <linux/module.h>
  14#include <linux/nvme.h>
  15#include <linux/slab.h>
  16#include <linux/string.h>
  17#include <linux/wait.h>
  18#include <linux/inet.h>
  19#include <linux/unaligned.h>
  20
  21#include <rdma/ib_verbs.h>
  22#include <rdma/rdma_cm.h>
  23#include <rdma/rw.h>
  24#include <rdma/ib_cm.h>
  25
  26#include <linux/nvme-rdma.h>
  27#include "nvmet.h"
  28
  29/*
  30 * We allow at least 1 page, up to 4 SGEs, and up to 16KB of inline data
  31 */
  32#define NVMET_RDMA_DEFAULT_INLINE_DATA_SIZE	PAGE_SIZE
  33#define NVMET_RDMA_MAX_INLINE_SGE		4
  34#define NVMET_RDMA_MAX_INLINE_DATA_SIZE		max_t(int, SZ_16K, PAGE_SIZE)
  35
  36/* Assume mpsmin == device_page_size == 4KB */
  37#define NVMET_RDMA_MAX_MDTS			8
  38#define NVMET_RDMA_MAX_METADATA_MDTS		5
  39
  40#define NVMET_RDMA_BACKLOG 128
  41
  42#define NVMET_RDMA_DISCRETE_RSP_TAG		-1
  43
  44struct nvmet_rdma_srq;
  45
  46struct nvmet_rdma_cmd {
  47	struct ib_sge		sge[NVMET_RDMA_MAX_INLINE_SGE + 1];
  48	struct ib_cqe		cqe;
  49	struct ib_recv_wr	wr;
  50	struct scatterlist	inline_sg[NVMET_RDMA_MAX_INLINE_SGE];
  51	struct nvme_command     *nvme_cmd;
  52	struct nvmet_rdma_queue	*queue;
  53	struct nvmet_rdma_srq   *nsrq;
  54};
  55
  56enum {
  57	NVMET_RDMA_REQ_INLINE_DATA	= (1 << 0),
  58};
  59
  60struct nvmet_rdma_rsp {
  61	struct ib_sge		send_sge;
  62	struct ib_cqe		send_cqe;
  63	struct ib_send_wr	send_wr;
  64
  65	struct nvmet_rdma_cmd	*cmd;
  66	struct nvmet_rdma_queue	*queue;
  67
  68	struct ib_cqe		read_cqe;
  69	struct ib_cqe		write_cqe;
  70	struct rdma_rw_ctx	rw;
  71
  72	struct nvmet_req	req;
  73
  74	bool			allocated;
  75	u8			n_rdma;
  76	u32			flags;
  77	u32			invalidate_rkey;
  78
  79	struct list_head	wait_list;
  80	int			tag;
  81};
  82
  83enum nvmet_rdma_queue_state {
  84	NVMET_RDMA_Q_CONNECTING,
  85	NVMET_RDMA_Q_LIVE,
  86	NVMET_RDMA_Q_DISCONNECTING,
  87};
  88
  89struct nvmet_rdma_queue {
  90	struct rdma_cm_id	*cm_id;
  91	struct ib_qp		*qp;
  92	struct nvmet_port	*port;
  93	struct ib_cq		*cq;
  94	atomic_t		sq_wr_avail;
  95	struct nvmet_rdma_device *dev;
  96	struct nvmet_rdma_srq   *nsrq;
  97	spinlock_t		state_lock;
  98	enum nvmet_rdma_queue_state state;
  99	struct nvmet_cq		nvme_cq;
 100	struct nvmet_sq		nvme_sq;
 101
 102	struct nvmet_rdma_rsp	*rsps;
 103	struct sbitmap		rsp_tags;
 104	struct nvmet_rdma_cmd	*cmds;
 105
 106	struct work_struct	release_work;
 107	struct list_head	rsp_wait_list;
 108	struct list_head	rsp_wr_wait_list;
 109	spinlock_t		rsp_wr_wait_lock;
 110
 111	int			idx;
 112	int			host_qid;
 113	int			comp_vector;
 114	int			recv_queue_size;
 115	int			send_queue_size;
 116
 117	struct list_head	queue_list;
 118};
 119
 120struct nvmet_rdma_port {
 121	struct nvmet_port	*nport;
 122	struct sockaddr_storage addr;
 123	struct rdma_cm_id	*cm_id;
 124	struct delayed_work	repair_work;
 125};
 126
 127struct nvmet_rdma_srq {
 128	struct ib_srq            *srq;
 129	struct nvmet_rdma_cmd    *cmds;
 130	struct nvmet_rdma_device *ndev;
 131};
 132
 133struct nvmet_rdma_device {
 134	struct ib_device	*device;
 135	struct ib_pd		*pd;
 136	struct nvmet_rdma_srq	**srqs;
 137	int			srq_count;
 138	size_t			srq_size;
 139	struct kref		ref;
 140	struct list_head	entry;
 141	int			inline_data_size;
 142	int			inline_page_count;
 143};
 144
 145static bool nvmet_rdma_use_srq;
 146module_param_named(use_srq, nvmet_rdma_use_srq, bool, 0444);
 147MODULE_PARM_DESC(use_srq, "Use shared receive queue.");
 148
 149static int srq_size_set(const char *val, const struct kernel_param *kp);
 150static const struct kernel_param_ops srq_size_ops = {
 151	.set = srq_size_set,
 152	.get = param_get_int,
 153};
 154
 155static int nvmet_rdma_srq_size = 1024;
 156module_param_cb(srq_size, &srq_size_ops, &nvmet_rdma_srq_size, 0644);
 157MODULE_PARM_DESC(srq_size, "set Shared Receive Queue (SRQ) size, should >= 256 (default: 1024)");
 158
 159static DEFINE_IDA(nvmet_rdma_queue_ida);
 160static LIST_HEAD(nvmet_rdma_queue_list);
 161static DEFINE_MUTEX(nvmet_rdma_queue_mutex);
 162
 163static LIST_HEAD(device_list);
 164static DEFINE_MUTEX(device_list_mutex);
 165
 166static bool nvmet_rdma_execute_command(struct nvmet_rdma_rsp *rsp);
 167static void nvmet_rdma_send_done(struct ib_cq *cq, struct ib_wc *wc);
 168static void nvmet_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc);
 169static void nvmet_rdma_read_data_done(struct ib_cq *cq, struct ib_wc *wc);
 170static void nvmet_rdma_write_data_done(struct ib_cq *cq, struct ib_wc *wc);
 171static void nvmet_rdma_qp_event(struct ib_event *event, void *priv);
 172static void nvmet_rdma_queue_disconnect(struct nvmet_rdma_queue *queue);
 173static void nvmet_rdma_free_rsp(struct nvmet_rdma_device *ndev,
 174				struct nvmet_rdma_rsp *r);
 175static int nvmet_rdma_alloc_rsp(struct nvmet_rdma_device *ndev,
 176				struct nvmet_rdma_rsp *r,
 177				int tag);
 178
 179static const struct nvmet_fabrics_ops nvmet_rdma_ops;
 180
 181static int srq_size_set(const char *val, const struct kernel_param *kp)
 182{
 183	int n = 0, ret;
 184
 185	ret = kstrtoint(val, 10, &n);
 186	if (ret != 0 || n < 256)
 187		return -EINVAL;
 188
 189	return param_set_int(val, kp);
 190}
 191
 192static int num_pages(int len)
 193{
 194	return 1 + (((len - 1) & PAGE_MASK) >> PAGE_SHIFT);
 195}
 196
 197static inline bool nvmet_rdma_need_data_in(struct nvmet_rdma_rsp *rsp)
 198{
 199	return nvme_is_write(rsp->req.cmd) &&
 200		rsp->req.transfer_len &&
 201		!(rsp->flags & NVMET_RDMA_REQ_INLINE_DATA);
 202}
 203
 204static inline bool nvmet_rdma_need_data_out(struct nvmet_rdma_rsp *rsp)
 205{
 206	return !nvme_is_write(rsp->req.cmd) &&
 207		rsp->req.transfer_len &&
 208		!rsp->req.cqe->status &&
 209		!(rsp->flags & NVMET_RDMA_REQ_INLINE_DATA);
 210}
 211
 212static inline struct nvmet_rdma_rsp *
 213nvmet_rdma_get_rsp(struct nvmet_rdma_queue *queue)
 214{
 215	struct nvmet_rdma_rsp *rsp = NULL;
 216	int tag;
 217
 218	tag = sbitmap_get(&queue->rsp_tags);
 219	if (tag >= 0)
 220		rsp = &queue->rsps[tag];
 221
 222	if (unlikely(!rsp)) {
 223		int ret;
 224
 225		rsp = kzalloc(sizeof(*rsp), GFP_KERNEL);
 226		if (unlikely(!rsp))
 227			return NULL;
 228		ret = nvmet_rdma_alloc_rsp(queue->dev, rsp,
 229				NVMET_RDMA_DISCRETE_RSP_TAG);
 230		if (unlikely(ret)) {
 231			kfree(rsp);
 232			return NULL;
 233		}
 234	}
 235
 236	return rsp;
 237}
 238
 239static inline void
 240nvmet_rdma_put_rsp(struct nvmet_rdma_rsp *rsp)
 241{
 242	if (unlikely(rsp->tag == NVMET_RDMA_DISCRETE_RSP_TAG)) {
 243		nvmet_rdma_free_rsp(rsp->queue->dev, rsp);
 244		kfree(rsp);
 245		return;
 246	}
 247
 248	sbitmap_clear_bit(&rsp->queue->rsp_tags, rsp->tag);
 249}
 250
 251static void nvmet_rdma_free_inline_pages(struct nvmet_rdma_device *ndev,
 252				struct nvmet_rdma_cmd *c)
 253{
 254	struct scatterlist *sg;
 255	struct ib_sge *sge;
 256	int i;
 257
 258	if (!ndev->inline_data_size)
 259		return;
 260
 261	sg = c->inline_sg;
 262	sge = &c->sge[1];
 263
 264	for (i = 0; i < ndev->inline_page_count; i++, sg++, sge++) {
 265		if (sge->length)
 266			ib_dma_unmap_page(ndev->device, sge->addr,
 267					sge->length, DMA_FROM_DEVICE);
 268		if (sg_page(sg))
 269			__free_page(sg_page(sg));
 270	}
 271}
 272
 273static int nvmet_rdma_alloc_inline_pages(struct nvmet_rdma_device *ndev,
 274				struct nvmet_rdma_cmd *c)
 275{
 276	struct scatterlist *sg;
 277	struct ib_sge *sge;
 278	struct page *pg;
 279	int len;
 280	int i;
 281
 282	if (!ndev->inline_data_size)
 283		return 0;
 284
 285	sg = c->inline_sg;
 286	sg_init_table(sg, ndev->inline_page_count);
 287	sge = &c->sge[1];
 288	len = ndev->inline_data_size;
 289
 290	for (i = 0; i < ndev->inline_page_count; i++, sg++, sge++) {
 291		pg = alloc_page(GFP_KERNEL);
 292		if (!pg)
 293			goto out_err;
 294		sg_assign_page(sg, pg);
 295		sge->addr = ib_dma_map_page(ndev->device,
 296			pg, 0, PAGE_SIZE, DMA_FROM_DEVICE);
 297		if (ib_dma_mapping_error(ndev->device, sge->addr))
 298			goto out_err;
 299		sge->length = min_t(int, len, PAGE_SIZE);
 300		sge->lkey = ndev->pd->local_dma_lkey;
 301		len -= sge->length;
 302	}
 303
 304	return 0;
 305out_err:
 306	for (; i >= 0; i--, sg--, sge--) {
 307		if (sge->length)
 308			ib_dma_unmap_page(ndev->device, sge->addr,
 309					sge->length, DMA_FROM_DEVICE);
 310		if (sg_page(sg))
 311			__free_page(sg_page(sg));
 312	}
 313	return -ENOMEM;
 314}
 315
 316static int nvmet_rdma_alloc_cmd(struct nvmet_rdma_device *ndev,
 317			struct nvmet_rdma_cmd *c, bool admin)
 318{
 319	/* NVMe command / RDMA RECV */
 320	c->nvme_cmd = kmalloc(sizeof(*c->nvme_cmd), GFP_KERNEL);
 321	if (!c->nvme_cmd)
 322		goto out;
 323
 324	c->sge[0].addr = ib_dma_map_single(ndev->device, c->nvme_cmd,
 325			sizeof(*c->nvme_cmd), DMA_FROM_DEVICE);
 326	if (ib_dma_mapping_error(ndev->device, c->sge[0].addr))
 327		goto out_free_cmd;
 328
 329	c->sge[0].length = sizeof(*c->nvme_cmd);
 330	c->sge[0].lkey = ndev->pd->local_dma_lkey;
 331
 332	if (!admin && nvmet_rdma_alloc_inline_pages(ndev, c))
 333		goto out_unmap_cmd;
 334
 335	c->cqe.done = nvmet_rdma_recv_done;
 336
 337	c->wr.wr_cqe = &c->cqe;
 338	c->wr.sg_list = c->sge;
 339	c->wr.num_sge = admin ? 1 : ndev->inline_page_count + 1;
 340
 341	return 0;
 342
 343out_unmap_cmd:
 344	ib_dma_unmap_single(ndev->device, c->sge[0].addr,
 345			sizeof(*c->nvme_cmd), DMA_FROM_DEVICE);
 346out_free_cmd:
 347	kfree(c->nvme_cmd);
 348
 349out:
 350	return -ENOMEM;
 351}
 352
 353static void nvmet_rdma_free_cmd(struct nvmet_rdma_device *ndev,
 354		struct nvmet_rdma_cmd *c, bool admin)
 355{
 356	if (!admin)
 357		nvmet_rdma_free_inline_pages(ndev, c);
 358	ib_dma_unmap_single(ndev->device, c->sge[0].addr,
 359				sizeof(*c->nvme_cmd), DMA_FROM_DEVICE);
 360	kfree(c->nvme_cmd);
 361}
 362
 363static struct nvmet_rdma_cmd *
 364nvmet_rdma_alloc_cmds(struct nvmet_rdma_device *ndev,
 365		int nr_cmds, bool admin)
 366{
 367	struct nvmet_rdma_cmd *cmds;
 368	int ret = -EINVAL, i;
 369
 370	cmds = kvcalloc(nr_cmds, sizeof(struct nvmet_rdma_cmd), GFP_KERNEL);
 371	if (!cmds)
 372		goto out;
 373
 374	for (i = 0; i < nr_cmds; i++) {
 375		ret = nvmet_rdma_alloc_cmd(ndev, cmds + i, admin);
 376		if (ret)
 377			goto out_free;
 378	}
 379
 380	return cmds;
 381
 382out_free:
 383	while (--i >= 0)
 384		nvmet_rdma_free_cmd(ndev, cmds + i, admin);
 385	kvfree(cmds);
 386out:
 387	return ERR_PTR(ret);
 388}
 389
 390static void nvmet_rdma_free_cmds(struct nvmet_rdma_device *ndev,
 391		struct nvmet_rdma_cmd *cmds, int nr_cmds, bool admin)
 392{
 393	int i;
 394
 395	for (i = 0; i < nr_cmds; i++)
 396		nvmet_rdma_free_cmd(ndev, cmds + i, admin);
 397	kvfree(cmds);
 398}
 399
 400static int nvmet_rdma_alloc_rsp(struct nvmet_rdma_device *ndev,
 401		struct nvmet_rdma_rsp *r, int tag)
 402{
 403	/* NVMe CQE / RDMA SEND */
 404	r->req.cqe = kmalloc(sizeof(*r->req.cqe), GFP_KERNEL);
 405	if (!r->req.cqe)
 406		goto out;
 407
 408	r->send_sge.addr = ib_dma_map_single(ndev->device, r->req.cqe,
 409			sizeof(*r->req.cqe), DMA_TO_DEVICE);
 410	if (ib_dma_mapping_error(ndev->device, r->send_sge.addr))
 411		goto out_free_rsp;
 412
 413	if (ib_dma_pci_p2p_dma_supported(ndev->device))
 414		r->req.p2p_client = &ndev->device->dev;
 415	r->send_sge.length = sizeof(*r->req.cqe);
 416	r->send_sge.lkey = ndev->pd->local_dma_lkey;
 417
 418	r->send_cqe.done = nvmet_rdma_send_done;
 419
 420	r->send_wr.wr_cqe = &r->send_cqe;
 421	r->send_wr.sg_list = &r->send_sge;
 422	r->send_wr.num_sge = 1;
 423	r->send_wr.send_flags = IB_SEND_SIGNALED;
 424
 425	/* Data In / RDMA READ */
 426	r->read_cqe.done = nvmet_rdma_read_data_done;
 427	/* Data Out / RDMA WRITE */
 428	r->write_cqe.done = nvmet_rdma_write_data_done;
 429	r->tag = tag;
 430
 431	return 0;
 432
 433out_free_rsp:
 434	kfree(r->req.cqe);
 435out:
 436	return -ENOMEM;
 437}
 438
 439static void nvmet_rdma_free_rsp(struct nvmet_rdma_device *ndev,
 440		struct nvmet_rdma_rsp *r)
 441{
 442	ib_dma_unmap_single(ndev->device, r->send_sge.addr,
 443				sizeof(*r->req.cqe), DMA_TO_DEVICE);
 444	kfree(r->req.cqe);
 445}
 446
 447static int
 448nvmet_rdma_alloc_rsps(struct nvmet_rdma_queue *queue)
 449{
 450	struct nvmet_rdma_device *ndev = queue->dev;
 451	int nr_rsps = queue->recv_queue_size * 2;
 452	int ret = -ENOMEM, i;
 453
 454	if (sbitmap_init_node(&queue->rsp_tags, nr_rsps, -1, GFP_KERNEL,
 455			NUMA_NO_NODE, false, true))
 456		goto out;
 457
 458	queue->rsps = kvcalloc(nr_rsps, sizeof(struct nvmet_rdma_rsp),
 459			GFP_KERNEL);
 460	if (!queue->rsps)
 461		goto out_free_sbitmap;
 462
 463	for (i = 0; i < nr_rsps; i++) {
 464		struct nvmet_rdma_rsp *rsp = &queue->rsps[i];
 465
 466		ret = nvmet_rdma_alloc_rsp(ndev, rsp, i);
 467		if (ret)
 468			goto out_free;
 469	}
 470
 471	return 0;
 472
 473out_free:
 474	while (--i >= 0)
 475		nvmet_rdma_free_rsp(ndev, &queue->rsps[i]);
 476	kvfree(queue->rsps);
 477out_free_sbitmap:
 478	sbitmap_free(&queue->rsp_tags);
 479out:
 480	return ret;
 481}
 482
 483static void nvmet_rdma_free_rsps(struct nvmet_rdma_queue *queue)
 484{
 485	struct nvmet_rdma_device *ndev = queue->dev;
 486	int i, nr_rsps = queue->recv_queue_size * 2;
 487
 488	for (i = 0; i < nr_rsps; i++)
 489		nvmet_rdma_free_rsp(ndev, &queue->rsps[i]);
 490	kvfree(queue->rsps);
 491	sbitmap_free(&queue->rsp_tags);
 492}
 493
 494static int nvmet_rdma_post_recv(struct nvmet_rdma_device *ndev,
 495		struct nvmet_rdma_cmd *cmd)
 496{
 497	int ret;
 498
 499	ib_dma_sync_single_for_device(ndev->device,
 500		cmd->sge[0].addr, cmd->sge[0].length,
 501		DMA_FROM_DEVICE);
 502
 503	if (cmd->nsrq)
 504		ret = ib_post_srq_recv(cmd->nsrq->srq, &cmd->wr, NULL);
 505	else
 506		ret = ib_post_recv(cmd->queue->qp, &cmd->wr, NULL);
 507
 508	if (unlikely(ret))
 509		pr_err("post_recv cmd failed\n");
 510
 511	return ret;
 512}
 513
 514static void nvmet_rdma_process_wr_wait_list(struct nvmet_rdma_queue *queue)
 515{
 516	spin_lock(&queue->rsp_wr_wait_lock);
 517	while (!list_empty(&queue->rsp_wr_wait_list)) {
 518		struct nvmet_rdma_rsp *rsp;
 519		bool ret;
 520
 521		rsp = list_entry(queue->rsp_wr_wait_list.next,
 522				struct nvmet_rdma_rsp, wait_list);
 523		list_del(&rsp->wait_list);
 524
 525		spin_unlock(&queue->rsp_wr_wait_lock);
 526		ret = nvmet_rdma_execute_command(rsp);
 527		spin_lock(&queue->rsp_wr_wait_lock);
 528
 529		if (!ret) {
 530			list_add(&rsp->wait_list, &queue->rsp_wr_wait_list);
 531			break;
 532		}
 533	}
 534	spin_unlock(&queue->rsp_wr_wait_lock);
 535}
 536
 537static u16 nvmet_rdma_check_pi_status(struct ib_mr *sig_mr)
 538{
 539	struct ib_mr_status mr_status;
 540	int ret;
 541	u16 status = 0;
 542
 543	ret = ib_check_mr_status(sig_mr, IB_MR_CHECK_SIG_STATUS, &mr_status);
 544	if (ret) {
 545		pr_err("ib_check_mr_status failed, ret %d\n", ret);
 546		return NVME_SC_INVALID_PI;
 547	}
 548
 549	if (mr_status.fail_status & IB_MR_CHECK_SIG_STATUS) {
 550		switch (mr_status.sig_err.err_type) {
 551		case IB_SIG_BAD_GUARD:
 552			status = NVME_SC_GUARD_CHECK;
 553			break;
 554		case IB_SIG_BAD_REFTAG:
 555			status = NVME_SC_REFTAG_CHECK;
 556			break;
 557		case IB_SIG_BAD_APPTAG:
 558			status = NVME_SC_APPTAG_CHECK;
 559			break;
 560		}
 561		pr_err("PI error found type %d expected 0x%x vs actual 0x%x\n",
 562		       mr_status.sig_err.err_type,
 563		       mr_status.sig_err.expected,
 564		       mr_status.sig_err.actual);
 565	}
 566
 567	return status;
 568}
 569
 570static void nvmet_rdma_set_sig_domain(struct blk_integrity *bi,
 571		struct nvme_command *cmd, struct ib_sig_domain *domain,
 572		u16 control, u8 pi_type)
 573{
 574	domain->sig_type = IB_SIG_TYPE_T10_DIF;
 575	domain->sig.dif.bg_type = IB_T10DIF_CRC;
 576	domain->sig.dif.pi_interval = 1 << bi->interval_exp;
 577	domain->sig.dif.ref_tag = le32_to_cpu(cmd->rw.reftag);
 578	if (control & NVME_RW_PRINFO_PRCHK_REF)
 579		domain->sig.dif.ref_remap = true;
 580
 581	domain->sig.dif.app_tag = le16_to_cpu(cmd->rw.lbat);
 582	domain->sig.dif.apptag_check_mask = le16_to_cpu(cmd->rw.lbatm);
 583	domain->sig.dif.app_escape = true;
 584	if (pi_type == NVME_NS_DPS_PI_TYPE3)
 585		domain->sig.dif.ref_escape = true;
 586}
 587
 588static void nvmet_rdma_set_sig_attrs(struct nvmet_req *req,
 589				     struct ib_sig_attrs *sig_attrs)
 590{
 591	struct nvme_command *cmd = req->cmd;
 592	u16 control = le16_to_cpu(cmd->rw.control);
 593	u8 pi_type = req->ns->pi_type;
 594	struct blk_integrity *bi;
 595
 596	bi = bdev_get_integrity(req->ns->bdev);
 597
 598	memset(sig_attrs, 0, sizeof(*sig_attrs));
 599
 600	if (control & NVME_RW_PRINFO_PRACT) {
 601		/* for WRITE_INSERT/READ_STRIP no wire domain */
 602		sig_attrs->wire.sig_type = IB_SIG_TYPE_NONE;
 603		nvmet_rdma_set_sig_domain(bi, cmd, &sig_attrs->mem, control,
 604					  pi_type);
 605		/* Clear the PRACT bit since HCA will generate/verify the PI */
 606		control &= ~NVME_RW_PRINFO_PRACT;
 607		cmd->rw.control = cpu_to_le16(control);
 608		/* PI is added by the HW */
 609		req->transfer_len += req->metadata_len;
 610	} else {
 611		/* for WRITE_PASS/READ_PASS both wire/memory domains exist */
 612		nvmet_rdma_set_sig_domain(bi, cmd, &sig_attrs->wire, control,
 613					  pi_type);
 614		nvmet_rdma_set_sig_domain(bi, cmd, &sig_attrs->mem, control,
 615					  pi_type);
 616	}
 617
 618	if (control & NVME_RW_PRINFO_PRCHK_REF)
 619		sig_attrs->check_mask |= IB_SIG_CHECK_REFTAG;
 620	if (control & NVME_RW_PRINFO_PRCHK_GUARD)
 621		sig_attrs->check_mask |= IB_SIG_CHECK_GUARD;
 622	if (control & NVME_RW_PRINFO_PRCHK_APP)
 623		sig_attrs->check_mask |= IB_SIG_CHECK_APPTAG;
 624}
 625
 626static int nvmet_rdma_rw_ctx_init(struct nvmet_rdma_rsp *rsp, u64 addr, u32 key,
 627				  struct ib_sig_attrs *sig_attrs)
 628{
 629	struct rdma_cm_id *cm_id = rsp->queue->cm_id;
 630	struct nvmet_req *req = &rsp->req;
 631	int ret;
 632
 633	if (req->metadata_len)
 634		ret = rdma_rw_ctx_signature_init(&rsp->rw, cm_id->qp,
 635			cm_id->port_num, req->sg, req->sg_cnt,
 636			req->metadata_sg, req->metadata_sg_cnt, sig_attrs,
 637			addr, key, nvmet_data_dir(req));
 638	else
 639		ret = rdma_rw_ctx_init(&rsp->rw, cm_id->qp, cm_id->port_num,
 640				       req->sg, req->sg_cnt, 0, addr, key,
 641				       nvmet_data_dir(req));
 642
 643	return ret;
 644}
 645
 646static void nvmet_rdma_rw_ctx_destroy(struct nvmet_rdma_rsp *rsp)
 647{
 648	struct rdma_cm_id *cm_id = rsp->queue->cm_id;
 649	struct nvmet_req *req = &rsp->req;
 650
 651	if (req->metadata_len)
 652		rdma_rw_ctx_destroy_signature(&rsp->rw, cm_id->qp,
 653			cm_id->port_num, req->sg, req->sg_cnt,
 654			req->metadata_sg, req->metadata_sg_cnt,
 655			nvmet_data_dir(req));
 656	else
 657		rdma_rw_ctx_destroy(&rsp->rw, cm_id->qp, cm_id->port_num,
 658				    req->sg, req->sg_cnt, nvmet_data_dir(req));
 659}
 660
 661static void nvmet_rdma_release_rsp(struct nvmet_rdma_rsp *rsp)
 662{
 663	struct nvmet_rdma_queue *queue = rsp->queue;
 664
 665	atomic_add(1 + rsp->n_rdma, &queue->sq_wr_avail);
 666
 667	if (rsp->n_rdma)
 668		nvmet_rdma_rw_ctx_destroy(rsp);
 669
 670	if (rsp->req.sg != rsp->cmd->inline_sg)
 671		nvmet_req_free_sgls(&rsp->req);
 672
 673	if (unlikely(!list_empty_careful(&queue->rsp_wr_wait_list)))
 674		nvmet_rdma_process_wr_wait_list(queue);
 675
 676	nvmet_rdma_put_rsp(rsp);
 677}
 678
 679static void nvmet_rdma_error_comp(struct nvmet_rdma_queue *queue)
 680{
 681	if (queue->nvme_sq.ctrl) {
 682		nvmet_ctrl_fatal_error(queue->nvme_sq.ctrl);
 683	} else {
 684		/*
 685		 * we didn't setup the controller yet in case
 686		 * of admin connect error, just disconnect and
 687		 * cleanup the queue
 688		 */
 689		nvmet_rdma_queue_disconnect(queue);
 690	}
 691}
 692
 693static void nvmet_rdma_send_done(struct ib_cq *cq, struct ib_wc *wc)
 694{
 695	struct nvmet_rdma_rsp *rsp =
 696		container_of(wc->wr_cqe, struct nvmet_rdma_rsp, send_cqe);
 697	struct nvmet_rdma_queue *queue = wc->qp->qp_context;
 698
 699	nvmet_rdma_release_rsp(rsp);
 700
 701	if (unlikely(wc->status != IB_WC_SUCCESS &&
 702		     wc->status != IB_WC_WR_FLUSH_ERR)) {
 703		pr_err("SEND for CQE 0x%p failed with status %s (%d).\n",
 704			wc->wr_cqe, ib_wc_status_msg(wc->status), wc->status);
 705		nvmet_rdma_error_comp(queue);
 706	}
 707}
 708
 709static void nvmet_rdma_queue_response(struct nvmet_req *req)
 710{
 711	struct nvmet_rdma_rsp *rsp =
 712		container_of(req, struct nvmet_rdma_rsp, req);
 713	struct rdma_cm_id *cm_id = rsp->queue->cm_id;
 714	struct ib_send_wr *first_wr;
 715
 716	if (rsp->invalidate_rkey) {
 717		rsp->send_wr.opcode = IB_WR_SEND_WITH_INV;
 718		rsp->send_wr.ex.invalidate_rkey = rsp->invalidate_rkey;
 719	} else {
 720		rsp->send_wr.opcode = IB_WR_SEND;
 721	}
 722
 723	if (nvmet_rdma_need_data_out(rsp)) {
 724		if (rsp->req.metadata_len)
 725			first_wr = rdma_rw_ctx_wrs(&rsp->rw, cm_id->qp,
 726					cm_id->port_num, &rsp->write_cqe, NULL);
 727		else
 728			first_wr = rdma_rw_ctx_wrs(&rsp->rw, cm_id->qp,
 729					cm_id->port_num, NULL, &rsp->send_wr);
 730	} else {
 731		first_wr = &rsp->send_wr;
 732	}
 733
 734	nvmet_rdma_post_recv(rsp->queue->dev, rsp->cmd);
 735
 736	ib_dma_sync_single_for_device(rsp->queue->dev->device,
 737		rsp->send_sge.addr, rsp->send_sge.length,
 738		DMA_TO_DEVICE);
 739
 740	if (unlikely(ib_post_send(cm_id->qp, first_wr, NULL))) {
 741		pr_err("sending cmd response failed\n");
 742		nvmet_rdma_release_rsp(rsp);
 743	}
 744}
 745
 746static void nvmet_rdma_read_data_done(struct ib_cq *cq, struct ib_wc *wc)
 747{
 748	struct nvmet_rdma_rsp *rsp =
 749		container_of(wc->wr_cqe, struct nvmet_rdma_rsp, read_cqe);
 750	struct nvmet_rdma_queue *queue = wc->qp->qp_context;
 751	u16 status = 0;
 752
 753	WARN_ON(rsp->n_rdma <= 0);
 754	atomic_add(rsp->n_rdma, &queue->sq_wr_avail);
 755	rsp->n_rdma = 0;
 756
 757	if (unlikely(wc->status != IB_WC_SUCCESS)) {
 758		nvmet_rdma_rw_ctx_destroy(rsp);
 759		nvmet_req_uninit(&rsp->req);
 760		nvmet_rdma_release_rsp(rsp);
 761		if (wc->status != IB_WC_WR_FLUSH_ERR) {
 762			pr_info("RDMA READ for CQE 0x%p failed with status %s (%d).\n",
 763				wc->wr_cqe, ib_wc_status_msg(wc->status), wc->status);
 764			nvmet_rdma_error_comp(queue);
 765		}
 766		return;
 767	}
 768
 769	if (rsp->req.metadata_len)
 770		status = nvmet_rdma_check_pi_status(rsp->rw.reg->mr);
 771	nvmet_rdma_rw_ctx_destroy(rsp);
 772
 773	if (unlikely(status))
 774		nvmet_req_complete(&rsp->req, status);
 775	else
 776		rsp->req.execute(&rsp->req);
 777}
 778
 779static void nvmet_rdma_write_data_done(struct ib_cq *cq, struct ib_wc *wc)
 780{
 781	struct nvmet_rdma_rsp *rsp =
 782		container_of(wc->wr_cqe, struct nvmet_rdma_rsp, write_cqe);
 783	struct nvmet_rdma_queue *queue = wc->qp->qp_context;
 784	struct rdma_cm_id *cm_id = rsp->queue->cm_id;
 785	u16 status;
 786
 787	if (!IS_ENABLED(CONFIG_BLK_DEV_INTEGRITY))
 788		return;
 789
 790	WARN_ON(rsp->n_rdma <= 0);
 791	atomic_add(rsp->n_rdma, &queue->sq_wr_avail);
 792	rsp->n_rdma = 0;
 793
 794	if (unlikely(wc->status != IB_WC_SUCCESS)) {
 795		nvmet_rdma_rw_ctx_destroy(rsp);
 796		nvmet_req_uninit(&rsp->req);
 797		nvmet_rdma_release_rsp(rsp);
 798		if (wc->status != IB_WC_WR_FLUSH_ERR) {
 799			pr_info("RDMA WRITE for CQE failed with status %s (%d).\n",
 800				ib_wc_status_msg(wc->status), wc->status);
 801			nvmet_rdma_error_comp(queue);
 802		}
 803		return;
 804	}
 805
 806	/*
 807	 * Upon RDMA completion check the signature status
 808	 * - if succeeded send good NVMe response
 809	 * - if failed send bad NVMe response with appropriate error
 810	 */
 811	status = nvmet_rdma_check_pi_status(rsp->rw.reg->mr);
 812	if (unlikely(status))
 813		rsp->req.cqe->status = cpu_to_le16(status << 1);
 814	nvmet_rdma_rw_ctx_destroy(rsp);
 815
 816	if (unlikely(ib_post_send(cm_id->qp, &rsp->send_wr, NULL))) {
 817		pr_err("sending cmd response failed\n");
 818		nvmet_rdma_release_rsp(rsp);
 819	}
 820}
 821
 822static void nvmet_rdma_use_inline_sg(struct nvmet_rdma_rsp *rsp, u32 len,
 823		u64 off)
 824{
 825	int sg_count = num_pages(len);
 826	struct scatterlist *sg;
 827	int i;
 828
 829	sg = rsp->cmd->inline_sg;
 830	for (i = 0; i < sg_count; i++, sg++) {
 831		if (i < sg_count - 1)
 832			sg_unmark_end(sg);
 833		else
 834			sg_mark_end(sg);
 835		sg->offset = off;
 836		sg->length = min_t(int, len, PAGE_SIZE - off);
 837		len -= sg->length;
 838		if (!i)
 839			off = 0;
 840	}
 841
 842	rsp->req.sg = rsp->cmd->inline_sg;
 843	rsp->req.sg_cnt = sg_count;
 844}
 845
 846static u16 nvmet_rdma_map_sgl_inline(struct nvmet_rdma_rsp *rsp)
 847{
 848	struct nvme_sgl_desc *sgl = &rsp->req.cmd->common.dptr.sgl;
 849	u64 off = le64_to_cpu(sgl->addr);
 850	u32 len = le32_to_cpu(sgl->length);
 851
 852	if (!nvme_is_write(rsp->req.cmd)) {
 853		rsp->req.error_loc =
 854			offsetof(struct nvme_common_command, opcode);
 855		return NVME_SC_INVALID_FIELD | NVME_STATUS_DNR;
 856	}
 857
 858	if (off + len > rsp->queue->dev->inline_data_size) {
 859		pr_err("invalid inline data offset!\n");
 860		return NVME_SC_SGL_INVALID_OFFSET | NVME_STATUS_DNR;
 861	}
 862
 863	/* no data command? */
 864	if (!len)
 865		return 0;
 866
 867	nvmet_rdma_use_inline_sg(rsp, len, off);
 868	rsp->flags |= NVMET_RDMA_REQ_INLINE_DATA;
 869	rsp->req.transfer_len += len;
 870	return 0;
 871}
 872
 873static u16 nvmet_rdma_map_sgl_keyed(struct nvmet_rdma_rsp *rsp,
 874		struct nvme_keyed_sgl_desc *sgl, bool invalidate)
 875{
 876	u64 addr = le64_to_cpu(sgl->addr);
 877	u32 key = get_unaligned_le32(sgl->key);
 878	struct ib_sig_attrs sig_attrs;
 879	int ret;
 880
 881	rsp->req.transfer_len = get_unaligned_le24(sgl->length);
 882
 883	/* no data command? */
 884	if (!rsp->req.transfer_len)
 885		return 0;
 886
 887	if (rsp->req.metadata_len)
 888		nvmet_rdma_set_sig_attrs(&rsp->req, &sig_attrs);
 889
 890	ret = nvmet_req_alloc_sgls(&rsp->req);
 891	if (unlikely(ret < 0))
 892		goto error_out;
 893
 894	ret = nvmet_rdma_rw_ctx_init(rsp, addr, key, &sig_attrs);
 895	if (unlikely(ret < 0))
 896		goto error_out;
 897	rsp->n_rdma += ret;
 898
 899	if (invalidate)
 900		rsp->invalidate_rkey = key;
 901
 902	return 0;
 903
 904error_out:
 905	rsp->req.transfer_len = 0;
 906	return NVME_SC_INTERNAL;
 907}
 908
 909static u16 nvmet_rdma_map_sgl(struct nvmet_rdma_rsp *rsp)
 910{
 911	struct nvme_keyed_sgl_desc *sgl = &rsp->req.cmd->common.dptr.ksgl;
 912
 913	switch (sgl->type >> 4) {
 914	case NVME_SGL_FMT_DATA_DESC:
 915		switch (sgl->type & 0xf) {
 916		case NVME_SGL_FMT_OFFSET:
 917			return nvmet_rdma_map_sgl_inline(rsp);
 918		default:
 919			pr_err("invalid SGL subtype: %#x\n", sgl->type);
 920			rsp->req.error_loc =
 921				offsetof(struct nvme_common_command, dptr);
 922			return NVME_SC_INVALID_FIELD | NVME_STATUS_DNR;
 923		}
 924	case NVME_KEY_SGL_FMT_DATA_DESC:
 925		switch (sgl->type & 0xf) {
 926		case NVME_SGL_FMT_ADDRESS | NVME_SGL_FMT_INVALIDATE:
 927			return nvmet_rdma_map_sgl_keyed(rsp, sgl, true);
 928		case NVME_SGL_FMT_ADDRESS:
 929			return nvmet_rdma_map_sgl_keyed(rsp, sgl, false);
 930		default:
 931			pr_err("invalid SGL subtype: %#x\n", sgl->type);
 932			rsp->req.error_loc =
 933				offsetof(struct nvme_common_command, dptr);
 934			return NVME_SC_INVALID_FIELD | NVME_STATUS_DNR;
 935		}
 936	default:
 937		pr_err("invalid SGL type: %#x\n", sgl->type);
 938		rsp->req.error_loc = offsetof(struct nvme_common_command, dptr);
 939		return NVME_SC_SGL_INVALID_TYPE | NVME_STATUS_DNR;
 940	}
 941}
 942
 943static bool nvmet_rdma_execute_command(struct nvmet_rdma_rsp *rsp)
 944{
 945	struct nvmet_rdma_queue *queue = rsp->queue;
 946
 947	if (unlikely(atomic_sub_return(1 + rsp->n_rdma,
 948			&queue->sq_wr_avail) < 0)) {
 949		pr_debug("IB send queue full (needed %d): queue %u cntlid %u\n",
 950				1 + rsp->n_rdma, queue->idx,
 951				queue->nvme_sq.ctrl->cntlid);
 952		atomic_add(1 + rsp->n_rdma, &queue->sq_wr_avail);
 953		return false;
 954	}
 955
 956	if (nvmet_rdma_need_data_in(rsp)) {
 957		if (rdma_rw_ctx_post(&rsp->rw, queue->qp,
 958				queue->cm_id->port_num, &rsp->read_cqe, NULL))
 959			nvmet_req_complete(&rsp->req, NVME_SC_DATA_XFER_ERROR);
 960	} else {
 961		rsp->req.execute(&rsp->req);
 962	}
 963
 964	return true;
 965}
 966
 967static void nvmet_rdma_handle_command(struct nvmet_rdma_queue *queue,
 968		struct nvmet_rdma_rsp *cmd)
 969{
 970	u16 status;
 971
 972	ib_dma_sync_single_for_cpu(queue->dev->device,
 973		cmd->cmd->sge[0].addr, cmd->cmd->sge[0].length,
 974		DMA_FROM_DEVICE);
 975	ib_dma_sync_single_for_cpu(queue->dev->device,
 976		cmd->send_sge.addr, cmd->send_sge.length,
 977		DMA_TO_DEVICE);
 978
 979	if (!nvmet_req_init(&cmd->req, &queue->nvme_sq, &nvmet_rdma_ops))
 980		return;
 981
 982	status = nvmet_rdma_map_sgl(cmd);
 983	if (status)
 984		goto out_err;
 985
 986	if (unlikely(!nvmet_rdma_execute_command(cmd))) {
 987		spin_lock(&queue->rsp_wr_wait_lock);
 988		list_add_tail(&cmd->wait_list, &queue->rsp_wr_wait_list);
 989		spin_unlock(&queue->rsp_wr_wait_lock);
 990	}
 991
 992	return;
 993
 994out_err:
 995	nvmet_req_complete(&cmd->req, status);
 996}
 997
 998static bool nvmet_rdma_recv_not_live(struct nvmet_rdma_queue *queue,
 999		struct nvmet_rdma_rsp *rsp)
1000{
1001	unsigned long flags;
1002	bool ret = true;
1003
1004	spin_lock_irqsave(&queue->state_lock, flags);
1005	/*
1006	 * recheck queue state is not live to prevent a race condition
1007	 * with RDMA_CM_EVENT_ESTABLISHED handler.
1008	 */
1009	if (queue->state == NVMET_RDMA_Q_LIVE)
1010		ret = false;
1011	else if (queue->state == NVMET_RDMA_Q_CONNECTING)
1012		list_add_tail(&rsp->wait_list, &queue->rsp_wait_list);
1013	else
1014		nvmet_rdma_put_rsp(rsp);
1015	spin_unlock_irqrestore(&queue->state_lock, flags);
1016	return ret;
1017}
1018
1019static void nvmet_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc)
1020{
1021	struct nvmet_rdma_cmd *cmd =
1022		container_of(wc->wr_cqe, struct nvmet_rdma_cmd, cqe);
1023	struct nvmet_rdma_queue *queue = wc->qp->qp_context;
1024	struct nvmet_rdma_rsp *rsp;
1025
1026	if (unlikely(wc->status != IB_WC_SUCCESS)) {
1027		if (wc->status != IB_WC_WR_FLUSH_ERR) {
1028			pr_err("RECV for CQE 0x%p failed with status %s (%d)\n",
1029				wc->wr_cqe, ib_wc_status_msg(wc->status),
1030				wc->status);
1031			nvmet_rdma_error_comp(queue);
1032		}
1033		return;
1034	}
1035
1036	if (unlikely(wc->byte_len < sizeof(struct nvme_command))) {
1037		pr_err("Ctrl Fatal Error: capsule size less than 64 bytes\n");
1038		nvmet_rdma_error_comp(queue);
1039		return;
1040	}
1041
1042	cmd->queue = queue;
1043	rsp = nvmet_rdma_get_rsp(queue);
1044	if (unlikely(!rsp)) {
1045		/*
1046		 * we get here only under memory pressure,
1047		 * silently drop and have the host retry
1048		 * as we can't even fail it.
1049		 */
1050		nvmet_rdma_post_recv(queue->dev, cmd);
1051		return;
1052	}
1053	rsp->queue = queue;
1054	rsp->cmd = cmd;
1055	rsp->flags = 0;
1056	rsp->req.cmd = cmd->nvme_cmd;
1057	rsp->req.port = queue->port;
1058	rsp->n_rdma = 0;
1059	rsp->invalidate_rkey = 0;
1060
1061	if (unlikely(queue->state != NVMET_RDMA_Q_LIVE) &&
1062	    nvmet_rdma_recv_not_live(queue, rsp))
1063		return;
1064
1065	nvmet_rdma_handle_command(queue, rsp);
1066}
1067
1068static void nvmet_rdma_destroy_srq(struct nvmet_rdma_srq *nsrq)
1069{
1070	nvmet_rdma_free_cmds(nsrq->ndev, nsrq->cmds, nsrq->ndev->srq_size,
1071			     false);
1072	ib_destroy_srq(nsrq->srq);
1073
1074	kfree(nsrq);
1075}
1076
1077static void nvmet_rdma_destroy_srqs(struct nvmet_rdma_device *ndev)
1078{
1079	int i;
1080
1081	if (!ndev->srqs)
1082		return;
1083
1084	for (i = 0; i < ndev->srq_count; i++)
1085		nvmet_rdma_destroy_srq(ndev->srqs[i]);
1086
1087	kfree(ndev->srqs);
1088}
1089
1090static struct nvmet_rdma_srq *
1091nvmet_rdma_init_srq(struct nvmet_rdma_device *ndev)
1092{
1093	struct ib_srq_init_attr srq_attr = { NULL, };
1094	size_t srq_size = ndev->srq_size;
1095	struct nvmet_rdma_srq *nsrq;
1096	struct ib_srq *srq;
1097	int ret, i;
1098
1099	nsrq = kzalloc(sizeof(*nsrq), GFP_KERNEL);
1100	if (!nsrq)
1101		return ERR_PTR(-ENOMEM);
1102
1103	srq_attr.attr.max_wr = srq_size;
1104	srq_attr.attr.max_sge = 1 + ndev->inline_page_count;
1105	srq_attr.attr.srq_limit = 0;
1106	srq_attr.srq_type = IB_SRQT_BASIC;
1107	srq = ib_create_srq(ndev->pd, &srq_attr);
1108	if (IS_ERR(srq)) {
1109		ret = PTR_ERR(srq);
1110		goto out_free;
1111	}
1112
1113	nsrq->cmds = nvmet_rdma_alloc_cmds(ndev, srq_size, false);
1114	if (IS_ERR(nsrq->cmds)) {
1115		ret = PTR_ERR(nsrq->cmds);
1116		goto out_destroy_srq;
1117	}
1118
1119	nsrq->srq = srq;
1120	nsrq->ndev = ndev;
1121
1122	for (i = 0; i < srq_size; i++) {
1123		nsrq->cmds[i].nsrq = nsrq;
1124		ret = nvmet_rdma_post_recv(ndev, &nsrq->cmds[i]);
1125		if (ret)
1126			goto out_free_cmds;
1127	}
1128
1129	return nsrq;
1130
1131out_free_cmds:
1132	nvmet_rdma_free_cmds(ndev, nsrq->cmds, srq_size, false);
1133out_destroy_srq:
1134	ib_destroy_srq(srq);
1135out_free:
1136	kfree(nsrq);
1137	return ERR_PTR(ret);
1138}
1139
1140static int nvmet_rdma_init_srqs(struct nvmet_rdma_device *ndev)
1141{
1142	int i, ret;
1143
1144	if (!ndev->device->attrs.max_srq_wr || !ndev->device->attrs.max_srq) {
1145		/*
1146		 * If SRQs aren't supported we just go ahead and use normal
1147		 * non-shared receive queues.
1148		 */
1149		pr_info("SRQ requested but not supported.\n");
1150		return 0;
1151	}
1152
1153	ndev->srq_size = min(ndev->device->attrs.max_srq_wr,
1154			     nvmet_rdma_srq_size);
1155	ndev->srq_count = min(ndev->device->num_comp_vectors,
1156			      ndev->device->attrs.max_srq);
1157
1158	ndev->srqs = kcalloc(ndev->srq_count, sizeof(*ndev->srqs), GFP_KERNEL);
1159	if (!ndev->srqs)
1160		return -ENOMEM;
1161
1162	for (i = 0; i < ndev->srq_count; i++) {
1163		ndev->srqs[i] = nvmet_rdma_init_srq(ndev);
1164		if (IS_ERR(ndev->srqs[i])) {
1165			ret = PTR_ERR(ndev->srqs[i]);
1166			goto err_srq;
1167		}
1168	}
1169
1170	return 0;
1171
1172err_srq:
1173	while (--i >= 0)
1174		nvmet_rdma_destroy_srq(ndev->srqs[i]);
1175	kfree(ndev->srqs);
1176	return ret;
1177}
1178
1179static void nvmet_rdma_free_dev(struct kref *ref)
1180{
1181	struct nvmet_rdma_device *ndev =
1182		container_of(ref, struct nvmet_rdma_device, ref);
1183
1184	mutex_lock(&device_list_mutex);
1185	list_del(&ndev->entry);
1186	mutex_unlock(&device_list_mutex);
1187
1188	nvmet_rdma_destroy_srqs(ndev);
1189	ib_dealloc_pd(ndev->pd);
1190
1191	kfree(ndev);
1192}
1193
1194static struct nvmet_rdma_device *
1195nvmet_rdma_find_get_device(struct rdma_cm_id *cm_id)
1196{
1197	struct nvmet_rdma_port *port = cm_id->context;
1198	struct nvmet_port *nport = port->nport;
1199	struct nvmet_rdma_device *ndev;
1200	int inline_page_count;
1201	int inline_sge_count;
1202	int ret;
1203
1204	mutex_lock(&device_list_mutex);
1205	list_for_each_entry(ndev, &device_list, entry) {
1206		if (ndev->device->node_guid == cm_id->device->node_guid &&
1207		    kref_get_unless_zero(&ndev->ref))
1208			goto out_unlock;
1209	}
1210
1211	ndev = kzalloc(sizeof(*ndev), GFP_KERNEL);
1212	if (!ndev)
1213		goto out_err;
1214
1215	inline_page_count = num_pages(nport->inline_data_size);
1216	inline_sge_count = max(cm_id->device->attrs.max_sge_rd,
1217				cm_id->device->attrs.max_recv_sge) - 1;
1218	if (inline_page_count > inline_sge_count) {
1219		pr_warn("inline_data_size %d cannot be supported by device %s. Reducing to %lu.\n",
1220			nport->inline_data_size, cm_id->device->name,
1221			inline_sge_count * PAGE_SIZE);
1222		nport->inline_data_size = inline_sge_count * PAGE_SIZE;
1223		inline_page_count = inline_sge_count;
1224	}
1225	ndev->inline_data_size = nport->inline_data_size;
1226	ndev->inline_page_count = inline_page_count;
1227
1228	if (nport->pi_enable && !(cm_id->device->attrs.kernel_cap_flags &
1229				  IBK_INTEGRITY_HANDOVER)) {
1230		pr_warn("T10-PI is not supported by device %s. Disabling it\n",
1231			cm_id->device->name);
1232		nport->pi_enable = false;
1233	}
1234
1235	ndev->device = cm_id->device;
1236	kref_init(&ndev->ref);
1237
1238	ndev->pd = ib_alloc_pd(ndev->device, 0);
1239	if (IS_ERR(ndev->pd))
1240		goto out_free_dev;
1241
1242	if (nvmet_rdma_use_srq) {
1243		ret = nvmet_rdma_init_srqs(ndev);
1244		if (ret)
1245			goto out_free_pd;
1246	}
1247
1248	list_add(&ndev->entry, &device_list);
1249out_unlock:
1250	mutex_unlock(&device_list_mutex);
1251	pr_debug("added %s.\n", ndev->device->name);
1252	return ndev;
1253
1254out_free_pd:
1255	ib_dealloc_pd(ndev->pd);
1256out_free_dev:
1257	kfree(ndev);
1258out_err:
1259	mutex_unlock(&device_list_mutex);
1260	return NULL;
1261}
1262
1263static int nvmet_rdma_create_queue_ib(struct nvmet_rdma_queue *queue)
1264{
1265	struct ib_qp_init_attr qp_attr = { };
1266	struct nvmet_rdma_device *ndev = queue->dev;
1267	int nr_cqe, ret, i, factor;
1268
1269	/*
1270	 * Reserve CQ slots for RECV + RDMA_READ/RDMA_WRITE + RDMA_SEND.
1271	 */
1272	nr_cqe = queue->recv_queue_size + 2 * queue->send_queue_size;
1273
1274	queue->cq = ib_cq_pool_get(ndev->device, nr_cqe + 1,
1275				   queue->comp_vector, IB_POLL_WORKQUEUE);
1276	if (IS_ERR(queue->cq)) {
1277		ret = PTR_ERR(queue->cq);
1278		pr_err("failed to create CQ cqe= %d ret= %d\n",
1279		       nr_cqe + 1, ret);
1280		goto out;
1281	}
1282
1283	qp_attr.qp_context = queue;
1284	qp_attr.event_handler = nvmet_rdma_qp_event;
1285	qp_attr.send_cq = queue->cq;
1286	qp_attr.recv_cq = queue->cq;
1287	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
1288	qp_attr.qp_type = IB_QPT_RC;
1289	/* +1 for drain */
1290	qp_attr.cap.max_send_wr = queue->send_queue_size + 1;
1291	factor = rdma_rw_mr_factor(ndev->device, queue->cm_id->port_num,
1292				   1 << NVMET_RDMA_MAX_MDTS);
1293	qp_attr.cap.max_rdma_ctxs = queue->send_queue_size * factor;
1294	qp_attr.cap.max_send_sge = max(ndev->device->attrs.max_sge_rd,
1295					ndev->device->attrs.max_send_sge);
1296
1297	if (queue->nsrq) {
1298		qp_attr.srq = queue->nsrq->srq;
1299	} else {
1300		/* +1 for drain */
1301		qp_attr.cap.max_recv_wr = 1 + queue->recv_queue_size;
1302		qp_attr.cap.max_recv_sge = 1 + ndev->inline_page_count;
1303	}
1304
1305	if (queue->port->pi_enable && queue->host_qid)
1306		qp_attr.create_flags |= IB_QP_CREATE_INTEGRITY_EN;
1307
1308	ret = rdma_create_qp(queue->cm_id, ndev->pd, &qp_attr);
1309	if (ret) {
1310		pr_err("failed to create_qp ret= %d\n", ret);
1311		goto err_destroy_cq;
1312	}
1313	queue->qp = queue->cm_id->qp;
1314
1315	atomic_set(&queue->sq_wr_avail, qp_attr.cap.max_send_wr);
1316
1317	pr_debug("%s: max_cqe= %d max_sge= %d sq_size = %d cm_id= %p\n",
1318		 __func__, queue->cq->cqe, qp_attr.cap.max_send_sge,
1319		 qp_attr.cap.max_send_wr, queue->cm_id);
1320
1321	if (!queue->nsrq) {
1322		for (i = 0; i < queue->recv_queue_size; i++) {
1323			queue->cmds[i].queue = queue;
1324			ret = nvmet_rdma_post_recv(ndev, &queue->cmds[i]);
1325			if (ret)
1326				goto err_destroy_qp;
1327		}
1328	}
1329
1330out:
1331	return ret;
1332
1333err_destroy_qp:
1334	rdma_destroy_qp(queue->cm_id);
1335err_destroy_cq:
1336	ib_cq_pool_put(queue->cq, nr_cqe + 1);
1337	goto out;
1338}
1339
1340static void nvmet_rdma_destroy_queue_ib(struct nvmet_rdma_queue *queue)
1341{
1342	ib_drain_qp(queue->qp);
1343	if (queue->cm_id)
1344		rdma_destroy_id(queue->cm_id);
1345	ib_destroy_qp(queue->qp);
1346	ib_cq_pool_put(queue->cq, queue->recv_queue_size + 2 *
1347		       queue->send_queue_size + 1);
1348}
1349
1350static void nvmet_rdma_free_queue(struct nvmet_rdma_queue *queue)
1351{
1352	pr_debug("freeing queue %d\n", queue->idx);
1353
1354	nvmet_sq_destroy(&queue->nvme_sq);
1355	nvmet_cq_put(&queue->nvme_cq);
1356
1357	nvmet_rdma_destroy_queue_ib(queue);
1358	if (!queue->nsrq) {
1359		nvmet_rdma_free_cmds(queue->dev, queue->cmds,
1360				queue->recv_queue_size,
1361				!queue->host_qid);
1362	}
1363	nvmet_rdma_free_rsps(queue);
1364	ida_free(&nvmet_rdma_queue_ida, queue->idx);
1365	kfree(queue);
1366}
1367
1368static void nvmet_rdma_release_queue_work(struct work_struct *w)
1369{
1370	struct nvmet_rdma_queue *queue =
1371		container_of(w, struct nvmet_rdma_queue, release_work);
1372	struct nvmet_rdma_device *dev = queue->dev;
1373
1374	nvmet_rdma_free_queue(queue);
1375
1376	kref_put(&dev->ref, nvmet_rdma_free_dev);
1377}
1378
1379static int
1380nvmet_rdma_parse_cm_connect_req(struct rdma_conn_param *conn,
1381				struct nvmet_rdma_queue *queue)
1382{
1383	struct nvme_rdma_cm_req *req;
1384
1385	req = (struct nvme_rdma_cm_req *)conn->private_data;
1386	if (!req || conn->private_data_len == 0)
1387		return NVME_RDMA_CM_INVALID_LEN;
1388
1389	if (le16_to_cpu(req->recfmt) != NVME_RDMA_CM_FMT_1_0)
1390		return NVME_RDMA_CM_INVALID_RECFMT;
1391
1392	queue->host_qid = le16_to_cpu(req->qid);
1393
1394	/*
1395	 * req->hsqsize corresponds to our recv queue size plus 1
1396	 * req->hrqsize corresponds to our send queue size
1397	 */
1398	queue->recv_queue_size = le16_to_cpu(req->hsqsize) + 1;
1399	queue->send_queue_size = le16_to_cpu(req->hrqsize);
1400
1401	if (!queue->host_qid && queue->recv_queue_size > NVME_AQ_DEPTH)
1402		return NVME_RDMA_CM_INVALID_HSQSIZE;
1403
1404	/* XXX: Should we enforce some kind of max for IO queues? */
1405
1406	return 0;
1407}
1408
1409static int nvmet_rdma_cm_reject(struct rdma_cm_id *cm_id,
1410				enum nvme_rdma_cm_status status)
1411{
1412	struct nvme_rdma_cm_rej rej;
1413
1414	pr_debug("rejecting connect request: status %d (%s)\n",
1415		 status, nvme_rdma_cm_msg(status));
1416
1417	rej.recfmt = cpu_to_le16(NVME_RDMA_CM_FMT_1_0);
1418	rej.sts = cpu_to_le16(status);
1419
1420	return rdma_reject(cm_id, (void *)&rej, sizeof(rej),
1421			   IB_CM_REJ_CONSUMER_DEFINED);
1422}
1423
1424static struct nvmet_rdma_queue *
1425nvmet_rdma_alloc_queue(struct nvmet_rdma_device *ndev,
1426		struct rdma_cm_id *cm_id,
1427		struct rdma_cm_event *event)
1428{
1429	struct nvmet_rdma_port *port = cm_id->context;
1430	struct nvmet_rdma_queue *queue;
1431	int ret;
1432
1433	queue = kzalloc(sizeof(*queue), GFP_KERNEL);
1434	if (!queue) {
1435		ret = NVME_RDMA_CM_NO_RSC;
1436		goto out_reject;
1437	}
1438
1439	nvmet_cq_init(&queue->nvme_cq);
1440	ret = nvmet_sq_init(&queue->nvme_sq, &queue->nvme_cq);
1441	if (ret) {
1442		ret = NVME_RDMA_CM_NO_RSC;
1443		goto out_free_queue;
1444	}
1445
1446	ret = nvmet_rdma_parse_cm_connect_req(&event->param.conn, queue);
1447	if (ret)
1448		goto out_destroy_sq;
1449
1450	/*
1451	 * Schedules the actual release because calling rdma_destroy_id from
1452	 * inside a CM callback would trigger a deadlock. (great API design..)
1453	 */
1454	INIT_WORK(&queue->release_work, nvmet_rdma_release_queue_work);
1455	queue->dev = ndev;
1456	queue->cm_id = cm_id;
1457	queue->port = port->nport;
1458
1459	spin_lock_init(&queue->state_lock);
1460	queue->state = NVMET_RDMA_Q_CONNECTING;
1461	INIT_LIST_HEAD(&queue->rsp_wait_list);
1462	INIT_LIST_HEAD(&queue->rsp_wr_wait_list);
1463	spin_lock_init(&queue->rsp_wr_wait_lock);
1464	INIT_LIST_HEAD(&queue->queue_list);
1465
1466	queue->idx = ida_alloc(&nvmet_rdma_queue_ida, GFP_KERNEL);
1467	if (queue->idx < 0) {
1468		ret = NVME_RDMA_CM_NO_RSC;
1469		goto out_destroy_sq;
1470	}
1471
1472	/*
1473	 * Spread the io queues across completion vectors,
1474	 * but still keep all admin queues on vector 0.
1475	 */
1476	queue->comp_vector = !queue->host_qid ? 0 :
1477		queue->idx % ndev->device->num_comp_vectors;
1478
1479
1480	ret = nvmet_rdma_alloc_rsps(queue);
1481	if (ret) {
1482		ret = NVME_RDMA_CM_NO_RSC;
1483		goto out_ida_remove;
1484	}
1485
1486	if (ndev->srqs) {
1487		queue->nsrq = ndev->srqs[queue->comp_vector % ndev->srq_count];
1488	} else {
1489		queue->cmds = nvmet_rdma_alloc_cmds(ndev,
1490				queue->recv_queue_size,
1491				!queue->host_qid);
1492		if (IS_ERR(queue->cmds)) {
1493			ret = NVME_RDMA_CM_NO_RSC;
1494			goto out_free_responses;
1495		}
1496	}
1497
1498	ret = nvmet_rdma_create_queue_ib(queue);
1499	if (ret) {
1500		pr_err("%s: creating RDMA queue failed (%d).\n",
1501			__func__, ret);
1502		ret = NVME_RDMA_CM_NO_RSC;
1503		goto out_free_cmds;
1504	}
1505
1506	return queue;
1507
1508out_free_cmds:
1509	if (!queue->nsrq) {
1510		nvmet_rdma_free_cmds(queue->dev, queue->cmds,
1511				queue->recv_queue_size,
1512				!queue->host_qid);
1513	}
1514out_free_responses:
1515	nvmet_rdma_free_rsps(queue);
1516out_ida_remove:
1517	ida_free(&nvmet_rdma_queue_ida, queue->idx);
1518out_destroy_sq:
1519	nvmet_sq_destroy(&queue->nvme_sq);
1520out_free_queue:
1521	nvmet_cq_put(&queue->nvme_cq);
1522	kfree(queue);
1523out_reject:
1524	nvmet_rdma_cm_reject(cm_id, ret);
1525	return NULL;
1526}
1527
1528static void nvmet_rdma_qp_event(struct ib_event *event, void *priv)
1529{
1530	struct nvmet_rdma_queue *queue = priv;
1531
1532	switch (event->event) {
1533	case IB_EVENT_COMM_EST:
1534		rdma_notify(queue->cm_id, event->event);
1535		break;
1536	case IB_EVENT_QP_LAST_WQE_REACHED:
1537		pr_debug("received last WQE reached event for queue=0x%p\n",
1538			 queue);
1539		break;
1540	default:
1541		pr_err("received IB QP event: %s (%d)\n",
1542		       ib_event_msg(event->event), event->event);
1543		break;
1544	}
1545}
1546
1547static int nvmet_rdma_cm_accept(struct rdma_cm_id *cm_id,
1548		struct nvmet_rdma_queue *queue,
1549		struct rdma_conn_param *p)
1550{
1551	struct rdma_conn_param  param = { };
1552	struct nvme_rdma_cm_rep priv = { };
1553	int ret = -ENOMEM;
1554
1555	param.rnr_retry_count = 7;
1556	param.flow_control = 1;
1557	param.initiator_depth = min_t(u8, p->initiator_depth,
1558		queue->dev->device->attrs.max_qp_init_rd_atom);
1559	param.private_data = &priv;
1560	param.private_data_len = sizeof(priv);
1561	priv.recfmt = cpu_to_le16(NVME_RDMA_CM_FMT_1_0);
1562	priv.crqsize = cpu_to_le16(queue->recv_queue_size);
1563
1564	ret = rdma_accept(cm_id, &param);
1565	if (ret)
1566		pr_err("rdma_accept failed (error code = %d)\n", ret);
1567
1568	return ret;
1569}
1570
1571static int nvmet_rdma_queue_connect(struct rdma_cm_id *cm_id,
1572		struct rdma_cm_event *event)
1573{
1574	struct nvmet_rdma_device *ndev;
1575	struct nvmet_rdma_queue *queue;
1576	int ret = -EINVAL;
1577
1578	ndev = nvmet_rdma_find_get_device(cm_id);
1579	if (!ndev) {
1580		nvmet_rdma_cm_reject(cm_id, NVME_RDMA_CM_NO_RSC);
1581		return -ECONNREFUSED;
1582	}
1583
1584	queue = nvmet_rdma_alloc_queue(ndev, cm_id, event);
1585	if (!queue) {
1586		ret = -ENOMEM;
1587		goto put_device;
1588	}
1589
1590	if (queue->host_qid == 0) {
1591		struct nvmet_rdma_queue *q;
1592		int pending = 0;
1593
1594		/* Check for pending controller teardown */
1595		mutex_lock(&nvmet_rdma_queue_mutex);
1596		list_for_each_entry(q, &nvmet_rdma_queue_list, queue_list) {
1597			if (q->nvme_sq.ctrl == queue->nvme_sq.ctrl &&
1598			    q->state == NVMET_RDMA_Q_DISCONNECTING)
1599				pending++;
1600		}
1601		mutex_unlock(&nvmet_rdma_queue_mutex);
1602		if (pending > NVMET_RDMA_BACKLOG)
1603			return NVME_SC_CONNECT_CTRL_BUSY;
1604	}
1605
1606	ret = nvmet_rdma_cm_accept(cm_id, queue, &event->param.conn);
1607	if (ret) {
1608		/*
1609		 * Don't destroy the cm_id in free path, as we implicitly
1610		 * destroy the cm_id here with non-zero ret code.
1611		 */
1612		queue->cm_id = NULL;
1613		goto free_queue;
1614	}
1615
1616	mutex_lock(&nvmet_rdma_queue_mutex);
1617	list_add_tail(&queue->queue_list, &nvmet_rdma_queue_list);
1618	mutex_unlock(&nvmet_rdma_queue_mutex);
1619
1620	return 0;
1621
1622free_queue:
1623	nvmet_rdma_free_queue(queue);
1624put_device:
1625	kref_put(&ndev->ref, nvmet_rdma_free_dev);
1626
1627	return ret;
1628}
1629
1630static void nvmet_rdma_queue_established(struct nvmet_rdma_queue *queue)
1631{
1632	unsigned long flags;
1633
1634	spin_lock_irqsave(&queue->state_lock, flags);
1635	if (queue->state != NVMET_RDMA_Q_CONNECTING) {
1636		pr_warn("trying to establish a connected queue\n");
1637		goto out_unlock;
1638	}
1639	queue->state = NVMET_RDMA_Q_LIVE;
1640
1641	while (!list_empty(&queue->rsp_wait_list)) {
1642		struct nvmet_rdma_rsp *cmd;
1643
1644		cmd = list_first_entry(&queue->rsp_wait_list,
1645					struct nvmet_rdma_rsp, wait_list);
1646		list_del(&cmd->wait_list);
1647
1648		spin_unlock_irqrestore(&queue->state_lock, flags);
1649		nvmet_rdma_handle_command(queue, cmd);
1650		spin_lock_irqsave(&queue->state_lock, flags);
1651	}
1652
1653out_unlock:
1654	spin_unlock_irqrestore(&queue->state_lock, flags);
1655}
1656
1657static void __nvmet_rdma_queue_disconnect(struct nvmet_rdma_queue *queue)
1658{
1659	bool disconnect = false;
1660	unsigned long flags;
1661
1662	pr_debug("cm_id= %p queue->state= %d\n", queue->cm_id, queue->state);
1663
1664	spin_lock_irqsave(&queue->state_lock, flags);
1665	switch (queue->state) {
1666	case NVMET_RDMA_Q_CONNECTING:
1667		while (!list_empty(&queue->rsp_wait_list)) {
1668			struct nvmet_rdma_rsp *rsp;
1669
1670			rsp = list_first_entry(&queue->rsp_wait_list,
1671					       struct nvmet_rdma_rsp,
1672					       wait_list);
1673			list_del(&rsp->wait_list);
1674			nvmet_rdma_put_rsp(rsp);
1675		}
1676		fallthrough;
1677	case NVMET_RDMA_Q_LIVE:
1678		queue->state = NVMET_RDMA_Q_DISCONNECTING;
1679		disconnect = true;
1680		break;
1681	case NVMET_RDMA_Q_DISCONNECTING:
1682		break;
1683	}
1684	spin_unlock_irqrestore(&queue->state_lock, flags);
1685
1686	if (disconnect) {
1687		rdma_disconnect(queue->cm_id);
1688		queue_work(nvmet_wq, &queue->release_work);
1689	}
1690}
1691
1692static void nvmet_rdma_queue_disconnect(struct nvmet_rdma_queue *queue)
1693{
1694	bool disconnect = false;
1695
1696	mutex_lock(&nvmet_rdma_queue_mutex);
1697	if (!list_empty(&queue->queue_list)) {
1698		list_del_init(&queue->queue_list);
1699		disconnect = true;
1700	}
1701	mutex_unlock(&nvmet_rdma_queue_mutex);
1702
1703	if (disconnect)
1704		__nvmet_rdma_queue_disconnect(queue);
1705}
1706
1707static void nvmet_rdma_queue_connect_fail(struct rdma_cm_id *cm_id,
1708		struct nvmet_rdma_queue *queue)
1709{
1710	WARN_ON_ONCE(queue->state != NVMET_RDMA_Q_CONNECTING);
1711
1712	mutex_lock(&nvmet_rdma_queue_mutex);
1713	if (!list_empty(&queue->queue_list))
1714		list_del_init(&queue->queue_list);
1715	mutex_unlock(&nvmet_rdma_queue_mutex);
1716
1717	pr_err("failed to connect queue %d\n", queue->idx);
1718	queue_work(nvmet_wq, &queue->release_work);
1719}
1720
1721/**
1722 * nvmet_rdma_device_removal() - Handle RDMA device removal
1723 * @cm_id:	rdma_cm id, used for nvmet port
1724 * @queue:      nvmet rdma queue (cm id qp_context)
1725 *
1726 * DEVICE_REMOVAL event notifies us that the RDMA device is about
1727 * to unplug. Note that this event can be generated on a normal
1728 * queue cm_id and/or a device bound listener cm_id (where in this
1729 * case queue will be null).
1730 *
1731 * We registered an ib_client to handle device removal for queues,
1732 * so we only need to handle the listening port cm_ids. In this case
1733 * we nullify the priv to prevent double cm_id destruction and destroying
1734 * the cm_id implicitly by returning a non-zero rc to the callout.
1735 */
1736static int nvmet_rdma_device_removal(struct rdma_cm_id *cm_id,
1737		struct nvmet_rdma_queue *queue)
1738{
1739	struct nvmet_rdma_port *port;
1740
1741	if (queue) {
1742		/*
1743		 * This is a queue cm_id. we have registered
1744		 * an ib_client to handle queues removal
1745		 * so don't interfere and just return.
1746		 */
1747		return 0;
1748	}
1749
1750	port = cm_id->context;
1751
1752	/*
1753	 * This is a listener cm_id. Make sure that
1754	 * future remove_port won't invoke a double
1755	 * cm_id destroy. use atomic xchg to make sure
1756	 * we don't compete with remove_port.
1757	 */
1758	if (xchg(&port->cm_id, NULL) != cm_id)
1759		return 0;
1760
1761	/*
1762	 * We need to return 1 so that the core will destroy
1763	 * its own ID.  What a great API design..
1764	 */
1765	return 1;
1766}
1767
1768static int nvmet_rdma_cm_handler(struct rdma_cm_id *cm_id,
1769		struct rdma_cm_event *event)
1770{
1771	struct nvmet_rdma_queue *queue = NULL;
1772	int ret = 0;
1773
1774	if (cm_id->qp)
1775		queue = cm_id->qp->qp_context;
1776
1777	pr_debug("%s (%d): status %d id %p\n",
1778		rdma_event_msg(event->event), event->event,
1779		event->status, cm_id);
1780
1781	switch (event->event) {
1782	case RDMA_CM_EVENT_CONNECT_REQUEST:
1783		ret = nvmet_rdma_queue_connect(cm_id, event);
1784		break;
1785	case RDMA_CM_EVENT_ESTABLISHED:
1786		nvmet_rdma_queue_established(queue);
1787		break;
1788	case RDMA_CM_EVENT_ADDR_CHANGE:
1789		if (!queue) {
1790			struct nvmet_rdma_port *port = cm_id->context;
1791
1792			queue_delayed_work(nvmet_wq, &port->repair_work, 0);
1793			break;
1794		}
1795		fallthrough;
1796	case RDMA_CM_EVENT_DISCONNECTED:
1797	case RDMA_CM_EVENT_TIMEWAIT_EXIT:
1798		nvmet_rdma_queue_disconnect(queue);
1799		break;
1800	case RDMA_CM_EVENT_DEVICE_REMOVAL:
1801		ret = nvmet_rdma_device_removal(cm_id, queue);
1802		break;
1803	case RDMA_CM_EVENT_REJECTED:
1804		pr_debug("Connection rejected: %s\n",
1805			 rdma_reject_msg(cm_id, event->status));
1806		fallthrough;
1807	case RDMA_CM_EVENT_UNREACHABLE:
1808	case RDMA_CM_EVENT_CONNECT_ERROR:
1809		nvmet_rdma_queue_connect_fail(cm_id, queue);
1810		break;
1811	default:
1812		pr_err("received unrecognized RDMA CM event %d\n",
1813			event->event);
1814		break;
1815	}
1816
1817	return ret;
1818}
1819
1820static void nvmet_rdma_delete_ctrl(struct nvmet_ctrl *ctrl)
1821{
1822	struct nvmet_rdma_queue *queue, *n;
1823
1824	mutex_lock(&nvmet_rdma_queue_mutex);
1825	list_for_each_entry_safe(queue, n, &nvmet_rdma_queue_list, queue_list) {
1826		if (queue->nvme_sq.ctrl != ctrl)
1827			continue;
1828		list_del_init(&queue->queue_list);
1829		__nvmet_rdma_queue_disconnect(queue);
1830	}
1831	mutex_unlock(&nvmet_rdma_queue_mutex);
1832}
1833
1834static void nvmet_rdma_destroy_port_queues(struct nvmet_rdma_port *port)
1835{
1836	struct nvmet_rdma_queue *queue, *tmp;
1837	struct nvmet_port *nport = port->nport;
1838
1839	mutex_lock(&nvmet_rdma_queue_mutex);
1840	list_for_each_entry_safe(queue, tmp, &nvmet_rdma_queue_list,
1841				 queue_list) {
1842		if (queue->port != nport)
1843			continue;
1844
1845		list_del_init(&queue->queue_list);
1846		__nvmet_rdma_queue_disconnect(queue);
1847	}
1848	mutex_unlock(&nvmet_rdma_queue_mutex);
1849}
1850
1851static void nvmet_rdma_disable_port(struct nvmet_rdma_port *port)
1852{
1853	struct rdma_cm_id *cm_id = xchg(&port->cm_id, NULL);
1854
1855	if (cm_id)
1856		rdma_destroy_id(cm_id);
1857
1858	/*
1859	 * Destroy the remaining queues, which are not belong to any
1860	 * controller yet. Do it here after the RDMA-CM was destroyed
1861	 * guarantees that no new queue will be created.
1862	 */
1863	nvmet_rdma_destroy_port_queues(port);
1864}
1865
1866static int nvmet_rdma_enable_port(struct nvmet_rdma_port *port)
1867{
1868	struct sockaddr *addr = (struct sockaddr *)&port->addr;
1869	struct rdma_cm_id *cm_id;
1870	int ret;
1871
1872	cm_id = rdma_create_id(&init_net, nvmet_rdma_cm_handler, port,
1873			RDMA_PS_TCP, IB_QPT_RC);
1874	if (IS_ERR(cm_id)) {
1875		pr_err("CM ID creation failed\n");
1876		return PTR_ERR(cm_id);
1877	}
1878
1879	/*
1880	 * Allow both IPv4 and IPv6 sockets to bind a single port
1881	 * at the same time.
1882	 */
1883	ret = rdma_set_afonly(cm_id, 1);
1884	if (ret) {
1885		pr_err("rdma_set_afonly failed (%d)\n", ret);
1886		goto out_destroy_id;
1887	}
1888
1889	ret = rdma_bind_addr(cm_id, addr);
1890	if (ret) {
1891		pr_err("binding CM ID to %pISpcs failed (%d)\n", addr, ret);
1892		goto out_destroy_id;
1893	}
1894
1895	ret = rdma_listen(cm_id, NVMET_RDMA_BACKLOG);
1896	if (ret) {
1897		pr_err("listening to %pISpcs failed (%d)\n", addr, ret);
1898		goto out_destroy_id;
1899	}
1900
1901	port->cm_id = cm_id;
1902	return 0;
1903
1904out_destroy_id:
1905	rdma_destroy_id(cm_id);
1906	return ret;
1907}
1908
1909static void nvmet_rdma_repair_port_work(struct work_struct *w)
1910{
1911	struct nvmet_rdma_port *port = container_of(to_delayed_work(w),
1912			struct nvmet_rdma_port, repair_work);
1913	int ret;
1914
1915	nvmet_rdma_disable_port(port);
1916	ret = nvmet_rdma_enable_port(port);
1917	if (ret)
1918		queue_delayed_work(nvmet_wq, &port->repair_work, 5 * HZ);
1919}
1920
1921static int nvmet_rdma_add_port(struct nvmet_port *nport)
1922{
1923	struct nvmet_rdma_port *port;
1924	__kernel_sa_family_t af;
1925	int ret;
1926
1927	port = kzalloc(sizeof(*port), GFP_KERNEL);
1928	if (!port)
1929		return -ENOMEM;
1930
1931	nport->priv = port;
1932	port->nport = nport;
1933	INIT_DELAYED_WORK(&port->repair_work, nvmet_rdma_repair_port_work);
1934
1935	switch (nport->disc_addr.adrfam) {
1936	case NVMF_ADDR_FAMILY_IP4:
1937		af = AF_INET;
1938		break;
1939	case NVMF_ADDR_FAMILY_IP6:
1940		af = AF_INET6;
1941		break;
1942	default:
1943		pr_err("address family %d not supported\n",
1944			nport->disc_addr.adrfam);
1945		ret = -EINVAL;
1946		goto out_free_port;
1947	}
1948
1949	if (nport->inline_data_size < 0) {
1950		nport->inline_data_size = NVMET_RDMA_DEFAULT_INLINE_DATA_SIZE;
1951	} else if (nport->inline_data_size > NVMET_RDMA_MAX_INLINE_DATA_SIZE) {
1952		pr_warn("inline_data_size %u is too large, reducing to %u\n",
1953			nport->inline_data_size,
1954			NVMET_RDMA_MAX_INLINE_DATA_SIZE);
1955		nport->inline_data_size = NVMET_RDMA_MAX_INLINE_DATA_SIZE;
1956	}
1957
1958	if (nport->max_queue_size < 0) {
1959		nport->max_queue_size = NVME_RDMA_DEFAULT_QUEUE_SIZE;
1960	} else if (nport->max_queue_size > NVME_RDMA_MAX_QUEUE_SIZE) {
1961		pr_warn("max_queue_size %u is too large, reducing to %u\n",
1962			nport->max_queue_size, NVME_RDMA_MAX_QUEUE_SIZE);
1963		nport->max_queue_size = NVME_RDMA_MAX_QUEUE_SIZE;
1964	}
1965
1966	ret = inet_pton_with_scope(&init_net, af, nport->disc_addr.traddr,
1967			nport->disc_addr.trsvcid, &port->addr);
1968	if (ret) {
1969		pr_err("malformed ip/port passed: %s:%s\n",
1970			nport->disc_addr.traddr, nport->disc_addr.trsvcid);
1971		goto out_free_port;
1972	}
1973
1974	ret = nvmet_rdma_enable_port(port);
1975	if (ret)
1976		goto out_free_port;
1977
1978	pr_info("enabling port %d (%pISpcs)\n",
1979		le16_to_cpu(nport->disc_addr.portid),
1980		(struct sockaddr *)&port->addr);
1981
1982	return 0;
1983
1984out_free_port:
1985	kfree(port);
1986	return ret;
1987}
1988
1989static void nvmet_rdma_remove_port(struct nvmet_port *nport)
1990{
1991	struct nvmet_rdma_port *port = nport->priv;
1992
1993	cancel_delayed_work_sync(&port->repair_work);
1994	nvmet_rdma_disable_port(port);
1995	kfree(port);
1996}
1997
1998static void nvmet_rdma_disc_port_addr(struct nvmet_req *req,
1999		struct nvmet_port *nport, char *traddr)
2000{
2001	struct nvmet_rdma_port *port = nport->priv;
2002	struct rdma_cm_id *cm_id = port->cm_id;
2003
2004	if (inet_addr_is_any(&cm_id->route.addr.src_addr)) {
2005		struct nvmet_rdma_rsp *rsp =
2006			container_of(req, struct nvmet_rdma_rsp, req);
2007		struct rdma_cm_id *req_cm_id = rsp->queue->cm_id;
2008		struct sockaddr *addr = (void *)&req_cm_id->route.addr.src_addr;
2009
2010		sprintf(traddr, "%pISc", addr);
2011	} else {
2012		memcpy(traddr, nport->disc_addr.traddr, NVMF_TRADDR_SIZE);
2013	}
2014}
2015
2016static ssize_t nvmet_rdma_host_port_addr(struct nvmet_ctrl *ctrl,
2017		char *traddr, size_t traddr_len)
2018{
2019	struct nvmet_sq *nvme_sq = ctrl->sqs[0];
2020	struct nvmet_rdma_queue *queue =
2021		container_of(nvme_sq, struct nvmet_rdma_queue, nvme_sq);
2022
2023	return snprintf(traddr, traddr_len, "%pISc",
2024			(struct sockaddr *)&queue->cm_id->route.addr.dst_addr);
2025}
2026
2027static u8 nvmet_rdma_get_mdts(const struct nvmet_ctrl *ctrl)
2028{
2029	if (ctrl->pi_support)
2030		return NVMET_RDMA_MAX_METADATA_MDTS;
2031	return NVMET_RDMA_MAX_MDTS;
2032}
2033
2034static u16 nvmet_rdma_get_max_queue_size(const struct nvmet_ctrl *ctrl)
2035{
2036	if (ctrl->pi_support)
2037		return NVME_RDMA_MAX_METADATA_QUEUE_SIZE;
2038	return NVME_RDMA_MAX_QUEUE_SIZE;
2039}
2040
2041static const struct nvmet_fabrics_ops nvmet_rdma_ops = {
2042	.owner			= THIS_MODULE,
2043	.type			= NVMF_TRTYPE_RDMA,
2044	.msdbd			= 1,
2045	.flags			= NVMF_KEYED_SGLS | NVMF_METADATA_SUPPORTED,
2046	.add_port		= nvmet_rdma_add_port,
2047	.remove_port		= nvmet_rdma_remove_port,
2048	.queue_response		= nvmet_rdma_queue_response,
2049	.delete_ctrl		= nvmet_rdma_delete_ctrl,
2050	.disc_traddr		= nvmet_rdma_disc_port_addr,
2051	.host_traddr		= nvmet_rdma_host_port_addr,
2052	.get_mdts		= nvmet_rdma_get_mdts,
2053	.get_max_queue_size	= nvmet_rdma_get_max_queue_size,
2054};
2055
2056static void nvmet_rdma_remove_one(struct ib_device *ib_device, void *client_data)
2057{
2058	struct nvmet_rdma_queue *queue, *tmp;
2059	struct nvmet_rdma_device *ndev;
2060	bool found = false;
2061
2062	mutex_lock(&device_list_mutex);
2063	list_for_each_entry(ndev, &device_list, entry) {
2064		if (ndev->device == ib_device) {
2065			found = true;
2066			break;
2067		}
2068	}
2069	mutex_unlock(&device_list_mutex);
2070
2071	if (!found)
2072		return;
2073
2074	/*
2075	 * IB Device that is used by nvmet controllers is being removed,
2076	 * delete all queues using this device.
2077	 */
2078	mutex_lock(&nvmet_rdma_queue_mutex);
2079	list_for_each_entry_safe(queue, tmp, &nvmet_rdma_queue_list,
2080				 queue_list) {
2081		if (queue->dev->device != ib_device)
2082			continue;
2083
2084		pr_info("Removing queue %d\n", queue->idx);
2085		list_del_init(&queue->queue_list);
2086		__nvmet_rdma_queue_disconnect(queue);
2087	}
2088	mutex_unlock(&nvmet_rdma_queue_mutex);
2089
2090	flush_workqueue(nvmet_wq);
2091	flush_workqueue(nvmet_aen_wq);
2092}
2093
2094static struct ib_client nvmet_rdma_ib_client = {
2095	.name   = "nvmet_rdma",
2096	.remove = nvmet_rdma_remove_one
2097};
2098
2099static int __init nvmet_rdma_init(void)
2100{
2101	int ret;
2102
2103	ret = ib_register_client(&nvmet_rdma_ib_client);
2104	if (ret)
2105		return ret;
2106
2107	ret = nvmet_register_transport(&nvmet_rdma_ops);
2108	if (ret)
2109		goto err_ib_client;
2110
2111	return 0;
2112
2113err_ib_client:
2114	ib_unregister_client(&nvmet_rdma_ib_client);
2115	return ret;
2116}
2117
2118static void __exit nvmet_rdma_exit(void)
2119{
2120	nvmet_unregister_transport(&nvmet_rdma_ops);
2121	ib_unregister_client(&nvmet_rdma_ib_client);
2122	WARN_ON_ONCE(!list_empty(&nvmet_rdma_queue_list));
2123	ida_destroy(&nvmet_rdma_queue_ida);
2124}
2125
2126module_init(nvmet_rdma_init);
2127module_exit(nvmet_rdma_exit);
2128
2129MODULE_DESCRIPTION("NVMe target RDMA transport driver");
2130MODULE_LICENSE("GPL v2");
2131MODULE_ALIAS("nvmet-transport-1"); /* 1 == NVMF_TRTYPE_RDMA */