Hi Mukesh, On Wed, 4 Nov 2026 18:01:06 -0800 Mukesh R <[email protected]> wrote:
> Add a new file to implement a kernel only virtual IOMMU that works > on Microsoft Hyper-V hypervisor (aka MSHV) in privileged VMs aka > root VMs. The hypervisor claims the IOMMU upon boot, and this driver > communicates with it for creating and deleting paging domains, > attaching of devices, mapping and unmapping of pages, etc. During > boot, hypervisor automatically creates identity and blocked domains, > so there is no need to do hypercalls to create them. This is a kernel > only driver and only supported on baremetal root (and not L1VH root) > without any guest passthru support. Support for guest device passthru > will be added incrementally. > > Signed-off-by: Mukesh R <[email protected]> > --- > arch/x86/kernel/pci-dma.c | 2 + > drivers/iommu/hyperv/Kconfig | 13 + > drivers/iommu/hyperv/Makefile | 1 + > drivers/iommu/hyperv/hv-iommu-root.c | 613 > +++++++++++++++++++++++++++ include/asm-generic/mshyperv.h | > 3 + include/linux/hyperv.h | 6 + > 6 files changed, 638 insertions(+) > create mode 100644 drivers/iommu/hyperv/hv-iommu-root.c > > diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c > index 75cf8f6ae8cd..560d8a4f6e1d 100644 > --- a/arch/x86/kernel/pci-dma.c > +++ b/arch/x86/kernel/pci-dma.c > @@ -8,6 +8,7 @@ > #include <linux/gfp.h> > #include <linux/pci.h> > #include <linux/amd-iommu.h> > +#include <linux/hyperv.h> > > #include <asm/proto.h> > #include <asm/dma.h> > @@ -103,6 +104,7 @@ void __init pci_iommu_alloc(void) > gart_iommu_hole_init(); > amd_iommu_detect(); > detect_intel_iommu(); > + hv_root_iommu_detect(); > swiotlb_init(x86_swiotlb_enable, x86_swiotlb_flags); > } > > diff --git a/drivers/iommu/hyperv/Kconfig > b/drivers/iommu/hyperv/Kconfig index f2f993f647c3..6ba5125ed501 100644 > --- a/drivers/iommu/hyperv/Kconfig > +++ b/drivers/iommu/hyperv/Kconfig > @@ -13,3 +13,16 @@ config HYPERV_PVIOMMU > Microsoft Hyper-V. Provides DMA remapping and IOTLB > flush support to enable DMA isolation for PCI devices > assigned to the guest. > + > +config HYPERV_ROOT_IOMMU > + bool "Hyper-V IOMMU Device in root partition" > + depends on HYPERV && X86 && PCI_MSI && MSHV_ROOT What requires PCI_MSI here? > + select IOMMU_API > + default HYPERV > + help > + This enables Hyper-V pseudo IOMMU device. When running as > privileged > + VM aka root on Microsoft Hyper-V hypervisor, this must be > enabled > + for doing any PCI passthru of devices to guest VMs. This > applies to > + both PFs and VFs. When enabling this, it is best to > disable amd/intel > + iommus via: intel_iommu=off amd_iommu=off as the > hypervisor really > + owns the iommu. > diff --git a/drivers/iommu/hyperv/Makefile > b/drivers/iommu/hyperv/Makefile index d3b2a259439c..04c66b4409a3 > 100644 --- a/drivers/iommu/hyperv/Makefile > +++ b/drivers/iommu/hyperv/Makefile > @@ -1,3 +1,4 @@ > # SPDX-License-Identifier: GPL-2.0 > obj-$(CONFIG_IRQ_REMAP) += hv-irq-remap-x86.o > obj-$(CONFIG_HYPERV_PVIOMMU) += hv-iommu-guest.o > +obj-$(CONFIG_HYPERV_ROOT_IOMMU) += hv-iommu-root.o > diff --git a/drivers/iommu/hyperv/hv-iommu-root.c > b/drivers/iommu/hyperv/hv-iommu-root.c new file mode 100644 > index 000000000000..e0e3e9d4385e > --- /dev/null > +++ b/drivers/iommu/hyperv/hv-iommu-root.c > @@ -0,0 +1,613 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Hyper-V root vIOMMU driver. > + * Copyright (C) 2026, Microsoft, Inc. > + */ > +#include <linux/pci.h> > +#include <linux/dma-map-ops.h> > +#include <linux/interval_tree.h> > +#include <linux/hyperv.h> > +#include <asm/iommu.h> > +#include <asm/mshyperv.h> > +#include "../dma-iommu.h" I don't think we need it, virtio iommu driver calls iommu_dma_get_resv_regions() but hv does not. > +static dma_addr_t hv_iommu_max_iova; > +static struct iommu_domain_ops hv_paging_domain_ops; > + > +/* IOMMU device that we export to the world. MSHV supports max of > one */ +static struct iommu_device hv_virt_iommu; > + > +struct hv_iommu_domain { > + struct iommu_domain iommu_dom; > + u32 domid_num; /* as opposed to > domain_id.type */ > + spinlock_t mappings_lock; /* protects > mappings_tree */ > + struct rb_root_cached mappings_tree; /* iova to pa lookup > tree */ +}; > + > +#define to_hv_domain(d) container_of(d, struct hv_iommu_domain, > iommu_dom) + > +struct hv_iommu_mapping { > + phys_addr_t paddr; > + struct interval_tree_node iova; > + u32 flags; > +}; > + > +/* > + * By default, during boot the hypervisor creates one Stage 2 (S2) > default > + * domain. It has two types: > + * S2 default: access to entire root partition memory. This for > the host > + * maps to IOMMU_DOMAIN_IDENTITY in the iommu > subsystem, and > + * is called HV_DEVICE_DOMAIN_ID_S2_DEFAULT in the > hypervisor. > + * (Linux renamed to : HV_DEVICE_DOMAIN_ID_DEFAULT) > + * S2 NULL: Blocks everything, ie, IOMMU_DOMAIN_BLOCKED in linux. > + */ > + > +/* > + * Create dummy domains to correspond to hypervisor prebuilt default > identity > + * and null domains (dummy because we do not make hypercalls to > create them). > + */ > +static struct hv_iommu_domain hv_def_identity_dom; > +static struct hv_iommu_domain hv_def_blocked_dom; > + > +/* > + * The hypervisor owns the IOMMU. As such it will choose the best > page size > + * and whenever possible use larger page sizes automatically. The > map gpa > + * hypercall to map the iova however currently uses only 4K pfns as > input. > + * So we specify 4K as the IOMMU PAGE_SIZE. > + */ > +#define HV_IOMMU_PGSIZES SZ_4K > + > +static DEFINE_IDA(hv_iommu_domids); /* unique numeric ids for new > domains */ + > +static bool hv_iommu_capable(struct device *dev, enum iommu_cap cap) > +{ > + switch (cap) { > + case IOMMU_CAP_CACHE_COHERENCY: > + return true; Maybe add a comment here to explain it is true for x86_64 mshv platforms, but need to be revisited if this driver expands to other architectures. > + default: > + return false; > + } > +} > + > +static int hv_iommu_add_tree_mapping(struct hv_iommu_domain *hvdom, > ulong iova, > + phys_addr_t paddr, size_t size, > u32 flags, > + gfp_t gfp) > +{ > + ulong irqflags; > + struct hv_iommu_mapping *mapping; > + > + mapping = kzalloc_obj(struct hv_iommu_mapping, gfp); > + if (!mapping) > + return -ENOMEM; > + > + mapping->paddr = paddr; > + mapping->iova.start = iova; > + mapping->iova.last = iova + size - 1; > + mapping->flags = flags; > + > + spin_lock_irqsave(&hvdom->mappings_lock, irqflags); > + interval_tree_insert(&mapping->iova, &hvdom->mappings_tree); > + spin_unlock_irqrestore(&hvdom->mappings_lock, irqflags); > + > + return 0; > +} > + > +/* If both size and iova are 0, then last = ULONG_MAX will remove > everything */ +static size_t hv_iommu_del_tree_mappings(struct > hv_iommu_domain *hvdom, > + ulong iova, size_t size) > +{ > + ulong flags; > + size_t unmapped = 0; > + ulong last = iova + size - 1; > + struct hv_iommu_mapping *mapping = NULL; > + struct interval_tree_node *node, *next; > + > + spin_lock_irqsave(&hvdom->mappings_lock, flags); nit: use scoped_guard(spinlock_irqsave, &hvdom->mappings_lock) ? > + next = interval_tree_iter_first(&hvdom->mappings_tree, iova, > last); > + while (next) { > + node = next; > + mapping = container_of(node, struct > hv_iommu_mapping, iova); > + next = interval_tree_iter_next(node, iova, last); > + > + /* Splitting of a mapping is not supported at > present */ > + if (mapping->iova.start < iova) > + break; > + > + unmapped += mapping->iova.last - mapping->iova.start > + 1; + > + interval_tree_remove(node, &hvdom->mappings_tree); > + kfree(mapping); > + } > + spin_unlock_irqrestore(&hvdom->mappings_lock, flags); > + > + return unmapped; > +} > + > +/* Create a new device domain in the hypervisor */ > +static int hv_iommu_create_hyp_devdom(struct hv_iommu_domain *hvdom) > +{ > + u64 status; > + struct hv_input_device_domain *ddp; > + struct hv_input_create_device_domain *input; > + ulong flags; > + > + local_irq_save(flags); > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + memset(input, 0, sizeof(*input)); > + > + ddp = &input->device_domain; > + ddp->partition_id = HV_PARTITION_ID_SELF; > + ddp->domain_id.type = HV_DEVICE_DOMAIN_TYPE_S2; > + ddp->domain_id.id = hvdom->domid_num; > + > + input->create_device_domain_flags.forward_progress_required > = 1; > + input->create_device_domain_flags.inherit_owning_vtl = 0; > + > + status = hv_do_hypercall(HVCALL_CREATE_DEVICE_DOMAIN, input, > NULL); + > + local_irq_restore(flags); > + > + if (!hv_result_success(status)) > + hv_status_err(status, "\n"); > + > + return hv_result_to_errno(status); > +} > + > +static struct iommu_domain *hv_iommu_domain_alloc_paging(struct > device *dev) +{ > + struct hv_iommu_domain *hvdom; > + int rc; > + > + if (!dev_is_pci(dev)) > + return NULL; > + > + hvdom = kzalloc_obj(struct hv_iommu_domain); > + if (hvdom == NULL) > + return ERR_PTR(-ENOMEM); > + > + spin_lock_init(&hvdom->mappings_lock); > + hvdom->mappings_tree = RB_ROOT_CACHED; > + > + rc = ida_alloc_range(&hv_iommu_domids, > + HV_DEVICE_DOMAIN_ID_DEFAULT + 1, > + HV_DEVICE_DOMAIN_ID_NULL - 1, > GFP_KERNEL); > + if (rc < 0) > + goto out_err; > + > + hvdom->domid_num = rc; > + hvdom->iommu_dom.pgsize_bitmap = HV_IOMMU_PGSIZES; > + hvdom->iommu_dom.geometry.aperture_start = 0; > + hvdom->iommu_dom.geometry.aperture_end = hv_iommu_max_iova; > + hvdom->iommu_dom.geometry.force_aperture = true; > + hvdom->iommu_dom.ops = &hv_paging_domain_ops; > + > + rc = hv_iommu_create_hyp_devdom(hvdom); > + if (rc) > + goto out_err1; > + > + return &hvdom->iommu_dom; > + > +out_err1: > + ida_free(&hv_iommu_domids, hvdom->domid_num); > +out_err: > + kfree(hvdom); > + return ERR_PTR(rc); > +} > + > +static void hv_iommu_domain_free(struct iommu_domain *immdom) > +{ > + ulong flags; > + u64 status; > + struct hv_input_delete_device_domain *input; > + struct hv_input_device_domain *ddp; > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + > + /* Cleanup any remaining. 0 for size results in ULONG_MAX as > the last */ > + hv_iommu_del_tree_mappings(hvdom, 0, 0); > + > + local_irq_save(flags); > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + ddp = &input->device_domain; > + memset(input, 0, sizeof(*input)); > + > + ddp->partition_id = HV_PARTITION_ID_SELF; > + ddp->domain_id.type = HV_DEVICE_DOMAIN_TYPE_S2; > + ddp->domain_id.id = hvdom->domid_num; > + > + status = hv_do_hypercall(HVCALL_DELETE_DEVICE_DOMAIN, input, > + NULL); > + local_irq_restore(flags); > + > + if (!hv_result_success(status)) > + hv_status_err(status, "\n"); > + > + ida_free(&hv_iommu_domids, hvdom->domid_num); > + kfree(hvdom); > +} > + > +/* > + * Attach a device to the default domain, or the null domain, or to > a domain > + * previously created in the hypervisor. > + */ > +static int hv_iommu_att_dev2dom(struct hv_iommu_domain *hvdom, > + struct pci_dev *pdev) > +{ > + ulong flags; > + u64 status; > + struct hv_input_attach_device_domain *input; > + > + local_irq_save(flags); > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + memset(input, 0, sizeof(*input)); > + > + /* For null domain, hvdom->domid_num == > HV_DEVICE_DOMAIN_ID_NULL */ > + input->device_domain.partition_id = HV_PARTITION_ID_SELF; > + input->device_domain.domain_id.type = > HV_DEVICE_DOMAIN_TYPE_S2; > + input->device_domain.domain_id.id = hvdom->domid_num; > + > + input->device_id.as_uint64 = hv_build_devid_type_pci(pdev); > + > + status = hv_do_hypercall(HVCALL_ATTACH_DEVICE_DOMAIN, input, > NULL); > + local_irq_restore(flags); > + > + if (hv_result_success(status) || > + hv_result(status) == HV_STATUS_DEVICE_ALREADY_IN_DOMAIN) > + return 0; > + > + hv_status_err(status, "\n"); > + return hv_result_to_errno(status); > +} > + > +static int hv_iommu_attach_dev(struct iommu_domain *immdom, struct > device *dev, > + struct iommu_domain *old) > +{ > + struct pci_dev *pdev; > + int rc; > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + > + pdev = to_pci_dev(dev); > + > + rc = hv_iommu_att_dev2dom(hvdom, pdev); > + if (rc) > + WARN(1, "Failed to attach pdev:%s\n", > pci_name(pdev)); + > + return rc; > +} > + > +static u64 hv_iommu_unmap_batch(u32 domid_num, ulong iova, u16 count) > +{ > + ulong flags; > + struct hv_input_unmap_device_gpa_pages *input; > + u64 status; > + > + local_irq_save(flags); > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + memset(input, 0, sizeof(*input)); > + > + input->device_domain.partition_id = HV_PARTITION_ID_SELF; > + input->device_domain.domain_id.type = > HV_DEVICE_DOMAIN_TYPE_S2; > + input->device_domain.domain_id.id = domid_num; > + input->target_device_va_base = iova; > + > + status = hv_do_rep_hypercall(HVCALL_UNMAP_DEVICE_GPA_PAGES, > count, > + 0, input, NULL); > + local_irq_restore(flags); > + > + if (!hv_result_success(status)) > + hv_status_err(status, "iova:0x%lx count:0x%x\n", > iova, count); + > + return status; > +} > + > +static size_t hv_iommu_hyp_unmap_pages(struct iommu_domain *immdom, > ulong iova, > + size_t size) > +{ > + u64 status; > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + size_t tot_done = 0; > + ulong npages = size >> HV_HYP_PAGE_SHIFT; > + > + while (npages) { > + int done, count = min(npages, HV_REP_COUNT_MAX); > + > + status = hv_iommu_unmap_batch(hvdom->domid_num, > iova, count); + > + done = hv_repcomp(status); > + tot_done += done; > + npages -= done; > + iova += done << HV_HYP_PAGE_SHIFT; > + > + if (!hv_result_success(status)) > + break; > + } > + > + return tot_done << HV_HYP_PAGE_SHIFT; > +} > + > +static size_t hv_iommu_unmap_pages(struct iommu_domain *immdom, > ulong iova, > + size_t pgsize, size_t pgcount, > + struct iommu_iotlb_gather *gather) > +{ > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + size_t unmap_sz, size = pgsize * pgcount; > + > + /* For valid input, the hypervisor guarantees unmap will > succeed */ > + unmap_sz = hv_iommu_hyp_unmap_pages(immdom, iova, size); > + if (unmap_sz != size) > + WARN(1, "Failed to unmap device gpa(%lx/%lx)\n", > unmap_sz, > + size); > + > + if (unmap_sz == 0) > + return 0; > + > + size = hv_iommu_del_tree_mappings(hvdom, iova, unmap_sz); > + if (size != unmap_sz) > + pr_err("%s: could not delete tree mappings > (%lx:%lx/%lx)\n", > + __func__, iova, unmap_sz, size); > + > + return size; > +} > + > +/* Return: must return exact status from the hypercall without > changes */ +static u64 hv_iommu_map_pgs(struct hv_iommu_domain > *hvdom, ulong iova, > + phys_addr_t paddr, ulong npages, u32 > map_flags) +{ > + u64 status; > + int i; > + struct hv_input_map_device_gpa_pages *input; > + unsigned long flags, pfn; > + > + local_irq_save(flags); > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + memset(input, 0, sizeof(*input)); > + > + input->device_domain.partition_id = HV_PARTITION_ID_SELF; > + input->device_domain.domain_id.type = > HV_DEVICE_DOMAIN_TYPE_S2; > + input->device_domain.domain_id.id = hvdom->domid_num; > + input->map_flags = map_flags; > + input->target_device_va_base = iova; > + > + pfn = paddr >> HV_HYP_PAGE_SHIFT; > + for (i = 0; i < npages; i++, pfn++) > + input->gpa_page_list[i] = pfn; > + > + status = hv_do_rep_hypercall(HVCALL_MAP_DEVICE_GPA_PAGES, > npages, 0, > + input, NULL); > + local_irq_restore(flags); > + > + if (!hv_result_success(status) && > !hv_result_needs_memory(status)) > + hv_status_err(status, "npgs:%lx paddr:%llx iova:%lx > mf:0x%x\n", > + npages, paddr, iova, map_flags); > + return status; > +} > + > +#define HV_MAP_DEVICE_GPA_BATCH_SIZE \ > + ((HV_HYP_PAGE_SIZE - sizeof(struct > hv_input_map_device_gpa_pages)) \ > + / sizeof(u64)) > + > +/* NB: cond_resched() is in vfio_iommu_map() */ map_pages() is not VFIO-specific, so it cannot depend on vfio_iommu_map() providing scheduling points. This comment is not relevant. > +static int hv_iommu_map_pages(struct iommu_domain *immdom, ulong > iova, > + phys_addr_t paddr, size_t pgsize, > size_t pgcount, > + int prot, gfp_t gfp, size_t *mapped) > +{ > + u32 map_flags; > + int ret; > + u64 status = 0; > + ulong npages, sav_iova = iova, done = 0; > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + size_t size = pgsize * pgcount; > + > + map_flags = HV_MAP_GPA_READABLE; /* required */ Why required? If the core asks for write-only, this still grant read access? VT-d S2 PTE has separate R W bits. Maybe reject write-only if mshv cannot handle it. if ((prot & IOMMU_WRITE) && !(prot & IOMMU_READ)) return -EINVAL; > + map_flags |= prot & IOMMU_WRITE ? HV_MAP_GPA_WRITABLE : 0; > + > + ret = hv_iommu_add_tree_mapping(hvdom, iova, paddr, size, > map_flags, > + gfp); > + if (ret) > + return ret; > + > + npages = size >> HV_HYP_PAGE_SHIFT; > + while (done < npages) { > + ulong completed, remain = npages - done; > + > + remain = min(remain, HV_MAP_DEVICE_GPA_BATCH_SIZE); > + > + status = hv_iommu_map_pgs(hvdom, iova, paddr, remain, > + map_flags); > + > + completed = hv_repcomp(status); > + done = done + completed; > + iova = iova + (completed << HV_HYP_PAGE_SHIFT); > + paddr = paddr + (completed << HV_HYP_PAGE_SHIFT); > + > + if (hv_result_needs_memory(status)) { > + ret = > hv_deposit_memory_gfp(hv_current_partition_id, > + status, gfp); > + if (ret) > + break; > + continue; > + } > + if (!hv_result_success(status)) > + break; > + } > + > + if (ret == 0) > + ret = hv_result_to_errno(status); > + > + if (hv_result_success(status)) { > + if (mapped) > + *mapped = size; > + } else { > + size_t done_size = done << HV_HYP_PAGE_SHIFT; > + > + hv_status_err(status, "pgs:%lx/%lx iova:%lx\n", > done, npages, > + sav_iova); > + > + hv_iommu_del_tree_mappings(hvdom, sav_iova, size); > + > + /* Hypervisor guarantees unmap will succeed here */ > + hv_iommu_hyp_unmap_pages(immdom, sav_iova, > done_size); + > + if (mapped) > + *mapped = 0; > + } > + > + return ret; > +} > + > +static phys_addr_t hv_iommu_iova_to_phys(struct iommu_domain *immdom, > + dma_addr_t iova) > +{ > + unsigned long flags; > + struct hv_iommu_mapping *mapping; > + struct interval_tree_node *node; > + u64 paddr = 0; > + struct hv_iommu_domain *hvdom = to_hv_domain(immdom); > + > + spin_lock_irqsave(&hvdom->mappings_lock, flags); guard(spinlock_irqsave)(&hvdom->mappings_lock); some other places too. > + node = interval_tree_iter_first(&hvdom->mappings_tree, iova, > iova); > + if (node) { > + mapping = container_of(node, struct > hv_iommu_mapping, iova); > + paddr = mapping->paddr + (iova - > mapping->iova.start); > + } > + spin_unlock_irqrestore(&hvdom->mappings_lock, flags); > + > + return paddr; > +} > + > +static struct iommu_device *hv_iommu_probe_device(struct device *dev) > +{ > + if (!dev_is_pci(dev)) > + return ERR_PTR(-ENODEV); > + > + return &hv_virt_iommu; > +} > + > +static void hv_iommu_get_resv_regions(struct device *dev, > + struct list_head *head) > +{ > + iommu_add_resv_x86_msi_region(head); > +} > + > +static struct iommu_domain_ops hv_paging_domain_ops = { > + .attach_dev = hv_iommu_attach_dev, > + .map_pages = hv_iommu_map_pages, > + .unmap_pages = hv_iommu_unmap_pages, > + .iova_to_phys = hv_iommu_iova_to_phys, > + .free = hv_iommu_domain_free, > +}; > + > +static struct iommu_ops hv_iommu_ops = { > + .capable = hv_iommu_capable, > + .domain_alloc_paging = hv_iommu_domain_alloc_paging, > + .probe_device = hv_iommu_probe_device, > + .device_group = pci_device_group, > + .get_resv_regions = hv_iommu_get_resv_regions, > + .owner = THIS_MODULE, > + .identity_domain = &hv_def_identity_dom.iommu_dom, > + .blocked_domain = &hv_def_blocked_dom.iommu_dom, > + .release_domain = &hv_def_blocked_dom.iommu_dom, > +}; > + > +static const struct iommu_domain_ops hv_special_domain_ops = { > + .attach_dev = hv_iommu_attach_dev, > +}; > + > +static void __init hv_initialize_special_domains(void) > +{ > + hv_def_identity_dom.iommu_dom.type = IOMMU_DOMAIN_IDENTITY; > + hv_def_identity_dom.iommu_dom.ops = &hv_special_domain_ops; > + hv_def_identity_dom.iommu_dom.owner = &hv_iommu_ops; > + hv_def_identity_dom.domid_num = HV_DEVICE_DOMAIN_ID_DEFAULT; > /* 0 */ + > + hv_def_blocked_dom.iommu_dom.type = IOMMU_DOMAIN_BLOCKED; > + hv_def_blocked_dom.iommu_dom.ops = &hv_special_domain_ops; > + hv_def_blocked_dom.iommu_dom.owner = &hv_iommu_ops; > + hv_def_blocked_dom.domid_num = HV_DEVICE_DOMAIN_ID_NULL; > /* INTMAX */ +} > + > +/* > + * In general, the hypervisor does not support the capabilities > hypercall for > + * root partitions, an exception was made for max_iova_width. For > IOMMU cap, > + * hv_root_iommu_detect() below checks for > HV_DEVICE_DOMAIN_AVAILABLE which > + * supersedes HV_IOMMU_CAP_PRESENT. As for the pgsize_bitmap cap, > see comment > + * above HV_IOMMU_PGSIZES. > + */ > +static int hv_iommu_get_caps(struct hv_output_get_iommu_capabilities Should be __init since it is only called by a __init function? > *caps) +{ > + u64 status; > + unsigned long flags; > + struct hv_input_get_iommu_capabilities *input; > + struct hv_output_get_iommu_capabilities *output; > + > + local_irq_save(flags); > + > + input = *this_cpu_ptr(hyperv_pcpu_input_arg); > + output = *this_cpu_ptr(hyperv_pcpu_output_arg); > + memset(input, 0, sizeof(*input)); > + input->partition_id = HV_PARTITION_ID_SELF; > + status = hv_do_hypercall(HVCALL_GET_IOMMU_CAPABILITIES, > input, output); > + *caps = *output; > + > + local_irq_restore(flags); > + > + if (!hv_result_success(status)) > + hv_status_err(status, "\n"); > + > + return hv_result_to_errno(status); > +} > + > +static int __init hv_root_iommu_init(void) > +{ > + int rc; > + struct iommu_device *iommup = &hv_virt_iommu; > + struct hv_output_get_iommu_capabilities caps; > + > + if (!hv_is_hyperv_initialized()) > + return -ENODEV; > + > + rc = hv_iommu_get_caps(&caps); > + if (rc) > + return rc; > + > + hv_iommu_max_iova = DMA_BIT_MASK(caps.max_iova_width); > + > + /* This must come before iommu_device_register() because the > latter > + * calls into the hooks. > + */ > + hv_initialize_special_domains(); > + > + rc = iommu_device_sysfs_add(iommup, NULL, NULL, "%s", > "hyperv-iommu"); > + if (rc) { > + pr_err("Hyper-V: iommu_device_sysfs_add failed: > %d\n", rc); > + return rc; > + } > + > + rc = iommu_device_register(iommup, &hv_iommu_ops, NULL); > + if (rc) { > + pr_err("Hyper-V: iommu_device_register failed: > %d\n", rc); > + goto err_sysfs_remove; > + } > + > + pr_info("Hyper-V IOMMU initialized\n"); > + > + return 0; > + > +err_sysfs_remove: > + iommu_device_sysfs_remove(iommup); > + return rc; > +} > + > +void __init hv_root_iommu_detect(void) > +{ > + if (no_iommu || iommu_detected || hv_l1vh_partition()) > + return; > + > + /* This is set for root partitions only, it is never set for > non-root */ > + if (!(ms_hyperv.misc_features & HV_DEVICE_DOMAIN_AVAILABLE)) > + return; > + > + iommu_detected = 1; > + x86_init.iommu.iommu_init = hv_root_iommu_init; > + > + pci_request_acs(); > +} > diff --git a/include/asm-generic/mshyperv.h > b/include/asm-generic/mshyperv.h index 2584e693d7b3..ad02d6956ae3 > 100644 --- a/include/asm-generic/mshyperv.h > +++ b/include/asm-generic/mshyperv.h > @@ -28,6 +28,9 @@ > > #define VTPM_BASE_ADDRESS 0xfed40000 > > +#define HV_REP_COUNT_MAX \ > + (HV_HYPERCALL_REP_COMP_MASK >> HV_HYPERCALL_REP_COMP_OFFSET) > + > enum hv_partition_type { > HV_PARTITION_TYPE_GUEST, > HV_PARTITION_TYPE_ROOT, > diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h > index e85a1a043eac..8aa752e8c4e1 100644 > --- a/include/linux/hyperv.h > +++ b/include/linux/hyperv.h > @@ -1823,4 +1823,10 @@ static inline unsigned long virt_to_hvpfn(void > *addr) #define HVPFN_DOWN(x) ((x) >> HV_HYP_PAGE_SHIFT) > #define page_to_hvpfn(page) (page_to_pfn(page) * > NR_HV_HYP_PAGES_IN_PAGE) > +#ifdef CONFIG_HYPERV_ROOT_IOMMU > +void __init hv_root_iommu_detect(void); > +#else > +static inline void hv_root_iommu_detect(void) { } nit: add __init to be consistent? also it may save memory if the stub is not empty in the future. With above addressed, Reviewed-by: Jacob Pan <[email protected]> > +#endif /* CONFIG_HYPERV_ROOT_IOMMU */ > + > #endif /* _HYPERV_H */
