Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma
Jason writes:
"Second RDMA rc pull request
- Fix a long standing race bug when destroying comp_event file descriptors
- srp, hfi1, bnxt_re: Various driver crashes from missing validation
and other cases
- Fixes for regressions in patches merged this window in the gid
cache, devx, ucma and uapi."
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma:
RDMA/core: Set right entry state before releasing reference
IB/mlx5: Destroy the DEVX object upon error flow
IB/uverbs: Free uapi on destroy
RDMA/bnxt_re: Fix system crash during RDMA resource initialization
IB/hfi1: Fix destroy_qp hang after a link down
IB/hfi1: Fix context recovery when PBC has an UnsupportedVL
IB/hfi1: Invalid user input can result in crash
IB/hfi1: Fix SL array bounds check
RDMA/uverbs: Fix validity check for modify QP
IB/srp: Avoid that sg_reset -d ${srp_device} triggers an infinite loop
ucma: fix a use-after-free in ucma_resolve_ip()
RDMA/uverbs: Atomically flush and mark closed the comp event queue
cxgb4: fix abort_req_rss6 struct
+199
-145
+49
-49
drivers/infiniband/core/cache.c
+49
-49
drivers/infiniband/core/cache.c
···
338
338
}
339
339
340
340
/**
341
-
* add_modify_gid - Add or modify GID table entry
342
-
*
343
-
* @table: GID table in which GID to be added or modified
344
-
* @attr: Attributes of the GID
345
-
*
346
-
* Returns 0 on success or appropriate error code. It accepts zero
347
-
* GID addition for non RoCE ports for HCA's who report them as valid
348
-
* GID. However such zero GIDs are not added to the cache.
349
-
*/
350
-
static int add_modify_gid(struct ib_gid_table *table,
351
-
const struct ib_gid_attr *attr)
352
-
{
353
-
struct ib_gid_table_entry *entry;
354
-
int ret = 0;
355
-
356
-
/*
357
-
* Invalidate any old entry in the table to make it safe to write to
358
-
* this index.
359
-
*/
360
-
if (is_gid_entry_valid(table->data_vec[attr->index]))
361
-
put_gid_entry(table->data_vec[attr->index]);
362
-
363
-
/*
364
-
* Some HCA's report multiple GID entries with only one valid GID, and
365
-
* leave other unused entries as the zero GID. Convert zero GIDs to
366
-
* empty table entries instead of storing them.
367
-
*/
368
-
if (rdma_is_zero_gid(&attr->gid))
369
-
return 0;
370
-
371
-
entry = alloc_gid_entry(attr);
372
-
if (!entry)
373
-
return -ENOMEM;
374
-
375
-
if (rdma_protocol_roce(attr->device, attr->port_num)) {
376
-
ret = add_roce_gid(entry);
377
-
if (ret)
378
-
goto done;
379
-
}
380
-
381
-
store_gid_entry(table, entry);
382
-
return 0;
383
-
384
-
done:
385
-
put_gid_entry(entry);
386
-
return ret;
387
-
}
388
-
389
-
/**
390
341
* del_gid - Delete GID table entry
391
342
*
392
343
* @ib_dev: IB device whose GID entry to be deleted
···
368
417
write_unlock_irq(&table->rwlock);
369
418
370
419
put_gid_entry_locked(entry);
420
+
}
421
+
422
+
/**
423
+
* add_modify_gid - Add or modify GID table entry
424
+
*
425
+
* @table: GID table in which GID to be added or modified
426
+
* @attr: Attributes of the GID
427
+
*
428
+
* Returns 0 on success or appropriate error code. It accepts zero
429
+
* GID addition for non RoCE ports for HCA's who report them as valid
430
+
* GID. However such zero GIDs are not added to the cache.
431
+
*/
432
+
static int add_modify_gid(struct ib_gid_table *table,
433
+
const struct ib_gid_attr *attr)
434
+
{
435
+
struct ib_gid_table_entry *entry;
436
+
int ret = 0;
437
+
438
+
/*
439
+
* Invalidate any old entry in the table to make it safe to write to
440
+
* this index.
441
+
*/
442
+
if (is_gid_entry_valid(table->data_vec[attr->index]))
443
+
del_gid(attr->device, attr->port_num, table, attr->index);
444
+
445
+
/*
446
+
* Some HCA's report multiple GID entries with only one valid GID, and
447
+
* leave other unused entries as the zero GID. Convert zero GIDs to
448
+
* empty table entries instead of storing them.
449
+
*/
450
+
if (rdma_is_zero_gid(&attr->gid))
451
+
return 0;
452
+
453
+
entry = alloc_gid_entry(attr);
454
+
if (!entry)
455
+
return -ENOMEM;
456
+
457
+
if (rdma_protocol_roce(attr->device, attr->port_num)) {
458
+
ret = add_roce_gid(entry);
459
+
if (ret)
460
+
goto done;
461
+
}
462
+
463
+
store_gid_entry(table, entry);
464
+
return 0;
465
+
466
+
done:
467
+
put_gid_entry(entry);
468
+
return ret;
371
469
}
372
470
373
471
/* rwlock should be read locked, or lock should be held */
+2
drivers/infiniband/core/ucma.c
+2
drivers/infiniband/core/ucma.c
+45
-23
drivers/infiniband/core/uverbs_cmd.c
+45
-23
drivers/infiniband/core/uverbs_cmd.c
···
2027
2027
2028
2028
if ((cmd->base.attr_mask & IB_QP_CUR_STATE &&
2029
2029
cmd->base.cur_qp_state > IB_QPS_ERR) ||
2030
-
cmd->base.qp_state > IB_QPS_ERR) {
2030
+
(cmd->base.attr_mask & IB_QP_STATE &&
2031
+
cmd->base.qp_state > IB_QPS_ERR)) {
2031
2032
ret = -EINVAL;
2032
2033
goto release_qp;
2033
2034
}
2034
2035
2035
-
attr->qp_state = cmd->base.qp_state;
2036
-
attr->cur_qp_state = cmd->base.cur_qp_state;
2037
-
attr->path_mtu = cmd->base.path_mtu;
2038
-
attr->path_mig_state = cmd->base.path_mig_state;
2039
-
attr->qkey = cmd->base.qkey;
2040
-
attr->rq_psn = cmd->base.rq_psn;
2041
-
attr->sq_psn = cmd->base.sq_psn;
2042
-
attr->dest_qp_num = cmd->base.dest_qp_num;
2043
-
attr->qp_access_flags = cmd->base.qp_access_flags;
2044
-
attr->pkey_index = cmd->base.pkey_index;
2045
-
attr->alt_pkey_index = cmd->base.alt_pkey_index;
2046
-
attr->en_sqd_async_notify = cmd->base.en_sqd_async_notify;
2047
-
attr->max_rd_atomic = cmd->base.max_rd_atomic;
2048
-
attr->max_dest_rd_atomic = cmd->base.max_dest_rd_atomic;
2049
-
attr->min_rnr_timer = cmd->base.min_rnr_timer;
2050
-
attr->port_num = cmd->base.port_num;
2051
-
attr->timeout = cmd->base.timeout;
2052
-
attr->retry_cnt = cmd->base.retry_cnt;
2053
-
attr->rnr_retry = cmd->base.rnr_retry;
2054
-
attr->alt_port_num = cmd->base.alt_port_num;
2055
-
attr->alt_timeout = cmd->base.alt_timeout;
2056
-
attr->rate_limit = cmd->rate_limit;
2036
+
if (cmd->base.attr_mask & IB_QP_STATE)
2037
+
attr->qp_state = cmd->base.qp_state;
2038
+
if (cmd->base.attr_mask & IB_QP_CUR_STATE)
2039
+
attr->cur_qp_state = cmd->base.cur_qp_state;
2040
+
if (cmd->base.attr_mask & IB_QP_PATH_MTU)
2041
+
attr->path_mtu = cmd->base.path_mtu;
2042
+
if (cmd->base.attr_mask & IB_QP_PATH_MIG_STATE)
2043
+
attr->path_mig_state = cmd->base.path_mig_state;
2044
+
if (cmd->base.attr_mask & IB_QP_QKEY)
2045
+
attr->qkey = cmd->base.qkey;
2046
+
if (cmd->base.attr_mask & IB_QP_RQ_PSN)
2047
+
attr->rq_psn = cmd->base.rq_psn;
2048
+
if (cmd->base.attr_mask & IB_QP_SQ_PSN)
2049
+
attr->sq_psn = cmd->base.sq_psn;
2050
+
if (cmd->base.attr_mask & IB_QP_DEST_QPN)
2051
+
attr->dest_qp_num = cmd->base.dest_qp_num;
2052
+
if (cmd->base.attr_mask & IB_QP_ACCESS_FLAGS)
2053
+
attr->qp_access_flags = cmd->base.qp_access_flags;
2054
+
if (cmd->base.attr_mask & IB_QP_PKEY_INDEX)
2055
+
attr->pkey_index = cmd->base.pkey_index;
2056
+
if (cmd->base.attr_mask & IB_QP_EN_SQD_ASYNC_NOTIFY)
2057
+
attr->en_sqd_async_notify = cmd->base.en_sqd_async_notify;
2058
+
if (cmd->base.attr_mask & IB_QP_MAX_QP_RD_ATOMIC)
2059
+
attr->max_rd_atomic = cmd->base.max_rd_atomic;
2060
+
if (cmd->base.attr_mask & IB_QP_MAX_DEST_RD_ATOMIC)
2061
+
attr->max_dest_rd_atomic = cmd->base.max_dest_rd_atomic;
2062
+
if (cmd->base.attr_mask & IB_QP_MIN_RNR_TIMER)
2063
+
attr->min_rnr_timer = cmd->base.min_rnr_timer;
2064
+
if (cmd->base.attr_mask & IB_QP_PORT)
2065
+
attr->port_num = cmd->base.port_num;
2066
+
if (cmd->base.attr_mask & IB_QP_TIMEOUT)
2067
+
attr->timeout = cmd->base.timeout;
2068
+
if (cmd->base.attr_mask & IB_QP_RETRY_CNT)
2069
+
attr->retry_cnt = cmd->base.retry_cnt;
2070
+
if (cmd->base.attr_mask & IB_QP_RNR_RETRY)
2071
+
attr->rnr_retry = cmd->base.rnr_retry;
2072
+
if (cmd->base.attr_mask & IB_QP_ALT_PATH) {
2073
+
attr->alt_port_num = cmd->base.alt_port_num;
2074
+
attr->alt_timeout = cmd->base.alt_timeout;
2075
+
attr->alt_pkey_index = cmd->base.alt_pkey_index;
2076
+
}
2077
+
if (cmd->base.attr_mask & IB_QP_RATE_LIMIT)
2078
+
attr->rate_limit = cmd->rate_limit;
2057
2079
2058
2080
if (cmd->base.attr_mask & IB_QP_AV)
2059
2081
copy_ah_attr_from_uverbs(qp->device, &attr->ah_attr,
+1
drivers/infiniband/core/uverbs_main.c
+1
drivers/infiniband/core/uverbs_main.c
+1
drivers/infiniband/core/uverbs_uapi.c
+1
drivers/infiniband/core/uverbs_uapi.c
+38
-55
drivers/infiniband/hw/bnxt_re/main.c
+38
-55
drivers/infiniband/hw/bnxt_re/main.c
···
78
78
/* Mutex to protect the list of bnxt_re devices added */
79
79
static DEFINE_MUTEX(bnxt_re_dev_lock);
80
80
static struct workqueue_struct *bnxt_re_wq;
81
-
static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev, bool lock_wait);
81
+
static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev);
82
82
83
83
/* SR-IOV helper functions */
84
84
···
182
182
if (!rdev)
183
183
return;
184
184
185
-
bnxt_re_ib_unreg(rdev, false);
185
+
bnxt_re_ib_unreg(rdev);
186
186
}
187
187
188
188
static void bnxt_re_stop_irq(void *handle)
···
251
251
/* Driver registration routines used to let the networking driver (bnxt_en)
252
252
* to know that the RoCE driver is now installed
253
253
*/
254
-
static int bnxt_re_unregister_netdev(struct bnxt_re_dev *rdev, bool lock_wait)
254
+
static int bnxt_re_unregister_netdev(struct bnxt_re_dev *rdev)
255
255
{
256
256
struct bnxt_en_dev *en_dev;
257
257
int rc;
···
260
260
return -EINVAL;
261
261
262
262
en_dev = rdev->en_dev;
263
-
/* Acquire rtnl lock if it is not invokded from netdev event */
264
-
if (lock_wait)
265
-
rtnl_lock();
266
263
267
264
rc = en_dev->en_ops->bnxt_unregister_device(rdev->en_dev,
268
265
BNXT_ROCE_ULP);
269
-
if (lock_wait)
270
-
rtnl_unlock();
271
266
return rc;
272
267
}
273
268
···
276
281
277
282
en_dev = rdev->en_dev;
278
283
279
-
rtnl_lock();
280
284
rc = en_dev->en_ops->bnxt_register_device(en_dev, BNXT_ROCE_ULP,
281
285
&bnxt_re_ulp_ops, rdev);
282
-
rtnl_unlock();
283
286
return rc;
284
287
}
285
288
286
-
static int bnxt_re_free_msix(struct bnxt_re_dev *rdev, bool lock_wait)
289
+
static int bnxt_re_free_msix(struct bnxt_re_dev *rdev)
287
290
{
288
291
struct bnxt_en_dev *en_dev;
289
292
int rc;
···
291
298
292
299
en_dev = rdev->en_dev;
293
300
294
-
if (lock_wait)
295
-
rtnl_lock();
296
301
297
302
rc = en_dev->en_ops->bnxt_free_msix(rdev->en_dev, BNXT_ROCE_ULP);
298
303
299
-
if (lock_wait)
300
-
rtnl_unlock();
301
304
return rc;
302
305
}
303
306
···
309
320
310
321
num_msix_want = min_t(u32, BNXT_RE_MAX_MSIX, num_online_cpus());
311
322
312
-
rtnl_lock();
313
323
num_msix_got = en_dev->en_ops->bnxt_request_msix(en_dev, BNXT_ROCE_ULP,
314
324
rdev->msix_entries,
315
325
num_msix_want);
···
323
335
}
324
336
rdev->num_msix = num_msix_got;
325
337
done:
326
-
rtnl_unlock();
327
338
return rc;
328
339
}
329
340
···
345
358
fw_msg->timeout = timeout;
346
359
}
347
360
348
-
static int bnxt_re_net_ring_free(struct bnxt_re_dev *rdev, u16 fw_ring_id,
349
-
bool lock_wait)
361
+
static int bnxt_re_net_ring_free(struct bnxt_re_dev *rdev, u16 fw_ring_id)
350
362
{
351
363
struct bnxt_en_dev *en_dev = rdev->en_dev;
352
364
struct hwrm_ring_free_input req = {0};
353
365
struct hwrm_ring_free_output resp;
354
366
struct bnxt_fw_msg fw_msg;
355
-
bool do_unlock = false;
356
367
int rc = -EINVAL;
357
368
358
369
if (!en_dev)
359
370
return rc;
360
371
361
372
memset(&fw_msg, 0, sizeof(fw_msg));
362
-
if (lock_wait) {
363
-
rtnl_lock();
364
-
do_unlock = true;
365
-
}
366
373
367
374
bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_RING_FREE, -1, -1);
368
375
req.ring_type = RING_ALLOC_REQ_RING_TYPE_L2_CMPL;
···
367
386
if (rc)
368
387
dev_err(rdev_to_dev(rdev),
369
388
"Failed to free HW ring:%d :%#x", req.ring_id, rc);
370
-
if (do_unlock)
371
-
rtnl_unlock();
372
389
return rc;
373
390
}
374
391
···
384
405
return rc;
385
406
386
407
memset(&fw_msg, 0, sizeof(fw_msg));
387
-
rtnl_lock();
388
408
bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_RING_ALLOC, -1, -1);
389
409
req.enables = 0;
390
410
req.page_tbl_addr = cpu_to_le64(dma_arr[0]);
···
404
426
if (!rc)
405
427
*fw_ring_id = le16_to_cpu(resp.ring_id);
406
428
407
-
rtnl_unlock();
408
429
return rc;
409
430
}
410
431
411
432
static int bnxt_re_net_stats_ctx_free(struct bnxt_re_dev *rdev,
412
-
u32 fw_stats_ctx_id, bool lock_wait)
433
+
u32 fw_stats_ctx_id)
413
434
{
414
435
struct bnxt_en_dev *en_dev = rdev->en_dev;
415
436
struct hwrm_stat_ctx_free_input req = {0};
416
437
struct bnxt_fw_msg fw_msg;
417
-
bool do_unlock = false;
418
438
int rc = -EINVAL;
419
439
420
440
if (!en_dev)
421
441
return rc;
422
442
423
443
memset(&fw_msg, 0, sizeof(fw_msg));
424
-
if (lock_wait) {
425
-
rtnl_lock();
426
-
do_unlock = true;
427
-
}
428
444
429
445
bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_STAT_CTX_FREE, -1, -1);
430
446
req.stat_ctx_id = cpu_to_le32(fw_stats_ctx_id);
···
429
457
dev_err(rdev_to_dev(rdev),
430
458
"Failed to free HW stats context %#x", rc);
431
459
432
-
if (do_unlock)
433
-
rtnl_unlock();
434
460
return rc;
435
461
}
436
462
···
448
478
return rc;
449
479
450
480
memset(&fw_msg, 0, sizeof(fw_msg));
451
-
rtnl_lock();
452
481
453
482
bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_STAT_CTX_ALLOC, -1, -1);
454
483
req.update_period_ms = cpu_to_le32(1000);
···
459
490
if (!rc)
460
491
*fw_stats_ctx_id = le32_to_cpu(resp.stat_ctx_id);
461
492
462
-
rtnl_unlock();
463
493
return rc;
464
494
}
465
495
···
897
929
return rc;
898
930
}
899
931
900
-
static void bnxt_re_free_nq_res(struct bnxt_re_dev *rdev, bool lock_wait)
932
+
static void bnxt_re_free_nq_res(struct bnxt_re_dev *rdev)
901
933
{
902
934
int i;
903
935
904
936
for (i = 0; i < rdev->num_msix - 1; i++) {
905
-
bnxt_re_net_ring_free(rdev, rdev->nq[i].ring_id, lock_wait);
937
+
bnxt_re_net_ring_free(rdev, rdev->nq[i].ring_id);
906
938
bnxt_qplib_free_nq(&rdev->nq[i]);
907
939
}
908
940
}
909
941
910
-
static void bnxt_re_free_res(struct bnxt_re_dev *rdev, bool lock_wait)
942
+
static void bnxt_re_free_res(struct bnxt_re_dev *rdev)
911
943
{
912
-
bnxt_re_free_nq_res(rdev, lock_wait);
944
+
bnxt_re_free_nq_res(rdev);
913
945
914
946
if (rdev->qplib_res.dpi_tbl.max) {
915
947
bnxt_qplib_dealloc_dpi(&rdev->qplib_res,
···
1187
1219
return 0;
1188
1220
}
1189
1221
1190
-
static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev, bool lock_wait)
1222
+
static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev)
1191
1223
{
1192
1224
int i, rc;
1193
1225
···
1202
1234
cancel_delayed_work(&rdev->worker);
1203
1235
1204
1236
bnxt_re_cleanup_res(rdev);
1205
-
bnxt_re_free_res(rdev, lock_wait);
1237
+
bnxt_re_free_res(rdev);
1206
1238
1207
1239
if (test_and_clear_bit(BNXT_RE_FLAG_RCFW_CHANNEL_EN, &rdev->flags)) {
1208
1240
rc = bnxt_qplib_deinit_rcfw(&rdev->rcfw);
1209
1241
if (rc)
1210
1242
dev_warn(rdev_to_dev(rdev),
1211
1243
"Failed to deinitialize RCFW: %#x", rc);
1212
-
bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id,
1213
-
lock_wait);
1244
+
bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id);
1214
1245
bnxt_qplib_free_ctx(rdev->en_dev->pdev, &rdev->qplib_ctx);
1215
1246
bnxt_qplib_disable_rcfw_channel(&rdev->rcfw);
1216
-
bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id, lock_wait);
1247
+
bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id);
1217
1248
bnxt_qplib_free_rcfw_channel(&rdev->rcfw);
1218
1249
}
1219
1250
if (test_and_clear_bit(BNXT_RE_FLAG_GOT_MSIX, &rdev->flags)) {
1220
-
rc = bnxt_re_free_msix(rdev, lock_wait);
1251
+
rc = bnxt_re_free_msix(rdev);
1221
1252
if (rc)
1222
1253
dev_warn(rdev_to_dev(rdev),
1223
1254
"Failed to free MSI-X vectors: %#x", rc);
1224
1255
}
1225
1256
if (test_and_clear_bit(BNXT_RE_FLAG_NETDEV_REGISTERED, &rdev->flags)) {
1226
-
rc = bnxt_re_unregister_netdev(rdev, lock_wait);
1257
+
rc = bnxt_re_unregister_netdev(rdev);
1227
1258
if (rc)
1228
1259
dev_warn(rdev_to_dev(rdev),
1229
1260
"Failed to unregister with netdev: %#x", rc);
···
1242
1275
static int bnxt_re_ib_reg(struct bnxt_re_dev *rdev)
1243
1276
{
1244
1277
int i, j, rc;
1278
+
1279
+
bool locked;
1280
+
1281
+
/* Acquire rtnl lock through out this function */
1282
+
rtnl_lock();
1283
+
locked = true;
1245
1284
1246
1285
/* Registered a new RoCE device instance to netdev */
1247
1286
rc = bnxt_re_register_netdev(rdev);
···
1347
1374
schedule_delayed_work(&rdev->worker, msecs_to_jiffies(30000));
1348
1375
}
1349
1376
1377
+
rtnl_unlock();
1378
+
locked = false;
1379
+
1350
1380
/* Register ib dev */
1351
1381
rc = bnxt_re_register_ib(rdev);
1352
1382
if (rc) {
1353
1383
pr_err("Failed to register with IB: %#x\n", rc);
1354
1384
goto fail;
1355
1385
}
1386
+
set_bit(BNXT_RE_FLAG_IBDEV_REGISTERED, &rdev->flags);
1356
1387
dev_info(rdev_to_dev(rdev), "Device registered successfully");
1357
1388
for (i = 0; i < ARRAY_SIZE(bnxt_re_attributes); i++) {
1358
1389
rc = device_create_file(&rdev->ibdev.dev,
···
1372
1395
goto fail;
1373
1396
}
1374
1397
}
1375
-
set_bit(BNXT_RE_FLAG_IBDEV_REGISTERED, &rdev->flags);
1376
1398
ib_get_eth_speed(&rdev->ibdev, 1, &rdev->active_speed,
1377
1399
&rdev->active_width);
1378
1400
set_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS, &rdev->flags);
···
1380
1404
1381
1405
return 0;
1382
1406
free_sctx:
1383
-
bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id, true);
1407
+
bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id);
1384
1408
free_ctx:
1385
1409
bnxt_qplib_free_ctx(rdev->en_dev->pdev, &rdev->qplib_ctx);
1386
1410
disable_rcfw:
1387
1411
bnxt_qplib_disable_rcfw_channel(&rdev->rcfw);
1388
1412
free_ring:
1389
-
bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id, true);
1413
+
bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id);
1390
1414
free_rcfw:
1391
1415
bnxt_qplib_free_rcfw_channel(&rdev->rcfw);
1392
1416
fail:
1393
-
bnxt_re_ib_unreg(rdev, true);
1417
+
if (!locked)
1418
+
rtnl_lock();
1419
+
bnxt_re_ib_unreg(rdev);
1420
+
rtnl_unlock();
1421
+
1394
1422
return rc;
1395
1423
}
1396
1424
···
1547
1567
*/
1548
1568
if (atomic_read(&rdev->sched_count) > 0)
1549
1569
goto exit;
1550
-
bnxt_re_ib_unreg(rdev, false);
1570
+
bnxt_re_ib_unreg(rdev);
1551
1571
bnxt_re_remove_one(rdev);
1552
1572
bnxt_re_dev_unreg(rdev);
1553
1573
break;
···
1626
1646
*/
1627
1647
flush_workqueue(bnxt_re_wq);
1628
1648
bnxt_re_dev_stop(rdev);
1629
-
bnxt_re_ib_unreg(rdev, true);
1649
+
/* Acquire the rtnl_lock as the L2 resources are freed here */
1650
+
rtnl_lock();
1651
+
bnxt_re_ib_unreg(rdev);
1652
+
rtnl_unlock();
1630
1653
bnxt_re_remove_one(rdev);
1631
1654
bnxt_re_dev_unreg(rdev);
1632
1655
}
+5
-1
drivers/infiniband/hw/hfi1/chip.c
+5
-1
drivers/infiniband/hw/hfi1/chip.c
···
6733
6733
struct hfi1_devdata *dd = ppd->dd;
6734
6734
struct send_context *sc;
6735
6735
int i;
6736
+
int sc_flags;
6736
6737
6737
6738
if (flags & FREEZE_SELF)
6738
6739
write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_FREEZE_SMASK);
···
6744
6743
/* notify all SDMA engines that they are going into a freeze */
6745
6744
sdma_freeze_notify(dd, !!(flags & FREEZE_LINK_DOWN));
6746
6745
6746
+
sc_flags = SCF_FROZEN | SCF_HALTED | (flags & FREEZE_LINK_DOWN ?
6747
+
SCF_LINK_DOWN : 0);
6747
6748
/* do halt pre-handling on all enabled send contexts */
6748
6749
for (i = 0; i < dd->num_send_contexts; i++) {
6749
6750
sc = dd->send_contexts[i].sc;
6750
6751
if (sc && (sc->flags & SCF_ENABLED))
6751
-
sc_stop(sc, SCF_FROZEN | SCF_HALTED);
6752
+
sc_stop(sc, sc_flags);
6752
6753
}
6753
6754
6754
6755
/* Send context are frozen. Notify user space */
···
10677
10674
add_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
10678
10675
10679
10676
handle_linkup_change(dd, 1);
10677
+
pio_kernel_linkup(dd);
10680
10678
10681
10679
/*
10682
10680
* After link up, a new link width will have been set.
+41
-10
drivers/infiniband/hw/hfi1/pio.c
+41
-10
drivers/infiniband/hw/hfi1/pio.c
···
86
86
unsigned long flags;
87
87
int write = 1; /* write sendctrl back */
88
88
int flush = 0; /* re-read sendctrl to make sure it is flushed */
89
+
int i;
89
90
90
91
spin_lock_irqsave(&dd->sendctrl_lock, flags);
91
92
···
96
95
reg |= SEND_CTRL_SEND_ENABLE_SMASK;
97
96
/* Fall through */
98
97
case PSC_DATA_VL_ENABLE:
98
+
mask = 0;
99
+
for (i = 0; i < ARRAY_SIZE(dd->vld); i++)
100
+
if (!dd->vld[i].mtu)
101
+
mask |= BIT_ULL(i);
99
102
/* Disallow sending on VLs not enabled */
100
-
mask = (((~0ull) << num_vls) & SEND_CTRL_UNSUPPORTED_VL_MASK) <<
101
-
SEND_CTRL_UNSUPPORTED_VL_SHIFT;
103
+
mask = (mask & SEND_CTRL_UNSUPPORTED_VL_MASK) <<
104
+
SEND_CTRL_UNSUPPORTED_VL_SHIFT;
102
105
reg = (reg & ~SEND_CTRL_UNSUPPORTED_VL_SMASK) | mask;
103
106
break;
104
107
case PSC_GLOBAL_DISABLE:
···
926
921
void sc_disable(struct send_context *sc)
927
922
{
928
923
u64 reg;
929
-
unsigned long flags;
930
924
struct pio_buf *pbuf;
931
925
932
926
if (!sc)
933
927
return;
934
928
935
929
/* do all steps, even if already disabled */
936
-
spin_lock_irqsave(&sc->alloc_lock, flags);
930
+
spin_lock_irq(&sc->alloc_lock);
937
931
reg = read_kctxt_csr(sc->dd, sc->hw_context, SC(CTRL));
938
932
reg &= ~SC(CTRL_CTXT_ENABLE_SMASK);
939
933
sc->flags &= ~SCF_ENABLED;
940
934
sc_wait_for_packet_egress(sc, 1);
941
935
write_kctxt_csr(sc->dd, sc->hw_context, SC(CTRL), reg);
942
-
spin_unlock_irqrestore(&sc->alloc_lock, flags);
943
936
944
937
/*
945
938
* Flush any waiters. Once the context is disabled,
···
947
944
* proceed with the flush.
948
945
*/
949
946
udelay(1);
950
-
spin_lock_irqsave(&sc->release_lock, flags);
947
+
spin_lock(&sc->release_lock);
951
948
if (sc->sr) { /* this context has a shadow ring */
952
949
while (sc->sr_tail != sc->sr_head) {
953
950
pbuf = &sc->sr[sc->sr_tail].pbuf;
···
958
955
sc->sr_tail = 0;
959
956
}
960
957
}
961
-
spin_unlock_irqrestore(&sc->release_lock, flags);
958
+
spin_unlock(&sc->release_lock);
959
+
spin_unlock_irq(&sc->alloc_lock);
962
960
}
963
961
964
962
/* return SendEgressCtxtStatus.PacketOccupancy */
···
1182
1178
sc = dd->send_contexts[i].sc;
1183
1179
if (!sc || !(sc->flags & SCF_FROZEN) || sc->type == SC_USER)
1184
1180
continue;
1181
+
if (sc->flags & SCF_LINK_DOWN)
1182
+
continue;
1185
1183
1186
1184
sc_enable(sc); /* will clear the sc frozen flag */
1185
+
}
1186
+
}
1187
+
1188
+
/**
1189
+
* pio_kernel_linkup() - Re-enable send contexts after linkup event
1190
+
* @dd: valid devive data
1191
+
*
1192
+
* When the link goes down, the freeze path is taken. However, a link down
1193
+
* event is different from a freeze because if the send context is re-enabled
1194
+
* whowever is sending data will start sending data again, which will hang
1195
+
* any QP that is sending data.
1196
+
*
1197
+
* The freeze path now looks at the type of event that occurs and takes this
1198
+
* path for link down event.
1199
+
*/
1200
+
void pio_kernel_linkup(struct hfi1_devdata *dd)
1201
+
{
1202
+
struct send_context *sc;
1203
+
int i;
1204
+
1205
+
for (i = 0; i < dd->num_send_contexts; i++) {
1206
+
sc = dd->send_contexts[i].sc;
1207
+
if (!sc || !(sc->flags & SCF_LINK_DOWN) || sc->type == SC_USER)
1208
+
continue;
1209
+
1210
+
sc_enable(sc); /* will clear the sc link down flag */
1187
1211
}
1188
1212
}
1189
1213
···
1414
1382
{
1415
1383
unsigned long flags;
1416
1384
1417
-
/* mark the context */
1418
-
sc->flags |= flag;
1419
-
1420
1385
/* stop buffer allocations */
1421
1386
spin_lock_irqsave(&sc->alloc_lock, flags);
1387
+
/* mark the context */
1388
+
sc->flags |= flag;
1422
1389
sc->flags &= ~SCF_ENABLED;
1423
1390
spin_unlock_irqrestore(&sc->alloc_lock, flags);
1424
1391
wake_up(&sc->halt_wait);
+2
drivers/infiniband/hw/hfi1/pio.h
+2
drivers/infiniband/hw/hfi1/pio.h
···
139
139
#define SCF_IN_FREE 0x02
140
140
#define SCF_HALTED 0x04
141
141
#define SCF_FROZEN 0x08
142
+
#define SCF_LINK_DOWN 0x10
142
143
143
144
struct send_context_info {
144
145
struct send_context *sc; /* allocated working context */
···
307
306
void pio_reset_all(struct hfi1_devdata *dd);
308
307
void pio_freeze(struct hfi1_devdata *dd);
309
308
void pio_kernel_unfreeze(struct hfi1_devdata *dd);
309
+
void pio_kernel_linkup(struct hfi1_devdata *dd);
310
310
311
311
/* global PIO send control operations */
312
312
#define PSC_GLOBAL_ENABLE 0
+1
-1
drivers/infiniband/hw/hfi1/user_sdma.c
+1
-1
drivers/infiniband/hw/hfi1/user_sdma.c
+7
-1
drivers/infiniband/hw/hfi1/verbs.c
+7
-1
drivers/infiniband/hw/hfi1/verbs.c
···
1582
1582
struct hfi1_pportdata *ppd;
1583
1583
struct hfi1_devdata *dd;
1584
1584
u8 sc5;
1585
+
u8 sl;
1585
1586
1586
1587
if (hfi1_check_mcast(rdma_ah_get_dlid(ah_attr)) &&
1587
1588
!(rdma_ah_get_ah_flags(ah_attr) & IB_AH_GRH))
···
1591
1590
/* test the mapping for validity */
1592
1591
ibp = to_iport(ibdev, rdma_ah_get_port_num(ah_attr));
1593
1592
ppd = ppd_from_ibp(ibp);
1594
-
sc5 = ibp->sl_to_sc[rdma_ah_get_sl(ah_attr)];
1595
1593
dd = dd_from_ppd(ppd);
1594
+
1595
+
sl = rdma_ah_get_sl(ah_attr);
1596
+
if (sl >= ARRAY_SIZE(ibp->sl_to_sc))
1597
+
return -EINVAL;
1598
+
1599
+
sc5 = ibp->sl_to_sc[sl];
1596
1600
if (sc_to_vlt(dd, sc5) > num_vls && sc_to_vlt(dd, sc5) != 0xf)
1597
1601
return -EINVAL;
1598
1602
return 0;
+4
-1
drivers/infiniband/hw/mlx5/devx.c
+4
-1
drivers/infiniband/hw/mlx5/devx.c
···
723
723
attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_HANDLE);
724
724
struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
725
725
struct mlx5_ib_dev *dev = to_mdev(c->ibucontext.device);
726
+
u32 out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)];
726
727
struct devx_obj *obj;
727
728
int err;
728
729
···
755
754
756
755
err = uverbs_copy_to(attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_CMD_OUT, cmd_out, cmd_out_len);
757
756
if (err)
758
-
goto obj_free;
757
+
goto obj_destroy;
759
758
760
759
return 0;
761
760
761
+
obj_destroy:
762
+
mlx5_cmd_exec(obj->mdev, obj->dinbox, obj->dinlen, out, sizeof(out));
762
763
obj_free:
763
764
kfree(obj);
764
765
return err;
+3
-3
drivers/infiniband/ulp/srp/ib_srp.c
+3
-3
drivers/infiniband/ulp/srp/ib_srp.c
···
2951
2951
{
2952
2952
struct srp_target_port *target = host_to_target(scmnd->device->host);
2953
2953
struct srp_rdma_ch *ch;
2954
-
int i;
2954
+
int i, j;
2955
2955
u8 status;
2956
2956
2957
2957
shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
···
2965
2965
2966
2966
for (i = 0; i < target->ch_count; i++) {
2967
2967
ch = &target->ch[i];
2968
-
for (i = 0; i < target->req_ring_size; ++i) {
2969
-
struct srp_request *req = &ch->req_ring[i];
2968
+
for (j = 0; j < target->req_ring_size; ++j) {
2969
+
struct srp_request *req = &ch->req_ring[j];
2970
2970
2971
2971
srp_finish_req(ch, req, scmnd->device, DID_RESET << 16);
2972
2972
}