blob: 8ae7a3beddb728ee22825e28382b37bc467bbe94 [file] [log] [blame]
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001/*
2 * Copyright (c) 2004, 2005, 2006 Voltaire, Inc. All rights reserved.
3 * Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
Or Gerlitz3ee07d22014-04-01 16:28:41 +03004 * Copyright (c) 2013-2014 Mellanox Technologies. All rights reserved.
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03005 *
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030033 */
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030034#include <linux/kernel.h>
35#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/slab.h>
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030037#include <linux/delay.h>
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030038
39#include "iscsi_iser.h"
40
41#define ISCSI_ISER_MAX_CONN 8
Sagi Grimberg6aabfa72014-10-01 14:02:09 +030042#define ISER_MAX_RX_LEN (ISER_QP_MAX_RECV_DTOS * ISCSI_ISER_MAX_CONN)
43#define ISER_MAX_TX_LEN (ISER_QP_MAX_REQ_DTOS * ISCSI_ISER_MAX_CONN)
Sagi Grimbergff3dd522014-10-01 14:02:10 +030044#define ISER_MAX_CQ_LEN (ISER_MAX_RX_LEN + ISER_MAX_TX_LEN + \
45 ISCSI_ISER_MAX_CONN)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030046
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030047static void iser_qp_event_callback(struct ib_event *cause, void *context)
48{
Sagi Grimberg871e00a2015-05-18 13:40:30 +030049 iser_err("qp event %s (%d)\n",
50 ib_event_msg(cause->event), cause->event);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030051}
52
Or Gerlitz2110f9b2010-05-05 17:30:10 +030053static void iser_event_handler(struct ib_event_handler *handler,
54 struct ib_event *event)
55{
Sagi Grimberg871e00a2015-05-18 13:40:30 +030056 iser_err("async event %s (%d) on device %s port %d\n",
57 ib_event_msg(event->event), event->event,
58 event->device->name, event->element.port_num);
Or Gerlitz2110f9b2010-05-05 17:30:10 +030059}
60
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030061/**
62 * iser_create_device_ib_res - creates Protection Domain (PD), Completion
63 * Queue (CQ), DMA Memory Region (DMA MR) with the device associated with
64 * the adapator.
65 *
66 * returns 0 on success, -1 on failure
67 */
68static int iser_create_device_ib_res(struct iser_device *device)
69{
Or Gerlitz4a061b22015-12-18 10:59:46 +020070 struct ib_device *ib_dev = device->ib_device;
Minh Tranf4641ef2014-12-07 16:09:52 +020071 int ret, i, max_cqe;
Alex Tabachnik5a33a662012-09-23 15:17:44 +000072
Sagi Grimberg48afbff2015-08-06 18:32:56 +030073 ret = iser_assign_reg_ops(device);
74 if (ret)
75 return ret;
Sagi Grimbergb4e155f2013-07-28 12:35:39 +030076
Sagi Grimbergda64bdb2014-12-07 16:10:03 +020077 device->comps_used = min_t(int, num_online_cpus(),
Or Gerlitz4a061b22015-12-18 10:59:46 +020078 ib_dev->num_comp_vectors);
Minh Tranf4641ef2014-12-07 16:09:52 +020079
Sagi Grimbergda64bdb2014-12-07 16:10:03 +020080 device->comps = kcalloc(device->comps_used, sizeof(*device->comps),
81 GFP_KERNEL);
82 if (!device->comps)
83 goto comps_err;
84
Or Gerlitz4a061b22015-12-18 10:59:46 +020085 max_cqe = min(ISER_MAX_CQ_LEN, ib_dev->attrs.max_cqe);
Minh Tranf4641ef2014-12-07 16:09:52 +020086
87 iser_info("using %d CQs, device %s supports %d vectors max_cqe %d\n",
Or Gerlitz4a061b22015-12-18 10:59:46 +020088 device->comps_used, ib_dev->name,
89 ib_dev->num_comp_vectors, max_cqe);
Alex Tabachnik5a33a662012-09-23 15:17:44 +000090
Christoph Hellwig8e612122016-09-05 12:56:18 +020091 device->pd = ib_alloc_pd(ib_dev,
92 iser_always_reg ? 0 : IB_PD_UNSAFE_GLOBAL_RKEY);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030093 if (IS_ERR(device->pd))
94 goto pd_err;
95
Sagi Grimbergbf175542014-10-01 14:02:07 +030096 for (i = 0; i < device->comps_used; i++) {
97 struct iser_comp *comp = &device->comps[i];
Or Gerlitz1cfa0a72006-05-11 10:02:46 +030098
Doug Ledford882f3b32015-12-22 17:03:15 -050099 comp->cq = ib_alloc_cq(ib_dev, comp, max_cqe, i,
100 IB_POLL_SOFTIRQ);
Sagi Grimberg6aabfa72014-10-01 14:02:09 +0300101 if (IS_ERR(comp->cq)) {
102 comp->cq = NULL;
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000103 goto cq_err;
Roi Dayanc33b15f2014-09-02 17:08:41 +0300104 }
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000105 }
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300106
Doug Ledford882f3b32015-12-22 17:03:15 -0500107 INIT_IB_EVENT_HANDLER(&device->event_handler, ib_dev,
108 iser_event_handler);
Or Gerlitz2110f9b2010-05-05 17:30:10 +0300109 if (ib_register_event_handler(&device->event_handler))
Christoph Hellwig8e612122016-09-05 12:56:18 +0200110 goto cq_err;
Or Gerlitz2110f9b2010-05-05 17:30:10 +0300111
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300112 return 0;
113
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000114cq_err:
Sagi Grimbergbf175542014-10-01 14:02:07 +0300115 for (i = 0; i < device->comps_used; i++) {
116 struct iser_comp *comp = &device->comps[i];
117
Sagi Grimberg6aabfa72014-10-01 14:02:09 +0300118 if (comp->cq)
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -0800119 ib_free_cq(comp->cq);
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000120 }
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300121 ib_dealloc_pd(device->pd);
122pd_err:
Sagi Grimbergda64bdb2014-12-07 16:10:03 +0200123 kfree(device->comps);
124comps_err:
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300125 iser_err("failed to allocate an IB resource\n");
126 return -1;
127}
128
129/**
Oliver Pinter38dc7322008-01-25 14:15:32 -0800130 * iser_free_device_ib_res - destroy/dealloc/dereg the DMA MR,
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300131 * CQ and PD created with the device associated with the adapator.
132 */
133static void iser_free_device_ib_res(struct iser_device *device)
134{
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000135 int i;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300136
Sagi Grimbergbf175542014-10-01 14:02:07 +0300137 for (i = 0; i < device->comps_used; i++) {
138 struct iser_comp *comp = &device->comps[i];
139
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -0800140 ib_free_cq(comp->cq);
Sagi Grimberg6aabfa72014-10-01 14:02:09 +0300141 comp->cq = NULL;
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000142 }
143
Or Gerlitz2110f9b2010-05-05 17:30:10 +0300144 (void)ib_unregister_event_handler(&device->event_handler);
Jason Gunthorpe7dd78642015-08-05 14:34:31 -0600145 ib_dealloc_pd(device->pd);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300146
Sagi Grimbergda64bdb2014-12-07 16:10:03 +0200147 kfree(device->comps);
148 device->comps = NULL;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300149 device->pd = NULL;
150}
151
152/**
Sagi Grimberg48afbff2015-08-06 18:32:56 +0300153 * iser_alloc_fmr_pool - Creates FMR pool and page_vector
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300154 *
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300155 * returns 0 on success, or errno code on failure
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300156 */
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300157int iser_alloc_fmr_pool(struct ib_conn *ib_conn,
158 unsigned cmds_max,
159 unsigned int size)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300160{
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300161 struct iser_device *device = ib_conn->device;
Sagi Grimberg385ad872015-08-06 18:32:58 +0300162 struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
163 struct iser_page_vec *page_vec;
Adir Lev2b3bf952015-08-06 18:32:59 +0300164 struct iser_fr_desc *desc;
Sagi Grimberg385ad872015-08-06 18:32:58 +0300165 struct ib_fmr_pool *fmr_pool;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300166 struct ib_fmr_pool_param params;
Adir Lev2b3bf952015-08-06 18:32:59 +0300167 int ret;
Or Gerlitzbcc60c32010-02-08 13:17:42 +0000168
Adir Lev2b3bf952015-08-06 18:32:59 +0300169 INIT_LIST_HEAD(&fr_pool->list);
Sagi Grimberg385ad872015-08-06 18:32:58 +0300170 spin_lock_init(&fr_pool->lock);
171
Adir Lev2b3bf952015-08-06 18:32:59 +0300172 desc = kzalloc(sizeof(*desc), GFP_KERNEL);
173 if (!desc)
174 return -ENOMEM;
175
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300176 page_vec = kmalloc(sizeof(*page_vec) + (sizeof(u64) * size),
Sagi Grimberg385ad872015-08-06 18:32:58 +0300177 GFP_KERNEL);
Adir Lev2b3bf952015-08-06 18:32:59 +0300178 if (!page_vec) {
179 ret = -ENOMEM;
180 goto err_frpl;
181 }
Dan Carpenter9fda1ac2010-05-06 16:22:21 +0300182
Sagi Grimberg385ad872015-08-06 18:32:58 +0300183 page_vec->pages = (u64 *)(page_vec + 1);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300184
Erez Zilber8dfa0872006-09-11 12:22:30 +0300185 params.page_shift = SHIFT_4K;
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300186 params.max_pages_per_fmr = size;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300187 /* make the pool size twice the max number of SCSI commands *
188 * the ML is expected to queue, watermark for unmap at 50% */
Shlomo Pongratzb7f04512013-07-28 12:35:38 +0300189 params.pool_size = cmds_max * 2;
190 params.dirty_watermark = cmds_max;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300191 params.cache = 0;
192 params.flush_function = NULL;
193 params.access = (IB_ACCESS_LOCAL_WRITE |
194 IB_ACCESS_REMOTE_WRITE |
195 IB_ACCESS_REMOTE_READ);
196
Sagi Grimberg385ad872015-08-06 18:32:58 +0300197 fmr_pool = ib_create_fmr_pool(device->pd, &params);
198 if (IS_ERR(fmr_pool)) {
199 ret = PTR_ERR(fmr_pool);
Sagi Grimberg8c18ed02015-08-06 18:32:55 +0300200 iser_err("FMR allocation failed, err %d\n", ret);
Adir Lev2b3bf952015-08-06 18:32:59 +0300201 goto err_fmr;
Sagi Grimberg8c18ed02015-08-06 18:32:55 +0300202 }
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300203
Adir Lev2b3bf952015-08-06 18:32:59 +0300204 desc->rsc.page_vec = page_vec;
205 desc->rsc.fmr_pool = fmr_pool;
206 list_add(&desc->list, &fr_pool->list);
Sagi Grimberg385ad872015-08-06 18:32:58 +0300207
Sagi Grimberg8c18ed02015-08-06 18:32:55 +0300208 return 0;
209
Adir Lev2b3bf952015-08-06 18:32:59 +0300210err_fmr:
Sagi Grimberg385ad872015-08-06 18:32:58 +0300211 kfree(page_vec);
Adir Lev2b3bf952015-08-06 18:32:59 +0300212err_frpl:
213 kfree(desc);
214
Sagi Grimberg8c18ed02015-08-06 18:32:55 +0300215 return ret;
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300216}
217
218/**
219 * iser_free_fmr_pool - releases the FMR pool and page vec
220 */
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300221void iser_free_fmr_pool(struct ib_conn *ib_conn)
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300222{
Sagi Grimberg385ad872015-08-06 18:32:58 +0300223 struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
Adir Lev2b3bf952015-08-06 18:32:59 +0300224 struct iser_fr_desc *desc;
225
226 desc = list_first_entry(&fr_pool->list,
227 struct iser_fr_desc, list);
228 list_del(&desc->list);
Sagi Grimberg385ad872015-08-06 18:32:58 +0300229
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300230 iser_info("freeing conn %p fmr pool %p\n",
Adir Lev2b3bf952015-08-06 18:32:59 +0300231 ib_conn, desc->rsc.fmr_pool);
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300232
Adir Lev2b3bf952015-08-06 18:32:59 +0300233 ib_destroy_fmr_pool(desc->rsc.fmr_pool);
234 kfree(desc->rsc.page_vec);
235 kfree(desc);
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300236}
237
Sagi Grimberg310b3472014-03-05 19:43:41 +0200238static int
Sagi Grimberg318d3112016-02-29 19:07:34 +0200239iser_alloc_reg_res(struct iser_device *device,
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300240 struct ib_pd *pd,
241 struct iser_reg_resources *res,
242 unsigned int size)
Sagi Grimbergd711d812015-08-06 18:32:53 +0300243{
Sagi Grimberg318d3112016-02-29 19:07:34 +0200244 struct ib_device *ib_dev = device->ib_device;
245 enum ib_mr_type mr_type;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300246 int ret;
247
Sagi Grimberg318d3112016-02-29 19:07:34 +0200248 if (ib_dev->attrs.device_cap_flags & IB_DEVICE_SG_GAPS_REG)
249 mr_type = IB_MR_TYPE_SG_GAPS;
250 else
251 mr_type = IB_MR_TYPE_MEM_REG;
252
253 res->mr = ib_alloc_mr(pd, mr_type, size);
Sagi Grimbergd711d812015-08-06 18:32:53 +0300254 if (IS_ERR(res->mr)) {
255 ret = PTR_ERR(res->mr);
256 iser_err("Failed to allocate ib_fast_reg_mr err=%d\n", ret);
Sagi Grimberg39405882015-10-13 19:11:33 +0300257 return ret;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300258 }
Jenny Derzhavetz1caa70d82015-12-09 14:12:02 +0200259 res->mr_valid = 0;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300260
261 return 0;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300262}
263
264static void
265iser_free_reg_res(struct iser_reg_resources *rsc)
266{
267 ib_dereg_mr(rsc->mr);
Sagi Grimbergd711d812015-08-06 18:32:53 +0300268}
269
270static int
Sagi Grimberg318d3112016-02-29 19:07:34 +0200271iser_alloc_pi_ctx(struct iser_device *device,
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300272 struct ib_pd *pd,
273 struct iser_fr_desc *desc,
274 unsigned int size)
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300275{
276 struct iser_pi_context *pi_ctx = NULL;
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300277 int ret;
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300278
279 desc->pi_ctx = kzalloc(sizeof(*desc->pi_ctx), GFP_KERNEL);
280 if (!desc->pi_ctx)
281 return -ENOMEM;
282
283 pi_ctx = desc->pi_ctx;
284
Sagi Grimberg318d3112016-02-29 19:07:34 +0200285 ret = iser_alloc_reg_res(device, pd, &pi_ctx->rsc, size);
Sagi Grimbergd711d812015-08-06 18:32:53 +0300286 if (ret) {
287 iser_err("failed to allocate reg_resources\n");
288 goto alloc_reg_res_err;
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300289 }
290
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300291 pi_ctx->sig_mr = ib_alloc_mr(pd, IB_MR_TYPE_SIGNATURE, 2);
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300292 if (IS_ERR(pi_ctx->sig_mr)) {
293 ret = PTR_ERR(pi_ctx->sig_mr);
294 goto sig_mr_failure;
295 }
Jenny Derzhavetz1caa70d82015-12-09 14:12:02 +0200296 pi_ctx->sig_mr_valid = 0;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300297 desc->pi_ctx->sig_protected = 0;
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300298
299 return 0;
300
301sig_mr_failure:
Sagi Grimbergd711d812015-08-06 18:32:53 +0300302 iser_free_reg_res(&pi_ctx->rsc);
303alloc_reg_res_err:
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300304 kfree(desc->pi_ctx);
305
306 return ret;
307}
308
309static void
310iser_free_pi_ctx(struct iser_pi_context *pi_ctx)
311{
Sagi Grimbergd711d812015-08-06 18:32:53 +0300312 iser_free_reg_res(&pi_ctx->rsc);
Sagi Grimberg8b91ffc2015-07-30 10:32:34 +0300313 ib_dereg_mr(pi_ctx->sig_mr);
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300314 kfree(pi_ctx);
315}
316
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300317static struct iser_fr_desc *
Sagi Grimberg318d3112016-02-29 19:07:34 +0200318iser_create_fastreg_desc(struct iser_device *device,
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300319 struct ib_pd *pd,
320 bool pi_enable,
321 unsigned int size)
Sagi Grimberg310b3472014-03-05 19:43:41 +0200322{
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300323 struct iser_fr_desc *desc;
Sagi Grimberg310b3472014-03-05 19:43:41 +0200324 int ret;
325
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300326 desc = kzalloc(sizeof(*desc), GFP_KERNEL);
327 if (!desc)
328 return ERR_PTR(-ENOMEM);
329
Sagi Grimberg318d3112016-02-29 19:07:34 +0200330 ret = iser_alloc_reg_res(device, pd, &desc->rsc, size);
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300331 if (ret)
332 goto reg_res_alloc_failure;
Sagi Grimberg310b3472014-03-05 19:43:41 +0200333
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200334 if (pi_enable) {
Sagi Grimberg318d3112016-02-29 19:07:34 +0200335 ret = iser_alloc_pi_ctx(device, pd, desc, size);
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300336 if (ret)
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200337 goto pi_ctx_alloc_failure;
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200338 }
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200339
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300340 return desc;
Sagi Grimbergd711d812015-08-06 18:32:53 +0300341
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200342pi_ctx_alloc_failure:
Sagi Grimbergd711d812015-08-06 18:32:53 +0300343 iser_free_reg_res(&desc->rsc);
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300344reg_res_alloc_failure:
345 kfree(desc);
Sagi Grimberg310b3472014-03-05 19:43:41 +0200346
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300347 return ERR_PTR(ret);
Sagi Grimberg310b3472014-03-05 19:43:41 +0200348}
349
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300350/**
Sagi Grimberg48afbff2015-08-06 18:32:56 +0300351 * iser_alloc_fastreg_pool - Creates pool of fast_reg descriptors
Sagi Grimberg55878562013-07-28 12:35:42 +0300352 * for fast registration work requests.
353 * returns 0 on success, or errno code on failure
354 */
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300355int iser_alloc_fastreg_pool(struct ib_conn *ib_conn,
356 unsigned cmds_max,
357 unsigned int size)
Sagi Grimberg55878562013-07-28 12:35:42 +0300358{
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300359 struct iser_device *device = ib_conn->device;
Sagi Grimberg385ad872015-08-06 18:32:58 +0300360 struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
Sagi Grimberg5190cc22015-08-06 18:32:54 +0300361 struct iser_fr_desc *desc;
Sagi Grimberg55878562013-07-28 12:35:42 +0300362 int i, ret;
363
Adir Lev2b3bf952015-08-06 18:32:59 +0300364 INIT_LIST_HEAD(&fr_pool->list);
Sagi Grimberg385ad872015-08-06 18:32:58 +0300365 spin_lock_init(&fr_pool->lock);
Adir Lev2b3bf952015-08-06 18:32:59 +0300366 fr_pool->size = 0;
Sagi Grimberg55878562013-07-28 12:35:42 +0300367 for (i = 0; i < cmds_max; i++) {
Sagi Grimberg318d3112016-02-29 19:07:34 +0200368 desc = iser_create_fastreg_desc(device, device->pd,
Sagi Grimbergf8db6512015-08-06 18:33:03 +0300369 ib_conn->pi_support, size);
Sagi Grimbergeb6ea8c32015-08-06 18:32:57 +0300370 if (IS_ERR(desc)) {
371 ret = PTR_ERR(desc);
Sagi Grimberg310b3472014-03-05 19:43:41 +0200372 goto err;
Sagi Grimberg55878562013-07-28 12:35:42 +0300373 }
374
Adir Lev2b3bf952015-08-06 18:32:59 +0300375 list_add_tail(&desc->list, &fr_pool->list);
376 fr_pool->size++;
Sagi Grimberg55878562013-07-28 12:35:42 +0300377 }
378
379 return 0;
Roi Dayan27ae2d12013-08-19 16:41:51 +0300380
Sagi Grimberg55878562013-07-28 12:35:42 +0300381err:
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300382 iser_free_fastreg_pool(ib_conn);
Sagi Grimberg55878562013-07-28 12:35:42 +0300383 return ret;
384}
385
386/**
Sagi Grimberg7306b8f2014-03-05 19:43:39 +0200387 * iser_free_fastreg_pool - releases the pool of fast_reg descriptors
Sagi Grimberg55878562013-07-28 12:35:42 +0300388 */
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300389void iser_free_fastreg_pool(struct ib_conn *ib_conn)
Sagi Grimberg55878562013-07-28 12:35:42 +0300390{
Sagi Grimberg385ad872015-08-06 18:32:58 +0300391 struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
Sagi Grimberg5190cc22015-08-06 18:32:54 +0300392 struct iser_fr_desc *desc, *tmp;
Sagi Grimberg55878562013-07-28 12:35:42 +0300393 int i = 0;
394
Adir Lev2b3bf952015-08-06 18:32:59 +0300395 if (list_empty(&fr_pool->list))
Sagi Grimberg55878562013-07-28 12:35:42 +0300396 return;
397
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300398 iser_info("freeing conn %p fr pool\n", ib_conn);
Sagi Grimberg55878562013-07-28 12:35:42 +0300399
Adir Lev2b3bf952015-08-06 18:32:59 +0300400 list_for_each_entry_safe(desc, tmp, &fr_pool->list, list) {
Sagi Grimberg55878562013-07-28 12:35:42 +0300401 list_del(&desc->list);
Sagi Grimbergd711d812015-08-06 18:32:53 +0300402 iser_free_reg_res(&desc->rsc);
Sagi Grimberg4dec2a22015-04-14 18:08:22 +0300403 if (desc->pi_ctx)
404 iser_free_pi_ctx(desc->pi_ctx);
Sagi Grimberg55878562013-07-28 12:35:42 +0300405 kfree(desc);
406 ++i;
407 }
408
Adir Lev2b3bf952015-08-06 18:32:59 +0300409 if (i < fr_pool->size)
Sagi Grimberg55878562013-07-28 12:35:42 +0300410 iser_warn("pool still has %d regions registered\n",
Adir Lev2b3bf952015-08-06 18:32:59 +0300411 fr_pool->size - i);
Sagi Grimberg55878562013-07-28 12:35:42 +0300412}
413
414/**
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300415 * iser_create_ib_conn_res - Queue-Pair (QP)
416 *
417 * returns 0 on success, -1 on failure
418 */
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300419static int iser_create_ib_conn_res(struct ib_conn *ib_conn)
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300420{
Sagi Grimberg7edc5a92015-11-04 10:50:32 +0200421 struct iser_conn *iser_conn = to_iser_conn(ib_conn);
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300422 struct iser_device *device;
Or Gerlitz4a061b22015-12-18 10:59:46 +0200423 struct ib_device *ib_dev;
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300424 struct ib_qp_init_attr init_attr;
425 int ret = -ENOMEM;
426 int index, min_index = 0;
427
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300428 BUG_ON(ib_conn->device == NULL);
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300429
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300430 device = ib_conn->device;
Or Gerlitz4a061b22015-12-18 10:59:46 +0200431 ib_dev = device->ib_device;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300432
433 memset(&init_attr, 0, sizeof init_attr);
434
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000435 mutex_lock(&ig.connlist_mutex);
436 /* select the CQ with the minimal number of usages */
Sagi Grimbergbf175542014-10-01 14:02:07 +0300437 for (index = 0; index < device->comps_used; index++) {
438 if (device->comps[index].active_qps <
439 device->comps[min_index].active_qps)
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000440 min_index = index;
Sagi Grimbergbf175542014-10-01 14:02:07 +0300441 }
442 ib_conn->comp = &device->comps[min_index];
443 ib_conn->comp->active_qps++;
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000444 mutex_unlock(&ig.connlist_mutex);
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300445 iser_info("cq index %d used for ib_conn %p\n", min_index, ib_conn);
Alex Tabachnik5a33a662012-09-23 15:17:44 +0000446
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300447 init_attr.event_handler = iser_qp_event_callback;
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300448 init_attr.qp_context = (void *)ib_conn;
Sagi Grimberg6aabfa72014-10-01 14:02:09 +0300449 init_attr.send_cq = ib_conn->comp->cq;
450 init_attr.recv_cq = ib_conn->comp->cq;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300451 init_attr.cap.max_recv_wr = ISER_QP_MAX_RECV_DTOS;
Or Gerlitzf19624a2010-02-08 13:19:56 +0000452 init_attr.cap.max_send_sge = 2;
Or Gerlitzbcc60c32010-02-08 13:17:42 +0000453 init_attr.cap.max_recv_sge = 1;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300454 init_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
455 init_attr.qp_type = IB_QPT_RC;
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300456 if (ib_conn->pi_support) {
Sagi Grimbergff3dd522014-10-01 14:02:10 +0300457 init_attr.cap.max_send_wr = ISER_QP_SIG_MAX_REQ_DTOS + 1;
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200458 init_attr.create_flags |= IB_QP_CREATE_SIGNATURE_EN;
Minh Tranf4641ef2014-12-07 16:09:52 +0200459 iser_conn->max_cmds =
460 ISER_GET_MAX_XMIT_CMDS(ISER_QP_SIG_MAX_REQ_DTOS);
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200461 } else {
Or Gerlitz4a061b22015-12-18 10:59:46 +0200462 if (ib_dev->attrs.max_qp_wr > ISER_QP_MAX_REQ_DTOS) {
Minh Tranf4641ef2014-12-07 16:09:52 +0200463 init_attr.cap.max_send_wr = ISER_QP_MAX_REQ_DTOS + 1;
464 iser_conn->max_cmds =
465 ISER_GET_MAX_XMIT_CMDS(ISER_QP_MAX_REQ_DTOS);
466 } else {
Or Gerlitz4a061b22015-12-18 10:59:46 +0200467 init_attr.cap.max_send_wr = ib_dev->attrs.max_qp_wr;
Minh Tranf4641ef2014-12-07 16:09:52 +0200468 iser_conn->max_cmds =
Or Gerlitz4a061b22015-12-18 10:59:46 +0200469 ISER_GET_MAX_XMIT_CMDS(ib_dev->attrs.max_qp_wr);
Minh Tranf4641ef2014-12-07 16:09:52 +0200470 iser_dbg("device %s supports max_send_wr %d\n",
Or Gerlitz4a061b22015-12-18 10:59:46 +0200471 device->ib_device->name, ib_dev->attrs.max_qp_wr);
Minh Tranf4641ef2014-12-07 16:09:52 +0200472 }
Alex Tabachnik6b5a8fb2014-03-05 19:43:47 +0200473 }
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300474
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300475 ret = rdma_create_qp(ib_conn->cma_id, device->pd, &init_attr);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300476 if (ret)
Dan Carpenter9fda1ac2010-05-06 16:22:21 +0300477 goto out_err;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300478
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300479 ib_conn->qp = ib_conn->cma_id->qp;
Shlomo Pongratz986db0d2013-07-28 12:35:37 +0300480 iser_info("setting conn %p cma_id %p qp %p\n",
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300481 ib_conn, ib_conn->cma_id,
482 ib_conn->cma_id->qp);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300483 return ret;
484
Dan Carpenter9fda1ac2010-05-06 16:22:21 +0300485out_err:
Sagi Grimberg93acb7b2014-12-07 16:09:55 +0200486 mutex_lock(&ig.connlist_mutex);
487 ib_conn->comp->active_qps--;
488 mutex_unlock(&ig.connlist_mutex);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300489 iser_err("unable to alloc mem or create resource, err %d\n", ret);
Sagi Grimberg93acb7b2014-12-07 16:09:55 +0200490
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300491 return ret;
492}
493
494/**
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300495 * based on the resolved device node GUID see if there already allocated
496 * device for this device. If there's no such, create one.
497 */
498static
499struct iser_device *iser_device_find_by_ib_device(struct rdma_cm_id *cma_id)
500{
Arne Redlich9a378272008-03-04 14:07:22 +0200501 struct iser_device *device;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300502
503 mutex_lock(&ig.device_list_mutex);
504
Arne Redlich9a378272008-03-04 14:07:22 +0200505 list_for_each_entry(device, &ig.device_list, ig_list)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300506 /* find if there's a match using the node GUID */
507 if (device->ib_device->node_guid == cma_id->device->node_guid)
Arne Redlichd33ed422008-03-04 14:11:54 +0200508 goto inc_refcnt;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300509
Arne Redlich9a378272008-03-04 14:07:22 +0200510 device = kzalloc(sizeof *device, GFP_KERNEL);
511 if (device == NULL)
512 goto out;
513
514 /* assign this device to the device */
515 device->ib_device = cma_id->device;
516 /* init the device and link it into ig device list */
517 if (iser_create_device_ib_res(device)) {
518 kfree(device);
519 device = NULL;
520 goto out;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300521 }
Arne Redlich9a378272008-03-04 14:07:22 +0200522 list_add(&device->ig_list, &ig.device_list);
523
Arne Redlichd33ed422008-03-04 14:11:54 +0200524inc_refcnt:
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300525 device->refcount++;
Arne Redlichd33ed422008-03-04 14:11:54 +0200526out:
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300527 mutex_unlock(&ig.device_list_mutex);
528 return device;
529}
530
531/* if there's no demand for this device, release it */
532static void iser_device_try_release(struct iser_device *device)
533{
534 mutex_lock(&ig.device_list_mutex);
535 device->refcount--;
Roi Dayan4f363882013-05-01 13:25:25 +0000536 iser_info("device %p refcount %d\n", device, device->refcount);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300537 if (!device->refcount) {
538 iser_free_device_ib_res(device);
539 list_del(&device->ig_list);
540 kfree(device);
541 }
542 mutex_unlock(&ig.device_list_mutex);
543}
544
Ariel Nahum504130c2014-07-31 13:27:49 +0300545/**
546 * Called with state mutex held
547 **/
Sagi Grimberg5716af62014-10-01 14:01:57 +0300548static int iser_conn_state_comp_exch(struct iser_conn *iser_conn,
549 enum iser_conn_state comp,
550 enum iser_conn_state exch)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300551{
552 int ret;
553
Sagi Grimberg5716af62014-10-01 14:01:57 +0300554 ret = (iser_conn->state == comp);
555 if (ret)
556 iser_conn->state = exch;
557
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300558 return ret;
559}
560
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300561void iser_release_work(struct work_struct *work)
562{
Sagi Grimberg5716af62014-10-01 14:01:57 +0300563 struct iser_conn *iser_conn;
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300564
Sagi Grimberg5716af62014-10-01 14:01:57 +0300565 iser_conn = container_of(work, struct iser_conn, release_work);
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300566
Sagi Grimbergc107a6c2014-10-01 14:02:02 +0300567 /* Wait for conn_stop to complete */
568 wait_for_completion(&iser_conn->stop_completion);
569 /* Wait for IB resouces cleanup to complete */
570 wait_for_completion(&iser_conn->ib_completion);
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300571
Sagi Grimberg5716af62014-10-01 14:01:57 +0300572 mutex_lock(&iser_conn->state_mutex);
573 iser_conn->state = ISER_CONN_DOWN;
574 mutex_unlock(&iser_conn->state_mutex);
Ariel Nahum504130c2014-07-31 13:27:49 +0300575
Sagi Grimberg5716af62014-10-01 14:01:57 +0300576 iser_conn_release(iser_conn);
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300577}
578
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300579/**
Sagi Grimberg96f15192014-10-01 14:02:00 +0300580 * iser_free_ib_conn_res - release IB related resources
581 * @iser_conn: iser connection struct
Sagi Grimberg6606e6a2015-01-18 16:51:06 +0200582 * @destroy: indicator if we need to try to release the
583 * iser device and memory regoins pool (only iscsi
584 * shutdown and DEVICE_REMOVAL will use this).
Sagi Grimberg96f15192014-10-01 14:02:00 +0300585 *
586 * This routine is called with the iser state mutex held
587 * so the cm_id removal is out of here. It is Safe to
588 * be invoked multiple times.
589 */
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300590static void iser_free_ib_conn_res(struct iser_conn *iser_conn,
Sagi Grimberg6606e6a2015-01-18 16:51:06 +0200591 bool destroy)
Sagi Grimberg96f15192014-10-01 14:02:00 +0300592{
593 struct ib_conn *ib_conn = &iser_conn->ib_conn;
594 struct iser_device *device = ib_conn->device;
595
596 iser_info("freeing conn %p cma_id %p qp %p\n",
597 iser_conn, ib_conn->cma_id, ib_conn->qp);
598
Sagi Grimberg96f15192014-10-01 14:02:00 +0300599 if (ib_conn->qp != NULL) {
Sagi Grimbergbf175542014-10-01 14:02:07 +0300600 ib_conn->comp->active_qps--;
Sagi Grimberg96f15192014-10-01 14:02:00 +0300601 rdma_destroy_qp(ib_conn->cma_id);
602 ib_conn->qp = NULL;
603 }
604
Sagi Grimberg6606e6a2015-01-18 16:51:06 +0200605 if (destroy) {
606 if (iser_conn->rx_descs)
607 iser_free_rx_descriptors(iser_conn);
608
609 if (device != NULL) {
610 iser_device_try_release(device);
611 ib_conn->device = NULL;
612 }
Sagi Grimberg96f15192014-10-01 14:02:00 +0300613 }
614}
615
616/**
Roland Dreier41179e22007-07-17 18:37:42 -0700617 * Frees all conn objects and deallocs conn descriptor
618 */
Sagi Grimberg5716af62014-10-01 14:01:57 +0300619void iser_conn_release(struct iser_conn *iser_conn)
Roland Dreier41179e22007-07-17 18:37:42 -0700620{
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300621 struct ib_conn *ib_conn = &iser_conn->ib_conn;
Roland Dreier41179e22007-07-17 18:37:42 -0700622
Roland Dreier41179e22007-07-17 18:37:42 -0700623 mutex_lock(&ig.connlist_mutex);
Sagi Grimberg5716af62014-10-01 14:01:57 +0300624 list_del(&iser_conn->conn_list);
Roland Dreier41179e22007-07-17 18:37:42 -0700625 mutex_unlock(&ig.connlist_mutex);
Ariel Nahum504130c2014-07-31 13:27:49 +0300626
Sagi Grimberg5716af62014-10-01 14:01:57 +0300627 mutex_lock(&iser_conn->state_mutex);
Ariel Nahum9a3119e2015-01-18 16:51:07 +0200628 /* In case we endup here without ep_disconnect being invoked. */
Ariel Nahum5426b172014-12-07 16:09:54 +0200629 if (iser_conn->state != ISER_CONN_DOWN) {
Ariel Nahumaea8f4d2014-10-01 14:02:06 +0300630 iser_warn("iser conn %p state %d, expected state down.\n",
631 iser_conn, iser_conn->state);
Ariel Nahum9a3119e2015-01-18 16:51:07 +0200632 iscsi_destroy_endpoint(iser_conn->ep);
Ariel Nahum5426b172014-12-07 16:09:54 +0200633 iser_conn->state = ISER_CONN_DOWN;
634 }
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300635 /*
636 * In case we never got to bind stage, we still need to
637 * release IB resources (which is safe to call more than once).
638 */
639 iser_free_ib_conn_res(iser_conn, true);
Sagi Grimberg5716af62014-10-01 14:01:57 +0300640 mutex_unlock(&iser_conn->state_mutex);
Ariel Nahum504130c2014-07-31 13:27:49 +0300641
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300642 if (ib_conn->cma_id != NULL) {
643 rdma_destroy_id(ib_conn->cma_id);
644 ib_conn->cma_id = NULL;
Roi Dayan5b61ff42013-05-08 12:21:17 +0000645 }
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300646
Sagi Grimberg5716af62014-10-01 14:01:57 +0300647 kfree(iser_conn);
Roland Dreier41179e22007-07-17 18:37:42 -0700648}
649
650/**
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300651 * triggers start of the disconnect procedures and wait for them to be done
652 * Called with state mutex held
653 */
654int iser_conn_terminate(struct iser_conn *iser_conn)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300655{
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300656 struct ib_conn *ib_conn = &iser_conn->ib_conn;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300657 int err = 0;
658
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300659 /* terminate the iser conn only if the conn state is UP */
660 if (!iser_conn_state_comp_exch(iser_conn, ISER_CONN_UP,
661 ISER_CONN_TERMINATING))
662 return 0;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300663
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300664 iser_info("iser_conn %p state %d\n", iser_conn, iser_conn->state);
665
666 /* suspend queuing of new iscsi commands */
667 if (iser_conn->iscsi_conn)
668 iscsi_suspend_queue(iser_conn->iscsi_conn);
669
670 /*
671 * In case we didn't already clean up the cma_id (peer initiated
672 * a disconnection), we need to Cause the CMA to change the QP
673 * state to ERROR.
674 */
675 if (ib_conn->cma_id) {
676 err = rdma_disconnect(ib_conn->cma_id);
677 if (err)
678 iser_err("Failed to disconnect, conn: 0x%p err %d\n",
679 iser_conn, err);
680
Steve Wise4c8ba942016-02-17 08:17:12 -0800681 /* block until all flush errors are consumed */
682 ib_drain_sq(ib_conn->qp);
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300683 }
684
685 return 1;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300686}
687
Ariel Nahum504130c2014-07-31 13:27:49 +0300688/**
689 * Called with state mutex held
690 **/
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300691static void iser_connect_error(struct rdma_cm_id *cma_id)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300692{
Sagi Grimberg5716af62014-10-01 14:01:57 +0300693 struct iser_conn *iser_conn;
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300694
Sagi Grimberg5716af62014-10-01 14:01:57 +0300695 iser_conn = (struct iser_conn *)cma_id->context;
Sagi Grimbergc4de4662015-04-14 18:08:11 +0300696 iser_conn->state = ISER_CONN_TERMINATING;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300697}
698
Sagi Grimbergdf749cd2015-08-06 18:33:04 +0300699static void
700iser_calc_scsi_params(struct iser_conn *iser_conn,
701 unsigned int max_sectors)
702{
703 struct iser_device *device = iser_conn->ib_conn.device;
704 unsigned short sg_tablesize, sup_sg_tablesize;
705
706 sg_tablesize = DIV_ROUND_UP(max_sectors * 512, SIZE_4K);
707 sup_sg_tablesize = min_t(unsigned, ISCSI_ISER_MAX_SG_TABLESIZE,
Or Gerlitz4a061b22015-12-18 10:59:46 +0200708 device->ib_device->attrs.max_fast_reg_page_list_len);
Sagi Grimbergdf749cd2015-08-06 18:33:04 +0300709
710 if (sg_tablesize > sup_sg_tablesize) {
711 sg_tablesize = sup_sg_tablesize;
712 iser_conn->scsi_max_sectors = sg_tablesize * SIZE_4K / 512;
713 } else {
714 iser_conn->scsi_max_sectors = max_sectors;
715 }
716
717 iser_conn->scsi_sg_tablesize = sg_tablesize;
718
719 iser_dbg("iser_conn %p, sg_tablesize %u, max_sectors %u\n",
720 iser_conn, iser_conn->scsi_sg_tablesize,
721 iser_conn->scsi_max_sectors);
722}
723
Ariel Nahum504130c2014-07-31 13:27:49 +0300724/**
725 * Called with state mutex held
726 **/
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300727static void iser_addr_handler(struct rdma_cm_id *cma_id)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300728{
729 struct iser_device *device;
Sagi Grimberg5716af62014-10-01 14:01:57 +0300730 struct iser_conn *iser_conn;
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300731 struct ib_conn *ib_conn;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300732 int ret;
733
Sagi Grimberg5716af62014-10-01 14:01:57 +0300734 iser_conn = (struct iser_conn *)cma_id->context;
735 if (iser_conn->state != ISER_CONN_PENDING)
Ariel Nahum504130c2014-07-31 13:27:49 +0300736 /* bailout */
737 return;
738
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300739 ib_conn = &iser_conn->ib_conn;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300740 device = iser_device_find_by_ib_device(cma_id);
Arne Redlichd33ed422008-03-04 14:11:54 +0200741 if (!device) {
742 iser_err("device lookup/creation failed\n");
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300743 iser_connect_error(cma_id);
744 return;
Arne Redlichd33ed422008-03-04 14:11:54 +0200745 }
746
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300747 ib_conn->device = device;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300748
Alex Tabachnik7f733842014-03-05 19:43:46 +0200749 /* connection T10-PI support */
750 if (iser_pi_enable) {
Or Gerlitz4a061b22015-12-18 10:59:46 +0200751 if (!(device->ib_device->attrs.device_cap_flags &
Alex Tabachnik7f733842014-03-05 19:43:46 +0200752 IB_DEVICE_SIGNATURE_HANDOVER)) {
753 iser_warn("T10-PI requested but not supported on %s, "
754 "continue without T10-PI\n",
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300755 ib_conn->device->ib_device->name);
756 ib_conn->pi_support = false;
Alex Tabachnik7f733842014-03-05 19:43:46 +0200757 } else {
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300758 ib_conn->pi_support = true;
Alex Tabachnik7f733842014-03-05 19:43:46 +0200759 }
760 }
761
Sagi Grimbergdf749cd2015-08-06 18:33:04 +0300762 iser_calc_scsi_params(iser_conn, iser_max_sectors);
763
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300764 ret = rdma_resolve_route(cma_id, 1000);
765 if (ret) {
766 iser_err("resolve route failed: %d\n", ret);
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300767 iser_connect_error(cma_id);
768 return;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300769 }
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300770}
771
Ariel Nahum504130c2014-07-31 13:27:49 +0300772/**
773 * Called with state mutex held
774 **/
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300775static void iser_route_handler(struct rdma_cm_id *cma_id)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300776{
777 struct rdma_conn_param conn_param;
778 int ret;
Or Gerlitz8d8399d2013-05-01 13:25:27 +0000779 struct iser_cm_hdr req_hdr;
Sagi Grimberg5716af62014-10-01 14:01:57 +0300780 struct iser_conn *iser_conn = (struct iser_conn *)cma_id->context;
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300781 struct ib_conn *ib_conn = &iser_conn->ib_conn;
782 struct iser_device *device = ib_conn->device;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300783
Sagi Grimberg5716af62014-10-01 14:01:57 +0300784 if (iser_conn->state != ISER_CONN_PENDING)
Ariel Nahum504130c2014-07-31 13:27:49 +0300785 /* bailout */
786 return;
787
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300788 ret = iser_create_ib_conn_res(ib_conn);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300789 if (ret)
790 goto failure;
791
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300792 memset(&conn_param, 0, sizeof conn_param);
Or Gerlitz4a061b22015-12-18 10:59:46 +0200793 conn_param.responder_resources = device->ib_device->attrs.max_qp_rd_atom;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300794 conn_param.initiator_depth = 1;
795 conn_param.retry_count = 7;
796 conn_param.rnr_retry_count = 6;
797
Or Gerlitz8d8399d2013-05-01 13:25:27 +0000798 memset(&req_hdr, 0, sizeof(req_hdr));
Jenny Derzhavetz59caaed2015-12-24 12:20:48 +0200799 req_hdr.flags = ISER_ZBVA_NOT_SUP;
800 if (!device->remote_inv_sup)
801 req_hdr.flags |= ISER_SEND_W_INV_NOT_SUP;
Sagi Grimbergd3cf81f2015-12-09 14:12:03 +0200802 conn_param.private_data = (void *)&req_hdr;
803 conn_param.private_data_len = sizeof(struct iser_cm_hdr);
Or Gerlitz8d8399d2013-05-01 13:25:27 +0000804
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300805 ret = rdma_connect(cma_id, &conn_param);
806 if (ret) {
807 iser_err("failure connecting: %d\n", ret);
808 goto failure;
809 }
810
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300811 return;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300812failure:
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300813 iser_connect_error(cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300814}
815
Jenny Derzhavetz59caaed2015-12-24 12:20:48 +0200816static void iser_connected_handler(struct rdma_cm_id *cma_id,
817 const void *private_data)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300818{
Sagi Grimberg5716af62014-10-01 14:01:57 +0300819 struct iser_conn *iser_conn;
Or Gerlitz4f9208a2014-04-01 16:28:40 +0300820 struct ib_qp_attr attr;
821 struct ib_qp_init_attr init_attr;
822
Sagi Grimberg5716af62014-10-01 14:01:57 +0300823 iser_conn = (struct iser_conn *)cma_id->context;
824 if (iser_conn->state != ISER_CONN_PENDING)
Ariel Nahum504130c2014-07-31 13:27:49 +0300825 /* bailout */
826 return;
827
Or Gerlitz4f9208a2014-04-01 16:28:40 +0300828 (void)ib_query_qp(cma_id->qp, &attr, ~0, &init_attr);
829 iser_info("remote qpn:%x my qpn:%x\n", attr.dest_qp_num, cma_id->qp->qp_num);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300830
Jenny Derzhavetz59caaed2015-12-24 12:20:48 +0200831 if (private_data) {
832 u8 flags = *(u8 *)private_data;
833
834 iser_conn->snd_w_inv = !(flags & ISER_SEND_W_INV_NOT_SUP);
835 }
836
837 iser_info("conn %p: negotiated %s invalidation\n",
838 iser_conn, iser_conn->snd_w_inv ? "remote" : "local");
839
Sagi Grimberg5716af62014-10-01 14:01:57 +0300840 iser_conn->state = ISER_CONN_UP;
841 complete(&iser_conn->up_completion);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300842}
843
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300844static void iser_disconnected_handler(struct rdma_cm_id *cma_id)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300845{
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300846 struct iser_conn *iser_conn = (struct iser_conn *)cma_id->context;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300847
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300848 if (iser_conn_terminate(iser_conn)) {
Sagi Grimberg5716af62014-10-01 14:01:57 +0300849 if (iser_conn->iscsi_conn)
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300850 iscsi_conn_failure(iser_conn->iscsi_conn,
851 ISCSI_ERR_CONN_FAILED);
Roi Dayan7d9eacf2014-02-04 16:54:54 +0200852 else
853 iser_err("iscsi_iser connection isn't bound\n");
854 }
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300855}
856
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300857static void iser_cleanup_handler(struct rdma_cm_id *cma_id,
Sagi Grimberg6606e6a2015-01-18 16:51:06 +0200858 bool destroy)
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300859{
860 struct iser_conn *iser_conn = (struct iser_conn *)cma_id->context;
861
862 /*
863 * We are not guaranteed that we visited disconnected_handler
864 * by now, call it here to be safe that we handle CM drep
865 * and flush errors.
866 */
867 iser_disconnected_handler(cma_id);
Sagi Grimberg6606e6a2015-01-18 16:51:06 +0200868 iser_free_ib_conn_res(iser_conn, destroy);
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300869 complete(&iser_conn->ib_completion);
870};
871
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300872static int iser_cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
873{
Sagi Grimberg5716af62014-10-01 14:01:57 +0300874 struct iser_conn *iser_conn;
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300875 int ret = 0;
Ariel Nahum504130c2014-07-31 13:27:49 +0300876
Sagi Grimberg5716af62014-10-01 14:01:57 +0300877 iser_conn = (struct iser_conn *)cma_id->context;
Sagi Grimberg871e00a2015-05-18 13:40:30 +0300878 iser_info("%s (%d): status %d conn %p id %p\n",
879 rdma_event_msg(event->event), event->event,
880 event->status, cma_id->context, cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300881
Sagi Grimberg5716af62014-10-01 14:01:57 +0300882 mutex_lock(&iser_conn->state_mutex);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300883 switch (event->event) {
884 case RDMA_CM_EVENT_ADDR_RESOLVED:
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300885 iser_addr_handler(cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300886 break;
887 case RDMA_CM_EVENT_ROUTE_RESOLVED:
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300888 iser_route_handler(cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300889 break;
890 case RDMA_CM_EVENT_ESTABLISHED:
Jenny Derzhavetz59caaed2015-12-24 12:20:48 +0200891 iser_connected_handler(cma_id, event->param.conn.private_data);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300892 break;
Steve Wise97540bb2016-10-26 12:36:47 -0700893 case RDMA_CM_EVENT_REJECTED:
894 iser_info("Connection rejected: %s\n",
895 rdma_reject_msg(cma_id, event->status));
896 /* FALLTHROUGH */
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300897 case RDMA_CM_EVENT_ADDR_ERROR:
898 case RDMA_CM_EVENT_ROUTE_ERROR:
899 case RDMA_CM_EVENT_CONNECT_ERROR:
900 case RDMA_CM_EVENT_UNREACHABLE:
Ariel Nahumb73c3ad2014-05-22 11:00:18 +0300901 iser_connect_error(cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300902 break;
903 case RDMA_CM_EVENT_DISCONNECTED:
Or Gerlitz2f5de152008-07-22 14:16:21 -0700904 case RDMA_CM_EVENT_ADDR_CHANGE:
Ariel Nahum5426b172014-12-07 16:09:54 +0200905 case RDMA_CM_EVENT_TIMEWAIT_EXIT:
906 iser_cleanup_handler(cma_id, false);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300907 break;
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300908 case RDMA_CM_EVENT_DEVICE_REMOVAL:
909 /*
910 * we *must* destroy the device as we cannot rely
911 * on iscsid to be around to initiate error handling.
Ariel Nahum5426b172014-12-07 16:09:54 +0200912 * also if we are not in state DOWN implicitly destroy
913 * the cma_id.
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300914 */
915 iser_cleanup_handler(cma_id, true);
Ariel Nahum5426b172014-12-07 16:09:54 +0200916 if (iser_conn->state != ISER_CONN_DOWN) {
917 iser_conn->ib_conn.cma_id = NULL;
918 ret = 1;
919 }
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300920 break;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300921 default:
Sagi Grimberg871e00a2015-05-18 13:40:30 +0300922 iser_err("Unexpected RDMA CM event: %s (%d)\n",
923 rdma_event_msg(event->event), event->event);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300924 break;
925 }
Sagi Grimberg5716af62014-10-01 14:01:57 +0300926 mutex_unlock(&iser_conn->state_mutex);
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300927
928 return ret;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300929}
930
Sagi Grimberg5716af62014-10-01 14:01:57 +0300931void iser_conn_init(struct iser_conn *iser_conn)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300932{
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -0800933 struct ib_conn *ib_conn = &iser_conn->ib_conn;
934
Sagi Grimberg5716af62014-10-01 14:01:57 +0300935 iser_conn->state = ISER_CONN_INIT;
Sagi Grimberg5716af62014-10-01 14:01:57 +0300936 init_completion(&iser_conn->stop_completion);
Sagi Grimbergc47a3c92014-10-01 14:02:01 +0300937 init_completion(&iser_conn->ib_completion);
Sagi Grimberg5716af62014-10-01 14:01:57 +0300938 init_completion(&iser_conn->up_completion);
939 INIT_LIST_HEAD(&iser_conn->conn_list);
Sagi Grimberg5716af62014-10-01 14:01:57 +0300940 mutex_init(&iser_conn->state_mutex);
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -0800941
942 ib_conn->post_recv_buf_count = 0;
943 ib_conn->reg_cqe.done = iser_reg_comp;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300944}
945
946 /**
947 * starts the process of connecting to the target
Thadeu Lima de Souza Cascardo94e2bd62009-10-16 15:20:49 +0200948 * sleeps until the connection is established or rejected
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300949 */
Sagi Grimberg5716af62014-10-01 14:01:57 +0300950int iser_connect(struct iser_conn *iser_conn,
Roi Dayan96ed02d2014-07-31 13:27:44 +0300951 struct sockaddr *src_addr,
952 struct sockaddr *dst_addr,
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300953 int non_blocking)
954{
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300955 struct ib_conn *ib_conn = &iser_conn->ib_conn;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300956 int err = 0;
957
Sagi Grimberg5716af62014-10-01 14:01:57 +0300958 mutex_lock(&iser_conn->state_mutex);
Ariel Nahum504130c2014-07-31 13:27:49 +0300959
Sagi Grimberg5716af62014-10-01 14:01:57 +0300960 sprintf(iser_conn->name, "%pISp", dst_addr);
Roi Dayan96ed02d2014-07-31 13:27:44 +0300961
Sagi Grimberg5716af62014-10-01 14:01:57 +0300962 iser_info("connecting to: %s\n", iser_conn->name);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300963
964 /* the device is known only --after-- address resolution */
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300965 ib_conn->device = NULL;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300966
Sagi Grimberg5716af62014-10-01 14:01:57 +0300967 iser_conn->state = ISER_CONN_PENDING;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300968
Guy Shapirofa201052015-10-22 15:20:10 +0300969 ib_conn->cma_id = rdma_create_id(&init_net, iser_cma_handler,
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300970 (void *)iser_conn,
971 RDMA_PS_TCP, IB_QPT_RC);
972 if (IS_ERR(ib_conn->cma_id)) {
973 err = PTR_ERR(ib_conn->cma_id);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300974 iser_err("rdma_create_id failed: %d\n", err);
975 goto id_failure;
976 }
977
Sagi Grimberga4ee3532014-10-01 14:01:58 +0300978 err = rdma_resolve_addr(ib_conn->cma_id, src_addr, dst_addr, 1000);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300979 if (err) {
980 iser_err("rdma_resolve_addr failed: %d\n", err);
981 goto addr_failure;
982 }
983
984 if (!non_blocking) {
Sagi Grimberg5716af62014-10-01 14:01:57 +0300985 wait_for_completion_interruptible(&iser_conn->up_completion);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300986
Sagi Grimberg5716af62014-10-01 14:01:57 +0300987 if (iser_conn->state != ISER_CONN_UP) {
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300988 err = -EIO;
989 goto connect_failure;
990 }
991 }
Sagi Grimberg5716af62014-10-01 14:01:57 +0300992 mutex_unlock(&iser_conn->state_mutex);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300993
994 mutex_lock(&ig.connlist_mutex);
Sagi Grimberg5716af62014-10-01 14:01:57 +0300995 list_add(&iser_conn->conn_list, &ig.connlist);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +0300996 mutex_unlock(&ig.connlist_mutex);
997 return 0;
998
999id_failure:
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001000 ib_conn->cma_id = NULL;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001001addr_failure:
Sagi Grimberg5716af62014-10-01 14:01:57 +03001002 iser_conn->state = ISER_CONN_DOWN;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001003connect_failure:
Sagi Grimberg5716af62014-10-01 14:01:57 +03001004 mutex_unlock(&iser_conn->state_mutex);
1005 iser_conn_release(iser_conn);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001006 return err;
1007}
1008
Sagi Grimberg5716af62014-10-01 14:01:57 +03001009int iser_post_recvl(struct iser_conn *iser_conn)
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001010{
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001011 struct ib_conn *ib_conn = &iser_conn->ib_conn;
Sagi Grimberg0f512b32015-11-04 10:50:31 +02001012 struct iser_login_desc *desc = &iser_conn->login_desc;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001013 struct ib_recv_wr wr, *wr_failed;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001014 int ib_ret;
1015
Sagi Grimberg0f512b32015-11-04 10:50:31 +02001016 desc->sge.addr = desc->rsp_dma;
1017 desc->sge.length = ISER_RX_LOGIN_SIZE;
1018 desc->sge.lkey = ib_conn->device->pd->local_dma_lkey;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001019
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001020 desc->cqe.done = iser_login_rsp;
1021 wr.wr_cqe = &desc->cqe;
1022 wr.sg_list = &desc->sge;
1023 wr.num_sge = 1;
1024 wr.next = NULL;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001025
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001026 ib_conn->post_recv_buf_count++;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001027 ib_ret = ib_post_recv(ib_conn->qp, &wr, &wr_failed);
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001028 if (ib_ret) {
1029 iser_err("ib_post_recv failed ret=%d\n", ib_ret);
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001030 ib_conn->post_recv_buf_count--;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001031 }
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001032
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001033 return ib_ret;
1034}
1035
Sagi Grimberg5716af62014-10-01 14:01:57 +03001036int iser_post_recvm(struct iser_conn *iser_conn, int count)
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001037{
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001038 struct ib_conn *ib_conn = &iser_conn->ib_conn;
Sagi Grimberg5716af62014-10-01 14:01:57 +03001039 unsigned int my_rx_head = iser_conn->rx_desc_head;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001040 struct iser_rx_desc *rx_desc;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001041 struct ib_recv_wr *wr, *wr_failed;
1042 int i, ib_ret;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001043
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001044 for (wr = ib_conn->rx_wr, i = 0; i < count; i++, wr++) {
1045 rx_desc = &iser_conn->rx_descs[my_rx_head];
1046 rx_desc->cqe.done = iser_task_rsp;
1047 wr->wr_cqe = &rx_desc->cqe;
1048 wr->sg_list = &rx_desc->rx_sg;
1049 wr->num_sge = 1;
1050 wr->next = wr + 1;
Sagi Grimberg5716af62014-10-01 14:01:57 +03001051 my_rx_head = (my_rx_head + 1) & iser_conn->qp_max_recv_dtos_mask;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001052 }
1053
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001054 wr--;
1055 wr->next = NULL; /* mark end of work requests list */
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001056
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001057 ib_conn->post_recv_buf_count += count;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001058 ib_ret = ib_post_recv(ib_conn->qp, ib_conn->rx_wr, &wr_failed);
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001059 if (ib_ret) {
1060 iser_err("ib_post_recv failed ret=%d\n", ib_ret);
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001061 ib_conn->post_recv_buf_count -= count;
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001062 } else
Sagi Grimberg5716af62014-10-01 14:01:57 +03001063 iser_conn->rx_desc_head = my_rx_head;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001064
Or Gerlitzbcc60c32010-02-08 13:17:42 +00001065 return ib_ret;
1066}
1067
1068
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001069/**
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001070 * iser_start_send - Initiate a Send DTO operation
1071 *
1072 * returns 0 on success, -1 on failure
1073 */
Sagi Grimberg6df5a122014-10-01 14:02:12 +03001074int iser_post_send(struct ib_conn *ib_conn, struct iser_tx_desc *tx_desc,
1075 bool signal)
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001076{
Sagi Grimberg7332bed2015-08-06 18:33:06 +03001077 struct ib_send_wr *bad_wr, *wr = iser_tx_next_wr(tx_desc);
1078 int ib_ret;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001079
Sagi Grimberga4ee3532014-10-01 14:01:58 +03001080 ib_dma_sync_single_for_device(ib_conn->device->ib_device,
Sagi Grimberg5716af62014-10-01 14:01:57 +03001081 tx_desc->dma_addr, ISER_HEADERS_LEN,
1082 DMA_TO_DEVICE);
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001083
Sagi Grimberg7332bed2015-08-06 18:33:06 +03001084 wr->next = NULL;
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001085 wr->wr_cqe = &tx_desc->cqe;
Sagi Grimberg7332bed2015-08-06 18:33:06 +03001086 wr->sg_list = tx_desc->tx_sg;
1087 wr->num_sge = tx_desc->num_sge;
1088 wr->opcode = IB_WR_SEND;
1089 wr->send_flags = signal ? IB_SEND_SIGNALED : 0;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001090
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001091 ib_ret = ib_post_send(ib_conn->qp, &tx_desc->wrs[0].send, &bad_wr);
Sagi Grimbergff3dd522014-10-01 14:02:10 +03001092 if (ib_ret)
Sagi Grimberg7332bed2015-08-06 18:33:06 +03001093 iser_err("ib_post_send failed, ret:%d opcode:%d\n",
1094 ib_ret, bad_wr->opcode);
Sagi Grimbergff3dd522014-10-01 14:02:10 +03001095
Or Gerlitzf19624a2010-02-08 13:19:56 +00001096 return ib_ret;
Or Gerlitz1cfa0a72006-05-11 10:02:46 +03001097}
1098
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001099u8 iser_check_task_pi_status(struct iscsi_iser_task *iser_task,
1100 enum iser_data_dir cmd_dir, sector_t *sector)
1101{
Sagi Grimbergb130ede2015-04-14 18:08:19 +03001102 struct iser_mem_reg *reg = &iser_task->rdma_reg[cmd_dir];
Sagi Grimberg5190cc22015-08-06 18:32:54 +03001103 struct iser_fr_desc *desc = reg->mem_h;
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001104 unsigned long sector_size = iser_task->sc->device->sector_size;
1105 struct ib_mr_status mr_status;
1106 int ret;
1107
Sagi Grimbergd711d812015-08-06 18:32:53 +03001108 if (desc && desc->pi_ctx->sig_protected) {
1109 desc->pi_ctx->sig_protected = 0;
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001110 ret = ib_check_mr_status(desc->pi_ctx->sig_mr,
1111 IB_MR_CHECK_SIG_STATUS, &mr_status);
1112 if (ret) {
1113 pr_err("ib_check_mr_status failed, ret %d\n", ret);
1114 goto err;
1115 }
1116
1117 if (mr_status.fail_status & IB_MR_CHECK_SIG_STATUS) {
1118 sector_t sector_off = mr_status.sig_err.sig_err_offset;
1119
Arnd Bergmann2c63d102015-11-20 17:41:36 +01001120 sector_div(sector_off, sector_size + 8);
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001121 *sector = scsi_get_lba(iser_task->sc) + sector_off;
1122
Randy Dunlap39c978c2014-03-28 14:03:40 -07001123 pr_err("PI error found type %d at sector %llx "
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001124 "expected %x vs actual %x\n",
Randy Dunlap39c978c2014-03-28 14:03:40 -07001125 mr_status.sig_err.err_type,
1126 (unsigned long long)*sector,
Sagi Grimberg0a7a08a2014-03-05 19:43:50 +02001127 mr_status.sig_err.expected,
1128 mr_status.sig_err.actual);
1129
1130 switch (mr_status.sig_err.err_type) {
1131 case IB_SIG_BAD_GUARD:
1132 return 0x1;
1133 case IB_SIG_BAD_REFTAG:
1134 return 0x3;
1135 case IB_SIG_BAD_APPTAG:
1136 return 0x2;
1137 }
1138 }
1139 }
1140
1141 return 0;
1142err:
1143 /* Not alot we can do here, return ambiguous guard error */
1144 return 0x1;
1145}
Christoph Hellwigcfeb91b2015-12-11 11:54:28 -08001146
1147void iser_err_comp(struct ib_wc *wc, const char *type)
1148{
1149 if (wc->status != IB_WC_WR_FLUSH_ERR) {
1150 struct iser_conn *iser_conn = to_iser_conn(wc->qp->qp_context);
1151
1152 iser_err("%s failure: %s (%d) vend_err %x\n", type,
1153 ib_wc_status_msg(wc->status), wc->status,
1154 wc->vendor_err);
1155
1156 if (iser_conn->iscsi_conn)
1157 iscsi_conn_failure(iser_conn->iscsi_conn,
1158 ISCSI_ERR_CONN_FAILED);
1159 } else {
1160 iser_dbg("%s failure: %s (%d)\n", type,
1161 ib_wc_status_msg(wc->status), wc->status);
1162 }
1163}