Re: [PATCH for-next] RDMA/rxe: Split MEM into MR and MW

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, Mar 15, 2021 at 6:30 AM Bob Pearson <rpearsonhpe@xxxxxxxxx> wrote:
>
> In the original rxe implementation it was intended to use a common
> object to represent MRs and MWs but they are different enough to
> separate these into two objects.

It is a long patch. Is it possible to split it into several short patches?

Zhu Yanjun

>
> This allows replacing the mem name with mr for MRs which is more
> consistent with the style for the other objects and less likely
> to be confusing. This is a long patch that mostly changes mem to
> mr where it makes sense and adds a new rxe_mw struct.
>
> Signed-off-by: Bob Pearson <rpearson@xxxxxxx>
> ---
>  drivers/infiniband/sw/rxe/rxe_comp.c  |   4 +-
>  drivers/infiniband/sw/rxe/rxe_loc.h   |  26 +--
>  drivers/infiniband/sw/rxe/rxe_mr.c    | 256 +++++++++++++-------------
>  drivers/infiniband/sw/rxe/rxe_pool.c  |  12 +-
>  drivers/infiniband/sw/rxe/rxe_req.c   |  10 +-
>  drivers/infiniband/sw/rxe/rxe_resp.c  |  34 ++--
>  drivers/infiniband/sw/rxe/rxe_verbs.c |  20 +-
>  drivers/infiniband/sw/rxe/rxe_verbs.h |  73 +++++---
>  8 files changed, 224 insertions(+), 211 deletions(-)
>
> diff --git a/drivers/infiniband/sw/rxe/rxe_comp.c b/drivers/infiniband/sw/rxe/rxe_comp.c
> index 0a1e6393250b..5dc86c9e74c2 100644
> --- a/drivers/infiniband/sw/rxe/rxe_comp.c
> +++ b/drivers/infiniband/sw/rxe/rxe_comp.c
> @@ -345,7 +345,7 @@ static inline enum comp_state do_read(struct rxe_qp *qp,
>
>         ret = copy_data(qp->pd, IB_ACCESS_LOCAL_WRITE,
>                         &wqe->dma, payload_addr(pkt),
> -                       payload_size(pkt), to_mem_obj, NULL);
> +                       payload_size(pkt), to_mr_obj, NULL);
>         if (ret)
>                 return COMPST_ERROR;
>
> @@ -365,7 +365,7 @@ static inline enum comp_state do_atomic(struct rxe_qp *qp,
>
>         ret = copy_data(qp->pd, IB_ACCESS_LOCAL_WRITE,
>                         &wqe->dma, &atomic_orig,
> -                       sizeof(u64), to_mem_obj, NULL);
> +                       sizeof(u64), to_mr_obj, NULL);
>         if (ret)
>                 return COMPST_ERROR;
>         else
> diff --git a/drivers/infiniband/sw/rxe/rxe_loc.h b/drivers/infiniband/sw/rxe/rxe_loc.h
> index 0d758760b9ae..9ec6bff6863f 100644
> --- a/drivers/infiniband/sw/rxe/rxe_loc.h
> +++ b/drivers/infiniband/sw/rxe/rxe_loc.h
> @@ -72,40 +72,40 @@ int rxe_mmap(struct ib_ucontext *context, struct vm_area_struct *vma);
>
>  /* rxe_mr.c */
>  enum copy_direction {
> -       to_mem_obj,
> -       from_mem_obj,
> +       to_mr_obj,
> +       from_mr_obj,
>  };
>
> -void rxe_mem_init_dma(struct rxe_pd *pd,
> -                     int access, struct rxe_mem *mem);
> +void rxe_mr_init_dma(struct rxe_pd *pd,
> +                     int access, struct rxe_mr *mr);
>
> -int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
> +int rxe_mr_init_user(struct rxe_pd *pd, u64 start,
>                       u64 length, u64 iova, int access, struct ib_udata *udata,
> -                     struct rxe_mem *mr);
> +                     struct rxe_mr *mr);
>
> -int rxe_mem_init_fast(struct rxe_pd *pd,
> -                     int max_pages, struct rxe_mem *mem);
> +int rxe_mr_init_fast(struct rxe_pd *pd,
> +                     int max_pages, struct rxe_mr *mr);
>
> -int rxe_mem_copy(struct rxe_mem *mem, u64 iova, void *addr,
> +int rxe_mr_copy(struct rxe_mr *mr, u64 iova, void *addr,
>                  int length, enum copy_direction dir, u32 *crcp);
>
>  int copy_data(struct rxe_pd *pd, int access,
>               struct rxe_dma_info *dma, void *addr, int length,
>               enum copy_direction dir, u32 *crcp);
>
> -void *iova_to_vaddr(struct rxe_mem *mem, u64 iova, int length);
> +void *iova_to_vaddr(struct rxe_mr *mr, u64 iova, int length);
>
>  enum lookup_type {
>         lookup_local,
>         lookup_remote,
>  };
>
> -struct rxe_mem *lookup_mem(struct rxe_pd *pd, int access, u32 key,
> +struct rxe_mr *lookup_mr(struct rxe_pd *pd, int access, u32 key,
>                            enum lookup_type type);
>
> -int mem_check_range(struct rxe_mem *mem, u64 iova, size_t length);
> +int mr_check_range(struct rxe_mr *mr, u64 iova, size_t length);
>
> -void rxe_mem_cleanup(struct rxe_pool_entry *arg);
> +void rxe_mr_cleanup(struct rxe_pool_entry *arg);
>
>  int advance_dma_data(struct rxe_dma_info *dma, unsigned int length);
>
> diff --git a/drivers/infiniband/sw/rxe/rxe_mr.c b/drivers/infiniband/sw/rxe/rxe_mr.c
> index 6e8c41567ba0..b27aea9638b8 100644
> --- a/drivers/infiniband/sw/rxe/rxe_mr.c
> +++ b/drivers/infiniband/sw/rxe/rxe_mr.c
> @@ -24,16 +24,16 @@ static u8 rxe_get_key(void)
>         return key;
>  }
>
> -int mem_check_range(struct rxe_mem *mem, u64 iova, size_t length)
> +int mr_check_range(struct rxe_mr *mr, u64 iova, size_t length)
>  {
> -       switch (mem->type) {
> -       case RXE_MEM_TYPE_DMA:
> +       switch (mr->type) {
> +       case RXE_MR_TYPE_DMA:
>                 return 0;
>
> -       case RXE_MEM_TYPE_MR:
> -               if (iova < mem->iova ||
> -                   length > mem->length ||
> -                   iova > mem->iova + mem->length - length)
> +       case RXE_MR_TYPE_MR:
> +               if (iova < mr->iova ||
> +                   length > mr->length ||
> +                   iova > mr->iova + mr->length - length)
>                         return -EFAULT;
>                 return 0;
>
> @@ -46,85 +46,85 @@ int mem_check_range(struct rxe_mem *mem, u64 iova, size_t length)
>                                 | IB_ACCESS_REMOTE_WRITE        \
>                                 | IB_ACCESS_REMOTE_ATOMIC)
>
> -static void rxe_mem_init(int access, struct rxe_mem *mem)
> +static void rxe_mr_init(int access, struct rxe_mr *mr)
>  {
> -       u32 lkey = mem->pelem.index << 8 | rxe_get_key();
> +       u32 lkey = mr->pelem.index << 8 | rxe_get_key();
>         u32 rkey = (access & IB_ACCESS_REMOTE) ? lkey : 0;
>
> -       mem->ibmr.lkey          = lkey;
> -       mem->ibmr.rkey          = rkey;
> -       mem->state              = RXE_MEM_STATE_INVALID;
> -       mem->type               = RXE_MEM_TYPE_NONE;
> -       mem->map_shift          = ilog2(RXE_BUF_PER_MAP);
> +       mr->ibmr.lkey           = lkey;
> +       mr->ibmr.rkey           = rkey;
> +       mr->state               = RXE_MR_STATE_INVALID;
> +       mr->type                = RXE_MR_TYPE_NONE;
> +       mr->map_shift           = ilog2(RXE_BUF_PER_MAP);
>  }
>
> -void rxe_mem_cleanup(struct rxe_pool_entry *arg)
> +void rxe_mr_cleanup(struct rxe_pool_entry *arg)
>  {
> -       struct rxe_mem *mem = container_of(arg, typeof(*mem), pelem);
> +       struct rxe_mr *mr = container_of(arg, typeof(*mr), pelem);
>         int i;
>
> -       ib_umem_release(mem->umem);
> +       ib_umem_release(mr->umem);
>
> -       if (mem->map) {
> -               for (i = 0; i < mem->num_map; i++)
> -                       kfree(mem->map[i]);
> +       if (mr->map) {
> +               for (i = 0; i < mr->num_map; i++)
> +                       kfree(mr->map[i]);
>
> -               kfree(mem->map);
> +               kfree(mr->map);
>         }
>  }
>
> -static int rxe_mem_alloc(struct rxe_mem *mem, int num_buf)
> +static int rxe_mr_alloc(struct rxe_mr *mr, int num_buf)
>  {
>         int i;
>         int num_map;
> -       struct rxe_map **map = mem->map;
> +       struct rxe_map **map = mr->map;
>
>         num_map = (num_buf + RXE_BUF_PER_MAP - 1) / RXE_BUF_PER_MAP;
>
> -       mem->map = kmalloc_array(num_map, sizeof(*map), GFP_KERNEL);
> -       if (!mem->map)
> +       mr->map = kmalloc_array(num_map, sizeof(*map), GFP_KERNEL);
> +       if (!mr->map)
>                 goto err1;
>
>         for (i = 0; i < num_map; i++) {
> -               mem->map[i] = kmalloc(sizeof(**map), GFP_KERNEL);
> -               if (!mem->map[i])
> +               mr->map[i] = kmalloc(sizeof(**map), GFP_KERNEL);
> +               if (!mr->map[i])
>                         goto err2;
>         }
>
>         BUILD_BUG_ON(!is_power_of_2(RXE_BUF_PER_MAP));
>
> -       mem->map_shift  = ilog2(RXE_BUF_PER_MAP);
> -       mem->map_mask   = RXE_BUF_PER_MAP - 1;
> +       mr->map_shift   = ilog2(RXE_BUF_PER_MAP);
> +       mr->map_mask    = RXE_BUF_PER_MAP - 1;
>
> -       mem->num_buf = num_buf;
> -       mem->num_map = num_map;
> -       mem->max_buf = num_map * RXE_BUF_PER_MAP;
> +       mr->num_buf = num_buf;
> +       mr->num_map = num_map;
> +       mr->max_buf = num_map * RXE_BUF_PER_MAP;
>
>         return 0;
>
>  err2:
>         for (i--; i >= 0; i--)
> -               kfree(mem->map[i]);
> +               kfree(mr->map[i]);
>
> -       kfree(mem->map);
> +       kfree(mr->map);
>  err1:
>         return -ENOMEM;
>  }
>
> -void rxe_mem_init_dma(struct rxe_pd *pd,
> -                     int access, struct rxe_mem *mem)
> +void rxe_mr_init_dma(struct rxe_pd *pd,
> +                     int access, struct rxe_mr *mr)
>  {
> -       rxe_mem_init(access, mem);
> +       rxe_mr_init(access, mr);
>
> -       mem->ibmr.pd            = &pd->ibpd;
> -       mem->access             = access;
> -       mem->state              = RXE_MEM_STATE_VALID;
> -       mem->type               = RXE_MEM_TYPE_DMA;
> +       mr->ibmr.pd             = &pd->ibpd;
> +       mr->access              = access;
> +       mr->state               = RXE_MR_STATE_VALID;
> +       mr->type                = RXE_MR_TYPE_DMA;
>  }
>
> -int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
> +int rxe_mr_init_user(struct rxe_pd *pd, u64 start,
>                       u64 length, u64 iova, int access, struct ib_udata *udata,
> -                     struct rxe_mem *mem)
> +                     struct rxe_mr *mr)
>  {
>         struct rxe_map          **map;
>         struct rxe_phys_buf     *buf = NULL;
> @@ -142,23 +142,23 @@ int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
>                 goto err1;
>         }
>
> -       mem->umem = umem;
> +       mr->umem = umem;
>         num_buf = ib_umem_num_pages(umem);
>
> -       rxe_mem_init(access, mem);
> +       rxe_mr_init(access, mr);
>
> -       err = rxe_mem_alloc(mem, num_buf);
> +       err = rxe_mr_alloc(mr, num_buf);
>         if (err) {
> -               pr_warn("err %d from rxe_mem_alloc\n", err);
> +               pr_warn("err %d from rxe_mr_alloc\n", err);
>                 ib_umem_release(umem);
>                 goto err1;
>         }
>
> -       mem->page_shift         = PAGE_SHIFT;
> -       mem->page_mask = PAGE_SIZE - 1;
> +       mr->page_shift          = PAGE_SHIFT;
> +       mr->page_mask = PAGE_SIZE - 1;
>
>         num_buf                 = 0;
> -       map                     = mem->map;
> +       map                     = mr->map;
>         if (length > 0) {
>                 buf = map[0]->buf;
>
> @@ -185,15 +185,15 @@ int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
>                 }
>         }
>
> -       mem->ibmr.pd            = &pd->ibpd;
> -       mem->umem               = umem;
> -       mem->access             = access;
> -       mem->length             = length;
> -       mem->iova               = iova;
> -       mem->va                 = start;
> -       mem->offset             = ib_umem_offset(umem);
> -       mem->state              = RXE_MEM_STATE_VALID;
> -       mem->type               = RXE_MEM_TYPE_MR;
> +       mr->ibmr.pd             = &pd->ibpd;
> +       mr->umem                = umem;
> +       mr->access              = access;
> +       mr->length              = length;
> +       mr->iova                = iova;
> +       mr->va                  = start;
> +       mr->offset              = ib_umem_offset(umem);
> +       mr->state               = RXE_MR_STATE_VALID;
> +       mr->type                = RXE_MR_TYPE_MR;
>
>         return 0;
>
> @@ -201,24 +201,24 @@ int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
>         return err;
>  }
>
> -int rxe_mem_init_fast(struct rxe_pd *pd,
> -                     int max_pages, struct rxe_mem *mem)
> +int rxe_mr_init_fast(struct rxe_pd *pd,
> +                     int max_pages, struct rxe_mr *mr)
>  {
>         int err;
>
> -       rxe_mem_init(0, mem);
> +       rxe_mr_init(0, mr);
>
>         /* In fastreg, we also set the rkey */
> -       mem->ibmr.rkey = mem->ibmr.lkey;
> +       mr->ibmr.rkey = mr->ibmr.lkey;
>
> -       err = rxe_mem_alloc(mem, max_pages);
> +       err = rxe_mr_alloc(mr, max_pages);
>         if (err)
>                 goto err1;
>
> -       mem->ibmr.pd            = &pd->ibpd;
> -       mem->max_buf            = max_pages;
> -       mem->state              = RXE_MEM_STATE_FREE;
> -       mem->type               = RXE_MEM_TYPE_MR;
> +       mr->ibmr.pd             = &pd->ibpd;
> +       mr->max_buf             = max_pages;
> +       mr->state               = RXE_MR_STATE_FREE;
> +       mr->type                = RXE_MR_TYPE_MR;
>
>         return 0;
>
> @@ -227,27 +227,27 @@ int rxe_mem_init_fast(struct rxe_pd *pd,
>  }
>
>  static void lookup_iova(
> -       struct rxe_mem  *mem,
> +       struct rxe_mr   *mr,
>         u64                     iova,
>         int                     *m_out,
>         int                     *n_out,
>         size_t                  *offset_out)
>  {
> -       size_t                  offset = iova - mem->iova + mem->offset;
> +       size_t                  offset = iova - mr->iova + mr->offset;
>         int                     map_index;
>         int                     buf_index;
>         u64                     length;
>
> -       if (likely(mem->page_shift)) {
> -               *offset_out = offset & mem->page_mask;
> -               offset >>= mem->page_shift;
> -               *n_out = offset & mem->map_mask;
> -               *m_out = offset >> mem->map_shift;
> +       if (likely(mr->page_shift)) {
> +               *offset_out = offset & mr->page_mask;
> +               offset >>= mr->page_shift;
> +               *n_out = offset & mr->map_mask;
> +               *m_out = offset >> mr->map_shift;
>         } else {
>                 map_index = 0;
>                 buf_index = 0;
>
> -               length = mem->map[map_index]->buf[buf_index].size;
> +               length = mr->map[map_index]->buf[buf_index].size;
>
>                 while (offset >= length) {
>                         offset -= length;
> @@ -257,7 +257,7 @@ static void lookup_iova(
>                                 map_index++;
>                                 buf_index = 0;
>                         }
> -                       length = mem->map[map_index]->buf[buf_index].size;
> +                       length = mr->map[map_index]->buf[buf_index].size;
>                 }
>
>                 *m_out = map_index;
> @@ -266,48 +266,48 @@ static void lookup_iova(
>         }
>  }
>
> -void *iova_to_vaddr(struct rxe_mem *mem, u64 iova, int length)
> +void *iova_to_vaddr(struct rxe_mr *mr, u64 iova, int length)
>  {
>         size_t offset;
>         int m, n;
>         void *addr;
>
> -       if (mem->state != RXE_MEM_STATE_VALID) {
> -               pr_warn("mem not in valid state\n");
> +       if (mr->state != RXE_MR_STATE_VALID) {
> +               pr_warn("mr not in valid state\n");
>                 addr = NULL;
>                 goto out;
>         }
>
> -       if (!mem->map) {
> +       if (!mr->map) {
>                 addr = (void *)(uintptr_t)iova;
>                 goto out;
>         }
>
> -       if (mem_check_range(mem, iova, length)) {
> +       if (mr_check_range(mr, iova, length)) {
>                 pr_warn("range violation\n");
>                 addr = NULL;
>                 goto out;
>         }
>
> -       lookup_iova(mem, iova, &m, &n, &offset);
> +       lookup_iova(mr, iova, &m, &n, &offset);
>
> -       if (offset + length > mem->map[m]->buf[n].size) {
> +       if (offset + length > mr->map[m]->buf[n].size) {
>                 pr_warn("crosses page boundary\n");
>                 addr = NULL;
>                 goto out;
>         }
>
> -       addr = (void *)(uintptr_t)mem->map[m]->buf[n].addr + offset;
> +       addr = (void *)(uintptr_t)mr->map[m]->buf[n].addr + offset;
>
>  out:
>         return addr;
>  }
>
>  /* copy data from a range (vaddr, vaddr+length-1) to or from
> - * a mem object starting at iova. Compute incremental value of
> - * crc32 if crcp is not zero. caller must hold a reference to mem
> + * a mr object starting at iova. Compute incremental value of
> + * crc32 if crcp is not zero. caller must hold a reference to mr
>   */
> -int rxe_mem_copy(struct rxe_mem *mem, u64 iova, void *addr, int length,
> +int rxe_mr_copy(struct rxe_mr *mr, u64 iova, void *addr, int length,
>                  enum copy_direction dir, u32 *crcp)
>  {
>         int                     err;
> @@ -323,43 +323,43 @@ int rxe_mem_copy(struct rxe_mem *mem, u64 iova, void *addr, int length,
>         if (length == 0)
>                 return 0;
>
> -       if (mem->type == RXE_MEM_TYPE_DMA) {
> +       if (mr->type == RXE_MR_TYPE_DMA) {
>                 u8 *src, *dest;
>
> -               src  = (dir == to_mem_obj) ?
> +               src  = (dir == to_mr_obj) ?
>                         addr : ((void *)(uintptr_t)iova);
>
> -               dest = (dir == to_mem_obj) ?
> +               dest = (dir == to_mr_obj) ?
>                         ((void *)(uintptr_t)iova) : addr;
>
>                 memcpy(dest, src, length);
>
>                 if (crcp)
> -                       *crcp = rxe_crc32(to_rdev(mem->ibmr.device),
> +                       *crcp = rxe_crc32(to_rdev(mr->ibmr.device),
>                                         *crcp, dest, length);
>
>                 return 0;
>         }
>
> -       WARN_ON_ONCE(!mem->map);
> +       WARN_ON_ONCE(!mr->map);
>
> -       err = mem_check_range(mem, iova, length);
> +       err = mr_check_range(mr, iova, length);
>         if (err) {
>                 err = -EFAULT;
>                 goto err1;
>         }
>
> -       lookup_iova(mem, iova, &m, &i, &offset);
> +       lookup_iova(mr, iova, &m, &i, &offset);
>
> -       map     = mem->map + m;
> +       map     = mr->map + m;
>         buf     = map[0]->buf + i;
>
>         while (length > 0) {
>                 u8 *src, *dest;
>
>                 va      = (u8 *)(uintptr_t)buf->addr + offset;
> -               src  = (dir == to_mem_obj) ? addr : va;
> -               dest = (dir == to_mem_obj) ? va : addr;
> +               src  = (dir == to_mr_obj) ? addr : va;
> +               dest = (dir == to_mr_obj) ? va : addr;
>
>                 bytes   = buf->size - offset;
>
> @@ -369,7 +369,7 @@ int rxe_mem_copy(struct rxe_mem *mem, u64 iova, void *addr, int length,
>                 memcpy(dest, src, bytes);
>
>                 if (crcp)
> -                       crc = rxe_crc32(to_rdev(mem->ibmr.device),
> +                       crc = rxe_crc32(to_rdev(mr->ibmr.device),
>                                         crc, dest, bytes);
>
>                 length  -= bytes;
> @@ -411,7 +411,7 @@ int copy_data(
>         struct rxe_sge          *sge    = &dma->sge[dma->cur_sge];
>         int                     offset  = dma->sge_offset;
>         int                     resid   = dma->resid;
> -       struct rxe_mem          *mem    = NULL;
> +       struct rxe_mr           *mr     = NULL;
>         u64                     iova;
>         int                     err;
>
> @@ -424,8 +424,8 @@ int copy_data(
>         }
>
>         if (sge->length && (offset < sge->length)) {
> -               mem = lookup_mem(pd, access, sge->lkey, lookup_local);
> -               if (!mem) {
> +               mr = lookup_mr(pd, access, sge->lkey, lookup_local);
> +               if (!mr) {
>                         err = -EINVAL;
>                         goto err1;
>                 }
> @@ -435,9 +435,9 @@ int copy_data(
>                 bytes = length;
>
>                 if (offset >= sge->length) {
> -                       if (mem) {
> -                               rxe_drop_ref(mem);
> -                               mem = NULL;
> +                       if (mr) {
> +                               rxe_drop_ref(mr);
> +                               mr = NULL;
>                         }
>                         sge++;
>                         dma->cur_sge++;
> @@ -449,9 +449,9 @@ int copy_data(
>                         }
>
>                         if (sge->length) {
> -                               mem = lookup_mem(pd, access, sge->lkey,
> +                               mr = lookup_mr(pd, access, sge->lkey,
>                                                  lookup_local);
> -                               if (!mem) {
> +                               if (!mr) {
>                                         err = -EINVAL;
>                                         goto err1;
>                                 }
> @@ -466,7 +466,7 @@ int copy_data(
>                 if (bytes > 0) {
>                         iova = sge->addr + offset;
>
> -                       err = rxe_mem_copy(mem, iova, addr, bytes, dir, crcp);
> +                       err = rxe_mr_copy(mr, iova, addr, bytes, dir, crcp);
>                         if (err)
>                                 goto err2;
>
> @@ -480,14 +480,14 @@ int copy_data(
>         dma->sge_offset = offset;
>         dma->resid      = resid;
>
> -       if (mem)
> -               rxe_drop_ref(mem);
> +       if (mr)
> +               rxe_drop_ref(mr);
>
>         return 0;
>
>  err2:
> -       if (mem)
> -               rxe_drop_ref(mem);
> +       if (mr)
> +               rxe_drop_ref(mr);
>  err1:
>         return err;
>  }
> @@ -525,31 +525,31 @@ int advance_dma_data(struct rxe_dma_info *dma, unsigned int length)
>         return 0;
>  }
>
> -/* (1) find the mem (mr or mw) corresponding to lkey/rkey
> +/* (1) find the mr corresponding to lkey/rkey
>   *     depending on lookup_type
> - * (2) verify that the (qp) pd matches the mem pd
> - * (3) verify that the mem can support the requested access
> - * (4) verify that mem state is valid
> + * (2) verify that the (qp) pd matches the mr pd
> + * (3) verify that the mr can support the requested access
> + * (4) verify that mr state is valid
>   */
> -struct rxe_mem *lookup_mem(struct rxe_pd *pd, int access, u32 key,
> +struct rxe_mr *lookup_mr(struct rxe_pd *pd, int access, u32 key,
>                            enum lookup_type type)
>  {
> -       struct rxe_mem *mem;
> +       struct rxe_mr *mr;
>         struct rxe_dev *rxe = to_rdev(pd->ibpd.device);
>         int index = key >> 8;
>
> -       mem = rxe_pool_get_index(&rxe->mr_pool, index);
> -       if (!mem)
> +       mr = rxe_pool_get_index(&rxe->mr_pool, index);
> +       if (!mr)
>                 return NULL;
>
> -       if (unlikely((type == lookup_local && mr_lkey(mem) != key) ||
> -                    (type == lookup_remote && mr_rkey(mem) != key) ||
> -                    mr_pd(mem) != pd ||
> -                    (access && !(access & mem->access)) ||
> -                    mem->state != RXE_MEM_STATE_VALID)) {
> -               rxe_drop_ref(mem);
> -               mem = NULL;
> +       if (unlikely((type == lookup_local && mr_lkey(mr) != key) ||
> +                    (type == lookup_remote && mr_rkey(mr) != key) ||
> +                    mr_pd(mr) != pd ||
> +                    (access && !(access & mr->access)) ||
> +                    mr->state != RXE_MR_STATE_VALID)) {
> +               rxe_drop_ref(mr);
> +               mr = NULL;
>         }
>
> -       return mem;
> +       return mr;
>  }
> diff --git a/drivers/infiniband/sw/rxe/rxe_pool.c b/drivers/infiniband/sw/rxe/rxe_pool.c
> index 62fef162e6a1..e7ae060059b8 100644
> --- a/drivers/infiniband/sw/rxe/rxe_pool.c
> +++ b/drivers/infiniband/sw/rxe/rxe_pool.c
> @@ -8,8 +8,6 @@
>  #include "rxe_loc.h"
>
>  /* info about object pools
> - * note that mr and mw share a single index space
> - * so that one can map an lkey to the correct type of object
>   */
>  struct rxe_type_info rxe_type_info[RXE_NUM_TYPES] = {
>         [RXE_TYPE_UC] = {
> @@ -56,17 +54,17 @@ struct rxe_type_info rxe_type_info[RXE_NUM_TYPES] = {
>         },
>         [RXE_TYPE_MR] = {
>                 .name           = "rxe-mr",
> -               .size           = sizeof(struct rxe_mem),
> -               .elem_offset    = offsetof(struct rxe_mem, pelem),
> -               .cleanup        = rxe_mem_cleanup,
> +               .size           = sizeof(struct rxe_mr),
> +               .elem_offset    = offsetof(struct rxe_mr, pelem),
> +               .cleanup        = rxe_mr_cleanup,
>                 .flags          = RXE_POOL_INDEX,
>                 .max_index      = RXE_MAX_MR_INDEX,
>                 .min_index      = RXE_MIN_MR_INDEX,
>         },
>         [RXE_TYPE_MW] = {
>                 .name           = "rxe-mw",
> -               .size           = sizeof(struct rxe_mem),
> -               .elem_offset    = offsetof(struct rxe_mem, pelem),
> +               .size           = sizeof(struct rxe_mw),
> +               .elem_offset    = offsetof(struct rxe_mw, pelem),
>                 .flags          = RXE_POOL_INDEX,
>                 .max_index      = RXE_MAX_MW_INDEX,
>                 .min_index      = RXE_MIN_MW_INDEX,
> diff --git a/drivers/infiniband/sw/rxe/rxe_req.c b/drivers/infiniband/sw/rxe/rxe_req.c
> index d4917646641a..4f4c82872378 100644
> --- a/drivers/infiniband/sw/rxe/rxe_req.c
> +++ b/drivers/infiniband/sw/rxe/rxe_req.c
> @@ -465,7 +465,7 @@ static int fill_packet(struct rxe_qp *qp, struct rxe_send_wqe *wqe,
>                 } else {
>                         err = copy_data(qp->pd, 0, &wqe->dma,
>                                         payload_addr(pkt), paylen,
> -                                       from_mem_obj,
> +                                       from_mr_obj,
>                                         &crc);
>                         if (err)
>                                 return err;
> @@ -597,7 +597,7 @@ int rxe_requester(void *arg)
>         if (wqe->mask & WR_REG_MASK) {
>                 if (wqe->wr.opcode == IB_WR_LOCAL_INV) {
>                         struct rxe_dev *rxe = to_rdev(qp->ibqp.device);
> -                       struct rxe_mem *rmr;
> +                       struct rxe_mr *rmr;
>
>                         rmr = rxe_pool_get_index(&rxe->mr_pool,
>                                                  wqe->wr.ex.invalidate_rkey >> 8);
> @@ -608,14 +608,14 @@ int rxe_requester(void *arg)
>                                 wqe->status = IB_WC_MW_BIND_ERR;
>                                 goto exit;
>                         }
> -                       rmr->state = RXE_MEM_STATE_FREE;
> +                       rmr->state = RXE_MR_STATE_FREE;
>                         rxe_drop_ref(rmr);
>                         wqe->state = wqe_state_done;
>                         wqe->status = IB_WC_SUCCESS;
>                 } else if (wqe->wr.opcode == IB_WR_REG_MR) {
> -                       struct rxe_mem *rmr = to_rmr(wqe->wr.wr.reg.mr);
> +                       struct rxe_mr *rmr = to_rmr(wqe->wr.wr.reg.mr);
>
> -                       rmr->state = RXE_MEM_STATE_VALID;
> +                       rmr->state = RXE_MR_STATE_VALID;
>                         rmr->access = wqe->wr.wr.reg.access;
>                         rmr->ibmr.lkey = wqe->wr.wr.reg.key;
>                         rmr->ibmr.rkey = wqe->wr.wr.reg.key;
> diff --git a/drivers/infiniband/sw/rxe/rxe_resp.c b/drivers/infiniband/sw/rxe/rxe_resp.c
> index 5a098083a9d2..4da05751c79a 100644
> --- a/drivers/infiniband/sw/rxe/rxe_resp.c
> +++ b/drivers/infiniband/sw/rxe/rxe_resp.c
> @@ -390,7 +390,7 @@ static enum resp_states check_length(struct rxe_qp *qp,
>  static enum resp_states check_rkey(struct rxe_qp *qp,
>                                    struct rxe_pkt_info *pkt)
>  {
> -       struct rxe_mem *mem = NULL;
> +       struct rxe_mr *mr = NULL;
>         u64 va;
>         u32 rkey;
>         u32 resid;
> @@ -429,18 +429,18 @@ static enum resp_states check_rkey(struct rxe_qp *qp,
>         resid   = qp->resp.resid;
>         pktlen  = payload_size(pkt);
>
> -       mem = lookup_mem(qp->pd, access, rkey, lookup_remote);
> -       if (!mem) {
> +       mr = lookup_mr(qp->pd, access, rkey, lookup_remote);
> +       if (!mr) {
>                 state = RESPST_ERR_RKEY_VIOLATION;
>                 goto err;
>         }
>
> -       if (unlikely(mem->state == RXE_MEM_STATE_FREE)) {
> +       if (unlikely(mr->state == RXE_MR_STATE_FREE)) {
>                 state = RESPST_ERR_RKEY_VIOLATION;
>                 goto err;
>         }
>
> -       if (mem_check_range(mem, va, resid)) {
> +       if (mr_check_range(mr, va, resid)) {
>                 state = RESPST_ERR_RKEY_VIOLATION;
>                 goto err;
>         }
> @@ -468,12 +468,12 @@ static enum resp_states check_rkey(struct rxe_qp *qp,
>
>         WARN_ON_ONCE(qp->resp.mr);
>
> -       qp->resp.mr = mem;
> +       qp->resp.mr = mr;
>         return RESPST_EXECUTE;
>
>  err:
> -       if (mem)
> -               rxe_drop_ref(mem);
> +       if (mr)
> +               rxe_drop_ref(mr);
>         return state;
>  }
>
> @@ -483,7 +483,7 @@ static enum resp_states send_data_in(struct rxe_qp *qp, void *data_addr,
>         int err;
>
>         err = copy_data(qp->pd, IB_ACCESS_LOCAL_WRITE, &qp->resp.wqe->dma,
> -                       data_addr, data_len, to_mem_obj, NULL);
> +                       data_addr, data_len, to_mr_obj, NULL);
>         if (unlikely(err))
>                 return (err == -ENOSPC) ? RESPST_ERR_LENGTH
>                                         : RESPST_ERR_MALFORMED_WQE;
> @@ -498,8 +498,8 @@ static enum resp_states write_data_in(struct rxe_qp *qp,
>         int     err;
>         int data_len = payload_size(pkt);
>
> -       err = rxe_mem_copy(qp->resp.mr, qp->resp.va, payload_addr(pkt),
> -                          data_len, to_mem_obj, NULL);
> +       err = rxe_mr_copy(qp->resp.mr, qp->resp.va, payload_addr(pkt),
> +                          data_len, to_mr_obj, NULL);
>         if (err) {
>                 rc = RESPST_ERR_RKEY_VIOLATION;
>                 goto out;
> @@ -521,9 +521,9 @@ static enum resp_states process_atomic(struct rxe_qp *qp,
>         u64 iova = atmeth_va(pkt);
>         u64 *vaddr;
>         enum resp_states ret;
> -       struct rxe_mem *mr = qp->resp.mr;
> +       struct rxe_mr *mr = qp->resp.mr;
>
> -       if (mr->state != RXE_MEM_STATE_VALID) {
> +       if (mr->state != RXE_MR_STATE_VALID) {
>                 ret = RESPST_ERR_RKEY_VIOLATION;
>                 goto out;
>         }
> @@ -700,8 +700,8 @@ static enum resp_states read_reply(struct rxe_qp *qp,
>         if (!skb)
>                 return RESPST_ERR_RNR;
>
> -       err = rxe_mem_copy(res->read.mr, res->read.va, payload_addr(&ack_pkt),
> -                          payload, from_mem_obj, &icrc);
> +       err = rxe_mr_copy(res->read.mr, res->read.va, payload_addr(&ack_pkt),
> +                          payload, from_mr_obj, &icrc);
>         if (err)
>                 pr_err("Failed copying memory\n");
>
> @@ -878,7 +878,7 @@ static enum resp_states do_complete(struct rxe_qp *qp,
>                         }
>
>                         if (pkt->mask & RXE_IETH_MASK) {
> -                               struct rxe_mem *rmr;
> +                               struct rxe_mr *rmr;
>
>                                 wc->wc_flags |= IB_WC_WITH_INVALIDATE;
>                                 wc->ex.invalidate_rkey = ieth_rkey(pkt);
> @@ -890,7 +890,7 @@ static enum resp_states do_complete(struct rxe_qp *qp,
>                                                wc->ex.invalidate_rkey);
>                                         return RESPST_ERROR;
>                                 }
> -                               rmr->state = RXE_MEM_STATE_FREE;
> +                               rmr->state = RXE_MR_STATE_FREE;
>                                 rxe_drop_ref(rmr);
>                         }
>
> diff --git a/drivers/infiniband/sw/rxe/rxe_verbs.c b/drivers/infiniband/sw/rxe/rxe_verbs.c
> index 7483a33bcec5..bfec57e0825c 100644
> --- a/drivers/infiniband/sw/rxe/rxe_verbs.c
> +++ b/drivers/infiniband/sw/rxe/rxe_verbs.c
> @@ -865,7 +865,7 @@ static struct ib_mr *rxe_get_dma_mr(struct ib_pd *ibpd, int access)
>  {
>         struct rxe_dev *rxe = to_rdev(ibpd->device);
>         struct rxe_pd *pd = to_rpd(ibpd);
> -       struct rxe_mem *mr;
> +       struct rxe_mr *mr;
>
>         mr = rxe_alloc(&rxe->mr_pool);
>         if (!mr)
> @@ -873,7 +873,7 @@ static struct ib_mr *rxe_get_dma_mr(struct ib_pd *ibpd, int access)
>
>         rxe_add_index(mr);
>         rxe_add_ref(pd);
> -       rxe_mem_init_dma(pd, access, mr);
> +       rxe_mr_init_dma(pd, access, mr);
>
>         return &mr->ibmr;
>  }
> @@ -887,7 +887,7 @@ static struct ib_mr *rxe_reg_user_mr(struct ib_pd *ibpd,
>         int err;
>         struct rxe_dev *rxe = to_rdev(ibpd->device);
>         struct rxe_pd *pd = to_rpd(ibpd);
> -       struct rxe_mem *mr;
> +       struct rxe_mr *mr;
>
>         mr = rxe_alloc(&rxe->mr_pool);
>         if (!mr) {
> @@ -899,7 +899,7 @@ static struct ib_mr *rxe_reg_user_mr(struct ib_pd *ibpd,
>
>         rxe_add_ref(pd);
>
> -       err = rxe_mem_init_user(pd, start, length, iova,
> +       err = rxe_mr_init_user(pd, start, length, iova,
>                                 access, udata, mr);
>         if (err)
>                 goto err3;
> @@ -916,9 +916,9 @@ static struct ib_mr *rxe_reg_user_mr(struct ib_pd *ibpd,
>
>  static int rxe_dereg_mr(struct ib_mr *ibmr, struct ib_udata *udata)
>  {
> -       struct rxe_mem *mr = to_rmr(ibmr);
> +       struct rxe_mr *mr = to_rmr(ibmr);
>
> -       mr->state = RXE_MEM_STATE_ZOMBIE;
> +       mr->state = RXE_MR_STATE_ZOMBIE;
>         rxe_drop_ref(mr_pd(mr));
>         rxe_drop_index(mr);
>         rxe_drop_ref(mr);
> @@ -930,7 +930,7 @@ static struct ib_mr *rxe_alloc_mr(struct ib_pd *ibpd, enum ib_mr_type mr_type,
>  {
>         struct rxe_dev *rxe = to_rdev(ibpd->device);
>         struct rxe_pd *pd = to_rpd(ibpd);
> -       struct rxe_mem *mr;
> +       struct rxe_mr *mr;
>         int err;
>
>         if (mr_type != IB_MR_TYPE_MEM_REG)
> @@ -946,7 +946,7 @@ static struct ib_mr *rxe_alloc_mr(struct ib_pd *ibpd, enum ib_mr_type mr_type,
>
>         rxe_add_ref(pd);
>
> -       err = rxe_mem_init_fast(pd, max_num_sg, mr);
> +       err = rxe_mr_init_fast(pd, max_num_sg, mr);
>         if (err)
>                 goto err2;
>
> @@ -962,7 +962,7 @@ static struct ib_mr *rxe_alloc_mr(struct ib_pd *ibpd, enum ib_mr_type mr_type,
>
>  static int rxe_set_page(struct ib_mr *ibmr, u64 addr)
>  {
> -       struct rxe_mem *mr = to_rmr(ibmr);
> +       struct rxe_mr *mr = to_rmr(ibmr);
>         struct rxe_map *map;
>         struct rxe_phys_buf *buf;
>
> @@ -982,7 +982,7 @@ static int rxe_set_page(struct ib_mr *ibmr, u64 addr)
>  static int rxe_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg,
>                          int sg_nents, unsigned int *sg_offset)
>  {
> -       struct rxe_mem *mr = to_rmr(ibmr);
> +       struct rxe_mr *mr = to_rmr(ibmr);
>         int n;
>
>         mr->nbuf = 0;
> diff --git a/drivers/infiniband/sw/rxe/rxe_verbs.h b/drivers/infiniband/sw/rxe/rxe_verbs.h
> index 79e0a5a878da..806d2735ec9f 100644
> --- a/drivers/infiniband/sw/rxe/rxe_verbs.h
> +++ b/drivers/infiniband/sw/rxe/rxe_verbs.h
> @@ -39,7 +39,7 @@ struct rxe_ucontext {
>  };
>
>  struct rxe_pd {
> -       struct ib_pd            ibpd;
> +       struct ib_pd            ibpd;
>         struct rxe_pool_entry   pelem;
>  };
>
> @@ -156,7 +156,7 @@ struct resp_res {
>                         struct sk_buff  *skb;
>                 } atomic;
>                 struct {
> -                       struct rxe_mem  *mr;
> +                       struct rxe_mr   *mr;
>                         u64             va_org;
>                         u32             rkey;
>                         u32             length;
> @@ -183,7 +183,7 @@ struct rxe_resp_info {
>
>         /* RDMA read / atomic only */
>         u64                     va;
> -       struct rxe_mem          *mr;
> +       struct rxe_mr           *mr;
>         u32                     resid;
>         u32                     rkey;
>         u32                     length;
> @@ -262,42 +262,39 @@ struct rxe_qp {
>         struct execute_work     cleanup_work;
>  };
>
> -enum rxe_mem_state {
> -       RXE_MEM_STATE_ZOMBIE,
> -       RXE_MEM_STATE_INVALID,
> -       RXE_MEM_STATE_FREE,
> -       RXE_MEM_STATE_VALID,
> +enum rxe_mr_state {
> +       RXE_MR_STATE_ZOMBIE,
> +       RXE_MR_STATE_INVALID,
> +       RXE_MR_STATE_FREE,
> +       RXE_MR_STATE_VALID,
>  };
>
> -enum rxe_mem_type {
> -       RXE_MEM_TYPE_NONE,
> -       RXE_MEM_TYPE_DMA,
> -       RXE_MEM_TYPE_MR,
> -       RXE_MEM_TYPE_MW,
> +enum rxe_mr_type {
> +       RXE_MR_TYPE_NONE,
> +       RXE_MR_TYPE_DMA,
> +       RXE_MR_TYPE_MR,
> +       RXE_MR_TYPE_MW,
>  };
>
>  #define RXE_BUF_PER_MAP                (PAGE_SIZE / sizeof(struct rxe_phys_buf))
>
>  struct rxe_phys_buf {
> -       u64      addr;
> -       u64      size;
> +       u64     addr;
> +       u64     size;
>  };
>
>  struct rxe_map {
>         struct rxe_phys_buf     buf[RXE_BUF_PER_MAP];
>  };
>
> -struct rxe_mem {
> +struct rxe_mr {
>         struct rxe_pool_entry   pelem;
> -       union {
> -               struct ib_mr            ibmr;
> -               struct ib_mw            ibmw;
> -       };
> +       struct ib_mr            ibmr;
>
>         struct ib_umem          *umem;
>
> -       enum rxe_mem_state      state;
> -       enum rxe_mem_type       type;
> +       enum rxe_mr_state       state;
> +       enum rxe_mr_type        type;
>         u64                     va;
>         u64                     iova;
>         size_t                  length;
> @@ -318,6 +315,24 @@ struct rxe_mem {
>         struct rxe_map          **map;
>  };
>
> +enum rxe_mw_state {
> +       RXE_MW_STATE_INVALID    = RXE_MR_STATE_INVALID,
> +       RXE_MW_STATE_FREE       = RXE_MR_STATE_FREE,
> +       RXE_MW_STATE_VALID      = RXE_MR_STATE_VALID,
> +};
> +
> +struct rxe_mw {
> +       struct rxe_pool_entry   pelem;
> +       struct ib_mw            ibmw;
> +       struct rxe_qp           *qp;    /* type 2B only */
> +       struct rxe_mr           *mr;
> +       spinlock_t              lock;
> +       enum rxe_mw_state       state;
> +       u32                     access;
> +       u64                     addr;
> +       u64                     length;
> +};
> +
>  struct rxe_mc_grp {
>         struct rxe_pool_entry   pelem;
>         spinlock_t              mcg_lock; /* guard group */
> @@ -422,27 +437,27 @@ static inline struct rxe_cq *to_rcq(struct ib_cq *cq)
>         return cq ? container_of(cq, struct rxe_cq, ibcq) : NULL;
>  }
>
> -static inline struct rxe_mem *to_rmr(struct ib_mr *mr)
> +static inline struct rxe_mr *to_rmr(struct ib_mr *mr)
>  {
> -       return mr ? container_of(mr, struct rxe_mem, ibmr) : NULL;
> +       return mr ? container_of(mr, struct rxe_mr, ibmr) : NULL;
>  }
>
> -static inline struct rxe_mem *to_rmw(struct ib_mw *mw)
> +static inline struct rxe_mw *to_rmw(struct ib_mw *mw)
>  {
> -       return mw ? container_of(mw, struct rxe_mem, ibmw) : NULL;
> +       return mw ? container_of(mw, struct rxe_mw, ibmw) : NULL;
>  }
>
> -static inline struct rxe_pd *mr_pd(struct rxe_mem *mr)
> +static inline struct rxe_pd *mr_pd(struct rxe_mr *mr)
>  {
>         return to_rpd(mr->ibmr.pd);
>  }
>
> -static inline u32 mr_lkey(struct rxe_mem *mr)
> +static inline u32 mr_lkey(struct rxe_mr *mr)
>  {
>         return mr->ibmr.lkey;
>  }
>
> -static inline u32 mr_rkey(struct rxe_mem *mr)
> +static inline u32 mr_rkey(struct rxe_mr *mr)
>  {
>         return mr->ibmr.rkey;
>  }
> --
> 2.27.0
>



[Index of Archives]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Photo]     [Yosemite News]     [Yosemite Photos]     [Linux Kernel]     [Linux SCSI]     [XFree86]

  Powered by Linux