1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
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
|
#include "kvm/kvm.h"
#include <asm/image.h>
#include <linux/byteorder.h>
#include <linux/cpumask.h>
#include <kvm/util.h>
int vcpu_affinity_parser(const struct option *opt, const char *arg, int unset)
{
struct kvm *kvm = opt->ptr;
const char *cpulist = arg;
cpumask_t *cpumask;
int cpu, ret;
kvm->cfg.arch.vcpu_affinity = cpulist;
cpumask = calloc(1, cpumask_size());
if (!cpumask)
die_perror("calloc");
ret = cpulist_parse(cpulist, cpumask);
if (ret) {
free(cpumask);
return ret;
}
kvm->arch.vcpu_affinity_cpuset = CPU_ALLOC(NR_CPUS);
if (!kvm->arch.vcpu_affinity_cpuset)
die_perror("CPU_ALLOC");
CPU_ZERO_S(CPU_ALLOC_SIZE(NR_CPUS), kvm->arch.vcpu_affinity_cpuset);
for_each_cpu(cpu, cpumask)
CPU_SET(cpu, kvm->arch.vcpu_affinity_cpuset);
return 0;
}
/*
* Return the TEXT_OFFSET value that the guest kernel expects. Note
* that pre-3.17 kernels expose this value using the native endianness
* instead of Little-Endian. BE kernels of this vintage may fail to
* boot. See Documentation/arm64/booting.rst in your local kernel tree.
*/
unsigned long long kvm__arch_get_kern_offset(struct kvm *kvm, int fd)
{
struct arm64_image_header header;
off_t cur_offset;
ssize_t size;
const char *debug_str;
/* the 32bit kernel offset is a well known value */
if (kvm->cfg.arch.aarch32_guest)
return 0x8000;
cur_offset = lseek(fd, 0, SEEK_CUR);
if (cur_offset == (off_t)-1 ||
lseek(fd, 0, SEEK_SET) == (off_t)-1) {
debug_str = "Failed to seek in kernel image file";
goto default_offset;
}
size = xread(fd, &header, sizeof(header));
if (size < 0 || (size_t)size < sizeof(header))
die("Failed to read kernel image header");
lseek(fd, cur_offset, SEEK_SET);
if (memcmp(&header.magic, ARM64_IMAGE_MAGIC, sizeof(header.magic))) {
debug_str = "Kernel image magic not matching";
goto default_offset;
}
if (le64_to_cpu(header.image_size))
return le64_to_cpu(header.text_offset);
debug_str = "Image size is 0";
default_offset:
pr_debug("%s, assuming TEXT_OFFSET to be 0x80000", debug_str);
return 0x80000;
}
int kvm__arch_get_ipa_limit(struct kvm *kvm)
{
int ret;
ret = ioctl(kvm->sys_fd, KVM_CHECK_EXTENSION, KVM_CAP_ARM_VM_IPA_SIZE);
if (ret <= 0)
ret = 0;
return ret;
}
int kvm__get_vm_type(struct kvm *kvm)
{
unsigned int ipa_bits, max_ipa_bits;
unsigned long max_ipa;
/* If we're running on an old kernel, use 0 as the VM type */
max_ipa_bits = kvm__arch_get_ipa_limit(kvm);
if (!max_ipa_bits)
return 0;
/* Otherwise, compute the minimal required IPA size */
max_ipa = ARM_MEMORY_AREA + kvm->cfg.ram_size - 1;
ipa_bits = max(32, fls_long(max_ipa));
pr_debug("max_ipa %lx ipa_bits %d max_ipa_bits %d",
max_ipa, ipa_bits, max_ipa_bits);
if (ipa_bits > max_ipa_bits)
die("Memory too large for this system (needs %d bits, %d available)", ipa_bits, max_ipa_bits);
return KVM_VM_TYPE_ARM_IPA_SIZE(ipa_bits);
}
void kvm__arch_enable_mte(struct kvm *kvm)
{
struct kvm_enable_cap cap = {
.cap = KVM_CAP_ARM_MTE,
};
if (kvm->cfg.arch.aarch32_guest) {
pr_debug("MTE is incompatible with AArch32");
return;
}
if (kvm->cfg.arch.mte_disabled) {
pr_debug("MTE disabled by user");
return;
}
if (!kvm__supports_extension(kvm, KVM_CAP_ARM_MTE)) {
pr_debug("MTE capability not available");
return;
}
if (ioctl(kvm->vm_fd, KVM_ENABLE_CAP, &cap))
die_perror("KVM_ENABLE_CAP(KVM_CAP_ARM_MTE)");
pr_debug("MTE capability enabled");
}
|
