1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | #include <linux/acpi.h> |
4 | #include <linux/cpu.h> |
5 | #include <linux/kexec.h> |
6 | #include <linux/memblock.h> |
7 | #include <linux/virtio_anchor.h> |
8 | |
9 | #include <xen/features.h> |
10 | #include <xen/events.h> |
11 | #include <xen/hvm.h> |
12 | #include <xen/interface/hvm/hvm_op.h> |
13 | #include <xen/interface/memory.h> |
14 | |
15 | #include <asm/apic.h> |
16 | #include <asm/cpu.h> |
17 | #include <asm/smp.h> |
18 | #include <asm/io_apic.h> |
19 | #include <asm/reboot.h> |
20 | #include <asm/setup.h> |
21 | #include <asm/idtentry.h> |
22 | #include <asm/hypervisor.h> |
23 | #include <asm/e820/api.h> |
24 | #include <asm/early_ioremap.h> |
25 | |
26 | #include <asm/xen/cpuid.h> |
27 | #include <asm/xen/hypervisor.h> |
28 | #include <asm/xen/page.h> |
29 | |
30 | #include "xen-ops.h" |
31 | #include "mmu.h" |
32 | #include "smp.h" |
33 | |
34 | static unsigned long shared_info_pfn; |
35 | |
36 | __ro_after_init bool xen_percpu_upcall; |
37 | EXPORT_SYMBOL_GPL(xen_percpu_upcall); |
38 | |
39 | void xen_hvm_init_shared_info(void) |
40 | { |
41 | struct xen_add_to_physmap xatp; |
42 | |
43 | xatp.domid = DOMID_SELF; |
44 | xatp.idx = 0; |
45 | xatp.space = XENMAPSPACE_shared_info; |
46 | xatp.gpfn = shared_info_pfn; |
47 | if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, arg: &xatp)) |
48 | BUG(); |
49 | } |
50 | |
51 | static void __init reserve_shared_info(void) |
52 | { |
53 | u64 pa; |
54 | |
55 | /* |
56 | * Search for a free page starting at 4kB physical address. |
57 | * Low memory is preferred to avoid an EPT large page split up |
58 | * by the mapping. |
59 | * Starting below X86_RESERVE_LOW (usually 64kB) is fine as |
60 | * the BIOS used for HVM guests is well behaved and won't |
61 | * clobber memory other than the first 4kB. |
62 | */ |
63 | for (pa = PAGE_SIZE; |
64 | !e820__mapped_all(start: pa, end: pa + PAGE_SIZE, type: E820_TYPE_RAM) || |
65 | memblock_is_reserved(addr: pa); |
66 | pa += PAGE_SIZE) |
67 | ; |
68 | |
69 | shared_info_pfn = PHYS_PFN(pa); |
70 | |
71 | memblock_reserve(base: pa, PAGE_SIZE); |
72 | HYPERVISOR_shared_info = early_memremap(phys_addr: pa, PAGE_SIZE); |
73 | } |
74 | |
75 | static void __init xen_hvm_init_mem_mapping(void) |
76 | { |
77 | early_memunmap(addr: HYPERVISOR_shared_info, PAGE_SIZE); |
78 | HYPERVISOR_shared_info = __va(PFN_PHYS(shared_info_pfn)); |
79 | |
80 | /* |
81 | * The virtual address of the shared_info page has changed, so |
82 | * the vcpu_info pointer for VCPU 0 is now stale. |
83 | * |
84 | * The prepare_boot_cpu callback will re-initialize it via |
85 | * xen_vcpu_setup, but we can't rely on that to be called for |
86 | * old Xen versions (xen_have_vector_callback == 0). |
87 | * |
88 | * It is, in any case, bad to have a stale vcpu_info pointer |
89 | * so reset it now. |
90 | */ |
91 | xen_vcpu_info_reset(cpu: 0); |
92 | } |
93 | |
94 | static void __init init_hvm_pv_info(void) |
95 | { |
96 | int major, minor; |
97 | uint32_t eax, ebx, ecx, edx, base; |
98 | |
99 | base = xen_cpuid_base(); |
100 | eax = cpuid_eax(op: base + 1); |
101 | |
102 | major = eax >> 16; |
103 | minor = eax & 0xffff; |
104 | printk(KERN_INFO "Xen version %d.%d.\n" , major, minor); |
105 | |
106 | xen_domain_type = XEN_HVM_DOMAIN; |
107 | |
108 | /* PVH set up hypercall page in xen_prepare_pvh(). */ |
109 | if (xen_pvh_domain()) |
110 | pv_info.name = "Xen PVH" ; |
111 | else { |
112 | u64 pfn; |
113 | uint32_t msr; |
114 | |
115 | pv_info.name = "Xen HVM" ; |
116 | msr = cpuid_ebx(op: base + 2); |
117 | pfn = __pa(hypercall_page); |
118 | wrmsr_safe(msr, (u32)pfn, (u32)(pfn >> 32)); |
119 | } |
120 | |
121 | xen_setup_features(); |
122 | |
123 | cpuid(op: base + 4, eax: &eax, ebx: &ebx, ecx: &ecx, edx: &edx); |
124 | if (eax & XEN_HVM_CPUID_VCPU_ID_PRESENT) |
125 | this_cpu_write(xen_vcpu_id, ebx); |
126 | else |
127 | this_cpu_write(xen_vcpu_id, smp_processor_id()); |
128 | } |
129 | |
130 | DEFINE_IDTENTRY_SYSVEC(sysvec_xen_hvm_callback) |
131 | { |
132 | struct pt_regs *old_regs = set_irq_regs(regs); |
133 | |
134 | if (xen_percpu_upcall) |
135 | apic_eoi(); |
136 | |
137 | inc_irq_stat(irq_hv_callback_count); |
138 | |
139 | xen_evtchn_do_upcall(); |
140 | |
141 | set_irq_regs(old_regs); |
142 | } |
143 | |
144 | #ifdef CONFIG_KEXEC_CORE |
145 | static void xen_hvm_shutdown(void) |
146 | { |
147 | native_machine_shutdown(); |
148 | if (kexec_in_progress) |
149 | xen_reboot(SHUTDOWN_soft_reset); |
150 | } |
151 | #endif |
152 | |
153 | #ifdef CONFIG_CRASH_DUMP |
154 | static void xen_hvm_crash_shutdown(struct pt_regs *regs) |
155 | { |
156 | native_machine_crash_shutdown(regs); |
157 | xen_reboot(SHUTDOWN_soft_reset); |
158 | } |
159 | #endif |
160 | |
161 | static int xen_cpu_up_prepare_hvm(unsigned int cpu) |
162 | { |
163 | int rc = 0; |
164 | |
165 | /* |
166 | * If a CPU was offlined earlier and offlining timed out then the |
167 | * lock mechanism is still initialized. Uninit it unconditionally |
168 | * as it's safe to call even if already uninited. Interrupts and |
169 | * timer have already been handled in xen_cpu_dead_hvm(). |
170 | */ |
171 | xen_uninit_lock_cpu(cpu); |
172 | |
173 | if (cpu_acpi_id(cpu) != CPU_ACPIID_INVALID) |
174 | per_cpu(xen_vcpu_id, cpu) = cpu_acpi_id(cpu); |
175 | else |
176 | per_cpu(xen_vcpu_id, cpu) = cpu; |
177 | xen_vcpu_setup(cpu); |
178 | if (!xen_have_vector_callback) |
179 | return 0; |
180 | |
181 | if (xen_percpu_upcall) { |
182 | rc = xen_set_upcall_vector(cpu); |
183 | if (rc) { |
184 | WARN(1, "HVMOP_set_evtchn_upcall_vector" |
185 | " for CPU %d failed: %d\n" , cpu, rc); |
186 | return rc; |
187 | } |
188 | } |
189 | |
190 | if (xen_feature(XENFEAT_hvm_safe_pvclock)) |
191 | xen_setup_timer(cpu); |
192 | |
193 | rc = xen_smp_intr_init(cpu); |
194 | if (rc) { |
195 | WARN(1, "xen_smp_intr_init() for CPU %d failed: %d\n" , |
196 | cpu, rc); |
197 | } |
198 | return rc; |
199 | } |
200 | |
201 | static int xen_cpu_dead_hvm(unsigned int cpu) |
202 | { |
203 | xen_smp_intr_free(cpu); |
204 | |
205 | if (xen_have_vector_callback && xen_feature(XENFEAT_hvm_safe_pvclock)) |
206 | xen_teardown_timer(cpu); |
207 | return 0; |
208 | } |
209 | |
210 | static void __init xen_hvm_guest_init(void) |
211 | { |
212 | if (xen_pv_domain()) |
213 | return; |
214 | |
215 | if (IS_ENABLED(CONFIG_XEN_VIRTIO_FORCE_GRANT)) |
216 | virtio_set_mem_acc_cb(func: xen_virtio_restricted_mem_acc); |
217 | |
218 | init_hvm_pv_info(); |
219 | |
220 | reserve_shared_info(); |
221 | xen_hvm_init_shared_info(); |
222 | |
223 | /* |
224 | * xen_vcpu is a pointer to the vcpu_info struct in the shared_info |
225 | * page, we use it in the event channel upcall and in some pvclock |
226 | * related functions. |
227 | */ |
228 | xen_vcpu_info_reset(cpu: 0); |
229 | |
230 | xen_panic_handler_init(); |
231 | |
232 | xen_hvm_smp_init(); |
233 | WARN_ON(xen_cpuhp_setup(xen_cpu_up_prepare_hvm, xen_cpu_dead_hvm)); |
234 | xen_unplug_emulated_devices(); |
235 | x86_init.irqs.intr_init = xen_init_IRQ; |
236 | xen_hvm_init_time_ops(); |
237 | xen_hvm_init_mmu_ops(); |
238 | |
239 | #ifdef CONFIG_KEXEC_CORE |
240 | machine_ops.shutdown = xen_hvm_shutdown; |
241 | #endif |
242 | #ifdef CONFIG_CRASH_DUMP |
243 | machine_ops.crash_shutdown = xen_hvm_crash_shutdown; |
244 | #endif |
245 | } |
246 | |
247 | static __init int xen_parse_nopv(char *arg) |
248 | { |
249 | pr_notice("\"xen_nopv\" is deprecated, please use \"nopv\" instead\n" ); |
250 | |
251 | if (xen_cpuid_base()) |
252 | nopv = true; |
253 | return 0; |
254 | } |
255 | early_param("xen_nopv" , xen_parse_nopv); |
256 | |
257 | static __init int xen_parse_no_vector_callback(char *arg) |
258 | { |
259 | xen_have_vector_callback = false; |
260 | return 0; |
261 | } |
262 | early_param("xen_no_vector_callback" , xen_parse_no_vector_callback); |
263 | |
264 | static __init bool xen_x2apic_available(void) |
265 | { |
266 | return x2apic_supported(); |
267 | } |
268 | |
269 | static bool __init msi_ext_dest_id(void) |
270 | { |
271 | return cpuid_eax(op: xen_cpuid_base() + 4) & XEN_HVM_CPUID_EXT_DEST_ID; |
272 | } |
273 | |
274 | static __init void xen_hvm_guest_late_init(void) |
275 | { |
276 | #ifdef CONFIG_XEN_PVH |
277 | /* Test for PVH domain (PVH boot path taken overrides ACPI flags). */ |
278 | if (!xen_pvh && |
279 | (x86_platform.legacy.rtc || !x86_platform.legacy.no_vga)) |
280 | return; |
281 | |
282 | /* PVH detected. */ |
283 | xen_pvh = true; |
284 | |
285 | if (nopv) |
286 | panic(fmt: "\"nopv\" and \"xen_nopv\" parameters are unsupported in PVH guest." ); |
287 | |
288 | /* Make sure we don't fall back to (default) ACPI_IRQ_MODEL_PIC. */ |
289 | if (!nr_ioapics && acpi_irq_model == ACPI_IRQ_MODEL_PIC) |
290 | acpi_irq_model = ACPI_IRQ_MODEL_PLATFORM; |
291 | |
292 | machine_ops.emergency_restart = xen_emergency_restart; |
293 | pv_info.name = "Xen PVH" ; |
294 | #endif |
295 | } |
296 | |
297 | static uint32_t __init xen_platform_hvm(void) |
298 | { |
299 | uint32_t xen_domain = xen_cpuid_base(); |
300 | struct x86_hyper_init *h = &x86_hyper_xen_hvm.init; |
301 | |
302 | if (xen_pv_domain()) |
303 | return 0; |
304 | |
305 | if (xen_pvh_domain() && nopv) { |
306 | /* Guest booting via the Xen-PVH boot entry goes here */ |
307 | pr_info("\"nopv\" parameter is ignored in PVH guest\n" ); |
308 | nopv = false; |
309 | } else if (nopv && xen_domain) { |
310 | /* |
311 | * Guest booting via normal boot entry (like via grub2) goes |
312 | * here. |
313 | * |
314 | * Use interface functions for bare hardware if nopv, |
315 | * xen_hvm_guest_late_init is an exception as we need to |
316 | * detect PVH and panic there. |
317 | */ |
318 | h->init_platform = x86_init_noop; |
319 | h->x2apic_available = bool_x86_init_noop; |
320 | h->init_mem_mapping = x86_init_noop; |
321 | h->init_after_bootmem = x86_init_noop; |
322 | h->guest_late_init = xen_hvm_guest_late_init; |
323 | x86_hyper_xen_hvm.runtime.pin_vcpu = x86_op_int_noop; |
324 | } |
325 | return xen_domain; |
326 | } |
327 | |
328 | struct hypervisor_x86 x86_hyper_xen_hvm __initdata = { |
329 | .name = "Xen HVM" , |
330 | .detect = xen_platform_hvm, |
331 | .type = X86_HYPER_XEN_HVM, |
332 | .init.init_platform = xen_hvm_guest_init, |
333 | .init.x2apic_available = xen_x2apic_available, |
334 | .init.init_mem_mapping = xen_hvm_init_mem_mapping, |
335 | .init.guest_late_init = xen_hvm_guest_late_init, |
336 | .init.msi_ext_dest_id = msi_ext_dest_id, |
337 | .runtime.pin_vcpu = xen_pin_vcpu, |
338 | .ignore_nopv = true, |
339 | }; |
340 | |