vfio_pci_vmf_insert_pfn() is the only caller of vmf_insert_pfn_pmd() and vmf_insert_pfn_pud() in the kernel that hardcodes write=false instead of passing vmf->flags & FAULT_FLAG_WRITE (unlike drm, panthor, and mshv). On x86_64, normal MAP_SHARED | PROT_WRITE VFIO BAR mappings usually mask this bug because vma->vm_page_prot already has _PAGE_RW set. However, when vma->vm_page_prot starts read-only, insert_pmd() and insert_pud() with write=false install a read-only huge entry without calling pmd_mkdirty()/maybe_pmd_mkwrite() (and similarly for PUD). Subsequent write-protection faults enter wp_huge_pmd() or wp_huge_pud(), which call vma->vm_ops->huge_fault() to upgrade the entry in place. Because vfio_pci_vmf_insert_pfn() passes write=false, insert_pmd() and insert_pud() see !pmd_none(*pmd) with !write, do nothing, and return VM_FAULT_NOPAGE, causing an unrecoverable infinite write page-fault loop and host CPU soft lockup on the next userspace or KVM guest MMIO store. In practice, vma->vm_page_prot is read-only on a writable MAP_SHARED BAR mapping in two situations: 1. Userspace soft-dirty tracking (CONFIG_MEM_SOFT_DIRTY) when a process such as CRIU (during pre-dump/checkpoint), a VMM live-migration loop, a memory profiler, or an unprivileged process holding a VFIO device fd writes "4" (CLEAR_REFS_SOFT_DIRTY) to /proc//clear_refs. That clears VM_SOFTDIRTY on all VMAs (including VM_PFNMAP) and calls vma_set_page_prot(), stripping _PAGE_RW from vma->vm_page_prot for subsequent huge faults. 2. Architectures where shared writable mappings start read-only for software dirty tracking, such as arm64 without hardware DBM (CONFIG_ARM64_HW_AFDBM off or FEAT_HAFDBS absent), where _PAGE_SHARED sets PTE_RDONLY | PTE_WRITE and pgprot_noncached() preserves PTE_RDONLY on MT_DEVICE_nGnRnE mappings until pmd_mkdirty() clears it on a write fault. This bug was found by code inspection while auditing huge_fault handlers and reproduced with a VFIO PCI selftest on a 2 MiB-aligned BAR mapping after writing "4" to /proc/self/clear_refs. Pass vmf->flags & FAULT_FLAG_WRITE to vmf_insert_pfn_pmd() and vmf_insert_pfn_pud() so write faults properly mark huge PFNMAP entries dirty and writable. Fixes: f9e54c3a2f5b ("vfio/pci: implement huge_fault support") Cc: stable@vger.kernel.org Cc: Ankit Agrawal Cc: Ritesh Harjani (IBM) Cc: David Matlack Signed-off-by: Mina Almasry --- drivers/vfio/pci/vfio_pci_core.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/drivers/vfio/pci/vfio_pci_core.c b/drivers/vfio/pci/vfio_pci_core.c index fcbb2da860e2..204d959086e9 100644 --- a/drivers/vfio/pci/vfio_pci_core.c +++ b/drivers/vfio/pci/vfio_pci_core.c @@ -1745,6 +1745,8 @@ vm_fault_t vfio_pci_vmf_insert_pfn(struct vfio_pci_core_device *vdev, unsigned long pfn, unsigned int order) { + bool write = vmf->flags & FAULT_FLAG_WRITE; + lockdep_assert_held_read(&vdev->memory_lock); if (vdev->pm_runtime_engaged || !__vfio_pci_memory_enabled(vdev)) @@ -1754,10 +1756,10 @@ vm_fault_t vfio_pci_vmf_insert_pfn(struct vfio_pci_core_device *vdev, return vmf_insert_pfn(vmf->vma, vmf->address, pfn); if (IS_ENABLED(CONFIG_ARCH_SUPPORTS_PMD_PFNMAP) && order == PMD_ORDER) - return vmf_insert_pfn_pmd(vmf, pfn, false); + return vmf_insert_pfn_pmd(vmf, pfn, write); if (IS_ENABLED(CONFIG_ARCH_SUPPORTS_PUD_PFNMAP) && order == PUD_ORDER) - return vmf_insert_pfn_pud(vmf, pfn, false); + return vmf_insert_pfn_pud(vmf, pfn, write); return VM_FAULT_FALLBACK; } -- 2.56.0.385.gac671c819a-goog