Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
KVM: selftests: Replace "u64 gpa" with "gpa_t" throughout
Use gpa_t instead of u64 for obvious declarations of GPA variables.
No functional change intended.
Link: https://patch.msgid.link/20260420212004.3938325-18-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>
+55
-55
+1
-1
tools/testing/selftests/kvm/guest_memfd_test.c
+1
-1
tools/testing/selftests/kvm/guest_memfd_test.c
+13
-13
tools/testing/selftests/kvm/include/kvm_util.h
+13
-13
tools/testing/selftests/kvm/include/kvm_util.h
···
114
114
gpa_t ucall_mmio_addr;
115
115
gva_t handlers;
116
116
u32 dirty_ring_size;
117
-
u64 gpa_tag_mask;
117
+
gpa_t gpa_tag_mask;
118
118
119
119
/*
120
120
* "mmu" is the guest's stage-1, with a short name because the vast
···
418
418
vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
419
419
}
420
420
421
-
static inline void vm_set_memory_attributes(struct kvm_vm *vm, u64 gpa,
421
+
static inline void vm_set_memory_attributes(struct kvm_vm *vm, gpa_t gpa,
422
422
u64 size, u64 attributes)
423
423
{
424
424
struct kvm_memory_attributes attr = {
···
439
439
}
440
440
441
441
442
-
static inline void vm_mem_set_private(struct kvm_vm *vm, u64 gpa,
442
+
static inline void vm_mem_set_private(struct kvm_vm *vm, gpa_t gpa,
443
443
u64 size)
444
444
{
445
445
vm_set_memory_attributes(vm, gpa, size, KVM_MEMORY_ATTRIBUTE_PRIVATE);
446
446
}
447
447
448
-
static inline void vm_mem_set_shared(struct kvm_vm *vm, u64 gpa,
448
+
static inline void vm_mem_set_shared(struct kvm_vm *vm, gpa_t gpa,
449
449
u64 size)
450
450
{
451
451
vm_set_memory_attributes(vm, gpa, size, 0);
452
452
}
453
453
454
-
void vm_guest_mem_fallocate(struct kvm_vm *vm, u64 gpa, u64 size,
454
+
void vm_guest_mem_fallocate(struct kvm_vm *vm, gpa_t gpa, u64 size,
455
455
bool punch_hole);
456
456
457
-
static inline void vm_guest_mem_punch_hole(struct kvm_vm *vm, u64 gpa,
457
+
static inline void vm_guest_mem_punch_hole(struct kvm_vm *vm, gpa_t gpa,
458
458
u64 size)
459
459
{
460
460
vm_guest_mem_fallocate(vm, gpa, size, true);
461
461
}
462
462
463
-
static inline void vm_guest_mem_allocate(struct kvm_vm *vm, u64 gpa,
463
+
static inline void vm_guest_mem_allocate(struct kvm_vm *vm, gpa_t gpa,
464
464
u64 size)
465
465
{
466
466
vm_guest_mem_fallocate(vm, gpa, size, false);
···
685
685
}
686
686
687
687
void vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
688
-
u64 gpa, u64 size, void *hva);
688
+
gpa_t gpa, u64 size, void *hva);
689
689
int __vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
690
-
u64 gpa, u64 size, void *hva);
690
+
gpa_t gpa, u64 size, void *hva);
691
691
void vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
692
-
u64 gpa, u64 size, void *hva,
692
+
gpa_t gpa, u64 size, void *hva,
693
693
u32 guest_memfd, u64 guest_memfd_offset);
694
694
int __vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
695
-
u64 gpa, u64 size, void *hva,
695
+
gpa_t gpa, u64 size, void *hva,
696
696
u32 guest_memfd, u64 guest_memfd_offset);
697
697
698
698
void vm_userspace_mem_region_add(struct kvm_vm *vm,
699
699
enum vm_mem_backing_src_type src_type,
700
-
u64 gpa, u32 slot, u64 npages, u32 flags);
700
+
gpa_t gpa, u32 slot, u64 npages, u32 flags);
701
701
void vm_mem_add(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,
702
-
u64 gpa, u32 slot, u64 npages, u32 flags,
702
+
gpa_t gpa, u32 slot, u64 npages, u32 flags,
703
703
int guest_memfd_fd, u64 guest_memfd_offset);
704
704
705
705
#ifndef vm_arch_has_protected_memory
+2
-2
tools/testing/selftests/kvm/include/memstress.h
+2
-2
tools/testing/selftests/kvm/include/memstress.h
···
20
20
#define MEMSTRESS_MEM_SLOT_INDEX 1
21
21
22
22
struct memstress_vcpu_args {
23
-
u64 gpa;
23
+
gpa_t gpa;
24
24
gva_t gva;
25
25
u64 pages;
26
26
···
32
32
struct memstress_args {
33
33
struct kvm_vm *vm;
34
34
/* The starting address and size of the guest test region. */
35
-
u64 gpa;
35
+
gpa_t gpa;
36
36
u64 size;
37
37
u64 guest_page_size;
38
38
u32 random_seed;
+2
-2
tools/testing/selftests/kvm/include/x86/processor.h
+2
-2
tools/testing/selftests/kvm/include/x86/processor.h
···
1400
1400
u64 __xen_hypercall(u64 nr, u64 a0, void *a1);
1401
1401
void xen_hypercall(u64 nr, u64 a0, void *a1);
1402
1402
1403
-
static inline u64 __kvm_hypercall_map_gpa_range(u64 gpa, u64 size, u64 flags)
1403
+
static inline u64 __kvm_hypercall_map_gpa_range(gpa_t gpa, u64 size, u64 flags)
1404
1404
{
1405
1405
return kvm_hypercall(KVM_HC_MAP_GPA_RANGE, gpa, size >> PAGE_SHIFT, flags, 0);
1406
1406
}
1407
1407
1408
-
static inline void kvm_hypercall_map_gpa_range(u64 gpa, u64 size, u64 flags)
1408
+
static inline void kvm_hypercall_map_gpa_range(gpa_t gpa, u64 size, u64 flags)
1409
1409
{
1410
1410
u64 ret = __kvm_hypercall_map_gpa_range(gpa, size, flags);
1411
1411
+7
-7
tools/testing/selftests/kvm/lib/kvm_util.c
+7
-7
tools/testing/selftests/kvm/lib/kvm_util.c
···
919
919
920
920
921
921
int __vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
922
-
u64 gpa, u64 size, void *hva)
922
+
gpa_t gpa, u64 size, void *hva)
923
923
{
924
924
struct kvm_userspace_memory_region region = {
925
925
.slot = slot,
···
933
933
}
934
934
935
935
void vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
936
-
u64 gpa, u64 size, void *hva)
936
+
gpa_t gpa, u64 size, void *hva)
937
937
{
938
938
int ret = __vm_set_user_memory_region(vm, slot, flags, gpa, size, hva);
939
939
···
946
946
"KVM selftests now require KVM_SET_USER_MEMORY_REGION2 (introduced in v6.8)")
947
947
948
948
int __vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
949
-
u64 gpa, u64 size, void *hva,
949
+
gpa_t gpa, u64 size, void *hva,
950
950
u32 guest_memfd, u64 guest_memfd_offset)
951
951
{
952
952
struct kvm_userspace_memory_region2 region = {
···
965
965
}
966
966
967
967
void vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
968
-
u64 gpa, u64 size, void *hva,
968
+
gpa_t gpa, u64 size, void *hva,
969
969
u32 guest_memfd, u64 guest_memfd_offset)
970
970
{
971
971
int ret = __vm_set_user_memory_region2(vm, slot, flags, gpa, size, hva,
···
978
978
979
979
/* FIXME: This thing needs to be ripped apart and rewritten. */
980
980
void vm_mem_add(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,
981
-
u64 gpa, u32 slot, u64 npages, u32 flags,
981
+
gpa_t gpa, u32 slot, u64 npages, u32 flags,
982
982
int guest_memfd, u64 guest_memfd_offset)
983
983
{
984
984
int ret;
···
1141
1141
1142
1142
void vm_userspace_mem_region_add(struct kvm_vm *vm,
1143
1143
enum vm_mem_backing_src_type src_type,
1144
-
u64 gpa, u32 slot, u64 npages, u32 flags)
1144
+
gpa_t gpa, u32 slot, u64 npages, u32 flags)
1145
1145
{
1146
1146
vm_mem_add(vm, src_type, gpa, slot, npages, flags, -1, 0);
1147
1147
}
···
1278
1278
const int mode = FALLOC_FL_KEEP_SIZE | (punch_hole ? FALLOC_FL_PUNCH_HOLE : 0);
1279
1279
struct userspace_mem_region *region;
1280
1280
u64 end = base + size;
1281
-
u64 gpa, len;
1281
+
gpa_t gpa, len;
1282
1282
off_t fd_offset;
1283
1283
int ret;
1284
1284
+1
-1
tools/testing/selftests/kvm/lib/s390/processor.c
+1
-1
tools/testing/selftests/kvm/lib/s390/processor.c
+1
-1
tools/testing/selftests/kvm/memslot_modification_stress_test.c
+1
-1
tools/testing/selftests/kvm/memslot_modification_stress_test.c
+5
-5
tools/testing/selftests/kvm/memslot_perf_test.c
+5
-5
tools/testing/selftests/kvm/memslot_perf_test.c
···
186
186
"sem_timedwait() failed: %d", errno);
187
187
}
188
188
189
-
static void *vm_gpa2hva(struct vm_data *data, u64 gpa, u64 *rempages)
189
+
static void *vm_gpa2hva(struct vm_data *data, gpa_t gpa, u64 *rempages)
190
190
{
191
-
u64 gpage, pgoffs;
191
+
gpa_t gpage, pgoffs;
192
192
u32 slot, slotoffs;
193
193
void *base;
194
194
u32 guest_page_size = data->vm->page_size;
···
332
332
333
333
for (slot = 1, guest_addr = MEM_GPA; slot <= data->nslots; slot++) {
334
334
u64 npages;
335
-
u64 gpa;
335
+
gpa_t gpa;
336
336
337
337
npages = data->pages_per_slot;
338
338
if (slot == data->nslots)
···
638
638
static void test_memslot_do_unmap(struct vm_data *data,
639
639
u64 offsp, u64 count)
640
640
{
641
-
u64 gpa, ctr;
641
+
gpa_t gpa, ctr;
642
642
u32 guest_page_size = data->vm->page_size;
643
643
644
644
for (gpa = MEM_TEST_GPA + offsp * guest_page_size, ctr = 0; ctr < count; ) {
···
663
663
static void test_memslot_map_unmap_check(struct vm_data *data,
664
664
u64 offsp, u64 valexp)
665
665
{
666
-
u64 gpa;
666
+
gpa_t gpa;
667
667
u64 *val;
668
668
u32 guest_page_size = data->vm->page_size;
669
669
+2
-2
tools/testing/selftests/kvm/mmu_stress_test.c
+2
-2
tools/testing/selftests/kvm/mmu_stress_test.c
···
22
22
23
23
static void guest_code(u64 start_gpa, u64 end_gpa, u64 stride)
24
24
{
25
-
u64 gpa;
25
+
gpa_t gpa;
26
26
int i;
27
27
28
28
for (i = 0; i < 2; i++) {
···
206
206
u64 start_gpa, u64 end_gpa)
207
207
{
208
208
struct vcpu_info *info;
209
-
u64 gpa, nr_bytes;
209
+
gpa_t gpa, nr_bytes;
210
210
pthread_t *threads;
211
211
int i;
212
212
+2
-2
tools/testing/selftests/kvm/pre_fault_memory_test.c
+2
-2
tools/testing/selftests/kvm/pre_fault_memory_test.c
···
33
33
34
34
struct slot_worker_data {
35
35
struct kvm_vm *vm;
36
-
u64 gpa;
36
+
gpa_t gpa;
37
37
u32 flags;
38
38
bool worker_ready;
39
39
bool prefault_ready;
···
161
161
162
162
static void __test_pre_fault_memory(unsigned long vm_type, bool private)
163
163
{
164
-
u64 gpa, gva, alignment, guest_page_size;
164
+
gpa_t gpa, gva, alignment, guest_page_size;
165
165
const struct vm_shape shape = {
166
166
.mode = VM_MODE_DEFAULT,
167
167
.type = vm_type,
+1
-1
tools/testing/selftests/kvm/s390/ucontrol_test.c
+1
-1
tools/testing/selftests/kvm/s390/ucontrol_test.c
···
269
269
}
270
270
271
271
/* calculate host virtual addr from guest physical addr */
272
-
static void *gpa2hva(FIXTURE_DATA(uc_kvm) *self, u64 gpa)
272
+
static void *gpa2hva(FIXTURE_DATA(uc_kvm) *self, gpa_t gpa)
273
273
{
274
274
return (void *)(self->base_hva - self->base_gpa + gpa);
275
275
}
+1
-1
tools/testing/selftests/kvm/set_memory_region_test.c
+1
-1
tools/testing/selftests/kvm/set_memory_region_test.c
+12
-12
tools/testing/selftests/kvm/x86/private_mem_conversions_test.c
+12
-12
tools/testing/selftests/kvm/x86/private_mem_conversions_test.c
···
38
38
pattern, i, gpa + i, mem[i]); \
39
39
} while (0)
40
40
41
-
static void memcmp_h(u8 *mem, u64 gpa, u8 pattern, size_t size)
41
+
static void memcmp_h(u8 *mem, gpa_t gpa, u8 pattern, size_t size)
42
42
{
43
43
size_t i;
44
44
···
70
70
SYNC_PRIVATE,
71
71
};
72
72
73
-
static void guest_sync_shared(u64 gpa, u64 size,
73
+
static void guest_sync_shared(gpa_t gpa, u64 size,
74
74
u8 current_pattern, u8 new_pattern)
75
75
{
76
76
GUEST_SYNC5(SYNC_SHARED, gpa, size, current_pattern, new_pattern);
77
77
}
78
78
79
-
static void guest_sync_private(u64 gpa, u64 size, u8 pattern)
79
+
static void guest_sync_private(gpa_t gpa, u64 size, u8 pattern)
80
80
{
81
81
GUEST_SYNC4(SYNC_PRIVATE, gpa, size, pattern);
82
82
}
···
86
86
#define MAP_GPA_SHARED BIT(1)
87
87
#define MAP_GPA_DO_FALLOCATE BIT(2)
88
88
89
-
static void guest_map_mem(u64 gpa, u64 size, bool map_shared,
89
+
static void guest_map_mem(gpa_t gpa, u64 size, bool map_shared,
90
90
bool do_fallocate)
91
91
{
92
92
u64 flags = MAP_GPA_SET_ATTRIBUTES;
···
98
98
kvm_hypercall_map_gpa_range(gpa, size, flags);
99
99
}
100
100
101
-
static void guest_map_shared(u64 gpa, u64 size, bool do_fallocate)
101
+
static void guest_map_shared(gpa_t gpa, u64 size, bool do_fallocate)
102
102
{
103
103
guest_map_mem(gpa, size, true, do_fallocate);
104
104
}
105
105
106
-
static void guest_map_private(u64 gpa, u64 size, bool do_fallocate)
106
+
static void guest_map_private(gpa_t gpa, u64 size, bool do_fallocate)
107
107
{
108
108
guest_map_mem(gpa, size, false, do_fallocate);
109
109
}
···
134
134
memcmp_g(base_gpa, init_p, PER_CPU_DATA_SIZE);
135
135
136
136
for (i = 0; i < ARRAY_SIZE(test_ranges); i++) {
137
-
u64 gpa = base_gpa + test_ranges[i].offset;
137
+
gpa_t gpa = base_gpa + test_ranges[i].offset;
138
138
u64 size = test_ranges[i].size;
139
139
u8 p1 = 0x11;
140
140
u8 p2 = 0x22;
···
214
214
}
215
215
}
216
216
217
-
static void guest_punch_hole(u64 gpa, u64 size)
217
+
static void guest_punch_hole(gpa_t gpa, u64 size)
218
218
{
219
219
/* "Mapping" memory shared via fallocate() is done via PUNCH_HOLE. */
220
220
u64 flags = MAP_GPA_SHARED | MAP_GPA_DO_FALLOCATE;
···
239
239
guest_map_private(base_gpa, PER_CPU_DATA_SIZE, false);
240
240
241
241
for (i = 0; i < ARRAY_SIZE(test_ranges); i++) {
242
-
u64 gpa = base_gpa + test_ranges[i].offset;
242
+
gpa_t gpa = base_gpa + test_ranges[i].offset;
243
243
u64 size = test_ranges[i].size;
244
244
245
245
/*
···
289
289
static void handle_exit_hypercall(struct kvm_vcpu *vcpu)
290
290
{
291
291
struct kvm_run *run = vcpu->run;
292
-
u64 gpa = run->hypercall.args[0];
292
+
gpa_t gpa = run->hypercall.args[0];
293
293
u64 size = run->hypercall.args[1] * PAGE_SIZE;
294
294
bool set_attributes = run->hypercall.args[2] & MAP_GPA_SET_ATTRIBUTES;
295
295
bool map_shared = run->hypercall.args[2] & MAP_GPA_SHARED;
···
337
337
case UCALL_ABORT:
338
338
REPORT_GUEST_ASSERT(uc);
339
339
case UCALL_SYNC: {
340
-
u64 gpa = uc.args[1];
340
+
gpa_t gpa = uc.args[1];
341
341
size_t size = uc.args[2];
342
342
size_t i;
343
343
···
402
402
KVM_MEM_GUEST_MEMFD, memfd, slot_size * i);
403
403
404
404
for (i = 0; i < nr_vcpus; i++) {
405
-
u64 gpa = BASE_DATA_GPA + i * per_cpu_size;
405
+
gpa_t gpa = BASE_DATA_GPA + i * per_cpu_size;
406
406
407
407
vcpu_args_set(vcpus[i], 1, gpa);
408
408
+1
-1
tools/testing/selftests/kvm/x86/smaller_maxphyaddr_emulation_test.c
+1
-1
tools/testing/selftests/kvm/x86/smaller_maxphyaddr_emulation_test.c
+4
-4
tools/testing/selftests/kvm/x86/svm_nested_vmcb12_gpa.c
+4
-4
tools/testing/selftests/kvm/x86/svm_nested_vmcb12_gpa.c
···
28
28
vmcall();
29
29
}
30
30
31
-
static void l1_vmrun(struct svm_test_data *svm, u64 gpa)
31
+
static void l1_vmrun(struct svm_test_data *svm, gpa_t gpa)
32
32
{
33
33
generic_svm_setup(svm, l2_code, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
34
34
35
35
asm volatile ("vmrun %[gpa]" : : [gpa] "a" (gpa) : "memory");
36
36
}
37
37
38
-
static void l1_vmload(struct svm_test_data *svm, u64 gpa)
38
+
static void l1_vmload(struct svm_test_data *svm, gpa_t gpa)
39
39
{
40
40
generic_svm_setup(svm, l2_code, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
41
41
42
42
asm volatile ("vmload %[gpa]" : : [gpa] "a" (gpa) : "memory");
43
43
}
44
44
45
-
static void l1_vmsave(struct svm_test_data *svm, u64 gpa)
45
+
static void l1_vmsave(struct svm_test_data *svm, gpa_t gpa)
46
46
{
47
47
generic_svm_setup(svm, l2_code, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
48
48
49
49
asm volatile ("vmsave %[gpa]" : : [gpa] "a" (gpa) : "memory");
50
50
}
51
51
52
-
static void l1_vmexit(struct svm_test_data *svm, u64 gpa)
52
+
static void l1_vmexit(struct svm_test_data *svm, gpa_t gpa)
53
53
{
54
54
generic_svm_setup(svm, l2_code, &l2_guest_stack[L2_GUEST_STACK_SIZE]);
55
55