forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390 
 kernel/tools/testing/selftests/kvm/include/kvm_util.h
....@@ -1,30 +1,24 @@
1
+/* SPDX-License-Identifier: GPL-2.0-only */
12 /*
23  * tools/testing/selftests/kvm/include/kvm_util.h
34  *
45  * Copyright (C) 2018, Google LLC.
5
- *
6
- * This work is licensed under the terms of the GNU GPL, version 2.
7
- *
86  */
97 #ifndef SELFTEST_KVM_UTIL_H
10
-#define SELFTEST_KVM_UTIL_H 1
8
+#define SELFTEST_KVM_UTIL_H
119 
1210 #include "test_util.h"
1311 
1412 #include "asm/kvm.h"
13
+#include "linux/list.h"
1514 #include "linux/kvm.h"
1615 #include <sys/ioctl.h>
1716 
1817 #include "sparsebit.h"
1918 
19
+
2020 /*
21
- * Memslots can't cover the gfn starting at this gpa otherwise vCPUs can't be
22
- * created. Only applies to VMs using EPT.
23
- */
24
-#define KVM_DEFAULT_IDENTITY_MAP_ADDRESS 0xfffbc000ul
25
-
26
-
27
-/* Callers of kvm_util only have an incomplete/opaque description of the
21
+ * Callers of kvm_util only have an incomplete/opaque description of the
2822  * structure kvm_util is using to maintain the state of a VM.
2923  */
3024 struct kvm_vm;
....@@ -33,15 +27,33 @@
3327 typedef uint64_t vm_vaddr_t; /* Virtual Machine (Guest) virtual address */
3428 
3529 /* Minimum allocated guest virtual and physical addresses */
36
-#define KVM_UTIL_MIN_VADDR 0x2000
30
+#define KVM_UTIL_MIN_VADDR		0x2000
3731 
3832 #define DEFAULT_GUEST_PHY_PAGES		512
3933 #define DEFAULT_GUEST_STACK_VADDR_MIN	0xab6000
40
-#define DEFAULT_STACK_PGS               5
34
+#define DEFAULT_STACK_PGS		5
4135 
4236 enum vm_guest_mode {
43
-	VM_MODE_FLAT48PG,
37
+	VM_MODE_P52V48_4K,
38
+	VM_MODE_P52V48_64K,
39
+	VM_MODE_P48V48_4K,
40
+	VM_MODE_P48V48_64K,
41
+	VM_MODE_P40V48_4K,
42
+	VM_MODE_P40V48_64K,
43
+	VM_MODE_PXXV48_4K,	/* For 48bits VA but ANY bits PA */
44
+	NUM_VM_MODES,
4445 };
46
+
47
+#if defined(__aarch64__)
48
+#define VM_MODE_DEFAULT VM_MODE_P40V48_4K
49
+#elif defined(__x86_64__)
50
+#define VM_MODE_DEFAULT VM_MODE_PXXV48_4K
51
+#else
52
+#define VM_MODE_DEFAULT VM_MODE_P52V48_4K
53
+#endif
54
+
55
+#define vm_guest_mode_string(m) vm_guest_mode_string[m]
56
+extern const char * const vm_guest_mode_string[];
4557 
4658 enum vm_mem_backing_src_type {
4759 	VM_MEM_SRC_ANONYMOUS,
....@@ -51,22 +63,44 @@
5163 
5264 int kvm_check_cap(long cap);
5365 int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap);
66
+int vcpu_enable_cap(struct kvm_vm *vm, uint32_t vcpu_id,
67
+		    struct kvm_enable_cap *cap);
68
+void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size);
5469 
5570 struct kvm_vm *vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm);
5671 void kvm_vm_free(struct kvm_vm *vmp);
5772 void kvm_vm_restart(struct kvm_vm *vmp, int perm);
5873 void kvm_vm_release(struct kvm_vm *vmp);
5974 void kvm_vm_get_dirty_log(struct kvm_vm *vm, int slot, void *log);
75
+void kvm_vm_clear_dirty_log(struct kvm_vm *vm, int slot, void *log,
76
+			    uint64_t first_page, uint32_t num_pages);
6077 
61
-int kvm_memcmp_hva_gva(void *hva,
62
-	struct kvm_vm *vm, const vm_vaddr_t gva, size_t len);
78
+int kvm_memcmp_hva_gva(void *hva, struct kvm_vm *vm, const vm_vaddr_t gva,
79
+		       size_t len);
6380 
6481 void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename,
65
-	uint32_t data_memslot, uint32_t pgd_memslot);
82
+		     uint32_t data_memslot, uint32_t pgd_memslot);
6683 
6784 void vm_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent);
68
-void vcpu_dump(FILE *stream, struct kvm_vm *vm,
69
-	uint32_t vcpuid, uint8_t indent);
85
+
86
+/*
87
+ * VM VCPU Dump
88
+ *
89
+ * Input Args:
90
+ *   stream - Output FILE stream
91
+ *   vm     - Virtual Machine
92
+ *   vcpuid - VCPU ID
93
+ *   indent - Left margin indent amount
94
+ *
95
+ * Output Args: None
96
+ *
97
+ * Return: None
98
+ *
99
+ * Dumps the current state of the VCPU specified by @vcpuid, within the VM
100
+ * given by @vm, to the FILE stream given by @stream.
101
+ */
102
+void vcpu_dump(FILE *stream, struct kvm_vm *vm, uint32_t vcpuid,
103
+	       uint8_t indent);
70104 
71105 void vm_create_irqchip(struct kvm_vm *vm);
72106 
....@@ -75,73 +109,174 @@
75109 	uint64_t guest_paddr, uint32_t slot, uint64_t npages,
76110 	uint32_t flags);
77111 
78
-void vcpu_ioctl(struct kvm_vm *vm,
79
-	uint32_t vcpuid, unsigned long ioctl, void *arg);
112
+void vcpu_ioctl(struct kvm_vm *vm, uint32_t vcpuid, unsigned long ioctl,
113
+		void *arg);
114
+int _vcpu_ioctl(struct kvm_vm *vm, uint32_t vcpuid, unsigned long ioctl,
115
+		void *arg);
80116 void vm_ioctl(struct kvm_vm *vm, unsigned long ioctl, void *arg);
81117 void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags);
82
-void vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpuid, int pgd_memslot, int gdt_memslot);
118
+void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa);
119
+void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot);
120
+void vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpuid);
83121 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min,
84
-	uint32_t data_memslot, uint32_t pgd_memslot);
122
+			  uint32_t data_memslot, uint32_t pgd_memslot);
85123 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
86
-	      size_t size, uint32_t pgd_memslot);
124
+	      unsigned int npages, uint32_t pgd_memslot);
87125 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa);
88126 void *addr_gva2hva(struct kvm_vm *vm, vm_vaddr_t gva);
89127 vm_paddr_t addr_hva2gpa(struct kvm_vm *vm, void *hva);
128
+
129
+/*
130
+ * Address Guest Virtual to Guest Physical
131
+ *
132
+ * Input Args:
133
+ *   vm - Virtual Machine
134
+ *   gva - VM virtual address
135
+ *
136
+ * Output Args: None
137
+ *
138
+ * Return:
139
+ *   Equivalent VM physical address
140
+ *
141
+ * Returns the VM physical address of the translated VM virtual
142
+ * address given by @gva.
143
+ */
90144 vm_paddr_t addr_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva);
91145 
92146 struct kvm_run *vcpu_state(struct kvm_vm *vm, uint32_t vcpuid);
93147 void vcpu_run(struct kvm_vm *vm, uint32_t vcpuid);
94148 int _vcpu_run(struct kvm_vm *vm, uint32_t vcpuid);
149
+void vcpu_run_complete_io(struct kvm_vm *vm, uint32_t vcpuid);
150
+void vcpu_set_guest_debug(struct kvm_vm *vm, uint32_t vcpuid,
151
+			  struct kvm_guest_debug *debug);
95152 void vcpu_set_mp_state(struct kvm_vm *vm, uint32_t vcpuid,
96
-	struct kvm_mp_state *mp_state);
97
-void vcpu_regs_get(struct kvm_vm *vm,
98
-	uint32_t vcpuid, struct kvm_regs *regs);
99
-void vcpu_regs_set(struct kvm_vm *vm,
100
-	uint32_t vcpuid, struct kvm_regs *regs);
153
+		       struct kvm_mp_state *mp_state);
154
+struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vm *vm, uint32_t vcpuid);
155
+void vcpu_regs_get(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_regs *regs);
156
+void vcpu_regs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_regs *regs);
157
+
158
+/*
159
+ * VM VCPU Args Set
160
+ *
161
+ * Input Args:
162
+ *   vm - Virtual Machine
163
+ *   vcpuid - VCPU ID
164
+ *   num - number of arguments
165
+ *   ... - arguments, each of type uint64_t
166
+ *
167
+ * Output Args: None
168
+ *
169
+ * Return: None
170
+ *
171
+ * Sets the first @num function input registers of the VCPU with @vcpuid,
172
+ * per the C calling convention of the architecture, to the values given
173
+ * as variable args. Each of the variable args is expected to be of type
174
+ * uint64_t. The maximum @num can be is specific to the architecture.
175
+ */
101176 void vcpu_args_set(struct kvm_vm *vm, uint32_t vcpuid, unsigned int num, ...);
102
-void vcpu_sregs_get(struct kvm_vm *vm,
103
-	uint32_t vcpuid, struct kvm_sregs *sregs);
104
-void vcpu_sregs_set(struct kvm_vm *vm,
105
-	uint32_t vcpuid, struct kvm_sregs *sregs);
106
-int _vcpu_sregs_set(struct kvm_vm *vm,
107
-	uint32_t vcpuid, struct kvm_sregs *sregs);
177
+
178
+void vcpu_sregs_get(struct kvm_vm *vm, uint32_t vcpuid,
179
+		    struct kvm_sregs *sregs);
180
+void vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid,
181
+		    struct kvm_sregs *sregs);
182
+int _vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid,
183
+		    struct kvm_sregs *sregs);
184
+void vcpu_fpu_get(struct kvm_vm *vm, uint32_t vcpuid,
185
+		  struct kvm_fpu *fpu);
186
+void vcpu_fpu_set(struct kvm_vm *vm, uint32_t vcpuid,
187
+		  struct kvm_fpu *fpu);
188
+void vcpu_get_reg(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_one_reg *reg);
189
+void vcpu_set_reg(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_one_reg *reg);
190
+#ifdef __KVM_HAVE_VCPU_EVENTS
108191 void vcpu_events_get(struct kvm_vm *vm, uint32_t vcpuid,
109
-			  struct kvm_vcpu_events *events);
192
+		     struct kvm_vcpu_events *events);
110193 void vcpu_events_set(struct kvm_vm *vm, uint32_t vcpuid,
111
-			  struct kvm_vcpu_events *events);
112
-uint64_t vcpu_get_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index);
113
-void vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index,
114
-	uint64_t msr_value);
194
+		     struct kvm_vcpu_events *events);
195
+#endif
196
+#ifdef __x86_64__
197
+void vcpu_nested_state_get(struct kvm_vm *vm, uint32_t vcpuid,
198
+			   struct kvm_nested_state *state);
199
+int vcpu_nested_state_set(struct kvm_vm *vm, uint32_t vcpuid,
200
+			  struct kvm_nested_state *state, bool ignore_error);
201
+#endif
115202 
116203 const char *exit_reason_str(unsigned int exit_reason);
117204 
118205 void virt_pgd_alloc(struct kvm_vm *vm, uint32_t pgd_memslot);
206
+
207
+/*
208
+ * VM Virtual Page Map
209
+ *
210
+ * Input Args:
211
+ *   vm - Virtual Machine
212
+ *   vaddr - VM Virtual Address
213
+ *   paddr - VM Physical Address
214
+ *   memslot - Memory region slot for new virtual translation tables
215
+ *
216
+ * Output Args: None
217
+ *
218
+ * Return: None
219
+ *
220
+ * Within @vm, creates a virtual translation for the page starting
221
+ * at @vaddr to the page starting at @paddr.
222
+ */
119223 void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
120
-	uint32_t pgd_memslot);
121
-vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm,
122
-	vm_paddr_t paddr_min, uint32_t memslot);
224
+		 uint32_t memslot);
123225 
124
-struct kvm_cpuid2 *kvm_get_supported_cpuid(void);
125
-void vcpu_set_cpuid(
126
-	struct kvm_vm *vm, uint32_t vcpuid, struct kvm_cpuid2 *cpuid);
226
+vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,
227
+			     uint32_t memslot);
228
+vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,
229
+			      vm_paddr_t paddr_min, uint32_t memslot);
127230 
128
-struct kvm_cpuid_entry2 *
129
-kvm_get_supported_cpuid_index(uint32_t function, uint32_t index);
130
-
131
-static inline struct kvm_cpuid_entry2 *
132
-kvm_get_supported_cpuid_entry(uint32_t function)
133
-{
134
-	return kvm_get_supported_cpuid_index(function, 0);
135
-}
136
-
137
-struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_size,
231
+/*
232
+ * Create a VM with reasonable defaults
233
+ *
234
+ * Input Args:
235
+ *   vcpuid - The id of the single VCPU to add to the VM.
236
+ *   extra_mem_pages - The number of extra pages to add (this will
237
+ *                     decide how much extra space we will need to
238
+ *                     setup the page tables using memslot 0)
239
+ *   guest_code - The vCPU's entry point
240
+ *
241
+ * Output Args: None
242
+ *
243
+ * Return:
244
+ *   Pointer to opaque structure that describes the created VM.
245
+ */
246
+struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_pages,
138247 				 void *guest_code);
248
+
249
+/*
250
+ * Adds a vCPU with reasonable defaults (e.g. a stack)
251
+ *
252
+ * Input Args:
253
+ *   vm - Virtual Machine
254
+ *   vcpuid - The id of the VCPU to add to the VM.
255
+ *   guest_code - The vCPU's entry point
256
+ */
139257 void vm_vcpu_add_default(struct kvm_vm *vm, uint32_t vcpuid, void *guest_code);
140258 
141
-typedef void (*vmx_guest_code_t)(vm_vaddr_t vmxon_vaddr,
142
-				 vm_paddr_t vmxon_paddr,
143
-				 vm_vaddr_t vmcs_vaddr,
144
-				 vm_paddr_t vmcs_paddr);
259
+bool vm_is_unrestricted_guest(struct kvm_vm *vm);
260
+
261
+unsigned int vm_get_page_size(struct kvm_vm *vm);
262
+unsigned int vm_get_page_shift(struct kvm_vm *vm);
263
+unsigned int vm_get_max_gfn(struct kvm_vm *vm);
264
+int vm_get_fd(struct kvm_vm *vm);
265
+
266
+unsigned int vm_calc_num_guest_pages(enum vm_guest_mode mode, size_t size);
267
+unsigned int vm_num_host_pages(enum vm_guest_mode mode, unsigned int num_guest_pages);
268
+unsigned int vm_num_guest_pages(enum vm_guest_mode mode, unsigned int num_host_pages);
269
+static inline unsigned int
270
+vm_adjust_num_guest_pages(enum vm_guest_mode mode, unsigned int num_guest_pages)
271
+{
272
+	unsigned int n;
273
+	n = vm_num_guest_pages(mode, vm_num_host_pages(mode, num_guest_pages));
274
+#ifdef __s390x__
275
+	/* s390 requires 1M aligned guest sizes */
276
+	n = (n + 255) & ~255;
277
+#endif
278
+	return n;
279
+}
145280 
146281 struct kvm_userspace_memory_region *
147282 kvm_userspace_memory_region_find(struct kvm_vm *vm, uint64_t start,
....@@ -152,43 +287,62 @@
152287 
153288 int vm_create_device(struct kvm_vm *vm, struct kvm_create_device *cd);
154289 
155
-#define GUEST_PORT_SYNC         0x1000
156
-#define GUEST_PORT_ABORT        0x1001
157
-#define GUEST_PORT_DONE         0x1002
290
+#define sync_global_to_guest(vm, g) ({				\
291
+	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
292
+	memcpy(_p, &(g), sizeof(g));				\
293
+})
158294 
159
-static inline void __exit_to_l0(uint16_t port, uint64_t arg0, uint64_t arg1)
160
-{
161
-	__asm__ __volatile__("in %[port], %%al"
162
-			     :
163
-			     : [port]"d"(port), "D"(arg0), "S"(arg1)
164
-			     : "rax");
165
-}
295
+#define sync_global_from_guest(vm, g) ({			\
296
+	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
297
+	memcpy(&(g), _p, sizeof(g));				\
298
+})
166299 
167
-/*
168
- * Allows to pass three arguments to the host: port is 16bit wide,
169
- * arg0 & arg1 are 64bit wide
170
- */
171
-#define GUEST_SYNC_ARGS(_port, _arg0, _arg1) \
172
-	__exit_to_l0(_port, (uint64_t) (_arg0), (uint64_t) (_arg1))
300
+void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);
173301 
174
-#define GUEST_ASSERT(_condition) do {				\
175
-		if (!(_condition))				\
176
-			GUEST_SYNC_ARGS(GUEST_PORT_ABORT,	\
177
-					"Failed guest assert: "	\
178
-					#_condition, __LINE__);	\
179
-	} while (0)
302
+/* Common ucalls */
303
+enum {
304
+	UCALL_NONE,
305
+	UCALL_SYNC,
306
+	UCALL_ABORT,
307
+	UCALL_DONE,
308
+};
180309 
181
-#define GUEST_SYNC(stage)  GUEST_SYNC_ARGS(GUEST_PORT_SYNC, "hello", stage)
310
+#define UCALL_MAX_ARGS 6
182311 
183
-#define GUEST_DONE()  GUEST_SYNC_ARGS(GUEST_PORT_DONE, 0, 0)
312
+struct ucall {
313
+	uint64_t cmd;
314
+	uint64_t args[UCALL_MAX_ARGS];
315
+};
184316 
185
-struct guest_args {
186
-	uint64_t arg0;
187
-	uint64_t arg1;
188
-	uint16_t port;
189
-} __attribute__ ((packed));
317
+void ucall_init(struct kvm_vm *vm, void *arg);
318
+void ucall_uninit(struct kvm_vm *vm);
319
+void ucall(uint64_t cmd, int nargs, ...);
320
+uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc);
190321 
191
-void guest_args_read(struct kvm_vm *vm, uint32_t vcpu_id,
192
-		     struct guest_args *args);
322
+#define GUEST_SYNC_ARGS(stage, arg1, arg2, arg3, arg4)	\
323
+				ucall(UCALL_SYNC, 6, "hello", stage, arg1, arg2, arg3, arg4)
324
+#define GUEST_SYNC(stage)	ucall(UCALL_SYNC, 2, "hello", stage)
325
+#define GUEST_DONE()		ucall(UCALL_DONE, 0)
326
+#define __GUEST_ASSERT(_condition, _nargs, _args...) do {	\
327
+	if (!(_condition))					\
328
+		ucall(UCALL_ABORT, 2 + _nargs,			\
329
+			"Failed guest assert: "			\
330
+			#_condition, __LINE__, _args);		\
331
+} while (0)
332
+
333
+#define GUEST_ASSERT(_condition) \
334
+	__GUEST_ASSERT((_condition), 0, 0)
335
+
336
+#define GUEST_ASSERT_1(_condition, arg1) \
337
+	__GUEST_ASSERT((_condition), 1, (arg1))
338
+
339
+#define GUEST_ASSERT_2(_condition, arg1, arg2) \
340
+	__GUEST_ASSERT((_condition), 2, (arg1), (arg2))
341
+
342
+#define GUEST_ASSERT_3(_condition, arg1, arg2, arg3) \
343
+	__GUEST_ASSERT((_condition), 3, (arg1), (arg2), (arg3))
344
+
345
+#define GUEST_ASSERT_4(_condition, arg1, arg2, arg3, arg4) \
346
+	__GUEST_ASSERT((_condition), 4, (arg1), (arg2), (arg3), (arg4))
193347 
194348 #endif /* SELFTEST_KVM_UTIL_H */