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/dledford/rdma

Pull rdma fixes from Doug Ledford:
"Round one of 4.8 rc fixes.

This should be the bulk of the -rc fixes for 4.8. I only have a few
things that are still outstanding (two ipoib bugs for which the
solution is not yet fully known, and a few queued items that came in
after my last push and I didn't want to delay this pull request for
late comers again).

Even though the patch count is kind of high, everything is minor fixes
so the overall churn is pretty low.

Summary:

- minor fixes to cxgb4
- minor fixes to mlx4
- one minor fix each to core, rxe, isert, srpt, mlx5, ocrdma, and usnic
- six or so fixes to i40iw fixes
- the rest are hfi1 fixes"

* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma: (34 commits)
i40iw: Send last streaming mode message for loopback connections
IB/srpt: Update sport->port_guid with each port refresh
RDMA/ocrdma: Fix the max_sge reported from FW
i40iw: Avoid writing to freed memory
i40iw: Fix double free of allocated_buffer
IB/mlx5: Remove superfluous include of io-mapping.h
i40iw: Do not set self-referencing pointer to NULL after kfree
i40iw: Add missing NULL check for MPA private data
iw_cxgb4: Fix cxgb4 arm CQ logic w/IB_CQ_REPORT_MISSED_EVENTS
i40iw: Add missing check for interface already open
i40iw: Protect req_resource_num update
i40iw: Change mem_resources pointer to a u8
IB/core: Use memdup_user() rather than duplicating its implementation
IB/qib: Use memdup_user() rather than duplicating its implementation
iw_cxgb4: use the MPA initiator's IRD if < our ORD
iw_cxgb4: limit IRD/ORD advertised to ULP by device max.
IB/hfi1: Fix mm_struct use after free
IB/rdmvat: Fix double vfree() in rvt_create_qp() error path
IB/hfi1: Improve J_KEY generation
IB/hfi1: Return invalid field for non-QSFP CableInfo queries
...

Linus Torvalds a3d34698 03cef710

+186 -146
+1 -1
MAINTAINERS
··· 7661 7661 S: Supported 7662 7662 W: https://github.com/SoftRoCE/rxe-dev/wiki/rxe-dev:-Home 7663 7663 Q: http://patchwork.kernel.org/project/linux-rdma/list/ 7664 - F: drivers/infiniband/hw/rxe/ 7664 + F: drivers/infiniband/sw/rxe/ 7665 7665 F: include/uapi/rdma/rdma_user_rxe.h 7666 7666 7667 7667 MEMBARRIER SUPPORT
+12 -6
drivers/infiniband/core/cma.c
··· 2462 2462 2463 2463 if (addr->dev_addr.bound_dev_if) { 2464 2464 ndev = dev_get_by_index(&init_net, addr->dev_addr.bound_dev_if); 2465 - if (!ndev) 2466 - return -ENODEV; 2465 + if (!ndev) { 2466 + ret = -ENODEV; 2467 + goto err2; 2468 + } 2467 2469 2468 2470 if (ndev->flags & IFF_LOOPBACK) { 2469 2471 dev_put(ndev); 2470 - if (!id_priv->id.device->get_netdev) 2471 - return -EOPNOTSUPP; 2472 + if (!id_priv->id.device->get_netdev) { 2473 + ret = -EOPNOTSUPP; 2474 + goto err2; 2475 + } 2472 2476 2473 2477 ndev = id_priv->id.device->get_netdev(id_priv->id.device, 2474 2478 id_priv->id.port_num); 2475 - if (!ndev) 2476 - return -ENODEV; 2479 + if (!ndev) { 2480 + ret = -ENODEV; 2481 + goto err2; 2482 + } 2477 2483 } 2478 2484 2479 2485 route->path_rec->net = &init_net;
+5 -1
drivers/infiniband/hw/cxgb4/cm.c
··· 1827 1827 (ep->mpa_pkt + sizeof(*mpa)); 1828 1828 ep->ird = ntohs(mpa_v2_params->ird) & 1829 1829 MPA_V2_IRD_ORD_MASK; 1830 + ep->ird = min_t(u32, ep->ird, 1831 + cur_max_read_depth(ep->com.dev)); 1830 1832 ep->ord = ntohs(mpa_v2_params->ord) & 1831 1833 MPA_V2_IRD_ORD_MASK; 1834 + ep->ord = min_t(u32, ep->ord, 1835 + cur_max_read_depth(ep->com.dev)); 1832 1836 PDBG("%s initiator ird %u ord %u\n", __func__, ep->ird, 1833 1837 ep->ord); 1834 1838 if (ntohs(mpa_v2_params->ird) & MPA_V2_PEER2PEER_MODEL) ··· 3140 3136 if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) { 3141 3137 if (conn_param->ord > ep->ird) { 3142 3138 if (RELAXED_IRD_NEGOTIATION) { 3143 - ep->ord = ep->ird; 3139 + conn_param->ord = ep->ird; 3144 3140 } else { 3145 3141 ep->ird = conn_param->ird; 3146 3142 ep->ord = conn_param->ord;
+5 -5
drivers/infiniband/hw/cxgb4/cq.c
··· 1016 1016 int c4iw_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags) 1017 1017 { 1018 1018 struct c4iw_cq *chp; 1019 - int ret; 1019 + int ret = 0; 1020 1020 unsigned long flag; 1021 1021 1022 1022 chp = to_c4iw_cq(ibcq); 1023 1023 spin_lock_irqsave(&chp->lock, flag); 1024 - ret = t4_arm_cq(&chp->cq, 1025 - (flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED); 1024 + t4_arm_cq(&chp->cq, 1025 + (flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED); 1026 + if (flags & IB_CQ_REPORT_MISSED_EVENTS) 1027 + ret = t4_cq_notempty(&chp->cq); 1026 1028 spin_unlock_irqrestore(&chp->lock, flag); 1027 - if (ret && !(flags & IB_CQ_REPORT_MISSED_EVENTS)) 1028 - ret = 0; 1029 1029 return ret; 1030 1030 }
+5
drivers/infiniband/hw/cxgb4/t4.h
··· 634 634 return (CQE_GENBIT(cqe) == cq->gen); 635 635 } 636 636 637 + static inline int t4_cq_notempty(struct t4_cq *cq) 638 + { 639 + return cq->sw_in_use || t4_valid_cqe(cq, &cq->queue[cq->cidx]); 640 + } 641 + 637 642 static inline int t4_next_hw_cqe(struct t4_cq *cq, struct t4_cqe **cqe) 638 643 { 639 644 int ret;
+14 -9
drivers/infiniband/hw/hfi1/affinity.c
··· 47 47 #include <linux/topology.h> 48 48 #include <linux/cpumask.h> 49 49 #include <linux/module.h> 50 - #include <linux/cpumask.h> 51 50 52 51 #include "hfi.h" 53 52 #include "affinity.h" ··· 681 682 size_t count) 682 683 { 683 684 struct hfi1_affinity_node *entry; 684 - struct cpumask mask; 685 + cpumask_var_t mask; 685 686 int ret, i; 686 687 687 688 spin_lock(&node_affinity.lock); ··· 691 692 if (!entry) 692 693 return -EINVAL; 693 694 694 - ret = cpulist_parse(buf, &mask); 695 - if (ret) 696 - return ret; 695 + ret = zalloc_cpumask_var(&mask, GFP_KERNEL); 696 + if (!ret) 697 + return -ENOMEM; 697 698 698 - if (!cpumask_subset(&mask, cpu_online_mask) || cpumask_empty(&mask)) { 699 + ret = cpulist_parse(buf, mask); 700 + if (ret) 701 + goto out; 702 + 703 + if (!cpumask_subset(mask, cpu_online_mask) || cpumask_empty(mask)) { 699 704 dd_dev_warn(dd, "Invalid CPU mask\n"); 700 - return -EINVAL; 705 + ret = -EINVAL; 706 + goto out; 701 707 } 702 708 703 709 mutex_lock(&sdma_affinity_mutex); 704 710 /* reset the SDMA interrupt affinity details */ 705 711 init_cpu_mask_set(&entry->def_intr); 706 - cpumask_copy(&entry->def_intr.mask, &mask); 712 + cpumask_copy(&entry->def_intr.mask, mask); 707 713 /* 708 714 * Reassign the affinity for each SDMA interrupt. 709 715 */ ··· 724 720 if (ret) 725 721 break; 726 722 } 727 - 728 723 mutex_unlock(&sdma_affinity_mutex); 724 + out: 725 + free_cpumask_var(mask); 729 726 return ret ? ret : strnlen(buf, PAGE_SIZE); 730 727 } 731 728
+9 -5
drivers/infiniband/hw/hfi1/debugfs.c
··· 223 223 DEBUGFS_FILE_OPS(ctx_stats); 224 224 225 225 static void *_qp_stats_seq_start(struct seq_file *s, loff_t *pos) 226 - __acquires(RCU) 226 + __acquires(RCU) 227 227 { 228 228 struct qp_iter *iter; 229 229 loff_t n = *pos; 230 230 231 - rcu_read_lock(); 232 231 iter = qp_iter_init(s->private); 232 + 233 + /* stop calls rcu_read_unlock */ 234 + rcu_read_lock(); 235 + 233 236 if (!iter) 234 237 return NULL; 235 238 236 - while (n--) { 239 + do { 237 240 if (qp_iter_next(iter)) { 238 241 kfree(iter); 239 242 return NULL; 240 243 } 241 - } 244 + } while (n--); 242 245 243 246 return iter; 244 247 } 245 248 246 249 static void *_qp_stats_seq_next(struct seq_file *s, void *iter_ptr, 247 250 loff_t *pos) 251 + __must_hold(RCU) 248 252 { 249 253 struct qp_iter *iter = iter_ptr; 250 254 ··· 263 259 } 264 260 265 261 static void _qp_stats_seq_stop(struct seq_file *s, void *iter_ptr) 266 - __releases(RCU) 262 + __releases(RCU) 267 263 { 268 264 rcu_read_unlock(); 269 265 }
+6 -5
drivers/infiniband/hw/hfi1/driver.c
··· 888 888 } 889 889 890 890 static inline int set_armed_to_active(struct hfi1_ctxtdata *rcd, 891 - struct hfi1_packet packet, 891 + struct hfi1_packet *packet, 892 892 struct hfi1_devdata *dd) 893 893 { 894 894 struct work_struct *lsaw = &rcd->ppd->linkstate_active_work; 895 - struct hfi1_message_header *hdr = hfi1_get_msgheader(packet.rcd->dd, 896 - packet.rhf_addr); 895 + struct hfi1_message_header *hdr = hfi1_get_msgheader(packet->rcd->dd, 896 + packet->rhf_addr); 897 + u8 etype = rhf_rcv_type(packet->rhf); 897 898 898 - if (hdr2sc(hdr, packet.rhf) != 0xf) { 899 + if (etype == RHF_RCV_TYPE_IB && hdr2sc(hdr, packet->rhf) != 0xf) { 899 900 int hwstate = read_logical_state(dd); 900 901 901 902 if (hwstate != LSTATE_ACTIVE) { ··· 980 979 /* Auto activate link on non-SC15 packet receive */ 981 980 if (unlikely(rcd->ppd->host_link_state == 982 981 HLS_UP_ARMED) && 983 - set_armed_to_active(rcd, packet, dd)) 982 + set_armed_to_active(rcd, &packet, dd)) 984 983 goto bail; 985 984 last = process_rcv_packet(&packet, thread); 986 985 }
+3 -1
drivers/infiniband/hw/hfi1/file_ops.c
··· 183 183 if (fd) { 184 184 fd->rec_cpu_num = -1; /* no cpu affinity by default */ 185 185 fd->mm = current->mm; 186 + atomic_inc(&fd->mm->mm_count); 186 187 } 187 188 188 189 fp->private_data = fd; ··· 223 222 ret = assign_ctxt(fp, &uinfo); 224 223 if (ret < 0) 225 224 return ret; 226 - setup_ctxt(fp); 225 + ret = setup_ctxt(fp); 227 226 if (ret) 228 227 return ret; 229 228 ret = user_init(fp); ··· 780 779 mutex_unlock(&hfi1_mutex); 781 780 hfi1_free_ctxtdata(dd, uctxt); 782 781 done: 782 + mmdrop(fdata->mm); 783 783 kobject_put(&dd->kobj); 784 784 kfree(fdata); 785 785 return 0;
+18 -2
drivers/infiniband/hw/hfi1/hfi.h
··· 1272 1272 ((!!(rhf_dc_info(rhf))) << 4); 1273 1273 } 1274 1274 1275 + #define HFI1_JKEY_WIDTH 16 1276 + #define HFI1_JKEY_MASK (BIT(16) - 1) 1277 + #define HFI1_ADMIN_JKEY_RANGE 32 1278 + 1279 + /* 1280 + * J_KEYs are split and allocated in the following groups: 1281 + * 0 - 31 - users with administrator privileges 1282 + * 32 - 63 - kernel protocols using KDETH packets 1283 + * 64 - 65535 - all other users using KDETH packets 1284 + */ 1275 1285 static inline u16 generate_jkey(kuid_t uid) 1276 1286 { 1277 - return from_kuid(current_user_ns(), uid) & 0xffff; 1287 + u16 jkey = from_kuid(current_user_ns(), uid) & HFI1_JKEY_MASK; 1288 + 1289 + if (capable(CAP_SYS_ADMIN)) 1290 + jkey &= HFI1_ADMIN_JKEY_RANGE - 1; 1291 + else if (jkey < 64) 1292 + jkey |= BIT(HFI1_JKEY_WIDTH - 1); 1293 + 1294 + return jkey; 1278 1295 } 1279 1296 1280 1297 /* ··· 1673 1656 struct hfi1_devdata *hfi1_init_dd(struct pci_dev *, 1674 1657 const struct pci_device_id *); 1675 1658 void hfi1_free_devdata(struct hfi1_devdata *); 1676 - void cc_state_reclaim(struct rcu_head *rcu); 1677 1659 struct hfi1_devdata *hfi1_alloc_devdata(struct pci_dev *pdev, size_t extra); 1678 1660 1679 1661 /* LED beaconing functions */
+1 -1
drivers/infiniband/hw/hfi1/init.c
··· 1333 1333 spin_unlock(&ppd->cc_state_lock); 1334 1334 1335 1335 if (cc_state) 1336 - call_rcu(&cc_state->rcu, cc_state_reclaim); 1336 + kfree_rcu(cc_state, rcu); 1337 1337 } 1338 1338 1339 1339 free_credit_return(dd);
+6 -8
drivers/infiniband/hw/hfi1/mad.c
··· 1819 1819 u32 len = OPA_AM_CI_LEN(am) + 1; 1820 1820 int ret; 1821 1821 1822 + if (dd->pport->port_type != PORT_TYPE_QSFP) { 1823 + smp->status |= IB_SMP_INVALID_FIELD; 1824 + return reply((struct ib_mad_hdr *)smp); 1825 + } 1826 + 1822 1827 #define __CI_PAGE_SIZE BIT(7) /* 128 bytes */ 1823 1828 #define __CI_PAGE_MASK ~(__CI_PAGE_SIZE - 1) 1824 1829 #define __CI_PAGE_NUM(a) ((a) & __CI_PAGE_MASK) ··· 3403 3398 3404 3399 spin_unlock(&ppd->cc_state_lock); 3405 3400 3406 - call_rcu(&old_cc_state->rcu, cc_state_reclaim); 3401 + kfree_rcu(old_cc_state, rcu); 3407 3402 } 3408 3403 3409 3404 static int __subn_set_opa_cong_setting(struct opa_smp *smp, u32 am, u8 *data, ··· 3556 3551 *resp_len += sizeof(u16) * (IB_CCT_ENTRIES * n_blocks + 1); 3557 3552 3558 3553 return reply((struct ib_mad_hdr *)smp); 3559 - } 3560 - 3561 - void cc_state_reclaim(struct rcu_head *rcu) 3562 - { 3563 - struct cc_state *cc_state = container_of(rcu, struct cc_state, rcu); 3564 - 3565 - kfree(cc_state); 3566 3554 } 3567 3555 3568 3556 static int __subn_set_opa_cc_table(struct opa_smp *smp, u32 am, u8 *data,
-4
drivers/infiniband/hw/hfi1/qp.c
··· 656 656 657 657 iter->dev = dev; 658 658 iter->specials = dev->rdi.ibdev.phys_port_cnt * 2; 659 - if (qp_iter_next(iter)) { 660 - kfree(iter); 661 - return NULL; 662 - } 663 659 664 660 return iter; 665 661 }
+30 -2
drivers/infiniband/hw/hfi1/qsfp.c
··· 706 706 u8 *data) 707 707 { 708 708 struct hfi1_pportdata *ppd; 709 - u32 excess_len = 0; 710 - int ret = 0; 709 + u32 excess_len = len; 710 + int ret = 0, offset = 0; 711 711 712 712 if (port_num > dd->num_pports || port_num < 1) { 713 713 dd_dev_info(dd, "%s: Invalid port number %d\n", ··· 740 740 } 741 741 742 742 memcpy(data, &ppd->qsfp_info.cache[addr], len); 743 + 744 + if (addr <= QSFP_MONITOR_VAL_END && 745 + (addr + len) >= QSFP_MONITOR_VAL_START) { 746 + /* Overlap with the dynamic channel monitor range */ 747 + if (addr < QSFP_MONITOR_VAL_START) { 748 + if (addr + len <= QSFP_MONITOR_VAL_END) 749 + len = addr + len - QSFP_MONITOR_VAL_START; 750 + else 751 + len = QSFP_MONITOR_RANGE; 752 + offset = QSFP_MONITOR_VAL_START - addr; 753 + addr = QSFP_MONITOR_VAL_START; 754 + } else if (addr == QSFP_MONITOR_VAL_START) { 755 + offset = 0; 756 + if (addr + len > QSFP_MONITOR_VAL_END) 757 + len = QSFP_MONITOR_RANGE; 758 + } else { 759 + offset = 0; 760 + if (addr + len > QSFP_MONITOR_VAL_END) 761 + len = QSFP_MONITOR_VAL_END - addr + 1; 762 + } 763 + /* Refresh the values of the dynamic monitors from the cable */ 764 + ret = one_qsfp_read(ppd, dd->hfi1_id, addr, data + offset, len); 765 + if (ret != len) { 766 + ret = -EAGAIN; 767 + goto set_zeroes; 768 + } 769 + } 770 + 743 771 return 0; 744 772 745 773 set_zeroes:
+3
drivers/infiniband/hw/hfi1/qsfp.h
··· 74 74 /* Defined fields that Intel requires of qualified cables */ 75 75 /* Byte 0 is Identifier, not checked */ 76 76 /* Byte 1 is reserved "status MSB" */ 77 + #define QSFP_MONITOR_VAL_START 22 78 + #define QSFP_MONITOR_VAL_END 81 79 + #define QSFP_MONITOR_RANGE (QSFP_MONITOR_VAL_END - QSFP_MONITOR_VAL_START + 1) 77 80 #define QSFP_TX_CTRL_BYTE_OFFS 86 78 81 #define QSFP_PWR_CTRL_BYTE_OFFS 93 79 82 #define QSFP_CDR_CTRL_BYTE_OFFS 98
+2 -2
drivers/infiniband/hw/i40iw/i40iw.h
··· 232 232 struct i40e_client *client; 233 233 struct i40iw_hw hw; 234 234 struct i40iw_cm_core cm_core; 235 - unsigned long *mem_resources; 235 + u8 *mem_resources; 236 236 unsigned long *allocated_qps; 237 237 unsigned long *allocated_cqs; 238 238 unsigned long *allocated_mrs; ··· 435 435 *next = resource_num + 1; 436 436 if (*next == max_resources) 437 437 *next = 0; 438 - spin_unlock_irqrestore(&iwdev->resource_lock, flags); 439 438 *req_resource_num = resource_num; 439 + spin_unlock_irqrestore(&iwdev->resource_lock, flags); 440 440 441 441 return 0; 442 442 }
+3 -23
drivers/infiniband/hw/i40iw/i40iw_cm.c
··· 535 535 buf += hdr_len; 536 536 } 537 537 538 - if (pd_len) 539 - memcpy(buf, pdata->addr, pd_len); 538 + if (pdata && pdata->addr) 539 + memcpy(buf, pdata->addr, pdata->size); 540 540 541 541 atomic_set(&sqbuf->refcount, 1); 542 542 ··· 3347 3347 } 3348 3348 3349 3349 /** 3350 - * i40iw_loopback_nop - Send a nop 3351 - * @qp: associated hw qp 3352 - */ 3353 - static void i40iw_loopback_nop(struct i40iw_sc_qp *qp) 3354 - { 3355 - u64 *wqe; 3356 - u64 header; 3357 - 3358 - wqe = qp->qp_uk.sq_base->elem; 3359 - set_64bit_val(wqe, 0, 0); 3360 - set_64bit_val(wqe, 8, 0); 3361 - set_64bit_val(wqe, 16, 0); 3362 - 3363 - header = LS_64(I40IWQP_OP_NOP, I40IWQPSQ_OPCODE) | 3364 - LS_64(0, I40IWQPSQ_SIGCOMPL) | 3365 - LS_64(qp->qp_uk.swqe_polarity, I40IWQPSQ_VALID); 3366 - set_64bit_val(wqe, 24, header); 3367 - } 3368 - 3369 - /** 3370 3350 * i40iw_qp_disconnect - free qp and close cm 3371 3351 * @iwqp: associate qp for the connection 3372 3352 */ ··· 3618 3638 } else { 3619 3639 if (iwqp->page) 3620 3640 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page); 3621 - i40iw_loopback_nop(&iwqp->sc_qp); 3641 + dev->iw_priv_qp_ops->qp_send_lsmm(&iwqp->sc_qp, NULL, 0, 0); 3622 3642 } 3623 3643 3624 3644 if (iwqp->page)
+4
drivers/infiniband/hw/i40iw/i40iw_main.c
··· 1558 1558 enum i40iw_status_code status; 1559 1559 struct i40iw_handler *hdl; 1560 1560 1561 + hdl = i40iw_find_netdev(ldev->netdev); 1562 + if (hdl) 1563 + return 0; 1564 + 1561 1565 hdl = kzalloc(sizeof(*hdl), GFP_KERNEL); 1562 1566 if (!hdl) 1563 1567 return -ENOMEM;
+4 -1
drivers/infiniband/hw/i40iw/i40iw_utils.c
··· 673 673 { 674 674 if (!mem) 675 675 return I40IW_ERR_PARAM; 676 + /* 677 + * mem->va points to the parent of mem, so both mem and mem->va 678 + * can not be touched once mem->va is freed 679 + */ 676 680 kfree(mem->va); 677 - mem->va = NULL; 678 681 return 0; 679 682 } 680 683
+1 -3
drivers/infiniband/hw/i40iw/i40iw_verbs.c
··· 794 794 return &iwqp->ibqp; 795 795 error: 796 796 i40iw_free_qp_resources(iwdev, iwqp, qp_num); 797 - kfree(mem); 798 797 return ERR_PTR(err_code); 799 798 } 800 799 ··· 1925 1926 } 1926 1927 if (iwpbl->pbl_allocated) 1927 1928 i40iw_free_pble(iwdev->pble_rsrc, palloc); 1928 - kfree(iwpbl->iwmr); 1929 - iwpbl->iwmr = NULL; 1929 + kfree(iwmr); 1930 1930 return 0; 1931 1931 } 1932 1932
+10 -10
drivers/infiniband/hw/mlx4/cq.c
··· 576 576 checksum == cpu_to_be16(0xffff); 577 577 } 578 578 579 - static int use_tunnel_data(struct mlx4_ib_qp *qp, struct mlx4_ib_cq *cq, struct ib_wc *wc, 580 - unsigned tail, struct mlx4_cqe *cqe, int is_eth) 579 + static void use_tunnel_data(struct mlx4_ib_qp *qp, struct mlx4_ib_cq *cq, struct ib_wc *wc, 580 + unsigned tail, struct mlx4_cqe *cqe, int is_eth) 581 581 { 582 582 struct mlx4_ib_proxy_sqp_hdr *hdr; 583 583 ··· 600 600 wc->slid = be16_to_cpu(hdr->tun.slid_mac_47_32); 601 601 wc->sl = (u8) (be16_to_cpu(hdr->tun.sl_vid) >> 12); 602 602 } 603 - 604 - return 0; 605 603 } 606 604 607 605 static void mlx4_ib_qp_sw_comp(struct mlx4_ib_qp *qp, int num_entries, ··· 690 692 if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) == MLX4_OPCODE_NOP && 691 693 is_send)) { 692 694 pr_warn("Completion for NOP opcode detected!\n"); 693 - return -EINVAL; 695 + return -EAGAIN; 694 696 } 695 697 696 698 /* Resize CQ in progress */ ··· 721 723 if (unlikely(!mqp)) { 722 724 pr_warn("CQ %06x with entry for unknown QPN %06x\n", 723 725 cq->mcq.cqn, be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK); 724 - return -EINVAL; 726 + return -EAGAIN; 725 727 } 726 728 727 729 *cur_qp = to_mibqp(mqp); ··· 739 741 if (unlikely(!msrq)) { 740 742 pr_warn("CQ %06x with entry for unknown SRQN %06x\n", 741 743 cq->mcq.cqn, srq_num); 742 - return -EINVAL; 744 + return -EAGAIN; 743 745 } 744 746 } 745 747 ··· 850 852 if (mlx4_is_mfunc(to_mdev(cq->ibcq.device)->dev)) { 851 853 if ((*cur_qp)->mlx4_ib_qp_type & 852 854 (MLX4_IB_QPT_PROXY_SMI_OWNER | 853 - MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI)) 854 - return use_tunnel_data(*cur_qp, cq, wc, tail, 855 - cqe, is_eth); 855 + MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI)) { 856 + use_tunnel_data(*cur_qp, cq, wc, tail, cqe, 857 + is_eth); 858 + return 0; 859 + } 856 860 } 857 861 858 862 wc->slid = be16_to_cpu(cqe->rlid);
-1
drivers/infiniband/hw/mlx5/main.c
··· 37 37 #include <linux/pci.h> 38 38 #include <linux/dma-mapping.h> 39 39 #include <linux/slab.h> 40 - #include <linux/io-mapping.h> 41 40 #if defined(CONFIG_X86) 42 41 #include <asm/pat.h> 43 42 #endif
+7 -7
drivers/infiniband/hw/ocrdma/ocrdma_hw.c
··· 1156 1156 attr->max_srq = 1157 1157 (rsp->max_srq_rpir_qps & OCRDMA_MBX_QUERY_CFG_MAX_SRQ_MASK) >> 1158 1158 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_OFFSET; 1159 - attr->max_send_sge = ((rsp->max_write_send_sge & 1159 + attr->max_send_sge = ((rsp->max_recv_send_sge & 1160 1160 OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK) >> 1161 1161 OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT); 1162 - attr->max_recv_sge = (rsp->max_write_send_sge & 1163 - OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK) >> 1164 - OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT; 1162 + attr->max_recv_sge = (rsp->max_recv_send_sge & 1163 + OCRDMA_MBX_QUERY_CFG_MAX_RECV_SGE_MASK) >> 1164 + OCRDMA_MBX_QUERY_CFG_MAX_RECV_SGE_SHIFT; 1165 1165 attr->max_srq_sge = (rsp->max_srq_rqe_sge & 1166 1166 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_MASK) >> 1167 1167 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET; 1168 - attr->max_rdma_sge = (rsp->max_write_send_sge & 1169 - OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_MASK) >> 1170 - OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_SHIFT; 1168 + attr->max_rdma_sge = (rsp->max_wr_rd_sge & 1169 + OCRDMA_MBX_QUERY_CFG_MAX_RD_SGE_MASK) >> 1170 + OCRDMA_MBX_QUERY_CFG_MAX_RD_SGE_SHIFT; 1171 1171 attr->max_ord_per_qp = (rsp->max_ird_ord_per_qp & 1172 1172 OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_MASK) >> 1173 1173 OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_SHIFT;
+8 -4
drivers/infiniband/hw/ocrdma/ocrdma_sli.h
··· 554 554 OCRDMA_MBX_QUERY_CFG_L3_TYPE_MASK = 0x18, 555 555 OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT = 0, 556 556 OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK = 0xFFFF, 557 - OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_SHIFT = 16, 558 - OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_MASK = 0xFFFF << 559 - OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_SHIFT, 557 + OCRDMA_MBX_QUERY_CFG_MAX_RECV_SGE_SHIFT = 16, 558 + OCRDMA_MBX_QUERY_CFG_MAX_RECV_SGE_MASK = 0xFFFF << 559 + OCRDMA_MBX_QUERY_CFG_MAX_RECV_SGE_SHIFT, 560 560 561 561 OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_SHIFT = 0, 562 562 OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_MASK = 0xFFFF, ··· 612 612 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET = 0, 613 613 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_MASK = 0xFFFF << 614 614 OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET, 615 + OCRDMA_MBX_QUERY_CFG_MAX_RD_SGE_SHIFT = 0, 616 + OCRDMA_MBX_QUERY_CFG_MAX_RD_SGE_MASK = 0xFFFF, 615 617 }; 616 618 617 619 struct ocrdma_mbx_query_config { ··· 621 619 struct ocrdma_mbx_rsp rsp; 622 620 u32 qp_srq_cq_ird_ord; 623 621 u32 max_pd_ca_ack_delay; 624 - u32 max_write_send_sge; 622 + u32 max_recv_send_sge; 625 623 u32 max_ird_ord_per_qp; 626 624 u32 max_shared_ird_ord; 627 625 u32 max_mr; ··· 641 639 u32 max_wqes_rqes_per_q; 642 640 u32 max_cq_cqes_per_cq; 643 641 u32 max_srq_rqe_sge; 642 + u32 max_wr_rd_sge; 643 + u32 ird_pgsz_num_pages; 644 644 }; 645 645 646 646 struct ocrdma_fw_ver_rsp {
+2 -2
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
··· 125 125 IB_DEVICE_SYS_IMAGE_GUID | 126 126 IB_DEVICE_LOCAL_DMA_LKEY | 127 127 IB_DEVICE_MEM_MGT_EXTENSIONS; 128 - attr->max_sge = dev->attr.max_send_sge; 129 - attr->max_sge_rd = attr->max_sge; 128 + attr->max_sge = min(dev->attr.max_send_sge, dev->attr.max_recv_sge); 129 + attr->max_sge_rd = dev->attr.max_rdma_sge; 130 130 attr->max_cq = dev->attr.max_cq; 131 131 attr->max_cqe = dev->attr.max_cqe; 132 132 attr->max_mr = dev->attr.max_mr;
+9 -3
drivers/infiniband/hw/qib/qib_debugfs.c
··· 189 189 DEBUGFS_FILE(ctx_stats) 190 190 191 191 static void *_qp_stats_seq_start(struct seq_file *s, loff_t *pos) 192 + __acquires(RCU) 192 193 { 193 194 struct qib_qp_iter *iter; 194 195 loff_t n = *pos; 195 196 196 - rcu_read_lock(); 197 197 iter = qib_qp_iter_init(s->private); 198 + 199 + /* stop calls rcu_read_unlock */ 200 + rcu_read_lock(); 201 + 198 202 if (!iter) 199 203 return NULL; 200 204 201 - while (n--) { 205 + do { 202 206 if (qib_qp_iter_next(iter)) { 203 207 kfree(iter); 204 208 return NULL; 205 209 } 206 - } 210 + } while (n--); 207 211 208 212 return iter; 209 213 } 210 214 211 215 static void *_qp_stats_seq_next(struct seq_file *s, void *iter_ptr, 212 216 loff_t *pos) 217 + __must_hold(RCU) 213 218 { 214 219 struct qib_qp_iter *iter = iter_ptr; 215 220 ··· 229 224 } 230 225 231 226 static void _qp_stats_seq_stop(struct seq_file *s, void *iter_ptr) 227 + __releases(RCU) 232 228 { 233 229 rcu_read_unlock(); 234 230 }
+5 -21
drivers/infiniband/hw/qib/qib_fs.c
··· 328 328 329 329 pos = *ppos; 330 330 331 - if (pos != 0) { 332 - ret = -EINVAL; 333 - goto bail; 334 - } 331 + if (pos != 0 || count != sizeof(struct qib_flash)) 332 + return -EINVAL; 335 333 336 - if (count != sizeof(struct qib_flash)) { 337 - ret = -EINVAL; 338 - goto bail; 339 - } 340 - 341 - tmp = kmalloc(count, GFP_KERNEL); 342 - if (!tmp) { 343 - ret = -ENOMEM; 344 - goto bail; 345 - } 346 - 347 - if (copy_from_user(tmp, buf, count)) { 348 - ret = -EFAULT; 349 - goto bail_tmp; 350 - } 334 + tmp = memdup_user(buf, count); 335 + if (IS_ERR(tmp)) 336 + return PTR_ERR(tmp); 351 337 352 338 dd = private2dd(file); 353 339 if (qib_eeprom_write(dd, pos, tmp, count)) { ··· 347 361 348 362 bail_tmp: 349 363 kfree(tmp); 350 - 351 - bail: 352 364 return ret; 353 365 } 354 366
-4
drivers/infiniband/hw/qib/qib_qp.c
··· 573 573 return NULL; 574 574 575 575 iter->dev = dev; 576 - if (qib_qp_iter_next(iter)) { 577 - kfree(iter); 578 - return NULL; 579 - } 580 576 581 577 return iter; 582 578 }
+2 -1
drivers/infiniband/hw/usnic/usnic_ib_main.c
··· 664 664 return err; 665 665 } 666 666 667 - if (pci_register_driver(&usnic_ib_pci_driver)) { 667 + err = pci_register_driver(&usnic_ib_pci_driver); 668 + if (err) { 668 669 usnic_err("Unable to register with PCI\n"); 669 670 goto out_umem_fini; 670 671 }
+2 -1
drivers/infiniband/sw/rdmavt/qp.c
··· 873 873 free_qpn(&rdi->qp_dev->qpn_table, qp->ibqp.qp_num); 874 874 875 875 bail_rq_wq: 876 - vfree(qp->r_rq.wq); 876 + if (!qp->ip) 877 + vfree(qp->r_rq.wq); 877 878 878 879 bail_driver_priv: 879 880 rdi->driver_f.qp_priv_free(rdi, qp);
+1 -1
drivers/infiniband/ulp/isert/ib_isert.c
··· 448 448 449 449 isert_conn->login_rsp_buf = kzalloc(ISER_RX_PAYLOAD_SIZE, GFP_KERNEL); 450 450 if (!isert_conn->login_rsp_buf) { 451 - isert_err("Unable to allocate isert_conn->login_rspbuf\n"); 451 + ret = -ENOMEM; 452 452 goto out_unmap_login_req_buf; 453 453 } 454 454
+5 -4
drivers/infiniband/ulp/srpt/ib_srpt.c
··· 522 522 if (ret) 523 523 goto err_query_port; 524 524 525 + snprintf(sport->port_guid, sizeof(sport->port_guid), 526 + "0x%016llx%016llx", 527 + be64_to_cpu(sport->gid.global.subnet_prefix), 528 + be64_to_cpu(sport->gid.global.interface_id)); 529 + 525 530 if (!sport->mad_agent) { 526 531 memset(&reg_req, 0, sizeof(reg_req)); 527 532 reg_req.mgmt_class = IB_MGMT_CLASS_DEVICE_MGMT; ··· 2553 2548 sdev->device->name, i); 2554 2549 goto err_ring; 2555 2550 } 2556 - snprintf(sport->port_guid, sizeof(sport->port_guid), 2557 - "0x%016llx%016llx", 2558 - be64_to_cpu(sport->gid.global.subnet_prefix), 2559 - be64_to_cpu(sport->gid.global.interface_id)); 2560 2551 } 2561 2552 2562 2553 spin_lock(&srpt_dev_lock);
+3 -8
include/rdma/ib_verbs.h
··· 2115 2115 size_t len) 2116 2116 { 2117 2117 const void __user *p = udata->inbuf + offset; 2118 - bool ret = false; 2118 + bool ret; 2119 2119 u8 *buf; 2120 2120 2121 2121 if (len > USHRT_MAX) 2122 2122 return false; 2123 2123 2124 - buf = kmalloc(len, GFP_KERNEL); 2125 - if (!buf) 2124 + buf = memdup_user(p, len); 2125 + if (IS_ERR(buf)) 2126 2126 return false; 2127 2127 2128 - if (copy_from_user(buf, p, len)) 2129 - goto free; 2130 - 2131 2128 ret = !memchr_inv(buf, 0, len); 2132 - 2133 - free: 2134 2129 kfree(buf); 2135 2130 return ret; 2136 2131 }