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:
"For the most part this is just a minor -rc cycle for the rdma
subsystem. Even given that this is all of the -rc patches since the
merge window closed, it's still only about 25 patches:
- Multiple i40iw, nes, iw_cxgb4, hfi1, qib, mlx4, mlx5 fixes
- A few upper layer protocol fixes (IPoIB, iSER, SRP)
- A modest number of core fixes"
* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma: (26 commits)
RDMA/SA: Fix kernel panic in CMA request handler flow
RDMA/umem: Fix missing mmap_sem in get umem ODP call
RDMA/core: not to set page dirty bit if it's already set.
RDMA/uverbs: Declare local function static and add brackets to sizeof
RDMA/netlink: Reduce exposure of RDMA netlink functions
RDMA/srp: Fix NULL deref at srp_destroy_qp()
RDMA/IPoIB: Limit the ipoib_dev_uninit_default scope
RDMA/IPoIB: Replace netdev_priv with ipoib_priv for ipoib_get_link_ksettings
RDMA/qedr: add null check before pointer dereference
RDMA/mlx5: set UMR wqe fence according to HCA cap
net/mlx5: Define interface bits for fencing UMR wqe
RDMA/mlx4: Fix MAD tunneling when SRIOV is enabled
RDMA/qib,hfi1: Fix MR reference count leak on write with immediate
RDMA/hfi1: Defer setting VL15 credits to link-up interrupt
RDMA/hfi1: change PCI bar addr assignments to Linux API functions
RDMA/hfi1: fix array termination by appending NULL to attr array
RDMA/iw_cxgb4: fix the calculation of ipv6 header size
RDMA/iw_cxgb4: calculate t4_eq_status_entries properly
RDMA/iw_cxgb4: Avoid touch after free error in ARP failure handlers
RDMA/nes: ACK MPA Reply frame
...
+194
-170
+2
-2
drivers/infiniband/core/cm.c
+2
-2
drivers/infiniband/core/cm.c
···
1429
1429
primary_path->packet_life_time =
1430
1430
cm_req_get_primary_local_ack_timeout(req_msg);
1431
1431
primary_path->packet_life_time -= (primary_path->packet_life_time > 0);
1432
-
sa_path_set_service_id(primary_path, req_msg->service_id);
1432
+
primary_path->service_id = req_msg->service_id;
1433
1433
1434
1434
if (req_msg->alt_local_lid) {
1435
1435
alt_path->dgid = req_msg->alt_local_gid;
···
1452
1452
alt_path->packet_life_time =
1453
1453
cm_req_get_alt_local_ack_timeout(req_msg);
1454
1454
alt_path->packet_life_time -= (alt_path->packet_life_time > 0);
1455
-
sa_path_set_service_id(alt_path, req_msg->service_id);
1455
+
alt_path->service_id = req_msg->service_id;
1456
1456
}
1457
1457
}
1458
1458
+6
-7
drivers/infiniband/core/cma.c
+6
-7
drivers/infiniband/core/cma.c
···
1140
1140
ib->sib_pkey = path->pkey;
1141
1141
ib->sib_flowinfo = path->flow_label;
1142
1142
memcpy(&ib->sib_addr, &path->sgid, 16);
1143
-
ib->sib_sid = sa_path_get_service_id(path);
1143
+
ib->sib_sid = path->service_id;
1144
1144
ib->sib_scope_id = 0;
1145
1145
} else {
1146
1146
ib->sib_pkey = listen_ib->sib_pkey;
···
1274
1274
memcpy(&req->local_gid, &req_param->primary_path->sgid,
1275
1275
sizeof(req->local_gid));
1276
1276
req->has_gid = true;
1277
-
req->service_id =
1278
-
sa_path_get_service_id(req_param->primary_path);
1277
+
req->service_id = req_param->primary_path->service_id;
1279
1278
req->pkey = be16_to_cpu(req_param->primary_path->pkey);
1280
1279
if (req->pkey != req_param->bth_pkey)
1281
1280
pr_warn_ratelimited("RDMA CMA: got different BTH P_Key (0x%x) and primary path P_Key (0x%x)\n"
···
1826
1827
struct rdma_route *rt;
1827
1828
const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
1828
1829
struct sa_path_rec *path = ib_event->param.req_rcvd.primary_path;
1829
-
const __be64 service_id = sa_path_get_service_id(path);
1830
+
const __be64 service_id =
1831
+
ib_event->param.req_rcvd.primary_path->service_id;
1830
1832
int ret;
1831
1833
1832
1834
id = rdma_create_id(listen_id->route.addr.dev_addr.net,
···
2345
2345
path_rec.pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
2346
2346
path_rec.numb_path = 1;
2347
2347
path_rec.reversible = 1;
2348
-
sa_path_set_service_id(&path_rec,
2349
-
rdma_get_service_id(&id_priv->id,
2350
-
cma_dst_addr(id_priv)));
2348
+
path_rec.service_id = rdma_get_service_id(&id_priv->id,
2349
+
cma_dst_addr(id_priv));
2351
2350
2352
2351
comp_mask = IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID |
2353
2352
IB_SA_PATH_REC_PKEY | IB_SA_PATH_REC_NUMB_PATH |
+10
drivers/infiniband/core/core_priv.h
+10
drivers/infiniband/core/core_priv.h
···
169
169
int ib_sa_init(void);
170
170
void ib_sa_cleanup(void);
171
171
172
+
int ibnl_init(void);
173
+
void ibnl_cleanup(void);
174
+
175
+
/**
176
+
* Check if there are any listeners to the netlink group
177
+
* @group: the netlink group ID
178
+
* Returns 0 on success or a negative for no listeners.
179
+
*/
180
+
int ibnl_chk_listeners(unsigned int group);
181
+
172
182
int ib_nl_handle_resolve_resp(struct sk_buff *skb,
173
183
struct netlink_callback *cb);
174
184
int ib_nl_handle_set_timeout(struct sk_buff *skb,
+1
-1
drivers/infiniband/core/netlink.c
+1
-1
drivers/infiniband/core/netlink.c
···
37
37
#include <net/net_namespace.h>
38
38
#include <net/sock.h>
39
39
#include <rdma/rdma_netlink.h>
40
+
#include "core_priv.h"
40
41
41
42
struct ibnl_client {
42
43
struct list_head list;
···
56
55
return -1;
57
56
return 0;
58
57
}
59
-
EXPORT_SYMBOL(ibnl_chk_listeners);
60
58
61
59
int ibnl_add_client(int index, int nops,
62
60
const struct ibnl_client_cbs cb_table[])
+3
-3
drivers/infiniband/core/sa_query.c
+3
-3
drivers/infiniband/core/sa_query.c
···
194
194
.field_name = "sa_path_rec:" #field
195
195
196
196
static const struct ib_field path_rec_table[] = {
197
-
{ PATH_REC_FIELD(ib.service_id),
197
+
{ PATH_REC_FIELD(service_id),
198
198
.offset_words = 0,
199
199
.offset_bits = 0,
200
200
.size_bits = 64 },
···
296
296
.field_name = "sa_path_rec:" #field
297
297
298
298
static const struct ib_field opa_path_rec_table[] = {
299
-
{ OPA_PATH_REC_FIELD(opa.service_id),
299
+
{ OPA_PATH_REC_FIELD(service_id),
300
300
.offset_words = 0,
301
301
.offset_bits = 0,
302
302
.size_bits = 64 },
···
774
774
775
775
/* Now build the attributes */
776
776
if (comp_mask & IB_SA_PATH_REC_SERVICE_ID) {
777
-
val64 = be64_to_cpu(sa_path_get_service_id(sa_rec));
777
+
val64 = be64_to_cpu(sa_rec->service_id);
778
778
nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_SERVICE_ID,
779
779
sizeof(val64), &val64);
780
780
}
+1
-1
drivers/infiniband/core/umem.c
+1
-1
drivers/infiniband/core/umem.c
+5
-1
drivers/infiniband/core/umem_odp.c
+5
-1
drivers/infiniband/core/umem_odp.c
···
321
321
struct vm_area_struct *vma;
322
322
struct hstate *h;
323
323
324
+
down_read(&mm->mmap_sem);
324
325
vma = find_vma(mm, ib_umem_start(umem));
325
-
if (!vma || !is_vm_hugetlb_page(vma))
326
+
if (!vma || !is_vm_hugetlb_page(vma)) {
327
+
up_read(&mm->mmap_sem);
326
328
return -EINVAL;
329
+
}
327
330
h = hstate_vma(vma);
328
331
umem->page_shift = huge_page_shift(h);
332
+
up_read(&mm->mmap_sem);
329
333
umem->hugetlb = 1;
330
334
} else {
331
335
umem->hugetlb = 0;
+4
-4
drivers/infiniband/core/uverbs_marshall.c
+4
-4
drivers/infiniband/core/uverbs_marshall.c
···
96
96
}
97
97
EXPORT_SYMBOL(ib_copy_qp_attr_to_user);
98
98
99
-
void __ib_copy_path_rec_to_user(struct ib_user_path_rec *dst,
100
-
struct sa_path_rec *src)
99
+
static void __ib_copy_path_rec_to_user(struct ib_user_path_rec *dst,
100
+
struct sa_path_rec *src)
101
101
{
102
-
memcpy(dst->dgid, src->dgid.raw, sizeof src->dgid);
103
-
memcpy(dst->sgid, src->sgid.raw, sizeof src->sgid);
102
+
memcpy(dst->dgid, src->dgid.raw, sizeof(src->dgid));
103
+
memcpy(dst->sgid, src->sgid.raw, sizeof(src->sgid));
104
104
105
105
dst->dlid = htons(ntohl(sa_path_get_dlid(src)));
106
106
dst->slid = htons(ntohl(sa_path_get_slid(src)));
+7
-2
drivers/infiniband/hw/cxgb4/cm.c
+7
-2
drivers/infiniband/hw/cxgb4/cm.c
···
488
488
489
489
ep = *((struct c4iw_ep **)(skb->cb + 2 * sizeof(void *)));
490
490
release_ep_resources(ep);
491
+
kfree_skb(skb);
491
492
return 0;
492
493
}
493
494
···
499
498
ep = *((struct c4iw_ep **)(skb->cb + 2 * sizeof(void *)));
500
499
c4iw_put_ep(&ep->parent_ep->com);
501
500
release_ep_resources(ep);
501
+
kfree_skb(skb);
502
502
return 0;
503
503
}
504
504
···
571
569
572
570
pr_debug("%s rdev %p\n", __func__, rdev);
573
571
req->cmd = CPL_ABORT_NO_RST;
572
+
skb_get(skb);
574
573
ret = c4iw_ofld_send(rdev, skb);
575
574
if (ret) {
576
575
__state_set(&ep->com, DEAD);
577
576
queue_arp_failure_cpl(ep, skb, FAKE_CPL_PUT_EP_SAFE);
578
-
}
577
+
} else
578
+
kfree_skb(skb);
579
579
}
580
580
581
581
static int send_flowc(struct c4iw_ep *ep)
···
2521
2517
goto reject;
2522
2518
}
2523
2519
2524
-
hdrs = sizeof(struct iphdr) + sizeof(struct tcphdr) +
2520
+
hdrs = ((iptype == 4) ? sizeof(struct iphdr) : sizeof(struct ipv6hdr)) +
2521
+
sizeof(struct tcphdr) +
2525
2522
((enable_tcp_timestamps && req->tcpopt.tstamp) ? 12 : 0);
2526
2523
if (peer_mss && child_ep->mtu > (peer_mss + hdrs))
2527
2524
child_ep->mtu = peer_mss + hdrs;
+1
-1
drivers/infiniband/hw/cxgb4/device.c
+1
-1
drivers/infiniband/hw/cxgb4/device.c
···
971
971
devp->rdev.lldi.sge_egrstatuspagesize);
972
972
973
973
devp->rdev.hw_queue.t4_eq_status_entries =
974
-
devp->rdev.lldi.sge_ingpadboundary > 64 ? 2 : 1;
974
+
devp->rdev.lldi.sge_egrstatuspagesize / 64;
975
975
devp->rdev.hw_queue.t4_max_eq_size = 65520;
976
976
devp->rdev.hw_queue.t4_max_iq_size = 65520;
977
977
devp->rdev.hw_queue.t4_max_rq_size = 8192 -
+50
-17
drivers/infiniband/hw/hfi1/chip.c
+50
-17
drivers/infiniband/hw/hfi1/chip.c
···
6312
6312
}
6313
6313
}
6314
6314
6315
-
static void write_global_credit(struct hfi1_devdata *dd,
6316
-
u8 vau, u16 total, u16 shared)
6315
+
/*
6316
+
* Set up allocation unit vaulue.
6317
+
*/
6318
+
void set_up_vau(struct hfi1_devdata *dd, u8 vau)
6317
6319
{
6318
-
write_csr(dd, SEND_CM_GLOBAL_CREDIT,
6319
-
((u64)total <<
6320
-
SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT) |
6321
-
((u64)shared <<
6322
-
SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT) |
6323
-
((u64)vau << SEND_CM_GLOBAL_CREDIT_AU_SHIFT));
6320
+
u64 reg = read_csr(dd, SEND_CM_GLOBAL_CREDIT);
6321
+
6322
+
/* do not modify other values in the register */
6323
+
reg &= ~SEND_CM_GLOBAL_CREDIT_AU_SMASK;
6324
+
reg |= (u64)vau << SEND_CM_GLOBAL_CREDIT_AU_SHIFT;
6325
+
write_csr(dd, SEND_CM_GLOBAL_CREDIT, reg);
6324
6326
}
6325
6327
6326
6328
/*
6327
6329
* Set up initial VL15 credits of the remote. Assumes the rest of
6328
-
* the CM credit registers are zero from a previous global or credit reset .
6330
+
* the CM credit registers are zero from a previous global or credit reset.
6331
+
* Shared limit for VL15 will always be 0.
6329
6332
*/
6330
-
void set_up_vl15(struct hfi1_devdata *dd, u8 vau, u16 vl15buf)
6333
+
void set_up_vl15(struct hfi1_devdata *dd, u16 vl15buf)
6331
6334
{
6332
-
/* leave shared count at zero for both global and VL15 */
6333
-
write_global_credit(dd, vau, vl15buf, 0);
6335
+
u64 reg = read_csr(dd, SEND_CM_GLOBAL_CREDIT);
6336
+
6337
+
/* set initial values for total and shared credit limit */
6338
+
reg &= ~(SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SMASK |
6339
+
SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SMASK);
6340
+
6341
+
/*
6342
+
* Set total limit to be equal to VL15 credits.
6343
+
* Leave shared limit at 0.
6344
+
*/
6345
+
reg |= (u64)vl15buf << SEND_CM_GLOBAL_CREDIT_TOTAL_CREDIT_LIMIT_SHIFT;
6346
+
write_csr(dd, SEND_CM_GLOBAL_CREDIT, reg);
6334
6347
6335
6348
write_csr(dd, SEND_CM_CREDIT_VL15, (u64)vl15buf
6336
6349
<< SEND_CM_CREDIT_VL15_DEDICATED_LIMIT_VL_SHIFT);
···
6361
6348
for (i = 0; i < TXE_NUM_DATA_VL; i++)
6362
6349
write_csr(dd, SEND_CM_CREDIT_VL + (8 * i), 0);
6363
6350
write_csr(dd, SEND_CM_CREDIT_VL15, 0);
6364
-
write_global_credit(dd, 0, 0, 0);
6351
+
write_csr(dd, SEND_CM_GLOBAL_CREDIT, 0);
6365
6352
/* reset the CM block */
6366
6353
pio_send_control(dd, PSC_CM_RESET);
6354
+
/* reset cached value */
6355
+
dd->vl15buf_cached = 0;
6367
6356
}
6368
6357
6369
6358
/* convert a vCU to a CU */
···
6854
6839
{
6855
6840
struct hfi1_pportdata *ppd = container_of(work, struct hfi1_pportdata,
6856
6841
link_up_work);
6842
+
struct hfi1_devdata *dd = ppd->dd;
6843
+
6857
6844
set_link_state(ppd, HLS_UP_INIT);
6858
6845
6859
6846
/* cache the read of DC_LCB_STS_ROUND_TRIP_LTP_CNT */
6860
-
read_ltp_rtt(ppd->dd);
6847
+
read_ltp_rtt(dd);
6861
6848
/*
6862
6849
* OPA specifies that certain counters are cleared on a transition
6863
6850
* to link up, so do that.
6864
6851
*/
6865
-
clear_linkup_counters(ppd->dd);
6852
+
clear_linkup_counters(dd);
6866
6853
/*
6867
6854
* And (re)set link up default values.
6868
6855
*/
6869
6856
set_linkup_defaults(ppd);
6870
6857
6858
+
/*
6859
+
* Set VL15 credits. Use cached value from verify cap interrupt.
6860
+
* In case of quick linkup or simulator, vl15 value will be set by
6861
+
* handle_linkup_change. VerifyCap interrupt handler will not be
6862
+
* called in those scenarios.
6863
+
*/
6864
+
if (!(quick_linkup || dd->icode == ICODE_FUNCTIONAL_SIMULATOR))
6865
+
set_up_vl15(dd, dd->vl15buf_cached);
6866
+
6871
6867
/* enforce link speed enabled */
6872
6868
if ((ppd->link_speed_active & ppd->link_speed_enabled) == 0) {
6873
6869
/* oops - current speed is not enabled, bounce */
6874
-
dd_dev_err(ppd->dd,
6870
+
dd_dev_err(dd,
6875
6871
"Link speed active 0x%x is outside enabled 0x%x, downing link\n",
6876
6872
ppd->link_speed_active, ppd->link_speed_enabled);
6877
6873
set_link_down_reason(ppd, OPA_LINKDOWN_REASON_SPEED_POLICY, 0,
···
7383
7357
*/
7384
7358
if (vau == 0)
7385
7359
vau = 1;
7386
-
set_up_vl15(dd, vau, vl15buf);
7360
+
set_up_vau(dd, vau);
7361
+
7362
+
/*
7363
+
* Set VL15 credits to 0 in global credit register. Cache remote VL15
7364
+
* credits value and wait for link-up interrupt ot set it.
7365
+
*/
7366
+
set_up_vl15(dd, 0);
7367
+
dd->vl15buf_cached = vl15buf;
7387
7368
7388
7369
/* set up the LCB CRC mode */
7389
7370
crc_mask = ppd->port_crc_mode_enabled & partner_supported_crc;
+2
drivers/infiniband/hw/hfi1/chip_registers.h
+2
drivers/infiniband/hw/hfi1/chip_registers.h
···
839
839
#define SEND_CM_CTRL_FORCE_CREDIT_MODE_SMASK 0x8ull
840
840
#define SEND_CM_CTRL_RESETCSR 0x0000000000000020ull
841
841
#define SEND_CM_GLOBAL_CREDIT (TXE + 0x000000000508)
842
+
#define SEND_CM_GLOBAL_CREDIT_AU_MASK 0x7ull
842
843
#define SEND_CM_GLOBAL_CREDIT_AU_SHIFT 16
844
+
#define SEND_CM_GLOBAL_CREDIT_AU_SMASK 0x70000ull
843
845
#define SEND_CM_GLOBAL_CREDIT_RESETCSR 0x0000094000030000ull
844
846
#define SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_MASK 0xFFFFull
845
847
#define SEND_CM_GLOBAL_CREDIT_SHARED_LIMIT_SHIFT 0
+10
-1
drivers/infiniband/hw/hfi1/hfi.h
+10
-1
drivers/infiniband/hw/hfi1/hfi.h
···
1045
1045
/* initial vl15 credits to use */
1046
1046
u16 vl15_init;
1047
1047
1048
+
/*
1049
+
* Cached value for vl15buf, read during verify cap interrupt. VL15
1050
+
* credits are to be kept at 0 and set when handling the link-up
1051
+
* interrupt. This removes the possibility of receiving VL15 MAD
1052
+
* packets before this HFI is ready.
1053
+
*/
1054
+
u16 vl15buf_cached;
1055
+
1048
1056
/* Misc small ints */
1049
1057
u8 n_krcv_queues;
1050
1058
u8 qos_shift;
···
1606
1598
int fm_get_table(struct hfi1_pportdata *ppd, int which, void *t);
1607
1599
int fm_set_table(struct hfi1_pportdata *ppd, int which, void *t);
1608
1600
1609
-
void set_up_vl15(struct hfi1_devdata *dd, u8 vau, u16 vl15buf);
1601
+
void set_up_vau(struct hfi1_devdata *dd, u8 vau);
1602
+
void set_up_vl15(struct hfi1_devdata *dd, u16 vl15buf);
1610
1603
void reset_link_credits(struct hfi1_devdata *dd);
1611
1604
void assign_remote_cm_au_table(struct hfi1_devdata *dd, u8 vcu);
1612
1605
+2
-1
drivers/infiniband/hw/hfi1/intr.c
+2
-1
drivers/infiniband/hw/hfi1/intr.c
···
130
130
* the remote values. Both sides must be using the values.
131
131
*/
132
132
if (quick_linkup || dd->icode == ICODE_FUNCTIONAL_SIMULATOR) {
133
-
set_up_vl15(dd, dd->vau, dd->vl15_init);
133
+
set_up_vau(dd, dd->vau);
134
+
set_up_vl15(dd, dd->vl15_init);
134
135
assign_remote_cm_au_table(dd, dd->vcu);
135
136
}
136
137
+2
-2
drivers/infiniband/hw/hfi1/pcie.c
+2
-2
drivers/infiniband/hw/hfi1/pcie.c
···
207
207
/*
208
208
* Save BARs and command to rewrite after device reset.
209
209
*/
210
-
dd->pcibar0 = addr;
211
-
dd->pcibar1 = addr >> 32;
210
+
pci_read_config_dword(dd->pcidev, PCI_BASE_ADDRESS_0, &dd->pcibar0);
211
+
pci_read_config_dword(dd->pcidev, PCI_BASE_ADDRESS_1, &dd->pcibar1);
212
212
pci_read_config_dword(dd->pcidev, PCI_ROM_ADDRESS, &dd->pci_rom);
213
213
pci_read_config_word(dd->pcidev, PCI_COMMAND, &dd->pci_command);
214
214
pcie_capability_read_word(dd->pcidev, PCI_EXP_DEVCTL, &dd->pcie_devctl);
+4
-1
drivers/infiniband/hw/hfi1/rc.c
+4
-1
drivers/infiniband/hw/hfi1/rc.c
···
2159
2159
ret = hfi1_rvt_get_rwqe(qp, 1);
2160
2160
if (ret < 0)
2161
2161
goto nack_op_err;
2162
-
if (!ret)
2162
+
if (!ret) {
2163
+
/* peer will send again */
2164
+
rvt_put_ss(&qp->r_sge);
2163
2165
goto rnr_nak;
2166
+
}
2164
2167
wc.ex.imm_data = ohdr->u.rc.imm_data;
2165
2168
wc.wc_flags = IB_WC_WITH_IMM;
2166
2169
goto send_last;
+2
-1
drivers/infiniband/hw/hfi1/sysfs.c
+2
-1
drivers/infiniband/hw/hfi1/sysfs.c
+1
-2
drivers/infiniband/hw/i40iw/i40iw_cm.c
+1
-2
drivers/infiniband/hw/i40iw/i40iw_cm.c
···
784
784
}
785
785
786
786
ctrl_ird |= IETF_PEER_TO_PEER;
787
-
ctrl_ird |= IETF_FLPDU_ZERO_LEN;
788
787
789
788
switch (mpa_key) {
790
789
case MPA_KEY_REQUEST:
···
2445
2446
} else {
2446
2447
type = I40IW_CM_EVENT_CONNECTED;
2447
2448
cm_node->state = I40IW_CM_STATE_OFFLOADED;
2448
-
i40iw_send_ack(cm_node);
2449
2449
}
2450
+
i40iw_send_ack(cm_node);
2450
2451
break;
2451
2452
default:
2452
2453
pr_err("%s wrong cm_node state =%d\n", __func__, cm_node->state);
+1
-11
drivers/infiniband/hw/i40iw/i40iw_ctrl.c
+1
-11
drivers/infiniband/hw/i40iw/i40iw_ctrl.c
···
285
285
struct i40iw_sc_dev *dev = vsi->dev;
286
286
struct i40iw_sc_qp *qp = NULL;
287
287
bool qs_handle_change = false;
288
-
bool mss_change = false;
289
288
unsigned long flags;
290
289
u16 qs_handle;
291
290
int i;
292
291
293
-
if (vsi->mss != l2params->mss) {
294
-
mss_change = true;
295
-
vsi->mss = l2params->mss;
296
-
}
292
+
vsi->mss = l2params->mss;
297
293
298
294
i40iw_fill_qos_list(l2params->qs_handle_list);
299
295
for (i = 0; i < I40IW_MAX_USER_PRIORITY; i++) {
300
296
qs_handle = l2params->qs_handle_list[i];
301
297
if (vsi->qos[i].qs_handle != qs_handle)
302
298
qs_handle_change = true;
303
-
else if (!mss_change)
304
-
continue; /* no MSS nor qs handle change */
305
299
spin_lock_irqsave(&vsi->qos[i].lock, flags);
306
300
qp = i40iw_get_qp(&vsi->qos[i].qplist, qp);
307
301
while (qp) {
308
-
if (mss_change)
309
-
i40iw_qp_mss_modify(dev, qp);
310
302
if (qs_handle_change) {
311
303
qp->qs_handle = qs_handle;
312
304
/* issue cqp suspend command */
···
2387
2395
2388
2396
set_64bit_val(wqe,
2389
2397
8,
2390
-
LS_64(info->new_mss, I40IW_CQPSQ_QP_NEWMSS) |
2391
2398
LS_64(term_len, I40IW_CQPSQ_QP_TERMLEN));
2392
2399
2393
2400
set_64bit_val(wqe, 16, qp->hw_host_ctx_pa);
···
2401
2410
LS_64(info->cq_num_valid, I40IW_CQPSQ_QP_CQNUMVALID) |
2402
2411
LS_64(info->force_loopback, I40IW_CQPSQ_QP_FORCELOOPBACK) |
2403
2412
LS_64(qp->qp_type, I40IW_CQPSQ_QP_QPTYPE) |
2404
-
LS_64(info->mss_change, I40IW_CQPSQ_QP_MSSCHANGE) |
2405
2413
LS_64(info->static_rsrc, I40IW_CQPSQ_QP_STATRSRC) |
2406
2414
LS_64(info->remove_hash_idx, I40IW_CQPSQ_QP_REMOVEHASHENTRY) |
2407
2415
LS_64(term_actions, I40IW_CQPSQ_QP_TERMACT) |
+13
-7
drivers/infiniband/hw/i40iw/i40iw_main.c
+13
-7
drivers/infiniband/hw/i40iw/i40iw_main.c
···
1319
1319
status = i40iw_obj_aligned_mem(iwdev, &mem, I40IW_QUERY_FPM_BUF_SIZE,
1320
1320
I40IW_FPM_QUERY_BUF_ALIGNMENT_MASK);
1321
1321
if (status)
1322
-
goto exit;
1322
+
goto error;
1323
1323
info.fpm_query_buf_pa = mem.pa;
1324
1324
info.fpm_query_buf = mem.va;
1325
1325
status = i40iw_obj_aligned_mem(iwdev, &mem, I40IW_COMMIT_FPM_BUF_SIZE,
1326
1326
I40IW_FPM_COMMIT_BUF_ALIGNMENT_MASK);
1327
1327
if (status)
1328
-
goto exit;
1328
+
goto error;
1329
1329
info.fpm_commit_buf_pa = mem.pa;
1330
1330
info.fpm_commit_buf = mem.va;
1331
1331
info.hmc_fn_id = ldev->fid;
···
1347
1347
info.exception_lan_queue = 1;
1348
1348
info.vchnl_send = i40iw_virtchnl_send;
1349
1349
status = i40iw_device_init(&iwdev->sc_dev, &info);
1350
-
exit:
1351
-
if (status) {
1352
-
kfree(iwdev->hmc_info_mem);
1353
-
iwdev->hmc_info_mem = NULL;
1354
-
}
1350
+
1351
+
if (status)
1352
+
goto error;
1355
1353
memset(&vsi_info, 0, sizeof(vsi_info));
1356
1354
vsi_info.dev = &iwdev->sc_dev;
1357
1355
vsi_info.back_vsi = (void *)iwdev;
···
1360
1362
memset(&stats_info, 0, sizeof(stats_info));
1361
1363
stats_info.fcn_id = ldev->fid;
1362
1364
stats_info.pestat = kzalloc(sizeof(*stats_info.pestat), GFP_KERNEL);
1365
+
if (!stats_info.pestat) {
1366
+
status = I40IW_ERR_NO_MEMORY;
1367
+
goto error;
1368
+
}
1363
1369
stats_info.stats_initialize = true;
1364
1370
if (stats_info.pestat)
1365
1371
i40iw_vsi_stats_init(&iwdev->vsi, &stats_info);
1366
1372
}
1373
+
return status;
1374
+
error:
1375
+
kfree(iwdev->hmc_info_mem);
1376
+
iwdev->hmc_info_mem = NULL;
1367
1377
return status;
1368
1378
}
1369
1379
-1
drivers/infiniband/hw/i40iw/i40iw_osdep.h
-1
drivers/infiniband/hw/i40iw/i40iw_osdep.h
···
199
199
struct i40iw_virtchnl_work_info *work_info, u32 iw_vf_idx);
200
200
void *i40iw_remove_head(struct list_head *list);
201
201
void i40iw_qp_suspend_resume(struct i40iw_sc_dev *dev, struct i40iw_sc_qp *qp, bool suspend);
202
-
void i40iw_qp_mss_modify(struct i40iw_sc_dev *dev, struct i40iw_sc_qp *qp);
203
202
204
203
void i40iw_term_modify_qp(struct i40iw_sc_qp *qp, u8 next_state, u8 term, u8 term_len);
205
204
void i40iw_terminate_done(struct i40iw_sc_qp *qp, int timeout_occurred);
-2
drivers/infiniband/hw/i40iw/i40iw_type.h
-2
drivers/infiniband/hw/i40iw/i40iw_type.h
···
541
541
struct i40iw_modify_qp_info {
542
542
u64 rx_win0;
543
543
u64 rx_win1;
544
-
u16 new_mss;
545
544
u8 next_iwarp_state;
546
545
u8 termlen;
547
546
bool ord_valid;
···
553
554
bool dont_send_term;
554
555
bool dont_send_fin;
555
556
bool cached_var_valid;
556
-
bool mss_change;
557
557
bool force_loopback;
558
558
};
559
559
-17
drivers/infiniband/hw/i40iw/i40iw_utils.c
-17
drivers/infiniband/hw/i40iw/i40iw_utils.c
···
757
757
}
758
758
759
759
/**
760
-
* i40iw_qp_mss_modify - modify mss for qp
761
-
* @dev: hardware control device structure
762
-
* @qp: hardware control qp
763
-
*/
764
-
void i40iw_qp_mss_modify(struct i40iw_sc_dev *dev, struct i40iw_sc_qp *qp)
765
-
{
766
-
struct i40iw_device *iwdev = (struct i40iw_device *)dev->back_dev;
767
-
struct i40iw_qp *iwqp = (struct i40iw_qp *)qp->back_qp;
768
-
struct i40iw_modify_qp_info info;
769
-
770
-
memset(&info, 0, sizeof(info));
771
-
info.mss_change = true;
772
-
info.new_mss = qp->vsi->mss;
773
-
i40iw_hw_modify_qp(iwdev, iwqp, &info, false);
774
-
}
775
-
776
-
/**
777
760
* i40iw_term_modify_qp - modify qp for term message
778
761
* @qp: hardware control qp
779
762
* @next_state: qp's next state
+1
-4
drivers/infiniband/hw/i40iw/i40iw_virtchnl.c
+1
-4
drivers/infiniband/hw/i40iw/i40iw_virtchnl.c
···
443
443
if (!dev->vchnl_up)
444
444
return I40IW_ERR_NOT_READY;
445
445
if (vchnl_msg->iw_op_code == I40IW_VCHNL_OP_GET_VER) {
446
-
if (vchnl_msg->iw_op_ver != I40IW_VCHNL_OP_GET_VER_V0)
447
-
vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
448
-
else
449
-
vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
446
+
vchnl_pf_send_get_ver_resp(dev, vf_id, vchnl_msg);
450
447
return I40IW_SUCCESS;
451
448
}
452
449
for (iw_vf_idx = 0; iw_vf_idx < I40IW_MAX_PE_ENABLED_VF_COUNT; iw_vf_idx++) {
+1
drivers/infiniband/hw/mlx4/mad.c
+1
drivers/infiniband/hw/mlx4/mad.c
···
1578
1578
if (port < 0)
1579
1579
return;
1580
1580
ah.av.ib.port_pd = cpu_to_be32(port << 24 | (be32_to_cpu(ah.av.ib.port_pd) & 0xffffff));
1581
+
ah.ibah.type = rdma_ah_find_type(&dev->ib_dev, port);
1581
1582
1582
1583
mlx4_ib_query_ah(&ah.ibah, &ah_attr);
1583
1584
if (rdma_ah_get_ah_flags(&ah_attr) & IB_AH_GRH)
+14
drivers/infiniband/hw/mlx5/main.c
+14
drivers/infiniband/hw/mlx5/main.c
···
2979
2979
return ret;
2980
2980
}
2981
2981
2982
+
static u8 mlx5_get_umr_fence(u8 umr_fence_cap)
2983
+
{
2984
+
switch (umr_fence_cap) {
2985
+
case MLX5_CAP_UMR_FENCE_NONE:
2986
+
return MLX5_FENCE_MODE_NONE;
2987
+
case MLX5_CAP_UMR_FENCE_SMALL:
2988
+
return MLX5_FENCE_MODE_INITIATOR_SMALL;
2989
+
default:
2990
+
return MLX5_FENCE_MODE_STRONG_ORDERING;
2991
+
}
2992
+
}
2993
+
2982
2994
static int create_dev_resources(struct mlx5_ib_resources *devr)
2983
2995
{
2984
2996
struct ib_srq_init_attr attr;
···
3704
3692
dev->ib_dev.disassociate_ucontext = mlx5_ib_disassociate_ucontext;
3705
3693
3706
3694
mlx5_ib_internal_fill_odp_caps(dev);
3695
+
3696
+
dev->umr_fence = mlx5_get_umr_fence(MLX5_CAP_GEN(mdev, umr_fence));
3707
3697
3708
3698
if (MLX5_CAP_GEN(mdev, imaicl)) {
3709
3699
dev->ib_dev.alloc_mw = mlx5_ib_alloc_mw;
+2
-1
drivers/infiniband/hw/mlx5/mlx5_ib.h
+2
-1
drivers/infiniband/hw/mlx5/mlx5_ib.h
···
349
349
struct mlx5_ib_wq rq;
350
350
351
351
u8 sq_signal_bits;
352
-
u8 fm_cache;
352
+
u8 next_fence;
353
353
struct mlx5_ib_wq sq;
354
354
355
355
/* serialize qp state modifications
···
654
654
struct mlx5_ib_port *port;
655
655
struct mlx5_sq_bfreg bfreg;
656
656
struct mlx5_sq_bfreg fp_bfreg;
657
+
u8 umr_fence;
657
658
};
658
659
659
660
static inline struct mlx5_ib_cq *to_mibcq(struct mlx5_core_cq *mcq)
+23
-36
drivers/infiniband/hw/mlx5/qp.c
+23
-36
drivers/infiniband/hw/mlx5/qp.c
···
3738
3738
}
3739
3739
}
3740
3740
3741
-
static u8 get_fence(u8 fence, struct ib_send_wr *wr)
3742
-
{
3743
-
if (unlikely(wr->opcode == IB_WR_LOCAL_INV &&
3744
-
wr->send_flags & IB_SEND_FENCE))
3745
-
return MLX5_FENCE_MODE_STRONG_ORDERING;
3746
-
3747
-
if (unlikely(fence)) {
3748
-
if (wr->send_flags & IB_SEND_FENCE)
3749
-
return MLX5_FENCE_MODE_SMALL_AND_FENCE;
3750
-
else
3751
-
return fence;
3752
-
} else if (unlikely(wr->send_flags & IB_SEND_FENCE)) {
3753
-
return MLX5_FENCE_MODE_FENCE;
3754
-
}
3755
-
3756
-
return 0;
3757
-
}
3758
-
3759
3741
static int begin_wqe(struct mlx5_ib_qp *qp, void **seg,
3760
3742
struct mlx5_wqe_ctrl_seg **ctrl,
3761
3743
struct ib_send_wr *wr, unsigned *idx,
···
3766
3784
static void finish_wqe(struct mlx5_ib_qp *qp,
3767
3785
struct mlx5_wqe_ctrl_seg *ctrl,
3768
3786
u8 size, unsigned idx, u64 wr_id,
3769
-
int nreq, u8 fence, u8 next_fence,
3770
-
u32 mlx5_opcode)
3787
+
int nreq, u8 fence, u32 mlx5_opcode)
3771
3788
{
3772
3789
u8 opmod = 0;
3773
3790
···
3774
3793
mlx5_opcode | ((u32)opmod << 24));
3775
3794
ctrl->qpn_ds = cpu_to_be32(size | (qp->trans_qp.base.mqp.qpn << 8));
3776
3795
ctrl->fm_ce_se |= fence;
3777
-
qp->fm_cache = next_fence;
3778
3796
if (unlikely(qp->wq_sig))
3779
3797
ctrl->signature = wq_sig(ctrl);
3780
3798
···
3833
3853
goto out;
3834
3854
}
3835
3855
3836
-
fence = qp->fm_cache;
3837
3856
num_sge = wr->num_sge;
3838
3857
if (unlikely(num_sge > qp->sq.max_gs)) {
3839
3858
mlx5_ib_warn(dev, "\n");
···
3847
3868
err = -ENOMEM;
3848
3869
*bad_wr = wr;
3849
3870
goto out;
3871
+
}
3872
+
3873
+
if (wr->opcode == IB_WR_LOCAL_INV ||
3874
+
wr->opcode == IB_WR_REG_MR) {
3875
+
fence = dev->umr_fence;
3876
+
next_fence = MLX5_FENCE_MODE_INITIATOR_SMALL;
3877
+
} else if (wr->send_flags & IB_SEND_FENCE) {
3878
+
if (qp->next_fence)
3879
+
fence = MLX5_FENCE_MODE_SMALL_AND_FENCE;
3880
+
else
3881
+
fence = MLX5_FENCE_MODE_FENCE;
3882
+
} else {
3883
+
fence = qp->next_fence;
3850
3884
}
3851
3885
3852
3886
switch (ibqp->qp_type) {
···
3888
3896
goto out;
3889
3897
3890
3898
case IB_WR_LOCAL_INV:
3891
-
next_fence = MLX5_FENCE_MODE_INITIATOR_SMALL;
3892
3899
qp->sq.wr_data[idx] = IB_WR_LOCAL_INV;
3893
3900
ctrl->imm = cpu_to_be32(wr->ex.invalidate_rkey);
3894
3901
set_linv_wr(qp, &seg, &size);
···
3895
3904
break;
3896
3905
3897
3906
case IB_WR_REG_MR:
3898
-
next_fence = MLX5_FENCE_MODE_INITIATOR_SMALL;
3899
3907
qp->sq.wr_data[idx] = IB_WR_REG_MR;
3900
3908
ctrl->imm = cpu_to_be32(reg_wr(wr)->key);
3901
3909
err = set_reg_wr(qp, reg_wr(wr), &seg, &size);
···
3917
3927
goto out;
3918
3928
}
3919
3929
3920
-
finish_wqe(qp, ctrl, size, idx, wr->wr_id,
3921
-
nreq, get_fence(fence, wr),
3922
-
next_fence, MLX5_OPCODE_UMR);
3930
+
finish_wqe(qp, ctrl, size, idx, wr->wr_id, nreq,
3931
+
fence, MLX5_OPCODE_UMR);
3923
3932
/*
3924
3933
* SET_PSV WQEs are not signaled and solicited
3925
3934
* on error
···
3943
3954
goto out;
3944
3955
}
3945
3956
3946
-
finish_wqe(qp, ctrl, size, idx, wr->wr_id,
3947
-
nreq, get_fence(fence, wr),
3948
-
next_fence, MLX5_OPCODE_SET_PSV);
3957
+
finish_wqe(qp, ctrl, size, idx, wr->wr_id, nreq,
3958
+
fence, MLX5_OPCODE_SET_PSV);
3949
3959
err = begin_wqe(qp, &seg, &ctrl, wr,
3950
3960
&idx, &size, nreq);
3951
3961
if (err) {
···
3954
3966
goto out;
3955
3967
}
3956
3968
3957
-
next_fence = MLX5_FENCE_MODE_INITIATOR_SMALL;
3958
3969
err = set_psv_wr(&sig_handover_wr(wr)->sig_attrs->wire,
3959
3970
mr->sig->psv_wire.psv_idx, &seg,
3960
3971
&size);
···
3963
3976
goto out;
3964
3977
}
3965
3978
3966
-
finish_wqe(qp, ctrl, size, idx, wr->wr_id,
3967
-
nreq, get_fence(fence, wr),
3968
-
next_fence, MLX5_OPCODE_SET_PSV);
3979
+
finish_wqe(qp, ctrl, size, idx, wr->wr_id, nreq,
3980
+
fence, MLX5_OPCODE_SET_PSV);
3981
+
qp->next_fence = MLX5_FENCE_MODE_INITIATOR_SMALL;
3969
3982
num_sge = 0;
3970
3983
goto skip_psv;
3971
3984
···
4076
4089
}
4077
4090
}
4078
4091
4079
-
finish_wqe(qp, ctrl, size, idx, wr->wr_id, nreq,
4080
-
get_fence(fence, wr), next_fence,
4092
+
qp->next_fence = next_fence;
4093
+
finish_wqe(qp, ctrl, size, idx, wr->wr_id, nreq, fence,
4081
4094
mlx5_ib_opcode[wr->opcode]);
4082
4095
skip_psv:
4083
4096
if (0)
+1
-2
drivers/infiniband/hw/nes/nes_cm.c
+1
-2
drivers/infiniband/hw/nes/nes_cm.c
···
610
610
ctrl_ord = cm_node->ord_size & IETF_NO_IRD_ORD;
611
611
}
612
612
ctrl_ird |= IETF_PEER_TO_PEER;
613
-
ctrl_ird |= IETF_FLPDU_ZERO_LEN;
614
613
615
614
switch (mpa_key) {
616
615
case MPA_KEY_REQUEST:
···
1825
1826
type = NES_CM_EVENT_CONNECTED;
1826
1827
cm_node->state = NES_CM_STATE_TSA;
1827
1828
}
1828
-
1829
+
send_ack(cm_node, NULL);
1829
1830
break;
1830
1831
default:
1831
1832
WARN_ON(1);
+6
-4
drivers/infiniband/hw/qedr/qedr_cm.c
+6
-4
drivers/infiniband/hw/qedr/qedr_cm.c
···
270
270
return rc;
271
271
}
272
272
273
-
vlan_id = rdma_vlan_dev_vlan_id(sgid_attr.ndev);
274
-
if (vlan_id < VLAN_CFI_MASK)
275
-
has_vlan = true;
276
-
if (sgid_attr.ndev)
273
+
if (sgid_attr.ndev) {
274
+
vlan_id = rdma_vlan_dev_vlan_id(sgid_attr.ndev);
275
+
if (vlan_id < VLAN_CFI_MASK)
276
+
has_vlan = true;
277
+
277
278
dev_put(sgid_attr.ndev);
279
+
}
278
280
279
281
if (!memcmp(&sgid, &zgid, sizeof(sgid))) {
280
282
DP_ERR(dev, "gsi post send: GID not found GID index %d\n",
+3
-1
drivers/infiniband/hw/qib/qib_rc.c
+3
-1
drivers/infiniband/hw/qib/qib_rc.c
···
1956
1956
ret = qib_get_rwqe(qp, 1);
1957
1957
if (ret < 0)
1958
1958
goto nack_op_err;
1959
-
if (!ret)
1959
+
if (!ret) {
1960
+
rvt_put_ss(&qp->r_sge);
1960
1961
goto rnr_nak;
1962
+
}
1961
1963
wc.ex.imm_data = ohdr->u.rc.imm_data;
1962
1964
hdrsize += 4;
1963
1965
wc.wc_flags = IB_WC_WITH_IMM;
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_ethtool.c
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_ethtool.c
···
178
178
static int ipoib_get_link_ksettings(struct net_device *netdev,
179
179
struct ethtool_link_ksettings *cmd)
180
180
{
181
-
struct ipoib_dev_priv *priv = netdev_priv(netdev);
181
+
struct ipoib_dev_priv *priv = ipoib_priv(netdev);
182
182
struct ib_port_attr attr;
183
183
int ret, speed, width;
184
184
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_main.c
+1
-1
drivers/infiniband/ulp/ipoib/ipoib_main.c
+2
-2
drivers/infiniband/ulp/srp/ib_srp.c
+2
-2
drivers/infiniband/ulp/srp/ib_srp.c
···
320
320
ch->path.sgid = target->sgid;
321
321
ch->path.dgid = target->orig_dgid;
322
322
ch->path.pkey = target->pkey;
323
-
sa_path_set_service_id(&ch->path, target->service_id);
323
+
ch->path.service_id = target->service_id;
324
324
325
325
return 0;
326
326
}
···
575
575
return 0;
576
576
577
577
err_qp:
578
-
srp_destroy_qp(ch, qp);
578
+
ib_destroy_qp(qp);
579
579
580
580
err_send_cq:
581
581
ib_free_cq(send_cq);
+9
-1
include/linux/mlx5/mlx5_ifc.h
+9
-1
include/linux/mlx5/mlx5_ifc.h
···
766
766
MLX5_CAP_PORT_TYPE_ETH = 0x1,
767
767
};
768
768
769
+
enum {
770
+
MLX5_CAP_UMR_FENCE_STRONG = 0x0,
771
+
MLX5_CAP_UMR_FENCE_SMALL = 0x1,
772
+
MLX5_CAP_UMR_FENCE_NONE = 0x2,
773
+
};
774
+
769
775
struct mlx5_ifc_cmd_hca_cap_bits {
770
776
u8 reserved_at_0[0x80];
771
777
···
881
875
u8 reserved_at_202[0x1];
882
876
u8 ipoib_enhanced_offloads[0x1];
883
877
u8 ipoib_basic_offloads[0x1];
884
-
u8 reserved_at_205[0xa];
878
+
u8 reserved_at_205[0x5];
879
+
u8 umr_fence[0x2];
880
+
u8 reserved_at_20c[0x3];
885
881
u8 drain_sigerr[0x1];
886
882
u8 cmdif_checksum[0x2];
887
883
u8 sigerr_cqe[0x1];
+3
-22
include/rdma/ib_sa.h
+3
-22
include/rdma/ib_sa.h
···
158
158
};
159
159
160
160
struct sa_path_rec_ib {
161
-
__be64 service_id;
162
161
__be16 dlid;
163
162
__be16 slid;
164
163
u8 raw_traffic;
···
173
174
};
174
175
175
176
struct sa_path_rec_opa {
176
-
__be64 service_id;
177
177
__be32 dlid;
178
178
__be32 slid;
179
179
u8 raw_traffic;
···
187
189
struct sa_path_rec {
188
190
union ib_gid dgid;
189
191
union ib_gid sgid;
192
+
__be64 service_id;
190
193
/* reserved */
191
194
__be32 flow_label;
192
195
u8 hop_limit;
···
261
262
ib->ib.dlid = htons(ntohl(opa->opa.dlid));
262
263
ib->ib.slid = htons(ntohl(opa->opa.slid));
263
264
}
264
-
ib->ib.service_id = opa->opa.service_id;
265
+
ib->service_id = opa->service_id;
265
266
ib->ib.raw_traffic = opa->opa.raw_traffic;
266
267
}
267
268
···
280
281
}
281
282
opa->opa.slid = slid;
282
283
opa->opa.dlid = dlid;
283
-
opa->opa.service_id = ib->ib.service_id;
284
+
opa->service_id = ib->service_id;
284
285
opa->opa.raw_traffic = ib->ib.raw_traffic;
285
286
}
286
287
···
590
591
(rec->rec_type == SA_PATH_REC_TYPE_ROCE_V2));
591
592
}
592
593
593
-
static inline void sa_path_set_service_id(struct sa_path_rec *rec,
594
-
__be64 service_id)
595
-
{
596
-
if (rec->rec_type == SA_PATH_REC_TYPE_IB)
597
-
rec->ib.service_id = service_id;
598
-
else if (rec->rec_type == SA_PATH_REC_TYPE_OPA)
599
-
rec->opa.service_id = service_id;
600
-
}
601
-
602
594
static inline void sa_path_set_slid(struct sa_path_rec *rec, __be32 slid)
603
595
{
604
596
if (rec->rec_type == SA_PATH_REC_TYPE_IB)
···
613
623
rec->ib.raw_traffic = raw_traffic;
614
624
else if (rec->rec_type == SA_PATH_REC_TYPE_OPA)
615
625
rec->opa.raw_traffic = raw_traffic;
616
-
}
617
-
618
-
static inline __be64 sa_path_get_service_id(struct sa_path_rec *rec)
619
-
{
620
-
if (rec->rec_type == SA_PATH_REC_TYPE_IB)
621
-
return rec->ib.service_id;
622
-
else if (rec->rec_type == SA_PATH_REC_TYPE_OPA)
623
-
return rec->opa.service_id;
624
-
return 0;
625
626
}
626
627
627
628
static inline __be32 sa_path_get_slid(struct sa_path_rec *rec)
-10
include/rdma/rdma_netlink.h
-10
include/rdma/rdma_netlink.h
···
10
10
struct module *module;
11
11
};
12
12
13
-
int ibnl_init(void);
14
-
void ibnl_cleanup(void);
15
-
16
13
/**
17
14
* Add a a client to the list of IB netlink exporters.
18
15
* @index: Index of the added client
···
73
76
*/
74
77
int ibnl_multicast(struct sk_buff *skb, struct nlmsghdr *nlh,
75
78
unsigned int group, gfp_t flags);
76
-
77
-
/**
78
-
* Check if there are any listeners to the netlink group
79
-
* @group: the netlink group ID
80
-
* Returns 0 on success or a negative for no listeners.
81
-
*/
82
-
int ibnl_chk_listeners(unsigned int group);
83
79
84
80
#endif /* _RDMA_NETLINK_H */