Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending
Pull SCSI target fixes from Nicholas Bellinger:
"Here are the target-pending fixes queued for v3.18-rc6.
The highlights include:
- target-core OOPs fix with tcm_qla2xxx + vxworks FC initiators +
zero length SCSI commands having a transfer direction set. (Roland
+ Craig Watson)
- vhost-scsi OOPs fix to explicitly prevent WWPN endpoint configfs
group removal while qemu still has an active reference. (Paolo +
nab)
- ib_srpt fix for RDMA hardware with lower srp_sq_size limits.
(Bart)
- two ib_isert work-arounds for running on ocrdma hardware (Or + Sagi
+ Chris)
- iscsi-target discovery portal typo + SPC-3 PR Preempt SA key
matching fix (Steve)"
* git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending:
IB/isert: Adjust CQ size to HW limits
target: return CONFLICT only when SA key unmatched
iser-target: Handle DEVICE_REMOVAL event on network portal listener correctly
ib_isert: Add max_send_sge=2 minimum for control PDU responses
srp-target: Retry when QP creation fails with ENOMEM
iscsi-target: return the correct port in SendTargets
vhost-scsi: Take configfs group dependency during VHOST_SCSI_SET_ENDPOINT
target: Don't call TFO->write_pending if data_length == 0
+69
-20
+30
-14
drivers/infiniband/ulp/isert/ib_isert.c
+30
-14
drivers/infiniband/ulp/isert/ib_isert.c
···
115
115
attr.cap.max_recv_wr = ISERT_QP_MAX_RECV_DTOS;
116
116
/*
117
117
* FIXME: Use devattr.max_sge - 2 for max_send_sge as
118
-
* work-around for RDMA_READ..
118
+
* work-around for RDMA_READs with ConnectX-2.
119
+
*
120
+
* Also, still make sure to have at least two SGEs for
121
+
* outgoing control PDU responses.
119
122
*/
120
-
attr.cap.max_send_sge = device->dev_attr.max_sge - 2;
123
+
attr.cap.max_send_sge = max(2, device->dev_attr.max_sge - 2);
121
124
isert_conn->max_sge = attr.cap.max_send_sge;
122
125
123
126
attr.cap.max_recv_sge = 1;
···
228
225
struct isert_cq_desc *cq_desc;
229
226
struct ib_device_attr *dev_attr;
230
227
int ret = 0, i, j;
228
+
int max_rx_cqe, max_tx_cqe;
231
229
232
230
dev_attr = &device->dev_attr;
233
231
ret = isert_query_device(ib_dev, dev_attr);
234
232
if (ret)
235
233
return ret;
234
+
235
+
max_rx_cqe = min(ISER_MAX_RX_CQ_LEN, dev_attr->max_cqe);
236
+
max_tx_cqe = min(ISER_MAX_TX_CQ_LEN, dev_attr->max_cqe);
236
237
237
238
/* asign function handlers */
238
239
if (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS &&
···
279
272
isert_cq_rx_callback,
280
273
isert_cq_event_callback,
281
274
(void *)&cq_desc[i],
282
-
ISER_MAX_RX_CQ_LEN, i);
275
+
max_rx_cqe, i);
283
276
if (IS_ERR(device->dev_rx_cq[i])) {
284
277
ret = PTR_ERR(device->dev_rx_cq[i]);
285
278
device->dev_rx_cq[i] = NULL;
···
291
284
isert_cq_tx_callback,
292
285
isert_cq_event_callback,
293
286
(void *)&cq_desc[i],
294
-
ISER_MAX_TX_CQ_LEN, i);
287
+
max_tx_cqe, i);
295
288
if (IS_ERR(device->dev_tx_cq[i])) {
296
289
ret = PTR_ERR(device->dev_tx_cq[i]);
297
290
device->dev_tx_cq[i] = NULL;
···
810
803
complete(&isert_conn->conn_wait);
811
804
}
812
805
813
-
static void
806
+
static int
814
807
isert_disconnected_handler(struct rdma_cm_id *cma_id, bool disconnect)
815
808
{
816
-
struct isert_conn *isert_conn = (struct isert_conn *)cma_id->context;
809
+
struct isert_conn *isert_conn;
810
+
811
+
if (!cma_id->qp) {
812
+
struct isert_np *isert_np = cma_id->context;
813
+
814
+
isert_np->np_cm_id = NULL;
815
+
return -1;
816
+
}
817
+
818
+
isert_conn = (struct isert_conn *)cma_id->context;
817
819
818
820
isert_conn->disconnect = disconnect;
819
821
INIT_WORK(&isert_conn->conn_logout_work, isert_disconnect_work);
820
822
schedule_work(&isert_conn->conn_logout_work);
823
+
824
+
return 0;
821
825
}
822
826
823
827
static int
···
843
825
switch (event->event) {
844
826
case RDMA_CM_EVENT_CONNECT_REQUEST:
845
827
ret = isert_connect_request(cma_id, event);
828
+
if (ret)
829
+
pr_err("isert_cma_handler failed RDMA_CM_EVENT: 0x%08x %d\n",
830
+
event->event, ret);
846
831
break;
847
832
case RDMA_CM_EVENT_ESTABLISHED:
848
833
isert_connected_handler(cma_id);
···
855
834
case RDMA_CM_EVENT_DEVICE_REMOVAL: /* FALLTHRU */
856
835
disconnect = true;
857
836
case RDMA_CM_EVENT_TIMEWAIT_EXIT: /* FALLTHRU */
858
-
isert_disconnected_handler(cma_id, disconnect);
837
+
ret = isert_disconnected_handler(cma_id, disconnect);
859
838
break;
860
839
case RDMA_CM_EVENT_CONNECT_ERROR:
861
840
default:
862
841
pr_err("Unhandled RDMA CMA event: %d\n", event->event);
863
842
break;
864
-
}
865
-
866
-
if (ret != 0) {
867
-
pr_err("isert_cma_handler failed RDMA_CM_EVENT: 0x%08x %d\n",
868
-
event->event, ret);
869
-
dump_stack();
870
843
}
871
844
872
845
return ret;
···
3205
3190
{
3206
3191
struct isert_np *isert_np = (struct isert_np *)np->np_context;
3207
3192
3208
-
rdma_destroy_id(isert_np->np_cm_id);
3193
+
if (isert_np->np_cm_id)
3194
+
rdma_destroy_id(isert_np->np_cm_id);
3209
3195
3210
3196
np->np_context = NULL;
3211
3197
kfree(isert_np);
+8
drivers/infiniband/ulp/srpt/ib_srpt.c
+8
drivers/infiniband/ulp/srpt/ib_srpt.c
···
2092
2092
if (!qp_init)
2093
2093
goto out;
2094
2094
2095
+
retry:
2095
2096
ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch,
2096
2097
ch->rq_size + srp_sq_size, 0);
2097
2098
if (IS_ERR(ch->cq)) {
···
2116
2115
ch->qp = ib_create_qp(sdev->pd, qp_init);
2117
2116
if (IS_ERR(ch->qp)) {
2118
2117
ret = PTR_ERR(ch->qp);
2118
+
if (ret == -ENOMEM) {
2119
+
srp_sq_size /= 2;
2120
+
if (srp_sq_size >= MIN_SRPT_SQ_SIZE) {
2121
+
ib_destroy_cq(ch->cq);
2122
+
goto retry;
2123
+
}
2124
+
}
2119
2125
printk(KERN_ERR "failed to create_qp ret= %d\n", ret);
2120
2126
goto err_destroy_cq;
2121
2127
}
+1
-1
drivers/target/iscsi/iscsi_target.c
+1
-1
drivers/target/iscsi/iscsi_target.c
+5
-4
drivers/target/target_core_pr.c
+5
-4
drivers/target/target_core_pr.c
···
2738
2738
struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
2739
2739
struct t10_reservation *pr_tmpl = &dev->t10_pr;
2740
2740
u32 pr_res_mapped_lun = 0;
2741
-
int all_reg = 0, calling_it_nexus = 0, released_regs = 0;
2741
+
int all_reg = 0, calling_it_nexus = 0;
2742
+
bool sa_res_key_unmatched = sa_res_key != 0;
2742
2743
int prh_type = 0, prh_scope = 0;
2743
2744
2744
2745
if (!se_sess)
···
2814
2813
if (!all_reg) {
2815
2814
if (pr_reg->pr_res_key != sa_res_key)
2816
2815
continue;
2816
+
sa_res_key_unmatched = false;
2817
2817
2818
2818
calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2819
2819
pr_reg_nacl = pr_reg->pr_reg_nacl;
···
2822
2820
__core_scsi3_free_registration(dev, pr_reg,
2823
2821
(preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
2824
2822
NULL, calling_it_nexus);
2825
-
released_regs++;
2826
2823
} else {
2827
2824
/*
2828
2825
* Case for any existing all registrants type
···
2839
2838
if ((sa_res_key) &&
2840
2839
(pr_reg->pr_res_key != sa_res_key))
2841
2840
continue;
2841
+
sa_res_key_unmatched = false;
2842
2842
2843
2843
calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2844
2844
if (calling_it_nexus)
···
2850
2848
__core_scsi3_free_registration(dev, pr_reg,
2851
2849
(preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
2852
2850
NULL, 0);
2853
-
released_regs++;
2854
2851
}
2855
2852
if (!calling_it_nexus)
2856
2853
core_scsi3_ua_allocate(pr_reg_nacl,
···
2864
2863
* registered reservation key, then the device server shall
2865
2864
* complete the command with RESERVATION CONFLICT status.
2866
2865
*/
2867
-
if (!released_regs) {
2866
+
if (sa_res_key_unmatched) {
2868
2867
spin_unlock(&dev->dev_reservation_lock);
2869
2868
core_scsi3_put_pr_reg(pr_reg_n);
2870
2869
return TCM_RESERVATION_CONFLICT;
+1
-1
drivers/target/target_core_transport.c
+1
-1
drivers/target/target_core_transport.c
···
2292
2292
* and let it call back once the write buffers are ready.
2293
2293
*/
2294
2294
target_add_to_state_list(cmd);
2295
-
if (cmd->data_direction != DMA_TO_DEVICE) {
2295
+
if (cmd->data_direction != DMA_TO_DEVICE || cmd->data_length == 0) {
2296
2296
target_execute_cmd(cmd);
2297
2297
return 0;
2298
2298
}
+24
drivers/vhost/scsi.c
+24
drivers/vhost/scsi.c
···
1312
1312
vhost_scsi_set_endpoint(struct vhost_scsi *vs,
1313
1313
struct vhost_scsi_target *t)
1314
1314
{
1315
+
struct se_portal_group *se_tpg;
1315
1316
struct tcm_vhost_tport *tv_tport;
1316
1317
struct tcm_vhost_tpg *tpg;
1317
1318
struct tcm_vhost_tpg **vs_tpg;
···
1360
1359
ret = -EEXIST;
1361
1360
goto out;
1362
1361
}
1362
+
/*
1363
+
* In order to ensure individual vhost-scsi configfs
1364
+
* groups cannot be removed while in use by vhost ioctl,
1365
+
* go ahead and take an explicit se_tpg->tpg_group.cg_item
1366
+
* dependency now.
1367
+
*/
1368
+
se_tpg = &tpg->se_tpg;
1369
+
ret = configfs_depend_item(se_tpg->se_tpg_tfo->tf_subsys,
1370
+
&se_tpg->tpg_group.cg_item);
1371
+
if (ret) {
1372
+
pr_warn("configfs_depend_item() failed: %d\n", ret);
1373
+
kfree(vs_tpg);
1374
+
mutex_unlock(&tpg->tv_tpg_mutex);
1375
+
goto out;
1376
+
}
1363
1377
tpg->tv_tpg_vhost_count++;
1364
1378
tpg->vhost_scsi = vs;
1365
1379
vs_tpg[tpg->tport_tpgt] = tpg;
···
1417
1401
vhost_scsi_clear_endpoint(struct vhost_scsi *vs,
1418
1402
struct vhost_scsi_target *t)
1419
1403
{
1404
+
struct se_portal_group *se_tpg;
1420
1405
struct tcm_vhost_tport *tv_tport;
1421
1406
struct tcm_vhost_tpg *tpg;
1422
1407
struct vhost_virtqueue *vq;
···
1466
1449
vs->vs_tpg[target] = NULL;
1467
1450
match = true;
1468
1451
mutex_unlock(&tpg->tv_tpg_mutex);
1452
+
/*
1453
+
* Release se_tpg->tpg_group.cg_item configfs dependency now
1454
+
* to allow vhost-scsi WWPN se_tpg->tpg_group shutdown to occur.
1455
+
*/
1456
+
se_tpg = &tpg->se_tpg;
1457
+
configfs_undepend_item(se_tpg->se_tpg_tfo->tf_subsys,
1458
+
&se_tpg->tpg_group.cg_item);
1469
1459
}
1470
1460
if (match) {
1471
1461
for (i = 0; i < VHOST_SCSI_MAX_VQ; i++) {