forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-14 bedbef8ad3e75a304af6361af235302bcc61d06b 
 kernel/drivers/infiniband/ulp/isert/ib_isert.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*******************************************************************************
23  * This file contains iSCSI extentions for RDMA (iSER) Verbs
34  *
....@@ -5,15 +6,6 @@
56  *
67  * Nicholas A. Bellinger <nab@linux-iscsi.org>
78  *
8
- * This program is free software; you can redistribute it and/or modify
9
- * it under the terms of the GNU General Public License as published by
10
- * the Free Software Foundation; either version 2 of the License, or
11
- * (at your option) any later version.
12
- *
13
- * This program is distributed in the hope that it will be useful,
14
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
- * GNU General Public License for more details.
179  ****************************************************************************/
1810 
1911 #include <linux/string.h>
....@@ -23,6 +15,7 @@
2315 #include <linux/in.h>
2416 #include <linux/in6.h>
2517 #include <rdma/ib_verbs.h>
18
+#include <rdma/ib_cm.h>
2619 #include <rdma/rdma_cm.h>
2720 #include <target/target_core_base.h>
2821 #include <target/target_core_fabric.h>
....@@ -31,16 +24,21 @@
3124 
3225 #include "ib_isert.h"
3326 
34
-#define	ISERT_MAX_CONN		8
35
-#define ISER_MAX_RX_CQ_LEN	(ISERT_QP_MAX_RECV_DTOS * ISERT_MAX_CONN)
36
-#define ISER_MAX_TX_CQ_LEN \
37
-	((ISERT_QP_MAX_REQ_DTOS + ISCSI_DEF_XMIT_CMDS_MAX) * ISERT_MAX_CONN)
38
-#define ISER_MAX_CQ_LEN		(ISER_MAX_RX_CQ_LEN + ISER_MAX_TX_CQ_LEN + \
39
-				 ISERT_MAX_CONN)
40
-
4127 static int isert_debug_level;
4228 module_param_named(debug_level, isert_debug_level, int, 0644);
4329 MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0 (default:0)");
30
+
31
+static int isert_sg_tablesize_set(const char *val,
32
+				  const struct kernel_param *kp);
33
+static const struct kernel_param_ops sg_tablesize_ops = {
34
+	.set = isert_sg_tablesize_set,
35
+	.get = param_get_int,
36
+};
37
+
38
+static int isert_sg_tablesize = ISCSI_ISER_MIN_SG_TABLESIZE;
39
+module_param_cb(sg_tablesize, &sg_tablesize_ops, &isert_sg_tablesize, 0644);
40
+MODULE_PARM_DESC(sg_tablesize,
41
+		 "Number of gather/scatter entries in a single scsi command, should >= 128 (default: 128, max: 4096)");
4442 
4543 static DEFINE_MUTEX(device_list_mutex);
4644 static LIST_HEAD(device_list);
....@@ -60,6 +58,19 @@
6058 static void isert_send_done(struct ib_cq *cq, struct ib_wc *wc);
6159 static void isert_login_recv_done(struct ib_cq *cq, struct ib_wc *wc);
6260 static void isert_login_send_done(struct ib_cq *cq, struct ib_wc *wc);
61
+
62
+static int isert_sg_tablesize_set(const char *val, const struct kernel_param *kp)
63
+{
64
+	int n = 0, ret;
65
+
66
+	ret = kstrtoint(val, 10, &n);
67
+	if (ret != 0 || n < ISCSI_ISER_MIN_SG_TABLESIZE ||
68
+	    n > ISCSI_ISER_MAX_SG_TABLESIZE)
69
+		return -EINVAL;
70
+
71
+	return param_set_int(val, kp);
72
+}
73
+
6374 
6475 static inline bool
6576 isert_prot_cmd(struct isert_conn *conn, struct se_cmd *cmd)
....@@ -89,86 +100,50 @@
89100 	}
90101 }
91102 
92
-static struct isert_comp *
93
-isert_comp_get(struct isert_conn *isert_conn)
94
-{
95
-	struct isert_device *device = isert_conn->device;
96
-	struct isert_comp *comp;
97
-	int i, min = 0;
98
-
99
-	mutex_lock(&device_list_mutex);
100
-	for (i = 0; i < device->comps_used; i++)
101
-		if (device->comps[i].active_qps <
102
-		    device->comps[min].active_qps)
103
-			min = i;
104
-	comp = &device->comps[min];
105
-	comp->active_qps++;
106
-	mutex_unlock(&device_list_mutex);
107
-
108
-	isert_info("conn %p, using comp %p min_index: %d\n",
109
-		   isert_conn, comp, min);
110
-
111
-	return comp;
112
-}
113
-
114
-static void
115
-isert_comp_put(struct isert_comp *comp)
116
-{
117
-	mutex_lock(&device_list_mutex);
118
-	comp->active_qps--;
119
-	mutex_unlock(&device_list_mutex);
120
-}
121
-
122103 static struct ib_qp *
123104 isert_create_qp(struct isert_conn *isert_conn,
124
-		struct isert_comp *comp,
125105 		struct rdma_cm_id *cma_id)
126106 {
107
+	u32 cq_size = ISERT_QP_MAX_REQ_DTOS + ISERT_QP_MAX_RECV_DTOS + 2;
127108 	struct isert_device *device = isert_conn->device;
109
+	struct ib_device *ib_dev = device->ib_device;
128110 	struct ib_qp_init_attr attr;
129
-	int ret;
111
+	int ret, factor;
112
+
113
+	isert_conn->cq = ib_cq_pool_get(ib_dev, cq_size, -1, IB_POLL_WORKQUEUE);
114
+	if (IS_ERR(isert_conn->cq)) {
115
+		isert_err("Unable to allocate cq\n");
116
+		ret = PTR_ERR(isert_conn->cq);
117
+		return ERR_PTR(ret);
118
+	}
119
+	isert_conn->cq_size = cq_size;
130120 
131121 	memset(&attr, 0, sizeof(struct ib_qp_init_attr));
132122 	attr.event_handler = isert_qp_event_callback;
133123 	attr.qp_context = isert_conn;
134
-	attr.send_cq = comp->cq;
135
-	attr.recv_cq = comp->cq;
124
+	attr.send_cq = isert_conn->cq;
125
+	attr.recv_cq = isert_conn->cq;
136126 	attr.cap.max_send_wr = ISERT_QP_MAX_REQ_DTOS + 1;
137127 	attr.cap.max_recv_wr = ISERT_QP_MAX_RECV_DTOS + 1;
138
-	attr.cap.max_rdma_ctxs = ISCSI_DEF_XMIT_CMDS_MAX;
128
+	factor = rdma_rw_mr_factor(device->ib_device, cma_id->port_num,
129
+				   isert_sg_tablesize);
130
+	attr.cap.max_rdma_ctxs = ISCSI_DEF_XMIT_CMDS_MAX * factor;
139131 	attr.cap.max_send_sge = device->ib_device->attrs.max_send_sge;
140132 	attr.cap.max_recv_sge = 1;
141133 	attr.sq_sig_type = IB_SIGNAL_REQ_WR;
142134 	attr.qp_type = IB_QPT_RC;
143135 	if (device->pi_capable)
144
-		attr.create_flags |= IB_QP_CREATE_SIGNATURE_EN;
136
+		attr.create_flags |= IB_QP_CREATE_INTEGRITY_EN;
145137 
146138 	ret = rdma_create_qp(cma_id, device->pd, &attr);
147139 	if (ret) {
148140 		isert_err("rdma_create_qp failed for cma_id %d\n", ret);
141
+		ib_cq_pool_put(isert_conn->cq, isert_conn->cq_size);
142
+
149143 		return ERR_PTR(ret);
150144 	}
151145 
152146 	return cma_id->qp;
153
-}
154
-
155
-static int
156
-isert_conn_setup_qp(struct isert_conn *isert_conn, struct rdma_cm_id *cma_id)
157
-{
158
-	struct isert_comp *comp;
159
-	int ret;
160
-
161
-	comp = isert_comp_get(isert_conn);
162
-	isert_conn->qp = isert_create_qp(isert_conn, comp, cma_id);
163
-	if (IS_ERR(isert_conn->qp)) {
164
-		ret = PTR_ERR(isert_conn->qp);
165
-		goto err;
166
-	}
167
-
168
-	return 0;
169
-err:
170
-	isert_comp_put(comp);
171
-	return ret;
172147 }
173148 
174149 static int
....@@ -190,15 +165,15 @@
190165 	rx_desc = isert_conn->rx_descs;
191166 
192167 	for (i = 0; i < ISERT_QP_MAX_RECV_DTOS; i++, rx_desc++)  {
193
-		dma_addr = ib_dma_map_single(ib_dev, (void *)rx_desc,
194
-					ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
168
+		dma_addr = ib_dma_map_single(ib_dev, rx_desc->buf,
169
+					ISER_RX_SIZE, DMA_FROM_DEVICE);
195170 		if (ib_dma_mapping_error(ib_dev, dma_addr))
196171 			goto dma_map_fail;
197172 
198173 		rx_desc->dma_addr = dma_addr;
199174 
200175 		rx_sg = &rx_desc->rx_sg;
201
-		rx_sg->addr = rx_desc->dma_addr;
176
+		rx_sg->addr = rx_desc->dma_addr + isert_get_hdr_offset(rx_desc);
202177 		rx_sg->length = ISER_RX_PAYLOAD_SIZE;
203178 		rx_sg->lkey = device->pd->local_dma_lkey;
204179 		rx_desc->rx_cqe.done = isert_recv_done;
....@@ -210,7 +185,7 @@
210185 	rx_desc = isert_conn->rx_descs;
211186 	for (j = 0; j < i; j++, rx_desc++) {
212187 		ib_dma_unmap_single(ib_dev, rx_desc->dma_addr,
213
-				    ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
188
+				    ISER_RX_SIZE, DMA_FROM_DEVICE);
214189 	}
215190 	kfree(isert_conn->rx_descs);
216191 	isert_conn->rx_descs = NULL;
....@@ -231,66 +206,11 @@
231206 	rx_desc = isert_conn->rx_descs;
232207 	for (i = 0; i < ISERT_QP_MAX_RECV_DTOS; i++, rx_desc++)  {
233208 		ib_dma_unmap_single(ib_dev, rx_desc->dma_addr,
234
-				    ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
209
+				    ISER_RX_SIZE, DMA_FROM_DEVICE);
235210 	}
236211 
237212 	kfree(isert_conn->rx_descs);
238213 	isert_conn->rx_descs = NULL;
239
-}
240
-
241
-static void
242
-isert_free_comps(struct isert_device *device)
243
-{
244
-	int i;
245
-
246
-	for (i = 0; i < device->comps_used; i++) {
247
-		struct isert_comp *comp = &device->comps[i];
248
-
249
-		if (comp->cq)
250
-			ib_free_cq(comp->cq);
251
-	}
252
-	kfree(device->comps);
253
-}
254
-
255
-static int
256
-isert_alloc_comps(struct isert_device *device)
257
-{
258
-	int i, max_cqe, ret = 0;
259
-
260
-	device->comps_used = min(ISERT_MAX_CQ, min_t(int, num_online_cpus(),
261
-				 device->ib_device->num_comp_vectors));
262
-
263
-	isert_info("Using %d CQs, %s supports %d vectors support "
264
-		   "pi_capable %d\n",
265
-		   device->comps_used, device->ib_device->name,
266
-		   device->ib_device->num_comp_vectors,
267
-		   device->pi_capable);
268
-
269
-	device->comps = kcalloc(device->comps_used, sizeof(struct isert_comp),
270
-				GFP_KERNEL);
271
-	if (!device->comps)
272
-		return -ENOMEM;
273
-
274
-	max_cqe = min(ISER_MAX_CQ_LEN, device->ib_device->attrs.max_cqe);
275
-
276
-	for (i = 0; i < device->comps_used; i++) {
277
-		struct isert_comp *comp = &device->comps[i];
278
-
279
-		comp->device = device;
280
-		comp->cq = ib_alloc_cq(device->ib_device, comp, max_cqe, i,
281
-				IB_POLL_WORKQUEUE);
282
-		if (IS_ERR(comp->cq)) {
283
-			isert_err("Unable to allocate cq\n");
284
-			ret = PTR_ERR(comp->cq);
285
-			comp->cq = NULL;
286
-			goto out_cq;
287
-		}
288
-	}
289
-
290
-	return 0;
291
-out_cq:
292
-	isert_free_comps(device);
293
-	return ret;
294214 }
295215 
296216 static int
....@@ -303,30 +223,19 @@
303223 		  ib_dev->attrs.max_send_sge, ib_dev->attrs.max_recv_sge);
304224 	isert_dbg("devattr->max_sge_rd: %d\n", ib_dev->attrs.max_sge_rd);
305225 
306
-	ret = isert_alloc_comps(device);
307
-	if (ret)
308
-		goto out;
309
-
310226 	device->pd = ib_alloc_pd(ib_dev, 0);
311227 	if (IS_ERR(device->pd)) {
312228 		ret = PTR_ERR(device->pd);
313229 		isert_err("failed to allocate pd, device %p, ret=%d\n",
314230 			  device, ret);
315
-		goto out_cq;
231
+		return ret;
316232 	}
317233 
318234 	/* Check signature cap */
319235 	device->pi_capable = ib_dev->attrs.device_cap_flags &
320
-			     IB_DEVICE_SIGNATURE_HANDOVER ? true : false;
236
+			     IB_DEVICE_INTEGRITY_HANDOVER ? true : false;
321237 
322238 	return 0;
323
-
324
-out_cq:
325
-	isert_free_comps(device);
326
-out:
327
-	if (ret > 0)
328
-		ret = -EINVAL;
329
-	return ret;
330239 }
331240 
332241 static void
....@@ -335,7 +244,6 @@
335244 	isert_info("device %p\n", device);
336245 
337246 	ib_dealloc_pd(device->pd);
338
-	isert_free_comps(device);
339247 }
340248 
341249 static void
....@@ -416,10 +324,9 @@
416324 			    ISER_RX_PAYLOAD_SIZE, DMA_TO_DEVICE);
417325 	kfree(isert_conn->login_rsp_buf);
418326 
419
-	ib_dma_unmap_single(ib_dev, isert_conn->login_req_dma,
420
-			    ISER_RX_PAYLOAD_SIZE,
421
-			    DMA_FROM_DEVICE);
422
-	kfree(isert_conn->login_req_buf);
327
+	ib_dma_unmap_single(ib_dev, isert_conn->login_desc->dma_addr,
328
+			    ISER_RX_SIZE, DMA_FROM_DEVICE);
329
+	kfree(isert_conn->login_desc);
423330 }
424331 
425332 static int
....@@ -428,25 +335,25 @@
428335 {
429336 	int ret;
430337 
431
-	isert_conn->login_req_buf = kzalloc(sizeof(*isert_conn->login_req_buf),
338
+	isert_conn->login_desc = kzalloc(sizeof(*isert_conn->login_desc),
432339 			GFP_KERNEL);
433
-	if (!isert_conn->login_req_buf)
340
+	if (!isert_conn->login_desc)
434341 		return -ENOMEM;
435342 
436
-	isert_conn->login_req_dma = ib_dma_map_single(ib_dev,
437
-				isert_conn->login_req_buf,
438
-				ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
439
-	ret = ib_dma_mapping_error(ib_dev, isert_conn->login_req_dma);
343
+	isert_conn->login_desc->dma_addr = ib_dma_map_single(ib_dev,
344
+				isert_conn->login_desc->buf,
345
+				ISER_RX_SIZE, DMA_FROM_DEVICE);
346
+	ret = ib_dma_mapping_error(ib_dev, isert_conn->login_desc->dma_addr);
440347 	if (ret) {
441
-		isert_err("login_req_dma mapping error: %d\n", ret);
442
-		isert_conn->login_req_dma = 0;
443
-		goto out_free_login_req_buf;
348
+		isert_err("login_desc dma mapping error: %d\n", ret);
349
+		isert_conn->login_desc->dma_addr = 0;
350
+		goto out_free_login_desc;
444351 	}
445352 
446353 	isert_conn->login_rsp_buf = kzalloc(ISER_RX_PAYLOAD_SIZE, GFP_KERNEL);
447354 	if (!isert_conn->login_rsp_buf) {
448355 		ret = -ENOMEM;
449
-		goto out_unmap_login_req_buf;
356
+		goto out_unmap_login_desc;
450357 	}
451358 
452359 	isert_conn->login_rsp_dma = ib_dma_map_single(ib_dev,
....@@ -463,11 +370,11 @@
463370 
464371 out_free_login_rsp_buf:
465372 	kfree(isert_conn->login_rsp_buf);
466
-out_unmap_login_req_buf:
467
-	ib_dma_unmap_single(ib_dev, isert_conn->login_req_dma,
468
-			    ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
469
-out_free_login_req_buf:
470
-	kfree(isert_conn->login_req_buf);
373
+out_unmap_login_desc:
374
+	ib_dma_unmap_single(ib_dev, isert_conn->login_desc->dma_addr,
375
+			    ISER_RX_SIZE, DMA_FROM_DEVICE);
376
+out_free_login_desc:
377
+	kfree(isert_conn->login_desc);
471378 	return ret;
472379 }
473380 
....@@ -497,6 +404,13 @@
497404 	}
498405 }
499406 
407
+static void
408
+isert_destroy_qp(struct isert_conn *isert_conn)
409
+{
410
+	ib_destroy_qp(isert_conn->qp);
411
+	ib_cq_pool_put(isert_conn->cq, isert_conn->cq_size);
412
+}
413
+
500414 static int
501415 isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
502416 {
....@@ -510,7 +424,7 @@
510424 	if (!np->enabled) {
511425 		spin_unlock_bh(&np->np_thread_lock);
512426 		isert_dbg("iscsi_np is not enabled, reject connect request\n");
513
-		return rdma_reject(cma_id, NULL, 0);
427
+		return rdma_reject(cma_id, NULL, 0, IB_CM_REJ_CONSUMER_DEFINED);
514428 	}
515429 	spin_unlock_bh(&np->np_thread_lock);
516430 
....@@ -524,30 +438,32 @@
524438 	isert_init_conn(isert_conn);
525439 	isert_conn->cm_id = cma_id;
526440 
527
-	ret = isert_alloc_login_buf(isert_conn, cma_id->device);
528
-	if (ret)
529
-		goto out;
530
-
531441 	device = isert_device_get(cma_id);
532442 	if (IS_ERR(device)) {
533443 		ret = PTR_ERR(device);
534
-		goto out_rsp_dma_map;
444
+		goto out;
535445 	}
536446 	isert_conn->device = device;
537447 
538
-	isert_set_nego_params(isert_conn, &event->param.conn);
539
-
540
-	ret = isert_conn_setup_qp(isert_conn, cma_id);
448
+	ret = isert_alloc_login_buf(isert_conn, cma_id->device);
541449 	if (ret)
542450 		goto out_conn_dev;
451
+
452
+	isert_set_nego_params(isert_conn, &event->param.conn);
453
+
454
+	isert_conn->qp = isert_create_qp(isert_conn, cma_id);
455
+	if (IS_ERR(isert_conn->qp)) {
456
+		ret = PTR_ERR(isert_conn->qp);
457
+		goto out_rsp_dma_map;
458
+	}
543459 
544460 	ret = isert_login_post_recv(isert_conn);
545461 	if (ret)
546
-		goto out_conn_dev;
462
+		goto out_destroy_qp;
547463 
548464 	ret = isert_rdma_accept(isert_conn);
549465 	if (ret)
550
-		goto out_conn_dev;
466
+		goto out_destroy_qp;
551467 
552468 	mutex_lock(&isert_np->mutex);
553469 	list_add_tail(&isert_conn->node, &isert_np->accepted);
....@@ -555,13 +471,15 @@
555471 
556472 	return 0;
557473 
558
-out_conn_dev:
559
-	isert_device_put(device);
474
+out_destroy_qp:
475
+	isert_destroy_qp(isert_conn);
560476 out_rsp_dma_map:
561477 	isert_free_login_buf(isert_conn);
478
+out_conn_dev:
479
+	isert_device_put(device);
562480 out:
563481 	kfree(isert_conn);
564
-	rdma_reject(cma_id, NULL, 0);
482
+	rdma_reject(cma_id, NULL, 0, IB_CM_REJ_CONSUMER_DEFINED);
565483 	return ret;
566484 }
567485 
....@@ -579,14 +497,10 @@
579497 	    !isert_conn->dev_removed)
580498 		rdma_destroy_id(isert_conn->cm_id);
581499 
582
-	if (isert_conn->qp) {
583
-		struct isert_comp *comp = isert_conn->qp->recv_cq->cq_context;
500
+	if (isert_conn->qp)
501
+		isert_destroy_qp(isert_conn);
584502 
585
-		isert_comp_put(comp);
586
-		ib_destroy_qp(isert_conn->qp);
587
-	}
588
-
589
-	if (isert_conn->login_req_buf)
503
+	if (isert_conn->login_desc)
590504 		isert_free_login_buf(isert_conn);
591505 
592506 	isert_device_put(device);
....@@ -742,9 +656,13 @@
742656 isert_connect_error(struct rdma_cm_id *cma_id)
743657 {
744658 	struct isert_conn *isert_conn = cma_id->qp->qp_context;
659
+	struct isert_np *isert_np = cma_id->context;
745660 
746661 	ib_drain_qp(isert_conn->qp);
662
+
663
+	mutex_lock(&isert_np->mutex);
747664 	list_del_init(&isert_conn->node);
665
+	mutex_unlock(&isert_np->mutex);
748666 	isert_conn->cm_id = NULL;
749667 	isert_put_conn(isert_conn);
750668 
....@@ -774,8 +692,8 @@
774692 	case RDMA_CM_EVENT_ESTABLISHED:
775693 		isert_connected_handler(cma_id);
776694 		break;
777
-	case RDMA_CM_EVENT_ADDR_CHANGE:    /* FALLTHRU */
778
-	case RDMA_CM_EVENT_DISCONNECTED:   /* FALLTHRU */
695
+	case RDMA_CM_EVENT_ADDR_CHANGE:
696
+	case RDMA_CM_EVENT_DISCONNECTED:
779697 	case RDMA_CM_EVENT_TIMEWAIT_EXIT:  /* FALLTHRU */
780698 		ret = isert_disconnected_handler(cma_id, event->event);
781699 		break;
....@@ -794,7 +712,7 @@
794712 	case RDMA_CM_EVENT_REJECTED:
795713 		isert_info("Connection rejected: %s\n",
796714 			   rdma_reject_msg(cma_id, event->status));
797
-		/* fall through */
715
+		fallthrough;
798716 	case RDMA_CM_EVENT_UNREACHABLE:
799717 	case RDMA_CM_EVENT_CONNECT_ERROR:
800718 		ret = isert_connect_error(cma_id);
....@@ -972,17 +890,18 @@
972890 	int ret;
973891 
974892 	memset(&sge, 0, sizeof(struct ib_sge));
975
-	sge.addr = isert_conn->login_req_dma;
893
+	sge.addr = isert_conn->login_desc->dma_addr +
894
+		isert_get_hdr_offset(isert_conn->login_desc);
976895 	sge.length = ISER_RX_PAYLOAD_SIZE;
977896 	sge.lkey = isert_conn->device->pd->local_dma_lkey;
978897 
979898 	isert_dbg("Setup sge: addr: %llx length: %d 0x%08x\n",
980899 		sge.addr, sge.length, sge.lkey);
981900 
982
-	isert_conn->login_req_buf->rx_cqe.done = isert_login_recv_done;
901
+	isert_conn->login_desc->rx_cqe.done = isert_login_recv_done;
983902 
984903 	memset(&rx_wr, 0, sizeof(struct ib_recv_wr));
985
-	rx_wr.wr_cqe = &isert_conn->login_req_buf->rx_cqe;
904
+	rx_wr.wr_cqe = &isert_conn->login_desc->rx_cqe;
986905 	rx_wr.sg_list = &sge;
987906 	rx_wr.num_sge = 1;
988907 
....@@ -1059,7 +978,7 @@
1059978 static void
1060979 isert_rx_login_req(struct isert_conn *isert_conn)
1061980 {
1062
-	struct iser_rx_desc *rx_desc = isert_conn->login_req_buf;
981
+	struct iser_rx_desc *rx_desc = isert_conn->login_desc;
1063982 	int rx_buflen = isert_conn->login_req_len;
1064983 	struct iscsi_conn *conn = isert_conn->conn;
1065984 	struct iscsi_login *login = conn->conn_login;
....@@ -1071,7 +990,7 @@
1071990 
1072991 	if (login->first_request) {
1073992 		struct iscsi_login_req *login_req =
1074
-			(struct iscsi_login_req *)&rx_desc->iscsi_header;
993
+			(struct iscsi_login_req *)isert_get_iscsi_hdr(rx_desc);
1075994 		/*
1076995 		 * Setup the initial iscsi_login values from the leading
1077996 		 * login request PDU.
....@@ -1090,13 +1009,13 @@
10901009 		login->tsih		= be16_to_cpu(login_req->tsih);
10911010 	}
10921011 
1093
-	memcpy(&login->req[0], (void *)&rx_desc->iscsi_header, ISCSI_HDR_LEN);
1012
+	memcpy(&login->req[0], isert_get_iscsi_hdr(rx_desc), ISCSI_HDR_LEN);
10941013 
10951014 	size = min(rx_buflen, MAX_KEY_VALUE_PAIRS);
10961015 	isert_dbg("Using login payload size: %d, rx_buflen: %d "
10971016 		  "MAX_KEY_VALUE_PAIRS: %d\n", size, rx_buflen,
10981017 		  MAX_KEY_VALUE_PAIRS);
1099
-	memcpy(login->req_buf, &rx_desc->data[0], size);
1018
+	memcpy(login->req_buf, isert_get_data(rx_desc), size);
11001019 
11011020 	if (login->first_request) {
11021021 		complete(&isert_conn->login_comp);
....@@ -1161,14 +1080,15 @@
11611080 	if (imm_data_len != data_len) {
11621081 		sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE));
11631082 		sg_copy_from_buffer(cmd->se_cmd.t_data_sg, sg_nents,
1164
-				    &rx_desc->data[0], imm_data_len);
1083
+				    isert_get_data(rx_desc), imm_data_len);
11651084 		isert_dbg("Copy Immediate sg_nents: %u imm_data_len: %d\n",
11661085 			  sg_nents, imm_data_len);
11671086 	} else {
11681087 		sg_init_table(&isert_cmd->sg, 1);
11691088 		cmd->se_cmd.t_data_sg = &isert_cmd->sg;
11701089 		cmd->se_cmd.t_data_nents = 1;
1171
-		sg_set_buf(&isert_cmd->sg, &rx_desc->data[0], imm_data_len);
1090
+		sg_set_buf(&isert_cmd->sg, isert_get_data(rx_desc),
1091
+				imm_data_len);
11721092 		isert_dbg("Transfer Immediate imm_data_len: %d\n",
11731093 			  imm_data_len);
11741094 	}
....@@ -1186,7 +1106,7 @@
11861106 	rc = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
11871107 
11881108 	if (!rc && dump_payload == false && unsol_data)
1189
-		iscsit_set_unsoliticed_dataout(cmd);
1109
+		iscsit_set_unsolicited_dataout(cmd);
11901110 	else if (dump_payload && imm_data)
11911111 		target_put_sess_cmd(&cmd->se_cmd);
11921112 
....@@ -1237,9 +1157,9 @@
12371157 	}
12381158 	isert_dbg("Copying DataOut: sg_start: %p, sg_off: %u "
12391159 		  "sg_nents: %u from %p %u\n", sg_start, sg_off,
1240
-		  sg_nents, &rx_desc->data[0], unsol_data_len);
1160
+		  sg_nents, isert_get_data(rx_desc), unsol_data_len);
12411161 
1242
-	sg_copy_from_buffer(sg_start, sg_nents, &rx_desc->data[0],
1162
+	sg_copy_from_buffer(sg_start, sg_nents, isert_get_data(rx_desc),
12431163 			    unsol_data_len);
12441164 
12451165 	rc = iscsit_check_dataout_payload(cmd, hdr, false);
....@@ -1250,12 +1170,7 @@
12501170 	 * multiple data-outs on the same command can arrive -
12511171 	 * so post the buffer before hand
12521172 	 */
1253
-	rc = isert_post_recv(isert_conn, rx_desc);
1254
-	if (rc) {
1255
-		isert_err("ib_post_recv failed with %d\n", rc);
1256
-		return rc;
1257
-	}
1258
-	return 0;
1173
+	return isert_post_recv(isert_conn, rx_desc);
12591174 }
12601175 
12611176 static int
....@@ -1298,7 +1213,7 @@
12981213 	}
12991214 	cmd->text_in_ptr = text_in;
13001215 
1301
-	memcpy(cmd->text_in_ptr, &rx_desc->data[0], payload_length);
1216
+	memcpy(cmd->text_in_ptr, isert_get_data(rx_desc), payload_length);
13021217 
13031218 	return iscsit_process_text_cmd(conn, cmd, hdr);
13041219 }
....@@ -1308,7 +1223,7 @@
13081223 		uint32_t read_stag, uint64_t read_va,
13091224 		uint32_t write_stag, uint64_t write_va)
13101225 {
1311
-	struct iscsi_hdr *hdr = &rx_desc->iscsi_header;
1226
+	struct iscsi_hdr *hdr = isert_get_iscsi_hdr(rx_desc);
13121227 	struct iscsi_conn *conn = isert_conn->conn;
13131228 	struct iscsi_cmd *cmd;
13141229 	struct isert_cmd *isert_cmd;
....@@ -1406,8 +1321,8 @@
14061321 	struct isert_conn *isert_conn = wc->qp->qp_context;
14071322 	struct ib_device *ib_dev = isert_conn->cm_id->device;
14081323 	struct iser_rx_desc *rx_desc = cqe_to_rx_desc(wc->wr_cqe);
1409
-	struct iscsi_hdr *hdr = &rx_desc->iscsi_header;
1410
-	struct iser_ctrl *iser_ctrl = &rx_desc->iser_header;
1324
+	struct iscsi_hdr *hdr = isert_get_iscsi_hdr(rx_desc);
1325
+	struct iser_ctrl *iser_ctrl = isert_get_iser_hdr(rx_desc);
14111326 	uint64_t read_va = 0, write_va = 0;
14121327 	uint32_t read_stag = 0, write_stag = 0;
14131328 
....@@ -1421,7 +1336,7 @@
14211336 	rx_desc->in_use = true;
14221337 
14231338 	ib_dma_sync_single_for_cpu(ib_dev, rx_desc->dma_addr,
1424
-			ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
1339
+			ISER_RX_SIZE, DMA_FROM_DEVICE);
14251340 
14261341 	isert_dbg("DMA: 0x%llx, iSCSI opcode: 0x%02x, ITT: 0x%08x, flags: 0x%02x dlen: %d\n",
14271342 		 rx_desc->dma_addr, hdr->opcode, hdr->itt, hdr->flags,
....@@ -1456,7 +1371,7 @@
14561371 			read_stag, read_va, write_stag, write_va);
14571372 
14581373 	ib_dma_sync_single_for_device(ib_dev, rx_desc->dma_addr,
1459
-			ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
1374
+			ISER_RX_SIZE, DMA_FROM_DEVICE);
14601375 }
14611376 
14621377 static void
....@@ -1470,8 +1385,8 @@
14701385 		return;
14711386 	}
14721387 
1473
-	ib_dma_sync_single_for_cpu(ib_dev, isert_conn->login_req_dma,
1474
-			ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
1388
+	ib_dma_sync_single_for_cpu(ib_dev, isert_conn->login_desc->dma_addr,
1389
+			ISER_RX_SIZE, DMA_FROM_DEVICE);
14751390 
14761391 	isert_conn->login_req_len = wc->byte_len - ISER_HEADERS_LEN;
14771392 
....@@ -1486,8 +1401,8 @@
14861401 	complete(&isert_conn->login_req_comp);
14871402 	mutex_unlock(&isert_conn->mutex);
14881403 
1489
-	ib_dma_sync_single_for_device(ib_dev, isert_conn->login_req_dma,
1490
-				ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE);
1404
+	ib_dma_sync_single_for_device(ib_dev, isert_conn->login_desc->dma_addr,
1405
+				ISER_RX_SIZE, DMA_FROM_DEVICE);
14911406 }
14921407 
14931408 static void
....@@ -1580,7 +1495,7 @@
15801495 			transport_generic_free_cmd(&cmd->se_cmd, 0);
15811496 			break;
15821497 		}
1583
-		/* fall through */
1498
+		fallthrough;
15841499 	default:
15851500 		iscsit_release_cmd(cmd);
15861501 		break;
....@@ -1642,12 +1557,12 @@
16421557 		}
16431558 		sec_offset_err = mr_status.sig_err.sig_err_offset;
16441559 		do_div(sec_offset_err, block_size);
1645
-		se_cmd->bad_sector = sec_offset_err + se_cmd->t_task_lba;
1560
+		se_cmd->sense_info = sec_offset_err + se_cmd->t_task_lba;
16461561 
16471562 		isert_err("PI error found type %d at sector 0x%llx "
16481563 			  "expected 0x%x vs actual 0x%x\n",
16491564 			  mr_status.sig_err.err_type,
1650
-			  (unsigned long long)se_cmd->bad_sector,
1565
+			  (unsigned long long)se_cmd->sense_info,
16511566 			  mr_status.sig_err.expected,
16521567 			  mr_status.sig_err.actual);
16531568 		ret = 1;
....@@ -1677,7 +1592,7 @@
16771592 
16781593 	isert_dbg("Cmd %p\n", isert_cmd);
16791594 
1680
-	ret = isert_check_pi_status(cmd, isert_cmd->rw.sig->sig_mr);
1595
+	ret = isert_check_pi_status(cmd, isert_cmd->rw.reg->mr);
16811596 	isert_rdma_rw_ctx_destroy(isert_cmd, isert_conn);
16821597 
16831598 	if (ret) {
....@@ -1723,7 +1638,7 @@
17231638 	iscsit_stop_dataout_timer(cmd);
17241639 
17251640 	if (isert_prot_cmd(isert_conn, se_cmd))
1726
-		ret = isert_check_pi_status(se_cmd, isert_cmd->rw.sig->sig_mr);
1641
+		ret = isert_check_pi_status(se_cmd, isert_cmd->rw.reg->mr);
17271642 	isert_rdma_rw_ctx_destroy(isert_cmd, isert_conn);
17281643 	cmd->write_data_done = 0;
17291644 
....@@ -1758,7 +1673,7 @@
17581673 	switch (cmd->i_state) {
17591674 	case ISTATE_SEND_TASKMGTRSP:
17601675 		iscsit_tmr_post_handler(cmd, cmd->conn);
1761
-		/* fall through */
1676
+		fallthrough;
17621677 	case ISTATE_SEND_REJECT:
17631678 	case ISTATE_SEND_TEXTRSP:
17641679 		cmd->i_state = ISTATE_SENT_STATUS;
....@@ -1832,10 +1747,8 @@
18321747 	int ret;
18331748 
18341749 	ret = isert_post_recv(isert_conn, isert_cmd->rx_desc);
1835
-	if (ret) {
1836
-		isert_err("ib_post_recv failed with %d\n", ret);
1750
+	if (ret)
18371751 		return ret;
1838
-	}
18391752 
18401753 	ret = ib_post_send(isert_conn->qp, &isert_cmd->tx_desc.send_wr, NULL);
18411754 	if (ret) {
....@@ -2067,8 +1980,7 @@
20671980 }
20681981 
20691982 static inline void
2070
-isert_set_dif_domain(struct se_cmd *se_cmd, struct ib_sig_attrs *sig_attrs,
2071
-		     struct ib_sig_domain *domain)
1983
+isert_set_dif_domain(struct se_cmd *se_cmd, struct ib_sig_domain *domain)
20721984 {
20731985 	domain->sig_type = IB_SIG_TYPE_T10_DIF;
20741986 	domain->sig.dif.bg_type = IB_T10DIF_CRC;
....@@ -2096,17 +2008,17 @@
20962008 	case TARGET_PROT_DIN_INSERT:
20972009 	case TARGET_PROT_DOUT_STRIP:
20982010 		sig_attrs->mem.sig_type = IB_SIG_TYPE_NONE;
2099
-		isert_set_dif_domain(se_cmd, sig_attrs, &sig_attrs->wire);
2011
+		isert_set_dif_domain(se_cmd, &sig_attrs->wire);
21002012 		break;
21012013 	case TARGET_PROT_DOUT_INSERT:
21022014 	case TARGET_PROT_DIN_STRIP:
21032015 		sig_attrs->wire.sig_type = IB_SIG_TYPE_NONE;
2104
-		isert_set_dif_domain(se_cmd, sig_attrs, &sig_attrs->mem);
2016
+		isert_set_dif_domain(se_cmd, &sig_attrs->mem);
21052017 		break;
21062018 	case TARGET_PROT_DIN_PASS:
21072019 	case TARGET_PROT_DOUT_PASS:
2108
-		isert_set_dif_domain(se_cmd, sig_attrs, &sig_attrs->wire);
2109
-		isert_set_dif_domain(se_cmd, sig_attrs, &sig_attrs->mem);
2020
+		isert_set_dif_domain(se_cmd, &sig_attrs->wire);
2021
+		isert_set_dif_domain(se_cmd, &sig_attrs->mem);
21102022 		break;
21112023 	default:
21122024 		isert_err("Unsupported PI operation %d\n", se_cmd->prot_op);
....@@ -2208,10 +2120,8 @@
22082120 				   &isert_cmd->tx_desc.send_wr);
22092121 
22102122 		rc = isert_post_recv(isert_conn, isert_cmd->rx_desc);
2211
-		if (rc) {
2212
-			isert_err("ib_post_recv failed with %d\n", rc);
2123
+		if (rc)
22132124 			return rc;
2214
-		}
22152125 
22162126 		chain_wr = &isert_cmd->tx_desc.send_wr;
22172127 	}
....@@ -2515,6 +2425,7 @@
25152425 {
25162426 	struct isert_np *isert_np = np->np_context;
25172427 	struct isert_conn *isert_conn, *n;
2428
+	LIST_HEAD(drop_conn_list);
25182429 
25192430 	if (isert_np->cm_id)
25202431 		rdma_destroy_id(isert_np->cm_id);
....@@ -2534,7 +2445,7 @@
25342445 					 node) {
25352446 			isert_info("cleaning isert_conn %p state (%d)\n",
25362447 				   isert_conn, isert_conn->state);
2537
-			isert_connect_release(isert_conn);
2448
+			list_move_tail(&isert_conn->node, &drop_conn_list);
25382449 		}
25392450 	}
25402451 
....@@ -2545,11 +2456,16 @@
25452456 					 node) {
25462457 			isert_info("cleaning isert_conn %p state (%d)\n",
25472458 				   isert_conn, isert_conn->state);
2548
-			isert_connect_release(isert_conn);
2459
+			list_move_tail(&isert_conn->node, &drop_conn_list);
25492460 		}
25502461 	}
25512462 	mutex_unlock(&isert_np->mutex);
25522463 
2464
+	list_for_each_entry_safe(isert_conn, n, &drop_conn_list, node) {
2465
+		list_del_init(&isert_conn->node);
2466
+		isert_connect_release(isert_conn);
2467
+	}
2468
+
25532469 	np->np_context = NULL;
25542470 	kfree(isert_np);
25552471 }