Linux Audio

Check our new training course

Loading...
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2
  3/*
  4 * Hyper-V nested virtualization code.
  5 *
  6 * Copyright (C) 2018, Microsoft, Inc.
  7 *
  8 * Author : Lan Tianyu <Tianyu.Lan@microsoft.com>
  9 */
 10#define pr_fmt(fmt)  "Hyper-V: " fmt
 11
 12
 13#include <linux/types.h>
 14#include <asm/hyperv-tlfs.h>
 15#include <asm/mshyperv.h>
 16#include <asm/tlbflush.h>
 17
 18#include <asm/trace/hyperv.h>
 19
 20int hyperv_flush_guest_mapping(u64 as)
 21{
 
 22	struct hv_guest_mapping_flush *flush;
 23	u64 status;
 24	unsigned long flags;
 25	int ret = -ENOTSUPP;
 26
 27	if (!hv_hypercall_pg)
 28		goto fault;
 29
 30	local_irq_save(flags);
 31
 32	flush = *this_cpu_ptr(hyperv_pcpu_input_arg);
 
 
 
 33
 34	if (unlikely(!flush)) {
 35		local_irq_restore(flags);
 36		goto fault;
 37	}
 38
 39	flush->address_space = as;
 40	flush->flags = 0;
 41
 42	status = hv_do_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_SPACE,
 43				 flush, NULL);
 44	local_irq_restore(flags);
 45
 46	if (hv_result_success(status))
 47		ret = 0;
 48
 49fault:
 50	trace_hyperv_nested_flush_guest_mapping(as, ret);
 51	return ret;
 52}
 53EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping);
 54
 55int hyperv_fill_flush_guest_mapping_list(
 56		struct hv_guest_mapping_flush_list *flush,
 57		u64 start_gfn, u64 pages)
 58{
 59	u64 cur = start_gfn;
 60	u64 additional_pages;
 61	int gpa_n = 0;
 62
 63	do {
 64		/*
 65		 * If flush requests exceed max flush count, go back to
 66		 * flush tlbs without range.
 67		 */
 68		if (gpa_n >= HV_MAX_FLUSH_REP_COUNT)
 69			return -ENOSPC;
 70
 71		additional_pages = min_t(u64, pages, HV_MAX_FLUSH_PAGES) - 1;
 72
 73		flush->gpa_list[gpa_n].page.additional_pages = additional_pages;
 74		flush->gpa_list[gpa_n].page.largepage = false;
 75		flush->gpa_list[gpa_n].page.basepfn = cur;
 76
 77		pages -= additional_pages + 1;
 78		cur += additional_pages + 1;
 79		gpa_n++;
 80	} while (pages > 0);
 81
 82	return gpa_n;
 83}
 84EXPORT_SYMBOL_GPL(hyperv_fill_flush_guest_mapping_list);
 85
 86int hyperv_flush_guest_mapping_range(u64 as,
 87		hyperv_fill_flush_list_func fill_flush_list_func, void *data)
 88{
 
 89	struct hv_guest_mapping_flush_list *flush;
 90	u64 status;
 91	unsigned long flags;
 92	int ret = -ENOTSUPP;
 93	int gpa_n = 0;
 94
 95	if (!hv_hypercall_pg || !fill_flush_list_func)
 96		goto fault;
 97
 98	local_irq_save(flags);
 99
100	flush = *this_cpu_ptr(hyperv_pcpu_input_arg);
 
101
 
102	if (unlikely(!flush)) {
103		local_irq_restore(flags);
104		goto fault;
105	}
106
107	flush->address_space = as;
108	flush->flags = 0;
109
110	gpa_n = fill_flush_list_func(flush, data);
111	if (gpa_n < 0) {
112		local_irq_restore(flags);
113		goto fault;
114	}
115
116	status = hv_do_rep_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_LIST,
117				     gpa_n, 0, flush, NULL);
118
119	local_irq_restore(flags);
120
121	if (hv_result_success(status))
122		ret = 0;
123	else
124		ret = hv_result(status);
125fault:
126	trace_hyperv_nested_flush_guest_mapping_range(as, ret);
127	return ret;
128}
129EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping_range);
v5.4
  1// SPDX-License-Identifier: GPL-2.0
  2
  3/*
  4 * Hyper-V nested virtualization code.
  5 *
  6 * Copyright (C) 2018, Microsoft, Inc.
  7 *
  8 * Author : Lan Tianyu <Tianyu.Lan@microsoft.com>
  9 */
 10#define pr_fmt(fmt)  "Hyper-V: " fmt
 11
 12
 13#include <linux/types.h>
 14#include <asm/hyperv-tlfs.h>
 15#include <asm/mshyperv.h>
 16#include <asm/tlbflush.h>
 17
 18#include <asm/trace/hyperv.h>
 19
 20int hyperv_flush_guest_mapping(u64 as)
 21{
 22	struct hv_guest_mapping_flush **flush_pcpu;
 23	struct hv_guest_mapping_flush *flush;
 24	u64 status;
 25	unsigned long flags;
 26	int ret = -ENOTSUPP;
 27
 28	if (!hv_hypercall_pg)
 29		goto fault;
 30
 31	local_irq_save(flags);
 32
 33	flush_pcpu = (struct hv_guest_mapping_flush **)
 34		this_cpu_ptr(hyperv_pcpu_input_arg);
 35
 36	flush = *flush_pcpu;
 37
 38	if (unlikely(!flush)) {
 39		local_irq_restore(flags);
 40		goto fault;
 41	}
 42
 43	flush->address_space = as;
 44	flush->flags = 0;
 45
 46	status = hv_do_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_SPACE,
 47				 flush, NULL);
 48	local_irq_restore(flags);
 49
 50	if (!(status & HV_HYPERCALL_RESULT_MASK))
 51		ret = 0;
 52
 53fault:
 54	trace_hyperv_nested_flush_guest_mapping(as, ret);
 55	return ret;
 56}
 57EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping);
 58
 59int hyperv_fill_flush_guest_mapping_list(
 60		struct hv_guest_mapping_flush_list *flush,
 61		u64 start_gfn, u64 pages)
 62{
 63	u64 cur = start_gfn;
 64	u64 additional_pages;
 65	int gpa_n = 0;
 66
 67	do {
 68		/*
 69		 * If flush requests exceed max flush count, go back to
 70		 * flush tlbs without range.
 71		 */
 72		if (gpa_n >= HV_MAX_FLUSH_REP_COUNT)
 73			return -ENOSPC;
 74
 75		additional_pages = min_t(u64, pages, HV_MAX_FLUSH_PAGES) - 1;
 76
 77		flush->gpa_list[gpa_n].page.additional_pages = additional_pages;
 78		flush->gpa_list[gpa_n].page.largepage = false;
 79		flush->gpa_list[gpa_n].page.basepfn = cur;
 80
 81		pages -= additional_pages + 1;
 82		cur += additional_pages + 1;
 83		gpa_n++;
 84	} while (pages > 0);
 85
 86	return gpa_n;
 87}
 88EXPORT_SYMBOL_GPL(hyperv_fill_flush_guest_mapping_list);
 89
 90int hyperv_flush_guest_mapping_range(u64 as,
 91		hyperv_fill_flush_list_func fill_flush_list_func, void *data)
 92{
 93	struct hv_guest_mapping_flush_list **flush_pcpu;
 94	struct hv_guest_mapping_flush_list *flush;
 95	u64 status = 0;
 96	unsigned long flags;
 97	int ret = -ENOTSUPP;
 98	int gpa_n = 0;
 99
100	if (!hv_hypercall_pg || !fill_flush_list_func)
101		goto fault;
102
103	local_irq_save(flags);
104
105	flush_pcpu = (struct hv_guest_mapping_flush_list **)
106		this_cpu_ptr(hyperv_pcpu_input_arg);
107
108	flush = *flush_pcpu;
109	if (unlikely(!flush)) {
110		local_irq_restore(flags);
111		goto fault;
112	}
113
114	flush->address_space = as;
115	flush->flags = 0;
116
117	gpa_n = fill_flush_list_func(flush, data);
118	if (gpa_n < 0) {
119		local_irq_restore(flags);
120		goto fault;
121	}
122
123	status = hv_do_rep_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_LIST,
124				     gpa_n, 0, flush, NULL);
125
126	local_irq_restore(flags);
127
128	if (!(status & HV_HYPERCALL_RESULT_MASK))
129		ret = 0;
130	else
131		ret = status;
132fault:
133	trace_hyperv_nested_flush_guest_mapping_range(as, ret);
134	return ret;
135}
136EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping_range);