xref: /openbmc/qemu/accel/hvf/hvf-accel-ops.c (revision 5f87dddb)
1 /*
2  * Copyright 2008 IBM Corporation
3  *           2008 Red Hat, Inc.
4  * Copyright 2011 Intel Corporation
5  * Copyright 2016 Veertu, Inc.
6  * Copyright 2017 The Android Open Source Project
7  *
8  * QEMU Hypervisor.framework support
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of version 2 of the GNU General Public
12  * License as published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
21  *
22  * This file contain code under public domain from the hvdos project:
23  * https://github.com/mist64/hvdos
24  *
25  * Parts Copyright (c) 2011 NetApp, Inc.
26  * All rights reserved.
27  *
28  * Redistribution and use in source and binary forms, with or without
29  * modification, are permitted provided that the following conditions
30  * are met:
31  * 1. Redistributions of source code must retain the above copyright
32  *    notice, this list of conditions and the following disclaimer.
33  * 2. Redistributions in binary form must reproduce the above copyright
34  *    notice, this list of conditions and the following disclaimer in the
35  *    documentation and/or other materials provided with the distribution.
36  *
37  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
38  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
39  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
40  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
41  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
42  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
43  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
45  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
46  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47  * SUCH DAMAGE.
48  */
49 
50 #include "qemu/osdep.h"
51 #include "qemu/error-report.h"
52 #include "qemu/main-loop.h"
53 #include "exec/address-spaces.h"
54 #include "exec/exec-all.h"
55 #include "exec/gdbstub.h"
56 #include "sysemu/cpus.h"
57 #include "sysemu/hvf.h"
58 #include "sysemu/hvf_int.h"
59 #include "sysemu/runstate.h"
60 #include "qemu/guest-random.h"
61 
62 HVFState *hvf_state;
63 
64 #ifdef __aarch64__
65 #define HV_VM_DEFAULT NULL
66 #endif
67 
68 /* Memory slots */
69 
70 hvf_slot *hvf_find_overlap_slot(uint64_t start, uint64_t size)
71 {
72     hvf_slot *slot;
73     int x;
74     for (x = 0; x < hvf_state->num_slots; ++x) {
75         slot = &hvf_state->slots[x];
76         if (slot->size && start < (slot->start + slot->size) &&
77             (start + size) > slot->start) {
78             return slot;
79         }
80     }
81     return NULL;
82 }
83 
84 struct mac_slot {
85     int present;
86     uint64_t size;
87     uint64_t gpa_start;
88     uint64_t gva;
89 };
90 
91 struct mac_slot mac_slots[32];
92 
93 static int do_hvf_set_memory(hvf_slot *slot, hv_memory_flags_t flags)
94 {
95     struct mac_slot *macslot;
96     hv_return_t ret;
97 
98     macslot = &mac_slots[slot->slot_id];
99 
100     if (macslot->present) {
101         if (macslot->size != slot->size) {
102             macslot->present = 0;
103             ret = hv_vm_unmap(macslot->gpa_start, macslot->size);
104             assert_hvf_ok(ret);
105         }
106     }
107 
108     if (!slot->size) {
109         return 0;
110     }
111 
112     macslot->present = 1;
113     macslot->gpa_start = slot->start;
114     macslot->size = slot->size;
115     ret = hv_vm_map(slot->mem, slot->start, slot->size, flags);
116     assert_hvf_ok(ret);
117     return 0;
118 }
119 
120 static void hvf_set_phys_mem(MemoryRegionSection *section, bool add)
121 {
122     hvf_slot *mem;
123     MemoryRegion *area = section->mr;
124     bool writable = !area->readonly && !area->rom_device;
125     hv_memory_flags_t flags;
126     uint64_t page_size = qemu_real_host_page_size();
127 
128     if (!memory_region_is_ram(area)) {
129         if (writable) {
130             return;
131         } else if (!memory_region_is_romd(area)) {
132             /*
133              * If the memory device is not in romd_mode, then we actually want
134              * to remove the hvf memory slot so all accesses will trap.
135              */
136              add = false;
137         }
138     }
139 
140     if (!QEMU_IS_ALIGNED(int128_get64(section->size), page_size) ||
141         !QEMU_IS_ALIGNED(section->offset_within_address_space, page_size)) {
142         /* Not page aligned, so we can not map as RAM */
143         add = false;
144     }
145 
146     mem = hvf_find_overlap_slot(
147             section->offset_within_address_space,
148             int128_get64(section->size));
149 
150     if (mem && add) {
151         if (mem->size == int128_get64(section->size) &&
152             mem->start == section->offset_within_address_space &&
153             mem->mem == (memory_region_get_ram_ptr(area) +
154             section->offset_within_region)) {
155             return; /* Same region was attempted to register, go away. */
156         }
157     }
158 
159     /* Region needs to be reset. set the size to 0 and remap it. */
160     if (mem) {
161         mem->size = 0;
162         if (do_hvf_set_memory(mem, 0)) {
163             error_report("Failed to reset overlapping slot");
164             abort();
165         }
166     }
167 
168     if (!add) {
169         return;
170     }
171 
172     if (area->readonly ||
173         (!memory_region_is_ram(area) && memory_region_is_romd(area))) {
174         flags = HV_MEMORY_READ | HV_MEMORY_EXEC;
175     } else {
176         flags = HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC;
177     }
178 
179     /* Now make a new slot. */
180     int x;
181 
182     for (x = 0; x < hvf_state->num_slots; ++x) {
183         mem = &hvf_state->slots[x];
184         if (!mem->size) {
185             break;
186         }
187     }
188 
189     if (x == hvf_state->num_slots) {
190         error_report("No free slots");
191         abort();
192     }
193 
194     mem->size = int128_get64(section->size);
195     mem->mem = memory_region_get_ram_ptr(area) + section->offset_within_region;
196     mem->start = section->offset_within_address_space;
197     mem->region = area;
198 
199     if (do_hvf_set_memory(mem, flags)) {
200         error_report("Error registering new memory slot");
201         abort();
202     }
203 }
204 
205 static void do_hvf_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
206 {
207     if (!cpu->vcpu_dirty) {
208         hvf_get_registers(cpu);
209         cpu->vcpu_dirty = true;
210     }
211 }
212 
213 static void hvf_cpu_synchronize_state(CPUState *cpu)
214 {
215     if (!cpu->vcpu_dirty) {
216         run_on_cpu(cpu, do_hvf_cpu_synchronize_state, RUN_ON_CPU_NULL);
217     }
218 }
219 
220 static void do_hvf_cpu_synchronize_set_dirty(CPUState *cpu,
221                                              run_on_cpu_data arg)
222 {
223     /* QEMU state is the reference, push it to HVF now and on next entry */
224     cpu->vcpu_dirty = true;
225 }
226 
227 static void hvf_cpu_synchronize_post_reset(CPUState *cpu)
228 {
229     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
230 }
231 
232 static void hvf_cpu_synchronize_post_init(CPUState *cpu)
233 {
234     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
235 }
236 
237 static void hvf_cpu_synchronize_pre_loadvm(CPUState *cpu)
238 {
239     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
240 }
241 
242 static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on)
243 {
244     hvf_slot *slot;
245 
246     slot = hvf_find_overlap_slot(
247             section->offset_within_address_space,
248             int128_get64(section->size));
249 
250     /* protect region against writes; begin tracking it */
251     if (on) {
252         slot->flags |= HVF_SLOT_LOG;
253         hv_vm_protect((uintptr_t)slot->start, (size_t)slot->size,
254                       HV_MEMORY_READ | HV_MEMORY_EXEC);
255     /* stop tracking region*/
256     } else {
257         slot->flags &= ~HVF_SLOT_LOG;
258         hv_vm_protect((uintptr_t)slot->start, (size_t)slot->size,
259                       HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC);
260     }
261 }
262 
263 static void hvf_log_start(MemoryListener *listener,
264                           MemoryRegionSection *section, int old, int new)
265 {
266     if (old != 0) {
267         return;
268     }
269 
270     hvf_set_dirty_tracking(section, 1);
271 }
272 
273 static void hvf_log_stop(MemoryListener *listener,
274                          MemoryRegionSection *section, int old, int new)
275 {
276     if (new != 0) {
277         return;
278     }
279 
280     hvf_set_dirty_tracking(section, 0);
281 }
282 
283 static void hvf_log_sync(MemoryListener *listener,
284                          MemoryRegionSection *section)
285 {
286     /*
287      * sync of dirty pages is handled elsewhere; just make sure we keep
288      * tracking the region.
289      */
290     hvf_set_dirty_tracking(section, 1);
291 }
292 
293 static void hvf_region_add(MemoryListener *listener,
294                            MemoryRegionSection *section)
295 {
296     hvf_set_phys_mem(section, true);
297 }
298 
299 static void hvf_region_del(MemoryListener *listener,
300                            MemoryRegionSection *section)
301 {
302     hvf_set_phys_mem(section, false);
303 }
304 
305 static MemoryListener hvf_memory_listener = {
306     .name = "hvf",
307     .priority = MEMORY_LISTENER_PRIORITY_ACCEL,
308     .region_add = hvf_region_add,
309     .region_del = hvf_region_del,
310     .log_start = hvf_log_start,
311     .log_stop = hvf_log_stop,
312     .log_sync = hvf_log_sync,
313 };
314 
315 static void dummy_signal(int sig)
316 {
317 }
318 
319 bool hvf_allowed;
320 
321 static int hvf_accel_init(MachineState *ms)
322 {
323     int x;
324     hv_return_t ret;
325     HVFState *s;
326 
327     ret = hv_vm_create(HV_VM_DEFAULT);
328     assert_hvf_ok(ret);
329 
330     s = g_new0(HVFState, 1);
331 
332     s->num_slots = ARRAY_SIZE(s->slots);
333     for (x = 0; x < s->num_slots; ++x) {
334         s->slots[x].size = 0;
335         s->slots[x].slot_id = x;
336     }
337 
338     QTAILQ_INIT(&s->hvf_sw_breakpoints);
339 
340     hvf_state = s;
341     memory_listener_register(&hvf_memory_listener, &address_space_memory);
342 
343     return hvf_arch_init();
344 }
345 
346 static inline int hvf_gdbstub_sstep_flags(void)
347 {
348     return SSTEP_ENABLE | SSTEP_NOIRQ;
349 }
350 
351 static void hvf_accel_class_init(ObjectClass *oc, void *data)
352 {
353     AccelClass *ac = ACCEL_CLASS(oc);
354     ac->name = "HVF";
355     ac->init_machine = hvf_accel_init;
356     ac->allowed = &hvf_allowed;
357     ac->gdbstub_supported_sstep_flags = hvf_gdbstub_sstep_flags;
358 }
359 
360 static const TypeInfo hvf_accel_type = {
361     .name = TYPE_HVF_ACCEL,
362     .parent = TYPE_ACCEL,
363     .class_init = hvf_accel_class_init,
364 };
365 
366 static void hvf_type_init(void)
367 {
368     type_register_static(&hvf_accel_type);
369 }
370 
371 type_init(hvf_type_init);
372 
373 static void hvf_vcpu_destroy(CPUState *cpu)
374 {
375     hv_return_t ret = hv_vcpu_destroy(cpu->accel->fd);
376     assert_hvf_ok(ret);
377 
378     hvf_arch_vcpu_destroy(cpu);
379     g_free(cpu->accel);
380     cpu->accel = NULL;
381 }
382 
383 static int hvf_init_vcpu(CPUState *cpu)
384 {
385     int r;
386 
387     cpu->accel = g_new0(AccelCPUState, 1);
388 
389     /* init cpu signals */
390     struct sigaction sigact;
391 
392     memset(&sigact, 0, sizeof(sigact));
393     sigact.sa_handler = dummy_signal;
394     sigaction(SIG_IPI, &sigact, NULL);
395 
396     pthread_sigmask(SIG_BLOCK, NULL, &cpu->accel->unblock_ipi_mask);
397     sigdelset(&cpu->accel->unblock_ipi_mask, SIG_IPI);
398 
399 #ifdef __aarch64__
400     r = hv_vcpu_create(&cpu->accel->fd,
401                        (hv_vcpu_exit_t **)&cpu->accel->exit, NULL);
402 #else
403     r = hv_vcpu_create((hv_vcpuid_t *)&cpu->accel->fd, HV_VCPU_DEFAULT);
404 #endif
405     cpu->vcpu_dirty = 1;
406     assert_hvf_ok(r);
407 
408     cpu->accel->guest_debug_enabled = false;
409 
410     return hvf_arch_init_vcpu(cpu);
411 }
412 
413 /*
414  * The HVF-specific vCPU thread function. This one should only run when the host
415  * CPU supports the VMX "unrestricted guest" feature.
416  */
417 static void *hvf_cpu_thread_fn(void *arg)
418 {
419     CPUState *cpu = arg;
420 
421     int r;
422 
423     assert(hvf_enabled());
424 
425     rcu_register_thread();
426 
427     qemu_mutex_lock_iothread();
428     qemu_thread_get_self(cpu->thread);
429 
430     cpu->thread_id = qemu_get_thread_id();
431     cpu->can_do_io = 1;
432     current_cpu = cpu;
433 
434     hvf_init_vcpu(cpu);
435 
436     /* signal CPU creation */
437     cpu_thread_signal_created(cpu);
438     qemu_guest_random_seed_thread_part2(cpu->random_seed);
439 
440     do {
441         if (cpu_can_run(cpu)) {
442             r = hvf_vcpu_exec(cpu);
443             if (r == EXCP_DEBUG) {
444                 cpu_handle_guest_debug(cpu);
445             }
446         }
447         qemu_wait_io_event(cpu);
448     } while (!cpu->unplug || cpu_can_run(cpu));
449 
450     hvf_vcpu_destroy(cpu);
451     cpu_thread_signal_destroyed(cpu);
452     qemu_mutex_unlock_iothread();
453     rcu_unregister_thread();
454     return NULL;
455 }
456 
457 static void hvf_start_vcpu_thread(CPUState *cpu)
458 {
459     char thread_name[VCPU_THREAD_NAME_SIZE];
460 
461     /*
462      * HVF currently does not support TCG, and only runs in
463      * unrestricted-guest mode.
464      */
465     assert(hvf_enabled());
466 
467     cpu->thread = g_malloc0(sizeof(QemuThread));
468     cpu->halt_cond = g_malloc0(sizeof(QemuCond));
469     qemu_cond_init(cpu->halt_cond);
470 
471     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HVF",
472              cpu->cpu_index);
473     qemu_thread_create(cpu->thread, thread_name, hvf_cpu_thread_fn,
474                        cpu, QEMU_THREAD_JOINABLE);
475 }
476 
477 static int hvf_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
478 {
479     struct hvf_sw_breakpoint *bp;
480     int err;
481 
482     if (type == GDB_BREAKPOINT_SW) {
483         bp = hvf_find_sw_breakpoint(cpu, addr);
484         if (bp) {
485             bp->use_count++;
486             return 0;
487         }
488 
489         bp = g_new(struct hvf_sw_breakpoint, 1);
490         bp->pc = addr;
491         bp->use_count = 1;
492         err = hvf_arch_insert_sw_breakpoint(cpu, bp);
493         if (err) {
494             g_free(bp);
495             return err;
496         }
497 
498         QTAILQ_INSERT_HEAD(&hvf_state->hvf_sw_breakpoints, bp, entry);
499     } else {
500         err = hvf_arch_insert_hw_breakpoint(addr, len, type);
501         if (err) {
502             return err;
503         }
504     }
505 
506     CPU_FOREACH(cpu) {
507         err = hvf_update_guest_debug(cpu);
508         if (err) {
509             return err;
510         }
511     }
512     return 0;
513 }
514 
515 static int hvf_remove_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
516 {
517     struct hvf_sw_breakpoint *bp;
518     int err;
519 
520     if (type == GDB_BREAKPOINT_SW) {
521         bp = hvf_find_sw_breakpoint(cpu, addr);
522         if (!bp) {
523             return -ENOENT;
524         }
525 
526         if (bp->use_count > 1) {
527             bp->use_count--;
528             return 0;
529         }
530 
531         err = hvf_arch_remove_sw_breakpoint(cpu, bp);
532         if (err) {
533             return err;
534         }
535 
536         QTAILQ_REMOVE(&hvf_state->hvf_sw_breakpoints, bp, entry);
537         g_free(bp);
538     } else {
539         err = hvf_arch_remove_hw_breakpoint(addr, len, type);
540         if (err) {
541             return err;
542         }
543     }
544 
545     CPU_FOREACH(cpu) {
546         err = hvf_update_guest_debug(cpu);
547         if (err) {
548             return err;
549         }
550     }
551     return 0;
552 }
553 
554 static void hvf_remove_all_breakpoints(CPUState *cpu)
555 {
556     struct hvf_sw_breakpoint *bp, *next;
557     CPUState *tmpcpu;
558 
559     QTAILQ_FOREACH_SAFE(bp, &hvf_state->hvf_sw_breakpoints, entry, next) {
560         if (hvf_arch_remove_sw_breakpoint(cpu, bp) != 0) {
561             /* Try harder to find a CPU that currently sees the breakpoint. */
562             CPU_FOREACH(tmpcpu)
563             {
564                 if (hvf_arch_remove_sw_breakpoint(tmpcpu, bp) == 0) {
565                     break;
566                 }
567             }
568         }
569         QTAILQ_REMOVE(&hvf_state->hvf_sw_breakpoints, bp, entry);
570         g_free(bp);
571     }
572     hvf_arch_remove_all_hw_breakpoints();
573 
574     CPU_FOREACH(cpu) {
575         hvf_update_guest_debug(cpu);
576     }
577 }
578 
579 static void hvf_accel_ops_class_init(ObjectClass *oc, void *data)
580 {
581     AccelOpsClass *ops = ACCEL_OPS_CLASS(oc);
582 
583     ops->create_vcpu_thread = hvf_start_vcpu_thread;
584     ops->kick_vcpu_thread = hvf_kick_vcpu_thread;
585 
586     ops->synchronize_post_reset = hvf_cpu_synchronize_post_reset;
587     ops->synchronize_post_init = hvf_cpu_synchronize_post_init;
588     ops->synchronize_state = hvf_cpu_synchronize_state;
589     ops->synchronize_pre_loadvm = hvf_cpu_synchronize_pre_loadvm;
590 
591     ops->insert_breakpoint = hvf_insert_breakpoint;
592     ops->remove_breakpoint = hvf_remove_breakpoint;
593     ops->remove_all_breakpoints = hvf_remove_all_breakpoints;
594     ops->update_guest_debug = hvf_update_guest_debug;
595     ops->supports_guest_debug = hvf_arch_supports_guest_debug;
596 };
597 static const TypeInfo hvf_accel_ops_type = {
598     .name = ACCEL_OPS_NAME("hvf"),
599 
600     .parent = TYPE_ACCEL_OPS,
601     .class_init = hvf_accel_ops_class_init,
602     .abstract = true,
603 };
604 static void hvf_accel_ops_register_types(void)
605 {
606     type_register_static(&hvf_accel_ops_type);
607 }
608 type_init(hvf_accel_ops_register_types);
609