Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/x86/hyperv/nested.c
26486 views
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 <[email protected]>

9
 */

10
#define pr_fmt(fmt)  "Hyper-V: " fmt

11


12


13
#include <linux/types.h>

14
#include <linux/export.h>

15
#include <hyperv/hvhdk.h>

16
#include <asm/mshyperv.h>

17
#include <asm/tlbflush.h>

18


19
#include <asm/trace/hyperv.h>

20


21
int hyperv_flush_guest_mapping(u64 as)

22
{

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 = *this_cpu_ptr(hyperv_pcpu_input_arg);

34


35
	if (unlikely(!flush)) {

36
		local_irq_restore(flags);

37
		goto fault;

38
	}

39


40
	flush->address_space = as;

41
	flush->flags = 0;

42


43
	status = hv_do_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_SPACE,

44
				 flush, NULL);

45
	local_irq_restore(flags);

46


47
	if (hv_result_success(status))

48
		ret = 0;

49


50
fault:

51
	trace_hyperv_nested_flush_guest_mapping(as, ret);

52
	return ret;

53
}

54
EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping);

55


56
int hyperv_fill_flush_guest_mapping_list(

57
		struct hv_guest_mapping_flush_list *flush,

58
		u64 start_gfn, u64 pages)

59
{

60
	u64 cur = start_gfn;

61
	u64 additional_pages;

62
	int gpa_n = 0;

63


64
	do {

65
		/*

66
		 * If flush requests exceed max flush count, go back to

67
		 * flush tlbs without range.

68
		 */

69
		if (gpa_n >= HV_MAX_FLUSH_REP_COUNT)

70
			return -ENOSPC;

71


72
		additional_pages = min_t(u64, pages, HV_MAX_FLUSH_PAGES) - 1;

73


74
		flush->gpa_list[gpa_n].page.additional_pages = additional_pages;

75
		flush->gpa_list[gpa_n].page.largepage = false;

76
		flush->gpa_list[gpa_n].page.basepfn = cur;

77


78
		pages -= additional_pages + 1;

79
		cur += additional_pages + 1;

80
		gpa_n++;

81
	} while (pages > 0);

82


83
	return gpa_n;

84
}

85
EXPORT_SYMBOL_GPL(hyperv_fill_flush_guest_mapping_list);

86


87
int hyperv_flush_guest_mapping_range(u64 as,

88
		hyperv_fill_flush_list_func fill_flush_list_func, void *data)

89
{

90
	struct hv_guest_mapping_flush_list *flush;

91
	u64 status;

92
	unsigned long flags;

93
	int ret = -ENOTSUPP;

94
	int gpa_n = 0;

95


96
	if (!hv_hypercall_pg || !fill_flush_list_func)

97
		goto fault;

98


99
	local_irq_save(flags);

100


101
	flush = *this_cpu_ptr(hyperv_pcpu_input_arg);

102


103
	if (unlikely(!flush)) {

104
		local_irq_restore(flags);

105
		goto fault;

106
	}

107


108
	flush->address_space = as;

109
	flush->flags = 0;

110


111
	gpa_n = fill_flush_list_func(flush, data);

112
	if (gpa_n < 0) {

113
		local_irq_restore(flags);

114
		goto fault;

115
	}

116


117
	status = hv_do_rep_hypercall(HVCALL_FLUSH_GUEST_PHYSICAL_ADDRESS_LIST,

118
				     gpa_n, 0, flush, NULL);

119


120
	local_irq_restore(flags);

121


122
	if (hv_result_success(status))

123
		ret = 0;

124
	else

125
		ret = hv_result(status);

126
fault:

127
	trace_hyperv_nested_flush_guest_mapping_range(as, ret);

128
	return ret;

129
}

130
EXPORT_SYMBOL_GPL(hyperv_flush_guest_mapping_range);

131


132