Commit 44261f8e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'hyperv-next-signed-20211102' of... 

Merge tag 'hyperv-next-signed-20211102' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux

Pull hyperv updates from Wei Liu:

 - Initial patch set for Hyper-V isolation VM support (Tianyu Lan)

 - Fix a warning on preemption (Vitaly Kuznetsov)

 - A bunch of misc cleanup patches

* tag 'hyperv-next-signed-20211102' of git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux:
  x86/hyperv: Protect set_hv_tscchange_cb() against getting preempted
  Drivers: hv : vmbus: Adding NULL pointer check
  x86/hyperv: Remove duplicate include
  x86/hyperv: Remove duplicated include in hv_init
  Drivers: hv: vmbus: Remove unused code to check for subchannels
  Drivers: hv: vmbus: Initialize VMbus ring buffer for Isolation VM
  Drivers: hv: vmbus: Add SNP support for VMbus channel initiate message
  x86/hyperv: Add ghcb hvcall support for SNP VM
  x86/hyperv: Add Write/Read MSR registers via ghcb page
  Drivers: hv: vmbus: Mark vmbus ring buffer visible to host in Isolation VM
  x86/hyperv: Add new hvcall guest address host visibility support
  x86/hyperv: Initialize shared memory boundary in the Isolation VM.
  x86/hyperv: Initialize GHCB page in Isolation VM
parents 0aaa58ec 285f68af

arch/x86/hyperv/Makefile

+1 −1
Original line number Diff line number Diff line 
# 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/hv_init.c

+61 −21
Original line number Diff line number Diff line
@@ -36,12 +36,42 @@ EXPORT_SYMBOL_GPL(hv_current_partition_id); 
void *hv_hypercall_pg;

EXPORT_SYMBOL_GPL(hv_hypercall_pg);



union hv_ghcb __percpu **hv_ghcb_pg;



/* Storage to save the hypercall page temporarily for hibernation */

static void *hv_hypercall_pg_saved;



struct hv_vp_assist_page **hv_vp_assist_page;

EXPORT_SYMBOL_GPL(hv_vp_assist_page);



static int hyperv_init_ghcb(void)

{

	u64 ghcb_gpa;

	void *ghcb_va;

	void **ghcb_base;



	if (!hv_isolation_type_snp())

		return 0;



	if (!hv_ghcb_pg)

		return -EINVAL;



	/*

	 * GHCB page is allocated by paravisor. The address

	 * returned by MSR_AMD64_SEV_ES_GHCB is above shared

	 * memory boundary and map it here.

	 */

	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(hv_ghcb_pg);

	*ghcb_base = ghcb_va;



	return 0;

}



static int hv_cpu_init(unsigned int cpu)

{

	union hv_vp_assist_msr_contents msr = { 0 };
@@ -85,7 +115,7 @@ static int hv_cpu_init(unsigned int cpu) 
		}

	}



	return 0;

	return hyperv_init_ghcb();

}



static void (*hv_reenlightenment_cb)(void);
@@ -139,7 +169,6 @@ void set_hv_tscchange_cb(void (*cb)(void)) 
	struct hv_reenlightenment_control re_ctrl = {

		.vector = HYPERV_REENLIGHTENMENT_VECTOR,

		.enabled = 1,

		.target_vp = hv_vp_index[smp_processor_id()]

	};

	struct hv_tsc_emulation_control emu_ctrl = {.enabled = 1};
@@ -153,8 +182,12 @@ void set_hv_tscchange_cb(void (*cb)(void)) 
	/* Make sure callback is registered before we write to MSRs */

	wmb();



	re_ctrl.target_vp = hv_vp_index[get_cpu()];



	wrmsrl(HV_X64_MSR_REENLIGHTENMENT_CONTROL, *((u64 *)&re_ctrl));

	wrmsrl(HV_X64_MSR_TSC_EMULATION_CONTROL, *((u64 *)&emu_ctrl));



	put_cpu();

}

EXPORT_SYMBOL_GPL(set_hv_tscchange_cb);
@@ -177,6 +210,14 @@ static int hv_cpu_die(unsigned int cpu) 
{

	struct hv_reenlightenment_control re_ctrl;

	unsigned int new_cpu;

	void **ghcb_va;



	if (hv_ghcb_pg) {

		ghcb_va = (void **)this_cpu_ptr(hv_ghcb_pg);

		if (*ghcb_va)

			memunmap(*ghcb_va);

		*ghcb_va = NULL;

	}



	hv_common_cpu_die(cpu);
@@ -366,10 +407,16 @@ void __init hyperv_init(void) 
		goto common_free;

	}



	if (hv_isolation_type_snp()) {

		hv_ghcb_pg = alloc_percpu(union hv_ghcb *);

		if (!hv_ghcb_pg)

			goto free_vp_assist_page;

	}



	cpuhp = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "x86/hyperv_init:online",

				  hv_cpu_init, hv_cpu_die);

	if (cpuhp < 0)

		goto free_vp_assist_page;

		goto free_ghcb_page;



	/*

	 * Setup the hypercall page and enable hypercalls.
@@ -379,14 +426,15 @@ void __init hyperv_init(void) 
	guest_id = generate_guest_id(0, LINUX_VERSION_CODE, 0);

	wrmsrl(HV_X64_MSR_GUEST_OS_ID, guest_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);



	hv_hypercall_pg = __vmalloc_node_range(PAGE_SIZE, 1, VMALLOC_START,

			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;



	rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);

	hypercall_msr.enable = 1;
@@ -456,8 +504,12 @@ 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);

	hv_ghcb_msr_write(HV_X64_MSR_GUEST_OS_ID, 0);

	cpuhp_remove_state(cpuhp);

free_ghcb_page:

	free_percpu(hv_ghcb_pg);

free_vp_assist_page:

	kfree(hv_vp_assist_page);

	hv_vp_assist_page = NULL;
@@ -476,6 +528,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,
@@ -546,16 +599,3 @@ bool hv_is_hyperv_initialized(void) 
	return hypercall_msr.enable;

}

EXPORT_SYMBOL_GPL(hv_is_hyperv_initialized);
 


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;

}

arch/x86/hyperv/ivm.c

0 → 100644
+289 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Hyper-V Isolation VM interface with paravisor and hypervisor

 *

 * Author:

 *  Tianyu Lan <Tianyu.Lan@microsoft.com>

 */



#include <linux/bitfield.h>

#include <linux/hyperv.h>

#include <linux/types.h>

#include <linux/slab.h>

#include <asm/svm.h>

#include <asm/sev.h>

#include <asm/io.h>

#include <asm/mshyperv.h>

#include <asm/hypervisor.h>



#ifdef CONFIG_AMD_MEM_ENCRYPT



#define GHCB_USAGE_HYPERV_CALL	1



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(HV_HYP_PAGE_SIZE);



u64 hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_size)

{

	union hv_ghcb *hv_ghcb;

	void **ghcb_base;

	unsigned long flags;

	u64 status;



	if (!hv_ghcb_pg)

		return -EFAULT;



	WARN_ON(in_nmi());



	local_irq_save(flags);

	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);

	hv_ghcb = (union hv_ghcb *)*ghcb_base;

	if (!hv_ghcb) {

		local_irq_restore(flags);

		return -EFAULT;

	}



	hv_ghcb->ghcb.protocol_version = GHCB_PROTOCOL_MAX;

	hv_ghcb->ghcb.ghcb_usage = GHCB_USAGE_HYPERV_CALL;



	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));



	status = hv_ghcb->hypercall.hypercalloutput.callstatus;



	local_irq_restore(flags);



	return status;

}



void hv_ghcb_msr_write(u64 msr, u64 value)

{

	union hv_ghcb *hv_ghcb;

	void **ghcb_base;

	unsigned long flags;

	struct es_em_ctxt ctxt;



	if (!hv_ghcb_pg)

		return;



	WARN_ON(in_nmi());



	local_irq_save(flags);

	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);

	hv_ghcb = (union hv_ghcb *)*ghcb_base;

	if (!hv_ghcb) {

		local_irq_restore(flags);

		return;

	}



	ghcb_set_rcx(&hv_ghcb->ghcb, msr);

	ghcb_set_rax(&hv_ghcb->ghcb, lower_32_bits(value));

	ghcb_set_rdx(&hv_ghcb->ghcb, upper_32_bits(value));



	if (sev_es_ghcb_hv_call(&hv_ghcb->ghcb, false, &ctxt,

				SVM_EXIT_MSR, 1, 0))

		pr_warn("Fail to write msr via ghcb %llx.\n", msr);



	local_irq_restore(flags);

}

EXPORT_SYMBOL_GPL(hv_ghcb_msr_write);



void hv_ghcb_msr_read(u64 msr, u64 *value)

{

	union hv_ghcb *hv_ghcb;

	void **ghcb_base;

	unsigned long flags;

	struct es_em_ctxt ctxt;



	/* Check size of union hv_ghcb here. */

	BUILD_BUG_ON(sizeof(union hv_ghcb) != HV_HYP_PAGE_SIZE);



	if (!hv_ghcb_pg)

		return;



	WARN_ON(in_nmi());



	local_irq_save(flags);

	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);

	hv_ghcb = (union hv_ghcb *)*ghcb_base;

	if (!hv_ghcb) {

		local_irq_restore(flags);

		return;

	}



	ghcb_set_rcx(&hv_ghcb->ghcb, msr);

	if (sev_es_ghcb_hv_call(&hv_ghcb->ghcb, false, &ctxt,

				SVM_EXIT_MSR, 0, 0))

		pr_warn("Fail to read msr via ghcb %llx.\n", msr);

	else

		*value = (u64)lower_32_bits(hv_ghcb->ghcb.save.rax)

			| ((u64)lower_32_bits(hv_ghcb->ghcb.save.rdx) << 32);

	local_irq_restore(flags);

}

EXPORT_SYMBOL_GPL(hv_ghcb_msr_read);

#endif



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);



/*

 * hv_is_isolation_supported - Check system runs in the Hyper-V

 * isolation VM.

 */

bool hv_is_isolation_supported(void)

{

	if (!cpu_feature_enabled(X86_FEATURE_HYPERVISOR))

		return false;



	if (!hypervisor_is_type(X86_HYPER_MS_HYPERV))

		return false;



	return hv_get_isolation_type() != HV_ISOLATION_TYPE_NONE;

}



DEFINE_STATIC_KEY_FALSE(isolation_type_snp);



/*

 * hv_isolation_type_snp - Check system runs in the AMD SEV-SNP based

 * isolation VM.

 */

bool hv_isolation_type_snp(void)

{

	return static_branch_unlikely(&isolation_type_snp);

}



/*

 * hv_mark_gpa_visibility - Set pages visible to host via hvcall.

 *

 * In Isolation VM, all guest memory is encrypted from host and guest

 * needs to set memory visible to host via hvcall before sharing memory

 * with host.

 */

static int hv_mark_gpa_visibility(u16 count, const u64 pfn[],

			   enum hv_mem_host_visibility visibility)

{

	struct hv_gpa_range_for_visibility **input_pcpu, *input;

	u16 pages_processed;

	u64 hv_status;

	unsigned long flags;



	/* no-op if partition isolation is not enabled */

	if (!hv_is_isolation_supported())

		return 0;



	if (count > HV_MAX_MODIFY_GPA_REP_COUNT) {

		pr_err("Hyper-V: GPA count:%d exceeds supported:%lu\n", count,

			HV_MAX_MODIFY_GPA_REP_COUNT);

		return -EINVAL;

	}



	local_irq_save(flags);

	input_pcpu = (struct hv_gpa_range_for_visibility **)

			this_cpu_ptr(hyperv_pcpu_input_arg);

	input = *input_pcpu;

	if (unlikely(!input)) {

		local_irq_restore(flags);

		return -EINVAL;

	}



	input->partition_id = HV_PARTITION_ID_SELF;

	input->host_visibility = visibility;

	input->reserved0 = 0;

	input->reserved1 = 0;

	memcpy((void *)input->gpa_page_list, pfn, count * sizeof(*pfn));

	hv_status = hv_do_rep_hypercall(

			HVCALL_MODIFY_SPARSE_GPA_PAGE_HOST_VISIBILITY, count,

			0, input, &pages_processed);

	local_irq_restore(flags);



	if (hv_result_success(hv_status))

		return 0;

	else

		return -EFAULT;

}



/*

 * hv_set_mem_host_visibility - Set specified memory visible to host.

 *

 * In Isolation VM, all guest memory is encrypted from host and guest

 * needs to set memory visible to host via hvcall before sharing memory

 * with host. This function works as wrap of hv_mark_gpa_visibility()

 * with memory base and size.

 */

int hv_set_mem_host_visibility(unsigned long kbuffer, int pagecount, bool visible)

{

	enum hv_mem_host_visibility visibility = visible ?

			VMBUS_PAGE_VISIBLE_READ_WRITE : VMBUS_PAGE_NOT_VISIBLE;

	u64 *pfn_array;

	int ret = 0;

	int i, pfn;



	if (!hv_is_isolation_supported() || !hv_hypercall_pg)

		return 0;



	pfn_array = kmalloc(HV_HYP_PAGE_SIZE, GFP_KERNEL);

	if (!pfn_array)

		return -ENOMEM;



	for (i = 0, pfn = 0; i < pagecount; i++) {

		pfn_array[pfn] = virt_to_hvpfn((void *)kbuffer + i * HV_HYP_PAGE_SIZE);

		pfn++;



		if (pfn == HV_MAX_MODIFY_GPA_REP_COUNT || i == pagecount - 1) {

			ret = hv_mark_gpa_visibility(pfn, pfn_array,

						     visibility);

			if (ret)

				goto err_free_pfn_array;

			pfn = 0;

		}

	}



 err_free_pfn_array:

	kfree(pfn_array);

	return ret;

}

arch/x86/include/asm/hyperv-tlfs.h

+17 −0
Original line number Diff line number Diff line
@@ -276,6 +276,23 @@ 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 memory host visibility */

enum hv_mem_host_visibility {

	VMBUS_PAGE_NOT_VISIBLE		= 0,

	VMBUS_PAGE_VISIBLE_READ_ONLY	= 1,

	VMBUS_PAGE_VISIBLE_READ_WRITE	= 3

};



/* HvCallModifySparseGpaPageHostVisibility hypercall */

#define HV_MAX_MODIFY_GPA_REP_COUNT	((PAGE_SIZE / sizeof(u64)) - 2)

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;



/*

 * Declare the MSR used to setup pages used to communicate with the hypervisor.

 */

arch/x86/include/asm/mshyperv.h

+57 −13
Original line number Diff line number Diff line
@@ -11,23 +11,14 @@ 
#include <asm/paravirt.h>

#include <asm/mshyperv.h>



union hv_ghcb;



DECLARE_STATIC_KEY_FALSE(isolation_type_snp);



typedef int (*hyperv_fill_flush_list_func)(

		struct hv_guest_mapping_flush_list *flush,

		void *data);



static inline void hv_set_register(unsigned int reg, u64 value)

{

	wrmsrl(reg, value);

}



static inline u64 hv_get_register(unsigned int reg)

{

	u64 value;



	rdmsrl(reg, value);

	return value;

}



#define hv_get_raw_timer() rdtsc_ordered()



void hyperv_vector_handler(struct pt_regs *regs);
@@ -39,6 +30,8 @@ extern void *hv_hypercall_pg; 


extern u64 hv_current_partition_id;



extern union hv_ghcb  __percpu **hv_ghcb_pg;



int hv_call_deposit_pages(int node, u64 partition_id, u32 num_pages);

int hv_call_add_logical_proc(int node, u32 lp_index, u32 acpi_id);

int hv_call_create_vp(int node, u64 partition_id, u32 vp_index, u32 flags);
@@ -188,6 +181,50 @@ 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_set_mem_host_visibility(unsigned long addr, int numpages, bool visible);



#ifdef CONFIG_AMD_MEM_ENCRYPT

void hv_ghcb_msr_write(u64 msr, u64 value);

void hv_ghcb_msr_read(u64 msr, u64 *value);

#else

static inline void hv_ghcb_msr_write(u64 msr, u64 value) {}

static inline void hv_ghcb_msr_read(u64 msr, u64 *value) {}

#endif



extern bool hv_isolation_type_snp(void);



static inline bool hv_is_synic_reg(unsigned int reg)

{

	if ((reg >= HV_REGISTER_SCONTROL) &&

	    (reg <= HV_REGISTER_SINT15))

		return true;

	return false;

}



static inline u64 hv_get_register(unsigned int reg)

{

	u64 value;



	if (hv_is_synic_reg(reg) && hv_isolation_type_snp())

		hv_ghcb_msr_read(reg, &value);

	else

		rdmsrl(reg, value);

	return value;

}



static inline void hv_set_register(unsigned int reg, u64 value)

{

	if (hv_is_synic_reg(reg) && hv_isolation_type_snp()) {

		hv_ghcb_msr_write(reg, value);



		/* Write proxy bit via wrmsl instruction */

		if (reg >= HV_REGISTER_SINT0 &&

		    reg <= HV_REGISTER_SINT15)

			wrmsrl(reg, value | 1 << 20);

	} else {

		wrmsrl(reg, value);

	}

}



#else /* CONFIG_HYPERV */

static inline void hyperv_init(void) {}
@@ -205,6 +242,13 @@ static inline int hyperv_flush_guest_mapping_range(u64 as, 
{

	return -1;

}

static inline void hv_set_register(unsigned int reg, u64 value) { }

static inline u64 hv_get_register(unsigned int reg) { return 0; }

static inline int hv_set_mem_host_visibility(unsigned long addr, int numpages,

					     bool visible)

{

	return -1;

}

#endif /* CONFIG_HYPERV */