mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-04 10:40:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

RDMA/efa: Add support for dmabuf memory regions

Browse source 
Implement a dmabuf importer for the EFA driver. As ODP is not supported,
the pinned dmabuf are used to prevent the move_notify callback from being
called.

Link: https://lore.kernel.org/r/20211012120903.96933-4-galpress@amazon.com
Signed-off-by: Gal Pressman <galpress@amazon.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
This commit is contained in:
Gal Pressman 2021-10-12 15:09:03 +03:00 committed by Jason Gunthorpe
parent 1e4df4a21c
commit 66f4817b57
3 changed files with 101 additions and 31 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/infiniband/hw/efa/efa.h
View file

@ -154,6 +154,10 @@ int efa_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr,
struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length, struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
u64 virt_addr, int access_flags, u64 virt_addr, int access_flags,
struct ib_udata *udata); struct ib_udata *udata);
struct ib_mr *efa_reg_user_mr_dmabuf(struct ib_pd *ibpd, u64 start,
u64 length, u64 virt_addr,
int fd, int access_flags,
struct ib_udata *udata);
int efa_dereg_mr(struct ib_mr *ibmr, struct ib_udata *udata); int efa_dereg_mr(struct ib_mr *ibmr, struct ib_udata *udata);
int efa_get_port_immutable(struct ib_device *ibdev, u32 port_num, int efa_get_port_immutable(struct ib_device *ibdev, u32 port_num,
struct ib_port_immutable *immutable); struct ib_port_immutable *immutable);

1
drivers/infiniband/hw/efa/efa_main.c
View file

@ -380,6 +380,7 @@ static const struct ib_device_ops efa_dev_ops = {
.query_port = efa_query_port, .query_port = efa_query_port,
.query_qp = efa_query_qp, .query_qp = efa_query_qp,
.reg_user_mr = efa_reg_mr, .reg_user_mr = efa_reg_mr,
.reg_user_mr_dmabuf = efa_reg_user_mr_dmabuf,
INIT_RDMA_OBJ_SIZE(ib_ah, efa_ah, ibah), INIT_RDMA_OBJ_SIZE(ib_ah, efa_ah, ibah),
INIT_RDMA_OBJ_SIZE(ib_cq, efa_cq, ibcq), INIT_RDMA_OBJ_SIZE(ib_cq, efa_cq, ibcq),

123
drivers/infiniband/hw/efa/efa_verbs.c
View file

@ -3,6 +3,8 @@
* Copyright 2018-2021 Amazon.com, Inc. or its affiliates. All rights reserved. * Copyright 2018-2021 Amazon.com, Inc. or its affiliates. All rights reserved.
*/ */
#include <linux/dma-buf.h>
#include <linux/dma-resv.h>
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/log2.h> #include <linux/log2.h>
@ -1544,26 +1546,18 @@ static int efa_create_pbl(struct efa_dev *dev,
return 0; return 0;
} }
struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length, static struct efa_mr *efa_alloc_mr(struct ib_pd *ibpd, int access_flags,
u64 virt_addr, int access_flags,
struct ib_udata *udata) struct ib_udata *udata)
{ {
struct efa_dev *dev = to_edev(ibpd->device); struct efa_dev *dev = to_edev(ibpd->device);
struct efa_com_reg_mr_params params = {};
struct efa_com_reg_mr_result result = {};
struct pbl_context pbl;
int supp_access_flags; int supp_access_flags;
unsigned int pg_sz;
struct efa_mr *mr; struct efa_mr *mr;
int inline_size;
int err;
if (udata && udata->inlen && if (udata && udata->inlen &&
!ib_is_udata_cleared(udata, 0, sizeof(udata->inlen))) { !ib_is_udata_cleared(udata, 0, sizeof(udata->inlen))) {
ibdev_dbg(&dev->ibdev, ibdev_dbg(&dev->ibdev,
"Incompatible ABI params, udata not cleared\n"); "Incompatible ABI params, udata not cleared\n");
err = -EINVAL; return ERR_PTR(-EINVAL);
goto err_out;
} }
supp_access_flags = supp_access_flags =
@ -1575,23 +1569,26 @@ struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
ibdev_dbg(&dev->ibdev, ibdev_dbg(&dev->ibdev,
"Unsupported access flags[%#x], supported[%#x]\n", "Unsupported access flags[%#x], supported[%#x]\n",
access_flags, supp_access_flags); access_flags, supp_access_flags);
err = -EOPNOTSUPP; return ERR_PTR(-EOPNOTSUPP);
goto err_out;
} }
mr = kzalloc(sizeof(*mr), GFP_KERNEL); mr = kzalloc(sizeof(*mr), GFP_KERNEL);
if (!mr) { if (!mr)
err = -ENOMEM; return ERR_PTR(-ENOMEM);
goto err_out;
return mr;
} }
mr->umem = ib_umem_get(ibpd->device, start, length, access_flags); static int efa_register_mr(struct ib_pd *ibpd, struct efa_mr *mr, u64 start,
if (IS_ERR(mr->umem)) { u64 length, u64 virt_addr, int access_flags)
err = PTR_ERR(mr->umem); {
ibdev_dbg(&dev->ibdev, struct efa_dev *dev = to_edev(ibpd->device);
"Failed to pin and map user space memory[%d]\n", err); struct efa_com_reg_mr_params params = {};
goto err_free; struct efa_com_reg_mr_result result = {};
} struct pbl_context pbl;
unsigned int pg_sz;
int inline_size;
int err;
params.pd = to_epd(ibpd)->pdn; params.pd = to_epd(ibpd)->pdn;
params.iova = virt_addr; params.iova = virt_addr;
@ -1602,10 +1599,9 @@ struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
dev->dev_attr.page_size_cap, dev->dev_attr.page_size_cap,
virt_addr); virt_addr);
if (!pg_sz) { if (!pg_sz) {
err = -EOPNOTSUPP;
ibdev_dbg(&dev->ibdev, "Failed to find a suitable page size in page_size_cap %#llx\n", ibdev_dbg(&dev->ibdev, "Failed to find a suitable page size in page_size_cap %#llx\n",
dev->dev_attr.page_size_cap); dev->dev_attr.page_size_cap);
goto err_unmap; return -EOPNOTSUPP;
} }
params.page_shift = order_base_2(pg_sz); params.page_shift = order_base_2(pg_sz);
@ -1619,21 +1615,21 @@ struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
if (params.page_num <= inline_size) { if (params.page_num <= inline_size) {
err = efa_create_inline_pbl(dev, mr, &params); err = efa_create_inline_pbl(dev, mr, &params);
if (err) if (err)
goto err_unmap; return err;
err = efa_com_register_mr(&dev->edev, &params, &result); err = efa_com_register_mr(&dev->edev, &params, &result);
if (err) if (err)
goto err_unmap; return err;
} else { } else {
err = efa_create_pbl(dev, &pbl, mr, &params); err = efa_create_pbl(dev, &pbl, mr, &params);
if (err) if (err)
goto err_unmap; return err;
err = efa_com_register_mr(&dev->edev, &params, &result); err = efa_com_register_mr(&dev->edev, &params, &result);
pbl_destroy(dev, &pbl); pbl_destroy(dev, &pbl);
if (err) if (err)
goto err_unmap; return err;
} }
mr->ibmr.lkey = result.l_key; mr->ibmr.lkey = result.l_key;
@ -1641,9 +1637,78 @@ struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
mr->ibmr.length = length; mr->ibmr.length = length;
ibdev_dbg(&dev->ibdev, "Registered mr[%d]\n", mr->ibmr.lkey); ibdev_dbg(&dev->ibdev, "Registered mr[%d]\n", mr->ibmr.lkey);
return 0;
}
struct ib_mr *efa_reg_user_mr_dmabuf(struct ib_pd *ibpd, u64 start,
u64 length, u64 virt_addr,
int fd, int access_flags,
struct ib_udata *udata)
{
struct efa_dev *dev = to_edev(ibpd->device);
struct ib_umem_dmabuf *umem_dmabuf;
struct efa_mr *mr;
int err;
mr = efa_alloc_mr(ibpd, access_flags, udata);
if (IS_ERR(mr)) {
err = PTR_ERR(mr);
goto err_out;
}
umem_dmabuf = ib_umem_dmabuf_get_pinned(ibpd->device, start, length, fd,
access_flags);
if (IS_ERR(umem_dmabuf)) {
err = PTR_ERR(umem_dmabuf);
ibdev_dbg(&dev->ibdev, "Failed to get dmabuf umem[%d]\n", err);
goto err_free;
}
mr->umem = &umem_dmabuf->umem;
err = efa_register_mr(ibpd, mr, start, length, virt_addr, access_flags);
if (err)
goto err_release;
return &mr->ibmr; return &mr->ibmr;
err_unmap: err_release:
ib_umem_release(mr->umem);
err_free:
kfree(mr);
err_out:
atomic64_inc(&dev->stats.reg_mr_err);
return ERR_PTR(err);
}
struct ib_mr *efa_reg_mr(struct ib_pd *ibpd, u64 start, u64 length,
u64 virt_addr, int access_flags,
struct ib_udata *udata)
{
struct efa_dev *dev = to_edev(ibpd->device);
struct efa_mr *mr;
int err;
mr = efa_alloc_mr(ibpd, access_flags, udata);
if (IS_ERR(mr)) {
err = PTR_ERR(mr);
goto err_out;
}
mr->umem = ib_umem_get(ibpd->device, start, length, access_flags);
if (IS_ERR(mr->umem)) {
err = PTR_ERR(mr->umem);
ibdev_dbg(&dev->ibdev,
"Failed to pin and map user space memory[%d]\n", err);
goto err_free;
}
err = efa_register_mr(ibpd, mr, start, length, virt_addr, access_flags);
if (err)
goto err_release;
return &mr->ibmr;
err_release:
ib_umem_release(mr->umem); ib_umem_release(mr->umem);
err_free: err_free:
kfree(mr); kfree(mr);