mmu.h 7.63 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0 */
2
3
4
#ifndef __KVM_X86_MMU_H
#define __KVM_X86_MMU_H

5
#include <linux/kvm_host.h>
6
#include "kvm_cache_regs.h"
7

8
9
10
11
12
13
#define PT64_PT_BITS 9
#define PT64_ENT_PER_PAGE (1 << PT64_PT_BITS)
#define PT32_PT_BITS 10
#define PT32_ENT_PER_PAGE (1 << PT32_PT_BITS)

#define PT_WRITABLE_SHIFT 1
14
#define PT_USER_SHIFT 2
15
16
17

#define PT_PRESENT_MASK (1ULL << 0)
#define PT_WRITABLE_MASK (1ULL << PT_WRITABLE_SHIFT)
18
#define PT_USER_MASK (1ULL << PT_USER_SHIFT)
19
20
#define PT_PWT_MASK (1ULL << 3)
#define PT_PCD_MASK (1ULL << 4)
21
22
#define PT_ACCESSED_SHIFT 5
#define PT_ACCESSED_MASK (1ULL << PT_ACCESSED_SHIFT)
23
24
#define PT_DIRTY_SHIFT 6
#define PT_DIRTY_MASK (1ULL << PT_DIRTY_SHIFT)
Avi Kivity's avatar
Avi Kivity committed
25
26
#define PT_PAGE_SIZE_SHIFT 7
#define PT_PAGE_SIZE_MASK (1ULL << PT_PAGE_SIZE_SHIFT)
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#define PT_PAT_MASK (1ULL << 7)
#define PT_GLOBAL_MASK (1ULL << 8)
#define PT64_NX_SHIFT 63
#define PT64_NX_MASK (1ULL << PT64_NX_SHIFT)

#define PT_PAT_SHIFT 7
#define PT_DIR_PAT_SHIFT 12
#define PT_DIR_PAT_MASK (1ULL << PT_DIR_PAT_SHIFT)

#define PT32_DIR_PSE36_SIZE 4
#define PT32_DIR_PSE36_SHIFT 13
#define PT32_DIR_PSE36_MASK \
	(((1ULL << PT32_DIR_PSE36_SIZE) - 1) << PT32_DIR_PSE36_SHIFT)

41
#define PT64_ROOT_5LEVEL 5
42
#define PT64_ROOT_4LEVEL 4
43
44
45
#define PT32_ROOT_LEVEL 2
#define PT32E_ROOT_LEVEL 3

46
47
static inline u64 rsvd_bits(int s, int e)
{
48
49
50
	if (e < s)
		return 0;

51
52
53
	return ((1ULL << (e - s + 1)) - 1) << s;
}

54
void kvm_mmu_set_mmio_spte_mask(u64 mmio_mask, u64 mmio_value, u64 access_mask);
55

56
57
58
void
reset_shadow_zero_bits_mask(struct kvm_vcpu *vcpu, struct kvm_mmu *context);

59
void kvm_init_mmu(struct kvm_vcpu *vcpu, bool reset_roots);
60
void kvm_init_shadow_mmu(struct kvm_vcpu *vcpu);
61
void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, bool execonly,
62
			     bool accessed_dirty, gpa_t new_eptp);
63
bool kvm_can_do_async_pf(struct kvm_vcpu *vcpu);
64
int kvm_handle_page_fault(struct kvm_vcpu *vcpu, u64 error_code,
65
				u64 fault_address, char *insn, int insn_len);
66

67
static inline unsigned long kvm_mmu_available_pages(struct kvm *kvm)
68
{
69
70
71
72
73
	if (kvm->arch.n_max_mmu_pages > kvm->arch.n_used_mmu_pages)
		return kvm->arch.n_max_mmu_pages -
			kvm->arch.n_used_mmu_pages;

	return 0;
74
75
}

76
77
static inline int kvm_mmu_reload(struct kvm_vcpu *vcpu)
{
78
	if (likely(vcpu->arch.mmu->root_hpa != INVALID_PAGE))
79
80
81
82
83
		return 0;

	return kvm_mmu_load(vcpu);
}

84
85
86
87
88
89
90
91
92
93
94
95
96
97
static inline unsigned long kvm_get_pcid(struct kvm_vcpu *vcpu, gpa_t cr3)
{
	BUILD_BUG_ON((X86_CR3_PCID_MASK & PAGE_MASK) != 0);

	return kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE)
	       ? cr3 & X86_CR3_PCID_MASK
	       : 0;
}

static inline unsigned long kvm_get_active_pcid(struct kvm_vcpu *vcpu)
{
	return kvm_get_pcid(vcpu, kvm_read_cr3(vcpu));
}

98
static inline void kvm_mmu_load_pgd(struct kvm_vcpu *vcpu)
99
{
100
	if (VALID_PAGE(vcpu->arch.mmu->root_hpa))
101
102
		kvm_x86_ops->set_cr3(vcpu, vcpu->arch.mmu->root_hpa |
				     kvm_get_active_pcid(vcpu));
103
104
}

105
106
107
108
109
110
111
112
113
114
115
116
117
int kvm_tdp_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,
		       bool prefault);

static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa,
					u32 err, bool prefault)
{
#ifdef CONFIG_RETPOLINE
	if (likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault))
		return kvm_tdp_page_fault(vcpu, cr2_or_gpa, err, prefault);
#endif
	return vcpu->arch.mmu->page_fault(vcpu, cr2_or_gpa, err, prefault);
}

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/*
 * Currently, we have two sorts of write-protection, a) the first one
 * write-protects guest page to sync the guest modification, b) another one is
 * used to sync dirty bitmap when we do KVM_GET_DIRTY_LOG. The differences
 * between these two sorts are:
 * 1) the first case clears SPTE_MMU_WRITEABLE bit.
 * 2) the first case requires flushing tlb immediately avoiding corrupting
 *    shadow page table between all vcpus so it should be in the protection of
 *    mmu-lock. And the another case does not need to flush tlb until returning
 *    the dirty bitmap to userspace since it only write-protects the page
 *    logged in the bitmap, that means the page in the dirty bitmap is not
 *    missed, so it can flush tlb out of mmu-lock.
 *
 * So, there is the problem: the first case can meet the corrupted tlb caused
 * by another case which write-protects pages but without flush tlb
 * immediately. In order to making the first case be aware this problem we let
 * it flush tlb if we try to write-protect a spte whose SPTE_MMU_WRITEABLE bit
 * is set, it works since another case never touches SPTE_MMU_WRITEABLE bit.
 *
 * Anyway, whenever a spte is updated (only permission and status bits are
 * changed) we need to check whether the spte with SPTE_MMU_WRITEABLE becomes
 * readonly, if that happens, we need to flush tlb. Fortunately,
 * mmu_spte_update() has already handled it perfectly.
 *
 * The rules to use SPTE_MMU_WRITEABLE and PT_WRITABLE_MASK:
 * - if we want to see if it has writable tlb entry or if the spte can be
 *   writable on the mmu mapping, check SPTE_MMU_WRITEABLE, this is the most
 *   case, otherwise
 * - if we fix page fault on the spte or do write-protection by dirty logging,
 *   check PT_WRITABLE_MASK.
 *
 * TODO: introduce APIs to split these two cases.
 */
151
152
153
154
155
156
157
158
159
160
static inline int is_writable_pte(unsigned long pte)
{
	return pte & PT_WRITABLE_MASK;
}

static inline bool is_write_protection(struct kvm_vcpu *vcpu)
{
	return kvm_read_cr0_bits(vcpu, X86_CR0_WP);
}

161
/*
162
163
164
165
166
167
 * Check if a given access (described through the I/D, W/R and U/S bits of a
 * page fault error code pfec) causes a permission fault with the given PTE
 * access rights (in ACC_* format).
 *
 * Return zero if the access does not fault; return the page fault error code
 * if the access faults.
168
 */
169
static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,
170
171
				  unsigned pte_access, unsigned pte_pkey,
				  unsigned pfec)
172
{
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
	int cpl = kvm_x86_ops->get_cpl(vcpu);
	unsigned long rflags = kvm_x86_ops->get_rflags(vcpu);

	/*
	 * If CPL < 3, SMAP prevention are disabled if EFLAGS.AC = 1.
	 *
	 * If CPL = 3, SMAP applies to all supervisor-mode data accesses
	 * (these are implicit supervisor accesses) regardless of the value
	 * of EFLAGS.AC.
	 *
	 * This computes (cpl < 3) && (rflags & X86_EFLAGS_AC), leaving
	 * the result in X86_EFLAGS_AC. We then insert it in place of
	 * the PFERR_RSVD_MASK bit; this bit will always be zero in pfec,
	 * but it will be one in index if SMAP checks are being overridden.
	 * It is important to keep this branchless.
	 */
	unsigned long smap = (cpl - 3) & (rflags & X86_EFLAGS_AC);
	int index = (pfec >> 1) +
		    (smap >> (X86_EFLAGS_AC_BIT - PFERR_RSVD_BIT + 1));
192
	bool fault = (mmu->permissions[index] >> pte_access) & 1;
193
	u32 errcode = PFERR_PRESENT_MASK;
194

195
196
197
198
199
200
201
202
203
204
	WARN_ON(pfec & (PFERR_PK_MASK | PFERR_RSVD_MASK));
	if (unlikely(mmu->pkru_mask)) {
		u32 pkru_bits, offset;

		/*
		* PKRU defines 32 bits, there are 16 domains and 2
		* attribute bits per domain in pkru.  pte_pkey is the
		* index of the protection domain, so pte_pkey * 2 is
		* is the index of the first bit for the domain.
		*/
205
		pkru_bits = (vcpu->arch.pkru >> (pte_pkey * 2)) & 3;
206
207

		/* clear present bit, replace PFEC.RSVD with ACC_USER_MASK. */
208
		offset = (pfec & ~1) +
209
210
211
			((pte_access & PT_USER_MASK) << (PFERR_RSVD_BIT - PT_USER_SHIFT));

		pkru_bits &= mmu->pkru_mask >> offset;
212
		errcode |= -pkru_bits & PFERR_PK_MASK;
213
214
215
		fault |= (pkru_bits != 0);
	}

216
	return -(u32)fault & errcode;
217
}
218

Xiao Guangrong's avatar
Xiao Guangrong committed
219
void kvm_zap_gfn_range(struct kvm *kvm, gfn_t gfn_start, gfn_t gfn_end);
220
221
222

void kvm_mmu_gfn_disallow_lpage(struct kvm_memory_slot *slot, gfn_t gfn);
void kvm_mmu_gfn_allow_lpage(struct kvm_memory_slot *slot, gfn_t gfn);
223
224
bool kvm_mmu_slot_gfn_write_protect(struct kvm *kvm,
				    struct kvm_memory_slot *slot, u64 gfn);
225
int kvm_arch_write_log_dirty(struct kvm_vcpu *vcpu);
226
227
228
229

int kvm_mmu_post_init_vm(struct kvm *kvm);
void kvm_mmu_pre_destroy_vm(struct kvm *kvm);

230
#endif