nvme-pci: remove struct nvme_descriptor

There is no real point in having a union of two pointer types here, just
use a void pointer as we mix and match types between the arms of the
union between the allocation and freeing side already.

Also rename the nr_allocations field to nr_descriptors to better describe
what it does.

Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
index 7990c3f22ecf660a5c82825cf1d372dc180e34f7..5d67be831c2e9d13987d35610515eef62b6c6e84 100644 (file)
--- a/drivers/nvme/host/pci.c
+++ b/drivers/nvme/host/pci.c
@@ -43,7 +43,7 @@
  */
 #define NVME_MAX_KB_SZ 8192
 #define NVME_MAX_SEGS  128
-#define NVME_MAX_NR_ALLOCATIONS        5
+#define NVME_MAX_NR_DESCRIPTORS        5
 
 static int use_threaded_interrupts;
 module_param(use_threaded_interrupts, int, 0444);
@@ -216,28 +216,20 @@ struct nvme_queue {
        struct completion delete_done;
 };
 
-union nvme_descriptor {
-       struct nvme_sgl_desc    *sg_list;
-       __le64                  *prp_list;
-};
-
 /*
  * The nvme_iod describes the data in an I/O.
- *
- * The sg pointer contains the list of PRP/SGL chunk allocations in addition
- * to the actual struct scatterlist.
  */
 struct nvme_iod {
        struct nvme_request req;
        struct nvme_command cmd;
        bool aborted;
-       s8 nr_allocations;      /* PRP list pool allocations. 0 means small
-                                  pool in use */
+       /* # of PRP/SGL descriptors: (0 for small pool) */
+       s8 nr_descriptors;
        unsigned int dma_len;   /* length of single DMA segment mapping */
        dma_addr_t first_dma;
        dma_addr_t meta_dma;
        struct sg_table sgt;
-       union nvme_descriptor list[NVME_MAX_NR_ALLOCATIONS];
+       void *descriptors[NVME_MAX_NR_DESCRIPTORS];
 };
 
 static inline unsigned int nvme_dbbuf_size(struct nvme_dev *dev)
@@ -528,8 +520,8 @@ static void nvme_free_prps(struct nvme_dev *dev, struct request *req)
        dma_addr_t dma_addr = iod->first_dma;
        int i;
 
-       for (i = 0; i < iod->nr_allocations; i++) {
-               __le64 *prp_list = iod->list[i].prp_list;
+       for (i = 0; i < iod->nr_descriptors; i++) {
+               __le64 *prp_list = iod->descriptors[i];
                dma_addr_t next_dma_addr = le64_to_cpu(prp_list[last_prp]);
 
                dma_pool_free(dev->prp_page_pool, prp_list, dma_addr);
@@ -551,11 +543,11 @@ static void nvme_unmap_data(struct nvme_dev *dev, struct request *req)
 
        dma_unmap_sgtable(dev->dev, &iod->sgt, rq_dma_dir(req), 0);
 
-       if (iod->nr_allocations == 0)
-               dma_pool_free(dev->prp_small_pool, iod->list[0].sg_list,
+       if (iod->nr_descriptors == 0)
+               dma_pool_free(dev->prp_small_pool, iod->descriptors[0],
                              iod->first_dma);
-       else if (iod->nr_allocations == 1)
-               dma_pool_free(dev->prp_page_pool, iod->list[0].sg_list,
+       else if (iod->nr_descriptors == 1)
+               dma_pool_free(dev->prp_page_pool, iod->descriptors[0],
                              iod->first_dma);
        else
                nvme_free_prps(dev, req);
@@ -613,18 +605,18 @@ static blk_status_t nvme_pci_setup_prps(struct nvme_dev *dev,
        nprps = DIV_ROUND_UP(length, NVME_CTRL_PAGE_SIZE);
        if (nprps <= (256 / 8)) {
                pool = dev->prp_small_pool;
-               iod->nr_allocations = 0;
+               iod->nr_descriptors = 0;
        } else {
                pool = dev->prp_page_pool;
-               iod->nr_allocations = 1;
+               iod->nr_descriptors = 1;
        }
 
        prp_list = dma_pool_alloc(pool, GFP_ATOMIC, &prp_dma);
        if (!prp_list) {
-               iod->nr_allocations = -1;
+               iod->nr_descriptors = -1;
                return BLK_STS_RESOURCE;
        }
-       iod->list[0].prp_list = prp_list;
+       iod->descriptors[0] = prp_list;
        iod->first_dma = prp_dma;
        i = 0;
        for (;;) {
@@ -633,7 +625,7 @@ static blk_status_t nvme_pci_setup_prps(struct nvme_dev *dev,
                        prp_list = dma_pool_alloc(pool, GFP_ATOMIC, &prp_dma);
                        if (!prp_list)
                                goto free_prps;
-                       iod->list[iod->nr_allocations++].prp_list = prp_list;
+                       iod->descriptors[iod->nr_descriptors++] = prp_list;
                        prp_list[0] = old_prp_list[i - 1];
                        old_prp_list[i - 1] = cpu_to_le64(prp_dma);
                        i = 1;
@@ -703,19 +695,19 @@ static blk_status_t nvme_pci_setup_sgls(struct nvme_dev *dev,
 
        if (entries <= (256 / sizeof(struct nvme_sgl_desc))) {
                pool = dev->prp_small_pool;
-               iod->nr_allocations = 0;
+               iod->nr_descriptors = 0;
        } else {
                pool = dev->prp_page_pool;
-               iod->nr_allocations = 1;
+               iod->nr_descriptors = 1;
        }
 
        sg_list = dma_pool_alloc(pool, GFP_ATOMIC, &sgl_dma);
        if (!sg_list) {
-               iod->nr_allocations = -1;
+               iod->nr_descriptors = -1;
                return BLK_STS_RESOURCE;
        }
 
-       iod->list[0].sg_list = sg_list;
+       iod->descriptors[0] = sg_list;
        iod->first_dma = sgl_dma;
 
        nvme_pci_sgl_set_seg(&cmd->dptr.sgl, sgl_dma, entries);
@@ -841,7 +833,7 @@ static blk_status_t nvme_prep_rq(struct nvme_dev *dev, struct request *req)
        blk_status_t ret;
 
        iod->aborted = false;
-       iod->nr_allocations = -1;
+       iod->nr_descriptors = -1;
        iod->sgt.nents = 0;
 
        ret = nvme_setup_cmd(req->q->queuedata, req);
@@ -3613,7 +3605,7 @@ static int __init nvme_init(void)
        BUILD_BUG_ON(IRQ_AFFINITY_MAX_SETS < 2);
        BUILD_BUG_ON(NVME_MAX_SEGS > SGES_PER_PAGE);
        BUILD_BUG_ON(sizeof(struct scatterlist) * NVME_MAX_SEGS > PAGE_SIZE);
-       BUILD_BUG_ON(nvme_pci_npages_prp() > NVME_MAX_NR_ALLOCATIONS);
+       BUILD_BUG_ON(nvme_pci_npages_prp() > NVME_MAX_NR_DESCRIPTORS);
 
        return pci_register_driver(&nvme_driver);
 }