lkml.org 
[lkml]   [2023]   [Oct]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v5 09/10] iommufd/selftest: Add nested domain allocation for mock domain
    Date
    From: Nicolin Chen <nicolinc@nvidia.com>

    Add nested domain support in the ->domain_alloc_user op with some proper
    sanity checks. Then, add a domain_nested_ops for all nested domains and
    split the get_md_pagetable helper into paging and nested helpers.

    Also, add an iotlb as a testing property of a nested domain.

    Signed-off-by: Nicolin Chen <nicolinc@nvidia.com>
    Signed-off-by: Yi Liu <yi.l.liu@intel.com>
    ---
    drivers/iommu/iommufd/iommufd_test.h | 18 ++++
    drivers/iommu/iommufd/selftest.c | 135 +++++++++++++++++++++++----
    2 files changed, 133 insertions(+), 20 deletions(-)

    diff --git a/drivers/iommu/iommufd/iommufd_test.h b/drivers/iommu/iommufd/iommufd_test.h
    index 3f3644375bf1..440ec3d64099 100644
    --- a/drivers/iommu/iommufd/iommufd_test.h
    +++ b/drivers/iommu/iommufd/iommufd_test.h
    @@ -40,6 +40,11 @@ enum {
    MOCK_FLAGS_ACCESS_CREATE_NEEDS_PIN_PAGES = 1 << 0,
    };

    +enum {
    + MOCK_NESTED_DOMAIN_IOTLB_ID_MAX = 3,
    + MOCK_NESTED_DOMAIN_IOTLB_NUM = 4,
    +};
    +
    struct iommu_test_cmd {
    __u32 size;
    __u32 op;
    @@ -109,4 +114,17 @@ struct iommu_test_hw_info {
    __u32 test_reg;
    };

    +/* Should not be equal to any defined value in enum iommu_hwpt_data_type */
    +#define IOMMU_HWPT_DATA_SELFTEST 0xdead
    +
    +/**
    + * struct iommu_hwpt_selftest
    + *
    + * @iotlb: default mock iotlb value, IOMMU_TEST_IOTLB_DEFAULT
    + */
    +struct iommu_hwpt_selftest {
    +#define IOMMU_TEST_IOTLB_DEFAULT 0xbadbeef
    + __u32 iotlb;
    +};
    +
    #endif
    diff --git a/drivers/iommu/iommufd/selftest.c b/drivers/iommu/iommufd/selftest.c
    index eca5b1d0919d..5f513c5d6876 100644
    --- a/drivers/iommu/iommufd/selftest.c
    +++ b/drivers/iommu/iommufd/selftest.c
    @@ -90,6 +90,12 @@ struct mock_iommu_domain {
    struct xarray pfns;
    };

    +struct mock_iommu_domain_nested {
    + struct iommu_domain domain;
    + struct mock_iommu_domain *parent;
    + u32 iotlb[MOCK_NESTED_DOMAIN_IOTLB_NUM];
    +};
    +
    enum selftest_obj_type {
    TYPE_IDEV,
    };
    @@ -147,20 +153,16 @@ static void *mock_domain_hw_info(struct device *dev, u32 *length, u32 *type)
    }

    static const struct iommu_ops mock_ops;
    +static struct iommu_domain_ops domain_nested_ops;

    -static struct iommu_domain *mock_domain_alloc(unsigned int iommu_domain_type)
    +static struct iommu_domain *
    +__mock_domain_alloc_paging(unsigned int iommu_domain_type)
    {
    struct mock_iommu_domain *mock;

    - if (iommu_domain_type == IOMMU_DOMAIN_BLOCKED)
    - return &mock_blocking_domain;
    -
    - if (iommu_domain_type != IOMMU_DOMAIN_UNMANAGED)
    - return NULL;
    -
    mock = kzalloc(sizeof(*mock), GFP_KERNEL);
    if (!mock)
    - return NULL;
    + return ERR_PTR(-ENOMEM);
    mock->domain.geometry.aperture_start = MOCK_APERTURE_START;
    mock->domain.geometry.aperture_end = MOCK_APERTURE_LAST;
    mock->domain.pgsize_bitmap = MOCK_IO_PAGE_SIZE;
    @@ -170,20 +172,72 @@ static struct iommu_domain *mock_domain_alloc(unsigned int iommu_domain_type)
    return &mock->domain;
    }

    +static struct iommu_domain *
    +__mock_domain_alloc_nested(struct mock_iommu_domain *mock_parent,
    + const struct iommu_hwpt_selftest *user_cfg)
    +{
    + struct mock_iommu_domain_nested *mock_nested;
    + int i;
    +
    + mock_nested = kzalloc(sizeof(*mock_nested), GFP_KERNEL);
    + if (!mock_nested)
    + return ERR_PTR(-ENOMEM);
    + mock_nested->parent = mock_parent;
    + mock_nested->domain.ops = &domain_nested_ops;
    + mock_nested->domain.type = IOMMU_DOMAIN_NESTED;
    + for (i = 0; i < MOCK_NESTED_DOMAIN_IOTLB_NUM; i++)
    + mock_nested->iotlb[i] = user_cfg->iotlb;
    + return &mock_nested->domain;
    +}
    +
    +static struct iommu_domain *mock_domain_alloc(unsigned int iommu_domain_type)
    +{
    + struct iommu_domain *domain;
    +
    + if (iommu_domain_type == IOMMU_DOMAIN_BLOCKED)
    + return &mock_blocking_domain;
    + if (iommu_domain_type != IOMMU_DOMAIN_UNMANAGED)
    + return NULL;
    + domain = __mock_domain_alloc_paging(iommu_domain_type);
    + if (IS_ERR(domain))
    + domain = NULL;
    + return domain;
    +}
    +
    static struct iommu_domain *
    mock_domain_alloc_user(struct device *dev, u32 flags,
    struct iommu_domain *parent,
    const struct iommu_user_data *user_data)
    {
    - struct iommu_domain *domain;
    + struct mock_iommu_domain *mock_parent;
    + struct iommu_hwpt_selftest user_cfg;
    + int rc;

    if (flags & (~IOMMU_HWPT_ALLOC_NEST_PARENT))
    return ERR_PTR(-EOPNOTSUPP);

    - domain = mock_domain_alloc(IOMMU_DOMAIN_UNMANAGED);
    - if (!domain)
    - domain = ERR_PTR(-ENOMEM);
    - return domain;
    + if (!user_data) { /* must be mock_domain */
    + if (parent)
    + return ERR_PTR(-EINVAL);
    + return __mock_domain_alloc_paging(IOMMU_DOMAIN_UNMANAGED);
    + }
    +
    + /* must be mock_domain_nested */
    + if (user_data->type != IOMMU_HWPT_DATA_SELFTEST)
    + return ERR_PTR(-EOPNOTSUPP);
    + if (!parent || parent->ops != mock_ops.default_domain_ops)
    + return ERR_PTR(-EINVAL);
    +
    + mock_parent = container_of(parent, struct mock_iommu_domain, domain);
    + if (!mock_parent)
    + return ERR_PTR(-EINVAL);
    +
    + rc = iommu_copy_struct_from_user(&user_cfg, user_data,
    + IOMMU_HWPT_DATA_SELFTEST, iotlb);
    + if (rc)
    + return ERR_PTR(rc);
    +
    + return __mock_domain_alloc_nested(mock_parent, &user_cfg);
    }

    static void mock_domain_free(struct iommu_domain *domain)
    @@ -342,19 +396,41 @@ static const struct iommu_ops mock_ops = {
    },
    };

    +static void mock_domain_free_nested(struct iommu_domain *domain)
    +{
    + struct mock_iommu_domain_nested *mock_nested =
    + container_of(domain, struct mock_iommu_domain_nested, domain);
    +
    + kfree(mock_nested);
    +}
    +
    +static struct iommu_domain_ops domain_nested_ops = {
    + .free = mock_domain_free_nested,
    + .attach_dev = mock_domain_nop_attach,
    +};
    +
    static inline struct iommufd_hw_pagetable *
    -get_md_pagetable(struct iommufd_ucmd *ucmd, u32 mockpt_id,
    - struct mock_iommu_domain **mock)
    +__get_md_pagetable(struct iommufd_ucmd *ucmd, u32 mockpt_id, u32 hwpt_type)
    {
    - struct iommufd_hw_pagetable *hwpt;
    struct iommufd_object *obj;

    - obj = iommufd_get_object(ucmd->ictx, mockpt_id,
    - IOMMUFD_OBJ_HWPT_PAGING);
    + obj = iommufd_get_object(ucmd->ictx, mockpt_id, hwpt_type);
    if (IS_ERR(obj))
    return ERR_CAST(obj);
    - hwpt = container_of(obj, struct iommufd_hw_pagetable, obj);
    - if (hwpt->domain->ops != mock_ops.default_domain_ops) {
    + return container_of(obj, struct iommufd_hw_pagetable, obj);
    +}
    +
    +static inline struct iommufd_hw_pagetable *
    +get_md_pagetable(struct iommufd_ucmd *ucmd, u32 mockpt_id,
    + struct mock_iommu_domain **mock)
    +{
    + struct iommufd_hw_pagetable *hwpt;
    +
    + hwpt = __get_md_pagetable(ucmd, mockpt_id, IOMMUFD_OBJ_HWPT_PAGING);
    + if (IS_ERR(hwpt))
    + return hwpt;
    + if (hwpt->domain->type != IOMMU_DOMAIN_UNMANAGED ||
    + hwpt->domain->ops != mock_ops.default_domain_ops) {
    iommufd_put_object(&hwpt->obj);
    return ERR_PTR(-EINVAL);
    }
    @@ -362,6 +438,25 @@ get_md_pagetable(struct iommufd_ucmd *ucmd, u32 mockpt_id,
    return hwpt;
    }

    +static inline struct iommufd_hw_pagetable *
    +get_md_pagetable_nested(struct iommufd_ucmd *ucmd, u32 mockpt_id,
    + struct mock_iommu_domain_nested **mock_nested)
    +{
    + struct iommufd_hw_pagetable *hwpt;
    +
    + hwpt = __get_md_pagetable(ucmd, mockpt_id, IOMMUFD_OBJ_HWPT_NESTED);
    + if (IS_ERR(hwpt))
    + return hwpt;
    + if (hwpt->domain->type != IOMMU_DOMAIN_NESTED ||
    + hwpt->domain->ops != &domain_nested_ops) {
    + iommufd_put_object(&hwpt->obj);
    + return ERR_PTR(-EINVAL);
    + }
    + *mock_nested = container_of(hwpt->domain,
    + struct mock_iommu_domain_nested, domain);
    + return hwpt;
    +}
    +
    struct mock_bus_type {
    struct bus_type bus;
    struct notifier_block nb;
    --
    2.34.1
    \
     
     \ /
      Last update: 2023-10-20 11:22    [W:2.921 / U:0.040 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site