Gh0st
/
linux
mirror of https://github.com/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

iommu/virtio: Break out bypass identity support into a global static 

To make way for a domain_alloc_paging conversion add the typical global
static IDENTITY domain. This supports VMMs that have a
VIRTIO_IOMMU_F_BYPASS_CONFIG config.

If the VMM does not have support then the domain_alloc path is still used,
which creates an IDENTITY domain out of a paging domain.

Reviewed-by: Jean-Philippe Brucker <jean-philippe@linaro.org>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Kevin Tian <kevin.tian@intel.com>
Link: https://lore.kernel.org/r/1-v4-ff5fb6b03bd1+288-iommu_virtio_domains_jgg@nvidia.com
Signed-off-by: Joerg Roedel <jroedel@suse.de>
This commit is contained in:
Jason Gunthorpe 2025-04-08 13:35:47 -03:00 committed by Joerg Roedel
parent f984fb09e6
commit 0d76a6edae
1 changed files with 67 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
drivers/iommu/virtio-iommu.c
View File

@ -48,6 +48,7 @@ struct viommu_dev {
u64 pgsize_bitmap;
u32 first_domain;
u32 last_domain;
u32 identity_domain_id;
/* Supported MAP flags */
u32 map_flags;
u32 probe_size;
@ -70,7 +71,6 @@ struct viommu_domain {
struct rb_root_cached mappings;
unsigned long nr_endpoints;
bool bypass;
};
struct viommu_endpoint {
@ -305,6 +305,22 @@ static int viommu_send_req_sync(struct viommu_dev *viommu, void *buf,
return ret;
}
static int viommu_send_attach_req(struct viommu_dev *viommu, struct device *dev,
struct virtio_iommu_req_attach *req)
{
int ret;
unsigned int i;
struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
for (i = 0; i < fwspec->num_ids; i++) {
req->endpoint = cpu_to_le32(fwspec->ids[i]);
ret = viommu_send_req_sync(viommu, req, sizeof(*req));
if (ret)
return ret;
}
return 0;
}
/*
* viommu_add_mapping - add a mapping to the internal tree
*
@ -687,12 +703,6 @@ static int viommu_domain_finalise(struct viommu_endpoint *vdev,
vdomain->viommu = viommu;
if (domain->type == IOMMU_DOMAIN_IDENTITY) {
if (virtio_has_feature(viommu->vdev,
VIRTIO_IOMMU_F_BYPASS_CONFIG)) {
vdomain->bypass = true;
return 0;
}
ret = viommu_domain_map_identity(vdev, vdomain);
if (ret) {
ida_free(&viommu->domain_ids, vdomain->id);
@ -719,10 +729,8 @@ static void viommu_domain_free(struct iommu_domain *domain)
static int viommu_attach_dev(struct iommu_domain *domain, struct device *dev)
{
int i;
int ret = 0;
struct virtio_iommu_req_attach req;
struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
struct viommu_endpoint *vdev = dev_iommu_priv_get(dev);
struct viommu_domain *vdomain = to_viommu_domain(domain);
@ -761,16 +769,9 @@ static int viommu_attach_dev(struct iommu_domain *domain, struct device *dev)
.domain = cpu_to_le32(vdomain->id),
};
if (vdomain->bypass)
req.flags |= cpu_to_le32(VIRTIO_IOMMU_ATTACH_F_BYPASS);
for (i = 0; i < fwspec->num_ids; i++) {
req.endpoint = cpu_to_le32(fwspec->ids[i]);
ret = viommu_send_req_sync(vdomain->viommu, &req, sizeof(req));
if (ret)
return ret;
}
ret = viommu_send_attach_req(vdomain->viommu, dev, &req);
if (ret)
return ret;
if (!vdomain->nr_endpoints) {
/*
@ -788,6 +789,40 @@ static int viommu_attach_dev(struct iommu_domain *domain, struct device *dev)
return 0;
}
static int viommu_attach_identity_domain(struct iommu_domain *domain,
struct device *dev)
{
int ret = 0;
struct virtio_iommu_req_attach req;
struct viommu_endpoint *vdev = dev_iommu_priv_get(dev);
struct viommu_domain *vdomain = to_viommu_domain(domain);
req = (struct virtio_iommu_req_attach) {
.head.type = VIRTIO_IOMMU_T_ATTACH,
.domain = cpu_to_le32(vdev->viommu->identity_domain_id),
.flags = cpu_to_le32(VIRTIO_IOMMU_ATTACH_F_BYPASS),
};
ret = viommu_send_attach_req(vdev->viommu, dev, &req);
if (ret)
return ret;
if (vdev->vdomain)
vdev->vdomain->nr_endpoints--;
vdomain->nr_endpoints++;
vdev->vdomain = vdomain;
return 0;
}
static struct viommu_domain viommu_identity_domain = {
.domain = {
.type = IOMMU_DOMAIN_IDENTITY,
.ops = &(const struct iommu_domain_ops) {
.attach_dev = viommu_attach_identity_domain,
},
},
};
static void viommu_detach_dev(struct viommu_endpoint *vdev)
{
int i;
@ -1061,6 +1096,7 @@ static bool viommu_capable(struct device *dev, enum iommu_cap cap)
}
static struct iommu_ops viommu_ops = {
.identity_domain = &viommu_identity_domain.domain,
.capable = viommu_capable,
.domain_alloc = viommu_domain_alloc,
.probe_device = viommu_probe_device,
@ -1184,6 +1220,18 @@ static int viommu_probe(struct virtio_device *vdev)
if (virtio_has_feature(vdev, VIRTIO_IOMMU_F_MMIO))
viommu->map_flags |= VIRTIO_IOMMU_MAP_F_MMIO;
/* Reserve an ID to use as the bypass domain */
if (virtio_has_feature(viommu->vdev, VIRTIO_IOMMU_F_BYPASS_CONFIG)) {
viommu->identity_domain_id = viommu->first_domain;
viommu->first_domain++;
} else {
/*
* Assume the VMM is sensible and it either supports bypass on
* all instances or no instances.
*/
viommu_ops.identity_domain = NULL;
}
viommu_ops.pgsize_bitmap = viommu->pgsize_bitmap;
virtio_device_ready(vdev);