x86/Hyper-V: Add Hyper-V Isolation VM support(Second part)
Subsystems (10)
v2 cover x86/Hyper-V: Add Hyper-V Isolation VM support(Second part)
From: Tianyu Lan <[email protected]>
Hyper-V provides two kinds of Isolation VMs. VBS(Virtualization-based security) and AMD SEV-SNP unenlightened Isolation VMs. This patchset is to add support for these Isolation VM support in Linux.
The memory of these vms are encrypted and host can't access guest memory directly. Hyper-V provides new host visibility hvcall and the guest needs to call new hvcall to mark memory visible to host before sharing memory with host. For security, all network/storage stack memory should not be shared with host and so there is bounce buffer requests.
Vmbus channel ring buffer already plays bounce buffer role because all data from/to host needs to copy from/to between the ring buffer and IO stack memory. So mark vmbus channel ring buffer visible.
For SNP isolation VM, guest needs to access the shared memory via extra address space which is specified by Hyper-V CPUID HYPERV_CPUID_ ISOLATION_CONFIG. The access physical address of the shared memory should be bounce buffer memory GPA plus with shared_gpa_boundary reported by CPUID.
This patchset is to enable swiotlb bounce buffer for netvsc/storvsc in Isolation VM. Add Hyper-V dma ops and provide dma_alloc/free_ noncontiguous and vmap/vunmap_noncontiguous callback. Allocate rx/tx ring via dma_alloc_noncontiguous() and map them into extra address space via dma_vmap_noncontiguous().
Change since v1:
* Add Hyper-V Isolation support check in the cc_platform_has() and return true for guest memory encrypt attr.
* Remove hv isolation check in the sev_setup_arch()
Tianyu Lan (6):
Swiotlb: Add Swiotlb bounce buffer remap function for HV IVM
dma-mapping: Add vmap/vunmap_noncontiguous() callback in dma ops x86/hyper-v: Add hyperv Isolation VM check in the cc_platform_has() hyperv/IOMMU: Enable swiotlb bounce buffer for Isolation VM
net: netvsc: Add Isolation VM support for netvsc driver
scsi: storvsc: Add Isolation VM support for storvsc driver
arch/x86/kernel/cc_platform.c | 15 +++ arch/x86/mm/mem_encrypt.c | 1 + arch/x86/xen/pci-swiotlb-xen.c | 3 +- drivers/hv/Kconfig | 1 + drivers/hv/vmbus_drv.c | 6 + drivers/iommu/hyperv-iommu.c | 164 +++++++++++++++++++++++++ drivers/net/hyperv/hyperv_net.h | 5 + drivers/net/hyperv/netvsc.c | 192 +++++++++++++++++++++++++++--- drivers/net/hyperv/rndis_filter.c | 2 + drivers/scsi/storvsc_drv.c | 37 +++--- include/linux/dma-map-ops.h | 3 + include/linux/hyperv.h | 17 +++ include/linux/swiotlb.h | 6 + kernel/dma/mapping.c | 18 ++- kernel/dma/swiotlb.c | 53 ++++++++- 15 files changed, 482 insertions(+), 41 deletions(-)
Signature · 1 line
2.25.1
PATCH v2 1/6 Swiotlb: Add Swiotlb bounce buffer remap function for HV IVM
From: Tianyu Lan <[email protected]>
In Isolation VM with AMD SEV, bounce buffer needs to be accessed via extra address space which is above shared_gpa_boundary (E.G 39 bit address line) reported by Hyper-V CPUID ISOLATION_CONFIG. The access physical address will be original physical address + shared_gpa_boundary. The shared_gpa_boundary in the AMD SEV SNP spec is called virtual top of memory(vTOM). Memory addresses below vTOM are automatically treated as private while memory above vTOM is treated as shared.
Expose swiotlb_unencrypted_base for platforms to set unencrypted memory base offset and platform calls swiotlb_update_mem_attributes() to remap swiotlb mem to unencrypted address space. memremap() can not be called in the early stage and so put remapping code into swiotlb_update_mem_attributes(). Store remap address and use it to copy data from/to swiotlb bounce buffer.
---
Change since v1:
* Rework comment in the swiotlb_init_io_tlb_mem()
* Make swiotlb_init_io_tlb_mem() back to return void.
--- include/linux/swiotlb.h | 6 +++++ kernel/dma/swiotlb.c | 53 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 54 insertions(+), 5 deletions(-)
include/linux/swiotlb.h +6 -0
@@ -73,6 +73,9 @@ extern enum swiotlb_force swiotlb_force;* @end: The end address of the swiotlb memory pool. Used to do a quick * range check to see if the memory was in fact allocated by this * API. +* @vaddr: The vaddr of the swiotlb memory pool. The swiotlb memory pool +* may be remapped in the memory encrypted case and store virtual +* address for bounce buffer operation. * @nslabs: The number of IO TLB blocks (in groups of 64) between @start and * @end. For default swiotlb, this is command line adjustable via * setup_io_tlb_npages.
@@ -92,6 +95,7 @@ extern enum swiotlb_force swiotlb_force;struct io_tlb_mem {phys_addr_t start;phys_addr_t end; +void *vaddr;unsigned long nslabs;unsigned long used;unsigned int index;
@@ -186,4 +190,6 @@ static inline bool is_swiotlb_for_alloc(struct device *dev) }#endif /* CONFIG_DMA_RESTRICTED_POOL */ +extern phys_addr_t swiotlb_unencrypted_base; +#endif /* __LINUX_SWIOTLB_H */
kernel/dma/swiotlb.c +48 -5
102 lines not on this page · raw message
Signature · 1 line
2.25.1
RE: [PATCH V2 1/6] Swiotlb: Add Swiotlb bounce buffer remap function for HV IVM
From: Tianyu Lan <[email protected]> Sent: Tuesday, November 23, 2021 6:31 AM
Quoted 112 lines
In Isolation VM with AMD SEV, bounce buffer needs to be accessed via extra address space which is above
shared_gpa_boundary(E.G 39 bit address line) reported by Hyper-V CPUIDISOLATION_CONFIG. The access physical address will be original physical address +shared_gpa_boundary. Theshared_gpa_boundaryin the AMD SEV SNP spec is called virtual top of memory(vTOM). Memory addresses below vTOM are automatically treated as private while memory above vTOM is treated as shared.Expose
swiotlb_unencrypted_basefor platforms to set unencrypted memory base offset and platform callsswiotlb_update_mem_attributes()to remap swiotlb mem to unencrypted address space.memremap()can not be called in the early stage and so put remapping code intoswiotlb_update_mem_attributes(). Store remap address and use it to copy data from/to swiotlb bounce buffer.Signed-off-by Tianyu Lan <[email protected]>---
Change since v1:
* Rework comment in theswiotlb_init_io_tlb_mem()
* Makeswiotlb_init_io_tlb_mem()back to return void.--- include/linux/swiotlb.h | 6 +++++ kernel/dma/swiotlb.c | 53 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 54 insertions(+), 5 deletions(-)include/linux/swiotlb.h +6
-0@@ -73,6 +73,9 @@ extern enum swiotlb_force swiotlb_force;* @end: The end address of the swiotlb memory pool. Used to do a quick * range check to see if the memory was in fact allocated by this * API. +* @vaddr: The vaddr of the swiotlb memory pool. The swiotlb memory pool +* may be remapped in the memory encrypted case and store virtual +* address for bounce buffer operation. * @nslabs: The number of IO TLB blocks (in groups of 64) between @start and * @end. For default swiotlb, this is command line adjustable via * setup_io_tlb_npages. @@ -92,6 +95,7 @@ extern enum swiotlb_force swiotlb_force;struct io_tlb_mem {phys_addr_t start;phys_addr_t end; +void *vaddr;unsigned long nslabs;unsigned long used;unsigned int index;@@ -186,4 +190,6 @@ static inline bool is_swiotlb_for_alloc(struct device *dev) }#endif /* CONFIG_DMA_RESTRICTED_POOL */ +extern phys_addr_t swiotlb_unencrypted_base; +#endif /* __LINUX_SWIOTLB_H */ kernel/dma/swiotlb.c +28
-0@@ -50,6 +50,7 @@#include <asm/io.h> #include <asm/dma.h> +#include <linux/io.h> #include <linux/init.h> #include <linux/memblock.h> #include <linux/iommu-helper.h> @@ -72,6 +73,8 @@ enum swiotlb_force swiotlb_force;struct io_tlb_mem io_tlb_default_mem; +phys_addr_t swiotlb_unencrypted_base; +/* * Max segment that we can provide which (if pages are contingous) will * not be bounced (unless SWIOTLB_FORCE is set). @@ -155,6 +158,31 @@ static inline unsigned long nr_slots(u64 val)return DIV_ROUND_UP (val,IO_TLB_SIZE ); } +/* +* Remap swioltb memory in the unencrypted physical address space +* when swiotlb_unencrypted_base is set. (e.g. for Hyper-V AMD SEV-SNP +* Isolation VMs). +*/ +void *swiotlb_mem_remap (struct io_tlb_mem *mem,unsigned long bytes) +{ +void *vaddr; + +if (swiotlb_unencrypted_base) { +phys_addr_t paddr = mem->start + swiotlb_unencrypted_base; + + vaddr =memremap (paddr, bytes,MEMREMAP_WB ); +if (!vaddr) { +pr_err ("Failed to map the unencrypted memory %llx size %lx.\n" , + paddr, bytes); +return NULL ; + } + +return vaddr; + } + +return phys_to_virt (mem->start); +} +/* * Early SWIOTLB allocation may be too early to allow an architecture to * perform the desired operations. This function allows the architecture to @@ -172,7 +200,14 @@ void __init swiotlb_update_mem_attributes(void) vaddr =phys_to_virt (mem->start); bytes =PAGE_ALIGN (mem->nslabs <<IO_TLB_SHIFT );set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT );
kernel/dma/swiotlb.c void __init swiotlb_update_mem_attributes(void) · line 211
Quoted 10 lines
kernel/dma/swiotlb.c +8
-1-memset (vaddr,0 , bytes); + + mem->vaddr =swiotlb_mem_remap (mem, bytes); +if (!mem->vaddr) { +pr_err ("Fail to remap swiotlb mem.\n" ); +return ; + } + +memset (mem->vaddr,0 , bytes); }
In the error case, do you want to leave mem->vaddr as NULL? Or is it better to leave it as the virtual address of mem-start? Your code leaves it as NULL.
The interaction between swiotlb_update_mem_attributes() and the helper function swiotlb_memo_remap() seems kind of clunky. phys_to_virt() gets called twice, for example, and two error messages are printed. The code would be more straightforward by just putting the helper function inline:
mem->vaddr = phys_to_virt(mem->start);
bytes = PAGE_ALIGN(mem->nslabs << IO_TLB_SHIFT); set_memory_decrypted((unsigned long)(mem->vaddr), bytes >> PAGE_SHIFT);
if (swiotlb_unencrypted_base) {
phys_addr_t paddr = mem->start + swiotlb_unencrypted_base;
mem->vaddr = memremap(paddr, bytes, MEMREMAP_WB);
if (!mem->vaddr) {
pr_err("Failed to map the unencrypted memory %llx size %lx.\n",
paddr, bytes);
return;
}
}memset(mem->vaddr, 0, bytes);
(This version also leaves mem->vaddr as NULL in the error case.)
Quoted 5 lines
kernel/dma/swiotlb.c +0
-0static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start,@@ -196,7 +231,18 @@ static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, mem->slots[i].orig_addr =INVALID_PHYS_ADDR ; mem->slots[i].alloc_size =0 ;
kernel/dma/swiotlb.c static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, · line 242
Quoted 10 lines
kernel/dma/swiotlb.c +9
-0} + +/* +* If swiotlb_unencrypted_base is set, the bounce buffer memory will +* be remapped and cleared in swiotlb_update_mem_attributes. +*/ +if (swiotlb_unencrypted_base) +return ; + +set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT );
Prior to this patch, and here in the new version as well, the return value from set_memory_decrypted() is ignored in several places in this file. As previously discussed, swiotlb_init_io_tlb_mem() is a void function, so there's no place to return an error. Is that OK?
Quoted 33 lines
kernel/dma/swiotlb.c +3
-5memset (vaddr,0 , bytes); + mem->vaddr = vaddr; +return ; }int __init swiotlb_init_with_tbl (char *tlb,unsigned long nslabs,int verbose)@@ -318,7 +364,6 @@ swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs)if (!mem->slots)return -ENOMEM ; -set_memory_decrypted ((unsigned long )tlb, bytes >>PAGE_SHIFT );swiotlb_init_io_tlb_mem (mem,virt_to_phys (tlb), nslabs, true);swiotlb_print_info ();@@ -371,7 +416,7 @@ static void swiotlb_bounce(struct device *dev, phys_addr_t tlb_addr, size_t sizephys_addr_t orig_addr = mem->slots[index].orig_addr;size_t alloc_size = mem->slots[index].alloc_size;unsigned long pfn =PFN_DOWN (orig_addr); -unsigned char *vaddr =phys_to_virt (tlb_addr); +unsigned char *vaddr = mem->vaddr + tlb_addr - mem->start;unsigned int tlb_offset, orig_addr_offset;if (orig_addr ==INVALID_PHYS_ADDR )@@ -806,8 +851,6 @@ static int rmem_swiotlb_device_init(struct reserved_mem *rmem,return -ENOMEM ; } -set_memory_decrypted ((unsigned long )phys_to_virt (rmem->base), - rmem->size >>PAGE_SHIFT );swiotlb_init_io_tlb_mem (mem, rmem->base, nslabs, false); mem->force_bounce = true; mem->for_alloc = true; --
Quoted 1 line
2.25.1
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH V2 1/6] Swiotlb: Add Swiotlb bounce buffer remap function for HV IVM
Hi Michael:
Thanks for your review.
Quoted 40 lines · Michael Kelley (LINUX)
Quoted 4 lines
kernel/dma/swiotlb.c +0
-0@@ -172,7 +200,14 @@ void __init swiotlb_update_mem_attributes(void) vaddr =phys_to_virt (mem->start); bytes =PAGE_ALIGN (mem->nslabs <<IO_TLB_SHIFT );set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT );kernel/dma/swiotlb.c void __init swiotlb_update_mem_attributes(void) · line 211
Quoted 10 lines
kernel/dma/swiotlb.c +8
-1-memset (vaddr,0 , bytes); + + mem->vaddr =swiotlb_mem_remap (mem, bytes); +if (!mem->vaddr) { +pr_err ("Fail to remap swiotlb mem.\n" ); +return ; + } + +memset (mem->vaddr,0 , bytes); }In the error case, do you want to leave
mem->vaddras NULL? Or is it better to leave it as the virtual address of mem-start? Your code leaves it as NULL.The interaction between
swiotlb_update_mem_attributes()and the helper functionswiotlb_memo_remap()seems kind of clunky.phys_to_virt()gets called twice, for example, and two error messages are printed. The code would be more straightforward by just putting the helper function inline:
mem->vaddr=phys_to_virt(mem->start);
bytes =PAGE_ALIGN(mem->nslabs << IO_TLB_SHIFT);set_memory_decrypted((unsigned long)(mem->vaddr), bytes >> PAGE_SHIFT);if (swiotlb_unencrypted_base) { phys_addr_t paddr = mem->start + swiotlb_unencrypted_base; mem->vaddr = memremap(paddr, bytes, MEMREMAP_WB); if (!mem->vaddr) { pr_err("Failed to map the unencrypted memory %llx size %lx.\n", paddr, bytes); return; } }
Quoted 3 lines
memset(mem->vaddr, 0, bytes);(This version also leaves
mem->vaddras NULL in the error case.)
From Christoph's previous suggestion, there should be a well-documented wrapper to explain the remap option and so I split the code. leaving the virtual address of mem-start is better.
https://lkml.org/lkml/2021/9/28/51
Quoted 11 lines
Quoted 11 lines
kernel/dma/swiotlb.c +5
-0static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start,@@ -196,7 +231,18 @@ static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, mem->slots[i].orig_addr =INVALID_PHYS_ADDR ; mem->slots[i].alloc_size =0 ; } + +/* +* If swiotlb_unencrypted_base is set, the bounce buffer memory will +* be remapped and cleared in swiotlb_update_mem_attributes. +*/
Quoted 8 lines
kernel/dma/swiotlb.c static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, · line 242
Quoted 4 lines
kernel/dma/swiotlb.c +4
-0+if (swiotlb_unencrypted_base) +return ; + +set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT );Prior to this patch, and here in the new version as well, the return value from
set_memory_decrypted()is ignored in several places in this file. As previously discussed,swiotlb_init_io_tlb_mem()is a void function, so there's no place to return an error. Is that OK?
Yes, the original code doesn't check the return value and so keep the rule。
Christoph, Could you help to check which way do you prefer?
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 2/6 dma-mapping: Add vmap/vunmap_noncontiguous() callback in dma ops
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V netvsc driver needs to allocate noncontiguous DMA memory and remap it into unencrypted address space before sharing with host. Add vmap/vunmap_noncontiguous() callback and handle the remap in the Hyper-V dma ops callback.
--- include/linux/dma-map-ops.h | 3 +++ kernel/dma/mapping.c | 18 ++++++++++++++---- 2 files changed, 17 insertions(+), 4 deletions(-)
include/linux/dma-map-ops.h +3 -0
@@ -27,6 +27,9 @@ struct dma_map_ops { unsigned long attrs);void (*free_noncontiguous)(struct device *dev,size_t size,struct sg_table *sgt,enum dma_data_direction dir); +void *(*vmap_noncontiguous)(struct device *dev,size_t size, +struct sg_table *sgt); +void (*vunmap_noncontiguous)(struct device *dev,void *addr);int (*mmap)(struct device *,struct vm_area_struct *,void *,dma_addr_t ,size_t ,unsigned long attrs);
kernel/dma/mapping.c +14 -4
@@ -674,8 +674,14 @@ void *dma_vmap_noncontiguous(struct device *dev, size_t size,const struct dma_map_ops *ops =get_dma_ops (dev);unsigned long count =PAGE_ALIGN (size) >>PAGE_SHIFT ; -if (ops && ops->alloc_noncontiguous) -return vmap (sgt_handle (sgt)->pages, count,VM_MAP ,PAGE_KERNEL ); +if (ops) { +if (ops->vmap_noncontiguous) +return ops->vmap_noncontiguous (dev, size, sgt); +else if (ops->alloc_noncontiguous) +return vmap (sgt_handle (sgt)->pages, count,VM_MAP , +PAGE_KERNEL ); + } +return page_address (sg_page (sgt->sgl)); }EXPORT_SYMBOL_GPL (dma_vmap_noncontiguous);
@@ -684,8 +690,12 @@ void dma_vunmap_noncontiguous(struct device *dev, void *vaddr) {const struct dma_map_ops *ops =get_dma_ops (dev); -if (ops && ops->alloc_noncontiguous) -vunmap (vaddr); +if (ops) { +if (ops->vunmap_noncontiguous) + ops->vunmap_noncontiguous (dev, vaddr); +else if (ops->alloc_noncontiguous) +vunmap (vaddr); + } }EXPORT_SYMBOL_GPL (dma_vunmap_noncontiguous);
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 3/6 x86/hyper-v: Add hyperv Isolation VM check in the cc_platform_has()
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V provides Isolation VM which has memory encrypt support. Add hyperv_cc_platform_has() and return true for check of GUEST_MEM_ENCRYPT attribute.
--- arch/x86/kernel/cc_platform.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
arch/x86/kernel/cc_platform.c +15 -0
@@ -11,6 +11,7 @@#include <linux/cc_platform.h> #include <linux/mem_encrypt.h> +#include <asm/mshyperv.h> #include <asm/processor.h> static bool __maybe_unused intel_cc_platform_has (enum cc_attr attr)
@@ -58,9 +59,23 @@ static bool amd_cc_platform_has(enum cc_attr attr)#endif } +static bool hyperv_cc_platform_has (enum cc_attr attr) +{ +#ifdef CONFIG_HYPERV +if (attr ==CC_ATTR_GUEST_MEM_ENCRYPT ) +return true; +else +return false; +#else +return false; +#endif +}bool cc_platform_has (enum cc_attr attr) { +if (hv_is_isolation_supported ()) +return hyperv_cc_platform_has (attr); +if (sme_me_mask)return amd_cc_platform_has (attr);
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 4/6 hyperv/IOMMU: Enable swiotlb bounce buffer for Isolation VM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
hyperv Isolation VM requires bounce buffer support to copy data from/to encrypted memory and so enable swiotlb force mode to use swiotlb bounce buffer for DMA transaction.
In Isolation VM with AMD SEV, the bounce buffer needs to be accessed via extra address space which is above shared_gpa_boundary (E.G 39 bit address line) reported by Hyper-V CPUID ISOLATION_CONFIG. The access physical address will be original physical address + shared_gpa_boundary. The shared_gpa_boundary in the AMD SEV SNP spec is called virtual top of memory(vTOM). Memory addresses below vTOM are automatically treated as private while memory above vTOM is treated as shared.
Hyper-V initalizes swiotlb bounce buffer and default swiotlb needs to be disabled. pci_swiotlb_detect_override() and pci_swiotlb_detect_4gb() enable the default one. To override the setting, hyperv_swiotlb_detect() needs to run before these detect functions which depends on the pci_xen_swiotlb_ init(). Make pci_xen_swiotlb_init() depends on the hyperv_swiotlb _detect() to keep the order.
Swiotlb bounce buffer code calls set_memory_decrypted() to mark bounce buffer visible to host and map it in extra address space via memremap. Populate the shared_gpa_boundary (vTOM) via swiotlb_unencrypted_base variable.
The map function memremap() can't work in the early place hyperv_iommu_swiotlb_init() and so call swiotlb_update_mem_attributes() in the hyperv_iommu_swiotlb_later_init().
Add Hyper-V dma ops and provide alloc/free and vmap/vunmap noncontiguous callback to handle request of allocating and mapping noncontiguous dma memory in vmbus device driver. Netvsc driver will use this. Set dma_ops_ bypass flag for hv device to use dma direct functions during mapping/unmapping dma page.
---
Change since v1:
* Remove hv isolation check in the sev_setup_arch()
arch/x86/mm/mem_encrypt.c | 1 + arch/x86/xen/pci-swiotlb-xen.c | 3 +- drivers/hv/Kconfig | 1 + drivers/hv/vmbus_drv.c | 6 ++ drivers/iommu/hyperv-iommu.c | 164 +++++++++++++++++++++++++++++++++ include/linux/hyperv.h | 10 ++ 6 files changed, 184 insertions(+), 1 deletion(-)
arch/x86/mm/mem_encrypt.c +1 -0
@@ -31,6 +31,7 @@#include <asm/processor-flags.h> #include <asm/msr.h> #include <asm/cmdline.h> +#include <asm/mshyperv.h> #include "mm_internal.h"
arch/x86/xen/pci-swiotlb-xen.c +2 -1
@@ -4,6 +4,7 @@#include <linux/dma-map-ops.h> #include <linux/pci.h> +#include <linux/hyperv.h> #include <xen/swiotlb-xen.h> #include <asm/xen/hypervisor.h>
@@ -91,6 +92,6 @@ int pci_xen_swiotlb_init_late(void)EXPORT_SYMBOL_GPL (pci_xen_swiotlb_init_late);IOMMU_INIT_FINISH (pci_xen_swiotlb_detect, -NULL , + hyperv_swiotlb_detect, pci_xen_swiotlb_init,NULL );
drivers/hv/Kconfig +1 -0
@@ -9,6 +9,7 @@ config HYPERV select PARAVIRT select X86_HV_CALLBACK_VECTOR if X86 select VMAP_PFN + select DMA_OPS_BYPASS help Select this option to run Linux as a Hyper-V client operating system.
drivers/hv/vmbus_drv.c +6 -0
@@ -33,6 +33,7 @@#include <linux/random.h> #include <linux/kernel.h> #include <linux/syscore_ops.h> +#include <linux/dma-map-ops.h> #include <clocksource/hyperv_timer.h> #include "hyperv_vmbus.h"
@@ -2078,6 +2079,7 @@ struct hv_device *vmbus_device_create(const guid_t *type,return child_device_obj; } +static u64 vmbus_dma_mask =DMA_BIT_MASK (64 );/* * vmbus_device_register - Register the child device */
@@ -2118,6 +2120,10 @@ int vmbus_device_register(struct hv_device *child_device_obj) }hv_debug_add_dev_dir (child_device_obj); + child_device_obj->device.dma_ops_bypass = true; + child_device_obj->device.dma_ops = &hyperv_iommu_dma_ops; + child_device_obj->device.dma_mask = &vmbus_dma_mask; + child_device_obj->device.dma_parms = &child_device_obj->dma_parms;return 0 ; err_kset_unregister:
drivers/iommu/hyperv-iommu.c +164 -0
182 lines not on this page · raw message
include/linux/hyperv.h +10 -0
@@ -1726,6 +1726,16 @@ int hyperv_write_cfg_blk(struct pci_dev *dev, void *buf, unsigned int len,int hyperv_reg_block_invalidate (struct pci_dev *dev,void *context,void (*block_invalidate)(void *context,u64 block_mask)); +#ifdef CONFIG_HYPERV +int __init hyperv_swiotlb_detect (void ); +#else +static inline int __init hyperv_swiotlb_detect (void ) +{ +return 0 ; +} +#endif + +extern const struct dma_map_ops hyperv_iommu_dma_ops;struct hyperv_pci_block_ops { int (*read_block)(struct pci_dev *dev, void *buf, unsigned int buf_len,
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH V2 4/6] hyperv/IOMMU: Enable swiotlb bounce buffer for Isolation VM
From: Tianyu Lan <[email protected]> Sent: Tuesday, November 23, 2021 6:31 AM
Quoted 55 lines
hyperv Isolation VM requires bounce buffer support to copy data from/to encrypted memory and so enable swiotlb force mode to use swiotlb bounce buffer for DMA transaction.
In Isolation VM with AMD SEV, the bounce buffer needs to be accessed via extra address space which is above
shared_gpa_boundary(E.G 39 bit address line) reported by Hyper-V CPUIDISOLATION_CONFIG. The access physical address will be original physical address +shared_gpa_boundary. Theshared_gpa_boundaryin the AMD SEV SNP spec is called virtual top of memory(vTOM). Memory addresses below vTOM are automatically treated as private while memory above vTOM is treated as shared.Hyper-V initalizes swiotlb bounce buffer and default swiotlb needs to be disabled.
pci_swiotlb_detect_override()andpci_swiotlb_detect_4gb()enable the default one. To override the setting,hyperv_swiotlb_detect()needs to run before these detect functions which depends on thepci_xen_swiotlb_init(). Makepci_xen_swiotlb_init()depends on thehyperv_swiotlb_detect()to keep the order.Swiotlb bounce buffer code calls
set_memory_decrypted()to mark bounce buffer visible to host and map it in extra address space via memremap. Populate theshared_gpa_boundary(vTOM) viaswiotlb_unencrypted_basevariable.The map function
memremap()can't work in the early placehyperv_iommu_swiotlb_init()and so callswiotlb_update_mem_attributes()in thehyperv_iommu_swiotlb_later_init().Add Hyper-V dma ops and provide alloc/free and vmap/vunmap noncontiguous callback to handle request of allocating and mapping noncontiguous dma memory in vmbus device driver. Netvsc driver will use this. Set
dma_ops_bypass flag for hv device to use dma direct functions during mapping/unmapping dma page.Signed-off-by Tianyu Lan <[email protected]>---
Change since v1:
* Remove hv isolation check in thesev_setup_arch()arch/x86/mm/mem_encrypt.c | 1 + arch/x86/xen/pci-swiotlb-xen.c | 3 +- drivers/hv/Kconfig | 1 + drivers/hv/vmbus_drv.c | 6 ++ drivers/iommu/hyperv-iommu.c | 164 +++++++++++++++++++++++++++++++++ include/linux/hyperv.h | 10 ++ 6 files changed, 184 insertions(+), 1 deletion(-)arch/x86/mm/mem_encrypt.c +0
-0
arch/x86/mm/mem_encrypt.c line 34
Quoted 4 lines
arch/x86/mm/mem_encrypt.c +1
-0@@ -31,6 +31,7 @@#include <asm/processor-flags.h> #include <asm/msr.h> #include <asm/cmdline.h> +#include <asm/mshyperv.h>
There is no longer any need to add this #include since code changes to this file in a previous version of the patch are now gone.
Quoted 144 lines
arch/x86/mm/mem_encrypt.c +0
-0#include "mm_internal.h" arch/x86/xen/pci-swiotlb-xen.c +2
-1@@ -4,6 +4,7 @@#include <linux/dma-map-ops.h> #include <linux/pci.h> +#include <linux/hyperv.h> #include <xen/swiotlb-xen.h> #include <asm/xen/hypervisor.h> @@ -91,6 +92,6 @@ int pci_xen_swiotlb_init_late(void)EXPORT_SYMBOL_GPL (pci_xen_swiotlb_init_late);IOMMU_INIT_FINISH (pci_xen_swiotlb_detect, -NULL , + hyperv_swiotlb_detect, pci_xen_swiotlb_init,NULL );drivers/hv/Kconfig +1
-0@@ -9,6 +9,7 @@ config HYPERV select PARAVIRT select X86_HV_CALLBACK_VECTOR if X86 select VMAP_PFN + select DMA_OPS_BYPASS help Select this option to run Linux as a Hyper-V client operating system.drivers/hv/vmbus_drv.c +6
-0@@ -33,6 +33,7 @@#include <linux/random.h> #include <linux/kernel.h> #include <linux/syscore_ops.h> +#include <linux/dma-map-ops.h> #include <clocksource/hyperv_timer.h> #include "hyperv_vmbus.h" @@ -2078,6 +2079,7 @@ struct hv_device *vmbus_device_create(const guid_t *type,return child_device_obj; } +static u64 vmbus_dma_mask =DMA_BIT_MASK (64 );/* * vmbus_device_register - Register the child device */ @@ -2118,6 +2120,10 @@ int vmbus_device_register(struct hv_device *child_device_obj) }hv_debug_add_dev_dir (child_device_obj); + child_device_obj->device.dma_ops_bypass = true; + child_device_obj->device.dma_ops = &hyperv_iommu_dma_ops; + child_device_obj->device.dma_mask = &vmbus_dma_mask; + child_device_obj->device.dma_parms = &child_device_obj->dma_parms;return 0 ; err_kset_unregister:drivers/iommu/hyperv-iommu.c +55
-0@@ -13,14 +13,21 @@#include <linux/irq.h> #include <linux/iommu.h> #include <linux/module.h> +#include <linux/hyperv.h> +#include <linux/io.h> #include <asm/apic.h> #include <asm/cpu.h> #include <asm/hw_irq.h> #include <asm/io_apic.h> +#include <asm/iommu.h> +#include <asm/iommu_table.h> #include <asm/irq_remapping.h> #include <asm/hypervisor.h> #include <asm/mshyperv.h> +#include <asm/swiotlb.h> +#include <linux/dma-map-ops.h> +#include <linux/dma-direct.h> #include "irq_remapping.h" @@ -337,4 +344,161 @@ static const struct irq_domain_ops hyperv_root_ir_domain_ops = { .free = hyperv_root_irq_remapping_free, }; +static void __init hyperv_iommu_swiotlb_init (void ) +{ +unsigned long hyperv_io_tlb_size; +void *hyperv_io_tlb_start; + +/* +* Allocate Hyper-V swiotlb bounce buffer at early place +* to reserve large contiguous memory. +*/ + hyperv_io_tlb_size =swiotlb_size_or_default (); + hyperv_io_tlb_start =memblock_alloc (hyperv_io_tlb_size,PAGE_SIZE ); + +if (!hyperv_io_tlb_start) +pr_warn ("Fail to allocate Hyper-V swiotlb buffer.\n" ); + +swiotlb_init_with_tbl (hyperv_io_tlb_start, + hyperv_io_tlb_size >>IO_TLB_SHIFT , true); +} + +int __init hyperv_swiotlb_detect (void ) +{ +if (!hypervisor_is_type (X86_HYPER_MS_HYPERV )) +return 0 ; + +if (!hv_is_isolation_supported ()) +return 0 ; + +/* +* Enable swiotlb force mode in Isolation VM to +* use swiotlb bounce buffer for dma transaction. +*/ +if (hv_isolation_type_snp ()) + swiotlb_unencrypted_base = ms_hyperv.shared_gpa_boundary; + swiotlb_force =SWIOTLB_FORCE ; +return 1 ; +} + +static void __init hyperv_iommu_swiotlb_later_init (void ) +{ +/* +* Swiotlb bounce buffer needs to be mapped in extra address +* space. Map function doesn't work in the early place and so +* call swiotlb_update_mem_attributes() here. +*/ +swiotlb_update_mem_attributes (); +} + +IOMMU_INIT_FINISH(hyperv_swiotlb_detect,
drivers/iommu/hyperv-iommu.c static const struct irq_domain_ops hyperv_root_ir_domain_ops = { · line 404
Quoted 10 lines
drivers/iommu/hyperv-iommu.c +10
-0+NULL , hyperv_iommu_swiotlb_init, + hyperv_iommu_swiotlb_later_init); + +static struct sg_table *hyperv_dma_alloc_noncontiguous (struct device *dev, +size_t size,enum dma_data_direction dir,gfp_t gfp, +unsigned long attrs) +{ +struct dma_sgt_handle *sh; +struct page **pages; +int num_pages = size >>PAGE_SHIFT ;
This assumes "size" is a multiple of PAGE_SIZE. Probably should round up for safety.
Quoted 18 lines
drivers/iommu/hyperv-iommu.c +18
-0+void *vaddr, *ptr; +int rc, i; + +if (!hv_isolation_type_snp ()) +return NULL ; + + sh =kmalloc (sizeof (*sh), gfp); +if (!sh) +return NULL ; + + vaddr =vmalloc (size); +if (!vaddr) + goto free_sgt; + + pages =kvmalloc_array (num_pages,sizeof (struct page *), +GFP_KERNEL | __GFP_ZERO); +if (!pages) + goto free_mem;
drivers/iommu/hyperv-iommu.c static const struct irq_domain_ops hyperv_root_ir_domain_ops = { · line 432
Quoted 10 lines
drivers/iommu/hyperv-iommu.c +10
-0+ +for (i =0 , ptr = vaddr; i < num_pages; ++i, ptr +=PAGE_SIZE ) + pages[i] =vmalloc_to_page (ptr); + + rc =sg_alloc_table_from_pages (&sh->sgt, pages, num_pages,0 , size,GFP_KERNEL ); +if (rc) + goto free_pages; + + sh->sgt.sgl->dma_address = (dma_addr_t )vaddr; + sh->sgt.sgl->dma_length = size;
include/linux/scatterlist.h defines macros sg_dma_address() andsg_dma_len() for accessing these two fields. It's probably best to use them.
Quoted 12 lines
drivers/iommu/hyperv-iommu.c +12
-0+ sh->pages = pages; + +return &sh->sgt; + +free_pages: +kvfree (pages); +free_mem: +vfree (vaddr); +free_sgt: +kfree (sh); +return NULL ; +}
drivers/iommu/hyperv-iommu.c static const struct irq_domain_ops hyperv_root_ir_domain_ops = { · line 454
Quoted 10 lines
drivers/iommu/hyperv-iommu.c +10
-0+ +static void hyperv_dma_free_noncontiguous (struct device *dev,size_t size, +struct sg_table *sgt,enum dma_data_direction dir) +{ +struct dma_sgt_handle *sh =sgt_handle (sgt); + +if (!hv_isolation_type_snp ()) +return ; + +vfree ((void *)sh->sgt.sgl->dma_address);
Use sg_dma_address()
drivers/iommu/hyperv-iommu.c static const struct irq_domain_ops hyperv_root_ir_domain_ops = { · line 463
Quoted 9 lines
drivers/iommu/hyperv-iommu.c +9
-0+sg_free_table (&sh->sgt); +kvfree (sh->pages); +kfree (sh); +} + +static void *hyperv_dma_vmap_noncontiguous (struct device *dev,size_t size, +struct sg_table *sgt) +{ +int pg_count = size >>PAGE_SHIFT ;
Round up so don't assume size is a multiple of PAGE_SIZE?
Quoted 63 lines
drivers/iommu/hyperv-iommu.c +40
-0+unsigned long *pfns; +struct page **pages =sgt_handle (sgt)->pages; +void *vaddr =NULL ; +int i; + +if (!hv_isolation_type_snp ()) +return NULL ; + +if (!pages) +return NULL ; + + pfns =kcalloc (pg_count,sizeof (*pfns),GFP_KERNEL ); +if (!pfns) +return NULL ; + +for (i =0 ; i < pg_count; i++) + pfns[i] =page_to_pfn (pages[i]) + + (ms_hyperv.shared_gpa_boundary >>PAGE_SHIFT ); + + vaddr =vmap_pfn (pfns, pg_count,PAGE_KERNEL ); +kfree (pfns); + return vaddr; + +} + +static void hyperv_dma_vunmap_noncontiguous (struct device *dev,void *addr) +{ +if (!hv_isolation_type_snp ()) +return ; +vunmap (addr); +} + +const struct dma_map_ops hyperv_iommu_dma_ops = { + .alloc_noncontiguous = hyperv_dma_alloc_noncontiguous, + .free_noncontiguous = hyperv_dma_free_noncontiguous, + .vmap_noncontiguous = hyperv_dma_vmap_noncontiguous, + .vunmap_noncontiguous = hyperv_dma_vunmap_noncontiguous, +}; +EXPORT_SYMBOL_GPL (hyperv_iommu_dma_ops); +#endif include/linux/hyperv.h +10
-1@@ -1726,6 +1726,16 @@ int hyperv_write_cfg_blk(struct pci_dev *dev, void *buf, unsigned int len,int hyperv_reg_block_invalidate (struct pci_dev *dev,void *context,void (*block_invalidate)(void *context,u64 block_mask)); +#ifdef CONFIG_HYPERV +int __init hyperv_swiotlb_detect (void ); +#else +static inline int __init hyperv_swiotlb_detect (void ) +{ +return 0 ; +} +#endif + +extern const struct dma_map_ops hyperv_iommu_dma_ops;struct hyperv_pci_block_ops { int (*read_block)(struct pci_dev *dev, void *buf, unsigned int buf_len, --
Quoted 1 line
2.25.1
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 5/6 net: netvsc: Add Isolation VM support for netvsc driver
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
In Isolation VM, all shared memory with host needs to mark visible to host via hvcall. vmbus_establish_gpadl() has already done it for netvsc rx/tx ring buffer. The page buffer used by vmbus_sendpacket_ pagebuffer() stills need to be handled. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V swiotlb bounce buffer dma address will be returned. The swiotlb bounce buffer has been masked to be visible to host during boot up.
Allocate rx/tx ring buffer via dma_alloc_noncontiguous() in Isolation VM. After calling vmbus_establish_gpadl() which marks these pages visible to host, map these pages unencrypted addes space via dma_vmap_noncontiguous().
--- drivers/net/hyperv/hyperv_net.h | 5 + drivers/net/hyperv/netvsc.c | 192 +++++++++++++++++++++++++++--- drivers/net/hyperv/rndis_filter.c | 2 + include/linux/hyperv.h | 6 + 4 files changed, 190 insertions(+), 15 deletions(-)
drivers/net/hyperv/hyperv_net.h +5 -0
@@ -164,6 +164,7 @@ struct hv_netvsc_packet {u32 total_bytes;u32 send_buf_index;u32 total_data_buflen; +struct hv_dma_range *dma_range; };#define NETVSC_HASH_KEYLEN 40
@@ -1074,6 +1075,7 @@ struct netvsc_device {/* Receive buffer allocated by us but manages by NetVSP */ void *recv_buf; +struct sg_table *recv_sgt;u32 recv_buf_size;/* allocated bytes */ struct vmbus_gpadl recv_buf_gpadl_handle;u32 recv_section_cnt;
@@ -1082,6 +1084,7 @@ struct netvsc_device {/* Send buffer allocated by us */ void *send_buf; +struct sg_table *send_sgt;u32 send_buf_size;struct vmbus_gpadl send_buf_gpadl_handle;u32 send_section_cnt;
@@ -1731,4 +1734,6 @@ struct rndis_message {#define RETRY_US_HI 10000#define RETRY_MAX 2000/* >10 sec */ +void netvsc_dma_unmap (struct hv_device *hv_dev, +struct hv_netvsc_packet *packet);#endif /* _HYPERV_NET_H */
drivers/net/hyperv/netvsc.c +177 -15
291 lines not on this page · raw message
drivers/net/hyperv/rndis_filter.c +2 -0
@@ -361,6 +361,8 @@ static void rndis_filter_receive_response(struct net_device *ndev, } } +netvsc_dma_unmap (((struct net_device_context *) +netdev_priv (ndev))->device_ctx, &request->pkt);complete (&request->wait_event); }else { netdev_err(ndev,
include/linux/hyperv.h +6 -0
@@ -25,6 +25,7 @@#include <linux/interrupt.h> #include <linux/reciprocal_div.h> #include <asm/hyperv-tlfs.h> +#include <linux/dma-map-ops.h> #define MAX_PAGE_BUFFER_COUNT 32#define MAX_MULTIPAGE_BUFFER_COUNT 32/* 128K */
@@ -1583,6 +1584,11 @@ struct hyperv_service_callback {void (*callback)(void *context); }; +struct hv_dma_range { +dma_addr_t dma; +u32 mapping_size; +}; +#define MAX_SRV_VER 0x7ffffff extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen, const int *fw_version, int fw_vercnt,
Signature · 1 line
2.25.1
RE: [PATCH V2 5/6] net: netvsc: Add Isolation VM support for netvsc driver
From: Tianyu Lan <[email protected]> Sent: Tuesday, November 23, 2021 6:31 AM
Quoted 116 lines
In Isolation VM, all shared memory with host needs to mark visible to host via hvcall.
vmbus_establish_gpadl()has already done it for netvsc rx/tx ring buffer. The page buffer used byvmbus_sendpacket_pagebuffer()stills need to be handled. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V swiotlb bounce buffer dma address will be returned. The swiotlb bounce buffer has been masked to be visible to host during boot up.Allocate rx/tx ring buffer via
dma_alloc_noncontiguous()in Isolation VM. After callingvmbus_establish_gpadl()which marks these pages visible to host, map these pages unencrypted addes space viadma_vmap_noncontiguous().Signed-off-by Tianyu Lan <[email protected]>--- drivers/net/hyperv/hyperv_net.h | 5 + drivers/net/hyperv/netvsc.c | 192 +++++++++++++++++++++++++++--- drivers/net/hyperv/rndis_filter.c | 2 + include/linux/hyperv.h | 6 + 4 files changed, 190 insertions(+), 15 deletions(-)drivers/net/hyperv/hyperv_net.h +5
-0@@ -164,6 +164,7 @@ struct hv_netvsc_packet {u32 total_bytes;u32 send_buf_index;u32 total_data_buflen; +struct hv_dma_range *dma_range; };#define NETVSC_HASH_KEYLEN 40@@ -1074,6 +1075,7 @@ struct netvsc_device {/* Receive buffer allocated by us but manages by NetVSP */ void *recv_buf; +struct sg_table *recv_sgt;u32 recv_buf_size;/* allocated bytes */ struct vmbus_gpadl recv_buf_gpadl_handle;u32 recv_section_cnt;@@ -1082,6 +1084,7 @@ struct netvsc_device {/* Send buffer allocated by us */ void *send_buf; +struct sg_table *send_sgt;u32 send_buf_size;struct vmbus_gpadl send_buf_gpadl_handle;u32 send_section_cnt;@@ -1731,4 +1734,6 @@ struct rndis_message {#define RETRY_US_HI 10000#define RETRY_MAX 2000/* >10 sec */ +void netvsc_dma_unmap (struct hv_device *hv_dev, +struct hv_netvsc_packet *packet);#endif /* _HYPERV_NET_H */ drivers/net/hyperv/netvsc.c +28
-3@@ -20,6 +20,7 @@#include <linux/vmalloc.h> #include <linux/rtnetlink.h> #include <linux/prefetch.h> +#include <linux/gfp.h> #include <asm/sync_bitops.h> #include <asm/mshyperv.h> @@ -146,15 +147,39 @@ static struct netvsc_device *alloc_net_device(void)return net_device; } +static struct hv_device *netvsc_channel_to_device (struct vmbus_channel *channel) +{ +struct vmbus_channel *primary = channel->primary_channel; + +return primary ? primary->device_obj : channel->device_obj; +} +static void free_netvsc_device (struct rcu_head *head) {struct netvsc_device *nvdev = container_of(head, struct netvsc_device, rcu); +struct hv_device *dev = +netvsc_channel_to_device (nvdev->chan_table[0 ].channel);int i;kfree (nvdev->extension); -vfree (nvdev->recv_buf); -vfree (nvdev->send_buf); + +if (nvdev->recv_sgt) { +dma_vunmap_noncontiguous (&dev->device, nvdev->recv_buf); +dma_free_noncontiguous (&dev->device, nvdev->recv_buf_size, + nvdev->recv_sgt,DMA_FROM_DEVICE ); + }else { +vfree (nvdev->recv_buf); + } + +if (nvdev->send_sgt) { +dma_vunmap_noncontiguous (&dev->device, nvdev->send_buf); +dma_free_noncontiguous (&dev->device, nvdev->send_buf_size, + nvdev->send_sgt,DMA_TO_DEVICE ); + }else { +vfree (nvdev->send_buf); + } +kfree (nvdev->send_section_map);for (i =0 ; i <VRSS_CHANNEL_MAX ; i++) {@@ -348,7 +373,21 @@ static int netvsc_init_buf(struct hv_device *device, buf_size = min_t(unsigned int, buf_size,NETVSC_RECEIVE_BUFFER_SIZE_LEGACY ); - net_device->recv_buf =vzalloc (buf_size); +if (hv_isolation_type_snp ()) {
drivers/net/hyperv/netvsc.c static int netvsc_init_buf(struct hv_device *device, · line 386
Quoted 10 lines
drivers/net/hyperv/netvsc.c +10
-0+ net_device->recv_sgt = +dma_alloc_noncontiguous (&device->device, buf_size, +DMA_FROM_DEVICE ,GFP_KERNEL ,0 ); +if (!net_device->recv_sgt) { +pr_err ("Fail to allocate recv buffer buf_size %d.\n." , buf_size); + ret = -ENOMEM ; + goto cleanup; + } + + net_device->recv_buf = (void *)net_device->recv_sgt->sgl->dma_address;
Use sg_dma_address() macro.
Quoted 42 lines
drivers/net/hyperv/netvsc.c +18
-3+ }else { + net_device->recv_buf =vzalloc (buf_size); + } +if (!net_device->recv_buf) { netdev_err(ndev, "unable to allocate receive buffer of size %u\n",@@ -357,8 +396,6 @@ static int netvsc_init_buf(struct hv_device *device, goto cleanup; } - net_device->recv_buf_size = buf_size; -/* * Establish the gpadl handle for this buffer on this * channel. Note: This call uses the vmbus connection rather @@ -373,6 +410,19 @@ static int netvsc_init_buf(struct hv_device *device, goto cleanup; } +if (net_device->recv_sgt) { + net_device->recv_buf = +dma_vmap_noncontiguous (&device->device, buf_size, + net_device->recv_sgt); +if (!net_device->recv_buf) { +pr_err ("Fail to vmap recv buffer.\n" ); + ret = -ENOMEM ; + goto cleanup; + } + } + + net_device->recv_buf_size = buf_size; +/* Notify the NetVsp of the gpadl handle */ init_packet = &net_device->channel_init_pkt;memset (init_packet,0 ,sizeof (struct nvsp_message ));@@ -454,14 +504,27 @@ static int netvsc_init_buf(struct hv_device *device, buf_size = device_info->send_sections * device_info->send_section_size; buf_size =round_up (buf_size,PAGE_SIZE ); - net_device->send_buf =vzalloc (buf_size); +if (hv_isolation_type_snp ()) {
drivers/net/hyperv/netvsc.c static int netvsc_init_buf(struct hv_device *device, · line 517
Quoted 10 lines
drivers/net/hyperv/netvsc.c +10
-0+ net_device->send_sgt = +dma_alloc_noncontiguous (&device->device, buf_size, +DMA_TO_DEVICE ,GFP_KERNEL ,0 ); +if (!net_device->send_sgt) { +pr_err ("Fail to allocate send buffer buf_size %d.\n." , buf_size); + ret = -ENOMEM ; + goto cleanup; + } + + net_device->send_buf = (void *)net_device->send_sgt->sgl->dma_address;
Use sg_dma_address() macro.
Quoted 121 lines
drivers/net/hyperv/netvsc.c +85
-2+ }else { + net_device->send_buf =vzalloc (buf_size); + } +if (!net_device->send_buf) {netdev_err (ndev,"unable to allocate send buffer of size %u\n" , buf_size); ret = -ENOMEM ; goto cleanup; } - net_device->send_buf_size = buf_size;/* Establish the gpadl handle for this buffer on this * channel. Note: This call uses the vmbus connection rather @@ -476,6 +539,19 @@ static int netvsc_init_buf(struct hv_device *device, goto cleanup; } +if (net_device->send_sgt) { + net_device->send_buf = +dma_vmap_noncontiguous (&device->device, buf_size, + net_device->send_sgt); +if (!net_device->send_buf) { +pr_err ("Fail to vmap send buffer.\n" ); + ret = -ENOMEM ; + goto cleanup; + } + } + + net_device->send_buf_size = buf_size; +/* Notify the NetVsp of the gpadl handle */ init_packet = &net_device->channel_init_pkt;memset (init_packet,0 ,sizeof (struct nvsp_message ));@@ -766,7 +842,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev,/* Notify the layer above us */ if (likely (skb)) { -const struct hv_netvsc_packet *packet +struct hv_netvsc_packet *packet = (struct hv_netvsc_packet *)skb->cb;u32 send_index = packet->send_buf_index;struct netvsc_stats *tx_stats;@@ -782,6 +858,7 @@ static void netvsc_send_tx_complete(struct net_device *ndev, tx_stats->bytes += packet->total_bytes;u64_stats_update_end (&tx_stats->syncp); +netvsc_dma_unmap (ndev_ctx->device_ctx, packet);napi_consume_skb (skb, budget); }@@ -946,6 +1023,87 @@ static void netvsc_copy_to_send_buf(struct netvsc_device *net_device,memset (dest,0 , padding); } +void netvsc_dma_unmap (struct hv_device *hv_dev, +struct hv_netvsc_packet *packet) +{ +u32 page_count = packet->cp_partial ? + packet->page_buf_cnt - packet->rmsg_pgcnt : + packet->page_buf_cnt; +int i; + +if (!hv_is_isolation_supported ()) +return ; + +if (!packet->dma_range) +return ; + +for (i =0 ; i < page_count; i++) +dma_unmap_single (&hv_dev->device, packet->dma_range[i].dma, + packet->dma_range[i].mapping_size, +DMA_TO_DEVICE ); + +kfree (packet->dma_range); +} + +/* netvsc_dma_map - Map swiotlb bounce buffer with data page of +* packet sent by vmbus_sendpacket_pagebuffer() in the Isolation +* VM. +* +* In isolation VM, netvsc send buffer has been marked visible to +* host and so the data copied to send buffer doesn't need to use +* bounce buffer. The data pages handled by vmbus_sendpacket_pagebuffer() +* may not be copied to send buffer and so these pages need to be +* mapped with swiotlb bounce buffer. netvsc_dma_map() is to do +* that. The pfns in the struct hv_page_buffer need to be converted +* to bounce buffer's pfn. The loop here is necessary because the +* entries in the page buffer array are not necessarily full +* pages of data. Each entry in the array has a separate offset and +* len that may be non-zero, even for entries in the middle of the +* array. And the entries are not physically contiguous. So each +* entry must be individually mapped rather than as a contiguous unit. +* So not use dma_map_sg() here. +*/ +static int netvsc_dma_map (struct hv_device *hv_dev, +struct hv_netvsc_packet *packet, +struct hv_page_buffer *pb) +{ +u32 page_count = packet->cp_partial ? + packet->page_buf_cnt - packet->rmsg_pgcnt : + packet->page_buf_cnt; +dma_addr_t dma; +int i; + +if (!hv_is_isolation_supported ()) +return 0 ; + + packet->dma_range =kcalloc (page_count, +sizeof (*packet->dma_range), +GFP_KERNEL ); +if (!packet->dma_range) +return -ENOMEM ; + +for (i =0 ; i < page_count; i++) { +char *src =phys_to_virt ((pb[i].pfn <<HV_HYP_PAGE_SHIFT ) + + pb[i].offset); +u32 len = pb[i].len; + + dma =dma_map_single (&hv_dev->device, src, len, +DMA_TO_DEVICE );
drivers/net/hyperv/netvsc.c static void netvsc_copy_to_send_buf(struct netvsc_device *net_device, · line 1101
Quoted 10 lines
drivers/net/hyperv/netvsc.c +10
-0+if (dma_mapping_error (&hv_dev->device, dma)) { +kfree (packet->dma_range); +return -ENOMEM ; + } + + packet->dma_range[i].dma = dma; + packet->dma_range[i].mapping_size = len; + pb[i].pfn = dma >>HV_HYP_PAGE_SHIFT ; + pb[i].offset =offset_in_hvpage (dma); + pb[i].len = len;
As noted in comments on an earlier version of this patch, the pb[i].len and .offset fields should not be changed by doing dma_map_single(). So there's no need to set them again here. Adding a comment to that effect might be good.
Quoted 94 lines
drivers/net/hyperv/netvsc.c +16
-7+ } + +return 0 ; +} + static inline int netvsc_send_pkt( struct hv_device *device, struct hv_netvsc_packet *packet,@@ -986,14 +1144,24 @@ static inline int netvsc_send_pkt(trace_nvsp_send_pkt (ndev, out_channel, rpkt); + packet->dma_range =NULL ;if (packet->page_buf_cnt) {if (packet->cp_partial) pb += packet->rmsg_pgcnt; + ret =netvsc_dma_map (ndev_ctx->device_ctx, packet, pb); +if (ret) { + ret = -EAGAIN ; + goto exit; + } + ret =vmbus_sendpacket_pagebuffer (out_channel, pb, packet->page_buf_cnt, &nvmsg,sizeof (nvmsg), req_id); + +if (ret) +netvsc_dma_unmap (ndev_ctx->device_ctx, packet); }else { ret = vmbus_sendpacket(out_channel, &nvmsg, sizeof(nvmsg),@@ -1001,6 +1169,7 @@ static inline int netvsc_send_pkt( VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); } +exit:if (ret ==0 ) {atomic_inc_return (&nvchan->queue_sends);@@ -1515,13 +1684,6 @@ static int netvsc_process_raw_pkt(struct hv_device *device,return 0 ; } -static struct hv_device *netvsc_channel_to_device (struct vmbus_channel *channel) -{ -struct vmbus_channel *primary = channel->primary_channel; - -return primary ? primary->device_obj : channel->device_obj; -} -/* Network processing softirq * Process data in incoming ring buffer from host * Stops when ring is empty or budget is met or exceeded. drivers/net/hyperv/rndis_filter.c +2
-0@@ -361,6 +361,8 @@ static void rndis_filter_receive_response(struct net_device *ndev, } } +netvsc_dma_unmap (((struct net_device_context *) +netdev_priv (ndev))->device_ctx, &request->pkt);complete (&request->wait_event); }else { netdev_err(ndev,include/linux/hyperv.h +6
-1@@ -25,6 +25,7 @@#include <linux/interrupt.h> #include <linux/reciprocal_div.h> #include <asm/hyperv-tlfs.h> +#include <linux/dma-map-ops.h> #define MAX_PAGE_BUFFER_COUNT 32#define MAX_MULTIPAGE_BUFFER_COUNT 32/* 128K */ @@ -1583,6 +1584,11 @@ struct hyperv_service_callback {void (*callback)(void *context); }; +struct hv_dma_range { +dma_addr_t dma; +u32 mapping_size; +}; +#define MAX_SRV_VER 0x7ffffff extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen, const int *fw_version, int fw_vercnt, --2.25.1
RE: [PATCH V2 5/6] net: netvsc: Add Isolation VM support for netvsc driver
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]> Sent: Tuesday, November 23, 2021 6:31 AM
Quoted 9 lines
In Isolation VM, all shared memory with host needs to mark visible to host via hvcall.
vmbus_establish_gpadl()has already done it for netvsc rx/tx ring buffer. The page buffer used byvmbus_sendpacket_pagebuffer()stills need to be handled. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V swiotlb bounce buffer dma address will be returned. The swiotlb bounce buffer has been masked to be visible to host during boot up.
Quoted 4 lines
Allocate rx/tx ring buffer via
dma_alloc_noncontiguous()in Isolation VM. After callingvmbus_establish_gpadl()which marks these pages visible to host, map these pages unencrypted addes space viadma_vmap_noncontiguous().
The big unresolved topic is how best to do the allocation and mapping of the big netvsc send and receive buffers. Let me summarize and make a recommendation.
Background
==========
1. Each Hyper-V synthetic network device requires a large pre-allocated receive buffer (defaults to 16 Mbytes) and a similar send buffer (defaults to 1 Mbyte).
2. The buffers are allocated in guest memory and shared with the Hyper-V host. As such, in the Hyper-V SNP environment, the memory must be unencrypted and accessed in the Hyper-V guest with shared_gpa_boundary (i.e., VTOM) added to the physical memory address.
3. The buffers need *not* be contiguous in guest physical memory, but must be contiguously mapped in guest kernel virtual space.
4. Network devices may come and go during the life of the VM, so allocation of these buffers and their mappings may be done after Linux has been running for a long time.
5. Performance of the allocation and mapping process is not an issue since it is done only on synthetic network device add/remove.
6. So the primary goals are an appropriate logical abstraction, code that is simple and straightforward, and efficient memory usage.
Approaches
==========
During the development of these patches, four approaches have been implemented:
1. Two virtual mappings: One from vmalloc() to allocate the guest memory, and
the second from vmap_pfns() after adding the shared_gpa_boundary. This is
implemented in Hyper-V or netvsc specific code, with no use of DMA APIs. No separate list of physical pages is maintained, so for creating the second mapping, the PFN list is assembled temporarily by doing virt-to-phys() page-by-page on the vmalloc mapping, and then discarded because it is no longer needed. [v4 of the original patch series.]
2. Two virtual mappings as in (1) above, but implemented via new DMA calls dma_map_decrypted() and dma_unmap_encrypted(). [v3 of the original patch series.]
3. Two virtual mappings as in (1) above, but implemented via DMA noncontiguous allocation and mapping calls, as enhanced to allow for custom map/unmap implementations. A list of physical pages is maintained in the dma_sgt_handle as expected by the DMA noncontiguous API. [New split-off patch series v1 & v2]
4. Single virtual mapping from vmap_pfns(). The netvsc driver allocates physical
memory via alloc_pages() with as much contiguity as possible, and maintains a
list of physical pages and ranges. Single virtual map is setup with vmap_pfns()
after adding shared_gpa_boundary. [v5 of the original patch series.]
Both implementations using DMA APIs use very little of the existing DMA machinery. Both require extensions to the DMA APIs, and custom ops functions. While in some sense the netvsc send and receive buffers involve DMA, they do not require any DMA actions on a per-I/O basis. It seems better to me to not try to fit these two buffers into the DMA model as a one-off. Let's just use Hyper-V specific code to allocate and map them, as is done with the Hyper-V VMbus channel ring buffers.
That leaves approaches (1) and (4) above. Between those two, (1) is simpler even though there are two virtual mappings. Using alloc_pages() as in (4) is messy and there's no real benefit to using higher order allocations.
(4) also requires maintaining a separate list of PFNs and ranges, which offsets some of the benefits to having only one virtual mapping active at any point in time.
I don't think there's a clear "right" answer, so it's a judgment call. We've explored what other approaches would look like, and I'd say let's go with
(1) as the simpler approach. Thoughts?
Michael
Haiyang Zhang
maintainerRE: [PATCH V2 5/6] net: netvsc: Add Isolation VM support for netvsc driver
Quoted 96 lines
-----Original Message-----
From: Michael Kelley (LINUX) <[email protected]>
Sent: Wednesday, November 24, 2021 12:03 PM
To: Tianyu Lan <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; KY Srinivasan <[email protected]>; Haiyang Zhang <[email protected]>; Stephen Hemminger <[email protected]>; [email protected]; Dexuan Cui <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; Tianyu Lan <[email protected]>; [email protected]; xen- [email protected]
Cc: [email protected]; [email protected]; linux- [email protected]; [email protected]; [email protected]; vkuznets <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]
Subject: RE: [PATCH V2 5/6] net: netvsc: Add Isolation VM support for netvsc driverFrom: Tianyu Lan <[email protected]> Sent: Tuesday, November 23, 2021 6:31 AM
Quoted 9 lines
In Isolation VM, all shared memory with host needs to mark visible to host via hvcall.
vmbus_establish_gpadl()has already done it for netvsc rx/tx ring buffer. The page buffer used byvmbus_sendpacket_pagebuffer()stills need to be handled. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V swiotlb bounce buffer dma address will be returned. The swiotlb bounce buffer has been masked to be visible to host during boot up.Quoted 4 lines
Allocate rx/tx ring buffer via
dma_alloc_noncontiguous()in Isolation VM. After callingvmbus_establish_gpadl()which marks these pages visible to host, map these pages unencrypted addes space viadma_vmap_noncontiguous().The big unresolved topic is how best to do the allocation and mapping of the big netvsc send and receive buffers. Let me summarize and make a recommendation.
Background
==========
1. Each Hyper-V synthetic network device requires a large pre-allocated receive buffer (defaults to 16 Mbytes) and a similar send buffer (defaults to 1 Mbyte).
2. The buffers are allocated in guest memory and shared with the Hyper-V host. As such, in the Hyper-V SNP environment, the memory must be unencrypted and accessed in the Hyper-V guest withshared_gpa_boundary(i.e., VTOM) added to the physical memory address.
3. The buffers need *not* be contiguous in guest physical memory, but must be contiguously mapped in guest kernel virtual space.
4. Network devices may come and go during the life of the VM, so allocation of these buffers and their mappings may be done after Linux has been running for a long time.
5. Performance of the allocation and mapping process is not an issue since it is done only on synthetic network device add/remove.
6. So the primary goals are an appropriate logical abstraction, code that is simple and straightforward, and efficient memory usage.Approaches
==========
During the development of these patches, four approaches have been implemented:1. Two virtual mappings: One from
vmalloc()to allocate the guest memory, and
the second fromvmap_pfns()after adding theshared_gpa_boundary. This is
implemented in Hyper-V or netvsc specific code, with no use of DMA APIs. No separate list of physical pages is maintained, so for creating the second mapping, the PFN list is assembled temporarily by doing virt-to-phys() page-by-page on the vmalloc mapping, and then discarded because it is no longer needed. [v4 of the original patch series.]2. Two virtual mappings as in (1) above, but implemented via new DMA calls
dma_map_decrypted()anddma_unmap_encrypted(). [v3 of the original patch series.]3. Two virtual mappings as in (1) above, but implemented via DMA noncontiguous allocation and mapping calls, as enhanced to allow for custom map/unmap implementations. A list of physical pages is maintained in the
dma_sgt_handleas expected by the DMA noncontiguous API. [New split-off patch series v1 & v2]4. Single virtual mapping from
vmap_pfns(). The netvsc driver allocates physical
memory viaalloc_pages()with as much contiguity as possible, and maintains a
list of physical pages and ranges. Single virtual map is setup withvmap_pfns()
after addingshared_gpa_boundary. [v5 of the original patch series.]Both implementations using DMA APIs use very little of the existing DMA machinery. Both require extensions to the DMA APIs, and custom ops functions.
While in some sense the netvsc send and receive buffers involve DMA, they do not require any DMA actions on a per-I/O basis. It seems better to me to not try to fit these two buffers into the DMA model as a one-off. Let's just use Hyper-V specific code to allocate and map them, as is done with the Hyper-V VMbus channel ring buffers.That leaves approaches (1) and (4) above. Between those two, (1) is simpler even though there are two virtual mappings. Using
alloc_pages()as in (4) is messy and there's no real benefit to using higher order allocations.
(4) also requires maintaining a separate list of PFNs and ranges, which offsets some of the benefits to having only one virtual mapping active at any point in time.
Quoted 4 lines
I don't think there's a clear "right" answer, so it's a judgment call. We've explored what other approaches would look like, and I'd say let's go with
(1) as the simpler approach. Thoughts?
I agree with the following goal:
"So the primary goals are an appropriate logical abstraction, code that is
simple and straightforward, and efficient memory usage."
And the Approach #1 looks better to me as well.
Thanks,
- Haiyang
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v2 6/6 scsi: storvsc: Add Isolation VM support for storvsc driver
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
In Isolation VM, all shared memory with host needs to mark visible to host via hvcall. vmbus_establish_gpadl() has already done it for storvsc rx/tx ring buffer. The page buffer used by vmbus_sendpacket_ mpb_desc() still needs to be handled. Use DMA API(scsi_dma_map/unmap) to map these memory during sending/receiving packet and return swiotlb bounce buffer dma address. In Isolation VM, swiotlb bounce buffer is marked to be visible to host and the swiotlb force mode is enabled.
Set device's dma min align mask to HV_HYP_PAGE_SIZE - 1 in order to keep the original data offset in the bounce buffer.
--- drivers/scsi/storvsc_drv.c | 37 +++++++++++++++++++++---------------- include/linux/hyperv.h | 1 + 2 files changed, 22 insertions(+), 16 deletions(-)
drivers/scsi/storvsc_drv.c +21 -16
@@ -21,6 +21,8 @@#include <linux/device.h> #include <linux/hyperv.h> #include <linux/blkdev.h> +#include <linux/dma-mapping.h> +#include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_host.h>
@@ -1336,6 +1338,7 @@ static void storvsc_on_channel_callback(void *context)continue ; } request = (struct storvsc_cmd_request *)scsi_cmd_priv (scmnd); +scsi_dma_unmap (scmnd); }storvsc_on_receive (stor_device, packet, request);
@@ -1749,7 +1752,6 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)struct hv_host_device *host_dev =shost_priv (host);struct hv_device *dev = host_dev->dev;struct storvsc_cmd_request *cmd_request =scsi_cmd_priv (scmnd); -int i;struct scatterlist *sgl;unsigned int sg_count;struct vmscsi_request *vm_srb;
@@ -1831,10 +1833,11 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd) payload_sz =sizeof (cmd_request->mpb);if (sg_count) { -unsigned int hvpgoff, hvpfns_to_add;unsigned long offset_in_hvpg =offset_in_hvpage (sgl->offset);unsigned int hvpg_count =HVPFN_UP (offset_in_hvpg + length); -u64 hvpfn; +struct scatterlist *sg; +unsigned long hvpfn, hvpfns_to_add; +int j, i =0 ;if (hvpg_count >MAX_PAGE_BUFFER_COUNT ) {
@@ -1848,21 +1851,22 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd) payload->range.len = length; payload->range.offset = offset_in_hvpg; + sg_count =scsi_dma_map (scmnd); +if (sg_count <0 ) +return SCSI_MLQUEUE_DEVICE_BUSY ; -for (i =0 ; sgl !=NULL ; sgl =sg_next (sgl)) { +for_each_sg (sgl, sg, sg_count, j) {/* -* Init values for the current sgl entry. hvpgoff -* and hvpfns_to_add are in units of Hyper-V size -* pages. Handling the PAGE_SIZE != HV_HYP_PAGE_SIZE -* case also handles values of sgl->offset that are -* larger than PAGE_SIZE. Such offsets are handled -* even on other than the first sgl entry, provided -* they are a multiple of PAGE_SIZE. +* Init values for the current sgl entry. hvpfns_to_add +* is in units of Hyper-V size pages. Handling the +* PAGE_SIZE != HV_HYP_PAGE_SIZE case also handles +* values of sgl->offset that are larger than PAGE_SIZE. +* Such offsets are handled even on other than the first +* sgl entry, provided they are a multiple of PAGE_SIZE. */ - hvpgoff =HVPFN_DOWN (sgl->offset); - hvpfn =page_to_hvpfn (sg_page (sgl)) + hvpgoff; - hvpfns_to_add =HVPFN_UP (sgl->offset + sgl->length) - - hvpgoff; + hvpfn =HVPFN_DOWN (sg_dma_address (sg)); + hvpfns_to_add =HVPFN_UP (sg_dma_address (sg) + +sg_dma_len (sg)) - hvpfn;/* * Fill the next portion of the PFN array with
@@ -1872,7 +1876,7 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)* the PFN array is filled. */ while (hvpfns_to_add--) - payload->range.pfn_array[i++] = hvpfn++; + payload->range.pfn_array[i++] = hvpfn++; } }
@@ -2016,6 +2020,7 @@ static int storvsc_probe(struct hv_device *device, stor_device->vmscsi_size_delta =sizeof (struct vmscsi_win8_extension );spin_lock_init (&stor_device->lock);hv_set_drvdata (device, stor_device); +dma_set_min_align_mask (&device->device,HV_HYP_PAGE_SIZE -1 ); stor_device->port_number = host->host_no; ret =storvsc_connect_to_vsp (device, storvsc_ringbuffer_size, is_fc);
include/linux/hyperv.h +1 -0
@@ -1262,6 +1262,7 @@ struct hv_device {struct vmbus_channel *channel;struct kset *channels_kset; +struct device_dma_parameters dma_parms;/* place holder to keep track of the dir for hv device in debugfs */ struct dentry *debug_dir;
Signature · 1 line
2.25.1