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/dledford/rdma
Pull rdma fixes from Doug Ledford:
"Three late 4.4-rc fixes.
The first two were very small in terms of number of lines, the third
is more lines of change than I like this late in the cycle, but there
are positive test results from Avagotech and from my own test setup
with the target hardware, and given the problem was a 100% failure
case, I sent it through.
- A previous patch updated the mlx4 driver to use vmalloc when there
was not enough memory to get a contiguous region large enough for
our needs, so we need kvfree() whenever we free that item. We
missed one place, so fix that now.
- A previous patch added code to match incoming packets against a
specific device, but failed to compensate for devices that have
both InfiniBand and Ethernet ports. Fix that.
- Under certain vlan conditions, the ocrdma driver would fail to
bring up any vlan interfaces and would print out a circular locking
failure. Fix that"
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma:
RDMA/be2net: Remove open and close entry points
RDMA/ocrdma: Depend on async link events from CNA
RDMA/ocrdma: Dispatch only port event when port state changes
RDMA/ocrdma: Fix vlan-id assignment in qp parameters
IB/mlx4: Replace kfree with kvfree in mlx4_ib_destroy_srq
IB/cma: cma_match_net_dev needs to take into account port_num
+134
-101
+9
-7
drivers/infiniband/core/cma.c
+9
-7
drivers/infiniband/core/cma.c
···
1265
1265
return cma_protocol_roce_dev_port(device, port_num);
1266
1266
}
1267
1267
1268
-
static bool cma_match_net_dev(const struct rdma_id_private *id_priv,
1269
-
const struct net_device *net_dev)
1268
+
static bool cma_match_net_dev(const struct rdma_cm_id *id,
1269
+
const struct net_device *net_dev,
1270
+
u8 port_num)
1270
1271
{
1271
-
const struct rdma_addr *addr = &id_priv->id.route.addr;
1272
+
const struct rdma_addr *addr = &id->route.addr;
1272
1273
1273
1274
if (!net_dev)
1274
1275
/* This request is an AF_IB request or a RoCE request */
1275
-
return addr->src_addr.ss_family == AF_IB ||
1276
-
cma_protocol_roce(&id_priv->id);
1276
+
return (!id->port_num || id->port_num == port_num) &&
1277
+
(addr->src_addr.ss_family == AF_IB ||
1278
+
cma_protocol_roce_dev_port(id->device, port_num));
1277
1279
1278
1280
return !addr->dev_addr.bound_dev_if ||
1279
1281
(net_eq(dev_net(net_dev), addr->dev_addr.net) &&
···
1297
1295
hlist_for_each_entry(id_priv, &bind_list->owners, node) {
1298
1296
if (cma_match_private_data(id_priv, ib_event->private_data)) {
1299
1297
if (id_priv->id.device == cm_id->device &&
1300
-
cma_match_net_dev(id_priv, net_dev))
1298
+
cma_match_net_dev(&id_priv->id, net_dev, req->port))
1301
1299
return id_priv;
1302
1300
list_for_each_entry(id_priv_dev,
1303
1301
&id_priv->listen_list,
1304
1302
listen_list) {
1305
1303
if (id_priv_dev->id.device == cm_id->device &&
1306
-
cma_match_net_dev(id_priv_dev, net_dev))
1304
+
cma_match_net_dev(&id_priv_dev->id, net_dev, req->port))
1307
1305
return id_priv_dev;
1308
1306
}
1309
1307
}
+1
-1
drivers/infiniband/hw/mlx4/srq.c
+1
-1
drivers/infiniband/hw/mlx4/srq.c
···
286
286
mlx4_ib_db_unmap_user(to_mucontext(srq->uobject->context), &msrq->db);
287
287
ib_umem_release(msrq->umem);
288
288
} else {
289
-
kfree(msrq->wrid);
289
+
kvfree(msrq->wrid);
290
290
mlx4_buf_free(dev->dev, msrq->msrq.max << msrq->msrq.wqe_shift,
291
291
&msrq->buf);
292
292
mlx4_db_free(dev->dev, &msrq->db);
+10
drivers/infiniband/hw/ocrdma/ocrdma.h
+10
drivers/infiniband/hw/ocrdma/ocrdma.h
···
232
232
u16 interface_type;
233
233
};
234
234
235
+
enum ocrdma_flags {
236
+
OCRDMA_FLAGS_LINK_STATUS_INIT = 0x01
237
+
};
238
+
235
239
struct ocrdma_dev {
236
240
struct ib_device ibdev;
237
241
struct ocrdma_dev_attr attr;
···
291
287
atomic_t update_sl;
292
288
u16 pvid;
293
289
u32 asic_id;
290
+
u32 flags;
294
291
295
292
ulong last_stats_time;
296
293
struct mutex stats_lock; /* provide synch for debugfs operations */
···
594
589
*/
595
590
return (state & OCRDMA_STATE_FLAG_ENABLED) &&
596
591
(state & OCRDMA_STATE_FLAG_SYNC);
592
+
}
593
+
594
+
static inline u8 ocrdma_get_ae_link_state(u32 ae_state)
595
+
{
596
+
return ((ae_state & OCRDMA_AE_LSC_LS_MASK) >> OCRDMA_AE_LSC_LS_SHIFT);
597
597
}
598
598
599
599
#endif
+39
-10
drivers/infiniband/hw/ocrdma/ocrdma_hw.c
+39
-10
drivers/infiniband/hw/ocrdma/ocrdma_hw.c
···
579
579
580
580
cmd->async_event_bitmap = BIT(OCRDMA_ASYNC_GRP5_EVE_CODE);
581
581
cmd->async_event_bitmap |= BIT(OCRDMA_ASYNC_RDMA_EVE_CODE);
582
+
/* Request link events on this MQ. */
583
+
cmd->async_event_bitmap |= BIT(OCRDMA_ASYNC_LINK_EVE_CODE);
582
584
583
585
cmd->async_cqid_ringsize = cq->id;
584
586
cmd->async_cqid_ringsize |= (ocrdma_encoded_q_len(mq->len) <<
···
821
819
}
822
820
}
823
821
822
+
static void ocrdma_process_link_state(struct ocrdma_dev *dev,
823
+
struct ocrdma_ae_mcqe *cqe)
824
+
{
825
+
struct ocrdma_ae_lnkst_mcqe *evt;
826
+
u8 lstate;
827
+
828
+
evt = (struct ocrdma_ae_lnkst_mcqe *)cqe;
829
+
lstate = ocrdma_get_ae_link_state(evt->speed_state_ptn);
830
+
831
+
if (!(lstate & OCRDMA_AE_LSC_LLINK_MASK))
832
+
return;
833
+
834
+
if (dev->flags & OCRDMA_FLAGS_LINK_STATUS_INIT)
835
+
ocrdma_update_link_state(dev, (lstate & OCRDMA_LINK_ST_MASK));
836
+
}
837
+
824
838
static void ocrdma_process_acqe(struct ocrdma_dev *dev, void *ae_cqe)
825
839
{
826
840
/* async CQE processing */
827
841
struct ocrdma_ae_mcqe *cqe = ae_cqe;
828
842
u32 evt_code = (cqe->valid_ae_event & OCRDMA_AE_MCQE_EVENT_CODE_MASK) >>
829
843
OCRDMA_AE_MCQE_EVENT_CODE_SHIFT;
830
-
831
-
if (evt_code == OCRDMA_ASYNC_RDMA_EVE_CODE)
844
+
switch (evt_code) {
845
+
case OCRDMA_ASYNC_LINK_EVE_CODE:
846
+
ocrdma_process_link_state(dev, cqe);
847
+
break;
848
+
case OCRDMA_ASYNC_RDMA_EVE_CODE:
832
849
ocrdma_dispatch_ibevent(dev, cqe);
833
-
else if (evt_code == OCRDMA_ASYNC_GRP5_EVE_CODE)
850
+
break;
851
+
case OCRDMA_ASYNC_GRP5_EVE_CODE:
834
852
ocrdma_process_grp5_aync(dev, cqe);
835
-
else
853
+
break;
854
+
default:
836
855
pr_err("%s(%d) invalid evt code=0x%x\n", __func__,
837
856
dev->id, evt_code);
857
+
}
838
858
}
839
859
840
860
static void ocrdma_process_mcqe(struct ocrdma_dev *dev, struct ocrdma_mcqe *cqe)
···
1387
1363
return status;
1388
1364
}
1389
1365
1390
-
int ocrdma_mbx_get_link_speed(struct ocrdma_dev *dev, u8 *lnk_speed)
1366
+
int ocrdma_mbx_get_link_speed(struct ocrdma_dev *dev, u8 *lnk_speed,
1367
+
u8 *lnk_state)
1391
1368
{
1392
1369
int status = -ENOMEM;
1393
1370
struct ocrdma_get_link_speed_rsp *rsp;
···
1409
1384
goto mbx_err;
1410
1385
1411
1386
rsp = (struct ocrdma_get_link_speed_rsp *)cmd;
1412
-
*lnk_speed = (rsp->pflt_pps_ld_pnum & OCRDMA_PHY_PS_MASK)
1413
-
>> OCRDMA_PHY_PS_SHIFT;
1387
+
if (lnk_speed)
1388
+
*lnk_speed = (rsp->pflt_pps_ld_pnum & OCRDMA_PHY_PS_MASK)
1389
+
>> OCRDMA_PHY_PS_SHIFT;
1390
+
if (lnk_state)
1391
+
*lnk_state = (rsp->res_lnk_st & OCRDMA_LINK_ST_MASK);
1414
1392
1415
1393
mbx_err:
1416
1394
kfree(cmd);
···
2543
2515
ocrdma_cpu_to_le32(&cmd->params.sgid[0], sizeof(cmd->params.sgid));
2544
2516
cmd->params.vlan_dmac_b4_to_b5 = mac_addr[4] | (mac_addr[5] << 8);
2545
2517
2546
-
if (vlan_id < 0x1000) {
2547
-
if (dev->pfc_state) {
2548
-
vlan_id = 0;
2518
+
if (vlan_id == 0xFFFF)
2519
+
vlan_id = 0;
2520
+
if (vlan_id || dev->pfc_state) {
2521
+
if (!vlan_id) {
2549
2522
pr_err("ocrdma%d:Using VLAN with PFC is recommended\n",
2550
2523
dev->id);
2551
2524
pr_err("ocrdma%d:Using VLAN 0 for this connection\n",
+3
-1
drivers/infiniband/hw/ocrdma/ocrdma_hw.h
+3
-1
drivers/infiniband/hw/ocrdma/ocrdma_hw.h
···
106
106
bool solicited, u16 cqe_popped);
107
107
108
108
/* verbs specific mailbox commands */
109
-
int ocrdma_mbx_get_link_speed(struct ocrdma_dev *dev, u8 *lnk_speed);
109
+
int ocrdma_mbx_get_link_speed(struct ocrdma_dev *dev, u8 *lnk_speed,
110
+
u8 *lnk_st);
110
111
int ocrdma_query_config(struct ocrdma_dev *,
111
112
struct ocrdma_mbx_query_config *config);
112
113
···
154
153
void ocrdma_init_service_level(struct ocrdma_dev *);
155
154
void ocrdma_alloc_pd_pool(struct ocrdma_dev *dev);
156
155
void ocrdma_free_pd_range(struct ocrdma_dev *dev);
156
+
void ocrdma_update_link_state(struct ocrdma_dev *dev, u8 lstate);
157
157
158
158
#endif /* __OCRDMA_HW_H__ */
+25
-32
drivers/infiniband/hw/ocrdma/ocrdma_main.c
+25
-32
drivers/infiniband/hw/ocrdma/ocrdma_main.c
···
290
290
static struct ocrdma_dev *ocrdma_add(struct be_dev_info *dev_info)
291
291
{
292
292
int status = 0, i;
293
+
u8 lstate = 0;
293
294
struct ocrdma_dev *dev;
294
295
295
296
dev = (struct ocrdma_dev *)ib_alloc_device(sizeof(struct ocrdma_dev));
···
319
318
status = ocrdma_register_device(dev);
320
319
if (status)
321
320
goto alloc_err;
321
+
322
+
/* Query Link state and update */
323
+
status = ocrdma_mbx_get_link_speed(dev, NULL, &lstate);
324
+
if (!status)
325
+
ocrdma_update_link_state(dev, lstate);
322
326
323
327
for (i = 0; i < ARRAY_SIZE(ocrdma_attributes); i++)
324
328
if (device_create_file(&dev->ibdev.dev, ocrdma_attributes[i]))
···
379
373
ocrdma_remove_free(dev);
380
374
}
381
375
382
-
static int ocrdma_open(struct ocrdma_dev *dev)
376
+
static int ocrdma_dispatch_port_active(struct ocrdma_dev *dev)
383
377
{
384
378
struct ib_event port_event;
385
379
···
390
384
return 0;
391
385
}
392
386
393
-
static int ocrdma_close(struct ocrdma_dev *dev)
387
+
static int ocrdma_dispatch_port_error(struct ocrdma_dev *dev)
394
388
{
395
-
int i;
396
-
struct ocrdma_qp *qp, **cur_qp;
397
389
struct ib_event err_event;
398
-
struct ib_qp_attr attrs;
399
-
int attr_mask = IB_QP_STATE;
400
-
401
-
attrs.qp_state = IB_QPS_ERR;
402
-
mutex_lock(&dev->dev_lock);
403
-
if (dev->qp_tbl) {
404
-
cur_qp = dev->qp_tbl;
405
-
for (i = 0; i < OCRDMA_MAX_QP; i++) {
406
-
qp = cur_qp[i];
407
-
if (qp && qp->ibqp.qp_type != IB_QPT_GSI) {
408
-
/* change the QP state to ERROR */
409
-
_ocrdma_modify_qp(&qp->ibqp, &attrs, attr_mask);
410
-
411
-
err_event.event = IB_EVENT_QP_FATAL;
412
-
err_event.element.qp = &qp->ibqp;
413
-
err_event.device = &dev->ibdev;
414
-
ib_dispatch_event(&err_event);
415
-
}
416
-
}
417
-
}
418
-
mutex_unlock(&dev->dev_lock);
419
390
420
391
err_event.event = IB_EVENT_PORT_ERR;
421
392
err_event.element.port_num = 1;
···
403
420
404
421
static void ocrdma_shutdown(struct ocrdma_dev *dev)
405
422
{
406
-
ocrdma_close(dev);
423
+
ocrdma_dispatch_port_error(dev);
407
424
ocrdma_remove(dev);
408
425
}
409
426
···
414
431
static void ocrdma_event_handler(struct ocrdma_dev *dev, u32 event)
415
432
{
416
433
switch (event) {
417
-
case BE_DEV_UP:
418
-
ocrdma_open(dev);
419
-
break;
420
-
case BE_DEV_DOWN:
421
-
ocrdma_close(dev);
422
-
break;
423
434
case BE_DEV_SHUTDOWN:
424
435
ocrdma_shutdown(dev);
425
436
break;
437
+
default:
438
+
break;
426
439
}
440
+
}
441
+
442
+
void ocrdma_update_link_state(struct ocrdma_dev *dev, u8 lstate)
443
+
{
444
+
if (!(dev->flags & OCRDMA_FLAGS_LINK_STATUS_INIT)) {
445
+
dev->flags |= OCRDMA_FLAGS_LINK_STATUS_INIT;
446
+
if (!lstate)
447
+
return;
448
+
}
449
+
450
+
if (!lstate)
451
+
ocrdma_dispatch_port_error(dev);
452
+
else
453
+
ocrdma_dispatch_port_active(dev);
427
454
}
428
455
429
456
static struct ocrdma_driver ocrdma_drv = {
+45
-4
drivers/infiniband/hw/ocrdma/ocrdma_sli.h
+45
-4
drivers/infiniband/hw/ocrdma/ocrdma_sli.h
···
465
465
u32 valid_ae_event;
466
466
};
467
467
468
-
#define OCRDMA_ASYNC_RDMA_EVE_CODE 0x14
469
-
#define OCRDMA_ASYNC_GRP5_EVE_CODE 0x5
468
+
enum ocrdma_async_event_code {
469
+
OCRDMA_ASYNC_LINK_EVE_CODE = 0x01,
470
+
OCRDMA_ASYNC_GRP5_EVE_CODE = 0x05,
471
+
OCRDMA_ASYNC_RDMA_EVE_CODE = 0x14
472
+
};
470
473
471
474
enum ocrdma_async_grp5_events {
472
475
OCRDMA_ASYNC_EVENT_QOS_VALUE = 0x01,
···
490
487
OCRDMA_QP_LAST_WQE_EVENT = 0x10,
491
488
492
489
OCRDMA_MAX_ASYNC_ERRORS
490
+
};
491
+
492
+
struct ocrdma_ae_lnkst_mcqe {
493
+
u32 speed_state_ptn;
494
+
u32 qos_reason_falut;
495
+
u32 evt_tag;
496
+
u32 valid_ae_event;
497
+
};
498
+
499
+
enum {
500
+
OCRDMA_AE_LSC_PORT_NUM_MASK = 0x3F,
501
+
OCRDMA_AE_LSC_PT_SHIFT = 0x06,
502
+
OCRDMA_AE_LSC_PT_MASK = (0x03 <<
503
+
OCRDMA_AE_LSC_PT_SHIFT),
504
+
OCRDMA_AE_LSC_LS_SHIFT = 0x08,
505
+
OCRDMA_AE_LSC_LS_MASK = (0xFF <<
506
+
OCRDMA_AE_LSC_LS_SHIFT),
507
+
OCRDMA_AE_LSC_LD_SHIFT = 0x10,
508
+
OCRDMA_AE_LSC_LD_MASK = (0xFF <<
509
+
OCRDMA_AE_LSC_LD_SHIFT),
510
+
OCRDMA_AE_LSC_PPS_SHIFT = 0x18,
511
+
OCRDMA_AE_LSC_PPS_MASK = (0xFF <<
512
+
OCRDMA_AE_LSC_PPS_SHIFT),
513
+
OCRDMA_AE_LSC_PPF_MASK = 0xFF,
514
+
OCRDMA_AE_LSC_ER_SHIFT = 0x08,
515
+
OCRDMA_AE_LSC_ER_MASK = (0xFF <<
516
+
OCRDMA_AE_LSC_ER_SHIFT),
517
+
OCRDMA_AE_LSC_QOS_SHIFT = 0x10,
518
+
OCRDMA_AE_LSC_QOS_MASK = (0xFFFF <<
519
+
OCRDMA_AE_LSC_QOS_SHIFT)
520
+
};
521
+
522
+
enum {
523
+
OCRDMA_AE_LSC_PLINK_DOWN = 0x00,
524
+
OCRDMA_AE_LSC_PLINK_UP = 0x01,
525
+
OCRDMA_AE_LSC_LLINK_DOWN = 0x02,
526
+
OCRDMA_AE_LSC_LLINK_MASK = 0x02,
527
+
OCRDMA_AE_LSC_LLINK_UP = 0x03
493
528
};
494
529
495
530
/* mailbox command request and responses */
···
717
676
OCRDMA_PHY_PFLT_SHIFT = 0x18,
718
677
OCRDMA_QOS_LNKSP_MASK = 0xFFFF0000,
719
678
OCRDMA_QOS_LNKSP_SHIFT = 0x10,
720
-
OCRDMA_LLST_MASK = 0xFF,
679
+
OCRDMA_LINK_ST_MASK = 0x01,
721
680
OCRDMA_PLFC_MASK = 0x00000400,
722
681
OCRDMA_PLFC_SHIFT = 0x8,
723
682
OCRDMA_PLRFC_MASK = 0x00000200,
···
732
691
733
692
u32 pflt_pps_ld_pnum;
734
693
u32 qos_lsp;
735
-
u32 res_lls;
694
+
u32 res_lnk_st;
736
695
};
737
696
738
697
enum {
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
-2
drivers/net/ethernet/emulex/benet/be.h
-2
drivers/net/ethernet/emulex/benet/be.h
-4
drivers/net/ethernet/emulex/benet/be_main.c
-4
drivers/net/ethernet/emulex/benet/be_main.c
···
3432
3432
3433
3433
be_disable_if_filters(adapter);
3434
3434
3435
-
be_roce_dev_close(adapter);
3436
-
3437
3435
if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
3438
3436
for_all_evt_queues(adapter, eqo, i) {
3439
3437
napi_disable(&eqo->napi);
···
3599
3601
be_link_status_update(adapter, link_status);
3600
3602
3601
3603
netif_tx_start_all_queues(netdev);
3602
-
be_roce_dev_open(adapter);
3603
-
3604
3604
#ifdef CONFIG_BE2NET_VXLAN
3605
3605
if (skyhawk_chip(adapter))
3606
3606
vxlan_get_rx_port(netdev);
-36
drivers/net/ethernet/emulex/benet/be_roce.c
-36
drivers/net/ethernet/emulex/benet/be_roce.c
···
116
116
}
117
117
}
118
118
119
-
static void _be_roce_dev_open(struct be_adapter *adapter)
120
-
{
121
-
if (ocrdma_drv && adapter->ocrdma_dev &&
122
-
ocrdma_drv->state_change_handler)
123
-
ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
124
-
BE_DEV_UP);
125
-
}
126
-
127
-
void be_roce_dev_open(struct be_adapter *adapter)
128
-
{
129
-
if (be_roce_supported(adapter)) {
130
-
mutex_lock(&be_adapter_list_lock);
131
-
_be_roce_dev_open(adapter);
132
-
mutex_unlock(&be_adapter_list_lock);
133
-
}
134
-
}
135
-
136
-
static void _be_roce_dev_close(struct be_adapter *adapter)
137
-
{
138
-
if (ocrdma_drv && adapter->ocrdma_dev &&
139
-
ocrdma_drv->state_change_handler)
140
-
ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
141
-
BE_DEV_DOWN);
142
-
}
143
-
144
-
void be_roce_dev_close(struct be_adapter *adapter)
145
-
{
146
-
if (be_roce_supported(adapter)) {
147
-
mutex_lock(&be_adapter_list_lock);
148
-
_be_roce_dev_close(adapter);
149
-
mutex_unlock(&be_adapter_list_lock);
150
-
}
151
-
}
152
-
153
119
void be_roce_dev_shutdown(struct be_adapter *adapter)
154
120
{
155
121
if (be_roce_supported(adapter)) {
···
143
177
144
178
_be_roce_dev_add(dev);
145
179
netdev = dev->netdev;
146
-
if (netif_running(netdev) && netif_oper_up(netdev))
147
-
_be_roce_dev_open(dev);
148
180
}
149
181
mutex_unlock(&be_adapter_list_lock);
150
182
return 0;