Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband
Pull RDMA/InfiniBand fixes from Roland Dreier:
- Fix some rough edges from the "IP addressing for IBoE" merge
- Other misc fixes, mostly to hardware drivers
* tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (21 commits)
RDMA/ocrdma: Fix load time panic during GID table init
RDMA/ocrdma: Fix traffic class shift
IB/iser: Fix use after free in iser_snd_completion()
IB/iser: Avoid dereferencing iscsi_iser conn object when not bound to iser connection
IB/usnic: Fix smatch endianness error
IB/mlx5: Remove dependency on X86
mlx5: Add include of <linux/slab.h> because of kzalloc()/kfree() use
IB/qib: Add missing serdes init sequence
RDMA/cxgb4: Add missing neigh_release in LE-Workaround path
IB: Report using RoCE IP based gids in port caps
IB/mlx4: Build the port IBoE GID table properly under bonding
IB/mlx4: Do IBoE GID table resets per-port
IB/mlx4: Do IBoE locking earlier when initializing the GID table
IB/mlx4: Move rtnl locking to the right place
IB/mlx4: Make sure GID index 0 is always occupied
IB/mlx4: Don't allocate range of steerable UD QPs for Ethernet-only device
RDMA/amso1100: Fix error return code
RDMA/nes: Fix error return code
IB/mlx5: Don't set "block multicast loopback" capability
IB/mlx5: Fix binary compatibility with libmlx5
...
+214
-74
+3
-1
drivers/infiniband/hw/amso1100/c2.c
+3
-1
drivers/infiniband/hw/amso1100/c2.c
···
1082
1082
1083
1083
/* Initialize network device */
1084
1084
if ((netdev = c2_devinit(c2dev, mmio_regs)) == NULL) {
1085
+
ret = -ENOMEM;
1085
1086
iounmap(mmio_regs);
1086
1087
goto bail4;
1087
1088
}
···
1152
1151
goto bail10;
1153
1152
}
1154
1153
1155
-
if (c2_register_device(c2dev))
1154
+
ret = c2_register_device(c2dev);
1155
+
if (ret)
1156
1156
goto bail10;
1157
1157
1158
1158
return 0;
+2
-1
drivers/infiniband/hw/amso1100/c2_rnic.c
+2
-1
drivers/infiniband/hw/amso1100/c2_rnic.c
+1
drivers/infiniband/hw/cxgb4/cm.c
+1
drivers/infiniband/hw/cxgb4/cm.c
+134
-51
drivers/infiniband/hw/mlx4/main.c
+134
-51
drivers/infiniband/hw/mlx4/main.c
···
347
347
props->active_width = (((u8 *)mailbox->buf)[5] == 0x40) ?
348
348
IB_WIDTH_4X : IB_WIDTH_1X;
349
349
props->active_speed = IB_SPEED_QDR;
350
-
props->port_cap_flags = IB_PORT_CM_SUP;
350
+
props->port_cap_flags = IB_PORT_CM_SUP | IB_PORT_IP_BASED_GIDS;
351
351
props->gid_tbl_len = mdev->dev->caps.gid_table_len[port];
352
352
props->max_msg_sz = mdev->dev->caps.max_msg_sz;
353
353
props->pkey_tbl_len = 1;
···
1357
1357
&dev_attr_board_id
1358
1358
};
1359
1359
1360
+
static void mlx4_addrconf_ifid_eui48(u8 *eui, u16 vlan_id,
1361
+
struct net_device *dev)
1362
+
{
1363
+
memcpy(eui, dev->dev_addr, 3);
1364
+
memcpy(eui + 5, dev->dev_addr + 3, 3);
1365
+
if (vlan_id < 0x1000) {
1366
+
eui[3] = vlan_id >> 8;
1367
+
eui[4] = vlan_id & 0xff;
1368
+
} else {
1369
+
eui[3] = 0xff;
1370
+
eui[4] = 0xfe;
1371
+
}
1372
+
eui[0] ^= 2;
1373
+
}
1374
+
1360
1375
static void update_gids_task(struct work_struct *work)
1361
1376
{
1362
1377
struct update_gid_work *gw = container_of(work, struct update_gid_work, work);
···
1408
1393
struct mlx4_cmd_mailbox *mailbox;
1409
1394
union ib_gid *gids;
1410
1395
int err;
1411
-
int i;
1412
1396
struct mlx4_dev *dev = gw->dev->dev;
1413
1397
1414
1398
mailbox = mlx4_alloc_cmd_mailbox(dev);
···
1419
1405
gids = mailbox->buf;
1420
1406
memcpy(gids, gw->gids, sizeof(gw->gids));
1421
1407
1422
-
for (i = 1; i < gw->dev->num_ports + 1; i++) {
1423
-
if (mlx4_ib_port_link_layer(&gw->dev->ib_dev, i) ==
1424
-
IB_LINK_LAYER_ETHERNET) {
1425
-
err = mlx4_cmd(dev, mailbox->dma,
1426
-
MLX4_SET_PORT_GID_TABLE << 8 | i,
1427
-
1, MLX4_CMD_SET_PORT,
1428
-
MLX4_CMD_TIME_CLASS_B,
1429
-
MLX4_CMD_WRAPPED);
1430
-
if (err)
1431
-
pr_warn(KERN_WARNING
1432
-
"set port %d command failed\n", i);
1433
-
}
1408
+
if (mlx4_ib_port_link_layer(&gw->dev->ib_dev, gw->port) ==
1409
+
IB_LINK_LAYER_ETHERNET) {
1410
+
err = mlx4_cmd(dev, mailbox->dma,
1411
+
MLX4_SET_PORT_GID_TABLE << 8 | gw->port,
1412
+
1, MLX4_CMD_SET_PORT,
1413
+
MLX4_CMD_TIME_CLASS_B,
1414
+
MLX4_CMD_WRAPPED);
1415
+
if (err)
1416
+
pr_warn(KERN_WARNING
1417
+
"set port %d command failed\n", gw->port);
1434
1418
}
1435
1419
1436
1420
mlx4_free_cmd_mailbox(dev, mailbox);
···
1437
1425
}
1438
1426
1439
1427
static int update_gid_table(struct mlx4_ib_dev *dev, int port,
1440
-
union ib_gid *gid, int clear)
1428
+
union ib_gid *gid, int clear,
1429
+
int default_gid)
1441
1430
{
1442
1431
struct update_gid_work *work;
1443
1432
int i;
···
1447
1434
int found = -1;
1448
1435
int max_gids;
1449
1436
1450
-
max_gids = dev->dev->caps.gid_table_len[port];
1451
-
for (i = 0; i < max_gids; ++i) {
1452
-
if (!memcmp(&dev->iboe.gid_table[port - 1][i], gid,
1453
-
sizeof(*gid)))
1454
-
found = i;
1455
-
1456
-
if (clear) {
1457
-
if (found >= 0) {
1458
-
need_update = 1;
1459
-
dev->iboe.gid_table[port - 1][found] = zgid;
1460
-
break;
1461
-
}
1462
-
} else {
1463
-
if (found >= 0)
1464
-
break;
1465
-
1466
-
if (free < 0 &&
1467
-
!memcmp(&dev->iboe.gid_table[port - 1][i], &zgid,
1437
+
if (default_gid) {
1438
+
free = 0;
1439
+
} else {
1440
+
max_gids = dev->dev->caps.gid_table_len[port];
1441
+
for (i = 1; i < max_gids; ++i) {
1442
+
if (!memcmp(&dev->iboe.gid_table[port - 1][i], gid,
1468
1443
sizeof(*gid)))
1469
-
free = i;
1444
+
found = i;
1445
+
1446
+
if (clear) {
1447
+
if (found >= 0) {
1448
+
need_update = 1;
1449
+
dev->iboe.gid_table[port - 1][found] =
1450
+
zgid;
1451
+
break;
1452
+
}
1453
+
} else {
1454
+
if (found >= 0)
1455
+
break;
1456
+
1457
+
if (free < 0 &&
1458
+
!memcmp(&dev->iboe.gid_table[port - 1][i],
1459
+
&zgid, sizeof(*gid)))
1460
+
free = i;
1461
+
}
1470
1462
}
1471
1463
}
1472
1464
···
1496
1478
return 0;
1497
1479
}
1498
1480
1499
-
static int reset_gid_table(struct mlx4_ib_dev *dev)
1481
+
static void mlx4_make_default_gid(struct net_device *dev, union ib_gid *gid)
1482
+
{
1483
+
gid->global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
1484
+
mlx4_addrconf_ifid_eui48(&gid->raw[8], 0xffff, dev);
1485
+
}
1486
+
1487
+
1488
+
static int reset_gid_table(struct mlx4_ib_dev *dev, u8 port)
1500
1489
{
1501
1490
struct update_gid_work *work;
1502
-
1503
1491
1504
1492
work = kzalloc(sizeof(*work), GFP_ATOMIC);
1505
1493
if (!work)
1506
1494
return -ENOMEM;
1507
-
memset(dev->iboe.gid_table, 0, sizeof(dev->iboe.gid_table));
1495
+
1496
+
memset(dev->iboe.gid_table[port - 1], 0, sizeof(work->gids));
1508
1497
memset(work->gids, 0, sizeof(work->gids));
1509
1498
INIT_WORK(&work->work, reset_gids_task);
1510
1499
work->dev = dev;
1500
+
work->port = port;
1511
1501
queue_work(wq, &work->work);
1512
1502
return 0;
1513
1503
}
···
1528
1502
struct net_device *real_dev = rdma_vlan_dev_real_dev(event_netdev) ?
1529
1503
rdma_vlan_dev_real_dev(event_netdev) :
1530
1504
event_netdev;
1505
+
union ib_gid default_gid;
1506
+
1507
+
mlx4_make_default_gid(real_dev, &default_gid);
1508
+
1509
+
if (!memcmp(gid, &default_gid, sizeof(*gid)))
1510
+
return 0;
1531
1511
1532
1512
if (event != NETDEV_DOWN && event != NETDEV_UP)
1533
1513
return 0;
···
1552
1520
(!netif_is_bond_master(real_dev) &&
1553
1521
(real_dev == iboe->netdevs[port - 1])))
1554
1522
update_gid_table(ibdev, port, gid,
1555
-
event == NETDEV_DOWN);
1523
+
event == NETDEV_DOWN, 0);
1556
1524
1557
1525
spin_unlock(&iboe->lock);
1558
1526
return 0;
···
1568
1536
rdma_vlan_dev_real_dev(dev) : dev;
1569
1537
1570
1538
iboe = &ibdev->iboe;
1571
-
spin_lock(&iboe->lock);
1572
1539
1573
1540
for (port = 1; port <= MLX4_MAX_PORTS; ++port)
1574
1541
if ((netif_is_bond_master(real_dev) &&
···
1575
1544
(!netif_is_bond_master(real_dev) &&
1576
1545
(real_dev == iboe->netdevs[port - 1])))
1577
1546
break;
1578
-
1579
-
spin_unlock(&iboe->lock);
1580
1547
1581
1548
if ((port == 0) || (port > MLX4_MAX_PORTS))
1582
1549
return 0;
···
1636
1607
/*ifa->ifa_address;*/
1637
1608
ipv6_addr_set_v4mapped(ifa->ifa_address,
1638
1609
(struct in6_addr *)&gid);
1639
-
update_gid_table(ibdev, port, &gid, 0);
1610
+
update_gid_table(ibdev, port, &gid, 0, 0);
1640
1611
}
1641
1612
endfor_ifa(in_dev);
1642
1613
in_dev_put(in_dev);
···
1648
1619
read_lock_bh(&in6_dev->lock);
1649
1620
list_for_each_entry(ifp, &in6_dev->addr_list, if_list) {
1650
1621
pgid = (union ib_gid *)&ifp->addr;
1651
-
update_gid_table(ibdev, port, pgid, 0);
1622
+
update_gid_table(ibdev, port, pgid, 0, 0);
1652
1623
}
1653
1624
read_unlock_bh(&in6_dev->lock);
1654
1625
in6_dev_put(in6_dev);
···
1656
1627
#endif
1657
1628
}
1658
1629
1630
+
static void mlx4_ib_set_default_gid(struct mlx4_ib_dev *ibdev,
1631
+
struct net_device *dev, u8 port)
1632
+
{
1633
+
union ib_gid gid;
1634
+
mlx4_make_default_gid(dev, &gid);
1635
+
update_gid_table(ibdev, port, &gid, 0, 1);
1636
+
}
1637
+
1659
1638
static int mlx4_ib_init_gid_table(struct mlx4_ib_dev *ibdev)
1660
1639
{
1661
1640
struct net_device *dev;
1641
+
struct mlx4_ib_iboe *iboe = &ibdev->iboe;
1642
+
int i;
1662
1643
1663
-
if (reset_gid_table(ibdev))
1664
-
return -1;
1644
+
for (i = 1; i <= ibdev->num_ports; ++i)
1645
+
if (reset_gid_table(ibdev, i))
1646
+
return -1;
1665
1647
1666
1648
read_lock(&dev_base_lock);
1649
+
spin_lock(&iboe->lock);
1667
1650
1668
1651
for_each_netdev(&init_net, dev) {
1669
1652
u8 port = mlx4_ib_get_dev_port(dev, ibdev);
···
1683
1642
mlx4_ib_get_dev_addr(dev, ibdev, port);
1684
1643
}
1685
1644
1645
+
spin_unlock(&iboe->lock);
1686
1646
read_unlock(&dev_base_lock);
1687
1647
1688
1648
return 0;
···
1698
1656
1699
1657
spin_lock(&iboe->lock);
1700
1658
mlx4_foreach_ib_transport_port(port, ibdev->dev) {
1659
+
enum ib_port_state port_state = IB_PORT_NOP;
1701
1660
struct net_device *old_master = iboe->masters[port - 1];
1661
+
struct net_device *curr_netdev;
1702
1662
struct net_device *curr_master;
1663
+
1703
1664
iboe->netdevs[port - 1] =
1704
1665
mlx4_get_protocol_dev(ibdev->dev, MLX4_PROT_ETH, port);
1666
+
if (iboe->netdevs[port - 1])
1667
+
mlx4_ib_set_default_gid(ibdev,
1668
+
iboe->netdevs[port - 1], port);
1669
+
curr_netdev = iboe->netdevs[port - 1];
1705
1670
1706
1671
if (iboe->netdevs[port - 1] &&
1707
1672
netif_is_bond_slave(iboe->netdevs[port - 1])) {
1708
-
rtnl_lock();
1709
1673
iboe->masters[port - 1] = netdev_master_upper_dev_get(
1710
1674
iboe->netdevs[port - 1]);
1711
-
rtnl_unlock();
1675
+
} else {
1676
+
iboe->masters[port - 1] = NULL;
1712
1677
}
1713
1678
curr_master = iboe->masters[port - 1];
1714
1679
1680
+
if (curr_netdev) {
1681
+
port_state = (netif_running(curr_netdev) && netif_carrier_ok(curr_netdev)) ?
1682
+
IB_PORT_ACTIVE : IB_PORT_DOWN;
1683
+
mlx4_ib_set_default_gid(ibdev, curr_netdev, port);
1684
+
} else {
1685
+
reset_gid_table(ibdev, port);
1686
+
}
1687
+
/* if using bonding/team and a slave port is down, we don't the bond IP
1688
+
* based gids in the table since flows that select port by gid may get
1689
+
* the down port.
1690
+
*/
1691
+
if (curr_master && (port_state == IB_PORT_DOWN)) {
1692
+
reset_gid_table(ibdev, port);
1693
+
mlx4_ib_set_default_gid(ibdev, curr_netdev, port);
1694
+
}
1715
1695
/* if bonding is used it is possible that we add it to masters
1716
-
only after IP address is assigned to the net bonding
1717
-
interface */
1718
-
if (curr_master && (old_master != curr_master))
1696
+
* only after IP address is assigned to the net bonding
1697
+
* interface.
1698
+
*/
1699
+
if (curr_master && (old_master != curr_master)) {
1700
+
reset_gid_table(ibdev, port);
1701
+
mlx4_ib_set_default_gid(ibdev, curr_netdev, port);
1719
1702
mlx4_ib_get_dev_addr(curr_master, ibdev, port);
1703
+
}
1704
+
1705
+
if (!curr_master && (old_master != curr_master)) {
1706
+
reset_gid_table(ibdev, port);
1707
+
mlx4_ib_set_default_gid(ibdev, curr_netdev, port);
1708
+
mlx4_ib_get_dev_addr(curr_netdev, ibdev, port);
1709
+
}
1720
1710
}
1721
1711
1722
1712
spin_unlock(&iboe->lock);
···
1884
1810
int i, j;
1885
1811
int err;
1886
1812
struct mlx4_ib_iboe *iboe;
1813
+
int ib_num_ports = 0;
1887
1814
1888
1815
pr_info_once("%s", mlx4_ib_version);
1889
1816
···
2060
1985
ibdev->counters[i] = -1;
2061
1986
}
2062
1987
1988
+
mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
1989
+
ib_num_ports++;
1990
+
2063
1991
spin_lock_init(&ibdev->sm_lock);
2064
1992
mutex_init(&ibdev->cap_mask_mutex);
2065
1993
2066
-
if (ibdev->steering_support == MLX4_STEERING_MODE_DEVICE_MANAGED) {
1994
+
if (ibdev->steering_support == MLX4_STEERING_MODE_DEVICE_MANAGED &&
1995
+
ib_num_ports) {
2067
1996
ibdev->steer_qpn_count = MLX4_IB_UC_MAX_NUM_QPS;
2068
1997
err = mlx4_qp_reserve_range(dev, ibdev->steer_qpn_count,
2069
1998
MLX4_IB_UC_STEER_QPN_ALIGN,
···
2130
2051
}
2131
2052
}
2132
2053
#endif
2054
+
for (i = 1 ; i <= ibdev->num_ports ; ++i)
2055
+
reset_gid_table(ibdev, i);
2056
+
rtnl_lock();
2133
2057
mlx4_ib_scan_netdevs(ibdev);
2058
+
rtnl_unlock();
2134
2059
mlx4_ib_init_gid_table(ibdev);
2135
2060
}
2136
2061
+1
-1
drivers/infiniband/hw/mlx5/Kconfig
+1
-1
drivers/infiniband/hw/mlx5/Kconfig
+18
-4
drivers/infiniband/hw/mlx5/main.c
+18
-4
drivers/infiniband/hw/mlx5/main.c
···
261
261
props->device_cap_flags = IB_DEVICE_CHANGE_PHY_PORT |
262
262
IB_DEVICE_PORT_ACTIVE_EVENT |
263
263
IB_DEVICE_SYS_IMAGE_GUID |
264
-
IB_DEVICE_RC_RNR_NAK_GEN |
265
-
IB_DEVICE_BLOCK_MULTICAST_LOOPBACK;
264
+
IB_DEVICE_RC_RNR_NAK_GEN;
266
265
flags = dev->mdev.caps.flags;
267
266
if (flags & MLX5_DEV_CAP_FLAG_BAD_PKEY_CNTR)
268
267
props->device_cap_flags |= IB_DEVICE_BAD_PKEY_CNTR;
···
535
536
struct ib_udata *udata)
536
537
{
537
538
struct mlx5_ib_dev *dev = to_mdev(ibdev);
538
-
struct mlx5_ib_alloc_ucontext_req req;
539
+
struct mlx5_ib_alloc_ucontext_req_v2 req;
539
540
struct mlx5_ib_alloc_ucontext_resp resp;
540
541
struct mlx5_ib_ucontext *context;
541
542
struct mlx5_uuar_info *uuari;
542
543
struct mlx5_uar *uars;
543
544
int gross_uuars;
544
545
int num_uars;
546
+
int ver;
545
547
int uuarn;
546
548
int err;
547
549
int i;
550
+
int reqlen;
548
551
549
552
if (!dev->ib_active)
550
553
return ERR_PTR(-EAGAIN);
551
554
552
-
err = ib_copy_from_udata(&req, udata, sizeof(req));
555
+
memset(&req, 0, sizeof(req));
556
+
reqlen = udata->inlen - sizeof(struct ib_uverbs_cmd_hdr);
557
+
if (reqlen == sizeof(struct mlx5_ib_alloc_ucontext_req))
558
+
ver = 0;
559
+
else if (reqlen == sizeof(struct mlx5_ib_alloc_ucontext_req_v2))
560
+
ver = 2;
561
+
else
562
+
return ERR_PTR(-EINVAL);
563
+
564
+
err = ib_copy_from_udata(&req, udata, reqlen);
553
565
if (err)
554
566
return ERR_PTR(err);
567
+
568
+
if (req.flags || req.reserved)
569
+
return ERR_PTR(-EINVAL);
555
570
556
571
if (req.total_num_uuars > MLX5_MAX_UUARS)
557
572
return ERR_PTR(-ENOMEM);
···
639
626
if (err)
640
627
goto out_uars;
641
628
629
+
uuari->ver = ver;
642
630
uuari->num_low_latency_uuars = req.num_low_latency_uuars;
643
631
uuari->uars = uars;
644
632
uuari->num_uars = num_uars;
+13
-5
drivers/infiniband/hw/mlx5/qp.c
+13
-5
drivers/infiniband/hw/mlx5/qp.c
···
216
216
217
217
case IB_QPT_UC:
218
218
size += sizeof(struct mlx5_wqe_ctrl_seg) +
219
-
sizeof(struct mlx5_wqe_raddr_seg);
219
+
sizeof(struct mlx5_wqe_raddr_seg) +
220
+
sizeof(struct mlx5_wqe_umr_ctrl_seg) +
221
+
sizeof(struct mlx5_mkey_seg);
220
222
break;
221
223
222
224
case IB_QPT_UD:
···
430
428
break;
431
429
432
430
case MLX5_IB_LATENCY_CLASS_MEDIUM:
433
-
uuarn = alloc_med_class_uuar(uuari);
431
+
if (uuari->ver < 2)
432
+
uuarn = -ENOMEM;
433
+
else
434
+
uuarn = alloc_med_class_uuar(uuari);
434
435
break;
435
436
436
437
case MLX5_IB_LATENCY_CLASS_HIGH:
437
-
uuarn = alloc_high_class_uuar(uuari);
438
+
if (uuari->ver < 2)
439
+
uuarn = -ENOMEM;
440
+
else
441
+
uuarn = alloc_high_class_uuar(uuari);
438
442
break;
439
443
440
444
case MLX5_IB_LATENCY_CLASS_FAST_PATH:
···
665
657
int err;
666
658
667
659
uuari = &dev->mdev.priv.uuari;
668
-
if (init_attr->create_flags & IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK)
669
-
qp->flags |= MLX5_IB_QP_BLOCK_MULTICAST_LOOPBACK;
660
+
if (init_attr->create_flags)
661
+
return -EINVAL;
670
662
671
663
if (init_attr->qp_type == MLX5_IB_QPT_REG_UMR)
672
664
lc = MLX5_IB_LATENCY_CLASS_FAST_PATH;
+7
drivers/infiniband/hw/mlx5/user.h
+7
drivers/infiniband/hw/mlx5/user.h
···
62
62
__u32 num_low_latency_uuars;
63
63
};
64
64
65
+
struct mlx5_ib_alloc_ucontext_req_v2 {
66
+
__u32 total_num_uuars;
67
+
__u32 num_low_latency_uuars;
68
+
__u32 flags;
69
+
__u32 reserved;
70
+
};
71
+
65
72
struct mlx5_ib_alloc_ucontext_resp {
66
73
__u32 qp_tab_size;
67
74
__u32 bf_reg_size;
+4
-1
drivers/infiniband/hw/nes/nes.c
+4
-1
drivers/infiniband/hw/nes/nes.c
···
675
675
INIT_DELAYED_WORK(&nesdev->work, nes_recheck_link_status);
676
676
677
677
/* Initialize network devices */
678
-
if ((netdev = nes_netdev_init(nesdev, mmio_regs)) == NULL)
678
+
netdev = nes_netdev_init(nesdev, mmio_regs);
679
+
if (netdev == NULL) {
680
+
ret = -ENOMEM;
679
681
goto bail7;
682
+
}
680
683
681
684
/* Register network device */
682
685
ret = register_netdev(netdev);
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_main.c
+1
-1
drivers/infiniband/hw/ocrdma/ocrdma_main.c
+2
-2
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+2
-2
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
···
176
176
props->port_cap_flags =
177
177
IB_PORT_CM_SUP |
178
178
IB_PORT_REINIT_SUP |
179
-
IB_PORT_DEVICE_MGMT_SUP | IB_PORT_VENDOR_CLASS_SUP;
179
+
IB_PORT_DEVICE_MGMT_SUP | IB_PORT_VENDOR_CLASS_SUP | IB_PORT_IP_BASED_GIDS;
180
180
props->gid_tbl_len = OCRDMA_MAX_SGID;
181
181
props->pkey_tbl_len = 1;
182
182
props->bad_pkey_cntr = 0;
···
1416
1416
OCRDMA_QP_PARAMS_HOP_LMT_MASK) >>
1417
1417
OCRDMA_QP_PARAMS_HOP_LMT_SHIFT;
1418
1418
qp_attr->ah_attr.grh.traffic_class = (params.tclass_sq_psn &
1419
-
OCRDMA_QP_PARAMS_SQ_PSN_MASK) >>
1419
+
OCRDMA_QP_PARAMS_TCLASS_MASK) >>
1420
1420
OCRDMA_QP_PARAMS_TCLASS_SHIFT;
1421
1421
1422
1422
qp_attr->ah_attr.ah_flags = IB_AH_GRH;
+5
drivers/infiniband/hw/qib/qib_iba7322.c
+5
drivers/infiniband/hw/qib/qib_iba7322.c
···
2395
2395
qib_write_kreg_port(ppd, krp_ibcctrl_a, ppd->cpspec->ibcctrl_a);
2396
2396
qib_write_kreg(dd, kr_scratch, 0ULL);
2397
2397
2398
+
/* ensure previous Tx parameters are not still forced */
2399
+
qib_write_kreg_port(ppd, krp_tx_deemph_override,
2400
+
SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
2401
+
reset_tx_deemphasis_override));
2402
+
2398
2403
if (qib_compat_ddr_negotiate) {
2399
2404
ppd->cpspec->ibdeltainprog = 1;
2400
2405
ppd->cpspec->ibsymsnap = read_7322_creg32_port(ppd,
+8
-1
drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c
+8
-1
drivers/infiniband/hw/usnic/usnic_ib_qp_grp.c
···
629
629
{
630
630
enum usnic_transport_type trans_type = qp_flow->trans_type;
631
631
int err;
632
+
uint16_t port_num = 0;
632
633
633
634
switch (trans_type) {
634
635
case USNIC_TRANSPORT_ROCE_CUSTOM:
···
638
637
case USNIC_TRANSPORT_IPV4_UDP:
639
638
err = usnic_transport_sock_get_addr(qp_flow->udp.sock,
640
639
NULL, NULL,
641
-
(uint16_t *) id);
640
+
&port_num);
642
641
if (err)
643
642
return err;
643
+
/*
644
+
* Copy port_num to stack first and then to *id,
645
+
* so that the short to int cast works for little
646
+
* and big endian systems.
647
+
*/
648
+
*id = port_num;
644
649
break;
645
650
default:
646
651
usnic_err("Unsupported transport %u\n", trans_type);
+2
-1
drivers/infiniband/ulp/iser/iser_initiator.c
+2
-1
drivers/infiniband/ulp/iser/iser_initiator.c
···
610
610
ib_dma_unmap_single(device->ib_device, tx_desc->dma_addr,
611
611
ISER_HEADERS_LEN, DMA_TO_DEVICE);
612
612
kmem_cache_free(ig.desc_cache, tx_desc);
613
+
tx_desc = NULL;
613
614
}
614
615
615
616
atomic_dec(&ib_conn->post_send_buf_count);
616
617
617
-
if (tx_desc->type == ISCSI_TX_CONTROL) {
618
+
if (tx_desc && tx_desc->type == ISCSI_TX_CONTROL) {
618
619
/* this arithmetic is legal by libiscsi dd_data allocation */
619
620
task = (void *) ((long)(void *)tx_desc -
620
621
sizeof(struct iscsi_task));
+7
-3
drivers/infiniband/ulp/iser/iser_verbs.c
+7
-3
drivers/infiniband/ulp/iser/iser_verbs.c
···
652
652
/* getting here when the state is UP means that the conn is being *
653
653
* terminated asynchronously from the iSCSI layer's perspective. */
654
654
if (iser_conn_state_comp_exch(ib_conn, ISER_CONN_UP,
655
-
ISER_CONN_TERMINATING))
656
-
iscsi_conn_failure(ib_conn->iser_conn->iscsi_conn,
657
-
ISCSI_ERR_CONN_FAILED);
655
+
ISER_CONN_TERMINATING)){
656
+
if (ib_conn->iser_conn)
657
+
iscsi_conn_failure(ib_conn->iser_conn->iscsi_conn,
658
+
ISCSI_ERR_CONN_FAILED);
659
+
else
660
+
iser_err("iscsi_iser connection isn't bound\n");
661
+
}
658
662
659
663
/* Complete the termination process if no posts are pending */
660
664
if (ib_conn->post_recv_buf_count == 0 &&
+1
-1
drivers/net/ethernet/mellanox/mlx5/core/Kconfig
+1
-1
drivers/net/ethernet/mellanox/mlx5/core/Kconfig
+3
include/linux/mlx5/driver.h
+3
include/linux/mlx5/driver.h
···
38
38
#include <linux/pci.h>
39
39
#include <linux/spinlock_types.h>
40
40
#include <linux/semaphore.h>
41
+
#include <linux/slab.h>
41
42
#include <linux/vmalloc.h>
42
43
#include <linux/radix-tree.h>
44
+
43
45
#include <linux/mlx5/device.h>
44
46
#include <linux/mlx5/doorbell.h>
45
47
···
229
227
* protect uuar allocation data structs
230
228
*/
231
229
struct mutex lock;
230
+
u32 ver;
232
231
};
233
232
234
233
struct mlx5_bf {
+2
-1
include/rdma/ib_verbs.h
+2
-1
include/rdma/ib_verbs.h
···
226
226
IB_PORT_CAP_MASK_NOTICE_SUP = 1 << 22,
227
227
IB_PORT_BOOT_MGMT_SUP = 1 << 23,
228
228
IB_PORT_LINK_LATENCY_SUP = 1 << 24,
229
-
IB_PORT_CLIENT_REG_SUP = 1 << 25
229
+
IB_PORT_CLIENT_REG_SUP = 1 << 25,
230
+
IB_PORT_IP_BASED_GIDS = 1 << 26
230
231
};
231
232
232
233
enum ib_port_width {