x86/Hyper-V: Add Hyper-V Isolation VM support
Subsystems (11)
v4 cover x86/Hyper-V: Add Hyper-V Isolation VM support
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.
There are two exceptions - packets sent by vmbus_sendpacket_ pagebuffer() and vmbus_sendpacket_mpb_desc(). These packets contains IO stack memory address and host will access these memory. So add allocation bounce buffer support in vmbus for these packets.
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.
Change since v3:
- Add interface set_memory_decrypted_map() to decrypt memory and
map bounce buffer in extra address space
- Remove swiotlb remap function and store the remap address
returned by set_memory_decrypted_map() in swiotlb mem data structure.
- Introduce hv_set_mem_enc() to make code more readable in the __set_memory_enc_dec().
Change since v2:
- Remove not UIO driver in Isolation VM patch
- Use vmap_pfn() to replace ioremap_page_range function in order to avoid exposing symbol ioremap_page_range() and ioremap_page_range()
- Call hv set mem host visibility hvcall in set_memory_encrypted/decrypted()
- Enable swiotlb force mode instead of adding Hyper-V dma map/unmap hook
- Fix code style
Tianyu Lan (13):
x86/HV: Initialize GHCB page in Isolation VM
x86/HV: Initialize shared memory boundary in the Isolation VM. x86/HV: Add new hvcall guest address host visibility support
HV: Mark vmbus ring buffer visible to host in Isolation VM
HV: Add Write/Read MSR registers via ghcb page
HV: Add ghcb hvcall support for SNP VM
HV/Vmbus: Add SNP support for VMbus channel initiate message HV/Vmbus: Initialize VMbus ring buffer for Isolation VM x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM HV/IOMMU: Enable swiotlb bounce buffer for Isolation VM HV/Netvsc: Add Isolation VM support for netvsc driver HV/Storvsc: Add Isolation VM support for storvsc driver x86/HV: Not set memory decrypted/encrypted during kexec alloc/free
page in IVM
arch/x86/hyperv/Makefile | 2 +- arch/x86/hyperv/hv_init.c | 25 +-- arch/x86/hyperv/ivm.c | 299 +++++++++++++++++++++++++++++ arch/x86/include/asm/hyperv-tlfs.h | 18 ++ arch/x86/include/asm/mshyperv.h | 84 +++++++- arch/x86/include/asm/set_memory.h | 2 + arch/x86/include/asm/sev-es.h | 4 + arch/x86/kernel/cpu/mshyperv.c | 5 + arch/x86/kernel/machine_kexec_64.c | 5 +- arch/x86/kernel/sev-es-shared.c | 21 +- arch/x86/mm/pat/set_memory.c | 34 +++- arch/x86/xen/pci-swiotlb-xen.c | 3 +- drivers/hv/Kconfig | 1 + drivers/hv/channel.c | 48 ++++- drivers/hv/connection.c | 71 ++++++- drivers/hv/hv.c | 129 +++++++++---- drivers/hv/hyperv_vmbus.h | 3 + drivers/hv/ring_buffer.c | 84 ++++++-- drivers/hv/vmbus_drv.c | 3 + drivers/iommu/hyperv-iommu.c | 62 ++++++ drivers/net/hyperv/hyperv_net.h | 6 + drivers/net/hyperv/netvsc.c | 144 +++++++++++++- drivers/net/hyperv/rndis_filter.c | 2 + drivers/scsi/storvsc_drv.c | 68 ++++++- include/asm-generic/hyperv-tlfs.h | 1 + include/asm-generic/mshyperv.h | 53 ++++- include/linux/hyperv.h | 16 ++ include/linux/swiotlb.h | 4 + kernel/dma/swiotlb.c | 11 +- 29 files changed, 1097 insertions(+), 111 deletions(-) create mode 100644 arch/x86/hyperv/ivm.c
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 1/13 x86/HV: Initialize GHCB page in Isolation VM
From: Tianyu Lan <[email protected]>
Hyper-V exposes GHCB page via SEV ES GHCB MSR for SNP guest to communicate with hypervisor. Map GHCB page for all cpus to read/write MSR register and submit hvcall request via GHCB.
--- arch/x86/hyperv/hv_init.c | 64 ++++++++++++++++++++++++++++++--- arch/x86/include/asm/mshyperv.h | 2 ++ include/asm-generic/mshyperv.h | 2 ++ 3 files changed, 64 insertions(+), 4 deletions(-)
arch/x86/hyperv/hv_init.c +60 -4
@@ -20,6 +20,7 @@#include <linux/kexec.h> #include <linux/version.h> #include <linux/vmalloc.h> +#include <linux/io.h> #include <linux/mm.h> #include <linux/hyperv.h> #include <linux/slab.h>
@@ -54,6 +55,26 @@ EXPORT_SYMBOL_GPL(hyperv_pcpu_output_arg);u32 hv_max_vp_index;EXPORT_SYMBOL_GPL (hv_max_vp_index); +static int hyperv_init_ghcb (void ) +{ +u64 ghcb_gpa; +void *ghcb_va; +void **ghcb_base; + +if (!ms_hyperv.ghcb_base) +return -EINVAL ; + +rdmsrl (MSR_AMD64_SEV_ES_GHCB , ghcb_gpa); + ghcb_va =memremap (ghcb_gpa,HV_HYP_PAGE_SIZE ,MEMREMAP_WB ); +if (!ghcb_va) +return -ENOMEM ; + + ghcb_base = (void **)this_cpu_ptr (ms_hyperv.ghcb_base); + *ghcb_base = ghcb_va; + +return 0 ; +} +static int hv_cpu_init (unsigned int cpu) {u64 msr_vp_index;
@@ -106,6 +127,8 @@ static int hv_cpu_init(unsigned int cpu)wrmsrl (HV_X64_MSR_VP_ASSIST_PAGE , val); } +hyperv_init_ghcb (); +return 0 ; }
@@ -201,6 +224,7 @@ static int hv_cpu_die(unsigned int cpu)unsigned long flags;void **input_arg;void *pg; +void **ghcb_va =NULL ;local_irq_save (flags); input_arg = (void **)this_cpu_ptr (hyperv_pcpu_input_arg);
@@ -214,6 +238,13 @@ static int hv_cpu_die(unsigned int cpu) *output_arg =NULL ; } +if (ms_hyperv.ghcb_base) { + ghcb_va = (void **)this_cpu_ptr (ms_hyperv.ghcb_base); +if (*ghcb_va) +memunmap (*ghcb_va); + *ghcb_va =NULL ; + } +local_irq_restore (flags);free_pages ((unsigned long )pg, hv_root_partition ?1 :0 );
@@ -410,9 +441,22 @@ void __init hyperv_init(void)VMALLOC_END ,GFP_KERNEL ,PAGE_KERNEL_ROX ,VM_FLUSH_RESET_PERMS ,NUMA_NO_NODE , __builtin_return_address(0)); -if (hv_hypercall_pg ==NULL ) { -wrmsrl (HV_X64_MSR_GUEST_OS_ID ,0 ); - goto remove_cpuhp_state; +if (hv_hypercall_pg ==NULL ) + goto clean_guest_os_id; + +if (hv_isolation_type_snp ()) { + ms_hyperv.ghcb_base = alloc_percpu(void *); +if (!ms_hyperv.ghcb_base) + goto clean_guest_os_id; + +if (hyperv_init_ghcb ()) { +free_percpu (ms_hyperv.ghcb_base); + ms_hyperv.ghcb_base =NULL ; + goto clean_guest_os_id; + } + +/* Hyper-V requires to write guest os id via ghcb in SNP IVM. */ +hv_ghcb_msr_write (HV_X64_MSR_GUEST_OS_ID , guest_id); }rdmsrl (HV_X64_MSR_HYPERCALL , hypercall_msr.as_uint64);
@@ -473,7 +517,8 @@ void __init hyperv_init(void)hv_query_ext_cap (0 );return ; -remove_cpuhp_state: +clean_guest_os_id: +wrmsrl (HV_X64_MSR_GUEST_OS_ID ,0 );cpuhp_remove_state (cpuhp); free_vp_assist_page:kfree (hv_vp_assist_page);
@@ -502,6 +547,9 @@ void hyperv_cleanup(void)*/ hv_hypercall_pg =NULL ; +if (ms_hyperv.ghcb_base) +free_percpu (ms_hyperv.ghcb_base); +/* Reset the hypercall page */ hypercall_msr.as_uint64 =0 ;wrmsrl (HV_X64_MSR_HYPERCALL , hypercall_msr.as_uint64);
@@ -586,6 +634,14 @@ bool hv_is_isolation_supported(void) }EXPORT_SYMBOL_GPL (hv_is_isolation_supported); +DEFINE_STATIC_KEY_FALSE (isolation_type_snp); + +bool hv_isolation_type_snp (void ) +{ +return static_branch_unlikely (&isolation_type_snp); +} +EXPORT_SYMBOL_GPL (hv_isolation_type_snp); +/* Bit mask of the extended capability to query: see HV_EXT_CAPABILITY_xxx */ bool hv_query_ext_cap (u64 cap_query) {
arch/x86/include/asm/mshyperv.h +2 -0
@@ -11,6 +11,8 @@#include <asm/paravirt.h> #include <asm/mshyperv.h> +DECLARE_STATIC_KEY_FALSE (isolation_type_snp); +typedef int (*hyperv_fill_flush_list_func )(struct hv_guest_mapping_flush_list *flush,void *data);
include/asm-generic/mshyperv.h +2 -0
@@ -35,6 +35,7 @@ struct ms_hyperv_info {u32 max_lp_index;u32 isolation_config_a;u32 isolation_config_b; +void __percpu **ghcb_base; };extern struct ms_hyperv_info ms_hyperv;
@@ -224,6 +225,7 @@ bool hv_is_hyperv_initialized(void);bool hv_is_hibernation_supported (void );enum hv_isolation_type hv_get_isolation_type (void );bool hv_is_isolation_supported (void ); +bool hv_isolation_type_snp (void );void hyperv_cleanup (void );bool hv_query_ext_cap (u64 cap_query);#else /* CONFIG_HYPERV */
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 2/13 x86/HV: Initialize shared memory boundary in the Isolation VM.
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V exposes shared memory boundary via cpuid HYPERV_CPUID_ISOLATION_CONFIG and store it in the shared_gpa_boundary of ms_hyperv struct. This prepares to share memory with host for SNP guest.
--- arch/x86/kernel/cpu/mshyperv.c | 2 ++ include/asm-generic/mshyperv.h | 12 +++++++++++- 2 files changed, 13 insertions(+), 1 deletion(-)
arch/x86/kernel/cpu/mshyperv.c +2 -0
@@ -334,6 +334,8 @@ static void __init ms_hyperv_init_platform(void)if (ms_hyperv.priv_high &HV_ISOLATION ) { ms_hyperv.isolation_config_a =cpuid_eax (HYPERV_CPUID_ISOLATION_CONFIG ); ms_hyperv.isolation_config_b =cpuid_ebx (HYPERV_CPUID_ISOLATION_CONFIG ); + ms_hyperv.shared_gpa_boundary = + (u64 )1 << ms_hyperv.shared_gpa_boundary_bits;pr_info ("Hyper-V: Isolation Config: Group A 0x%x, Group B 0x%x\n" , ms_hyperv.isolation_config_a, ms_hyperv.isolation_config_b);
include/asm-generic/mshyperv.h +11 -1
@@ -34,8 +34,18 @@ struct ms_hyperv_info {u32 max_vp_index;u32 max_lp_index;u32 isolation_config_a; -u32 isolation_config_b; +union { +u32 isolation_config_b; +struct { +u32 cvm_type :4 ; +u32 Reserved11 :1 ; +u32 shared_gpa_boundary_active :1 ; +u32 shared_gpa_boundary_bits :6 ; +u32 Reserved12 :20 ; + }; + };void __percpu **ghcb_base; +u64 shared_gpa_boundary; };extern struct ms_hyperv_info ms_hyperv;
Signature · 1 line
2.25.1
RFC PATCH v4 3/13 x86/HV: Add new hvcall guest address host visibility support
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Add new hvcall guest address host visibility support to mark memory visible to host. Call it inside set_memory_decrypted /encrypted().
--- arch/x86/hyperv/Makefile | 2 +- arch/x86/hyperv/ivm.c | 112 +++++++++++++++++++++++++++++ arch/x86/include/asm/hyperv-tlfs.h | 18 +++++ arch/x86/include/asm/mshyperv.h | 3 +- arch/x86/mm/pat/set_memory.c | 6 +- include/asm-generic/hyperv-tlfs.h | 1 + 6 files changed, 139 insertions(+), 3 deletions(-) create mode 100644 arch/x86/hyperv/ivm.c
arch/x86/hyperv/Makefile +1 -1
@@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only -obj-y := hv_init.o mmu.o nested.o irqdomain.o +obj-y := hv_init.o mmu.o nested.o irqdomain.o ivm.o obj-$(CONFIG_X86_64) += hv_apic.o hv_proc.o ifdef CONFIG_X86_64
arch/x86/hyperv/ivm.c new file +112 -0
112 lines not on this page · raw message
arch/x86/include/asm/hyperv-tlfs.h +18 -0
@@ -262,6 +262,11 @@ enum hv_isolation_type {#define HV_X64_MSR_TIME_REF_COUNT HV_REGISTER_TIME_REF_COUNT#define HV_X64_MSR_REFERENCE_TSC HV_REGISTER_REFERENCE_TSC +/* Hyper-V GPA map flags */ +#define VMBUS_PAGE_NOT_VISIBLE 0 +#define VMBUS_PAGE_VISIBLE_READ_ONLY 1 +#define VMBUS_PAGE_VISIBLE_READ_WRITE 3 +/* * Declare the MSR used to setup pages used to communicate with the hypervisor. */
@@ -561,4 +566,17 @@ enum hv_interrupt_type {#include <asm-generic/hyperv-tlfs.h> +/* All input parameters should be in single page. */ +#define HV_MAX_MODIFY_GPA_REP_COUNT \ + ((PAGE_SIZE / sizeof(u64)) - 2) + +/* HvCallModifySparseGpaPageHostVisibility hypercall */ +struct hv_gpa_range_for_visibility { +u64 partition_id; +u32 host_visibility:2 ; +u32 reserved0:30 ; +u32 reserved1; +u64 gpa_page_list[HV_MAX_MODIFY_GPA_REP_COUNT ]; +} __packed; +#endif
arch/x86/include/asm/mshyperv.h +2 -1
@@ -194,7 +194,8 @@ struct irq_domain *hv_create_pci_msi_domain(void);int hv_map_ioapic_interrupt (int ioapic_id,bool level,int vcpu,int vector,struct hv_interrupt_entry *entry);int hv_unmap_ioapic_interrupt (int ioapic_id,struct hv_interrupt_entry *entry); - +int hv_mark_gpa_visibility (u16 count,const u64 pfn[],u32 visibility); +int hv_set_mem_enc (unsigned long addr,int numpages,bool enc);#else /* CONFIG_HYPERV */ static inline void hyperv_init (void ) {}static inline void hyperv_setup_mmu_ops (void ) {}
arch/x86/mm/pat/set_memory.c +5 -1
@@ -29,6 +29,8 @@#include <asm/proto.h> #include <asm/memtype.h> #include <asm/set_memory.h> +#include <asm/hyperv-tlfs.h> +#include <asm/mshyperv.h> #include "../mm_internal.h"
@@ -1986,7 +1988,9 @@ static int __set_memory_enc_dec(unsigned long addr, int numpages, bool enc)int ret;/* Nothing to do if memory encryption is not active */ -if (!mem_encrypt_active ()) +if (hv_is_isolation_supported ()) +return hv_set_mem_enc (addr, numpages, enc); +else if (!mem_encrypt_active ())return 0 ;/* Should not be working on unaligned addresses */
include/asm-generic/hyperv-tlfs.h +1 -0
@@ -158,6 +158,7 @@ struct ms_hyperv_tsc_page {#define HVCALL_RETARGET_INTERRUPT 0x007e#define HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_SPACE 0x00af#define HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_LIST 0x00b0 +#define HVCALL_MODIFY_SPARSE_GPA_PAGE_HOST_VISIBILITY 0x00db/* Extended hypercalls */ #define HV_EXT_CALL_QUERY_CAPABILITIES 0x8001
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 4/13 HV: Mark vmbus ring buffer visible to host in Isolation VM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Mark vmbus ring buffer visible with set_memory_decrypted() when establish gpadl handle.
--- drivers/hv/channel.c | 38 ++++++++++++++++++++++++++++++++++++-- include/linux/hyperv.h | 10 ++++++++++ 2 files changed, 46 insertions(+), 2 deletions(-)
drivers/hv/channel.c +36 -2
@@ -17,6 +17,7 @@#include <linux/hyperv.h> #include <linux/uio.h> #include <linux/interrupt.h> +#include <linux/set_memory.h> #include <asm/page.h> #include <asm/mshyperv.h>
@@ -465,7 +466,7 @@ static int __vmbus_establish_gpadl(struct vmbus_channel *channel,struct list_head *curr;u32 next_gpadl_handle;unsigned long flags; -int ret =0 ; +int ret =0 , index; next_gpadl_handle = (atomic_inc_return (&vmbus_connection.next_gpadl_handle) -1 );
@@ -474,6 +475,13 @@ static int __vmbus_establish_gpadl(struct vmbus_channel *channel,if (ret)return ret; + ret =set_memory_decrypted ((unsigned long )kbuffer, +HVPFN_UP (size)); +if (ret) { +pr_warn ("Failed to set host visibility.\n" ); +return ret; + } +init_completion (&msginfo->waitevent); msginfo->waiting_channel = channel;
@@ -539,6 +547,15 @@ static int __vmbus_establish_gpadl(struct vmbus_channel *channel,/* At this point, we received the gpadl created msg */ *gpadl_handle = gpadlmsg->gpadl; +if (type ==HV_GPADL_BUFFER ) + index =0 ; +else + index = channel->gpadl_range[1 ].gpadlhandle ?2 :1 ; + + channel->gpadl_range[index].size = size; + channel->gpadl_range[index].buffer = kbuffer; + channel->gpadl_range[index].gpadlhandle = *gpadl_handle; + cleanup:spin_lock_irqsave (&vmbus_connection.channelmsg_lock, flags);list_del (&msginfo->msglistentry);
@@ -549,6 +566,11 @@ static int __vmbus_establish_gpadl(struct vmbus_channel *channel, }kfree (msginfo); + +if (ret) +set_memory_encrypted ((unsigned long )kbuffer, +HVPFN_UP (size)); +return ret; }
@@ -811,7 +833,7 @@ int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle)struct vmbus_channel_gpadl_teardown *msg;struct vmbus_channel_msginfo *info;unsigned long flags; -int ret; +int ret, i; info =kzalloc (sizeof (*info) +sizeof (struct vmbus_channel_gpadl_teardown ),GFP_KERNEL );
@@ -859,6 +881,18 @@ int vmbus_teardown_gpadl(struct vmbus_channel *channel, u32 gpadl_handle)spin_unlock_irqrestore (&vmbus_connection.channelmsg_lock, flags);kfree (info); + +/* Find gpadl buffer virtual address and size. */ +for (i =0 ; i <VMBUS_GPADL_RANGE_COUNT ; i++) +if (channel->gpadl_range[i].gpadlhandle == gpadl_handle) +break ; + +if (set_memory_encrypted ((unsigned long )channel->gpadl_range[i].buffer, +HVPFN_UP (channel->gpadl_range[i].size))) +pr_warn ("Fail to set mem host visibility.\n" ); + + channel->gpadl_range[i].gpadlhandle =0 ; +return ret; }EXPORT_SYMBOL_GPL (vmbus_teardown_gpadl);
include/linux/hyperv.h +10 -0
@@ -809,6 +809,14 @@ struct vmbus_device {#define VMBUS_DEFAULT_MAX_PKT_SIZE 4096 +struct vmbus_gpadl_range { +u32 gpadlhandle; +u32 size; +void *buffer; +}; + +#define VMBUS_GPADL_RANGE_COUNT 3 +struct vmbus_channel {struct list_head listentry;
@@ -829,6 +837,8 @@ struct vmbus_channel {struct completion rescind_event;u32 ringbuffer_gpadlhandle; +/* GPADL_RING and Send/Receive GPADL_BUFFER. */ +struct vmbus_gpadl_range gpadl_range[VMBUS_GPADL_RANGE_COUNT ];/* Allocated memory for ring buffer */ struct page *ringbuffer_page;
Signature · 1 line
2.25.1
RFC PATCH v4 5/13 HV: Add Write/Read MSR registers via ghcb page
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V provides GHCB protocol to write Synthetic Interrupt Controller MSR registers in Isolation VM with AMD SEV SNP and these registers are emulated by hypervisor directly. Hyper-V requires to write SINTx MSR registers twice. First writes MSR via GHCB page to communicate with hypervisor and then writes wrmsr instruction to talk with paravisor which runs in VMPL0. Guest OS ID MSR also needs to be set via GHCB.
--- arch/x86/hyperv/hv_init.c | 25 +------ arch/x86/hyperv/ivm.c | 115 ++++++++++++++++++++++++++++++ arch/x86/include/asm/mshyperv.h | 78 +++++++++++++++++++- arch/x86/include/asm/sev-es.h | 4 ++ arch/x86/kernel/cpu/mshyperv.c | 3 + arch/x86/kernel/sev-es-shared.c | 21 ++++-- drivers/hv/hv.c | 121 ++++++++++++++++++++++---------- include/asm-generic/mshyperv.h | 12 +++- 8 files changed, 308 insertions(+), 71 deletions(-)
arch/x86/hyperv/hv_init.c +2 -23
@@ -445,7 +445,7 @@ void __init hyperv_init(void) goto clean_guest_os_id;if (hv_isolation_type_snp ()) { - ms_hyperv.ghcb_base = alloc_percpu(void *); + ms_hyperv.ghcb_base = alloc_percpu(union hv_ghcb __percpu *);if (!ms_hyperv.ghcb_base) goto clean_guest_os_id;
@@ -539,6 +539,7 @@ void hyperv_cleanup(void)/* Reset our OS id */ wrmsrl (HV_X64_MSR_GUEST_OS_ID ,0 ); +hv_ghcb_msr_write (HV_X64_MSR_GUEST_OS_ID ,0 );/* * Reset hypercall page reference before reset the page,
@@ -620,28 +621,6 @@ bool hv_is_hibernation_supported(void) }EXPORT_SYMBOL_GPL (hv_is_hibernation_supported); -enum hv_isolation_type hv_get_isolation_type (void ) -{ -if (!(ms_hyperv.priv_high &HV_ISOLATION )) -return HV_ISOLATION_TYPE_NONE ; -return FIELD_GET (HV_ISOLATION_TYPE , ms_hyperv.isolation_config_b); -} -EXPORT_SYMBOL_GPL (hv_get_isolation_type); - -bool hv_is_isolation_supported (void ) -{ -return hv_get_isolation_type () !=HV_ISOLATION_TYPE_NONE ; -} -EXPORT_SYMBOL_GPL (hv_is_isolation_supported); - -DEFINE_STATIC_KEY_FALSE (isolation_type_snp); - -bool hv_isolation_type_snp (void ) -{ -return static_branch_unlikely (&isolation_type_snp); -} -EXPORT_SYMBOL_GPL (hv_isolation_type_snp); -/* Bit mask of the extended capability to query: see HV_EXT_CAPABILITY_xxx */ bool hv_query_ext_cap (u64 cap_query) {
arch/x86/hyperv/ivm.c +115 -0
127 lines not on this page · raw message
arch/x86/include/asm/mshyperv.h +77 -1
98 lines not on this page · raw message
arch/x86/include/asm/sev-es.h +4 -0
@@ -103,6 +103,10 @@ static __always_inline void sev_es_nmi_complete(void) __sev_es_nmi_complete(); }extern int __init sev_es_efi_map_ghcbs (pgd_t *pgd); +enum es_result sev_es_ghcb_hv_call (struct ghcb *ghcb, +struct es_em_ctxt *ctxt, +u64 exit_code,u64 exit_info_1, +u64 exit_info_2);#else static inline void sev_es_ist_enter (struct pt_regs *regs) { }static inline void sev_es_ist_exit (void ) { }
arch/x86/kernel/cpu/mshyperv.c +3 -0
@@ -339,6 +339,9 @@ static void __init ms_hyperv_init_platform(void)pr_info ("Hyper-V: Isolation Config: Group A 0x%x, Group B 0x%x\n" , ms_hyperv.isolation_config_a, ms_hyperv.isolation_config_b); + +if (hv_get_isolation_type () ==HV_ISOLATION_TYPE_SNP ) +static_branch_enable (&isolation_type_snp); }if (ms_hyperv.hints &HV_X64_ENLIGHTENED_VMCS_RECOMMENDED ) {
arch/x86/kernel/sev-es-shared.c +15 -6
@@ -93,10 +93,10 @@ static void vc_finish_insn(struct es_em_ctxt *ctxt) ctxt->regs->ip += ctxt->insn.length; } -static enum es_result sev_es_ghcb_hv_call (struct ghcb *ghcb, -struct es_em_ctxt *ctxt, -u64 exit_code,u64 exit_info_1, -u64 exit_info_2) +enum es_result sev_es_ghcb_hv_call (struct ghcb *ghcb, +struct es_em_ctxt *ctxt, +u64 exit_code,u64 exit_info_1, +u64 exit_info_2) {enum es_result ret;
@@ -108,7 +108,16 @@ static enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb,ghcb_set_sw_exit_info_1 (ghcb, exit_info_1);ghcb_set_sw_exit_info_2 (ghcb, exit_info_2); -sev_es_wr_ghcb_msr (__pa (ghcb)); +/* +* Hyper-V runs paravisor with SEV. Ghcb page is allocated by +* paravisor and not needs to be updated in the Linux guest. +* Otherwise, the ghcb page's PA reported by paravisor is above +* VTOM. Hyper-V use this function with NULL for ctxt point and +* skip setting ghcb page in such case. +*/ +if (ctxt) +sev_es_wr_ghcb_msr (__pa (ghcb)); +VMGEXIT ();if ((ghcb->save.sw_exit_info_1 &0xffffffff ) ==1 ) {
@@ -119,7 +128,7 @@ static enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb, v = info &SVM_EVTINJ_VEC_MASK ;/* Check if exception information from hypervisor is sane. */ -if ((info &SVM_EVTINJ_VALID ) && +if (ctxt && (info &SVM_EVTINJ_VALID ) && ((v ==X86_TRAP_GP ) || (v ==X86_TRAP_UD )) && ((info &SVM_EVTINJ_TYPE_MASK ) ==SVM_EVTINJ_TYPE_EXEPT )) { ctxt->fi.vector = v;
drivers/hv/hv.c +82 -39
192 lines not on this page · raw message
include/asm-generic/mshyperv.h +10 -2
@@ -22,9 +22,16 @@#include <linux/atomic.h> #include <linux/bitops.h> #include <linux/cpumask.h> +#include <asm/svm.h> +#include <asm/sev-es.h> #include <asm/ptrace.h> +#include <asm/mshyperv.h> #include <asm/hyperv-tlfs.h> +union hv_ghcb { +struct ghcb ghcb; +} __packed__aligned(PAGE_SIZE) ; +struct ms_hyperv_info {u32 features;u32 priv_high;
@@ -44,13 +51,14 @@ struct ms_hyperv_info { u32 Reserved12 : 20; }; }; -void __percpu **ghcb_base; +union hv_ghcb __percpu **ghcb_base;u64 shared_gpa_boundary; };extern struct ms_hyperv_info ms_hyperv;extern u64 hv_do_hypercall (u64 control,void *inputaddr,void *outputaddr);extern u64 hv_do_fast_hypercall8 (u16 control,u64 input8); +extern bool hv_isolation_type_snp (void );/* Helper functions that provide a consistent pattern for checking Hyper-V hypercall status. */ static inline int hv_result (u64 status)
@@ -145,7 +153,7 @@ static inline void vmbus_signal_eom(struct hv_message *msg, u32 old_msg_type)* possibly deliver another msg from the * hypervisor */ -hv_set_register (HV_REGISTER_EOM ,0 ); +hv_signal_eom (); } }
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 6/13 HV: Add ghcb hvcall support for SNP VM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V provides ghcb hvcall to handle VMBusHVCALL_SIGNAL_EVENT and HVCALL_POST_MESSAGE
msg in SNP Isolation VM. Add such support.
--- arch/x86/hyperv/ivm.c | 42 +++++++++++++++++++++++++++++++++ arch/x86/include/asm/mshyperv.h | 1 + drivers/hv/connection.c | 6 ++++- drivers/hv/hv.c | 8 ++++++- include/asm-generic/mshyperv.h | 29 +++++++++++++++++++++++ 5 files changed, 84 insertions(+), 2 deletions(-)
arch/x86/hyperv/ivm.c +42 -0
@@ -15,6 +15,48 @@#include <asm/io.h> #include <asm/mshyperv.h> +u64 hv_ghcb_hypercall (u64 control,void *input,void *output,u32 input_size) +{ +union hv_ghcb *hv_ghcb; +void **ghcb_base; +unsigned long flags; + +if (!ms_hyperv.ghcb_base) +return -EFAULT ; + +WARN_ON (in_nmi ()); + +local_irq_save (flags); + ghcb_base = (void **)this_cpu_ptr (ms_hyperv.ghcb_base); + hv_ghcb = (union hv_ghcb *)*ghcb_base; +if (!hv_ghcb) { +local_irq_restore (flags); +return -EFAULT ; + } + +memset (hv_ghcb,0x00 ,HV_HYP_PAGE_SIZE ); + hv_ghcb->ghcb.protocol_version =1 ; + hv_ghcb->ghcb.ghcb_usage =1 ; + + hv_ghcb->hypercall.outputgpa = (u64 )output; + hv_ghcb->hypercall.hypercallinput.asuint64 =0 ; + hv_ghcb->hypercall.hypercallinput.callcode = control; + +if (input_size) +memcpy (hv_ghcb->hypercall.hypercalldata, input, input_size); + +VMGEXIT (); + + hv_ghcb->ghcb.ghcb_usage =0xffffffff ; +memset (hv_ghcb->ghcb.save.valid_bitmap,0 , +sizeof (hv_ghcb->ghcb.save.valid_bitmap)); + +local_irq_restore (flags); + +return hv_ghcb->hypercall.hypercalloutput.callstatus; +} +EXPORT_SYMBOL_GPL (hv_ghcb_hypercall); +void hv_ghcb_msr_write (u64 msr,u64 value) {union hv_ghcb *hv_ghcb;
arch/x86/include/asm/mshyperv.h +1 -0
@@ -258,6 +258,7 @@ void hv_sint_rdmsrl_ghcb(u64 msr, u64 *value);void hv_signal_eom_ghcb (void );void hv_ghcb_msr_write (u64 msr,u64 value);void hv_ghcb_msr_read (u64 msr,u64 *value); +u64 hv_ghcb_hypercall (u64 control,void *input,void *output,u32 input_size);#define hv_get_synint_state_ghcb (int_num, val) \ hv_sint_rdmsrl_ghcb(HV_X64_MSR_SINT0 + int_num, val)
drivers/hv/connection.c +5 -1
@@ -445,6 +445,10 @@ void vmbus_set_event(struct vmbus_channel *channel) ++channel->sig_events; -hv_do_fast_hypercall8 (HVCALL_SIGNAL_EVENT , channel->sig_event); +if (hv_isolation_type_snp ()) +hv_ghcb_hypercall (HVCALL_SIGNAL_EVENT , &channel->sig_event, +NULL ,sizeof (u64)); +else +hv_do_fast_hypercall8 (HVCALL_SIGNAL_EVENT , channel->sig_event); }EXPORT_SYMBOL_GPL (vmbus_set_event);
drivers/hv/hv.c +7 -1
@@ -98,7 +98,13 @@ int hv_post_message(union hv_connection_id connection_id, aligned_msg->payload_size = payload_size;memcpy ((void *)aligned_msg->payload, payload, payload_size); - status =hv_do_hypercall (HVCALL_POST_MESSAGE , aligned_msg,NULL ); +if (hv_isolation_type_snp ()) + status =hv_ghcb_hypercall (HVCALL_POST_MESSAGE , + (void *)aligned_msg,NULL , +sizeof (struct hv_input_post_message )); +else + status =hv_do_hypercall (HVCALL_POST_MESSAGE , + aligned_msg,NULL );/* Preemption must remain disabled until after the hypercall * so some other thread can't get scheduled onto this cpu and
include/asm-generic/mshyperv.h +29 -0
@@ -30,6 +30,35 @@union hv_ghcb {struct ghcb ghcb; +struct { +u64 hypercalldata[509 ]; +u64 outputgpa; +union { +union { +struct { +u32 callcode :16 ; +u32 isfast :1 ; +u32 reserved1 :14 ; +u32 isnested :1 ; +u32 countofelements :12 ; +u32 reserved2 :4 ; +u32 repstartindex :12 ; +u32 reserved3 :4 ; + }; +u64 asuint64; + } hypercallinput; +union { +struct { +u16 callstatus; +u16 reserved1; +u32 elementsprocessed :12 ; +u32 reserved2 :20 ; + }; +u64 asunit64; + } hypercalloutput; + }; +u64 reserved2; + } hypercall; } __packed__aligned(PAGE_SIZE) ;struct ms_hyperv_info {
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 7/13 HV/Vmbus: Add SNP support for VMbus channel initiate message
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
The monitor pages in the CHANNELMSG_INITIATE_CONTACT msg are shared with host in Isolation VM and so it's necessary to use hvcall to set them visible to host. In Isolation VM with AMD SEV SNP, the access address should be in the extra space which is above shared gpa boundary. So remap these pages into the extra address(pa + shared_gpa_boundary).
--- drivers/hv/connection.c | 65 +++++++++++++++++++++++++++++++++++++++ drivers/hv/hyperv_vmbus.h | 1 + 2 files changed, 66 insertions(+)
drivers/hv/connection.c +65 -0
@@ -19,6 +19,7 @@#include <linux/vmalloc.h> #include <linux/hyperv.h> #include <linux/export.h> +#include <linux/io.h> #include <asm/mshyperv.h> #include "hyperv_vmbus.h"
@@ -104,6 +105,12 @@ int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo, u32 version) msg->monitor_page1 =virt_to_phys (vmbus_connection.monitor_pages[0 ]); msg->monitor_page2 =virt_to_phys (vmbus_connection.monitor_pages[1 ]); + +if (hv_is_isolation_supported ()) { + msg->monitor_page1 += ms_hyperv.shared_gpa_boundary; + msg->monitor_page2 += ms_hyperv.shared_gpa_boundary; + } + msg->target_vcpu =hv_cpu_number_to_vp_number (VMBUS_CONNECT_CPU );/*
@@ -148,6 +155,31 @@ int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo, u32 version)return -ECONNREFUSED ; } +if (hv_is_isolation_supported ()) { + vmbus_connection.monitor_pages_va[0 ] + = vmbus_connection.monitor_pages[0 ]; + vmbus_connection.monitor_pages[0 ] + =memremap (msg->monitor_page1,HV_HYP_PAGE_SIZE , +MEMREMAP_WB ); +if (!vmbus_connection.monitor_pages[0 ]) +return -ENOMEM ; + + vmbus_connection.monitor_pages_va[1 ] + = vmbus_connection.monitor_pages[1 ]; + vmbus_connection.monitor_pages[1 ] + =memremap (msg->monitor_page2,HV_HYP_PAGE_SIZE , +MEMREMAP_WB ); +if (!vmbus_connection.monitor_pages[1 ]) { +memunmap (vmbus_connection.monitor_pages[0 ]); +return -ENOMEM ; + } + +memset (vmbus_connection.monitor_pages[0 ],0x00 , +HV_HYP_PAGE_SIZE ); +memset (vmbus_connection.monitor_pages[1 ],0x00 , +HV_HYP_PAGE_SIZE ); + } +return ret; }
@@ -159,6 +191,7 @@ int vmbus_connect(void)struct vmbus_channel_msginfo *msginfo =NULL ;int i, ret =0 ;__u32 version; +u64 pfn[2 ];/* Initialize the vmbus connection */ vmbus_connection.conn_state =CONNECTING ;
@@ -216,6 +249,16 @@ int vmbus_connect(void) goto cleanup; } +if (hv_is_isolation_supported ()) { + pfn[0 ] =virt_to_hvpfn (vmbus_connection.monitor_pages[0 ]); + pfn[1 ] =virt_to_hvpfn (vmbus_connection.monitor_pages[1 ]); +if (hv_mark_gpa_visibility (2 , pfn, +VMBUS_PAGE_VISIBLE_READ_WRITE )) { + ret = -EFAULT ; + goto cleanup; + } + } + msginfo =kzalloc (sizeof (*msginfo) +sizeof (struct vmbus_channel_initiate_contact ),GFP_KERNEL );
@@ -282,6 +325,8 @@ int vmbus_connect(void)void vmbus_disconnect (void ) { +u64 pfn[2 ]; +/* * First send the unload request to the host. */
@@ -301,6 +346,26 @@ void vmbus_disconnect(void) vmbus_connection.int_page =NULL ; } +if (hv_is_isolation_supported ()) { +if (vmbus_connection.monitor_pages_va[0 ]) { +memunmap (vmbus_connection.monitor_pages[0 ]); + vmbus_connection.monitor_pages[0 ] + = vmbus_connection.monitor_pages_va[0 ]; + vmbus_connection.monitor_pages_va[0 ] =NULL ; + } + +if (vmbus_connection.monitor_pages_va[1 ]) { +memunmap (vmbus_connection.monitor_pages[1 ]); + vmbus_connection.monitor_pages[1 ] + = vmbus_connection.monitor_pages_va[1 ]; + vmbus_connection.monitor_pages_va[1 ] =NULL ; + } + + pfn[0 ] =virt_to_hvpfn (vmbus_connection.monitor_pages[0 ]); + pfn[1 ] =virt_to_hvpfn (vmbus_connection.monitor_pages[1 ]); +hv_mark_gpa_visibility (2 , pfn,VMBUS_PAGE_NOT_VISIBLE ); + } +hv_free_hyperv_page ((unsigned long )vmbus_connection.monitor_pages[0 ]);hv_free_hyperv_page ((unsigned long )vmbus_connection.monitor_pages[1 ]); vmbus_connection.monitor_pages[0 ] =NULL ;
drivers/hv/hyperv_vmbus.h +1 -0
@@ -240,6 +240,7 @@ struct vmbus_connection {* is child->parent notification */ struct hv_monitor_page *monitor_pages[2 ]; +void *monitor_pages_va[2 ];struct list_head chn_msg_list;spinlock_t channelmsg_lock;
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 8/13 HV/Vmbus: Initialize VMbus ring buffer for Isolation VM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
VMbus ring buffer are shared with host and it's need to be accessed via extra address space of Isolation VM with SNP support. This patch is to map the ring buffer address in extra address space via ioremap(). HV host visibility hvcall smears data in the ring buffer and so reset the ring buffer memory to zero after calling visibility hvcall.
--- drivers/hv/Kconfig | 1 + drivers/hv/channel.c | 10 +++++ drivers/hv/hyperv_vmbus.h | 2 + drivers/hv/ring_buffer.c | 84 ++++++++++++++++++++++++++++++--------- 4 files changed, 79 insertions(+), 18 deletions(-)
drivers/hv/Kconfig +1 -0
@@ -7,6 +7,7 @@ config HYPERV depends on X86 && ACPI && X86_LOCAL_APIC && HYPERVISOR_GUEST select PARAVIRT select X86_HV_CALLBACK_VECTOR + select VMAP_PFN help Select this option to run Linux as a Hyper-V client operating system.
drivers/hv/channel.c +10 -0
@@ -707,6 +707,16 @@ static int __vmbus_open(struct vmbus_channel *newchannel,if (err) goto error_clean_ring; + err =hv_ringbuffer_post_init (&newchannel->outbound, + page, send_pages); +if (err) + goto error_free_gpadl; + + err =hv_ringbuffer_post_init (&newchannel->inbound, + &page[send_pages], recv_pages); +if (err) + goto error_free_gpadl; +/* Create and init the channel open message */ open_info = kzalloc(sizeof(*open_info) + sizeof(struct vmbus_channel_open_channel),
drivers/hv/hyperv_vmbus.h +2 -0
@@ -172,6 +172,8 @@ extern int hv_synic_cleanup(unsigned int cpu);/* Interface */ void hv_ringbuffer_pre_init (struct vmbus_channel *channel); +int hv_ringbuffer_post_init (struct hv_ring_buffer_info *ring_info, +struct page *pages,u32 page_cnt);int hv_ringbuffer_init (struct hv_ring_buffer_info *ring_info,struct page *pages,u32 pagecnt,u32 max_pkt_size);
drivers/hv/ring_buffer.c +66 -18
115 lines not on this page · raw message
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 9/13 x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
In reply to Tianyu LanFrom: 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.
Introduce set_memory_decrypted_map() function to decrypt memory and remap memory with platform callback. Use set_memory_decrypted_ map() in the swiotlb code, store remap address returned by the new API and use the remap address to copy data from/to swiotlb bounce buffer.
--- arch/x86/hyperv/ivm.c | 30 ++++++++++++++++++++++++++++++ arch/x86/include/asm/mshyperv.h | 2 ++ arch/x86/include/asm/set_memory.h | 2 ++ arch/x86/mm/pat/set_memory.c | 28 ++++++++++++++++++++++++++++ include/linux/swiotlb.h | 4 ++++ kernel/dma/swiotlb.c | 11 ++++++++--- 6 files changed, 74 insertions(+), 3 deletions(-)
arch/x86/hyperv/ivm.c +30 -0
@@ -267,3 +267,33 @@ int hv_set_mem_enc(unsigned long addr, int numpages, bool enc) enc ?VMBUS_PAGE_NOT_VISIBLE : VMBUS_PAGE_VISIBLE_READ_WRITE); } + +/* +* hv_map_memory - map memory to extra space in the AMD SEV-SNP Isolation VM. +*/ +unsigned long hv_map_memory (unsigned long addr,unsigned long size) +{ +unsigned long *pfns =kcalloc (size /HV_HYP_PAGE_SIZE , +sizeof (unsigned long ), +GFP_KERNEL ); +unsigned long vaddr; +int i; + +if (!pfns) +return (unsigned long )NULL ; + +for (i =0 ; i < size /HV_HYP_PAGE_SIZE ; i++) + pfns[i] =virt_to_hvpfn ((void *)addr + i *HV_HYP_PAGE_SIZE ) + + (ms_hyperv.shared_gpa_boundary >>HV_HYP_PAGE_SHIFT ); + + vaddr = (unsigned long )vmap_pfn (pfns, size /HV_HYP_PAGE_SIZE , +PAGE_KERNEL_IO ); +kfree (pfns); + +return vaddr; +} + +void hv_unmap_memory (unsigned long addr) +{ +vunmap ((void *)addr); +}
arch/x86/include/asm/mshyperv.h +2 -0
@@ -253,6 +253,8 @@ int hv_map_ioapic_interrupt(int ioapic_id, bool level, int vcpu, int vector,int hv_unmap_ioapic_interrupt (int ioapic_id,struct hv_interrupt_entry *entry);int hv_mark_gpa_visibility (u16 count,const u64 pfn[],u32 visibility);int hv_set_mem_enc (unsigned long addr,int numpages,bool enc); +unsigned long hv_map_memory (unsigned long addr,unsigned long size); +void hv_unmap_memory (unsigned long addr);void hv_sint_wrmsrl_ghcb (u64 msr,u64 value);void hv_sint_rdmsrl_ghcb (u64 msr,u64 *value);void hv_signal_eom_ghcb (void );
arch/x86/include/asm/set_memory.h +2 -0
@@ -49,6 +49,8 @@ int set_memory_decrypted(unsigned long addr, int numpages);int set_memory_np_noalias (unsigned long addr,int numpages);int set_memory_nonglobal (unsigned long addr,int numpages);int set_memory_global (unsigned long addr,int numpages); +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size); +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size);int set_pages_array_uc (struct page **pages,int addrinarray);int set_pages_array_wc (struct page **pages,int addrinarray);
arch/x86/mm/pat/set_memory.c +28 -0
@@ -2039,6 +2039,34 @@ int set_memory_decrypted(unsigned long addr, int numpages) }EXPORT_SYMBOL_GPL (set_memory_decrypted); +static unsigned long __map_memory (unsigned long addr,unsigned long size) +{ +if (hv_is_isolation_supported ()) +return hv_map_memory (addr, size); + +return addr; +} + +static void __unmap_memory (unsigned long addr) +{ +if (hv_is_isolation_supported ()) +hv_unmap_memory (addr); +} + +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size) +{ +if (__set_memory_enc_dec (addr, size /PAGE_SIZE , false)) +return (unsigned long )NULL ; + +return __map_memory (addr, size); +} + +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size) +{ +__unmap_memory (addr); +return __set_memory_enc_dec (addr, size /PAGE_SIZE , true); +} +int set_pages_uc (struct page *page,int numpages) {unsigned long addr = (unsigned long )page_address (page);
include/linux/swiotlb.h +4 -0
@@ -72,6 +72,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. +* @vstart: The virtual start address 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.
@@ -89,6 +92,7 @@ extern enum swiotlb_force swiotlb_force;struct io_tlb_mem {phys_addr_t start;phys_addr_t end; +void *vstart;unsigned long nslabs;unsigned long used;unsigned int index;
kernel/dma/swiotlb.c +8 -3
@@ -194,8 +194,13 @@ static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, mem->slots[i].alloc_size =0 ; } -set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT ); -memset (vaddr,0 , bytes); + mem->vstart = (void *)set_memory_decrypted_map ((unsigned long )vaddr, bytes); +if (!mem->vstart) { +pr_err ("Failed to decrypt memory.\n" ); +return ; + } + +memset (mem->vstart,0 , bytes); }int __init swiotlb_init_with_tbl (char *tlb,unsigned long nslabs,int verbose)
@@ -352,7 +357,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->vstart + tlb_addr - mem->start;if (orig_addr ==INVALID_PHYS_ADDR )return ;
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
Hi Christoph & Konrad:
Could you review this patch and make sure this is right way to
resolve the memory remap request from AMD SEV-SNP vTOM case?
Thanks.
Quoted 173 lines · Tianyu Lan
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 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.Introduce
set_memory_decrypted_map()function to decrypt memory and remap memory with platform callback. Useset_memory_decrypted_map()in the swiotlb code, store remap address returned by the new API and use the remap address to copy data from/to swiotlb bounce buffer.Signed-off-by Tianyu Lan <[email protected]>--- arch/x86/hyperv/ivm.c | 30 ++++++++++++++++++++++++++++++ arch/x86/include/asm/mshyperv.h | 2 ++ arch/x86/include/asm/set_memory.h | 2 ++ arch/x86/mm/pat/set_memory.c | 28 ++++++++++++++++++++++++++++ include/linux/swiotlb.h | 4 ++++ kernel/dma/swiotlb.c | 11 ++++++++--- 6 files changed, 74 insertions(+), 3 deletions(-)arch/x86/hyperv/ivm.c +30
-0@@ -267,3 +267,33 @@ int hv_set_mem_enc(unsigned long addr, int numpages, bool enc) enc ?VMBUS_PAGE_NOT_VISIBLE : VMBUS_PAGE_VISIBLE_READ_WRITE); } + +/* +* hv_map_memory - map memory to extra space in the AMD SEV-SNP Isolation VM. +*/ +unsigned long hv_map_memory (unsigned long addr,unsigned long size) +{ +unsigned long *pfns =kcalloc (size /HV_HYP_PAGE_SIZE , +sizeof (unsigned long ), +GFP_KERNEL ); +unsigned long vaddr; +int i; + +if (!pfns) +return (unsigned long )NULL ; + +for (i =0 ; i < size /HV_HYP_PAGE_SIZE ; i++) + pfns[i] =virt_to_hvpfn ((void *)addr + i *HV_HYP_PAGE_SIZE ) + + (ms_hyperv.shared_gpa_boundary >>HV_HYP_PAGE_SHIFT ); + + vaddr = (unsigned long )vmap_pfn (pfns, size /HV_HYP_PAGE_SIZE , +PAGE_KERNEL_IO ); +kfree (pfns); + +return vaddr; +} + +void hv_unmap_memory (unsigned long addr) +{ +vunmap ((void *)addr); +}arch/x86/include/asm/mshyperv.h +2
-0@@ -253,6 +253,8 @@ int hv_map_ioapic_interrupt(int ioapic_id, bool level, int vcpu, int vector,int hv_unmap_ioapic_interrupt (int ioapic_id,struct hv_interrupt_entry *entry);int hv_mark_gpa_visibility (u16 count,const u64 pfn[],u32 visibility);int hv_set_mem_enc (unsigned long addr,int numpages,bool enc); +unsigned long hv_map_memory (unsigned long addr,unsigned long size); +void hv_unmap_memory (unsigned long addr);void hv_sint_wrmsrl_ghcb (u64 msr,u64 value);void hv_sint_rdmsrl_ghcb (u64 msr,u64 *value);void hv_signal_eom_ghcb (void );arch/x86/include/asm/set_memory.h +2
-0@@ -49,6 +49,8 @@ int set_memory_decrypted(unsigned long addr, int numpages);int set_memory_np_noalias (unsigned long addr,int numpages);int set_memory_nonglobal (unsigned long addr,int numpages);int set_memory_global (unsigned long addr,int numpages); +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size); +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size);int set_pages_array_uc (struct page **pages,int addrinarray);int set_pages_array_wc (struct page **pages,int addrinarray);arch/x86/mm/pat/set_memory.c +28
-0@@ -2039,6 +2039,34 @@ int set_memory_decrypted(unsigned long addr, int numpages) }EXPORT_SYMBOL_GPL (set_memory_decrypted); +static unsigned long __map_memory (unsigned long addr,unsigned long size) +{ +if (hv_is_isolation_supported ()) +return hv_map_memory (addr, size); + +return addr; +} + +static void __unmap_memory (unsigned long addr) +{ +if (hv_is_isolation_supported ()) +hv_unmap_memory (addr); +} + +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size) +{ +if (__set_memory_enc_dec (addr, size /PAGE_SIZE , false)) +return (unsigned long )NULL ; + +return __map_memory (addr, size); +} + +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size) +{ +__unmap_memory (addr); +return __set_memory_enc_dec (addr, size /PAGE_SIZE , true); +} +int set_pages_uc (struct page *page,int numpages) {unsigned long addr = (unsigned long )page_address (page);include/linux/swiotlb.h +4
-0@@ -72,6 +72,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. +* @vstart: The virtual start address 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. @@ -89,6 +92,7 @@ extern enum swiotlb_force swiotlb_force;struct io_tlb_mem {phys_addr_t start;phys_addr_t end; +void *vstart;unsigned long nslabs;unsigned long used;unsigned int index;kernel/dma/swiotlb.c +7
-2@@ -194,8 +194,13 @@ static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, mem->slots[i].alloc_size =0 ; } -set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT ); -memset (vaddr,0 , bytes); + mem->vstart = (void *)set_memory_decrypted_map ((unsigned long )vaddr, bytes); +if (!mem->vstart) { +pr_err ("Failed to decrypt memory.\n" ); +return ; + } + +memset (mem->vstart,0 , bytes); }int __init swiotlb_init_with_tbl (char *tlb,unsigned long nslabs,int verbose)
kernel/dma/swiotlb.c static void swiotlb_bounce(struct device *dev, phys_addr_t tlb_addr, size_t size · line 363
Quoted 8 lines
kernel/dma/swiotlb.c +1
-1@@ -352,7 +357,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->vstart + tlb_addr - mem->start;if (orig_addr ==INVALID_PHYS_ADDR )return ;
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
In reply to Tianyu LanPlease split the swiotlb changes into a separate patch from the consumer.
Quoted 15 lines
}
arch/x86/hyperv/ivm.c +14
-0+ +/* +* hv_map_memory - map memory to extra space in the AMD SEV-SNP Isolation VM. +*/ +unsigned long hv_map_memory (unsigned long addr,unsigned long size) +{ +unsigned long *pfns =kcalloc (size /HV_HYP_PAGE_SIZE , +sizeof (unsigned long ), +GFP_KERNEL ); +unsigned long vaddr; +int i; + +if (!pfns) +return (unsigned long )NULL ;
arch/x86/hyperv/ivm.c int hv_set_mem_enc(unsigned long addr, int numpages, bool enc) · line 293
Quoted 10 lines
arch/x86/hyperv/ivm.c +10
-0+ +for (i =0 ; i < size /HV_HYP_PAGE_SIZE ; i++) + pfns[i] =virt_to_hvpfn ((void *)addr + i *HV_HYP_PAGE_SIZE ) + + (ms_hyperv.shared_gpa_boundary >>HV_HYP_PAGE_SHIFT ); + + vaddr = (unsigned long )vmap_pfn (pfns, size /HV_HYP_PAGE_SIZE , +PAGE_KERNEL_IO ); +kfree (pfns); + +return vaddr;
This seems to miss a 'select VMAP_PFN'. But more importantly I don't think this actually works. Various DMA APIs do expect a struct page backing, so how is this going to work with say dma_mmap_attrs or dma_get_sgtable_attrs?
Quoted 17 lines
arch/x86/mm/pat/set_memory.c +17
-0+static unsigned long __map_memory (unsigned long addr,unsigned long size) +{ +if (hv_is_isolation_supported ()) +return hv_map_memory (addr, size); + +return addr; +} + +static void __unmap_memory (unsigned long addr) +{ +if (hv_is_isolation_supported ()) +hv_unmap_memory (addr); +} + +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size) +{ +if (__set_memory_enc_dec (addr, size /PAGE_SIZE , false))
arch/x86/mm/pat/set_memory.c int set_memory_decrypted(unsigned long addr, int numpages) · line 2068
Quoted 10 lines
arch/x86/mm/pat/set_memory.c +10
-0+return (unsigned long )NULL ; + +return __map_memory (addr, size); +} + +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size) +{ +__unmap_memory (addr); +return __set_memory_enc_dec (addr, size /PAGE_SIZE , true); +}
Why this obsfucation into all kinds of strange helpers? Also I think we want an ops vectors (or alternative calls) instead of the random if checks here.
Quoted 2 lines
+ * @vstart: The virtual start address of the swiotlb memory pool. The swiotlb
+ * memory pool may be remapped in the memory encrypted case and store
Normall we'd call this vaddr or cpu_addr.
kernel/dma/swiotlb.c static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, · line 197
Quoted 3 lines
kernel/dma/swiotlb.c +1
-2-set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT ); -memset (vaddr,0 , bytes); + mem->vstart = (void *)set_memory_decrypted_map ((unsigned long )vaddr, bytes);
Please always pass kernel virtual addresses as pointers.
And I think these APIs might need better names, e.g.
arch_dma_map_decrypted and arch_dma_unmap_decrypted.
Also these will need fallback versions for non-x86 architectures that currently use memory encryption.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
Thanks for review.
Quoted 3 lines · Christoph Hellwig
Please split the swiotlb changes into a separate patch from the consumer.
OK. Will update.
Quoted 20 lines
Quoted 20 lines
}arch/x86/hyperv/ivm.c +18
-0+ +/* +* hv_map_memory - map memory to extra space in the AMD SEV-SNP Isolation VM. +*/ +unsigned long hv_map_memory (unsigned long addr,unsigned long size) +{ +unsigned long *pfns =kcalloc (size /HV_HYP_PAGE_SIZE , +sizeof (unsigned long ), +GFP_KERNEL ); +unsigned long vaddr; +int i; + +if (!pfns) +return (unsigned long )NULL ; + +for (i =0 ; i < size /HV_HYP_PAGE_SIZE ; i++) + pfns[i] =virt_to_hvpfn ((void *)addr + i *HV_HYP_PAGE_SIZE ) + + (ms_hyperv.shared_gpa_boundary >>HV_HYP_PAGE_SHIFT );
Quoted 8 lines
arch/x86/hyperv/ivm.c int hv_set_mem_enc(unsigned long addr, int numpages, bool enc) · line 293
Quoted 6 lines
arch/x86/hyperv/ivm.c +6
-0+ + vaddr = (unsigned long )vmap_pfn (pfns, size /HV_HYP_PAGE_SIZE , +PAGE_KERNEL_IO ); +kfree (pfns); + +return vaddr;This seems to miss a 'select
VMAP_PFN'.
VMAP_PFN has been selected in the previous patch "RFC PATCH V4 08/13] HV/Vmbus: Initialize VMbus ring buffer for Isolation VM"
Quoted 4 lines
But more importantly I don't
think this actually works. Various DMA APIs do expect a struct page backing, so how is this going to work with saydma_mmap_attrsordma_get_sgtable_attrs?
dma_mmap_attrs() and dma_get_sgtable_attrs() get input virtual address belonging to backing memory with struct page and returns bounce buffer dma physical address which is below shared_gpa_boundary(vTOM) and passed to Hyper-V via vmbus protocol.
The new map virtual address is only to access bounce buffer in swiotlb code and will not be used other places. It's stored in the mem->vstart. So the new API set_memory_decrypted_map() in this series is only called in the swiotlb code. Other platforms may replace set_memory_decrypted() with set_memory_decrypted_map() as requested.
Quoted 24 lines
Quoted 24 lines
arch/x86/mm/pat/set_memory.c +23
-0+static unsigned long __map_memory (unsigned long addr,unsigned long size) +{ +if (hv_is_isolation_supported ()) +return hv_map_memory (addr, size); + +return addr; +} + +static void __unmap_memory (unsigned long addr) +{ +if (hv_is_isolation_supported ()) +hv_unmap_memory (addr); +} + +unsigned long set_memory_decrypted_map (unsigned long addr,unsigned long size) +{ +if (__set_memory_enc_dec (addr, size /PAGE_SIZE , false)) +return (unsigned long )NULL ; + +return __map_memory (addr, size); +} + +int set_memory_encrypted_unmap (unsigned long addr,unsigned long size)
Quoted 8 lines
arch/x86/mm/pat/set_memory.c int set_memory_decrypted(unsigned long addr, int numpages) · line 2068
Quoted 4 lines
arch/x86/mm/pat/set_memory.c +4
-0+{ +__unmap_memory (addr); +return __set_memory_enc_dec (addr, size /PAGE_SIZE , true); +}Why this obsfucation into all kinds of strange helpers? Also I think we want an ops vectors (or alternative calls) instead of the random if checks here.
Yes, agree and will add ops for different platforms to map/unmap memory.
Quoted 5 lines
Quoted 3 lines
+ * @vstart: The virtual start address of the swiotlb memory pool. The swiotlb
+ * memory pool may be remapped in the memory encrypted case and storeNormall we'd call this vaddr or
cpu_addr.
OK. Will update.
Quoted 7 lines
kernel/dma/swiotlb.c static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, · line 197
Quoted 4 lines
kernel/dma/swiotlb.c +1
-2-set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT ); -memset (vaddr,0 , bytes); + mem->vstart = (void *)set_memory_decrypted_map ((unsigned long )vaddr, bytes);Please always pass kernel virtual addresses as pointers.
Quoted 6 lines
And I think these APIs might need better names, e.g.
arch_dma_map_decryptedandarch_dma_unmap_decrypted.Also these will need fallback versions for non-x86 architectures that currently use memory encryption.
Sure. Will update in the next version.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
Quoted 10 lines · Tianyu Lan
dma_mmap_attrs()anddma_get_sgtable_attrs()get input virtual address belonging to backing memory with struct page and returns bounce buffer dma physical address which is belowshared_gpa_boundary(vTOM)and passed to Hyper-V via vmbus protocol.The new map virtual address is only to access bounce buffer in swiotlb code and will not be used other places. It's stored in the
mem->vstart. So the new APIset_memory_decrypted_map()in this series is only called in the swiotlb code. Other platforms may replaceset_memory_decrypted()withset_memory_decrypted_map()as requested.
It seems like you are indeed not using these new helpers in dma_direct_alloc. How is dma_alloc_attrs/dma_alloc_coherent going to work on these systems?
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
Quoted 12 lines · Christoph Hellwig
Quoted 10 lines · Tianyu Lan
dma_mmap_attrs()anddma_get_sgtable_attrs()get input virtual address belonging to backing memory with struct page and returns bounce buffer dma physical address which is belowshared_gpa_boundary(vTOM)and passed to Hyper-V via vmbus protocol.The new map virtual address is only to access bounce buffer in swiotlb code and will not be used other places. It's stored in the
mem->vstart. So the new APIset_memory_decrypted_map()in this series is only called in the swiotlb code. Other platforms may replaceset_memory_decrypted()withset_memory_decrypted_map()as requested.
Quoted 4 lines
It seems like you are indeed not using these new helpers in
dma_direct_alloc. How is dma_alloc_attrs/dma_alloc_coherent going to work on these systems?
Current vmbus device drivers don't use dma_alloc_attrs/dma_alloc_coherent() because vmbus driver allocates ring buffer for all devices. Ring buffer has been marked decrypted and remapped in vmbus driver. Netvsc and storvsc drivers just need to use dma_map_single/dma_map_page().
Re: [Resend RFC PATCH V4 09/13] x86/Swiotlb/HV: Add Swiotlb bounce buffer remap function for HV IVM
In reply to Christoph HellwigHi Christoph:
I followed your this suggestion to rework the latest
version(https://lkml.org/lkml/2021/8/9/805). I just remove the arch
prefix from your suggested name arch_dma_map_decrypted because the platform may populate their map/umap callback in the ops. But from your latest comment(https://lkml.org/lkml/2021/8/12/149), these names confuse vs the actual dma_map_* calls... Could you help to give the right function name? The new map function is to map bounce buffer in the trust/Isolation VM and these buffers are DMA memory.
Quoted 11 lines · Christoph Hellwig
kernel/dma/swiotlb.c static void swiotlb_init_io_tlb_mem(struct io_tlb_mem *mem, phys_addr_t start, · line 197
Quoted 3 lines
kernel/dma/swiotlb.c +1
-2-set_memory_decrypted ((unsigned long )vaddr, bytes >>PAGE_SHIFT ); -memset (vaddr,0 , bytes); + mem->vstart = (void *)set_memory_decrypted_map ((unsigned long )vaddr, bytes);Please always pass kernel virtual addresses as pointers.
And I think these APIs might need better names, e.g.
arch_dma_map_decryptedandarch_dma_unmap_decrypted.Also these will need fallback versions for non-x86 architectures that currently use memory encryption.
RFC PATCH v4 10/13 HV/IOMMU: Enable swiotlb bounce buffer for Isolation VM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V 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.
Swiotlb bounce buffer code calls set_memory_decrypted_map() to mark bounce buffer visible to host and map it in extra address space.
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.
The map function vmap_pfn() can't work in the early place hyperv_iommu_swiotlb_init() and so initialize swiotlb bounce buffer in the hyperv_iommu_swiotlb_later_init().
--- arch/x86/xen/pci-swiotlb-xen.c | 3 +- drivers/hv/vmbus_drv.c | 3 ++ drivers/iommu/hyperv-iommu.c | 62 ++++++++++++++++++++++++++++++++++ include/linux/hyperv.h | 1 + 4 files changed, 68 insertions(+), 1 deletion(-)
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/vmbus_drv.c +3 -0
@@ -23,6 +23,7 @@#include <linux/cpu.h> #include <linux/sched/task_stack.h> +#include <linux/dma-map-ops.h> #include <linux/delay.h> #include <linux/notifier.h> #include <linux/ptrace.h>
@@ -2080,6 +2081,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 */
@@ -2120,6 +2122,7 @@ int vmbus_device_register(struct hv_device *child_device_obj) }hv_debug_add_dev_dir (child_device_obj); + child_device_obj->device.dma_mask = &vmbus_dma_mask;return 0 ; err_kset_unregister:
drivers/iommu/hyperv-iommu.c +62 -0
86 lines not on this page · raw message
include/linux/hyperv.h +1 -0
@@ -1759,6 +1759,7 @@ 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)); +int __init hyperv_swiotlb_detect (void );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
RFC PATCH v4 11/13 HV/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() still need to handle. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V DMA ops callback will use swiotlb function to allocate bounce buffer and copy data from/to bounce buffer.
--- drivers/net/hyperv/hyperv_net.h | 6 ++ drivers/net/hyperv/netvsc.c | 144 +++++++++++++++++++++++++++++- drivers/net/hyperv/rndis_filter.c | 2 + include/linux/hyperv.h | 5 ++ 4 files changed, 154 insertions(+), 3 deletions(-)
drivers/net/hyperv/hyperv_net.h +6 -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; +void *recv_original_buf;u32 recv_buf_size;/* allocated bytes */ u32 recv_buf_gpadl_handle;u32 recv_section_cnt;
@@ -1082,6 +1084,8 @@ struct netvsc_device {/* Send buffer allocated by us */ void *send_buf; +void *send_original_buf; +u32 send_buf_size;u32 send_buf_gpadl_handle;u32 send_section_cnt;u32 send_section_size;
@@ -1729,4 +1733,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 +141 -3
206 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 +5 -0
@@ -1616,6 +1616,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 · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 12/13 HV/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 need to handle. Use DMA API to map/umap these memory during sending/receiving packet and Hyper-V DMA ops callback will use swiotlb function to allocate bounce buffer and copy data from/to bounce buffer.
--- drivers/scsi/storvsc_drv.c | 68 +++++++++++++++++++++++++++++++++++--- 1 file changed, 63 insertions(+), 5 deletions(-)
drivers/scsi/storvsc_drv.c +63 -5
@@ -21,6 +21,8 @@#include <linux/device.h> #include <linux/hyperv.h> #include <linux/blkdev.h> +#include <linux/io.h> +#include <linux/dma-mapping.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_host.h>
@@ -427,6 +429,8 @@ struct storvsc_cmd_request {u32 payload_sz;struct vstor_packet vstor_packet; +u32 hvpg_count; +struct hv_dma_range *dma_range; };
@@ -509,6 +513,14 @@ struct storvsc_scan_work {u8 tgt_id; }; +#define storvsc_dma_map (dev, page, offset, size, dir) \ + dma_map_page(dev, page, offset, size, dir) + +#define storvsc_dma_unmap (dev, dma_range, dir) \ + dma_unmap_page(dev, dma_range.dma, \ + dma_range.mapping_size, \ + dir ? DMA_FROM_DEVICE : DMA_TO_DEVICE) +static void storvsc_device_scan (struct work_struct *work) {struct storvsc_scan_work *wrk;
@@ -1267,6 +1279,7 @@ static void storvsc_on_channel_callback(void *context)struct hv_device *device;struct storvsc_device *stor_device;struct Scsi_Host *shost; +int i;if (channel->primary_channel !=NULL ) device = channel->primary_channel->device_obj;
@@ -1321,6 +1334,15 @@ static void storvsc_on_channel_callback(void *context) request = (struct storvsc_cmd_request *)scsi_cmd_priv (scmnd); } +if (request->dma_range) { +for (i =0 ; i < request->hvpg_count; i++) +storvsc_dma_unmap (&device->device, + request->dma_range[i], + request->vstor_packet.vm_srb.data_in ==READ_TYPE ); + +kfree (request->dma_range); + } +storvsc_on_receive (stor_device, packet, request);continue ; }
@@ -1817,7 +1839,9 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)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); +dma_addr_t dma;u64 hvpfn; +u32 size;if (hvpg_count >MAX_PAGE_BUFFER_COUNT ) {
@@ -1831,6 +1855,13 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd) payload->range.len = length; payload->range.offset = offset_in_hvpg; + cmd_request->dma_range =kcalloc (hvpg_count, +sizeof (*cmd_request->dma_range), +GFP_ATOMIC ); +if (!cmd_request->dma_range) { + ret = -ENOMEM ; + goto free_payload; + }for (i =0 ; sgl !=NULL ; sgl =sg_next (sgl)) {/*
@@ -1854,9 +1885,29 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)* last sgl should be reached at the same time that * the PFN array is filled. */ -while (hvpfns_to_add--) - payload->range.pfn_array[i++] = hvpfn++; +while (hvpfns_to_add--) { + size =min (HV_HYP_PAGE_SIZE - offset_in_hvpg, + (unsigned long )length); + dma =storvsc_dma_map (&dev->device,pfn_to_page (hvpfn++), + offset_in_hvpg, size, + scmnd->sc_data_direction); +if (dma_mapping_error (&dev->device, dma)) { + ret = -ENOMEM ; + goto free_dma_range; + } + +if (offset_in_hvpg) { + payload->range.offset = dma & ~HV_HYP_PAGE_MASK ; + offset_in_hvpg =0 ; + } + + cmd_request->dma_range[i].dma = dma; + cmd_request->dma_range[i].mapping_size = size; + payload->range.pfn_array[i++] = dma >>HV_HYP_PAGE_SHIFT ; + length -= size; + } } + cmd_request->hvpg_count = hvpg_count; } cmd_request->payload = payload;
@@ -1867,13 +1918,20 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)put_cpu ();if (ret == -EAGAIN ) { -if (payload_sz >sizeof (cmd_request->mpb)) -kfree (payload);/* no more space */ -return SCSI_MLQUEUE_DEVICE_BUSY ; + ret =SCSI_MLQUEUE_DEVICE_BUSY ; + goto free_dma_range; }return 0 ; + +free_dma_range: +kfree (cmd_request->dma_range); + +free_payload: +if (payload_sz >sizeof (cmd_request->mpb)) +kfree (payload); +return ret; }static struct scsi_host_template scsi_driver = {
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
RFC PATCH v4 13/13 x86/HV: Not set memory decrypted/encrypted during kexec alloc/free page in IVM
In reply to Tianyu LanFrom: Tianyu Lan <[email protected]>
Hyper-V Isolation VM reuses set_memory_decrypted/encrypted function and not needs to decrypted/encrypted in arch_kexec_post_alloc(pre_free) _pages just likes AMD SEV VM. So skip them.
--- arch/x86/kernel/machine_kexec_64.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
arch/x86/kernel/machine_kexec_64.c +3 -2
@@ -26,6 +26,7 @@#include <asm/kexec-bzimage64.h> #include <asm/setup.h> #include <asm/set_memory.h> +#include <asm/mshyperv.h> #ifdef CONFIG_ACPI /*
@@ -598,7 +599,7 @@ void arch_kexec_unprotect_crashkres(void)*/ int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages,gfp_t gfp) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return 0 ;/*
@@ -611,7 +612,7 @@ int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp)void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return ;/*
Signature · 6 lines
2.25.1 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [Resend RFC PATCH V4 13/13] x86/HV: Not set memory decrypted/encrypted during kexec alloc/free page in IVM
Quoted 10 lines · Tianyu Lan
arch/x86/kernel/machine_kexec_64.c +1
-1@@ -598,7 +599,7 @@ void arch_kexec_unprotect_crashkres(void)*/ int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages,gfp_t gfp) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return 0 ;/*
arch/x86/kernel/machine_kexec_64.c int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp) · line 616
Quoted 6 lines
arch/x86/kernel/machine_kexec_64.c +1
-1@@ -611,7 +612,7 @@ int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp)void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return ;
You might want to take a look through the "protected guest" patches. I think this series is touching a few of the same locations that TDX and recent SEV work touch.
https://lore.kernel.org/lkml/20210618225755.662725-5-sathyanarayanan.kuppuswamy@linux.intel.com/
Re: [Resend RFC PATCH V4 13/13] x86/HV: Not set memory decrypted/encrypted during kexec alloc/free page in IVM
Hi Dave:
Thanks for your review.
Quoted 22 lines · Dave Hansen
Quoted 10 lines · Tianyu Lan
arch/x86/kernel/machine_kexec_64.c +1
-1@@ -598,7 +599,7 @@ void arch_kexec_unprotect_crashkres(void)*/ int arch_kexec_post_alloc_pages (void *vaddr,unsigned int pages,gfp_t gfp) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return 0 ;/* arch/x86/kernel/machine_kexec_64.c int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp) · line 616
Quoted 6 lines
arch/x86/kernel/machine_kexec_64.c +1
-1@@ -611,7 +612,7 @@ int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages, gfp_t gfp)void arch_kexec_pre_free_pages (void *vaddr,unsigned int pages) { -if (sev_active ()) +if (sev_active () ||hv_is_isolation_supported ())return ;You might want to take a look through the "protected guest" patches. I think this series is touching a few of the same locations that TDX and recent SEV work touch.
Quoted 1 line
https://lore.kernel.org/lkml/20210618225755.662725-5-sathyanarayanan.kuppuswamy@linux.intel.com/
Thanks for reminder. You are right. There will be a generic API to check "proteced guest" type.