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
Pull rdma fixes from Doug Ledford:
"This is our first pull request of the rc cycle. It's not that it's
been overly quiet, we were just waiting on a few things before sending
this off.
For instance, the 6 patch series from Intel for the hfi1 driver had
actually been pulled in on Tuesday for a Wednesday pull request, only
to have Jason notice something I missed, so we held off for some
testing, and then on Thursday had to respin the series because the
very first patch needed a minor fix (unnecessary cast is all).
There is a sizable hns patch series in here, as well as a reasonably
largish hfi1 patch series, then all of the lines of uapi updates are
just the change to the new official Linux-OpenIB SPDX tag (a bunch of
our files had what amounts to a BSD-2-Clause + MIT Warranty statement
as their license as a result of the initial code submission years ago,
and the SPDX folks decided it was unique enough to warrant a unique
tag), then the typical mlx4 and mlx5 updates, and finally some cxgb4
and core/cache/cma updates to round out the bunch.
None of it was overly large by itself, but in the 2 1/2 weeks we've
been collecting patches, it has added up :-/.
As best I can tell, it's been through 0day (I got a notice about my
last for-next push, but not for my for-rc push, but Jason seems to
think that failure messages are prioritized and success messages not
so much). It's also been through linux-next. And yes, we did notice in
the context portion of the CMA query gid fix patch that there is a
dubious BUG_ON() in the code, and have plans to audit our BUG_ON usage
and remove it anywhere we can.
Summary:
- Various build fixes (USER_ACCESS=m and ADDR_TRANS turned off)
- SPDX license tag cleanups (new tag Linux-OpenIB)
- RoCE GID fixes related to default GIDs
- Various fixes to: cxgb4, uverbs, cma, iwpm, rxe, hns (big batch),
mlx4, mlx5, and hfi1 (medium batch)"
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma: (52 commits)
RDMA/cma: Do not query GID during QP state transition to RTR
IB/mlx4: Fix integer overflow when calculating optimal MTT size
IB/hfi1: Fix memory leak in exception path in get_irq_affinity()
IB/{hfi1, rdmavt}: Fix memory leak in hfi1_alloc_devdata() upon failure
IB/hfi1: Fix NULL pointer dereference when invalid num_vls is used
IB/hfi1: Fix loss of BECN with AHG
IB/hfi1 Use correct type for num_user_context
IB/hfi1: Fix handling of FECN marked multicast packet
IB/core: Make ib_mad_client_id atomic
iw_cxgb4: Atomically flush per QP HW CQEs
IB/uverbs: Fix kernel crash during MR deregistration flow
IB/uverbs: Prevent reregistration of DM_MR to regular MR
RDMA/mlx4: Add missed RSS hash inner header flag
RDMA/hns: Fix a couple misspellings
RDMA/hns: Submit bad wr
RDMA/hns: Update assignment method for owner field of send wqe
RDMA/hns: Adjust the order of cleanup hem table
RDMA/hns: Only assign dqpn if IB_QP_PATH_DEST_QPN bit is set
RDMA/hns: Remove some unnecessary attr_mask judgement
RDMA/hns: Only assign mtu if IB_QP_PATH_MTU bit is set
...
+409
-210
+4
-1
drivers/infiniband/Kconfig
+4
-1
drivers/infiniband/Kconfig
···
61
61
pages on demand instead.
62
62
63
63
config INFINIBAND_ADDR_TRANS
64
-
bool
64
+
bool "RDMA/CM"
65
65
depends on INFINIBAND
66
66
default y
67
+
---help---
68
+
Support for RDMA communication manager (CM).
69
+
This allows for a generic connection abstraction over RDMA.
67
70
68
71
config INFINIBAND_ADDR_TRANS_CONFIGFS
69
72
bool
+35
-20
drivers/infiniband/core/cache.c
+35
-20
drivers/infiniband/core/cache.c
···
291
291
* so lookup free slot only if requested.
292
292
*/
293
293
if (pempty && empty < 0) {
294
-
if (data->props & GID_TABLE_ENTRY_INVALID) {
295
-
/* Found an invalid (free) entry; allocate it */
296
-
if (data->props & GID_TABLE_ENTRY_DEFAULT) {
297
-
if (default_gid)
298
-
empty = curr_index;
299
-
} else {
300
-
empty = curr_index;
301
-
}
294
+
if (data->props & GID_TABLE_ENTRY_INVALID &&
295
+
(default_gid ==
296
+
!!(data->props & GID_TABLE_ENTRY_DEFAULT))) {
297
+
/*
298
+
* Found an invalid (free) entry; allocate it.
299
+
* If default GID is requested, then our
300
+
* found slot must be one of the DEFAULT
301
+
* reserved slots or we fail.
302
+
* This ensures that only DEFAULT reserved
303
+
* slots are used for default property GIDs.
304
+
*/
305
+
empty = curr_index;
302
306
}
303
307
}
304
308
···
424
420
return ret;
425
421
}
426
422
427
-
int ib_cache_gid_del(struct ib_device *ib_dev, u8 port,
428
-
union ib_gid *gid, struct ib_gid_attr *attr)
423
+
static int
424
+
_ib_cache_gid_del(struct ib_device *ib_dev, u8 port,
425
+
union ib_gid *gid, struct ib_gid_attr *attr,
426
+
unsigned long mask, bool default_gid)
429
427
{
430
428
struct ib_gid_table *table;
431
429
int ret = 0;
···
437
431
438
432
mutex_lock(&table->lock);
439
433
440
-
ix = find_gid(table, gid, attr, false,
441
-
GID_ATTR_FIND_MASK_GID |
442
-
GID_ATTR_FIND_MASK_GID_TYPE |
443
-
GID_ATTR_FIND_MASK_NETDEV,
444
-
NULL);
434
+
ix = find_gid(table, gid, attr, default_gid, mask, NULL);
445
435
if (ix < 0) {
446
436
ret = -EINVAL;
447
437
goto out_unlock;
···
452
450
pr_debug("%s: can't delete gid %pI6 error=%d\n",
453
451
__func__, gid->raw, ret);
454
452
return ret;
453
+
}
454
+
455
+
int ib_cache_gid_del(struct ib_device *ib_dev, u8 port,
456
+
union ib_gid *gid, struct ib_gid_attr *attr)
457
+
{
458
+
unsigned long mask = GID_ATTR_FIND_MASK_GID |
459
+
GID_ATTR_FIND_MASK_GID_TYPE |
460
+
GID_ATTR_FIND_MASK_DEFAULT |
461
+
GID_ATTR_FIND_MASK_NETDEV;
462
+
463
+
return _ib_cache_gid_del(ib_dev, port, gid, attr, mask, false);
455
464
}
456
465
457
466
int ib_cache_gid_del_all_netdev_gids(struct ib_device *ib_dev, u8 port,
···
741
728
unsigned long gid_type_mask,
742
729
enum ib_cache_gid_default_mode mode)
743
730
{
744
-
union ib_gid gid;
731
+
union ib_gid gid = { };
745
732
struct ib_gid_attr gid_attr;
746
733
struct ib_gid_table *table;
747
734
unsigned int gid_type;
···
749
736
750
737
table = ib_dev->cache.ports[port - rdma_start_port(ib_dev)].gid;
751
738
752
-
make_default_gid(ndev, &gid);
739
+
mask = GID_ATTR_FIND_MASK_GID_TYPE |
740
+
GID_ATTR_FIND_MASK_DEFAULT |
741
+
GID_ATTR_FIND_MASK_NETDEV;
753
742
memset(&gid_attr, 0, sizeof(gid_attr));
754
743
gid_attr.ndev = ndev;
755
744
···
762
747
gid_attr.gid_type = gid_type;
763
748
764
749
if (mode == IB_CACHE_GID_DEFAULT_MODE_SET) {
765
-
mask = GID_ATTR_FIND_MASK_GID_TYPE |
766
-
GID_ATTR_FIND_MASK_DEFAULT;
750
+
make_default_gid(ndev, &gid);
767
751
__ib_cache_gid_add(ib_dev, port, &gid,
768
752
&gid_attr, mask, true);
769
753
} else if (mode == IB_CACHE_GID_DEFAULT_MODE_DELETE) {
770
-
ib_cache_gid_del(ib_dev, port, &gid, &gid_attr);
754
+
_ib_cache_gid_del(ib_dev, port, &gid,
755
+
&gid_attr, mask, true);
771
756
}
772
757
}
773
758
}
+43
-17
drivers/infiniband/core/cma.c
+43
-17
drivers/infiniband/core/cma.c
···
382
382
#define CMA_VERSION 0x00
383
383
384
384
struct cma_req_info {
385
+
struct sockaddr_storage listen_addr_storage;
386
+
struct sockaddr_storage src_addr_storage;
385
387
struct ib_device *device;
386
388
int port;
387
389
union ib_gid local_gid;
···
868
866
{
869
867
struct ib_qp_attr qp_attr;
870
868
int qp_attr_mask, ret;
871
-
union ib_gid sgid;
872
869
873
870
mutex_lock(&id_priv->qp_mutex);
874
871
if (!id_priv->id.qp) {
···
887
886
888
887
qp_attr.qp_state = IB_QPS_RTR;
889
888
ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
890
-
if (ret)
891
-
goto out;
892
-
893
-
ret = ib_query_gid(id_priv->id.device, id_priv->id.port_num,
894
-
rdma_ah_read_grh(&qp_attr.ah_attr)->sgid_index,
895
-
&sgid, NULL);
896
889
if (ret)
897
890
goto out;
898
891
···
1335
1340
}
1336
1341
1337
1342
static struct net_device *cma_get_net_dev(struct ib_cm_event *ib_event,
1338
-
const struct cma_req_info *req)
1343
+
struct cma_req_info *req)
1339
1344
{
1340
-
struct sockaddr_storage listen_addr_storage, src_addr_storage;
1341
-
struct sockaddr *listen_addr = (struct sockaddr *)&listen_addr_storage,
1342
-
*src_addr = (struct sockaddr *)&src_addr_storage;
1345
+
struct sockaddr *listen_addr =
1346
+
(struct sockaddr *)&req->listen_addr_storage;
1347
+
struct sockaddr *src_addr = (struct sockaddr *)&req->src_addr_storage;
1343
1348
struct net_device *net_dev;
1344
1349
const union ib_gid *gid = req->has_gid ? &req->local_gid : NULL;
1345
1350
int err;
···
1353
1358
gid, listen_addr);
1354
1359
if (!net_dev)
1355
1360
return ERR_PTR(-ENODEV);
1356
-
1357
-
if (!validate_net_dev(net_dev, listen_addr, src_addr)) {
1358
-
dev_put(net_dev);
1359
-
return ERR_PTR(-EHOSTUNREACH);
1360
-
}
1361
1361
1362
1362
return net_dev;
1363
1363
}
···
1480
1490
}
1481
1491
}
1482
1492
1493
+
/*
1494
+
* Net namespace might be getting deleted while route lookup,
1495
+
* cm_id lookup is in progress. Therefore, perform netdevice
1496
+
* validation, cm_id lookup under rcu lock.
1497
+
* RCU lock along with netdevice state check, synchronizes with
1498
+
* netdevice migrating to different net namespace and also avoids
1499
+
* case where net namespace doesn't get deleted while lookup is in
1500
+
* progress.
1501
+
* If the device state is not IFF_UP, its properties such as ifindex
1502
+
* and nd_net cannot be trusted to remain valid without rcu lock.
1503
+
* net/core/dev.c change_net_namespace() ensures to synchronize with
1504
+
* ongoing operations on net device after device is closed using
1505
+
* synchronize_net().
1506
+
*/
1507
+
rcu_read_lock();
1508
+
if (*net_dev) {
1509
+
/*
1510
+
* If netdevice is down, it is likely that it is administratively
1511
+
* down or it might be migrating to different namespace.
1512
+
* In that case avoid further processing, as the net namespace
1513
+
* or ifindex may change.
1514
+
*/
1515
+
if (((*net_dev)->flags & IFF_UP) == 0) {
1516
+
id_priv = ERR_PTR(-EHOSTUNREACH);
1517
+
goto err;
1518
+
}
1519
+
1520
+
if (!validate_net_dev(*net_dev,
1521
+
(struct sockaddr *)&req.listen_addr_storage,
1522
+
(struct sockaddr *)&req.src_addr_storage)) {
1523
+
id_priv = ERR_PTR(-EHOSTUNREACH);
1524
+
goto err;
1525
+
}
1526
+
}
1527
+
1483
1528
bind_list = cma_ps_find(*net_dev ? dev_net(*net_dev) : &init_net,
1484
1529
rdma_ps_from_service_id(req.service_id),
1485
1530
cma_port_from_service_id(req.service_id));
1486
1531
id_priv = cma_find_listener(bind_list, cm_id, ib_event, &req, *net_dev);
1532
+
err:
1533
+
rcu_read_unlock();
1487
1534
if (IS_ERR(id_priv) && *net_dev) {
1488
1535
dev_put(*net_dev);
1489
1536
*net_dev = NULL;
1490
1537
}
1491
-
1492
1538
return id_priv;
1493
1539
}
1494
1540
+4
-1
drivers/infiniband/core/iwpm_util.c
+4
-1
drivers/infiniband/core/iwpm_util.c
···
114
114
struct sockaddr_storage *mapped_sockaddr,
115
115
u8 nl_client)
116
116
{
117
-
struct hlist_head *hash_bucket_head;
117
+
struct hlist_head *hash_bucket_head = NULL;
118
118
struct iwpm_mapping_info *map_info;
119
119
unsigned long flags;
120
120
int ret = -EINVAL;
···
142
142
}
143
143
}
144
144
spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags);
145
+
146
+
if (!hash_bucket_head)
147
+
kfree(map_info);
145
148
return ret;
146
149
}
147
150
+2
-2
drivers/infiniband/core/mad.c
+2
-2
drivers/infiniband/core/mad.c
···
59
59
MODULE_PARM_DESC(recv_queue_size, "Size of receive queue in number of work requests");
60
60
61
61
static struct list_head ib_mad_port_list;
62
-
static u32 ib_mad_client_id = 0;
62
+
static atomic_t ib_mad_client_id = ATOMIC_INIT(0);
63
63
64
64
/* Port list lock */
65
65
static DEFINE_SPINLOCK(ib_mad_port_list_lock);
···
377
377
}
378
378
379
379
spin_lock_irqsave(&port_priv->reg_lock, flags);
380
-
mad_agent_priv->agent.hi_tid = ++ib_mad_client_id;
380
+
mad_agent_priv->agent.hi_tid = atomic_inc_return(&ib_mad_client_id);
381
381
382
382
/*
383
383
* Make sure MAD registration (if supplied)
+15
-13
drivers/infiniband/core/roce_gid_mgmt.c
+15
-13
drivers/infiniband/core/roce_gid_mgmt.c
···
255
255
struct net_device *rdma_ndev)
256
256
{
257
257
struct net_device *real_dev = rdma_vlan_dev_real_dev(event_ndev);
258
+
unsigned long gid_type_mask;
258
259
259
260
if (!rdma_ndev)
260
261
return;
···
265
264
266
265
rcu_read_lock();
267
266
268
-
if (rdma_is_upper_dev_rcu(rdma_ndev, event_ndev) &&
269
-
is_eth_active_slave_of_bonding_rcu(rdma_ndev, real_dev) ==
270
-
BONDING_SLAVE_STATE_INACTIVE) {
271
-
unsigned long gid_type_mask;
272
-
267
+
if (((rdma_ndev != event_ndev &&
268
+
!rdma_is_upper_dev_rcu(rdma_ndev, event_ndev)) ||
269
+
is_eth_active_slave_of_bonding_rcu(rdma_ndev, real_dev)
270
+
==
271
+
BONDING_SLAVE_STATE_INACTIVE)) {
273
272
rcu_read_unlock();
274
-
275
-
gid_type_mask = roce_gid_type_mask_support(ib_dev, port);
276
-
277
-
ib_cache_gid_set_default_gid(ib_dev, port, rdma_ndev,
278
-
gid_type_mask,
279
-
IB_CACHE_GID_DEFAULT_MODE_DELETE);
280
-
} else {
281
-
rcu_read_unlock();
273
+
return;
282
274
}
275
+
276
+
rcu_read_unlock();
277
+
278
+
gid_type_mask = roce_gid_type_mask_support(ib_dev, port);
279
+
280
+
ib_cache_gid_set_default_gid(ib_dev, port, rdma_ndev,
281
+
gid_type_mask,
282
+
IB_CACHE_GID_DEFAULT_MODE_DELETE);
283
283
}
284
284
285
285
static void enum_netdev_ipv4_ips(struct ib_device *ib_dev,
+28
-16
drivers/infiniband/core/ucma.c
+28
-16
drivers/infiniband/core/ucma.c
···
159
159
complete(&ctx->comp);
160
160
}
161
161
162
+
/*
163
+
* Same as ucm_get_ctx but requires that ->cm_id->device is valid, eg that the
164
+
* CM_ID is bound.
165
+
*/
166
+
static struct ucma_context *ucma_get_ctx_dev(struct ucma_file *file, int id)
167
+
{
168
+
struct ucma_context *ctx = ucma_get_ctx(file, id);
169
+
170
+
if (IS_ERR(ctx))
171
+
return ctx;
172
+
if (!ctx->cm_id->device) {
173
+
ucma_put_ctx(ctx);
174
+
return ERR_PTR(-EINVAL);
175
+
}
176
+
return ctx;
177
+
}
178
+
162
179
static void ucma_close_event_id(struct work_struct *work)
163
180
{
164
181
struct ucma_event *uevent_close = container_of(work, struct ucma_event, close_work);
···
700
683
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
701
684
return -EFAULT;
702
685
703
-
if (!rdma_addr_size_in6(&cmd.src_addr) ||
686
+
if ((cmd.src_addr.sin6_family && !rdma_addr_size_in6(&cmd.src_addr)) ||
704
687
!rdma_addr_size_in6(&cmd.dst_addr))
705
688
return -EINVAL;
706
689
···
751
734
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
752
735
return -EFAULT;
753
736
754
-
ctx = ucma_get_ctx(file, cmd.id);
737
+
ctx = ucma_get_ctx_dev(file, cmd.id);
755
738
if (IS_ERR(ctx))
756
739
return PTR_ERR(ctx);
757
740
···
1067
1050
if (!cmd.conn_param.valid)
1068
1051
return -EINVAL;
1069
1052
1070
-
ctx = ucma_get_ctx(file, cmd.id);
1053
+
ctx = ucma_get_ctx_dev(file, cmd.id);
1071
1054
if (IS_ERR(ctx))
1072
1055
return PTR_ERR(ctx);
1073
1056
···
1109
1092
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1110
1093
return -EFAULT;
1111
1094
1112
-
ctx = ucma_get_ctx(file, cmd.id);
1095
+
ctx = ucma_get_ctx_dev(file, cmd.id);
1113
1096
if (IS_ERR(ctx))
1114
1097
return PTR_ERR(ctx);
1115
1098
···
1137
1120
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1138
1121
return -EFAULT;
1139
1122
1140
-
ctx = ucma_get_ctx(file, cmd.id);
1123
+
ctx = ucma_get_ctx_dev(file, cmd.id);
1141
1124
if (IS_ERR(ctx))
1142
1125
return PTR_ERR(ctx);
1143
1126
···
1156
1139
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1157
1140
return -EFAULT;
1158
1141
1159
-
ctx = ucma_get_ctx(file, cmd.id);
1142
+
ctx = ucma_get_ctx_dev(file, cmd.id);
1160
1143
if (IS_ERR(ctx))
1161
1144
return PTR_ERR(ctx);
1162
1145
···
1184
1167
if (cmd.qp_state > IB_QPS_ERR)
1185
1168
return -EINVAL;
1186
1169
1187
-
ctx = ucma_get_ctx(file, cmd.id);
1170
+
ctx = ucma_get_ctx_dev(file, cmd.id);
1188
1171
if (IS_ERR(ctx))
1189
1172
return PTR_ERR(ctx);
1190
-
1191
-
if (!ctx->cm_id->device) {
1192
-
ret = -EINVAL;
1193
-
goto out;
1194
-
}
1195
1173
1196
1174
resp.qp_attr_mask = 0;
1197
1175
memset(&qp_attr, 0, sizeof qp_attr);
···
1328
1316
if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1329
1317
return -EFAULT;
1330
1318
1319
+
if (unlikely(cmd.optlen > KMALLOC_MAX_SIZE))
1320
+
return -EINVAL;
1321
+
1331
1322
ctx = ucma_get_ctx(file, cmd.id);
1332
1323
if (IS_ERR(ctx))
1333
1324
return PTR_ERR(ctx);
1334
-
1335
-
if (unlikely(cmd.optlen > KMALLOC_MAX_SIZE))
1336
-
return -EINVAL;
1337
1325
1338
1326
optval = memdup_user(u64_to_user_ptr(cmd.optval),
1339
1327
cmd.optlen);
···
1396
1384
else
1397
1385
return -EINVAL;
1398
1386
1399
-
ctx = ucma_get_ctx(file, cmd->id);
1387
+
ctx = ucma_get_ctx_dev(file, cmd->id);
1400
1388
if (IS_ERR(ctx))
1401
1389
return PTR_ERR(ctx);
1402
1390
+6
drivers/infiniband/core/uverbs_cmd.c
+6
drivers/infiniband/core/uverbs_cmd.c
···
691
691
692
692
mr->device = pd->device;
693
693
mr->pd = pd;
694
+
mr->dm = NULL;
694
695
mr->uobject = uobj;
695
696
atomic_inc(&pd->usecnt);
696
697
mr->res.type = RDMA_RESTRACK_MR;
···
765
764
return PTR_ERR(uobj);
766
765
767
766
mr = uobj->object;
767
+
768
+
if (mr->dm) {
769
+
ret = -EINVAL;
770
+
goto put_uobjs;
771
+
}
768
772
769
773
if (cmd.flags & IB_MR_REREG_ACCESS) {
770
774
ret = ib_check_mr_access(cmd.access_flags);
+9
drivers/infiniband/core/uverbs_ioctl.c
+9
drivers/infiniband/core/uverbs_ioctl.c
···
234
234
return -EINVAL;
235
235
}
236
236
237
+
for (; i < method_spec->num_buckets; i++) {
238
+
struct uverbs_attr_spec_hash *attr_spec_bucket =
239
+
method_spec->attr_buckets[i];
240
+
241
+
if (!bitmap_empty(attr_spec_bucket->mandatory_attrs_bitmask,
242
+
attr_spec_bucket->num_attrs))
243
+
return -EINVAL;
244
+
}
245
+
237
246
return 0;
238
247
}
239
248
+6
-6
drivers/infiniband/core/uverbs_std_types_flow_action.c
+6
-6
drivers/infiniband/core/uverbs_std_types_flow_action.c
···
363
363
364
364
static const struct uverbs_attr_spec uverbs_flow_action_esp_keymat[] = {
365
365
[IB_UVERBS_FLOW_ACTION_ESP_KEYMAT_AES_GCM] = {
366
-
.ptr = {
366
+
{ .ptr = {
367
367
.type = UVERBS_ATTR_TYPE_PTR_IN,
368
368
UVERBS_ATTR_TYPE(struct ib_uverbs_flow_action_esp_keymat_aes_gcm),
369
369
.flags = UVERBS_ATTR_SPEC_F_MIN_SZ_OR_ZERO,
370
-
},
370
+
} },
371
371
},
372
372
};
373
373
374
374
static const struct uverbs_attr_spec uverbs_flow_action_esp_replay[] = {
375
375
[IB_UVERBS_FLOW_ACTION_ESP_REPLAY_NONE] = {
376
-
.ptr = {
376
+
{ .ptr = {
377
377
.type = UVERBS_ATTR_TYPE_PTR_IN,
378
378
/* No need to specify any data */
379
379
.len = 0,
380
-
}
380
+
} }
381
381
},
382
382
[IB_UVERBS_FLOW_ACTION_ESP_REPLAY_BMP] = {
383
-
.ptr = {
383
+
{ .ptr = {
384
384
.type = UVERBS_ATTR_TYPE_PTR_IN,
385
385
UVERBS_ATTR_STRUCT(struct ib_uverbs_flow_action_esp_replay_bmp, size),
386
386
.flags = UVERBS_ATTR_SPEC_F_MIN_SZ_OR_ZERO,
387
-
}
387
+
} }
388
388
},
389
389
};
390
390
+1
drivers/infiniband/core/verbs.c
+1
drivers/infiniband/core/verbs.c
+10
-1
drivers/infiniband/hw/cxgb4/cq.c
+10
-1
drivers/infiniband/hw/cxgb4/cq.c
···
315
315
* Deal with out-of-order and/or completions that complete
316
316
* prior unsignalled WRs.
317
317
*/
318
-
void c4iw_flush_hw_cq(struct c4iw_cq *chp)
318
+
void c4iw_flush_hw_cq(struct c4iw_cq *chp, struct c4iw_qp *flush_qhp)
319
319
{
320
320
struct t4_cqe *hw_cqe, *swcqe, read_cqe;
321
321
struct c4iw_qp *qhp;
···
338
338
*/
339
339
if (qhp == NULL)
340
340
goto next_cqe;
341
+
342
+
if (flush_qhp != qhp) {
343
+
spin_lock(&qhp->lock);
344
+
345
+
if (qhp->wq.flushed == 1)
346
+
goto next_cqe;
347
+
}
341
348
342
349
if (CQE_OPCODE(hw_cqe) == FW_RI_TERMINATE)
343
350
goto next_cqe;
···
397
390
next_cqe:
398
391
t4_hwcq_consume(&chp->cq);
399
392
ret = t4_next_hw_cqe(&chp->cq, &hw_cqe);
393
+
if (qhp && flush_qhp != qhp)
394
+
spin_unlock(&qhp->lock);
400
395
}
401
396
}
402
397
+8
-1
drivers/infiniband/hw/cxgb4/device.c
+8
-1
drivers/infiniband/hw/cxgb4/device.c
···
875
875
876
876
rdev->status_page->db_off = 0;
877
877
878
+
init_completion(&rdev->rqt_compl);
879
+
init_completion(&rdev->pbl_compl);
880
+
kref_init(&rdev->rqt_kref);
881
+
kref_init(&rdev->pbl_kref);
882
+
878
883
return 0;
879
884
err_free_status_page_and_wr_log:
880
885
if (c4iw_wr_log && rdev->wr_log)
···
898
893
899
894
static void c4iw_rdev_close(struct c4iw_rdev *rdev)
900
895
{
901
-
destroy_workqueue(rdev->free_workq);
902
896
kfree(rdev->wr_log);
903
897
c4iw_release_dev_ucontext(rdev, &rdev->uctx);
904
898
free_page((unsigned long)rdev->status_page);
905
899
c4iw_pblpool_destroy(rdev);
906
900
c4iw_rqtpool_destroy(rdev);
901
+
wait_for_completion(&rdev->pbl_compl);
902
+
wait_for_completion(&rdev->rqt_compl);
907
903
c4iw_ocqp_pool_destroy(rdev);
904
+
destroy_workqueue(rdev->free_workq);
908
905
c4iw_destroy_resource(&rdev->resource);
909
906
}
910
907
+5
-1
drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+5
-1
drivers/infiniband/hw/cxgb4/iw_cxgb4.h
···
185
185
struct wr_log_entry *wr_log;
186
186
int wr_log_size;
187
187
struct workqueue_struct *free_workq;
188
+
struct completion rqt_compl;
189
+
struct completion pbl_compl;
190
+
struct kref rqt_kref;
191
+
struct kref pbl_kref;
188
192
};
189
193
190
194
static inline int c4iw_fatal_error(struct c4iw_rdev *rdev)
···
1053
1049
void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size);
1054
1050
u32 c4iw_ocqp_pool_alloc(struct c4iw_rdev *rdev, int size);
1055
1051
void c4iw_ocqp_pool_free(struct c4iw_rdev *rdev, u32 addr, int size);
1056
-
void c4iw_flush_hw_cq(struct c4iw_cq *chp);
1052
+
void c4iw_flush_hw_cq(struct c4iw_cq *chp, struct c4iw_qp *flush_qhp);
1057
1053
void c4iw_count_rcqes(struct t4_cq *cq, struct t4_wq *wq, int *count);
1058
1054
int c4iw_ep_disconnect(struct c4iw_ep *ep, int abrupt, gfp_t gfp);
1059
1055
int c4iw_flush_rq(struct t4_wq *wq, struct t4_cq *cq, int count);
+2
-2
drivers/infiniband/hw/cxgb4/qp.c
+2
-2
drivers/infiniband/hw/cxgb4/qp.c
···
1343
1343
qhp->wq.flushed = 1;
1344
1344
t4_set_wq_in_error(&qhp->wq);
1345
1345
1346
-
c4iw_flush_hw_cq(rchp);
1346
+
c4iw_flush_hw_cq(rchp, qhp);
1347
1347
c4iw_count_rcqes(&rchp->cq, &qhp->wq, &count);
1348
1348
rq_flushed = c4iw_flush_rq(&qhp->wq, &rchp->cq, count);
1349
1349
1350
1350
if (schp != rchp)
1351
-
c4iw_flush_hw_cq(schp);
1351
+
c4iw_flush_hw_cq(schp, qhp);
1352
1352
sq_flushed = c4iw_flush_sq(qhp);
1353
1353
1354
1354
spin_unlock(&qhp->lock);
+24
-2
drivers/infiniband/hw/cxgb4/resource.c
+24
-2
drivers/infiniband/hw/cxgb4/resource.c
···
260
260
rdev->stats.pbl.cur += roundup(size, 1 << MIN_PBL_SHIFT);
261
261
if (rdev->stats.pbl.cur > rdev->stats.pbl.max)
262
262
rdev->stats.pbl.max = rdev->stats.pbl.cur;
263
+
kref_get(&rdev->pbl_kref);
263
264
} else
264
265
rdev->stats.pbl.fail++;
265
266
mutex_unlock(&rdev->stats.lock);
266
267
return (u32)addr;
268
+
}
269
+
270
+
static void destroy_pblpool(struct kref *kref)
271
+
{
272
+
struct c4iw_rdev *rdev;
273
+
274
+
rdev = container_of(kref, struct c4iw_rdev, pbl_kref);
275
+
gen_pool_destroy(rdev->pbl_pool);
276
+
complete(&rdev->pbl_compl);
267
277
}
268
278
269
279
void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
···
283
273
rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT);
284
274
mutex_unlock(&rdev->stats.lock);
285
275
gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
276
+
kref_put(&rdev->pbl_kref, destroy_pblpool);
286
277
}
287
278
288
279
int c4iw_pblpool_create(struct c4iw_rdev *rdev)
···
321
310
322
311
void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
323
312
{
324
-
gen_pool_destroy(rdev->pbl_pool);
313
+
kref_put(&rdev->pbl_kref, destroy_pblpool);
325
314
}
326
315
327
316
/*
···
342
331
rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT);
343
332
if (rdev->stats.rqt.cur > rdev->stats.rqt.max)
344
333
rdev->stats.rqt.max = rdev->stats.rqt.cur;
334
+
kref_get(&rdev->rqt_kref);
345
335
} else
346
336
rdev->stats.rqt.fail++;
347
337
mutex_unlock(&rdev->stats.lock);
348
338
return (u32)addr;
339
+
}
340
+
341
+
static void destroy_rqtpool(struct kref *kref)
342
+
{
343
+
struct c4iw_rdev *rdev;
344
+
345
+
rdev = container_of(kref, struct c4iw_rdev, rqt_kref);
346
+
gen_pool_destroy(rdev->rqt_pool);
347
+
complete(&rdev->rqt_compl);
349
348
}
350
349
351
350
void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
···
365
344
rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT);
366
345
mutex_unlock(&rdev->stats.lock);
367
346
gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
347
+
kref_put(&rdev->rqt_kref, destroy_rqtpool);
368
348
}
369
349
370
350
int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
···
402
380
403
381
void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
404
382
{
405
-
gen_pool_destroy(rdev->rqt_pool);
383
+
kref_put(&rdev->rqt_kref, destroy_rqtpool);
406
384
}
407
385
408
386
/*
+5
-6
drivers/infiniband/hw/hfi1/affinity.c
+5
-6
drivers/infiniband/hw/hfi1/affinity.c
···
412
412
static int get_irq_affinity(struct hfi1_devdata *dd,
413
413
struct hfi1_msix_entry *msix)
414
414
{
415
-
int ret;
416
415
cpumask_var_t diff;
417
416
struct hfi1_affinity_node *entry;
418
417
struct cpu_mask_set *set = NULL;
···
422
423
423
424
extra[0] = '\0';
424
425
cpumask_clear(&msix->mask);
425
-
426
-
ret = zalloc_cpumask_var(&diff, GFP_KERNEL);
427
-
if (!ret)
428
-
return -ENOMEM;
429
426
430
427
entry = node_affinity_lookup(dd->node);
431
428
···
453
458
* finds its CPU here.
454
459
*/
455
460
if (cpu == -1 && set) {
461
+
if (!zalloc_cpumask_var(&diff, GFP_KERNEL))
462
+
return -ENOMEM;
463
+
456
464
if (cpumask_equal(&set->mask, &set->used)) {
457
465
/*
458
466
* We've used up all the CPUs, bump up the generation
···
467
469
cpumask_andnot(diff, &set->mask, &set->used);
468
470
cpu = cpumask_first(diff);
469
471
cpumask_set_cpu(cpu, &set->used);
472
+
473
+
free_cpumask_var(diff);
470
474
}
471
475
472
476
cpumask_set_cpu(cpu, &msix->mask);
···
482
482
hfi1_setup_sdma_notifier(msix);
483
483
}
484
484
485
-
free_cpumask_var(diff);
486
485
return 0;
487
486
}
488
487
+15
-4
drivers/infiniband/hw/hfi1/driver.c
+15
-4
drivers/infiniband/hw/hfi1/driver.c
···
433
433
bool do_cnp)
434
434
{
435
435
struct hfi1_ibport *ibp = to_iport(qp->ibqp.device, qp->port_num);
436
+
struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
436
437
struct ib_other_headers *ohdr = pkt->ohdr;
437
438
struct ib_grh *grh = pkt->grh;
438
439
u32 rqpn = 0, bth1;
439
-
u16 pkey, rlid, dlid = ib_get_dlid(pkt->hdr);
440
+
u16 pkey;
441
+
u32 rlid, slid, dlid = 0;
440
442
u8 hdr_type, sc, svc_type;
441
443
bool is_mcast = false;
442
444
445
+
/* can be called from prescan */
443
446
if (pkt->etype == RHF_RCV_TYPE_BYPASS) {
444
447
is_mcast = hfi1_is_16B_mcast(dlid);
445
448
pkey = hfi1_16B_get_pkey(pkt->hdr);
446
449
sc = hfi1_16B_get_sc(pkt->hdr);
450
+
dlid = hfi1_16B_get_dlid(pkt->hdr);
451
+
slid = hfi1_16B_get_slid(pkt->hdr);
447
452
hdr_type = HFI1_PKT_TYPE_16B;
448
453
} else {
449
454
is_mcast = (dlid > be16_to_cpu(IB_MULTICAST_LID_BASE)) &&
450
455
(dlid != be16_to_cpu(IB_LID_PERMISSIVE));
451
456
pkey = ib_bth_get_pkey(ohdr);
452
457
sc = hfi1_9B_get_sc5(pkt->hdr, pkt->rhf);
458
+
dlid = ib_get_dlid(pkt->hdr);
459
+
slid = ib_get_slid(pkt->hdr);
453
460
hdr_type = HFI1_PKT_TYPE_9B;
454
461
}
455
462
456
463
switch (qp->ibqp.qp_type) {
464
+
case IB_QPT_UD:
465
+
dlid = ppd->lid;
466
+
rlid = slid;
467
+
rqpn = ib_get_sqpn(pkt->ohdr);
468
+
svc_type = IB_CC_SVCTYPE_UD;
469
+
break;
457
470
case IB_QPT_SMI:
458
471
case IB_QPT_GSI:
459
-
case IB_QPT_UD:
460
-
rlid = ib_get_slid(pkt->hdr);
472
+
rlid = slid;
461
473
rqpn = ib_get_sqpn(pkt->ohdr);
462
474
svc_type = IB_CC_SVCTYPE_UD;
463
475
break;
···
494
482
dlid, rlid, sc, grh);
495
483
496
484
if (!is_mcast && (bth1 & IB_BECN_SMASK)) {
497
-
struct hfi1_pportdata *ppd = ppd_from_ibp(ibp);
498
485
u32 lqpn = bth1 & RVT_QPN_MASK;
499
486
u8 sl = ibp->sc_to_sl[sc];
500
487
+4
-4
drivers/infiniband/hw/hfi1/hfi.h
+4
-4
drivers/infiniband/hw/hfi1/hfi.h
···
1537
1537
void process_becn(struct hfi1_pportdata *ppd, u8 sl, u32 rlid, u32 lqpn,
1538
1538
u32 rqpn, u8 svc_type);
1539
1539
void return_cnp(struct hfi1_ibport *ibp, struct rvt_qp *qp, u32 remote_qpn,
1540
-
u32 pkey, u32 slid, u32 dlid, u8 sc5,
1540
+
u16 pkey, u32 slid, u32 dlid, u8 sc5,
1541
1541
const struct ib_grh *old_grh);
1542
1542
void return_cnp_16B(struct hfi1_ibport *ibp, struct rvt_qp *qp,
1543
-
u32 remote_qpn, u32 pkey, u32 slid, u32 dlid,
1543
+
u32 remote_qpn, u16 pkey, u32 slid, u32 dlid,
1544
1544
u8 sc5, const struct ib_grh *old_grh);
1545
1545
typedef void (*hfi1_handle_cnp)(struct hfi1_ibport *ibp, struct rvt_qp *qp,
1546
-
u32 remote_qpn, u32 pkey, u32 slid, u32 dlid,
1546
+
u32 remote_qpn, u16 pkey, u32 slid, u32 dlid,
1547
1547
u8 sc5, const struct ib_grh *old_grh);
1548
1548
1549
1549
#define PKEY_CHECK_INVALID -1
···
2437
2437
((slid >> OPA_16B_SLID_SHIFT) << OPA_16B_SLID_HIGH_SHIFT);
2438
2438
lrh2 = (lrh2 & ~OPA_16B_DLID_MASK) |
2439
2439
((dlid >> OPA_16B_DLID_SHIFT) << OPA_16B_DLID_HIGH_SHIFT);
2440
-
lrh2 = (lrh2 & ~OPA_16B_PKEY_MASK) | (pkey << OPA_16B_PKEY_SHIFT);
2440
+
lrh2 = (lrh2 & ~OPA_16B_PKEY_MASK) | ((u32)pkey << OPA_16B_PKEY_SHIFT);
2441
2441
lrh2 = (lrh2 & ~OPA_16B_L4_MASK) | l4;
2442
2442
2443
2443
hdr->lrh[0] = lrh0;
+31
-12
drivers/infiniband/hw/hfi1/init.c
+31
-12
drivers/infiniband/hw/hfi1/init.c
···
88
88
* pio buffers per ctxt, etc.) Zero means use one user context per CPU.
89
89
*/
90
90
int num_user_contexts = -1;
91
-
module_param_named(num_user_contexts, num_user_contexts, uint, S_IRUGO);
91
+
module_param_named(num_user_contexts, num_user_contexts, int, 0444);
92
92
MODULE_PARM_DESC(
93
-
num_user_contexts, "Set max number of user contexts to use");
93
+
num_user_contexts, "Set max number of user contexts to use (default: -1 will use the real (non-HT) CPU count)");
94
94
95
95
uint krcvqs[RXE_NUM_DATA_VL];
96
96
int krcvqsset;
···
1209
1209
kfree(ad);
1210
1210
}
1211
1211
1212
-
static void __hfi1_free_devdata(struct kobject *kobj)
1212
+
/**
1213
+
* hfi1_clean_devdata - cleans up per-unit data structure
1214
+
* @dd: pointer to a valid devdata structure
1215
+
*
1216
+
* It cleans up all data structures set up by
1217
+
* by hfi1_alloc_devdata().
1218
+
*/
1219
+
static void hfi1_clean_devdata(struct hfi1_devdata *dd)
1213
1220
{
1214
-
struct hfi1_devdata *dd =
1215
-
container_of(kobj, struct hfi1_devdata, kobj);
1216
1221
struct hfi1_asic_data *ad;
1217
1222
unsigned long flags;
1218
1223
1219
1224
spin_lock_irqsave(&hfi1_devs_lock, flags);
1220
-
idr_remove(&hfi1_unit_table, dd->unit);
1221
-
list_del(&dd->list);
1225
+
if (!list_empty(&dd->list)) {
1226
+
idr_remove(&hfi1_unit_table, dd->unit);
1227
+
list_del_init(&dd->list);
1228
+
}
1222
1229
ad = release_asic_data(dd);
1223
1230
spin_unlock_irqrestore(&hfi1_devs_lock, flags);
1224
-
if (ad)
1225
-
finalize_asic_data(dd, ad);
1231
+
1232
+
finalize_asic_data(dd, ad);
1226
1233
free_platform_config(dd);
1227
1234
rcu_barrier(); /* wait for rcu callbacks to complete */
1228
1235
free_percpu(dd->int_counter);
1229
1236
free_percpu(dd->rcv_limit);
1230
1237
free_percpu(dd->send_schedule);
1231
1238
free_percpu(dd->tx_opstats);
1239
+
dd->int_counter = NULL;
1240
+
dd->rcv_limit = NULL;
1241
+
dd->send_schedule = NULL;
1242
+
dd->tx_opstats = NULL;
1232
1243
sdma_clean(dd, dd->num_sdma);
1233
1244
rvt_dealloc_device(&dd->verbs_dev.rdi);
1245
+
}
1246
+
1247
+
static void __hfi1_free_devdata(struct kobject *kobj)
1248
+
{
1249
+
struct hfi1_devdata *dd =
1250
+
container_of(kobj, struct hfi1_devdata, kobj);
1251
+
1252
+
hfi1_clean_devdata(dd);
1234
1253
}
1235
1254
1236
1255
static struct kobj_type hfi1_devdata_type = {
···
1284
1265
return ERR_PTR(-ENOMEM);
1285
1266
dd->num_pports = nports;
1286
1267
dd->pport = (struct hfi1_pportdata *)(dd + 1);
1268
+
dd->pcidev = pdev;
1269
+
pci_set_drvdata(pdev, dd);
1287
1270
1288
1271
INIT_LIST_HEAD(&dd->list);
1289
1272
idr_preload(GFP_KERNEL);
···
1352
1331
return dd;
1353
1332
1354
1333
bail:
1355
-
if (!list_empty(&dd->list))
1356
-
list_del_init(&dd->list);
1357
-
rvt_dealloc_device(&dd->verbs_dev.rdi);
1334
+
hfi1_clean_devdata(dd);
1358
1335
return ERR_PTR(ret);
1359
1336
}
1360
1337
-3
drivers/infiniband/hw/hfi1/pcie.c
-3
drivers/infiniband/hw/hfi1/pcie.c
+1
drivers/infiniband/hw/hfi1/platform.c
+1
drivers/infiniband/hw/hfi1/platform.c
+2
drivers/infiniband/hw/hfi1/qsfp.c
+2
drivers/infiniband/hw/hfi1/qsfp.c
+40
-10
drivers/infiniband/hw/hfi1/ruc.c
+40
-10
drivers/infiniband/hw/hfi1/ruc.c
···
733
733
ohdr->bth[2] = cpu_to_be32(bth2);
734
734
}
735
735
736
+
/**
737
+
* hfi1_make_ruc_header_16B - build a 16B header
738
+
* @qp: the queue pair
739
+
* @ohdr: a pointer to the destination header memory
740
+
* @bth0: bth0 passed in from the RC/UC builder
741
+
* @bth2: bth2 passed in from the RC/UC builder
742
+
* @middle: non zero implies indicates ahg "could" be used
743
+
* @ps: the current packet state
744
+
*
745
+
* This routine may disarm ahg under these situations:
746
+
* - packet needs a GRH
747
+
* - BECN needed
748
+
* - migration state not IB_MIG_MIGRATED
749
+
*/
736
750
static inline void hfi1_make_ruc_header_16B(struct rvt_qp *qp,
737
751
struct ib_other_headers *ohdr,
738
752
u32 bth0, u32 bth2, int middle,
···
791
777
else
792
778
middle = 0;
793
779
780
+
if (qp->s_flags & RVT_S_ECN) {
781
+
qp->s_flags &= ~RVT_S_ECN;
782
+
/* we recently received a FECN, so return a BECN */
783
+
becn = true;
784
+
middle = 0;
785
+
}
794
786
if (middle)
795
787
build_ahg(qp, bth2);
796
788
else
···
804
784
805
785
bth0 |= pkey;
806
786
bth0 |= extra_bytes << 20;
807
-
if (qp->s_flags & RVT_S_ECN) {
808
-
qp->s_flags &= ~RVT_S_ECN;
809
-
/* we recently received a FECN, so return a BECN */
810
-
becn = true;
811
-
}
812
787
hfi1_make_ruc_bth(qp, ohdr, bth0, bth1, bth2);
813
788
814
789
if (!ppd->lid)
···
821
806
pkey, becn, 0, l4, priv->s_sc);
822
807
}
823
808
809
+
/**
810
+
* hfi1_make_ruc_header_9B - build a 9B header
811
+
* @qp: the queue pair
812
+
* @ohdr: a pointer to the destination header memory
813
+
* @bth0: bth0 passed in from the RC/UC builder
814
+
* @bth2: bth2 passed in from the RC/UC builder
815
+
* @middle: non zero implies indicates ahg "could" be used
816
+
* @ps: the current packet state
817
+
*
818
+
* This routine may disarm ahg under these situations:
819
+
* - packet needs a GRH
820
+
* - BECN needed
821
+
* - migration state not IB_MIG_MIGRATED
822
+
*/
824
823
static inline void hfi1_make_ruc_header_9B(struct rvt_qp *qp,
825
824
struct ib_other_headers *ohdr,
826
825
u32 bth0, u32 bth2, int middle,
···
868
839
else
869
840
middle = 0;
870
841
842
+
if (qp->s_flags & RVT_S_ECN) {
843
+
qp->s_flags &= ~RVT_S_ECN;
844
+
/* we recently received a FECN, so return a BECN */
845
+
bth1 |= (IB_BECN_MASK << IB_BECN_SHIFT);
846
+
middle = 0;
847
+
}
871
848
if (middle)
872
849
build_ahg(qp, bth2);
873
850
else
···
881
846
882
847
bth0 |= pkey;
883
848
bth0 |= extra_bytes << 20;
884
-
if (qp->s_flags & RVT_S_ECN) {
885
-
qp->s_flags &= ~RVT_S_ECN;
886
-
/* we recently received a FECN, so return a BECN */
887
-
bth1 |= (IB_BECN_MASK << IB_BECN_SHIFT);
888
-
}
889
849
hfi1_make_ruc_bth(qp, ohdr, bth0, bth1, bth2);
890
850
hfi1_make_ib_hdr(&ps->s_txreq->phdr.hdr.ibh,
891
851
lrh0,
+2
-2
drivers/infiniband/hw/hfi1/ud.c
+2
-2
drivers/infiniband/hw/hfi1/ud.c
···
628
628
}
629
629
630
630
void return_cnp_16B(struct hfi1_ibport *ibp, struct rvt_qp *qp,
631
-
u32 remote_qpn, u32 pkey, u32 slid, u32 dlid,
631
+
u32 remote_qpn, u16 pkey, u32 slid, u32 dlid,
632
632
u8 sc5, const struct ib_grh *old_grh)
633
633
{
634
634
u64 pbc, pbc_flags = 0;
···
687
687
}
688
688
689
689
void return_cnp(struct hfi1_ibport *ibp, struct rvt_qp *qp, u32 remote_qpn,
690
-
u32 pkey, u32 slid, u32 dlid, u8 sc5,
690
+
u16 pkey, u32 slid, u32 dlid, u8 sc5,
691
691
const struct ib_grh *old_grh)
692
692
{
693
693
u64 pbc, pbc_flags = 0;
+6
-6
drivers/infiniband/hw/hns/hns_roce_hem.c
+6
-6
drivers/infiniband/hw/hns/hns_roce_hem.c
···
912
912
obj_per_chunk = buf_chunk_size / obj_size;
913
913
num_hem = (nobj + obj_per_chunk - 1) / obj_per_chunk;
914
914
bt_chunk_num = bt_chunk_size / 8;
915
-
if (table->type >= HEM_TYPE_MTT)
915
+
if (type >= HEM_TYPE_MTT)
916
916
num_bt_l0 = bt_chunk_num;
917
917
918
918
table->hem = kcalloc(num_hem, sizeof(*table->hem),
···
920
920
if (!table->hem)
921
921
goto err_kcalloc_hem_buf;
922
922
923
-
if (check_whether_bt_num_3(table->type, hop_num)) {
923
+
if (check_whether_bt_num_3(type, hop_num)) {
924
924
unsigned long num_bt_l1;
925
925
926
926
num_bt_l1 = (num_hem + bt_chunk_num - 1) /
···
939
939
goto err_kcalloc_l1_dma;
940
940
}
941
941
942
-
if (check_whether_bt_num_2(table->type, hop_num) ||
943
-
check_whether_bt_num_3(table->type, hop_num)) {
942
+
if (check_whether_bt_num_2(type, hop_num) ||
943
+
check_whether_bt_num_3(type, hop_num)) {
944
944
table->bt_l0 = kcalloc(num_bt_l0, sizeof(*table->bt_l0),
945
945
GFP_KERNEL);
946
946
if (!table->bt_l0)
···
1039
1039
void hns_roce_cleanup_hem(struct hns_roce_dev *hr_dev)
1040
1040
{
1041
1041
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->cq_table.table);
1042
-
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->qp_table.irrl_table);
1043
1042
if (hr_dev->caps.trrl_entry_sz)
1044
1043
hns_roce_cleanup_hem_table(hr_dev,
1045
1044
&hr_dev->qp_table.trrl_table);
1045
+
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->qp_table.irrl_table);
1046
1046
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->qp_table.qp_table);
1047
1047
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->mr_table.mtpt_table);
1048
-
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->mr_table.mtt_table);
1049
1048
if (hns_roce_check_whether_mhop(hr_dev, HEM_TYPE_CQE))
1050
1049
hns_roce_cleanup_hem_table(hr_dev,
1051
1050
&hr_dev->mr_table.mtt_cqe_table);
1051
+
hns_roce_cleanup_hem_table(hr_dev, &hr_dev->mr_table.mtt_table);
1052
1052
}
+29
-20
drivers/infiniband/hw/hns/hns_roce_hw_v2.c
+29
-20
drivers/infiniband/hw/hns/hns_roce_hw_v2.c
···
71
71
return -EINVAL;
72
72
}
73
73
74
+
if (wr->opcode == IB_WR_RDMA_READ) {
75
+
dev_err(hr_dev->dev, "Not support inline data!\n");
76
+
return -EINVAL;
77
+
}
78
+
74
79
for (i = 0; i < wr->num_sge; i++) {
75
80
memcpy(wqe, ((void *)wr->sg_list[i].addr),
76
81
wr->sg_list[i].length);
···
153
148
ibqp->qp_type != IB_QPT_GSI &&
154
149
ibqp->qp_type != IB_QPT_UD)) {
155
150
dev_err(dev, "Not supported QP(0x%x)type!\n", ibqp->qp_type);
156
-
*bad_wr = NULL;
151
+
*bad_wr = wr;
157
152
return -EOPNOTSUPP;
158
153
}
159
154
···
187
182
qp->sq.wrid[(qp->sq.head + nreq) & (qp->sq.wqe_cnt - 1)] =
188
183
wr->wr_id;
189
184
190
-
owner_bit = ~(qp->sq.head >> ilog2(qp->sq.wqe_cnt)) & 0x1;
185
+
owner_bit =
186
+
~(((qp->sq.head + nreq) >> ilog2(qp->sq.wqe_cnt)) & 0x1);
191
187
192
188
/* Corresponding to the QP type, wqe process separately */
193
189
if (ibqp->qp_type == IB_QPT_GSI) {
···
462
456
} else {
463
457
dev_err(dev, "Illegal qp_type(0x%x)\n", ibqp->qp_type);
464
458
spin_unlock_irqrestore(&qp->sq.lock, flags);
459
+
*bad_wr = wr;
465
460
return -EOPNOTSUPP;
466
461
}
467
462
}
···
2599
2592
roce_set_field(qpc_mask->byte_4_sqpn_tst, V2_QPC_BYTE_4_SQPN_M,
2600
2593
V2_QPC_BYTE_4_SQPN_S, 0);
2601
2594
2602
-
roce_set_field(context->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2603
-
V2_QPC_BYTE_56_DQPN_S, hr_qp->qpn);
2604
-
roce_set_field(qpc_mask->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2605
-
V2_QPC_BYTE_56_DQPN_S, 0);
2595
+
if (attr_mask & IB_QP_DEST_QPN) {
2596
+
roce_set_field(context->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2597
+
V2_QPC_BYTE_56_DQPN_S, hr_qp->qpn);
2598
+
roce_set_field(qpc_mask->byte_56_dqpn_err,
2599
+
V2_QPC_BYTE_56_DQPN_M, V2_QPC_BYTE_56_DQPN_S, 0);
2600
+
}
2606
2601
roce_set_field(context->byte_168_irrl_idx,
2607
2602
V2_QPC_BYTE_168_SQ_SHIFT_BAK_M,
2608
2603
V2_QPC_BYTE_168_SQ_SHIFT_BAK_S,
···
2659
2650
return -EINVAL;
2660
2651
}
2661
2652
2662
-
if ((attr_mask & IB_QP_ALT_PATH) || (attr_mask & IB_QP_ACCESS_FLAGS) ||
2663
-
(attr_mask & IB_QP_PKEY_INDEX) || (attr_mask & IB_QP_QKEY)) {
2653
+
if (attr_mask & IB_QP_ALT_PATH) {
2664
2654
dev_err(dev, "INIT2RTR attr_mask (0x%x) error\n", attr_mask);
2665
2655
return -EINVAL;
2666
2656
}
···
2808
2800
V2_QPC_BYTE_140_RR_MAX_S, 0);
2809
2801
}
2810
2802
2811
-
roce_set_field(context->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2812
-
V2_QPC_BYTE_56_DQPN_S, attr->dest_qp_num);
2813
-
roce_set_field(qpc_mask->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2814
-
V2_QPC_BYTE_56_DQPN_S, 0);
2803
+
if (attr_mask & IB_QP_DEST_QPN) {
2804
+
roce_set_field(context->byte_56_dqpn_err, V2_QPC_BYTE_56_DQPN_M,
2805
+
V2_QPC_BYTE_56_DQPN_S, attr->dest_qp_num);
2806
+
roce_set_field(qpc_mask->byte_56_dqpn_err,
2807
+
V2_QPC_BYTE_56_DQPN_M, V2_QPC_BYTE_56_DQPN_S, 0);
2808
+
}
2815
2809
2816
2810
/* Configure GID index */
2817
2811
port_num = rdma_ah_get_port_num(&attr->ah_attr);
···
2855
2845
if (ibqp->qp_type == IB_QPT_GSI || ibqp->qp_type == IB_QPT_UD)
2856
2846
roce_set_field(context->byte_24_mtu_tc, V2_QPC_BYTE_24_MTU_M,
2857
2847
V2_QPC_BYTE_24_MTU_S, IB_MTU_4096);
2858
-
else
2848
+
else if (attr_mask & IB_QP_PATH_MTU)
2859
2849
roce_set_field(context->byte_24_mtu_tc, V2_QPC_BYTE_24_MTU_M,
2860
2850
V2_QPC_BYTE_24_MTU_S, attr->path_mtu);
2861
2851
···
2932
2922
return -EINVAL;
2933
2923
}
2934
2924
2935
-
/* If exist optional param, return error */
2936
-
if ((attr_mask & IB_QP_ALT_PATH) || (attr_mask & IB_QP_ACCESS_FLAGS) ||
2937
-
(attr_mask & IB_QP_QKEY) || (attr_mask & IB_QP_PATH_MIG_STATE) ||
2938
-
(attr_mask & IB_QP_CUR_STATE) ||
2939
-
(attr_mask & IB_QP_MIN_RNR_TIMER)) {
2925
+
/* Not support alternate path and path migration */
2926
+
if ((attr_mask & IB_QP_ALT_PATH) ||
2927
+
(attr_mask & IB_QP_PATH_MIG_STATE)) {
2940
2928
dev_err(dev, "RTR2RTS attr_mask (0x%x)error\n", attr_mask);
2941
2929
return -EINVAL;
2942
2930
}
···
3169
3161
(cur_state == IB_QPS_RTR && new_state == IB_QPS_ERR) ||
3170
3162
(cur_state == IB_QPS_RTS && new_state == IB_QPS_ERR) ||
3171
3163
(cur_state == IB_QPS_SQD && new_state == IB_QPS_ERR) ||
3172
-
(cur_state == IB_QPS_SQE && new_state == IB_QPS_ERR)) {
3164
+
(cur_state == IB_QPS_SQE && new_state == IB_QPS_ERR) ||
3165
+
(cur_state == IB_QPS_ERR && new_state == IB_QPS_ERR)) {
3173
3166
/* Nothing */
3174
3167
;
3175
3168
} else {
···
4487
4478
ret = hns_roce_cmd_mbox(hr_dev, mailbox->dma, 0, eq->eqn, 0,
4488
4479
eq_cmd, HNS_ROCE_CMD_TIMEOUT_MSECS);
4489
4480
if (ret) {
4490
-
dev_err(dev, "[mailbox cmd] creat eqc failed.\n");
4481
+
dev_err(dev, "[mailbox cmd] create eqc failed.\n");
4491
4482
goto err_cmd_mbox;
4492
4483
}
4493
4484
+1
-1
drivers/infiniband/hw/hns/hns_roce_qp.c
+1
-1
drivers/infiniband/hw/hns/hns_roce_qp.c
+1
-1
drivers/infiniband/hw/mlx4/mr.c
+1
-1
drivers/infiniband/hw/mlx4/mr.c
···
346
346
/* Add to the first block the misalignment that it suffers from. */
347
347
total_len += (first_block_start & ((1ULL << block_shift) - 1ULL));
348
348
last_block_end = current_block_start + current_block_len;
349
-
last_block_aligned_end = round_up(last_block_end, 1 << block_shift);
349
+
last_block_aligned_end = round_up(last_block_end, 1ULL << block_shift);
350
350
total_len += (last_block_aligned_end - last_block_end);
351
351
352
352
if (total_len & ((1ULL << block_shift) - 1ULL))
+2
-1
drivers/infiniband/hw/mlx4/qp.c
+2
-1
drivers/infiniband/hw/mlx4/qp.c
···
673
673
MLX4_IB_RX_HASH_SRC_PORT_TCP |
674
674
MLX4_IB_RX_HASH_DST_PORT_TCP |
675
675
MLX4_IB_RX_HASH_SRC_PORT_UDP |
676
-
MLX4_IB_RX_HASH_DST_PORT_UDP)) {
676
+
MLX4_IB_RX_HASH_DST_PORT_UDP |
677
+
MLX4_IB_RX_HASH_INNER)) {
677
678
pr_debug("RX Hash fields_mask has unsupported mask (0x%llx)\n",
678
679
ucmd->rx_hash_fields_mask);
679
680
return (-EOPNOTSUPP);
+1
drivers/infiniband/hw/mlx5/Kconfig
+1
drivers/infiniband/hw/mlx5/Kconfig
···
1
1
config MLX5_INFINIBAND
2
2
tristate "Mellanox Connect-IB HCA support"
3
3
depends on NETDEVICES && ETHERNET && PCI && MLX5_CORE
4
+
depends on INFINIBAND_USER_ACCESS || INFINIBAND_USER_ACCESS=n
4
5
---help---
5
6
This driver provides low-level InfiniBand support for
6
7
Mellanox Connect-IB PCI Express host channel adapters (HCAs).
+2
-5
drivers/infiniband/hw/mlx5/main.c
+2
-5
drivers/infiniband/hw/mlx5/main.c
···
52
52
#include <linux/mlx5/port.h>
53
53
#include <linux/mlx5/vport.h>
54
54
#include <linux/mlx5/fs.h>
55
-
#include <linux/mlx5/fs_helpers.h>
56
55
#include <linux/list.h>
57
56
#include <rdma/ib_smi.h>
58
57
#include <rdma/ib_umem.h>
···
179
180
if (rep_ndev == ndev)
180
181
roce->netdev = (event == NETDEV_UNREGISTER) ?
181
182
NULL : ndev;
182
-
} else if (ndev->dev.parent == &ibdev->mdev->pdev->dev) {
183
+
} else if (ndev->dev.parent == &mdev->pdev->dev) {
183
184
roce->netdev = (event == NETDEV_UNREGISTER) ?
184
185
NULL : ndev;
185
186
}
···
5426
5427
static int mlx5_ib_stage_uar_init(struct mlx5_ib_dev *dev)
5427
5428
{
5428
5429
dev->mdev->priv.uar = mlx5_get_uars_page(dev->mdev);
5429
-
if (!dev->mdev->priv.uar)
5430
-
return -ENOMEM;
5431
-
return 0;
5430
+
return PTR_ERR_OR_ZERO(dev->mdev->priv.uar);
5432
5431
}
5433
5432
5434
5433
static void mlx5_ib_stage_uar_cleanup(struct mlx5_ib_dev *dev)
+23
-9
drivers/infiniband/hw/mlx5/mr.c
+23
-9
drivers/infiniband/hw/mlx5/mr.c
···
866
866
int *order)
867
867
{
868
868
struct mlx5_ib_dev *dev = to_mdev(pd->device);
869
+
struct ib_umem *u;
869
870
int err;
870
871
871
-
*umem = ib_umem_get(pd->uobject->context, start, length,
872
-
access_flags, 0);
873
-
err = PTR_ERR_OR_ZERO(*umem);
872
+
*umem = NULL;
873
+
874
+
u = ib_umem_get(pd->uobject->context, start, length, access_flags, 0);
875
+
err = PTR_ERR_OR_ZERO(u);
874
876
if (err) {
875
-
*umem = NULL;
876
-
mlx5_ib_err(dev, "umem get failed (%d)\n", err);
877
+
mlx5_ib_dbg(dev, "umem get failed (%d)\n", err);
877
878
return err;
878
879
}
879
880
880
-
mlx5_ib_cont_pages(*umem, start, MLX5_MKEY_PAGE_SHIFT_MASK, npages,
881
+
mlx5_ib_cont_pages(u, start, MLX5_MKEY_PAGE_SHIFT_MASK, npages,
881
882
page_shift, ncont, order);
882
883
if (!*npages) {
883
884
mlx5_ib_warn(dev, "avoid zero region\n");
884
-
ib_umem_release(*umem);
885
+
ib_umem_release(u);
885
886
return -EINVAL;
886
887
}
888
+
889
+
*umem = u;
887
890
888
891
mlx5_ib_dbg(dev, "npages %d, ncont %d, order %d, page_shift %d\n",
889
892
*npages, *ncont, *order, *page_shift);
···
1461
1458
int access_flags = flags & IB_MR_REREG_ACCESS ?
1462
1459
new_access_flags :
1463
1460
mr->access_flags;
1464
-
u64 addr = (flags & IB_MR_REREG_TRANS) ? virt_addr : mr->umem->address;
1465
-
u64 len = (flags & IB_MR_REREG_TRANS) ? length : mr->umem->length;
1466
1461
int page_shift = 0;
1467
1462
int upd_flags = 0;
1468
1463
int npages = 0;
1469
1464
int ncont = 0;
1470
1465
int order = 0;
1466
+
u64 addr, len;
1471
1467
int err;
1472
1468
1473
1469
mlx5_ib_dbg(dev, "start 0x%llx, virt_addr 0x%llx, length 0x%llx, access_flags 0x%x\n",
1474
1470
start, virt_addr, length, access_flags);
1475
1471
1476
1472
atomic_sub(mr->npages, &dev->mdev->priv.reg_pages);
1473
+
1474
+
if (!mr->umem)
1475
+
return -EINVAL;
1476
+
1477
+
if (flags & IB_MR_REREG_TRANS) {
1478
+
addr = virt_addr;
1479
+
len = length;
1480
+
} else {
1481
+
addr = mr->umem->address;
1482
+
len = mr->umem->length;
1483
+
}
1477
1484
1478
1485
if (flags != IB_MR_REREG_PD) {
1479
1486
/*
···
1492
1479
*/
1493
1480
flags |= IB_MR_REREG_TRANS;
1494
1481
ib_umem_release(mr->umem);
1482
+
mr->umem = NULL;
1495
1483
err = mr_umem_get(pd, addr, len, access_flags, &mr->umem,
1496
1484
&npages, &page_shift, &ncont, &order);
1497
1485
if (err)
+14
-10
drivers/infiniband/hw/mlx5/qp.c
+14
-10
drivers/infiniband/hw/mlx5/qp.c
···
259
259
} else {
260
260
if (ucmd) {
261
261
qp->rq.wqe_cnt = ucmd->rq_wqe_count;
262
+
if (ucmd->rq_wqe_shift > BITS_PER_BYTE * sizeof(ucmd->rq_wqe_shift))
263
+
return -EINVAL;
262
264
qp->rq.wqe_shift = ucmd->rq_wqe_shift;
265
+
if ((1 << qp->rq.wqe_shift) / sizeof(struct mlx5_wqe_data_seg) < qp->wq_sig)
266
+
return -EINVAL;
263
267
qp->rq.max_gs = (1 << qp->rq.wqe_shift) / sizeof(struct mlx5_wqe_data_seg) - qp->wq_sig;
264
268
qp->rq.max_post = qp->rq.wqe_cnt;
265
269
} else {
···
2455
2451
2456
2452
static int ib_rate_to_mlx5(struct mlx5_ib_dev *dev, u8 rate)
2457
2453
{
2458
-
if (rate == IB_RATE_PORT_CURRENT) {
2454
+
if (rate == IB_RATE_PORT_CURRENT)
2459
2455
return 0;
2460
-
} else if (rate < IB_RATE_2_5_GBPS || rate > IB_RATE_300_GBPS) {
2461
-
return -EINVAL;
2462
-
} else {
2463
-
while (rate != IB_RATE_2_5_GBPS &&
2464
-
!(1 << (rate + MLX5_STAT_RATE_OFFSET) &
2465
-
MLX5_CAP_GEN(dev->mdev, stat_rate_support)))
2466
-
--rate;
2467
-
}
2468
2456
2469
-
return rate + MLX5_STAT_RATE_OFFSET;
2457
+
if (rate < IB_RATE_2_5_GBPS || rate > IB_RATE_300_GBPS)
2458
+
return -EINVAL;
2459
+
2460
+
while (rate != IB_RATE_PORT_CURRENT &&
2461
+
!(1 << (rate + MLX5_STAT_RATE_OFFSET) &
2462
+
MLX5_CAP_GEN(dev->mdev, stat_rate_support)))
2463
+
--rate;
2464
+
2465
+
return rate ? rate + MLX5_STAT_RATE_OFFSET : rate;
2470
2466
}
2471
2467
2472
2468
static int modify_raw_packet_eth_prio(struct mlx5_core_dev *dev,
+1
-1
drivers/infiniband/hw/nes/nes_nic.c
+1
-1
drivers/infiniband/hw/nes/nes_nic.c
···
461
461
/**
462
462
* nes_netdev_start_xmit
463
463
*/
464
-
static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
464
+
static netdev_tx_t nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
465
465
{
466
466
struct nes_vnic *nesvnic = netdev_priv(netdev);
467
467
struct nes_device *nesdev = nesvnic->nesdev;
+1
-1
drivers/infiniband/sw/rxe/rxe_opcode.c
+1
-1
drivers/infiniband/sw/rxe/rxe_opcode.c
···
390
390
.name = "IB_OPCODE_RC_SEND_ONLY_INV",
391
391
.mask = RXE_IETH_MASK | RXE_PAYLOAD_MASK | RXE_REQ_MASK
392
392
| RXE_COMP_MASK | RXE_RWR_MASK | RXE_SEND_MASK
393
-
| RXE_END_MASK,
393
+
| RXE_END_MASK | RXE_START_MASK,
394
394
.length = RXE_BTH_BYTES + RXE_IETH_BYTES,
395
395
.offset = {
396
396
[RXE_BTH] = 0,
-1
drivers/infiniband/sw/rxe/rxe_req.c
-1
drivers/infiniband/sw/rxe/rxe_req.c
+1
-5
drivers/infiniband/sw/rxe/rxe_resp.c
+1
-5
drivers/infiniband/sw/rxe/rxe_resp.c
···
742
742
err = rxe_xmit_packet(rxe, qp, &ack_pkt, skb);
743
743
if (err) {
744
744
pr_err("Failed sending RDMA reply.\n");
745
-
kfree_skb(skb);
746
745
return RESPST_ERR_RNR;
747
746
}
748
747
···
953
954
}
954
955
955
956
err = rxe_xmit_packet(rxe, qp, &ack_pkt, skb);
956
-
if (err) {
957
+
if (err)
957
958
pr_err_ratelimited("Failed sending ack\n");
958
-
kfree_skb(skb);
959
-
}
960
959
961
960
err1:
962
961
return err;
···
1138
1141
if (rc) {
1139
1142
pr_err("Failed resending result. This flow is not handled - skb ignored\n");
1140
1143
rxe_drop_ref(qp);
1141
-
kfree_skb(skb_copy);
1142
1144
rc = RESPST_CLEANUP;
1143
1145
goto out;
1144
1146
}
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_main.c
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_main.c
···
1094
1094
spin_unlock_irqrestore(&priv->lock, flags);
1095
1095
}
1096
1096
1097
-
static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
1097
+
static netdev_tx_t ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
1098
1098
{
1099
1099
struct ipoib_dev_priv *priv = ipoib_priv(dev);
1100
1100
struct rdma_netdev *rn = netdev_priv(dev);
+1
-1
drivers/infiniband/ulp/srp/Kconfig
+1
-1
drivers/infiniband/ulp/srp/Kconfig
+1
-1
drivers/infiniband/ulp/srpt/Kconfig
+1
-1
drivers/infiniband/ulp/srpt/Kconfig
+1
-1
drivers/nvme/host/Kconfig
+1
-1
drivers/nvme/host/Kconfig
+1
-1
drivers/nvme/target/Kconfig
+1
-1
drivers/nvme/target/Kconfig
+1
-1
fs/cifs/Kconfig
+1
-1
fs/cifs/Kconfig
···
197
197
198
198
config CIFS_SMB_DIRECT
199
199
bool "SMB Direct support (Experimental)"
200
-
depends on CIFS=m && INFINIBAND || CIFS=y && INFINIBAND=y
200
+
depends on CIFS=m && INFINIBAND && INFINIBAND_ADDR_TRANS || CIFS=y && INFINIBAND=y && INFINIBAND_ADDR_TRANS=y
201
201
help
202
202
Enables SMB Direct experimental support for SMB 3.0, 3.02 and 3.1.1.
203
203
SMB Direct allows transferring SMB packets over RDMA. If unsure,
+1
-1
include/uapi/linux/if_infiniband.h
+1
-1
include/uapi/linux/if_infiniband.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
2
2
/*
3
3
* This software is available to you under a choice of one of two
4
4
* licenses. You may choose to be licensed under the terms of the GNU
+1
-1
include/uapi/linux/rds.h
+1
-1
include/uapi/linux/rds.h
+1
-1
include/uapi/linux/tls.h
+1
-1
include/uapi/linux/tls.h
+1
-1
include/uapi/rdma/cxgb3-abi.h
+1
-1
include/uapi/rdma/cxgb3-abi.h
+1
-1
include/uapi/rdma/cxgb4-abi.h
+1
-1
include/uapi/rdma/cxgb4-abi.h
+1
-1
include/uapi/rdma/hns-abi.h
+1
-1
include/uapi/rdma/hns-abi.h
+1
-1
include/uapi/rdma/ib_user_cm.h
+1
-1
include/uapi/rdma/ib_user_cm.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2005 Topspin Communications. All rights reserved.
4
4
* Copyright (c) 2005 Intel Corporation. All rights reserved.
+1
-1
include/uapi/rdma/ib_user_ioctl_verbs.h
+1
-1
include/uapi/rdma/ib_user_ioctl_verbs.h
+1
-1
include/uapi/rdma/ib_user_mad.h
+1
-1
include/uapi/rdma/ib_user_mad.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2004 Topspin Communications. All rights reserved.
4
4
* Copyright (c) 2005 Voltaire, Inc. All rights reserved.
+1
-1
include/uapi/rdma/ib_user_sa.h
+1
-1
include/uapi/rdma/ib_user_sa.h
+1
-1
include/uapi/rdma/ib_user_verbs.h
+1
-1
include/uapi/rdma/ib_user_verbs.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2005 Topspin Communications. All rights reserved.
4
4
* Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
+1
-1
include/uapi/rdma/mlx4-abi.h
+1
-1
include/uapi/rdma/mlx4-abi.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
4
4
* Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
+1
-1
include/uapi/rdma/mlx5-abi.h
+1
-1
include/uapi/rdma/mlx5-abi.h
+1
-1
include/uapi/rdma/mthca-abi.h
+1
-1
include/uapi/rdma/mthca-abi.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2005 Topspin Communications. All rights reserved.
4
4
* Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
+1
-1
include/uapi/rdma/nes-abi.h
+1
-1
include/uapi/rdma/nes-abi.h
···
1
-
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */
1
+
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR Linux-OpenIB) */
2
2
/*
3
3
* Copyright (c) 2006 - 2011 Intel Corporation. All rights reserved.
4
4
* Copyright (c) 2005 Topspin Communications. All rights reserved.
+1
-1
include/uapi/rdma/qedr-abi.h
+1
-1
include/uapi/rdma/qedr-abi.h
+1
-1
include/uapi/rdma/rdma_user_cm.h
+1
-1
include/uapi/rdma/rdma_user_cm.h
+1
-1
include/uapi/rdma/rdma_user_ioctl.h
+1
-1
include/uapi/rdma/rdma_user_ioctl.h
+1
-1
include/uapi/rdma/rdma_user_rxe.h
+1
-1
include/uapi/rdma/rdma_user_rxe.h