[PATCH v1: vfio: avoid unnecessary pin memory when dma map io address space 0/2]
Subsystems (4)
PATCH 1/2 mm: introduce vma flag VM_PGOFF_IS_PFN
In reply to Qinyun TanIntroduce a new vma flag 'VM_PGOFF_IS_PFN', which means vma->vm_pgoff == pfn. This allows us to directly obtain pfn through vma->vm_pgoff. No Functional Change.
--- include/linux/mm.h | 6 ++++++ 1 file changed, 6 insertions(+)
include/linux/mm.h +6 -0
@@ -322,6 +322,12 @@ extern unsigned int kobjsize(const void *objp);#define VM_NOHUGEPAGE 0x40000000/* MADV_NOHUGEPAGE marked this vma */ #define VM_MERGEABLE 0x80000000/* KSM may merge identical pages */ +#ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS /* vma->vm_pgoff == pfn */ +#define VM_PGOFF_IS_PFN BIT(62) +#else +#define VM_PGOFF_IS_PFN VM_NONE +#endif +#ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS #define VM_HIGH_ARCH_BIT_0 32/* bit only usable on 64-bit architectures */ #define VM_HIGH_ARCH_BIT_1 33/* bit only usable on 64-bit architectures */
Signature · 1 line
2.43.5
cover [PATCH v1: vfio: avoid unnecessary pin memory when dma map io address space 0/2]
When user application call ioctl(VFIO_IOMMU_MAP_DMA) to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.
However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag VM_IO | VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.
To address this issue, we introduce a new DMA MAP flag 'VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag for vfio_pci_mmap address, ensuring that we can directly obtain the pfn through vma->vm_pgoff.
This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
Qinyun Tan (2):
mm: introduce vma flag VM_PGOFF_IS_PFN
vfio: avoid unnecessary pin memory when dma map io address space
drivers/vfio/pci/vfio_pci_core.c | 2 +- drivers/vfio/vfio_iommu_type1.c | 64 +++++++++++++++++++++++++------- include/linux/mm.h | 6 +++ include/uapi/linux/vfio.h | 11 ++++++ 4 files changed, 68 insertions(+), 15 deletions(-)
Signature · 1 line
2.43.5
PATCH 2/2 vfio: avoid unnecessary pin memory when dma map io address space
When user application call ioctl(VFIO_IOMMU_MAP_DMA) to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.
However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag VM_IO | VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.
To address this issue, we introduce a new DMA MAP flag 'VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag for vfio_pci_mmap address, ensuring that we can directly obtain the pfn through vma->vm_pgoff.
This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
--- drivers/vfio/pci/vfio_pci_core.c | 2 +- drivers/vfio/vfio_iommu_type1.c | 64 +++++++++++++++++++++++++------- include/uapi/linux/vfio.h | 11 ++++++ 3 files changed, 62 insertions(+), 15 deletions(-)
drivers/vfio/pci/vfio_pci_core.c +1 -1
@@ -1802,7 +1802,7 @@ int vfio_pci_core_mmap(struct vfio_device *core_vdev, struct vm_area_struct *vma* the VMA flags. */ vm_flags_set (vma,VM_ALLOW_ANY_UNCACHED |VM_IO |VM_PFNMAP | -VM_DONTEXPAND |VM_DONTDUMP ); +VM_DONTEXPAND |VM_DONTDUMP |VM_PGOFF_IS_PFN ); vma->vm_ops = &vfio_pci_mmap_ops;return 0 ;
drivers/vfio/vfio_iommu_type1.c +50 -14
110 lines not on this page · raw message
include/uapi/linux/vfio.h +11 -0
@@ -56,6 +56,16 @@*/ #define VFIO_UPDATE_VADDR 10 +/* +* Support VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN for DMA mapping. For MMIO addresses, +* we do not need to pin the pages or establish address mapping in the MMU +* at this stage. We only need to establish the address mapping in the IOMMU for +* the ioctl(VFIO_IOMMU_MAP_DMA). The page table mapping in the MMU will be +* dynamically established through the page fault mechanism when the page +* is accessed in the future. +*/ +#define VFIO_DMA_MAP_MMIO_DONT_PIN 11 +/* * The IOCTL interface is designed for extensibility by embedding the * structure length (argsz) and flags into structures passed between
@@ -1560,6 +1570,7 @@ struct vfio_iommu_type1_dma_map {#define VFIO_DMA_MAP_FLAG_READ (1 << 0)/* readable from device */ #define VFIO_DMA_MAP_FLAG_WRITE (1 << 1)/* writable from device */ #define VFIO_DMA_MAP_FLAG_VADDR (1 << 2) +#define VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN (1 << 3)/* MMIO doesn't need pin page */ __u64 vaddr;/* Process virtual address */ __u64 iova;/* IO virtual address */ __u64 size;/* Size of mapping (bytes) */
Signature · 1 line
2.43.5
Quoted 16 lines · On Thu, 24 Oct 2024 17:34:42 +0800 Qinyun Tan <[email protected]>…
When user application call
ioctl(VFIO_IOMMU_MAP_DMA)to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag
VM_IO|VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.To address this issue, we introduce a new DMA MAP flag '
VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag forvfio_pci_mmapaddress, ensuring that we can directly obtain the pfn throughvma->vm_pgoff.
Quoted 6 lines
This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
If the vma has a flag to indicate pfnmap, why does the user need to provide a mapping flag to indicate not to pin? We generally cannot trust such a user directive anyway, nor do we in this series, so it all seems rather redundant.
What about simply improving the batching of pfnmap ranges rather than imposing any sort of mm or uapi changes? Or perhaps, since we're now using huge_fault to populate the vma, maybe we can iterate at PMD or PUD granularity rather than PAGE_SIZE? Seems like we have plenty of optimizations to pursue that could be done transparently to the user. Thanks,
Alex
Quoted 22 lines · Alex Williamson
Quoted 19 lines · On Thu, 24 Oct 2024 17:34:42 +0800 Qinyun Tan <[email protected]>…
When user application call
ioctl(VFIO_IOMMU_MAP_DMA)to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag
VM_IO|VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.To address this issue, we introduce a new DMA MAP flag '
VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag forvfio_pci_mmapaddress, ensuring that we can directly obtain the pfn throughvma->vm_pgoff.This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
Quoted 8 lines
Quoted 3 lines
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
If the vma has a flag to indicate pfnmap, why does the user need to provide a mapping flag to indicate not to pin? We generally cannot trust such a user directive anyway, nor do we in this series, so it all seems rather redundant.
The best answer is to map from DMABUF not from VMA and then you get perfect aggregation cheaply.
Quoted 6 lines
What about simply improving the batching of pfnmap ranges rather than imposing any sort of mm or uapi changes? Or perhaps, since we're now using
huge_faultto populate the vma, maybe we can iterate at PMD or PUD granularity rather thanPAGE_SIZE? Seems like we have plenty of optimizations to pursue that could be done transparently to the user.
I don't want to add more stuff to support the security broken follow_pfn path. It needs to be replaced.
Leon's work to improve the DMA API is soo close so we may be close to the end!
There are two versions of the dmabuf patches on the list, it would be good to get that in good shape. We could make a full solution, including the vfio/iommufd map side while waiting.
Jason
Quoted 43 lines
2024年10月25日 01:06,Alex Williamson <[email protected]> 写道:
Quoted 16 lines · On Thu, 24 Oct 2024 17:34:42 +0800 Qinyun Tan <[email protected]>…
When user application call
ioctl(VFIO_IOMMU_MAP_DMA)to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag
VM_IO|VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.To address this issue, we introduce a new DMA MAP flag '
VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag forvfio_pci_mmapaddress, ensuring that we can directly obtain the pfn throughvma->vm_pgoff.Quoted 6 lines
This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
If the vma has a flag to indicate pfnmap, why does the user need to provide a mapping flag to indicate not to pin? We generally cannot trust such a user directive anyway, nor do we in this series, so it all seems rather redundant.
What about simply improving the batching of pfnmap ranges rather than imposing any sort of mm or uapi changes? Or perhaps, since we're now using
huge_faultto populate the vma, maybe we can iterate at PMD or PUD granularity rather thanPAGE_SIZE? Seems like we have plenty of optimizations to pursue that could be done transparently to the user. Thanks,Alex
You are right, it seems I did not get the relevant updates in time. In the patch f9e54c3a2f5b7 ("vfio/pci: implement huge_fault support"), huge_fault was introduced, and maybe we can achieve the same effect by adjusting the function vfio_pci_mmap_huge_fault's order parameter. Thanks,
Qinyun Tan
Quoted 39 lines · Alex Williamson
Quoted 16 lines · On Thu, 24 Oct 2024 17:34:42 +0800 Qinyun Tan <[email protected]>…
When user application call
ioctl(VFIO_IOMMU_MAP_DMA)to map a dma address, the general handler 'vfio_pin_map_dma' attempts to pin the memory and then create the mapping in the iommu.However, some mappings aren't backed by a struct page, for example an mmap'd MMIO range for our own or another device. In this scenario, a vma with flag
VM_IO|VM_PFNMAP, the pin operation will fail. Moreover, the pin operation incurs a large overhead which will result in a longer startup time for the VM. We don't actually need a pin in this scenario.To address this issue, we introduce a new DMA MAP flag '
VFIO_DMA_MAP_FLAG_MMIO_DONT_PIN' to skip the 'vfio_pin_pages_remote' operation in the DMA map process for mmio memory. Additionally, we add the 'VM_PGOFF_IS_PFN' flag forvfio_pci_mmapaddress, ensuring that we can directly obtain the pfn throughvma->vm_pgoff.Quoted 6 lines
This approach allows us to avoid unnecessary memory pinning operations, which would otherwise introduce additional overhead during DMA mapping.
In my tests, using vfio to pass through an 8-card AMD GPU which with a large bar size (128GB*8), the time mapping the 192GB*8 bar was reduced from about 50.79s to 1.57s.
If the vma has a flag to indicate pfnmap, why does the user need to provide a mapping flag to indicate not to pin? We generally cannot trust such a user directive anyway, nor do we in this series, so it all seems rather redundant.
What about simply improving the batching of pfnmap ranges rather than imposing any sort of mm or uapi changes? Or perhaps, since we're now using
huge_faultto populate the vma, maybe we can iterate at PMD or PUD granularity rather thanPAGE_SIZE? Seems like we have plenty of optimizations to pursue that could be done transparently to the user. Thanks,Alex