nvme-rdma: introduce nvme_rdma_sgl structure

Remove first_sgl pointer from struct nvme_rdma_request and use pointer
arithmetic instead. The inline scatterlist, if exists, will be located
right after the nvme_rdma_request. This patch is needed as a preparation
for adding PI support.

Signed-off-by: Israel Rukshin <israelr@mellanox.com>
Reviewed-by: Max Gurtovoy <maxg@mellanox.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c
index cac8a93..4086874 100644 (file)
--- a/drivers/nvme/host/rdma.c
+++ b/drivers/nvme/host/rdma.c
@@ -48,6 +48,11 @@ struct nvme_rdma_qe {
        u64                     dma;
 };
 
+struct nvme_rdma_sgl {
+       int                     nents;
+       struct sg_table         sg_table;
+};
+
 struct nvme_rdma_queue;
 struct nvme_rdma_request {
        struct nvme_request     req;
@@ -58,12 +63,10 @@ struct nvme_rdma_request {
        refcount_t              ref;
        struct ib_sge           sge[1 + NVME_RDMA_MAX_INLINE_SEGMENTS];
        u32                     num_sge;
-       int                     nents;
        struct ib_reg_wr        reg_wr;
        struct ib_cqe           reg_cqe;
        struct nvme_rdma_queue  *queue;
-       struct sg_table         sg_table;
-       struct scatterlist      first_sgl[];
+       struct nvme_rdma_sgl    data_sgl;
 };
 
 enum nvme_rdma_queue_flags {
@@ -1158,8 +1161,9 @@ static void nvme_rdma_unmap_data(struct nvme_rdma_queue *queue,
                req->mr = NULL;
        }
 
-       ib_dma_unmap_sg(ibdev, req->sg_table.sgl, req->nents, rq_dma_dir(rq));
-       sg_free_table_chained(&req->sg_table, NVME_INLINE_SG_CNT);
+       ib_dma_unmap_sg(ibdev, req->data_sgl.sg_table.sgl, req->data_sgl.nents,
+                       rq_dma_dir(rq));
+       sg_free_table_chained(&req->data_sgl.sg_table, NVME_INLINE_SG_CNT);
 }
 
 static int nvme_rdma_set_sg_null(struct nvme_command *c)
@@ -1178,7 +1182,7 @@ static int nvme_rdma_map_sg_inline(struct nvme_rdma_queue *queue,
                int count)
 {
        struct nvme_sgl_desc *sg = &c->common.dptr.sgl;
-       struct scatterlist *sgl = req->sg_table.sgl;
+       struct scatterlist *sgl = req->data_sgl.sg_table.sgl;
        struct ib_sge *sge = &req->sge[1];
        u32 len = 0;
        int i;
@@ -1203,8 +1207,8 @@ static int nvme_rdma_map_sg_single(struct nvme_rdma_queue *queue,
 {
        struct nvme_keyed_sgl_desc *sg = &c->common.dptr.ksgl;
 
-       sg->addr = cpu_to_le64(sg_dma_address(req->sg_table.sgl));
-       put_unaligned_le24(sg_dma_len(req->sg_table.sgl), sg->length);
+       sg->addr = cpu_to_le64(sg_dma_address(req->data_sgl.sg_table.sgl));
+       put_unaligned_le24(sg_dma_len(req->data_sgl.sg_table.sgl), sg->length);
        put_unaligned_le32(queue->device->pd->unsafe_global_rkey, sg->key);
        sg->type = NVME_KEY_SGL_FMT_DATA_DESC << 4;
        return 0;
@@ -1225,7 +1229,8 @@ static int nvme_rdma_map_sg_fr(struct nvme_rdma_queue *queue,
         * Align the MR to a 4K page size to match the ctrl page size and
         * the block virtual boundary.
         */
-       nr = ib_map_mr_sg(req->mr, req->sg_table.sgl, count, NULL, SZ_4K);
+       nr = ib_map_mr_sg(req->mr, req->data_sgl.sg_table.sgl, count, NULL,
+                         SZ_4K);
        if (unlikely(nr < count)) {
                ib_mr_pool_put(queue->qp, &queue->qp->rdma_mrs, req->mr);
                req->mr = NULL;
@@ -1272,17 +1277,18 @@ static int nvme_rdma_map_data(struct nvme_rdma_queue *queue,
        if (!blk_rq_nr_phys_segments(rq))
                return nvme_rdma_set_sg_null(c);
 
-       req->sg_table.sgl = req->first_sgl;
-       ret = sg_alloc_table_chained(&req->sg_table,
-                       blk_rq_nr_phys_segments(rq), req->sg_table.sgl,
+       req->data_sgl.sg_table.sgl = (struct scatterlist *)(req + 1);
+       ret = sg_alloc_table_chained(&req->data_sgl.sg_table,
+                       blk_rq_nr_phys_segments(rq), req->data_sgl.sg_table.sgl,
                        NVME_INLINE_SG_CNT);
        if (ret)
                return -ENOMEM;
 
-       req->nents = blk_rq_map_sg(rq->q, rq, req->sg_table.sgl);
+       req->data_sgl.nents = blk_rq_map_sg(rq->q, rq,
+                                           req->data_sgl.sg_table.sgl);
 
-       count = ib_dma_map_sg(ibdev, req->sg_table.sgl, req->nents,
-                             rq_dma_dir(rq));
+       count = ib_dma_map_sg(ibdev, req->data_sgl.sg_table.sgl,
+                             req->data_sgl.nents, rq_dma_dir(rq));
        if (unlikely(count <= 0)) {
                ret = -EIO;
                goto out_free_table;
@@ -1311,9 +1317,10 @@ out:
        return 0;
 
 out_unmap_sg:
-       ib_dma_unmap_sg(ibdev, req->sg_table.sgl, req->nents, rq_dma_dir(rq));
+       ib_dma_unmap_sg(ibdev, req->data_sgl.sg_table.sgl, req->data_sgl.nents,
+                       rq_dma_dir(rq));
 out_free_table:
-       sg_free_table_chained(&req->sg_table, NVME_INLINE_SG_CNT);
+       sg_free_table_chained(&req->data_sgl.sg_table, NVME_INLINE_SG_CNT);
        return ret;
 }