Merge feature/mm_discard (e0e7ed2)

* msft/feature/mm_discard:
  Hyper-V: support for free page reporting
  Hyper-V: Support for querying extended capabilities
  Hyper-V: arm64: Support for repetitive hypercall

Author: tyhicks

arch/arm64/hyperv/hv_core.c

@@ -40,10 +40,21 @@ EXPORT_SYMBOL_GPL(hv_vp_index);
 u32            hv_max_vp_index;
 EXPORT_SYMBOL_GPL(hv_max_vp_index);
 
+void  __percpu **hyperv_pcpu_input_arg;
+EXPORT_SYMBOL_GPL(hyperv_pcpu_input_arg);
+
 static int hv_cpu_init(unsigned int cpu)
 {
+	void **input_arg;
+	struct page *pg;
 	u64 msr_vp_index;
 
+	input_arg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
+	pg = alloc_page(GFP_KERNEL);
+	if (unlikely(!pg))
+		return -ENOMEM;
+	*input_arg = page_address(pg);
+
 	msr_vp_index = hv_get_vpreg(HV_REGISTER_VPINDEX);
 
 	hv_vp_index[smp_processor_id()] = msr_vp_index;
@@ -54,6 +65,22 @@ static int hv_cpu_init(unsigned int cpu)
 	return 0;
 }
 
+static int hv_cpu_die(unsigned int cpu)
+{
+	void **input_arg;
+	void *input_pg;
+	unsigned long flags;
+
+	local_irq_save(flags);
+	input_arg = (void **)this_cpu_ptr(hyperv_pcpu_input_arg);
+	input_pg = *input_arg;
+	*input_arg = NULL;
+	local_irq_restore(flags);
+	free_page((unsigned long)input_pg);
+
+	return 0;
+}
+
 /*
  * Functions for allocating and freeing memory with size and
  * alignment HV_HYP_PAGE_SIZE. These functions are needed because
@@ -132,13 +159,25 @@ static int __init hyperv_init(struct acpi_table_header *table)
 	/* Get the features and hints from Hyper-V */
 	hv_get_vpreg_128(HV_REGISTER_FEATURES, &result);
 	ms_hyperv.features = result.as32.a;
+	ms_hyperv.priv_high = result.as32.b;
 	ms_hyperv.misc_features = result.as32.c;
 
 	hv_get_vpreg_128(HV_REGISTER_ENLIGHTENMENTS, &result);
 	ms_hyperv.hints = result.as32.a;
 
-	pr_info("Hyper-V: Features 0x%x, hints 0x%x, misc 0x%x\n",
-		ms_hyperv.features, ms_hyperv.hints, ms_hyperv.misc_features);
+	pr_info("Hyper-V: Features 0x%x, privilege high: 0x%x, hints 0x%x, misc 0x%x\n",
+		ms_hyperv.features, ms_hyperv.priv_high, ms_hyperv.hints,
+		ms_hyperv.misc_features);
+
+	/*
+	 * Allocate the per-CPU state for the hypercall input arg.
+	 * If this allocation fails, we will not be able to setup
+	 * (per-CPU) hypercall input page and thus this failure is
+	 * fatal on Hyper-V.
+	 */
+	hyperv_pcpu_input_arg = alloc_percpu(void *);
+
+	BUG_ON(hyperv_pcpu_input_arg == NULL);
 
 	/*
 	 * If Hyper-V has crash notifications, set crash_kexec_post_notifiers
@@ -166,7 +205,7 @@ static int __init hyperv_init(struct acpi_table_header *table)
 		hv_vp_index[i] = VP_INVAL;
 
 	cpuhp = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
-			"arm64/hyperv_init:online", hv_cpu_init, NULL);
+			"arm64/hyperv_init:online", hv_cpu_init, hv_cpu_die);
 	if (cpuhp < 0)
 		goto free_vp_index;
 

arch/arm64/include/asm/mshyperv.h

@@ -35,6 +35,8 @@ extern void hv_set_vpreg(u32 reg, u64 value);
 extern u64 hv_get_vpreg(u32 reg);
 extern void hv_get_vpreg_128(u32 reg, struct hv_get_vp_registers_output *result);
 
+extern void __percpu **hyperv_pcpu_input_arg;
+
 /* Access various Hyper-V synthetic registers */
 static inline void hv_set_simp(u64 val)
 {

arch/x86/include/asm/mshyperv.h

@@ -186,38 +186,6 @@ static inline u64 hv_do_fast_hypercall16(u16 code, u64 input1, u64 input2)
 	return hv_status;
 }
 
-/*
- * Rep hypercalls. Callers of this functions are supposed to ensure that
- * rep_count and varhead_size comply with Hyper-V hypercall definition.
- */
-static inline u64 hv_do_rep_hypercall(u16 code, u16 rep_count, u16 varhead_size,
-				      void *input, void *output)
-{
-	u64 control = code;
-	u64 status;
-	u16 rep_comp;
-
-	control |= (u64)varhead_size << HV_HYPERCALL_VARHEAD_OFFSET;
-	control |= (u64)rep_count << HV_HYPERCALL_REP_COMP_OFFSET;
-
-	do {
-		status = hv_do_hypercall(control, input, output);
-		if ((status & HV_HYPERCALL_RESULT_MASK) != HV_STATUS_SUCCESS)
-			return status;
-
-		/* Bits 32-43 of status have 'Reps completed' data. */
-		rep_comp = (status & HV_HYPERCALL_REP_COMP_MASK) >>
-			HV_HYPERCALL_REP_COMP_OFFSET;
-
-		control &= ~HV_HYPERCALL_REP_START_MASK;
-		control |= (u64)rep_comp << HV_HYPERCALL_REP_START_OFFSET;
-
-		touch_nmi_watchdog();
-	} while (rep_comp < rep_count);
-
-	return status;
-}
-
 extern struct hv_vp_assist_page **hv_vp_assist_page;
 
 static inline struct hv_vp_assist_page *hv_get_vp_assist_page(unsigned int cpu)

arch/x86/kernel/cpu/mshyperv.c

@@ -243,11 +243,13 @@ static void __init ms_hyperv_init_platform(void)
 	 * Extract the features and hints
 	 */
 	ms_hyperv.features = cpuid_eax(HYPERV_CPUID_FEATURES);
+	ms_hyperv.priv_high = cpuid_ebx(HYPERV_CPUID_FEATURES);
 	ms_hyperv.misc_features = cpuid_edx(HYPERV_CPUID_FEATURES);
 	ms_hyperv.hints    = cpuid_eax(HYPERV_CPUID_ENLIGHTMENT_INFO);
 
-	pr_info("Hyper-V: features 0x%x, hints 0x%x, misc 0x%x\n",
-		ms_hyperv.features, ms_hyperv.hints, ms_hyperv.misc_features);
+	pr_info("Hyper-V: features 0x%x, privilege high: 0x%x, hints 0x%x, misc 0x%x\n",
+		ms_hyperv.features, ms_hyperv.priv_high, ms_hyperv.hints,
+		ms_hyperv.misc_features);
 
 	ms_hyperv.max_vp_index = cpuid_eax(HYPERV_CPUID_IMPLEMENT_LIMITS);
 	ms_hyperv.max_lp_index = cpuid_ebx(HYPERV_CPUID_IMPLEMENT_LIMITS);

drivers/hv/Kconfig

@@ -24,6 +24,7 @@ config HYPERV_UTILS
 config HYPERV_BALLOON
 	tristate "Microsoft Hyper-V Balloon driver"
 	depends on HYPERV
+	select PAGE_REPORTING
 	help
 	  Select this option to enable Hyper-V Balloon driver.
 

drivers/hv/hv_balloon.c

@@ -21,7 +21,7 @@
 #include <linux/memory.h>
 #include <linux/notifier.h>
 #include <linux/percpu_counter.h>
-
+#include <linux/page_reporting.h>
 #include <linux/hyperv.h>
 #include <asm/hyperv-tlfs.h>
 
@@ -563,6 +563,9 @@ struct hv_dynmem_device {
 	 * The negotiated version agreed by host.
 	 */
 	__u32 version;
+#ifdef CONFIG_PAGE_REPORTING
+	struct page_reporting_dev_info ph_dev_info;
+#endif
 };
 
 static struct hv_dynmem_device dm_device;
@@ -1565,6 +1568,88 @@ static void balloon_onchannelcallback(void *context)
 
 }
 
+#ifdef CONFIG_PAGE_REPORTING
+static int hyperv_discard_pages(struct scatterlist **sgs, int nents)
+{
+	unsigned long flags;
+	struct hv_memory_hint *hint;
+	int i;
+	struct scatterlist *sg;
+	u64 status;
+
+	WARN_ON(nents > HV_MAX_GPA_PAGE_RANGES);
+	local_irq_save(flags);
+	hint = *(struct hv_memory_hint **)this_cpu_ptr(hyperv_pcpu_input_arg);
+	if (!hint) {
+		local_irq_restore(flags);
+		return -EINVAL;
+	}
+
+	hint->type = HV_MEMORY_HINT_TYPE_COLD_DISCARD;
+	hint->reserved = 0;
+	for (i = 0, sg = sgs[0]; sg; sg = sg_next(sg), i++) {
+		int order;
+		union hv_gpa_page_range *range;
+
+		order = get_order(sg->length);
+		range = &hint->ranges[i];
+		range->address_space = 0;
+		range->page.largepage = 1;
+		range->page.additional_pages = (1ull << (order - 9)) - 1;
+		range->base_large_pfn = page_to_pfn(sg_page(sg)) >> 9;
+	}
+
+	WARN_ON(i != nents);
+
+	status = hv_do_rep_hypercall(HVCALL_MEMORY_HEAT_HINT, nents, 0,
+				     hint, NULL);
+	local_irq_restore(flags);
+	status &= HV_HYPERCALL_RESULT_MASK;
+	if (status != HV_STATUS_SUCCESS) {
+		WARN_ONCE(1,
+		"Cold memory discard hypercall failed with status 0x%llx\n",
+			status);
+		return -EINVAL;
+	} else {
+		return 0;
+	}
+}
+
+static int hv_page_hinting(struct page_reporting_dev_info *ph_dev_info,
+		struct scatterlist *sg, unsigned int nents)
+{
+	return hyperv_discard_pages(&sg, nents);
+}
+
+static void enable_page_reporting(void)
+{
+	int ret;
+
+	if (!hyperv_query_ext_cap(HV_CAPABILITY_MEMORY_COLD_DISCARD_HINT)) {
+		pr_info("Cold memory discard hint not supported.\n");
+		return;
+	}
+
+	BUILD_BUG_ON(PAGE_REPORTING_CAPACITY > HV_MAX_GPA_PAGE_RANGES);
+	dm_device.ph_dev_info.report = hv_page_hinting;
+	ret = page_reporting_register(&dm_device.ph_dev_info);
+	if (ret < 0) {
+		pr_err("Failed to enable cold memory discard: %d\n", ret);
+		dm_device.ph_dev_info.report = NULL;
+	} else {
+		pr_info("Cold memory discard hint enabled\n");
+	}
+}
+
+static void disable_hinting(void)
+{
+	if (dm_device.ph_dev_info.report) {
+		page_reporting_unregister(&dm_device.ph_dev_info);
+		dm_device.ph_dev_info.report = NULL;
+	}
+}
+#endif //CONFIG_PAGE_REPORTING
+
 static int balloon_connect_vsp(struct hv_device *dev)
 {
 	struct dm_version_request version_req;
@@ -1710,6 +1795,10 @@ static int balloon_probe(struct hv_device *dev,
 	if (ret != 0)
 		return ret;
 
+#ifdef CONFIG_PAGE_REPORTING
+	enable_page_reporting();
+#endif
+
 	dm_device.state = DM_INITIALIZED;
 
 	dm_device.thread =
@@ -1725,6 +1814,9 @@ static int balloon_probe(struct hv_device *dev,
 	dm_device.state = DM_INIT_ERROR;
 	dm_device.thread  = NULL;
 	vmbus_close(dev->channel);
+#ifdef CONFIG_PAGE_REPORTING
+	disable_hinting();
+#endif
 #ifdef CONFIG_MEMORY_HOTPLUG
 	unregister_memory_notifier(&hv_memory_nb);
 	restore_online_page_callback(&hv_online_page);
@@ -1747,6 +1839,9 @@ static int balloon_remove(struct hv_device *dev)
 
 	kthread_stop(dm->thread);
 	vmbus_close(dev->channel);
+#ifdef CONFIG_PAGE_REPORTING
+	disable_hinting();
+#endif
 #ifdef CONFIG_MEMORY_HOTPLUG
 	unregister_memory_notifier(&hv_memory_nb);
 	restore_online_page_callback(&hv_online_page);

include/asm-generic/hyperv-tlfs.h

@@ -89,6 +89,7 @@
 #define HV_ACCESS_STATS				BIT(8)
 #define HV_DEBUGGING				BIT(11)
 #define HV_CPU_POWER_MANAGEMENT			BIT(12)
+#define HV_ENABLE_EXTENDED_HYPERCALLS           BIT(20)
 
 
 /*
@@ -151,6 +152,8 @@ 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_QUERY_CAPABILITIES		0x8001
+#define HVCALL_MEMORY_HEAT_HINT			0x8003
 
 #define HV_FLUSH_ALL_PROCESSORS			BIT(0)
 #define HV_FLUSH_ALL_VIRTUAL_ADDRESS_SPACES	BIT(1)
@@ -375,6 +378,12 @@ union hv_gpa_page_range {
 		u64 largepage:1;
 		u64 basepfn:52;
 	} page;
+	struct {
+		u64:12;
+		u64 page_size:1;
+		u64 reserved:8;
+		u64 base_large_pfn:43;
+	};
 };
 
 /*
@@ -494,4 +503,20 @@ struct hv_set_vp_registers_input {
 	} element[];
 } __packed;
 
+#ifdef CONFIG_PAGE_REPORTING
+#define HV_CAPABILITY_MEMORY_COLD_DISCARD_HINT	BIT(8)
+
+// The whole argument should fit in a page to be able to pass to the hypervisor
+// in one hypercall.
+#define HV_MAX_GPA_PAGE_RANGES ((PAGE_SIZE - 8)/sizeof(union hv_gpa_page_range))
+
+/* HvExtMemoryHeatHint hypercall */
+#define HV_MEMORY_HINT_TYPE_COLD_DISCARD	BIT(1)
+struct hv_memory_hint {
+	u64 type:2;
+	u64 reserved:62;
+	union hv_gpa_page_range ranges[1];
+};
+
+#endif //CONFIG_PAGE_REPORTING
 #endif