IB/iser: Avoid FRWR notation, use fastreg instead

FRWR stands for "fast registration work request". We want to avoid
calling the fastreg pool with that name, instead we name it fastreg
which stands for "fast registration".

This pool will include more elements in the future, so it is a good
idea to generalize the name.

Signed-off-by: Sagi Grimberg <sagig@mellanox.com>
Signed-off-by: Alex Tabachnik <alext@mellanox.com>
Signed-off-by: Roland Dreier <roland@purestorage.com>

3 files changed, 67 insertions, 65 deletions

diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index e1a01c6e6e12..ca161dfeee48 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -138,7 +138,7 @@
 #define ISER_WSV                        0x08
 #define ISER_RSV                        0x04
 
-#define ISER_FRWR_LI_WRID               0xffffffffffffffffULL
+#define ISER_FASTREG_LI_WRID            0xffffffffffffffffULL
 
 struct iser_hdr {
         u8      flags;
@@ -312,6 +312,8 @@ struct iser_conn {
         unsigned int                 rx_desc_head;
         struct iser_rx_desc          *rx_descs;
         struct ib_recv_wr            rx_wr[ISER_MIN_POSTED_RX];
+
+        /* Connection memory registration pool */
         union {
                 struct {
                         struct ib_fmr_pool      *pool;     /* pool of IB FMRs         */
@@ -321,8 +323,8 @@ struct iser_conn {
                 struct {
                         struct list_head        pool;
                         int                     pool_size;
-                } frwr;
-        } fastreg;
+                } fastreg;
+        };
 };
 
 struct iscsi_iser_conn {
@@ -408,8 +410,8 @@ void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_task *task,
 
 int  iser_reg_rdma_mem_fmr(struct iscsi_iser_task *task,
                            enum iser_data_dir cmd_dir);
-int  iser_reg_rdma_mem_frwr(struct iscsi_iser_task *task,
-                            enum iser_data_dir cmd_dir);
+int  iser_reg_rdma_mem_fastreg(struct iscsi_iser_task *task,
+                               enum iser_data_dir cmd_dir);
 
 int  iser_connect(struct iser_conn   *ib_conn,
                   struct sockaddr_in *src_addr,
@@ -422,8 +424,8 @@ int  iser_reg_page_vec(struct iser_conn     *ib_conn,
 
 void iser_unreg_mem_fmr(struct iscsi_iser_task *iser_task,
                         enum iser_data_dir cmd_dir);
-void iser_unreg_mem_frwr(struct iscsi_iser_task *iser_task,
-                         enum iser_data_dir cmd_dir);
+void iser_unreg_mem_fastreg(struct iscsi_iser_task *iser_task,
+                            enum iser_data_dir cmd_dir);
 
 int  iser_post_recvl(struct iser_conn *ib_conn);
 int  iser_post_recvm(struct iser_conn *ib_conn, int count);
@@ -440,6 +442,6 @@ int  iser_initialize_task_headers(struct iscsi_task *task,
 int iser_alloc_rx_descriptors(struct iser_conn *ib_conn, struct iscsi_session *session);
 int iser_create_fmr_pool(struct iser_conn *ib_conn, unsigned cmds_max);
 void iser_free_fmr_pool(struct iser_conn *ib_conn);
-int iser_create_frwr_pool(struct iser_conn *ib_conn, unsigned cmds_max);
-void iser_free_frwr_pool(struct iser_conn *ib_conn);
+int iser_create_fastreg_pool(struct iser_conn *ib_conn, unsigned cmds_max);
+void iser_free_fastreg_pool(struct iser_conn *ib_conn);
 #endif
diff --git a/drivers/infiniband/ulp/iser/iser_memory.c b/drivers/infiniband/ulp/iser/iser_memory.c
index f7701795cef2..6e9b7bcbc562 100644
--- a/drivers/infiniband/ulp/iser/iser_memory.c
+++ b/drivers/infiniband/ulp/iser/iser_memory.c
@@ -422,8 +422,8 @@ int iser_reg_rdma_mem_fmr(struct iscsi_iser_task *iser_task,
                          (unsigned long)regd_buf->reg.va,
                          (unsigned long)regd_buf->reg.len);
         } else { /* use FMR for multiple dma entries */
-                iser_page_vec_build(mem, ib_conn->fastreg.fmr.page_vec, ibdev);
-                err = iser_reg_page_vec(ib_conn, ib_conn->fastreg.fmr.page_vec,
+                iser_page_vec_build(mem, ib_conn->fmr.page_vec, ibdev);
+                err = iser_reg_page_vec(ib_conn, ib_conn->fmr.page_vec,
                                         &regd_buf->reg);
                 if (err && err != -EAGAIN) {
                         iser_data_buf_dump(mem, ibdev);
@@ -431,12 +431,12 @@ int iser_reg_rdma_mem_fmr(struct iscsi_iser_task *iser_task,
                                  mem->dma_nents,
                                  ntoh24(iser_task->desc.iscsi_header.dlength));
                         iser_err("page_vec: data_size = 0x%x, length = %d, offset = 0x%x\n",
-                                 ib_conn->fastreg.fmr.page_vec->data_size,
-                                 ib_conn->fastreg.fmr.page_vec->length,
-                                 ib_conn->fastreg.fmr.page_vec->offset);
-                        for (i = 0; i < ib_conn->fastreg.fmr.page_vec->length; i++)
+                                 ib_conn->fmr.page_vec->data_size,
+                                 ib_conn->fmr.page_vec->length,
+                                 ib_conn->fmr.page_vec->offset);
+                        for (i = 0; i < ib_conn->fmr.page_vec->length; i++)
                                 iser_err("page_vec[%d] = 0x%llx\n", i,
-                                         (unsigned long long) ib_conn->fastreg.fmr.page_vec->pages[i]);
+                                         (unsigned long long) ib_conn->fmr.page_vec->pages[i]);
                 }
                 if (err)
                         return err;
@@ -457,7 +457,7 @@ static int iser_fast_reg_mr(struct fast_reg_descriptor *desc,
 
         if (!desc->valid) {
                 memset(&inv_wr, 0, sizeof(inv_wr));
-                inv_wr.wr_id = ISER_FRWR_LI_WRID;
+                inv_wr.wr_id = ISER_FASTREG_LI_WRID;
                 inv_wr.opcode = IB_WR_LOCAL_INV;
                 inv_wr.ex.invalidate_rkey = desc->data_mr->rkey;
                 wr = &inv_wr;
@@ -468,7 +468,7 @@ static int iser_fast_reg_mr(struct fast_reg_descriptor *desc,
 
         /* Prepare FASTREG WR */
         memset(&fastreg_wr, 0, sizeof(fastreg_wr));
-        fastreg_wr.wr_id = ISER_FRWR_LI_WRID;
+        fastreg_wr.wr_id = ISER_FASTREG_LI_WRID;
         fastreg_wr.opcode = IB_WR_FAST_REG_MR;
         fastreg_wr.wr.fast_reg.iova_start = desc->data_frpl->page_list[0] + offset;
         fastreg_wr.wr.fast_reg.page_list = desc->data_frpl;
@@ -503,13 +503,13 @@ static int iser_fast_reg_mr(struct fast_reg_descriptor *desc,
 }
 
 /**
- * iser_reg_rdma_mem_frwr - Registers memory intended for RDMA,
+ * iser_reg_rdma_mem_fastreg - Registers memory intended for RDMA,
  * using Fast Registration WR (if possible) obtaining rkey and va
  *
  * returns 0 on success, errno code on failure
  */
-int iser_reg_rdma_mem_frwr(struct iscsi_iser_task *iser_task,
-                           enum iser_data_dir cmd_dir)
+int iser_reg_rdma_mem_fastreg(struct iscsi_iser_task *iser_task,
+                              enum iser_data_dir cmd_dir)
 {
         struct iser_conn *ib_conn = iser_task->iser_conn->ib_conn;
         struct iser_device *device = ib_conn->device;
@@ -544,7 +544,7 @@ int iser_reg_rdma_mem_frwr(struct iscsi_iser_task *iser_task,
                 regd_buf->reg.is_mr = 0;
         } else {
                 spin_lock_irqsave(&ib_conn->lock, flags);
-                desc = list_first_entry(&ib_conn->fastreg.frwr.pool,
+                desc = list_first_entry(&ib_conn->fastreg.pool,
                                         struct fast_reg_descriptor, list);
                 list_del(&desc->list);
                 spin_unlock_irqrestore(&ib_conn->lock, flags);
@@ -567,7 +567,7 @@ int iser_reg_rdma_mem_frwr(struct iscsi_iser_task *iser_task,
         return 0;
 err_reg:
         spin_lock_irqsave(&ib_conn->lock, flags);
-        list_add_tail(&desc->list, &ib_conn->fastreg.frwr.pool);
+        list_add_tail(&desc->list, &ib_conn->fastreg.pool);
         spin_unlock_irqrestore(&ib_conn->lock, flags);
         return err;
 }
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index 7bdb811ad5b1..dc5a0b49cfbe 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -94,13 +94,13 @@ static int iser_create_device_ib_res(struct iser_device *device)
                 device->iser_unreg_rdma_mem = iser_unreg_mem_fmr;
         } else
         if (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS) {
-                iser_info("FRWR supported, using FRWR for registration\n");
-                device->iser_alloc_rdma_reg_res = iser_create_frwr_pool;
-                device->iser_free_rdma_reg_res = iser_free_frwr_pool;
-                device->iser_reg_rdma_mem = iser_reg_rdma_mem_frwr;
-                device->iser_unreg_rdma_mem = iser_unreg_mem_frwr;
+                iser_info("FastReg supported, using FastReg for registration\n");
+                device->iser_alloc_rdma_reg_res = iser_create_fastreg_pool;
+                device->iser_free_rdma_reg_res = iser_free_fastreg_pool;
+                device->iser_reg_rdma_mem = iser_reg_rdma_mem_fastreg;
+                device->iser_unreg_rdma_mem = iser_unreg_mem_fastreg;
         } else {
-                iser_err("IB device does not support FMRs nor FRWRs, can't register memory\n");
+                iser_err("IB device does not support FMRs nor FastRegs, can't register memory\n");
                 goto dev_attr_err;
         }
 
@@ -221,13 +221,13 @@ int iser_create_fmr_pool(struct iser_conn *ib_conn, unsigned cmds_max)
         struct ib_fmr_pool_param params;
         int ret = -ENOMEM;
 
-        ib_conn->fastreg.fmr.page_vec = kmalloc(sizeof(struct iser_page_vec) +
-                                                (sizeof(u64)*(ISCSI_ISER_SG_TABLESIZE + 1)),
-                                                GFP_KERNEL);
-        if (!ib_conn->fastreg.fmr.page_vec)
+        ib_conn->fmr.page_vec = kmalloc(sizeof(*ib_conn->fmr.page_vec) +
+                                        (sizeof(u64)*(ISCSI_ISER_SG_TABLESIZE + 1)),
+                                        GFP_KERNEL);
+        if (!ib_conn->fmr.page_vec)
                 return ret;
 
-        ib_conn->fastreg.fmr.page_vec->pages = (u64 *)(ib_conn->fastreg.fmr.page_vec + 1);
+        ib_conn->fmr.page_vec->pages = (u64 *)(ib_conn->fmr.page_vec + 1);
 
         params.page_shift        = SHIFT_4K;
         /* when the first/last SG element are not start/end *
@@ -243,16 +243,16 @@ int iser_create_fmr_pool(struct iser_conn *ib_conn, unsigned cmds_max)
                                     IB_ACCESS_REMOTE_WRITE |
                                     IB_ACCESS_REMOTE_READ);
 
-        ib_conn->fastreg.fmr.pool = ib_create_fmr_pool(device->pd, &params);
-        if (!IS_ERR(ib_conn->fastreg.fmr.pool))
+        ib_conn->fmr.pool = ib_create_fmr_pool(device->pd, &params);
+        if (!IS_ERR(ib_conn->fmr.pool))
                 return 0;
 
         /* no FMR => no need for page_vec */
-        kfree(ib_conn->fastreg.fmr.page_vec);
-        ib_conn->fastreg.fmr.page_vec = NULL;
+        kfree(ib_conn->fmr.page_vec);
+        ib_conn->fmr.page_vec = NULL;
 
-        ret = PTR_ERR(ib_conn->fastreg.fmr.pool);
-        ib_conn->fastreg.fmr.pool = NULL;
+        ret = PTR_ERR(ib_conn->fmr.pool);
+        ib_conn->fmr.pool = NULL;
         if (ret != -ENOSYS) {
                 iser_err("FMR allocation failed, err %d\n", ret);
                 return ret;
@@ -268,30 +268,30 @@ int iser_create_fmr_pool(struct iser_conn *ib_conn, unsigned cmds_max)
 void iser_free_fmr_pool(struct iser_conn *ib_conn)
 {
         iser_info("freeing conn %p fmr pool %p\n",
-                  ib_conn, ib_conn->fastreg.fmr.pool);
+                  ib_conn, ib_conn->fmr.pool);
 
-        if (ib_conn->fastreg.fmr.pool != NULL)
-                ib_destroy_fmr_pool(ib_conn->fastreg.fmr.pool);
+        if (ib_conn->fmr.pool != NULL)
+                ib_destroy_fmr_pool(ib_conn->fmr.pool);
 
-        ib_conn->fastreg.fmr.pool = NULL;
+        ib_conn->fmr.pool = NULL;
 
-        kfree(ib_conn->fastreg.fmr.page_vec);
-        ib_conn->fastreg.fmr.page_vec = NULL;
+        kfree(ib_conn->fmr.page_vec);
+        ib_conn->fmr.page_vec = NULL;
 }
 
 /**
- * iser_create_frwr_pool - Creates pool of fast_reg descriptors
+ * iser_create_fastreg_pool - Creates pool of fast_reg descriptors
  * for fast registration work requests.
  * returns 0 on success, or errno code on failure
  */
-int iser_create_frwr_pool(struct iser_conn *ib_conn, unsigned cmds_max)
+int iser_create_fastreg_pool(struct iser_conn *ib_conn, unsigned cmds_max)
 {
         struct iser_device      *device = ib_conn->device;
         struct fast_reg_descriptor      *desc;
         int i, ret;
 
-        INIT_LIST_HEAD(&ib_conn->fastreg.frwr.pool);
-        ib_conn->fastreg.frwr.pool_size = 0;
+        INIT_LIST_HEAD(&ib_conn->fastreg.pool);
+        ib_conn->fastreg.pool_size = 0;
         for (i = 0; i < cmds_max; i++) {
                 desc = kmalloc(sizeof(*desc), GFP_KERNEL);
                 if (!desc) {
@@ -316,8 +316,8 @@ int iser_create_frwr_pool(struct iser_conn *ib_conn, unsigned cmds_max)
                         goto fast_reg_mr_failure;
                 }
                 desc->valid = true;
-                list_add_tail(&desc->list, &ib_conn->fastreg.frwr.pool);
-                ib_conn->fastreg.frwr.pool_size++;
+                list_add_tail(&desc->list, &ib_conn->fastreg.pool);
+                ib_conn->fastreg.pool_size++;
         }
 
         return 0;
@@ -327,24 +327,24 @@ fast_reg_mr_failure:
 fast_reg_page_failure:
         kfree(desc);
 err:
-        iser_free_frwr_pool(ib_conn);
+        iser_free_fastreg_pool(ib_conn);
         return ret;
 }
 
 /**
- * iser_free_frwr_pool - releases the pool of fast_reg descriptors
+ * iser_free_fastreg_pool - releases the pool of fast_reg descriptors
  */
-void iser_free_frwr_pool(struct iser_conn *ib_conn)
+void iser_free_fastreg_pool(struct iser_conn *ib_conn)
 {
         struct fast_reg_descriptor *desc, *tmp;
         int i = 0;
 
-        if (list_empty(&ib_conn->fastreg.frwr.pool))
+        if (list_empty(&ib_conn->fastreg.pool))
                 return;
 
-        iser_info("freeing conn %p frwr pool\n", ib_conn);
+        iser_info("freeing conn %p fr pool\n", ib_conn);
 
-        list_for_each_entry_safe(desc, tmp, &ib_conn->fastreg.frwr.pool, list) {
+        list_for_each_entry_safe(desc, tmp, &ib_conn->fastreg.pool, list) {
                 list_del(&desc->list);
                 ib_free_fast_reg_page_list(desc->data_frpl);
                 ib_dereg_mr(desc->data_mr);
@@ -352,9 +352,9 @@ void iser_free_frwr_pool(struct iser_conn *ib_conn)
                 ++i;
         }
 
-        if (i < ib_conn->fastreg.frwr.pool_size)
+        if (i < ib_conn->fastreg.pool_size)
                 iser_warn("pool still has %d regions registered\n",
-                          ib_conn->fastreg.frwr.pool_size - i);
+                          ib_conn->fastreg.pool_size - i);
 }
 
 /**
@@ -801,7 +801,7 @@ int iser_reg_page_vec(struct iser_conn     *ib_conn,
         page_list = page_vec->pages;
         io_addr   = page_list[0];
 
-        mem  = ib_fmr_pool_map_phys(ib_conn->fastreg.fmr.pool,
+        mem  = ib_fmr_pool_map_phys(ib_conn->fmr.pool,
                                     page_list,
                                     page_vec->length,
                                     io_addr);
@@ -855,8 +855,8 @@ void iser_unreg_mem_fmr(struct iscsi_iser_task *iser_task,
         reg->mem_h = NULL;
 }
 
-void iser_unreg_mem_frwr(struct iscsi_iser_task *iser_task,
-                         enum iser_data_dir cmd_dir)
+void iser_unreg_mem_fastreg(struct iscsi_iser_task *iser_task,
+                            enum iser_data_dir cmd_dir)
 {
         struct iser_mem_reg *reg = &iser_task->rdma_regd[cmd_dir].reg;
         struct iser_conn *ib_conn = iser_task->iser_conn->ib_conn;
@@ -868,7 +868,7 @@ void iser_unreg_mem_frwr(struct iscsi_iser_task *iser_task,
         reg->mem_h = NULL;
         reg->is_mr = 0;
         spin_lock_bh(&ib_conn->lock);
-        list_add_tail(&desc->list, &ib_conn->fastreg.frwr.pool);
+        list_add_tail(&desc->list, &ib_conn->fastreg.pool);
         spin_unlock_bh(&ib_conn->lock);
 }
 
@@ -999,7 +999,7 @@ static int iser_drain_tx_cq(struct iser_device  *device, int cq_index)
                 } else {
                         iser_err("tx id %llx status %d vend_err %x\n",
                                  wc.wr_id, wc.status, wc.vendor_err);
-                        if (wc.wr_id != ISER_FRWR_LI_WRID) {
+                        if (wc.wr_id != ISER_FASTREG_LI_WRID) {
                                 atomic_dec(&ib_conn->post_send_buf_count);
                                 iser_handle_comp_error(tx_desc, ib_conn);
                         }