On 3/23/21 6:14 AM, Zhu Yanjun wrote:
> 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.
>>
>> 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);t are different from MRs. One is that the rkey for an MW can
change over its lifetime.
>> 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_qp *qp; /* type 2B only */
> struct rxe_mr *mr;
> spinlock_t lock;
> enum rxe_mw_state state;
> u32 access;
> u64 addr;
> u64 length;
>
> The above member variables are not used in your commit. Why keep them
> in this struct rxe_mw?
>
> Zhu Yanjun
>
There is more to come. The goal here is to implement MW and peeking ahead
MWs need each of those fields. As soon as this change gets accepted I will start
adding code to implement the MW verbs APIs.
bob
>> +
>> 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
>>
