tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma

Pull rdma fixes from Jason Gunthorpe:
"A lot of fixes accumulated over the holiday break:

- Static tool fixes, value is already proven to be NULL, possible
integer overflow

- Many bnxt_re fixes:
- Crashes due to a mismatch in the maximum SGE list size
- Don't waste memory for user QPs by creating kernel-only
structures
- Fix compatability issues with older HW in some of the new HW
features recently introduced: RTS->RTS feature, work around 9096
- Do not allow destroy_qp to fail
- Validate QP MTU against device limits
- Add missing validation on madatory QP attributes for RTR->RTS
- Report port_num in query_qp as required by the spec
- Fix creation of QPs of the maximum queue size, and in the
variable mode
- Allow all QPs to be used on newer HW by limiting a work around
only to HW it affects
- Use the correct MSN table size for variable mode QPs
- Add missing locking in create_qp() accessing the qp_tbl
- Form WQE buffers correctly when some of the buffers are 0 hop
- Don't crash on QP destroy if the userspace doesn't setup the
dip_ctx
- Add the missing QP flush handler call on the DWQE path to avoid
hanging on error recovery
- Consistently use ENXIO for return codes if the devices is
fatally errored

- Try again to fix VLAN support on iwarp, previous fix was reverted
due to breaking other cards

- Correct error path return code for rdma netlink events

- Remove the seperate net_device pointer in siw and rxe which
syzkaller found a way to UAF

- Fix a UAF of a stack ib_sge in rtrs

- Fix a regression where old mlx5 devices and FW were wrongly
activing new device features and failing"

* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma: (28 commits)
RDMA/mlx5: Enable multiplane mode only when it is supported
RDMA/bnxt_re: Fix error recovery sequence
RDMA/rtrs: Ensure 'ib_sge list' is accessible
RDMA/rxe: Remove the direct link to net_device
RDMA/hns: Fix missing flush CQE for DWQE
RDMA/hns: Fix warning storm caused by invalid input in IO path
RDMA/hns: Fix accessing invalid dip_ctx during destroying QP
RDMA/hns: Fix mapping error of zero-hop WQE buffer
RDMA/bnxt_re: Fix the locking while accessing the QP table
RDMA/bnxt_re: Fix MSN table size for variable wqe mode
RDMA/bnxt_re: Add send queue size check for variable wqe
RDMA/bnxt_re: Disable use of reserved wqes
RDMA/bnxt_re: Fix max_qp_wrs reported
RDMA/siw: Remove direct link to net_device
RDMA/nldev: Set error code in rdma_nl_notify_event
RDMA/bnxt_re: Fix reporting hw_ver in query_device
RDMA/bnxt_re: Fix to export port num to ib_query_qp
RDMA/bnxt_re: Fix setting mandatory attributes for modify_qp
RDMA/bnxt_re: Add check for path mtu in modify_qp
RDMA/bnxt_re: Fix the check for 9060 condition
...

Linus Torvalds dea3165f f274fffb

+321 -159
+16
drivers/infiniband/core/cma.c
··· 690 690 int bound_if_index = dev_addr->bound_dev_if; 691 691 int dev_type = dev_addr->dev_type; 692 692 struct net_device *ndev = NULL; 693 + struct net_device *pdev = NULL; 693 694 694 695 if (!rdma_dev_access_netns(device, id_priv->id.route.addr.dev_addr.net)) 695 696 goto out; ··· 715 714 716 715 rcu_read_lock(); 717 716 ndev = rcu_dereference(sgid_attr->ndev); 717 + if (ndev->ifindex != bound_if_index) { 718 + pdev = dev_get_by_index_rcu(dev_addr->net, bound_if_index); 719 + if (pdev) { 720 + if (is_vlan_dev(pdev)) { 721 + pdev = vlan_dev_real_dev(pdev); 722 + if (ndev->ifindex == pdev->ifindex) 723 + bound_if_index = pdev->ifindex; 724 + } 725 + if (is_vlan_dev(ndev)) { 726 + pdev = vlan_dev_real_dev(ndev); 727 + if (bound_if_index == pdev->ifindex) 728 + bound_if_index = ndev->ifindex; 729 + } 730 + } 731 + } 718 732 if (!net_eq(dev_net(ndev), dev_addr->net) || 719 733 ndev->ifindex != bound_if_index) { 720 734 rdma_put_gid_attr(sgid_attr);
+1 -1
drivers/infiniband/core/nldev.c
··· 2833 2833 enum rdma_nl_notify_event_type type) 2834 2834 { 2835 2835 struct sk_buff *skb; 2836 + int ret = -EMSGSIZE; 2836 2837 struct net *net; 2837 - int ret = 0; 2838 2838 void *nlh; 2839 2839 2840 2840 net = read_pnet(&device->coredev.rdma_net);
+9 -7
drivers/infiniband/core/uverbs_cmd.c
··· 161 161 { 162 162 const void __user *res = iter->cur; 163 163 164 - if (iter->cur + len > iter->end) 164 + if (len > iter->end - iter->cur) 165 165 return (void __force __user *)ERR_PTR(-ENOSPC); 166 166 iter->cur += len; 167 167 return res; ··· 2008 2008 ret = uverbs_request_start(attrs, &iter, &cmd, sizeof(cmd)); 2009 2009 if (ret) 2010 2010 return ret; 2011 - wqes = uverbs_request_next_ptr(&iter, cmd.wqe_size * cmd.wr_count); 2011 + wqes = uverbs_request_next_ptr(&iter, size_mul(cmd.wqe_size, 2012 + cmd.wr_count)); 2012 2013 if (IS_ERR(wqes)) 2013 2014 return PTR_ERR(wqes); 2014 - sgls = uverbs_request_next_ptr( 2015 - &iter, cmd.sge_count * sizeof(struct ib_uverbs_sge)); 2015 + sgls = uverbs_request_next_ptr(&iter, 2016 + size_mul(cmd.sge_count, 2017 + sizeof(struct ib_uverbs_sge))); 2016 2018 if (IS_ERR(sgls)) 2017 2019 return PTR_ERR(sgls); 2018 2020 ret = uverbs_request_finish(&iter); ··· 2200 2198 if (wqe_size < sizeof(struct ib_uverbs_recv_wr)) 2201 2199 return ERR_PTR(-EINVAL); 2202 2200 2203 - wqes = uverbs_request_next_ptr(iter, wqe_size * wr_count); 2201 + wqes = uverbs_request_next_ptr(iter, size_mul(wqe_size, wr_count)); 2204 2202 if (IS_ERR(wqes)) 2205 2203 return ERR_CAST(wqes); 2206 - sgls = uverbs_request_next_ptr( 2207 - iter, sge_count * sizeof(struct ib_uverbs_sge)); 2204 + sgls = uverbs_request_next_ptr(iter, size_mul(sge_count, 2205 + sizeof(struct ib_uverbs_sge))); 2208 2206 if (IS_ERR(sgls)) 2209 2207 return ERR_CAST(sgls); 2210 2208 ret = uverbs_request_finish(iter);
+25 -25
drivers/infiniband/hw/bnxt_re/ib_verbs.c
··· 199 199 200 200 ib_attr->vendor_id = rdev->en_dev->pdev->vendor; 201 201 ib_attr->vendor_part_id = rdev->en_dev->pdev->device; 202 - ib_attr->hw_ver = rdev->en_dev->pdev->subsystem_device; 202 + ib_attr->hw_ver = rdev->en_dev->pdev->revision; 203 203 ib_attr->max_qp = dev_attr->max_qp; 204 204 ib_attr->max_qp_wr = dev_attr->max_qp_wqes; 205 205 ib_attr->device_cap_flags = ··· 967 967 unsigned int flags; 968 968 int rc; 969 969 970 + bnxt_re_debug_rem_qpinfo(rdev, qp); 971 + 970 972 bnxt_qplib_flush_cqn_wq(&qp->qplib_qp); 971 973 972 974 rc = bnxt_qplib_destroy_qp(&rdev->qplib_res, &qp->qplib_qp); 973 - if (rc) { 975 + if (rc) 974 976 ibdev_err(&rdev->ibdev, "Failed to destroy HW QP"); 975 - return rc; 976 - } 977 977 978 978 if (rdma_is_kernel_res(&qp->ib_qp.res)) { 979 979 flags = bnxt_re_lock_cqs(qp); ··· 983 983 984 984 bnxt_qplib_free_qp_res(&rdev->qplib_res, &qp->qplib_qp); 985 985 986 - if (ib_qp->qp_type == IB_QPT_GSI && rdev->gsi_ctx.gsi_sqp) { 987 - rc = bnxt_re_destroy_gsi_sqp(qp); 988 - if (rc) 989 - return rc; 990 - } 986 + if (ib_qp->qp_type == IB_QPT_GSI && rdev->gsi_ctx.gsi_sqp) 987 + bnxt_re_destroy_gsi_sqp(qp); 991 988 992 989 mutex_lock(&rdev->qp_lock); 993 990 list_del(&qp->list); ··· 994 997 atomic_dec(&rdev->stats.res.rc_qp_count); 995 998 else if (qp->qplib_qp.type == CMDQ_CREATE_QP_TYPE_UD) 996 999 atomic_dec(&rdev->stats.res.ud_qp_count); 997 - 998 - bnxt_re_debug_rem_qpinfo(rdev, qp); 999 1000 1000 1001 ib_umem_release(qp->rumem); 1001 1002 ib_umem_release(qp->sumem); ··· 2162 2167 } 2163 2168 } 2164 2169 2165 - if (qp_attr_mask & IB_QP_PATH_MTU) { 2166 - qp->qplib_qp.modify_flags |= 2167 - CMDQ_MODIFY_QP_MODIFY_MASK_PATH_MTU; 2168 - qp->qplib_qp.path_mtu = __from_ib_mtu(qp_attr->path_mtu); 2169 - qp->qplib_qp.mtu = ib_mtu_enum_to_int(qp_attr->path_mtu); 2170 - } else if (qp_attr->qp_state == IB_QPS_RTR) { 2171 - qp->qplib_qp.modify_flags |= 2172 - CMDQ_MODIFY_QP_MODIFY_MASK_PATH_MTU; 2173 - qp->qplib_qp.path_mtu = 2174 - __from_ib_mtu(iboe_get_mtu(rdev->netdev->mtu)); 2175 - qp->qplib_qp.mtu = 2176 - ib_mtu_enum_to_int(iboe_get_mtu(rdev->netdev->mtu)); 2170 + if (qp_attr->qp_state == IB_QPS_RTR) { 2171 + enum ib_mtu qpmtu; 2172 + 2173 + qpmtu = iboe_get_mtu(rdev->netdev->mtu); 2174 + if (qp_attr_mask & IB_QP_PATH_MTU) { 2175 + if (ib_mtu_enum_to_int(qp_attr->path_mtu) > 2176 + ib_mtu_enum_to_int(qpmtu)) 2177 + return -EINVAL; 2178 + qpmtu = qp_attr->path_mtu; 2179 + } 2180 + 2181 + qp->qplib_qp.modify_flags |= CMDQ_MODIFY_QP_MODIFY_MASK_PATH_MTU; 2182 + qp->qplib_qp.path_mtu = __from_ib_mtu(qpmtu); 2183 + qp->qplib_qp.mtu = ib_mtu_enum_to_int(qpmtu); 2177 2184 } 2178 2185 2179 2186 if (qp_attr_mask & IB_QP_TIMEOUT) { ··· 2325 2328 qp_attr->retry_cnt = qplib_qp->retry_cnt; 2326 2329 qp_attr->rnr_retry = qplib_qp->rnr_retry; 2327 2330 qp_attr->min_rnr_timer = qplib_qp->min_rnr_timer; 2331 + qp_attr->port_num = __to_ib_port_num(qplib_qp->port_id); 2328 2332 qp_attr->rq_psn = qplib_qp->rq.psn; 2329 2333 qp_attr->max_rd_atomic = qplib_qp->max_rd_atomic; 2330 2334 qp_attr->sq_psn = qplib_qp->sq.psn; ··· 2822 2824 wr = wr->next; 2823 2825 } 2824 2826 bnxt_qplib_post_send_db(&qp->qplib_qp); 2825 - bnxt_ud_qp_hw_stall_workaround(qp); 2827 + if (!bnxt_qplib_is_chip_gen_p5_p7(qp->rdev->chip_ctx)) 2828 + bnxt_ud_qp_hw_stall_workaround(qp); 2826 2829 spin_unlock_irqrestore(&qp->sq_lock, flags); 2827 2830 return rc; 2828 2831 } ··· 2935 2936 wr = wr->next; 2936 2937 } 2937 2938 bnxt_qplib_post_send_db(&qp->qplib_qp); 2938 - bnxt_ud_qp_hw_stall_workaround(qp); 2939 + if (!bnxt_qplib_is_chip_gen_p5_p7(qp->rdev->chip_ctx)) 2940 + bnxt_ud_qp_hw_stall_workaround(qp); 2939 2941 spin_unlock_irqrestore(&qp->sq_lock, flags); 2940 2942 2941 2943 return rc;
+4
drivers/infiniband/hw/bnxt_re/ib_verbs.h
··· 268 268 int bnxt_re_mmap(struct ib_ucontext *context, struct vm_area_struct *vma); 269 269 void bnxt_re_mmap_free(struct rdma_user_mmap_entry *rdma_entry); 270 270 271 + static inline u32 __to_ib_port_num(u16 port_id) 272 + { 273 + return (u32)port_id + 1; 274 + } 271 275 272 276 unsigned long bnxt_re_lock_cqs(struct bnxt_re_qp *qp); 273 277 void bnxt_re_unlock_cqs(struct bnxt_re_qp *qp, unsigned long flags);
+1 -7
drivers/infiniband/hw/bnxt_re/main.c
··· 1715 1715 1716 1716 static void bnxt_re_dev_stop(struct bnxt_re_dev *rdev) 1717 1717 { 1718 - int mask = IB_QP_STATE; 1719 - struct ib_qp_attr qp_attr; 1720 1718 struct bnxt_re_qp *qp; 1721 1719 1722 - qp_attr.qp_state = IB_QPS_ERR; 1723 1720 mutex_lock(&rdev->qp_lock); 1724 1721 list_for_each_entry(qp, &rdev->qp_list, list) { 1725 1722 /* Modify the state of all QPs except QP1/Shadow QP */ ··· 1724 1727 if (qp->qplib_qp.state != 1725 1728 CMDQ_MODIFY_QP_NEW_STATE_RESET && 1726 1729 qp->qplib_qp.state != 1727 - CMDQ_MODIFY_QP_NEW_STATE_ERR) { 1730 + CMDQ_MODIFY_QP_NEW_STATE_ERR) 1728 1731 bnxt_re_dispatch_event(&rdev->ibdev, &qp->ib_qp, 1729 1732 1, IB_EVENT_QP_FATAL); 1730 - bnxt_re_modify_qp(&qp->ib_qp, &qp_attr, mask, 1731 - NULL); 1732 - } 1733 1733 } 1734 1734 } 1735 1735 mutex_unlock(&rdev->qp_lock);
+50 -29
drivers/infiniband/hw/bnxt_re/qplib_fp.c
··· 659 659 rc = bnxt_qplib_alloc_init_hwq(&srq->hwq, &hwq_attr); 660 660 if (rc) 661 661 return rc; 662 - 663 - srq->swq = kcalloc(srq->hwq.max_elements, sizeof(*srq->swq), 664 - GFP_KERNEL); 665 - if (!srq->swq) { 666 - rc = -ENOMEM; 667 - goto fail; 668 - } 669 662 srq->dbinfo.flags = 0; 670 663 bnxt_qplib_rcfw_cmd_prep((struct cmdq_base *)&req, 671 664 CMDQ_BASE_OPCODE_CREATE_SRQ, ··· 687 694 spin_lock_init(&srq->lock); 688 695 srq->start_idx = 0; 689 696 srq->last_idx = srq->hwq.max_elements - 1; 690 - for (idx = 0; idx < srq->hwq.max_elements; idx++) 691 - srq->swq[idx].next_idx = idx + 1; 692 - srq->swq[srq->last_idx].next_idx = -1; 697 + if (!srq->hwq.is_user) { 698 + srq->swq = kcalloc(srq->hwq.max_elements, sizeof(*srq->swq), 699 + GFP_KERNEL); 700 + if (!srq->swq) { 701 + rc = -ENOMEM; 702 + goto fail; 703 + } 704 + for (idx = 0; idx < srq->hwq.max_elements; idx++) 705 + srq->swq[idx].next_idx = idx + 1; 706 + srq->swq[srq->last_idx].next_idx = -1; 707 + } 693 708 694 709 srq->id = le32_to_cpu(resp.xid); 695 710 srq->dbinfo.hwq = &srq->hwq; ··· 1001 1000 u32 tbl_indx; 1002 1001 u16 nsge; 1003 1002 1004 - if (res->dattr) 1005 - qp->is_host_msn_tbl = _is_host_msn_table(res->dattr->dev_cap_flags2); 1006 - 1003 + qp->is_host_msn_tbl = _is_host_msn_table(res->dattr->dev_cap_flags2); 1007 1004 sq->dbinfo.flags = 0; 1008 1005 bnxt_qplib_rcfw_cmd_prep((struct cmdq_base *)&req, 1009 1006 CMDQ_BASE_OPCODE_CREATE_QP, ··· 1033 1034 : 0; 1034 1035 /* Update msn tbl size */ 1035 1036 if (qp->is_host_msn_tbl && psn_sz) { 1036 - hwq_attr.aux_depth = roundup_pow_of_two(bnxt_qplib_set_sq_size(sq, qp->wqe_mode)); 1037 + if (qp->wqe_mode == BNXT_QPLIB_WQE_MODE_STATIC) 1038 + hwq_attr.aux_depth = 1039 + roundup_pow_of_two(bnxt_qplib_set_sq_size(sq, qp->wqe_mode)); 1040 + else 1041 + hwq_attr.aux_depth = 1042 + roundup_pow_of_two(bnxt_qplib_set_sq_size(sq, qp->wqe_mode)) / 2; 1037 1043 qp->msn_tbl_sz = hwq_attr.aux_depth; 1038 1044 qp->msn = 0; 1039 1045 } ··· 1048 1044 if (rc) 1049 1045 return rc; 1050 1046 1051 - rc = bnxt_qplib_alloc_init_swq(sq); 1052 - if (rc) 1053 - goto fail_sq; 1047 + if (!sq->hwq.is_user) { 1048 + rc = bnxt_qplib_alloc_init_swq(sq); 1049 + if (rc) 1050 + goto fail_sq; 1054 1051 1055 - if (psn_sz) 1056 - bnxt_qplib_init_psn_ptr(qp, psn_sz); 1057 - 1052 + if (psn_sz) 1053 + bnxt_qplib_init_psn_ptr(qp, psn_sz); 1054 + } 1058 1055 req.sq_size = cpu_to_le32(bnxt_qplib_set_sq_size(sq, qp->wqe_mode)); 1059 1056 pbl = &sq->hwq.pbl[PBL_LVL_0]; 1060 1057 req.sq_pbl = cpu_to_le64(pbl->pg_map_arr[0]); ··· 1081 1076 rc = bnxt_qplib_alloc_init_hwq(&rq->hwq, &hwq_attr); 1082 1077 if (rc) 1083 1078 goto sq_swq; 1084 - rc = bnxt_qplib_alloc_init_swq(rq); 1085 - if (rc) 1086 - goto fail_rq; 1079 + if (!rq->hwq.is_user) { 1080 + rc = bnxt_qplib_alloc_init_swq(rq); 1081 + if (rc) 1082 + goto fail_rq; 1083 + } 1087 1084 1088 1085 req.rq_size = cpu_to_le32(rq->max_wqe); 1089 1086 pbl = &rq->hwq.pbl[PBL_LVL_0]; ··· 1181 1174 rq->dbinfo.db = qp->dpi->dbr; 1182 1175 rq->dbinfo.max_slot = bnxt_qplib_set_rq_max_slot(rq->wqe_size); 1183 1176 } 1177 + spin_lock_bh(&rcfw->tbl_lock); 1184 1178 tbl_indx = map_qp_id_to_tbl_indx(qp->id, rcfw); 1185 1179 rcfw->qp_tbl[tbl_indx].qp_id = qp->id; 1186 1180 rcfw->qp_tbl[tbl_indx].qp_handle = (void *)qp; 1181 + spin_unlock_bh(&rcfw->tbl_lock); 1187 1182 1188 1183 return 0; 1189 1184 fail: ··· 1292 1283 } 1293 1284 } 1294 1285 1295 - static void bnxt_set_mandatory_attributes(struct bnxt_qplib_qp *qp, 1286 + static void bnxt_set_mandatory_attributes(struct bnxt_qplib_res *res, 1287 + struct bnxt_qplib_qp *qp, 1296 1288 struct cmdq_modify_qp *req) 1297 1289 { 1298 1290 u32 mandatory_flags = 0; ··· 1306 1296 if (qp->type == CMDQ_MODIFY_QP_QP_TYPE_RC && qp->srq) 1307 1297 req->flags = cpu_to_le16(CMDQ_MODIFY_QP_FLAGS_SRQ_USED); 1308 1298 mandatory_flags |= CMDQ_MODIFY_QP_MODIFY_MASK_PKEY; 1299 + } 1300 + 1301 + if (_is_min_rnr_in_rtr_rts_mandatory(res->dattr->dev_cap_flags2) && 1302 + (qp->cur_qp_state == CMDQ_MODIFY_QP_NEW_STATE_RTR && 1303 + qp->state == CMDQ_MODIFY_QP_NEW_STATE_RTS)) { 1304 + if (qp->type == CMDQ_MODIFY_QP_QP_TYPE_RC) 1305 + mandatory_flags |= 1306 + CMDQ_MODIFY_QP_MODIFY_MASK_MIN_RNR_TIMER; 1309 1307 } 1310 1308 1311 1309 if (qp->type == CMDQ_MODIFY_QP_QP_TYPE_UD || ··· 1356 1338 /* Set mandatory attributes for INIT -> RTR and RTR -> RTS transition */ 1357 1339 if (_is_optimize_modify_qp_supported(res->dattr->dev_cap_flags2) && 1358 1340 is_optimized_state_transition(qp)) 1359 - bnxt_set_mandatory_attributes(qp, &req); 1341 + bnxt_set_mandatory_attributes(res, qp, &req); 1360 1342 } 1361 1343 bmask = qp->modify_flags; 1362 1344 req.modify_mask = cpu_to_le32(qp->modify_flags); ··· 1539 1521 qp->dest_qpn = le32_to_cpu(sb->dest_qp_id); 1540 1522 memcpy(qp->smac, sb->src_mac, 6); 1541 1523 qp->vlan_id = le16_to_cpu(sb->vlan_pcp_vlan_dei_vlan_id); 1524 + qp->port_id = le16_to_cpu(sb->port_id); 1542 1525 bail: 1543 1526 dma_free_coherent(&rcfw->pdev->dev, sbuf.size, 1544 1527 sbuf.sb, sbuf.dma_addr); ··· 2686 2667 bnxt_qplib_add_flush_qp(qp); 2687 2668 } else { 2688 2669 /* Before we complete, do WA 9060 */ 2689 - if (do_wa9060(qp, cq, cq_cons, sq->swq_last, 2690 - cqe_sq_cons)) { 2691 - *lib_qp = qp; 2692 - goto out; 2670 + if (!bnxt_qplib_is_chip_gen_p5_p7(qp->cctx)) { 2671 + if (do_wa9060(qp, cq, cq_cons, sq->swq_last, 2672 + cqe_sq_cons)) { 2673 + *lib_qp = qp; 2674 + goto out; 2675 + } 2693 2676 } 2694 2677 if (swq->flags & SQ_SEND_FLAGS_SIGNAL_COMP) { 2695 2678 cqe->status = CQ_REQ_STATUS_OK;
+2 -2
drivers/infiniband/hw/bnxt_re/qplib_fp.h
··· 114 114 u32 size; 115 115 }; 116 116 117 - #define BNXT_QPLIB_QP_MAX_SGL 6 118 117 struct bnxt_qplib_swq { 119 118 u64 wr_id; 120 119 int next_idx; ··· 153 154 #define BNXT_QPLIB_SWQE_FLAGS_UC_FENCE BIT(2) 154 155 #define BNXT_QPLIB_SWQE_FLAGS_SOLICIT_EVENT BIT(3) 155 156 #define BNXT_QPLIB_SWQE_FLAGS_INLINE BIT(4) 156 - struct bnxt_qplib_sge sg_list[BNXT_QPLIB_QP_MAX_SGL]; 157 + struct bnxt_qplib_sge sg_list[BNXT_VAR_MAX_SGE]; 157 158 int num_sge; 158 159 /* Max inline data is 96 bytes */ 159 160 u32 inline_len; ··· 298 299 u32 dest_qpn; 299 300 u8 smac[6]; 300 301 u16 vlan_id; 302 + u16 port_id; 301 303 u8 nw_type; 302 304 struct bnxt_qplib_ah ah; 303 305
+3 -2
drivers/infiniband/hw/bnxt_re/qplib_rcfw.c
··· 424 424 425 425 /* Prevent posting if f/w is not in a state to process */ 426 426 if (test_bit(ERR_DEVICE_DETACHED, &rcfw->cmdq.flags)) 427 - return bnxt_qplib_map_rc(opcode); 427 + return -ENXIO; 428 + 428 429 if (test_bit(FIRMWARE_STALL_DETECTED, &cmdq->flags)) 429 430 return -ETIMEDOUT; 430 431 ··· 494 493 495 494 rc = __send_message_basic_sanity(rcfw, msg, opcode); 496 495 if (rc) 497 - return rc; 496 + return rc == -ENXIO ? bnxt_qplib_map_rc(opcode) : rc; 498 497 499 498 rc = __send_message(rcfw, msg, opcode); 500 499 if (rc)
+5
drivers/infiniband/hw/bnxt_re/qplib_res.h
··· 584 584 return dev_cap_ext_flags2 & CREQ_QUERY_FUNC_RESP_SB_OPTIMIZE_MODIFY_QP_SUPPORTED; 585 585 } 586 586 587 + static inline bool _is_min_rnr_in_rtr_rts_mandatory(u16 dev_cap_ext_flags2) 588 + { 589 + return !!(dev_cap_ext_flags2 & CREQ_QUERY_FUNC_RESP_SB_MIN_RNR_RTR_RTS_OPT_SUPPORTED); 590 + } 591 + 587 592 static inline bool _is_cq_coalescing_supported(u16 dev_cap_ext_flags2) 588 593 { 589 594 return dev_cap_ext_flags2 & CREQ_QUERY_FUNC_RESP_SB_CQ_COALESCING_SUPPORTED;
+12 -6
drivers/infiniband/hw/bnxt_re/qplib_sp.c
··· 129 129 attr->max_qp_init_rd_atom = 130 130 sb->max_qp_init_rd_atom > BNXT_QPLIB_MAX_OUT_RD_ATOM ? 131 131 BNXT_QPLIB_MAX_OUT_RD_ATOM : sb->max_qp_init_rd_atom; 132 - attr->max_qp_wqes = le16_to_cpu(sb->max_qp_wr); 133 - /* 134 - * 128 WQEs needs to be reserved for the HW (8916). Prevent 135 - * reporting the max number 136 - */ 137 - attr->max_qp_wqes -= BNXT_QPLIB_RESERVED_QP_WRS + 1; 132 + attr->max_qp_wqes = le16_to_cpu(sb->max_qp_wr) - 1; 133 + if (!bnxt_qplib_is_chip_gen_p5_p7(rcfw->res->cctx)) { 134 + /* 135 + * 128 WQEs needs to be reserved for the HW (8916). Prevent 136 + * reporting the max number on legacy devices 137 + */ 138 + attr->max_qp_wqes -= BNXT_QPLIB_RESERVED_QP_WRS + 1; 139 + } 140 + 141 + /* Adjust for max_qp_wqes for variable wqe */ 142 + if (cctx->modes.wqe_mode == BNXT_QPLIB_WQE_MODE_VARIABLE) 143 + attr->max_qp_wqes = BNXT_VAR_MAX_WQE - 1; 138 144 139 145 attr->max_qp_sges = cctx->modes.wqe_mode == BNXT_QPLIB_WQE_MODE_VARIABLE ? 140 146 min_t(u32, sb->max_sge_var_wqe, BNXT_VAR_MAX_SGE) : 6;
+1
drivers/infiniband/hw/bnxt_re/roce_hsi.h
··· 2215 2215 #define CREQ_QUERY_FUNC_RESP_SB_REQ_RETRANSMISSION_SUPPORT_IQM_MSN_TABLE (0x2UL << 4) 2216 2216 #define CREQ_QUERY_FUNC_RESP_SB_REQ_RETRANSMISSION_SUPPORT_LAST \ 2217 2217 CREQ_QUERY_FUNC_RESP_SB_REQ_RETRANSMISSION_SUPPORT_IQM_MSN_TABLE 2218 + #define CREQ_QUERY_FUNC_RESP_SB_MIN_RNR_RTR_RTS_OPT_SUPPORTED 0x1000UL 2218 2219 __le16 max_xp_qp_size; 2219 2220 __le16 create_qp_batch_size; 2220 2221 __le16 destroy_qp_batch_size;
+29 -14
drivers/infiniband/hw/hns/hns_roce_hem.c
··· 931 931 size_t count; /* max ba numbers */ 932 932 int start; /* start buf offset in this hem */ 933 933 int end; /* end buf offset in this hem */ 934 + bool exist_bt; 934 935 }; 935 936 936 937 /* All HEM items are linked in a tree structure */ ··· 960 959 } 961 960 } 962 961 962 + hem->exist_bt = exist_bt; 963 963 hem->count = count; 964 964 hem->start = start; 965 965 hem->end = end; ··· 971 969 } 972 970 973 971 static void hem_list_free_item(struct hns_roce_dev *hr_dev, 974 - struct hns_roce_hem_item *hem, bool exist_bt) 972 + struct hns_roce_hem_item *hem) 975 973 { 976 - if (exist_bt) 974 + if (hem->exist_bt) 977 975 dma_free_coherent(hr_dev->dev, hem->count * BA_BYTE_LEN, 978 976 hem->addr, hem->dma_addr); 979 977 kfree(hem); 980 978 } 981 979 982 980 static void hem_list_free_all(struct hns_roce_dev *hr_dev, 983 - struct list_head *head, bool exist_bt) 981 + struct list_head *head) 984 982 { 985 983 struct hns_roce_hem_item *hem, *temp_hem; 986 984 987 985 list_for_each_entry_safe(hem, temp_hem, head, list) { 988 986 list_del(&hem->list); 989 - hem_list_free_item(hr_dev, hem, exist_bt); 987 + hem_list_free_item(hr_dev, hem); 990 988 } 991 989 } 992 990 ··· 1086 1084 1087 1085 for (i = 0; i < region_cnt; i++) { 1088 1086 r = (struct hns_roce_buf_region *)&regions[i]; 1087 + /* when r->hopnum = 0, the region should not occupy root_ba. */ 1088 + if (!r->hopnum) 1089 + continue; 1090 + 1089 1091 if (r->hopnum > 1) { 1090 1092 step = hem_list_calc_ba_range(r->hopnum, 1, unit); 1091 1093 if (step > 0) ··· 1183 1177 1184 1178 err_exit: 1185 1179 for (level = 1; level < hopnum; level++) 1186 - hem_list_free_all(hr_dev, &temp_list[level], true); 1180 + hem_list_free_all(hr_dev, &temp_list[level]); 1187 1181 1188 1182 return ret; 1189 1183 } ··· 1224 1218 { 1225 1219 struct hns_roce_hem_item *hem; 1226 1220 1221 + /* This is on the has_mtt branch, if r->hopnum 1222 + * is 0, there is no root_ba to reuse for the 1223 + * region's fake hem, so a dma_alloc request is 1224 + * necessary here. 1225 + */ 1227 1226 hem = hem_list_alloc_item(hr_dev, r->offset, r->offset + r->count - 1, 1228 - r->count, false); 1227 + r->count, !r->hopnum); 1229 1228 if (!hem) 1230 1229 return -ENOMEM; 1231 1230 1232 - hem_list_assign_bt(hem, cpu_base, phy_base); 1231 + /* The root_ba can be reused only when r->hopnum > 0. */ 1232 + if (r->hopnum) 1233 + hem_list_assign_bt(hem, cpu_base, phy_base); 1233 1234 list_add(&hem->list, branch_head); 1234 1235 list_add(&hem->sibling, leaf_head); 1235 1236 1236 - return r->count; 1237 + /* If r->hopnum == 0, 0 is returned, 1238 + * so that the root_bt entry is not occupied. 1239 + */ 1240 + return r->hopnum ? r->count : 0; 1237 1241 } 1238 1242 1239 1243 static int setup_middle_bt(struct hns_roce_dev *hr_dev, void *cpu_base, ··· 1287 1271 return -ENOMEM; 1288 1272 1289 1273 total = 0; 1290 - for (i = 0; i < region_cnt && total < max_ba_num; i++) { 1274 + for (i = 0; i < region_cnt && total <= max_ba_num; i++) { 1291 1275 r = &regions[i]; 1292 1276 if (!r->count) 1293 1277 continue; ··· 1353 1337 region_cnt); 1354 1338 if (ret) { 1355 1339 for (i = 0; i < region_cnt; i++) 1356 - hem_list_free_all(hr_dev, &head.branch[i], false); 1340 + hem_list_free_all(hr_dev, &head.branch[i]); 1357 1341 1358 - hem_list_free_all(hr_dev, &head.root, true); 1342 + hem_list_free_all(hr_dev, &head.root); 1359 1343 } 1360 1344 1361 1345 return ret; ··· 1418 1402 1419 1403 for (i = 0; i < HNS_ROCE_MAX_BT_REGION; i++) 1420 1404 for (j = 0; j < HNS_ROCE_MAX_BT_LEVEL; j++) 1421 - hem_list_free_all(hr_dev, &hem_list->mid_bt[i][j], 1422 - j != 0); 1405 + hem_list_free_all(hr_dev, &hem_list->mid_bt[i][j]); 1423 1406 1424 - hem_list_free_all(hr_dev, &hem_list->root_bt, true); 1407 + hem_list_free_all(hr_dev, &hem_list->root_bt); 1425 1408 INIT_LIST_HEAD(&hem_list->btm_bt); 1426 1409 hem_list->root_ba = 0; 1427 1410 }
+9 -2
drivers/infiniband/hw/hns/hns_roce_hw_v2.c
··· 468 468 valid_num_sge = calc_wr_sge_num(wr, &msg_len); 469 469 470 470 ret = set_ud_opcode(ud_sq_wqe, wr); 471 - if (WARN_ON(ret)) 471 + if (WARN_ON_ONCE(ret)) 472 472 return ret; 473 473 474 474 ud_sq_wqe->msg_len = cpu_to_le32(msg_len); ··· 572 572 rc_sq_wqe->msg_len = cpu_to_le32(msg_len); 573 573 574 574 ret = set_rc_opcode(hr_dev, rc_sq_wqe, wr); 575 - if (WARN_ON(ret)) 575 + if (WARN_ON_ONCE(ret)) 576 576 return ret; 577 577 578 578 hr_reg_write(rc_sq_wqe, RC_SEND_WQE_SO, ··· 670 670 #define HNS_ROCE_SL_SHIFT 2 671 671 struct hns_roce_v2_rc_send_wqe *rc_sq_wqe = wqe; 672 672 673 + if (unlikely(qp->state == IB_QPS_ERR)) { 674 + flush_cqe(hr_dev, qp); 675 + return; 676 + } 673 677 /* All kinds of DirectWQE have the same header field layout */ 674 678 hr_reg_enable(rc_sq_wqe, RC_SEND_WQE_FLAG); 675 679 hr_reg_write(rc_sq_wqe, RC_SEND_WQE_DB_SL_L, qp->sl); ··· 5622 5618 struct hns_roce_qp *hr_qp) 5623 5619 { 5624 5620 struct hns_roce_dip *hr_dip = hr_qp->dip; 5621 + 5622 + if (!hr_dip) 5623 + return; 5625 5624 5626 5625 xa_lock(&hr_dev->qp_table.dip_xa); 5627 5626
-5
drivers/infiniband/hw/hns/hns_roce_mr.c
··· 814 814 for (i = 0, mapped_cnt = 0; i < mtr->hem_cfg.region_count && 815 815 mapped_cnt < page_cnt; i++) { 816 816 r = &mtr->hem_cfg.region[i]; 817 - /* if hopnum is 0, no need to map pages in this region */ 818 - if (!r->hopnum) { 819 - mapped_cnt += r->count; 820 - continue; 821 - } 822 817 823 818 if (r->offset + r->count > page_cnt) { 824 819 ret = -EINVAL;
+5 -3
drivers/infiniband/hw/mlx5/main.c
··· 2839 2839 int err; 2840 2840 2841 2841 *num_plane = 0; 2842 - if (!MLX5_CAP_GEN(mdev, ib_virt)) 2842 + if (!MLX5_CAP_GEN(mdev, ib_virt) || !MLX5_CAP_GEN_2(mdev, multiplane)) 2843 2843 return 0; 2844 2844 2845 2845 err = mlx5_query_hca_vport_context(mdev, 0, 1, 0, &vport_ctx); ··· 3639 3639 list_for_each_entry(mpi, &mlx5_ib_unaffiliated_port_list, 3640 3640 list) { 3641 3641 if (dev->sys_image_guid == mpi->sys_image_guid && 3642 - (mlx5_core_native_port_num(mpi->mdev) - 1) == i) { 3642 + (mlx5_core_native_port_num(mpi->mdev) - 1) == i && 3643 + mlx5_core_same_coredev_type(dev->mdev, mpi->mdev)) { 3643 3644 bound = mlx5_ib_bind_slave_port(dev, mpi); 3644 3645 } 3645 3646 ··· 4786 4785 4787 4786 mutex_lock(&mlx5_ib_multiport_mutex); 4788 4787 list_for_each_entry(dev, &mlx5_ib_dev_list, ib_dev_list) { 4789 - if (dev->sys_image_guid == mpi->sys_image_guid) 4788 + if (dev->sys_image_guid == mpi->sys_image_guid && 4789 + mlx5_core_same_coredev_type(dev->mdev, mpi->mdev)) 4790 4790 bound = mlx5_ib_bind_slave_port(dev, mpi); 4791 4791 4792 4792 if (bound) {
+19 -4
drivers/infiniband/sw/rxe/rxe.c
··· 40 40 /* initialize rxe device parameters */ 41 41 static void rxe_init_device_param(struct rxe_dev *rxe) 42 42 { 43 + struct net_device *ndev; 44 + 43 45 rxe->max_inline_data = RXE_MAX_INLINE_DATA; 44 46 45 47 rxe->attr.vendor_id = RXE_VENDOR_ID; ··· 73 71 rxe->attr.max_fast_reg_page_list_len = RXE_MAX_FMR_PAGE_LIST_LEN; 74 72 rxe->attr.max_pkeys = RXE_MAX_PKEYS; 75 73 rxe->attr.local_ca_ack_delay = RXE_LOCAL_CA_ACK_DELAY; 74 + 75 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 76 + if (!ndev) 77 + return; 78 + 76 79 addrconf_addr_eui48((unsigned char *)&rxe->attr.sys_image_guid, 77 - rxe->ndev->dev_addr); 80 + ndev->dev_addr); 81 + 82 + dev_put(ndev); 78 83 79 84 rxe->max_ucontext = RXE_MAX_UCONTEXT; 80 85 } ··· 118 109 static void rxe_init_ports(struct rxe_dev *rxe) 119 110 { 120 111 struct rxe_port *port = &rxe->port; 112 + struct net_device *ndev; 121 113 122 114 rxe_init_port_param(port); 115 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 116 + if (!ndev) 117 + return; 123 118 addrconf_addr_eui48((unsigned char *)&port->port_guid, 124 - rxe->ndev->dev_addr); 119 + ndev->dev_addr); 120 + dev_put(ndev); 125 121 spin_lock_init(&port->port_lock); 126 122 } 127 123 ··· 181 167 /* called by ifc layer to create new rxe device. 182 168 * The caller should allocate memory for rxe by calling ib_alloc_device. 183 169 */ 184 - int rxe_add(struct rxe_dev *rxe, unsigned int mtu, const char *ibdev_name) 170 + int rxe_add(struct rxe_dev *rxe, unsigned int mtu, const char *ibdev_name, 171 + struct net_device *ndev) 185 172 { 186 173 rxe_init(rxe); 187 174 rxe_set_mtu(rxe, mtu); 188 175 189 - return rxe_register_device(rxe, ibdev_name); 176 + return rxe_register_device(rxe, ibdev_name, ndev); 190 177 } 191 178 192 179 static int rxe_newlink(const char *ibdev_name, struct net_device *ndev)
+2 -1
drivers/infiniband/sw/rxe/rxe.h
··· 139 139 140 140 void rxe_set_mtu(struct rxe_dev *rxe, unsigned int dev_mtu); 141 141 142 - int rxe_add(struct rxe_dev *rxe, unsigned int mtu, const char *ibdev_name); 142 + int rxe_add(struct rxe_dev *rxe, unsigned int mtu, const char *ibdev_name, 143 + struct net_device *ndev); 143 144 144 145 void rxe_rcv(struct sk_buff *skb); 145 146
+20 -2
drivers/infiniband/sw/rxe/rxe_mcast.c
··· 31 31 static int rxe_mcast_add(struct rxe_dev *rxe, union ib_gid *mgid) 32 32 { 33 33 unsigned char ll_addr[ETH_ALEN]; 34 + struct net_device *ndev; 35 + int ret; 36 + 37 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 38 + if (!ndev) 39 + return -ENODEV; 34 40 35 41 ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr); 36 42 37 - return dev_mc_add(rxe->ndev, ll_addr); 43 + ret = dev_mc_add(ndev, ll_addr); 44 + dev_put(ndev); 45 + 46 + return ret; 38 47 } 39 48 40 49 /** ··· 56 47 static int rxe_mcast_del(struct rxe_dev *rxe, union ib_gid *mgid) 57 48 { 58 49 unsigned char ll_addr[ETH_ALEN]; 50 + struct net_device *ndev; 51 + int ret; 52 + 53 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 54 + if (!ndev) 55 + return -ENODEV; 59 56 60 57 ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr); 61 58 62 - return dev_mc_del(rxe->ndev, ll_addr); 59 + ret = dev_mc_del(ndev, ll_addr); 60 + dev_put(ndev); 61 + 62 + return ret; 63 63 } 64 64 65 65 /**
+20 -4
drivers/infiniband/sw/rxe/rxe_net.c
··· 524 524 */ 525 525 const char *rxe_parent_name(struct rxe_dev *rxe, unsigned int port_num) 526 526 { 527 - return rxe->ndev->name; 527 + struct net_device *ndev; 528 + char *ndev_name; 529 + 530 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 531 + if (!ndev) 532 + return NULL; 533 + ndev_name = ndev->name; 534 + dev_put(ndev); 535 + 536 + return ndev_name; 528 537 } 529 538 530 539 int rxe_net_add(const char *ibdev_name, struct net_device *ndev) ··· 545 536 if (!rxe) 546 537 return -ENOMEM; 547 538 548 - rxe->ndev = ndev; 549 539 ib_mark_name_assigned_by_user(&rxe->ib_dev); 550 540 551 - err = rxe_add(rxe, ndev->mtu, ibdev_name); 541 + err = rxe_add(rxe, ndev->mtu, ibdev_name, ndev); 552 542 if (err) { 553 543 ib_dealloc_device(&rxe->ib_dev); 554 544 return err; ··· 595 587 596 588 void rxe_set_port_state(struct rxe_dev *rxe) 597 589 { 598 - if (netif_running(rxe->ndev) && netif_carrier_ok(rxe->ndev)) 590 + struct net_device *ndev; 591 + 592 + ndev = rxe_ib_device_get_netdev(&rxe->ib_dev); 593 + if (!ndev) 594 + return; 595 + 596 + if (netif_running(ndev) && netif_carrier_ok(ndev)) 599 597 rxe_port_up(rxe); 600 598 else 601 599 rxe_port_down(rxe); 600 + 601 + dev_put(ndev); 602 602 } 603 603 604 604 static int rxe_notify(struct notifier_block *not_blk,
+21 -5
drivers/infiniband/sw/rxe/rxe_verbs.c
··· 41 41 u32 port_num, struct ib_port_attr *attr) 42 42 { 43 43 struct rxe_dev *rxe = to_rdev(ibdev); 44 + struct net_device *ndev; 44 45 int err, ret; 45 46 46 47 if (port_num != 1) { 47 48 err = -EINVAL; 48 49 rxe_dbg_dev(rxe, "bad port_num = %d\n", port_num); 50 + goto err_out; 51 + } 52 + 53 + ndev = rxe_ib_device_get_netdev(ibdev); 54 + if (!ndev) { 55 + err = -ENODEV; 49 56 goto err_out; 50 57 } 51 58 ··· 64 57 65 58 if (attr->state == IB_PORT_ACTIVE) 66 59 attr->phys_state = IB_PORT_PHYS_STATE_LINK_UP; 67 - else if (dev_get_flags(rxe->ndev) & IFF_UP) 60 + else if (dev_get_flags(ndev) & IFF_UP) 68 61 attr->phys_state = IB_PORT_PHYS_STATE_POLLING; 69 62 else 70 63 attr->phys_state = IB_PORT_PHYS_STATE_DISABLED; 71 64 72 65 mutex_unlock(&rxe->usdev_lock); 73 66 67 + dev_put(ndev); 74 68 return ret; 75 69 76 70 err_out: ··· 1433 1425 static int rxe_enable_driver(struct ib_device *ib_dev) 1434 1426 { 1435 1427 struct rxe_dev *rxe = container_of(ib_dev, struct rxe_dev, ib_dev); 1428 + struct net_device *ndev; 1429 + 1430 + ndev = rxe_ib_device_get_netdev(ib_dev); 1431 + if (!ndev) 1432 + return -ENODEV; 1436 1433 1437 1434 rxe_set_port_state(rxe); 1438 - dev_info(&rxe->ib_dev.dev, "added %s\n", netdev_name(rxe->ndev)); 1435 + dev_info(&rxe->ib_dev.dev, "added %s\n", netdev_name(ndev)); 1436 + 1437 + dev_put(ndev); 1439 1438 return 0; 1440 1439 } 1441 1440 ··· 1510 1495 INIT_RDMA_OBJ_SIZE(ib_mw, rxe_mw, ibmw), 1511 1496 }; 1512 1497 1513 - int rxe_register_device(struct rxe_dev *rxe, const char *ibdev_name) 1498 + int rxe_register_device(struct rxe_dev *rxe, const char *ibdev_name, 1499 + struct net_device *ndev) 1514 1500 { 1515 1501 int err; 1516 1502 struct ib_device *dev = &rxe->ib_dev; ··· 1523 1507 dev->num_comp_vectors = num_possible_cpus(); 1524 1508 dev->local_dma_lkey = 0; 1525 1509 addrconf_addr_eui48((unsigned char *)&dev->node_guid, 1526 - rxe->ndev->dev_addr); 1510 + ndev->dev_addr); 1527 1511 1528 1512 dev->uverbs_cmd_mask |= BIT_ULL(IB_USER_VERBS_CMD_POST_SEND) | 1529 1513 BIT_ULL(IB_USER_VERBS_CMD_REQ_NOTIFY_CQ); 1530 1514 1531 1515 ib_set_device_ops(dev, &rxe_dev_ops); 1532 - err = ib_device_set_netdev(&rxe->ib_dev, rxe->ndev, 1); 1516 + err = ib_device_set_netdev(&rxe->ib_dev, ndev, 1); 1533 1517 if (err) 1534 1518 return err; 1535 1519
+8 -3
drivers/infiniband/sw/rxe/rxe_verbs.h
··· 370 370 u32 qp_gsi_index; 371 371 }; 372 372 373 + #define RXE_PORT 1 373 374 struct rxe_dev { 374 375 struct ib_device ib_dev; 375 376 struct ib_device_attr attr; 376 377 int max_ucontext; 377 378 int max_inline_data; 378 379 struct mutex usdev_lock; 379 - 380 - struct net_device *ndev; 381 380 382 381 struct rxe_pool uc_pool; 383 382 struct rxe_pool pd_pool; ··· 404 405 struct rxe_port port; 405 406 struct crypto_shash *tfm; 406 407 }; 408 + 409 + static inline struct net_device *rxe_ib_device_get_netdev(struct ib_device *dev) 410 + { 411 + return ib_device_get_netdev(dev, RXE_PORT); 412 + } 407 413 408 414 static inline void rxe_counter_inc(struct rxe_dev *rxe, enum rxe_counters index) 409 415 { ··· 475 471 return to_rpd(mw->ibmw.pd); 476 472 } 477 473 478 - int rxe_register_device(struct rxe_dev *rxe, const char *ibdev_name); 474 + int rxe_register_device(struct rxe_dev *rxe, const char *ibdev_name, 475 + struct net_device *ndev); 479 476 480 477 #endif /* RXE_VERBS_H */
+3 -4
drivers/infiniband/sw/siw/siw.h
··· 46 46 */ 47 47 #define SIW_IRQ_MAXBURST_SQ_ACTIVE 4 48 48 49 + /* There is always only a port 1 per siw device */ 50 + #define SIW_PORT 1 51 + 49 52 struct siw_dev_cap { 50 53 int max_qp; 51 54 int max_qp_wr; ··· 72 69 73 70 struct siw_device { 74 71 struct ib_device base_dev; 75 - struct net_device *netdev; 76 72 struct siw_dev_cap attrs; 77 73 78 74 u32 vendor_part_id; 79 75 int numa_node; 80 76 char raw_gid[ETH_ALEN]; 81 - 82 - /* physical port state (only one port per device) */ 83 - enum ib_port_state state; 84 77 85 78 spinlock_t lock; 86 79
+21 -6
drivers/infiniband/sw/siw/siw_cm.c
··· 1759 1759 { 1760 1760 struct socket *s; 1761 1761 struct siw_cep *cep = NULL; 1762 + struct net_device *ndev = NULL; 1762 1763 struct siw_device *sdev = to_siw_dev(id->device); 1763 1764 int addr_family = id->local_addr.ss_family; 1764 1765 int rv = 0; ··· 1780 1779 struct sockaddr_in *laddr = &to_sockaddr_in(id->local_addr); 1781 1780 1782 1781 /* For wildcard addr, limit binding to current device only */ 1783 - if (ipv4_is_zeronet(laddr->sin_addr.s_addr)) 1784 - s->sk->sk_bound_dev_if = sdev->netdev->ifindex; 1785 - 1782 + if (ipv4_is_zeronet(laddr->sin_addr.s_addr)) { 1783 + ndev = ib_device_get_netdev(id->device, SIW_PORT); 1784 + if (ndev) { 1785 + s->sk->sk_bound_dev_if = ndev->ifindex; 1786 + } else { 1787 + rv = -ENODEV; 1788 + goto error; 1789 + } 1790 + } 1786 1791 rv = s->ops->bind(s, (struct sockaddr *)laddr, 1787 1792 sizeof(struct sockaddr_in)); 1788 1793 } else { ··· 1804 1797 } 1805 1798 1806 1799 /* For wildcard addr, limit binding to current device only */ 1807 - if (ipv6_addr_any(&laddr->sin6_addr)) 1808 - s->sk->sk_bound_dev_if = sdev->netdev->ifindex; 1809 - 1800 + if (ipv6_addr_any(&laddr->sin6_addr)) { 1801 + ndev = ib_device_get_netdev(id->device, SIW_PORT); 1802 + if (ndev) { 1803 + s->sk->sk_bound_dev_if = ndev->ifindex; 1804 + } else { 1805 + rv = -ENODEV; 1806 + goto error; 1807 + } 1808 + } 1810 1809 rv = s->ops->bind(s, (struct sockaddr *)laddr, 1811 1810 sizeof(struct sockaddr_in6)); 1812 1811 } ··· 1873 1860 } 1874 1861 list_add_tail(&cep->listenq, (struct list_head *)id->provider_data); 1875 1862 cep->state = SIW_EPSTATE_LISTENING; 1863 + dev_put(ndev); 1876 1864 1877 1865 siw_dbg(id->device, "Listen at laddr %pISp\n", &id->local_addr); 1878 1866 ··· 1893 1879 siw_cep_set_free_and_put(cep); 1894 1880 } 1895 1881 sock_release(s); 1882 + dev_put(ndev); 1896 1883 1897 1884 return rv; 1898 1885 }
+1 -14
drivers/infiniband/sw/siw/siw_main.c
··· 287 287 return NULL; 288 288 289 289 base_dev = &sdev->base_dev; 290 - sdev->netdev = netdev; 291 290 292 291 if (netdev->addr_len) { 293 292 memcpy(sdev->raw_gid, netdev->dev_addr, ··· 380 381 381 382 switch (event) { 382 383 case NETDEV_UP: 383 - sdev->state = IB_PORT_ACTIVE; 384 384 siw_port_event(sdev, 1, IB_EVENT_PORT_ACTIVE); 385 385 break; 386 386 387 387 case NETDEV_DOWN: 388 - sdev->state = IB_PORT_DOWN; 389 388 siw_port_event(sdev, 1, IB_EVENT_PORT_ERR); 390 389 break; 391 390 ··· 404 407 siw_port_event(sdev, 1, IB_EVENT_LID_CHANGE); 405 408 break; 406 409 /* 407 - * Todo: Below netdev events are currently not handled. 410 + * All other events are not handled 408 411 */ 409 - case NETDEV_CHANGEMTU: 410 - case NETDEV_CHANGE: 411 - break; 412 - 413 412 default: 414 413 break; 415 414 } ··· 435 442 sdev = siw_device_create(netdev); 436 443 if (sdev) { 437 444 dev_dbg(&netdev->dev, "siw: new device\n"); 438 - 439 - if (netif_running(netdev) && netif_carrier_ok(netdev)) 440 - sdev->state = IB_PORT_ACTIVE; 441 - else 442 - sdev->state = IB_PORT_DOWN; 443 - 444 445 ib_mark_name_assigned_by_user(&sdev->base_dev); 445 446 rv = siw_device_register(sdev, basedev_name); 446 447 if (rv)
+24 -11
drivers/infiniband/sw/siw/siw_verbs.c
··· 171 171 int siw_query_port(struct ib_device *base_dev, u32 port, 172 172 struct ib_port_attr *attr) 173 173 { 174 - struct siw_device *sdev = to_siw_dev(base_dev); 174 + struct net_device *ndev; 175 175 int rv; 176 176 177 177 memset(attr, 0, sizeof(*attr)); 178 178 179 179 rv = ib_get_eth_speed(base_dev, port, &attr->active_speed, 180 180 &attr->active_width); 181 + if (rv) 182 + return rv; 183 + 184 + ndev = ib_device_get_netdev(base_dev, SIW_PORT); 185 + if (!ndev) 186 + return -ENODEV; 187 + 181 188 attr->gid_tbl_len = 1; 182 189 attr->max_msg_sz = -1; 183 - attr->max_mtu = ib_mtu_int_to_enum(sdev->netdev->mtu); 184 - attr->active_mtu = ib_mtu_int_to_enum(sdev->netdev->mtu); 185 - attr->phys_state = sdev->state == IB_PORT_ACTIVE ? 190 + attr->max_mtu = ib_mtu_int_to_enum(ndev->max_mtu); 191 + attr->active_mtu = ib_mtu_int_to_enum(READ_ONCE(ndev->mtu)); 192 + attr->phys_state = (netif_running(ndev) && netif_carrier_ok(ndev)) ? 186 193 IB_PORT_PHYS_STATE_LINK_UP : IB_PORT_PHYS_STATE_DISABLED; 194 + attr->state = attr->phys_state == IB_PORT_PHYS_STATE_LINK_UP ? 195 + IB_PORT_ACTIVE : IB_PORT_DOWN; 187 196 attr->port_cap_flags = IB_PORT_CM_SUP | IB_PORT_DEVICE_MGMT_SUP; 188 - attr->state = sdev->state; 189 197 /* 190 198 * All zero 191 199 * ··· 207 199 * attr->subnet_timeout = 0; 208 200 * attr->init_type_repy = 0; 209 201 */ 202 + dev_put(ndev); 210 203 return rv; 211 204 } 212 205 ··· 514 505 int qp_attr_mask, struct ib_qp_init_attr *qp_init_attr) 515 506 { 516 507 struct siw_qp *qp; 517 - struct siw_device *sdev; 508 + struct net_device *ndev; 518 509 519 - if (base_qp && qp_attr && qp_init_attr) { 510 + if (base_qp && qp_attr && qp_init_attr) 520 511 qp = to_siw_qp(base_qp); 521 - sdev = to_siw_dev(base_qp->device); 522 - } else { 512 + else 523 513 return -EINVAL; 524 - } 514 + 515 + ndev = ib_device_get_netdev(base_qp->device, SIW_PORT); 516 + if (!ndev) 517 + return -ENODEV; 518 + 525 519 qp_attr->qp_state = siw_qp_state_to_ib_qp_state[qp->attrs.state]; 526 520 qp_attr->cap.max_inline_data = SIW_MAX_INLINE; 527 521 qp_attr->cap.max_send_wr = qp->attrs.sq_size; 528 522 qp_attr->cap.max_send_sge = qp->attrs.sq_max_sges; 529 523 qp_attr->cap.max_recv_wr = qp->attrs.rq_size; 530 524 qp_attr->cap.max_recv_sge = qp->attrs.rq_max_sges; 531 - qp_attr->path_mtu = ib_mtu_int_to_enum(sdev->netdev->mtu); 525 + qp_attr->path_mtu = ib_mtu_int_to_enum(READ_ONCE(ndev->mtu)); 532 526 qp_attr->max_rd_atomic = qp->attrs.irq_size; 533 527 qp_attr->max_dest_rd_atomic = qp->attrs.orq_size; 534 528 ··· 546 534 547 535 qp_init_attr->cap = qp_attr->cap; 548 536 537 + dev_put(ndev); 549 538 return 0; 550 539 } 551 540
+1 -1
drivers/infiniband/ulp/rtrs/rtrs-srv.c
··· 349 349 struct rtrs_srv_mr *srv_mr; 350 350 bool need_inval = false; 351 351 enum ib_send_flags flags; 352 + struct ib_sge list; 352 353 u32 imm; 353 354 int err; 354 355 ··· 402 401 imm = rtrs_to_io_rsp_imm(id->msg_id, errno, need_inval); 403 402 imm_wr.wr.next = NULL; 404 403 if (always_invalidate) { 405 - struct ib_sge list; 406 404 struct rtrs_msg_rkey_rsp *msg; 407 405 408 406 srv_mr = &srv_path->mrs[id->msg_id];
+6
include/linux/mlx5/driver.h
··· 1202 1202 return dev->coredev_type == MLX5_COREDEV_VF; 1203 1203 } 1204 1204 1205 + static inline bool mlx5_core_same_coredev_type(const struct mlx5_core_dev *dev1, 1206 + const struct mlx5_core_dev *dev2) 1207 + { 1208 + return dev1->coredev_type == dev2->coredev_type; 1209 + } 1210 + 1205 1211 static inline bool mlx5_core_is_ecpf(const struct mlx5_core_dev *dev) 1206 1212 { 1207 1213 return dev->caps.embedded_cpu;
+3 -1
include/linux/mlx5/mlx5_ifc.h
··· 2119 2119 u8 migration_in_chunks[0x1]; 2120 2120 u8 reserved_at_d1[0x1]; 2121 2121 u8 sf_eq_usage[0x1]; 2122 - u8 reserved_at_d3[0xd]; 2122 + u8 reserved_at_d3[0x5]; 2123 + u8 multiplane[0x1]; 2124 + u8 reserved_at_d9[0x7]; 2123 2125 2124 2126 u8 cross_vhca_object_to_object_supported[0x20]; 2125 2127