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 number of driver bug fixes and a few recent regressions:

- Several bug fixes for bnxt_re. Crashing, incorrect data reported,
and corruption on new HW

- Memory leak and crash in rxe

- Fix sysfs corruption in rxe if the netdev name is too long

- Fix a crash on error unwind in the new cq_pool code

- Fix kobject panics in rtrs by working device lifetime properly

- Fix a data corruption bug in iser target related to misaligned
buffers"

* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma:
IB/isert: Fix unaligned immediate-data handling
RDMA/rtrs-srv: Set .release function for rtrs srv device during device init
RDMA/bnxt_re: Remove set but not used variable 'qplib_ctx'
RDMA/core: Fix reported speed and width
RDMA/core: Fix unsafe linked list traversal after failing to allocate CQ
RDMA/bnxt_re: Remove the qp from list only if the qp destroy succeeds
RDMA/bnxt_re: Fix driver crash on unaligned PSN entry address
RDMA/bnxt_re: Restrict the max_gids to 256
RDMA/bnxt_re: Static NQ depth allocation
RDMA/bnxt_re: Fix the qp table indexing
RDMA/bnxt_re: Do not report transparent vlan from QP1
RDMA/mlx4: Read pkey table length instead of hardcoded value
RDMA/rxe: Fix panic when calling kmem_cache_create()
RDMA/rxe: Fix memleak in rxe_mem_init_user
RDMA/rxe: Fix the parent sysfs read when the interface has 15 chars
RDMA/rtrs-srv: Replace device_register with device_initialize and device_add

Linus Torvalds b1df2a07 40249c69

+168 -106
+2 -2
drivers/infiniband/core/cq.c
··· 379 379 { 380 380 LIST_HEAD(tmp_list); 381 381 unsigned int nr_cqs, i; 382 - struct ib_cq *cq; 382 + struct ib_cq *cq, *n; 383 383 int ret; 384 384 385 385 if (poll_ctx > IB_POLL_LAST_POOL_TYPE) { ··· 412 412 return 0; 413 413 414 414 out_free_cqs: 415 - list_for_each_entry(cq, &tmp_list, pool_entry) { 415 + list_for_each_entry_safe(cq, n, &tmp_list, pool_entry) { 416 416 cq->shared = false; 417 417 ib_free_cq(cq); 418 418 }
+1 -1
drivers/infiniband/core/verbs.c
··· 1801 1801 1802 1802 dev_put(netdev); 1803 1803 1804 - if (!rc) { 1804 + if (!rc && lksettings.base.speed != (u32)SPEED_UNKNOWN) { 1805 1805 netdev_speed = lksettings.base.speed; 1806 1806 } else { 1807 1807 netdev_speed = SPEED_1000;
+29 -14
drivers/infiniband/hw/bnxt_re/ib_verbs.c
··· 752 752 gsi_sqp = rdev->gsi_ctx.gsi_sqp; 753 753 gsi_sah = rdev->gsi_ctx.gsi_sah; 754 754 755 - /* remove from active qp list */ 756 - mutex_lock(&rdev->qp_lock); 757 - list_del(&gsi_sqp->list); 758 - mutex_unlock(&rdev->qp_lock); 759 - atomic_dec(&rdev->qp_count); 760 - 761 755 ibdev_dbg(&rdev->ibdev, "Destroy the shadow AH\n"); 762 756 bnxt_qplib_destroy_ah(&rdev->qplib_res, 763 757 &gsi_sah->qplib_ah, ··· 765 771 goto fail; 766 772 } 767 773 bnxt_qplib_free_qp_res(&rdev->qplib_res, &gsi_sqp->qplib_qp); 774 + 775 + /* remove from active qp list */ 776 + mutex_lock(&rdev->qp_lock); 777 + list_del(&gsi_sqp->list); 778 + mutex_unlock(&rdev->qp_lock); 779 + atomic_dec(&rdev->qp_count); 768 780 769 781 kfree(rdev->gsi_ctx.sqp_tbl); 770 782 kfree(gsi_sah); ··· 791 791 struct bnxt_re_dev *rdev = qp->rdev; 792 792 unsigned int flags; 793 793 int rc; 794 - 795 - mutex_lock(&rdev->qp_lock); 796 - list_del(&qp->list); 797 - mutex_unlock(&rdev->qp_lock); 798 - atomic_dec(&rdev->qp_count); 799 794 800 795 bnxt_qplib_flush_cqn_wq(&qp->qplib_qp); 801 796 ··· 813 818 if (rc) 814 819 goto sh_fail; 815 820 } 821 + 822 + mutex_lock(&rdev->qp_lock); 823 + list_del(&qp->list); 824 + mutex_unlock(&rdev->qp_lock); 825 + atomic_dec(&rdev->qp_count); 816 826 817 827 ib_umem_release(qp->rumem); 818 828 ib_umem_release(qp->sumem); ··· 3264 3264 wc->wc_flags |= IB_WC_GRH; 3265 3265 } 3266 3266 3267 + static bool bnxt_re_check_if_vlan_valid(struct bnxt_re_dev *rdev, 3268 + u16 vlan_id) 3269 + { 3270 + /* 3271 + * Check if the vlan is configured in the host. If not configured, it 3272 + * can be a transparent VLAN. So dont report the vlan id. 3273 + */ 3274 + if (!__vlan_find_dev_deep_rcu(rdev->netdev, 3275 + htons(ETH_P_8021Q), vlan_id)) 3276 + return false; 3277 + return true; 3278 + } 3279 + 3267 3280 static bool bnxt_re_is_vlan_pkt(struct bnxt_qplib_cqe *orig_cqe, 3268 3281 u16 *vid, u8 *sl) 3269 3282 { ··· 3345 3332 wc->src_qp = orig_cqe->src_qp; 3346 3333 memcpy(wc->smac, orig_cqe->smac, ETH_ALEN); 3347 3334 if (bnxt_re_is_vlan_pkt(orig_cqe, &vlan_id, &sl)) { 3348 - wc->vlan_id = vlan_id; 3349 - wc->sl = sl; 3350 - wc->wc_flags |= IB_WC_WITH_VLAN; 3335 + if (bnxt_re_check_if_vlan_valid(rdev, vlan_id)) { 3336 + wc->vlan_id = vlan_id; 3337 + wc->sl = sl; 3338 + wc->wc_flags |= IB_WC_WITH_VLAN; 3339 + } 3351 3340 } 3352 3341 wc->port_num = 1; 3353 3342 wc->vendor_err = orig_cqe->status;
+1 -4
drivers/infiniband/hw/bnxt_re/main.c
··· 1009 1009 static int bnxt_re_alloc_res(struct bnxt_re_dev *rdev) 1010 1010 { 1011 1011 struct bnxt_re_ring_attr rattr = {}; 1012 - struct bnxt_qplib_ctx *qplib_ctx; 1013 1012 int num_vec_created = 0; 1014 1013 int rc = 0, i; 1015 1014 u8 type; ··· 1031 1032 if (rc) 1032 1033 goto dealloc_res; 1033 1034 1034 - qplib_ctx = &rdev->qplib_ctx; 1035 1035 for (i = 0; i < rdev->num_msix - 1; i++) { 1036 1036 struct bnxt_qplib_nq *nq; 1037 1037 1038 1038 nq = &rdev->nq[i]; 1039 - nq->hwq.max_elements = (qplib_ctx->cq_count + 1040 - qplib_ctx->srqc_count + 2); 1039 + nq->hwq.max_elements = BNXT_QPLIB_NQE_MAX_CNT; 1041 1040 rc = bnxt_qplib_alloc_nq(&rdev->qplib_res, &rdev->nq[i]); 1042 1041 if (rc) { 1043 1042 ibdev_err(&rdev->ibdev, "Alloc Failed NQ%d rc:%#x",
+16 -10
drivers/infiniband/hw/bnxt_re/qplib_fp.c
··· 818 818 u16 cmd_flags = 0; 819 819 u32 qp_flags = 0; 820 820 u8 pg_sz_lvl; 821 + u32 tbl_indx; 821 822 int rc; 822 823 823 824 RCFW_CMD_PREP(req, CREATE_QP1, cmd_flags); ··· 908 907 rq->dbinfo.db = qp->dpi->dbr; 909 908 rq->dbinfo.max_slot = bnxt_qplib_set_rq_max_slot(rq->wqe_size); 910 909 } 911 - rcfw->qp_tbl[qp->id].qp_id = qp->id; 912 - rcfw->qp_tbl[qp->id].qp_handle = (void *)qp; 910 + tbl_indx = map_qp_id_to_tbl_indx(qp->id, rcfw); 911 + rcfw->qp_tbl[tbl_indx].qp_id = qp->id; 912 + rcfw->qp_tbl[tbl_indx].qp_handle = (void *)qp; 913 913 914 914 return 0; 915 915 ··· 937 935 938 936 sq = &qp->sq; 939 937 hwq = &sq->hwq; 938 + /* First psn entry */ 940 939 fpsne = (u64)bnxt_qplib_get_qe(hwq, hwq->depth, &psn_pg); 941 940 if (!IS_ALIGNED(fpsne, PAGE_SIZE)) 942 - indx_pad = ALIGN(fpsne, PAGE_SIZE) / size; 943 - 941 + indx_pad = (fpsne & ~PAGE_MASK) / size; 944 942 hwq->pad_pgofft = indx_pad; 945 943 hwq->pad_pg = (u64 *)psn_pg; 946 944 hwq->pad_stride = size; ··· 961 959 u16 cmd_flags = 0; 962 960 u32 qp_flags = 0; 963 961 u8 pg_sz_lvl; 962 + u32 tbl_indx; 964 963 u16 nsge; 965 964 966 965 RCFW_CMD_PREP(req, CREATE_QP, cmd_flags); ··· 1114 1111 rq->dbinfo.db = qp->dpi->dbr; 1115 1112 rq->dbinfo.max_slot = bnxt_qplib_set_rq_max_slot(rq->wqe_size); 1116 1113 } 1117 - rcfw->qp_tbl[qp->id].qp_id = qp->id; 1118 - rcfw->qp_tbl[qp->id].qp_handle = (void *)qp; 1114 + tbl_indx = map_qp_id_to_tbl_indx(qp->id, rcfw); 1115 + rcfw->qp_tbl[tbl_indx].qp_id = qp->id; 1116 + rcfw->qp_tbl[tbl_indx].qp_handle = (void *)qp; 1119 1117 1120 1118 return 0; 1121 1119 fail: ··· 1461 1457 struct cmdq_destroy_qp req; 1462 1458 struct creq_destroy_qp_resp resp; 1463 1459 u16 cmd_flags = 0; 1460 + u32 tbl_indx; 1464 1461 int rc; 1465 1462 1466 - rcfw->qp_tbl[qp->id].qp_id = BNXT_QPLIB_QP_ID_INVALID; 1467 - rcfw->qp_tbl[qp->id].qp_handle = NULL; 1463 + tbl_indx = map_qp_id_to_tbl_indx(qp->id, rcfw); 1464 + rcfw->qp_tbl[tbl_indx].qp_id = BNXT_QPLIB_QP_ID_INVALID; 1465 + rcfw->qp_tbl[tbl_indx].qp_handle = NULL; 1468 1466 1469 1467 RCFW_CMD_PREP(req, DESTROY_QP, cmd_flags); 1470 1468 ··· 1474 1468 rc = bnxt_qplib_rcfw_send_message(rcfw, (void *)&req, 1475 1469 (void *)&resp, NULL, 0); 1476 1470 if (rc) { 1477 - rcfw->qp_tbl[qp->id].qp_id = qp->id; 1478 - rcfw->qp_tbl[qp->id].qp_handle = qp; 1471 + rcfw->qp_tbl[tbl_indx].qp_id = qp->id; 1472 + rcfw->qp_tbl[tbl_indx].qp_handle = qp; 1479 1473 return rc; 1480 1474 } 1481 1475
+6 -4
drivers/infiniband/hw/bnxt_re/qplib_rcfw.c
··· 307 307 __le16 mcookie; 308 308 u16 cookie; 309 309 int rc = 0; 310 - u32 qp_id; 310 + u32 qp_id, tbl_indx; 311 311 312 312 pdev = rcfw->pdev; 313 313 switch (qp_event->event) { 314 314 case CREQ_QP_EVENT_EVENT_QP_ERROR_NOTIFICATION: 315 315 err_event = (struct creq_qp_error_notification *)qp_event; 316 316 qp_id = le32_to_cpu(err_event->xid); 317 - qp = rcfw->qp_tbl[qp_id].qp_handle; 317 + tbl_indx = map_qp_id_to_tbl_indx(qp_id, rcfw); 318 + qp = rcfw->qp_tbl[tbl_indx].qp_handle; 318 319 dev_dbg(&pdev->dev, "Received QP error notification\n"); 319 320 dev_dbg(&pdev->dev, 320 321 "qpid 0x%x, req_err=0x%x, resp_err=0x%x\n", ··· 616 615 617 616 cmdq->bmap_size = bmap_size; 618 617 619 - rcfw->qp_tbl_size = qp_tbl_sz; 620 - rcfw->qp_tbl = kcalloc(qp_tbl_sz, sizeof(struct bnxt_qplib_qp_node), 618 + /* Allocate one extra to hold the QP1 entries */ 619 + rcfw->qp_tbl_size = qp_tbl_sz + 1; 620 + rcfw->qp_tbl = kcalloc(rcfw->qp_tbl_size, sizeof(struct bnxt_qplib_qp_node), 621 621 GFP_KERNEL); 622 622 if (!rcfw->qp_tbl) 623 623 goto fail;
+5
drivers/infiniband/hw/bnxt_re/qplib_rcfw.h
··· 216 216 int bnxt_qplib_init_rcfw(struct bnxt_qplib_rcfw *rcfw, 217 217 struct bnxt_qplib_ctx *ctx, int is_virtfn); 218 218 void bnxt_qplib_mark_qp_error(void *qp_handle); 219 + static inline u32 map_qp_id_to_tbl_indx(u32 qid, struct bnxt_qplib_rcfw *rcfw) 220 + { 221 + /* Last index of the qp_tbl is for QP1 ie. qp_tbl_size - 1*/ 222 + return (qid == 1) ? rcfw->qp_tbl_size - 1 : qid % rcfw->qp_tbl_size - 2; 223 + } 219 224 #endif /* __BNXT_QPLIB_RCFW_H__ */
+1 -1
drivers/infiniband/hw/bnxt_re/qplib_sp.c
··· 149 149 attr->max_inline_data = le32_to_cpu(sb->max_inline_data); 150 150 attr->l2_db_size = (sb->l2_db_space_size + 1) * 151 151 (0x01 << RCFW_DBR_BASE_PAGE_SHIFT); 152 - attr->max_sgid = le32_to_cpu(sb->max_gid); 152 + attr->max_sgid = BNXT_QPLIB_NUM_GIDS_SUPPORTED; 153 153 154 154 bnxt_qplib_query_version(rcfw, attr->fw_ver); 155 155
+1
drivers/infiniband/hw/bnxt_re/qplib_sp.h
··· 47 47 struct bnxt_qplib_dev_attr { 48 48 #define FW_VER_ARR_LEN 4 49 49 u8 fw_ver[FW_VER_ARR_LEN]; 50 + #define BNXT_QPLIB_NUM_GIDS_SUPPORTED 256 50 51 u16 max_sgid; 51 52 u16 max_mrw; 52 53 u32 max_qp;
+2 -1
drivers/infiniband/hw/mlx4/main.c
··· 784 784 props->ip_gids = true; 785 785 props->gid_tbl_len = mdev->dev->caps.gid_table_len[port]; 786 786 props->max_msg_sz = mdev->dev->caps.max_msg_sz; 787 - props->pkey_tbl_len = 1; 787 + if (mdev->dev->caps.pkey_table_len[port]) 788 + props->pkey_tbl_len = 1; 788 789 props->max_mtu = IB_MTU_4096; 789 790 props->max_vl_num = 2; 790 791 props->state = IB_PORT_DOWN;
+4
drivers/infiniband/sw/rxe/rxe.c
··· 40 40 MODULE_DESCRIPTION("Soft RDMA transport"); 41 41 MODULE_LICENSE("Dual BSD/GPL"); 42 42 43 + bool rxe_initialized; 44 + 43 45 /* free resources for a rxe device all objects created for this device must 44 46 * have been destroyed 45 47 */ ··· 317 315 return err; 318 316 319 317 rdma_link_register(&rxe_link_ops); 318 + rxe_initialized = true; 320 319 pr_info("loaded\n"); 321 320 return 0; 322 321 } ··· 329 326 rxe_net_exit(); 330 327 rxe_cache_exit(); 331 328 329 + rxe_initialized = false; 332 330 pr_info("unloaded\n"); 333 331 } 334 332
+2
drivers/infiniband/sw/rxe/rxe.h
··· 67 67 68 68 #define RXE_ROCE_V2_SPORT (0xc000) 69 69 70 + extern bool rxe_initialized; 71 + 70 72 static inline u32 rxe_crc32(struct rxe_dev *rxe, 71 73 u32 crc, void *next, size_t len) 72 74 {
+1
drivers/infiniband/sw/rxe/rxe_mr.c
··· 205 205 vaddr = page_address(sg_page_iter_page(&sg_iter)); 206 206 if (!vaddr) { 207 207 pr_warn("null vaddr\n"); 208 + ib_umem_release(umem); 208 209 err = -ENOMEM; 209 210 goto err1; 210 211 }
+5
drivers/infiniband/sw/rxe/rxe_sysfs.c
··· 61 61 struct net_device *ndev; 62 62 struct rxe_dev *exists; 63 63 64 + if (!rxe_initialized) { 65 + pr_err("Module parameters are not supported, use rdma link add or rxe_cfg\n"); 66 + return -EAGAIN; 67 + } 68 + 64 69 len = sanitize_arg(val, intf, sizeof(intf)); 65 70 if (!len) { 66 71 pr_err("add: invalid interface name\n");
+1 -1
drivers/infiniband/sw/rxe/rxe_verbs.c
··· 1056 1056 struct rxe_dev *rxe = 1057 1057 rdma_device_to_drv_device(device, struct rxe_dev, ib_dev); 1058 1058 1059 - return snprintf(buf, 16, "%s\n", rxe_parent_name(rxe, 1)); 1059 + return scnprintf(buf, PAGE_SIZE, "%s\n", rxe_parent_name(rxe, 1)); 1060 1060 } 1061 1061 1062 1062 static DEVICE_ATTR_RO(parent);
+47 -46
drivers/infiniband/ulp/isert/ib_isert.c
··· 140 140 rx_desc = isert_conn->rx_descs; 141 141 142 142 for (i = 0; i < ISERT_QP_MAX_RECV_DTOS; i++, rx_desc++) { 143 - dma_addr = ib_dma_map_single(ib_dev, (void *)rx_desc, 144 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 143 + dma_addr = ib_dma_map_single(ib_dev, rx_desc->buf, 144 + ISER_RX_SIZE, DMA_FROM_DEVICE); 145 145 if (ib_dma_mapping_error(ib_dev, dma_addr)) 146 146 goto dma_map_fail; 147 147 148 148 rx_desc->dma_addr = dma_addr; 149 149 150 150 rx_sg = &rx_desc->rx_sg; 151 - rx_sg->addr = rx_desc->dma_addr; 151 + rx_sg->addr = rx_desc->dma_addr + isert_get_hdr_offset(rx_desc); 152 152 rx_sg->length = ISER_RX_PAYLOAD_SIZE; 153 153 rx_sg->lkey = device->pd->local_dma_lkey; 154 154 rx_desc->rx_cqe.done = isert_recv_done; ··· 160 160 rx_desc = isert_conn->rx_descs; 161 161 for (j = 0; j < i; j++, rx_desc++) { 162 162 ib_dma_unmap_single(ib_dev, rx_desc->dma_addr, 163 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 163 + ISER_RX_SIZE, DMA_FROM_DEVICE); 164 164 } 165 165 kfree(isert_conn->rx_descs); 166 166 isert_conn->rx_descs = NULL; ··· 181 181 rx_desc = isert_conn->rx_descs; 182 182 for (i = 0; i < ISERT_QP_MAX_RECV_DTOS; i++, rx_desc++) { 183 183 ib_dma_unmap_single(ib_dev, rx_desc->dma_addr, 184 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 184 + ISER_RX_SIZE, DMA_FROM_DEVICE); 185 185 } 186 186 187 187 kfree(isert_conn->rx_descs); ··· 299 299 ISER_RX_PAYLOAD_SIZE, DMA_TO_DEVICE); 300 300 kfree(isert_conn->login_rsp_buf); 301 301 302 - ib_dma_unmap_single(ib_dev, isert_conn->login_req_dma, 303 - ISER_RX_PAYLOAD_SIZE, 304 - DMA_FROM_DEVICE); 305 - kfree(isert_conn->login_req_buf); 302 + ib_dma_unmap_single(ib_dev, isert_conn->login_desc->dma_addr, 303 + ISER_RX_SIZE, DMA_FROM_DEVICE); 304 + kfree(isert_conn->login_desc); 306 305 } 307 306 308 307 static int ··· 310 311 { 311 312 int ret; 312 313 313 - isert_conn->login_req_buf = kzalloc(sizeof(*isert_conn->login_req_buf), 314 + isert_conn->login_desc = kzalloc(sizeof(*isert_conn->login_desc), 314 315 GFP_KERNEL); 315 - if (!isert_conn->login_req_buf) 316 + if (!isert_conn->login_desc) 316 317 return -ENOMEM; 317 318 318 - isert_conn->login_req_dma = ib_dma_map_single(ib_dev, 319 - isert_conn->login_req_buf, 320 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 321 - ret = ib_dma_mapping_error(ib_dev, isert_conn->login_req_dma); 319 + isert_conn->login_desc->dma_addr = ib_dma_map_single(ib_dev, 320 + isert_conn->login_desc->buf, 321 + ISER_RX_SIZE, DMA_FROM_DEVICE); 322 + ret = ib_dma_mapping_error(ib_dev, isert_conn->login_desc->dma_addr); 322 323 if (ret) { 323 - isert_err("login_req_dma mapping error: %d\n", ret); 324 - isert_conn->login_req_dma = 0; 325 - goto out_free_login_req_buf; 324 + isert_err("login_desc dma mapping error: %d\n", ret); 325 + isert_conn->login_desc->dma_addr = 0; 326 + goto out_free_login_desc; 326 327 } 327 328 328 329 isert_conn->login_rsp_buf = kzalloc(ISER_RX_PAYLOAD_SIZE, GFP_KERNEL); 329 330 if (!isert_conn->login_rsp_buf) { 330 331 ret = -ENOMEM; 331 - goto out_unmap_login_req_buf; 332 + goto out_unmap_login_desc; 332 333 } 333 334 334 335 isert_conn->login_rsp_dma = ib_dma_map_single(ib_dev, ··· 345 346 346 347 out_free_login_rsp_buf: 347 348 kfree(isert_conn->login_rsp_buf); 348 - out_unmap_login_req_buf: 349 - ib_dma_unmap_single(ib_dev, isert_conn->login_req_dma, 350 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 351 - out_free_login_req_buf: 352 - kfree(isert_conn->login_req_buf); 349 + out_unmap_login_desc: 350 + ib_dma_unmap_single(ib_dev, isert_conn->login_desc->dma_addr, 351 + ISER_RX_SIZE, DMA_FROM_DEVICE); 352 + out_free_login_desc: 353 + kfree(isert_conn->login_desc); 353 354 return ret; 354 355 } 355 356 ··· 475 476 if (isert_conn->qp) 476 477 isert_destroy_qp(isert_conn); 477 478 478 - if (isert_conn->login_req_buf) 479 + if (isert_conn->login_desc) 479 480 isert_free_login_buf(isert_conn); 480 481 481 482 isert_device_put(device); ··· 861 862 int ret; 862 863 863 864 memset(&sge, 0, sizeof(struct ib_sge)); 864 - sge.addr = isert_conn->login_req_dma; 865 + sge.addr = isert_conn->login_desc->dma_addr + 866 + isert_get_hdr_offset(isert_conn->login_desc); 865 867 sge.length = ISER_RX_PAYLOAD_SIZE; 866 868 sge.lkey = isert_conn->device->pd->local_dma_lkey; 867 869 868 870 isert_dbg("Setup sge: addr: %llx length: %d 0x%08x\n", 869 871 sge.addr, sge.length, sge.lkey); 870 872 871 - isert_conn->login_req_buf->rx_cqe.done = isert_login_recv_done; 873 + isert_conn->login_desc->rx_cqe.done = isert_login_recv_done; 872 874 873 875 memset(&rx_wr, 0, sizeof(struct ib_recv_wr)); 874 - rx_wr.wr_cqe = &isert_conn->login_req_buf->rx_cqe; 876 + rx_wr.wr_cqe = &isert_conn->login_desc->rx_cqe; 875 877 rx_wr.sg_list = &sge; 876 878 rx_wr.num_sge = 1; 877 879 ··· 949 949 static void 950 950 isert_rx_login_req(struct isert_conn *isert_conn) 951 951 { 952 - struct iser_rx_desc *rx_desc = isert_conn->login_req_buf; 952 + struct iser_rx_desc *rx_desc = isert_conn->login_desc; 953 953 int rx_buflen = isert_conn->login_req_len; 954 954 struct iscsi_conn *conn = isert_conn->conn; 955 955 struct iscsi_login *login = conn->conn_login; ··· 961 961 962 962 if (login->first_request) { 963 963 struct iscsi_login_req *login_req = 964 - (struct iscsi_login_req *)&rx_desc->iscsi_header; 964 + (struct iscsi_login_req *)isert_get_iscsi_hdr(rx_desc); 965 965 /* 966 966 * Setup the initial iscsi_login values from the leading 967 967 * login request PDU. ··· 980 980 login->tsih = be16_to_cpu(login_req->tsih); 981 981 } 982 982 983 - memcpy(&login->req[0], (void *)&rx_desc->iscsi_header, ISCSI_HDR_LEN); 983 + memcpy(&login->req[0], isert_get_iscsi_hdr(rx_desc), ISCSI_HDR_LEN); 984 984 985 985 size = min(rx_buflen, MAX_KEY_VALUE_PAIRS); 986 986 isert_dbg("Using login payload size: %d, rx_buflen: %d " 987 987 "MAX_KEY_VALUE_PAIRS: %d\n", size, rx_buflen, 988 988 MAX_KEY_VALUE_PAIRS); 989 - memcpy(login->req_buf, &rx_desc->data[0], size); 989 + memcpy(login->req_buf, isert_get_data(rx_desc), size); 990 990 991 991 if (login->first_request) { 992 992 complete(&isert_conn->login_comp); ··· 1051 1051 if (imm_data_len != data_len) { 1052 1052 sg_nents = max(1UL, DIV_ROUND_UP(imm_data_len, PAGE_SIZE)); 1053 1053 sg_copy_from_buffer(cmd->se_cmd.t_data_sg, sg_nents, 1054 - &rx_desc->data[0], imm_data_len); 1054 + isert_get_data(rx_desc), imm_data_len); 1055 1055 isert_dbg("Copy Immediate sg_nents: %u imm_data_len: %d\n", 1056 1056 sg_nents, imm_data_len); 1057 1057 } else { 1058 1058 sg_init_table(&isert_cmd->sg, 1); 1059 1059 cmd->se_cmd.t_data_sg = &isert_cmd->sg; 1060 1060 cmd->se_cmd.t_data_nents = 1; 1061 - sg_set_buf(&isert_cmd->sg, &rx_desc->data[0], imm_data_len); 1061 + sg_set_buf(&isert_cmd->sg, isert_get_data(rx_desc), 1062 + imm_data_len); 1062 1063 isert_dbg("Transfer Immediate imm_data_len: %d\n", 1063 1064 imm_data_len); 1064 1065 } ··· 1128 1127 } 1129 1128 isert_dbg("Copying DataOut: sg_start: %p, sg_off: %u " 1130 1129 "sg_nents: %u from %p %u\n", sg_start, sg_off, 1131 - sg_nents, &rx_desc->data[0], unsol_data_len); 1130 + sg_nents, isert_get_data(rx_desc), unsol_data_len); 1132 1131 1133 - sg_copy_from_buffer(sg_start, sg_nents, &rx_desc->data[0], 1132 + sg_copy_from_buffer(sg_start, sg_nents, isert_get_data(rx_desc), 1134 1133 unsol_data_len); 1135 1134 1136 1135 rc = iscsit_check_dataout_payload(cmd, hdr, false); ··· 1189 1188 } 1190 1189 cmd->text_in_ptr = text_in; 1191 1190 1192 - memcpy(cmd->text_in_ptr, &rx_desc->data[0], payload_length); 1191 + memcpy(cmd->text_in_ptr, isert_get_data(rx_desc), payload_length); 1193 1192 1194 1193 return iscsit_process_text_cmd(conn, cmd, hdr); 1195 1194 } ··· 1199 1198 uint32_t read_stag, uint64_t read_va, 1200 1199 uint32_t write_stag, uint64_t write_va) 1201 1200 { 1202 - struct iscsi_hdr *hdr = &rx_desc->iscsi_header; 1201 + struct iscsi_hdr *hdr = isert_get_iscsi_hdr(rx_desc); 1203 1202 struct iscsi_conn *conn = isert_conn->conn; 1204 1203 struct iscsi_cmd *cmd; 1205 1204 struct isert_cmd *isert_cmd; ··· 1297 1296 struct isert_conn *isert_conn = wc->qp->qp_context; 1298 1297 struct ib_device *ib_dev = isert_conn->cm_id->device; 1299 1298 struct iser_rx_desc *rx_desc = cqe_to_rx_desc(wc->wr_cqe); 1300 - struct iscsi_hdr *hdr = &rx_desc->iscsi_header; 1301 - struct iser_ctrl *iser_ctrl = &rx_desc->iser_header; 1299 + struct iscsi_hdr *hdr = isert_get_iscsi_hdr(rx_desc); 1300 + struct iser_ctrl *iser_ctrl = isert_get_iser_hdr(rx_desc); 1302 1301 uint64_t read_va = 0, write_va = 0; 1303 1302 uint32_t read_stag = 0, write_stag = 0; 1304 1303 ··· 1312 1311 rx_desc->in_use = true; 1313 1312 1314 1313 ib_dma_sync_single_for_cpu(ib_dev, rx_desc->dma_addr, 1315 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 1314 + ISER_RX_SIZE, DMA_FROM_DEVICE); 1316 1315 1317 1316 isert_dbg("DMA: 0x%llx, iSCSI opcode: 0x%02x, ITT: 0x%08x, flags: 0x%02x dlen: %d\n", 1318 1317 rx_desc->dma_addr, hdr->opcode, hdr->itt, hdr->flags, ··· 1347 1346 read_stag, read_va, write_stag, write_va); 1348 1347 1349 1348 ib_dma_sync_single_for_device(ib_dev, rx_desc->dma_addr, 1350 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 1349 + ISER_RX_SIZE, DMA_FROM_DEVICE); 1351 1350 } 1352 1351 1353 1352 static void ··· 1361 1360 return; 1362 1361 } 1363 1362 1364 - ib_dma_sync_single_for_cpu(ib_dev, isert_conn->login_req_dma, 1365 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 1363 + ib_dma_sync_single_for_cpu(ib_dev, isert_conn->login_desc->dma_addr, 1364 + ISER_RX_SIZE, DMA_FROM_DEVICE); 1366 1365 1367 1366 isert_conn->login_req_len = wc->byte_len - ISER_HEADERS_LEN; 1368 1367 ··· 1377 1376 complete(&isert_conn->login_req_comp); 1378 1377 mutex_unlock(&isert_conn->mutex); 1379 1378 1380 - ib_dma_sync_single_for_device(ib_dev, isert_conn->login_req_dma, 1381 - ISER_RX_PAYLOAD_SIZE, DMA_FROM_DEVICE); 1379 + ib_dma_sync_single_for_device(ib_dev, isert_conn->login_desc->dma_addr, 1380 + ISER_RX_SIZE, DMA_FROM_DEVICE); 1382 1381 } 1383 1382 1384 1383 static void
+31 -10
drivers/infiniband/ulp/isert/ib_isert.h
··· 59 59 ISERT_MAX_TX_MISC_PDUS + \ 60 60 ISERT_MAX_RX_MISC_PDUS) 61 61 62 - #define ISER_RX_PAD_SIZE (ISCSI_DEF_MAX_RECV_SEG_LEN + 4096 - \ 63 - (ISER_RX_PAYLOAD_SIZE + sizeof(u64) + sizeof(struct ib_sge) + \ 64 - sizeof(struct ib_cqe) + sizeof(bool))) 62 + /* 63 + * RX size is default of 8k plus headers, but data needs to align to 64 + * 512 boundary, so use 1024 to have the extra space for alignment. 65 + */ 66 + #define ISER_RX_SIZE (ISCSI_DEF_MAX_RECV_SEG_LEN + 1024) 65 67 66 68 /* Maximum support is 16MB I/O size */ 67 69 #define ISCSI_ISER_MAX_SG_TABLESIZE 4096 ··· 83 81 }; 84 82 85 83 struct iser_rx_desc { 86 - struct iser_ctrl iser_header; 87 - struct iscsi_hdr iscsi_header; 88 - char data[ISCSI_DEF_MAX_RECV_SEG_LEN]; 84 + char buf[ISER_RX_SIZE]; 89 85 u64 dma_addr; 90 86 struct ib_sge rx_sg; 91 87 struct ib_cqe rx_cqe; 92 88 bool in_use; 93 - char pad[ISER_RX_PAD_SIZE]; 94 - } __packed; 89 + }; 95 90 96 91 static inline struct iser_rx_desc *cqe_to_rx_desc(struct ib_cqe *cqe) 97 92 { 98 93 return container_of(cqe, struct iser_rx_desc, rx_cqe); 94 + } 95 + 96 + static void *isert_get_iser_hdr(struct iser_rx_desc *desc) 97 + { 98 + return PTR_ALIGN(desc->buf + ISER_HEADERS_LEN, 512) - ISER_HEADERS_LEN; 99 + } 100 + 101 + static size_t isert_get_hdr_offset(struct iser_rx_desc *desc) 102 + { 103 + return isert_get_iser_hdr(desc) - (void *)desc->buf; 104 + } 105 + 106 + static void *isert_get_iscsi_hdr(struct iser_rx_desc *desc) 107 + { 108 + return isert_get_iser_hdr(desc) + sizeof(struct iser_ctrl); 109 + } 110 + 111 + static void *isert_get_data(struct iser_rx_desc *desc) 112 + { 113 + void *data = isert_get_iser_hdr(desc) + ISER_HEADERS_LEN; 114 + 115 + WARN_ON((uintptr_t)data & 511); 116 + return data; 99 117 } 100 118 101 119 struct iser_tx_desc { ··· 164 142 u32 responder_resources; 165 143 u32 initiator_depth; 166 144 bool pi_support; 167 - struct iser_rx_desc *login_req_buf; 145 + struct iser_rx_desc *login_desc; 168 146 char *login_rsp_buf; 169 - u64 login_req_dma; 170 147 int login_req_len; 171 148 u64 login_rsp_dma; 172 149 struct iser_rx_desc *rx_descs;
+4 -12
drivers/infiniband/ulp/rtrs/rtrs-srv-sysfs.c
··· 152 152 .attrs = rtrs_srv_stats_attrs, 153 153 }; 154 154 155 - static void rtrs_srv_dev_release(struct device *dev) 156 - { 157 - struct rtrs_srv *srv = container_of(dev, struct rtrs_srv, dev); 158 - 159 - kfree(srv); 160 - } 161 - 162 155 static int rtrs_srv_create_once_sysfs_root_folders(struct rtrs_srv_sess *sess) 163 156 { 164 157 struct rtrs_srv *srv = sess->srv; ··· 165 172 goto unlock; 166 173 } 167 174 srv->dev.class = rtrs_dev_class; 168 - srv->dev.release = rtrs_srv_dev_release; 169 175 err = dev_set_name(&srv->dev, "%s", sess->s.sessname); 170 176 if (err) 171 177 goto unlock; ··· 174 182 * sysfs files are created 175 183 */ 176 184 dev_set_uevent_suppress(&srv->dev, true); 177 - err = device_register(&srv->dev); 185 + err = device_add(&srv->dev); 178 186 if (err) { 179 - pr_err("device_register(): %d\n", err); 187 + pr_err("device_add(): %d\n", err); 180 188 goto put; 181 189 } 182 190 srv->kobj_paths = kobject_create_and_add("paths", &srv->dev.kobj); 183 191 if (!srv->kobj_paths) { 184 192 err = -ENOMEM; 185 193 pr_err("kobject_create_and_add(): %d\n", err); 186 - device_unregister(&srv->dev); 194 + device_del(&srv->dev); 187 195 goto unlock; 188 196 } 189 197 dev_set_uevent_suppress(&srv->dev, false); ··· 208 216 kobject_del(srv->kobj_paths); 209 217 kobject_put(srv->kobj_paths); 210 218 mutex_unlock(&srv->paths_mutex); 211 - device_unregister(&srv->dev); 219 + device_del(&srv->dev); 212 220 } else { 213 221 mutex_unlock(&srv->paths_mutex); 214 222 }
+9
drivers/infiniband/ulp/rtrs/rtrs-srv.c
··· 1319 1319 return sess->cur_cq_vector; 1320 1320 } 1321 1321 1322 + static void rtrs_srv_dev_release(struct device *dev) 1323 + { 1324 + struct rtrs_srv *srv = container_of(dev, struct rtrs_srv, dev); 1325 + 1326 + kfree(srv); 1327 + } 1328 + 1322 1329 static struct rtrs_srv *__alloc_srv(struct rtrs_srv_ctx *ctx, 1323 1330 const uuid_t *paths_uuid) 1324 1331 { ··· 1343 1336 uuid_copy(&srv->paths_uuid, paths_uuid); 1344 1337 srv->queue_depth = sess_queue_depth; 1345 1338 srv->ctx = ctx; 1339 + device_initialize(&srv->dev); 1340 + srv->dev.release = rtrs_srv_dev_release; 1346 1341 1347 1342 srv->chunks = kcalloc(srv->queue_depth, sizeof(*srv->chunks), 1348 1343 GFP_KERNEL);