accel/hvf/hvf-accel-ops.c

   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 "gdbstub/enums.h"
  56 #include "hw/boards.h"
  57 #include "sysemu/cpus.h"
  58 #include "sysemu/hvf.h"
  59 #include "sysemu/hvf_int.h"
  60 #include "sysemu/runstate.h"
  61 #include "qemu/guest-random.h"
  62
  63 HVFState *hvf_state;
  64
  65 /* Memory slots */
  66
  67 hvf_slot *hvf_find_overlap_slot(uint64_t start, uint64_t size)
  68 {
  69     hvf_slot *slot;
  70     int x;
  71     for (x = 0; x < hvf_state->num_slots; ++x) {
  72         slot = &hvf_state->slots[x];
  73         if (slot->size && start < (slot->start + slot->size) &&
  74             (start + size) > slot->start) {
  75             return slot;
  76         }
  77     }
  78     return NULL;
  79 }
  80
  81 struct mac_slot {
  82     int present;
  83     uint64_t size;
  84     uint64_t gpa_start;
  85     uint64_t gva;
  86 };
  87
  88 struct mac_slot mac_slots[32];
  89
  90 static int do_hvf_set_memory(hvf_slot *slot, hv_memory_flags_t flags)
  91 {
  92     struct mac_slot *macslot;
  93     hv_return_t ret;
  94
  95     macslot = &mac_slots[slot->slot_id];
  96
  97     if (macslot->present) {
  98         if (macslot->size != slot->size) {
  99             macslot->present = 0;
 100             ret = hv_vm_unmap(macslot->gpa_start, macslot->size);
 101             assert_hvf_ok(ret);
 102         }
 103     }
 104
 105     if (!slot->size) {
 106         return 0;
 107     }
 108
 109     macslot->present = 1;
 110     macslot->gpa_start = slot->start;
 111     macslot->size = slot->size;
 112     ret = hv_vm_map(slot->mem, slot->start, slot->size, flags);
 113     assert_hvf_ok(ret);
 114     return 0;
 115 }
 116
 117 static void hvf_set_phys_mem(MemoryRegionSection *section, bool add)
 118 {
 119     hvf_slot *mem;
 120     MemoryRegion *area = section->mr;
 121     bool writable = !area->readonly && !area->rom_device;
 122     hv_memory_flags_t flags;
 123     uint64_t page_size = qemu_real_host_page_size();
 124
 125     if (!memory_region_is_ram(area)) {
 126         if (writable) {
 127             return;
 128         } else if (!memory_region_is_romd(area)) {
 129             /*
 130              * If the memory device is not in romd_mode, then we actually want
 131              * to remove the hvf memory slot so all accesses will trap.
 132              */
 133              add = false;
 134         }
 135     }
 136
 137     if (!QEMU_IS_ALIGNED(int128_get64(section->size), page_size) ||
 138         !QEMU_IS_ALIGNED(section->offset_within_address_space, page_size)) {
 139         /* Not page aligned, so we can not map as RAM */
 140         add = false;
 141     }
 142
 143     mem = hvf_find_overlap_slot(
 144             section->offset_within_address_space,
 145             int128_get64(section->size));
 146
 147     if (mem && add) {
 148         if (mem->size == int128_get64(section->size) &&
 149             mem->start == section->offset_within_address_space &&
 150             mem->mem == (memory_region_get_ram_ptr(area) +
 151             section->offset_within_region)) {
 152             return; /* Same region was attempted to register, go away. */
 153         }
 154     }
 155
 156     /* Region needs to be reset. set the size to 0 and remap it. */
 157     if (mem) {
 158         mem->size = 0;
 159         if (do_hvf_set_memory(mem, 0)) {
 160             error_report("Failed to reset overlapping slot");
 161             abort();
 162         }
 163     }
 164
 165     if (!add) {
 166         return;
 167     }
 168
 169     if (area->readonly ||
 170         (!memory_region_is_ram(area) && memory_region_is_romd(area))) {
 171         flags = HV_MEMORY_READ | HV_MEMORY_EXEC;
 172     } else {
 173         flags = HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC;
 174     }
 175
 176     /* Now make a new slot. */
 177     int x;
 178
 179     for (x = 0; x < hvf_state->num_slots; ++x) {
 180         mem = &hvf_state->slots[x];
 181         if (!mem->size) {
 182             break;
 183         }
 184     }
 185
 186     if (x == hvf_state->num_slots) {
 187         error_report("No free slots");
 188         abort();
 189     }
 190
 191     mem->size = int128_get64(section->size);
 192     mem->mem = memory_region_get_ram_ptr(area) + section->offset_within_region;
 193     mem->start = section->offset_within_address_space;
 194     mem->region = area;
 195
 196     if (do_hvf_set_memory(mem, flags)) {
 197         error_report("Error registering new memory slot");
 198         abort();
 199     }
 200 }
 201
 202 static void do_hvf_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
 203 {
 204     if (!cpu->accel->dirty) {
 205         hvf_get_registers(cpu);
 206         cpu->accel->dirty = true;
 207     }
 208 }
 209
 210 static void hvf_cpu_synchronize_state(CPUState *cpu)
 211 {
 212     if (!cpu->accel->dirty) {
 213         run_on_cpu(cpu, do_hvf_cpu_synchronize_state, RUN_ON_CPU_NULL);
 214     }
 215 }
 216
 217 static void do_hvf_cpu_synchronize_set_dirty(CPUState *cpu,
 218                                              run_on_cpu_data arg)
 219 {
 220     /* QEMU state is the reference, push it to HVF now and on next entry */
 221     cpu->accel->dirty = true;
 222 }
 223
 224 static void hvf_cpu_synchronize_post_reset(CPUState *cpu)
 225 {
 226     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
 227 }
 228
 229 static void hvf_cpu_synchronize_post_init(CPUState *cpu)
 230 {
 231     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
 232 }
 233
 234 static void hvf_cpu_synchronize_pre_loadvm(CPUState *cpu)
 235 {
 236     run_on_cpu(cpu, do_hvf_cpu_synchronize_set_dirty, RUN_ON_CPU_NULL);
 237 }
 238
 239 static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on)
 240 {
 241     hvf_slot *slot;
 242
 243     slot = hvf_find_overlap_slot(
 244             section->offset_within_address_space,
 245             int128_get64(section->size));
 246
 247     /* protect region against writes; begin tracking it */
 248     if (on) {
 249         slot->flags |= HVF_SLOT_LOG;
 250         hv_vm_protect((uintptr_t)slot->start, (size_t)slot->size,
 251                       HV_MEMORY_READ | HV_MEMORY_EXEC);
 252     /* stop tracking region*/
 253     } else {
 254         slot->flags &= ~HVF_SLOT_LOG;
 255         hv_vm_protect((uintptr_t)slot->start, (size_t)slot->size,
 256                       HV_MEMORY_READ | HV_MEMORY_WRITE | HV_MEMORY_EXEC);
 257     }
 258 }
 259
 260 static void hvf_log_start(MemoryListener *listener,
 261                           MemoryRegionSection *section, int old, int new)
 262 {
 263     if (old != 0) {
 264         return;
 265     }
 266
 267     hvf_set_dirty_tracking(section, 1);
 268 }
 269
 270 static void hvf_log_stop(MemoryListener *listener,
 271                          MemoryRegionSection *section, int old, int new)
 272 {
 273     if (new != 0) {
 274         return;
 275     }
 276
 277     hvf_set_dirty_tracking(section, 0);
 278 }
 279
 280 static void hvf_log_sync(MemoryListener *listener,
 281                          MemoryRegionSection *section)
 282 {
 283     /*
 284      * sync of dirty pages is handled elsewhere; just make sure we keep
 285      * tracking the region.
 286      */
 287     hvf_set_dirty_tracking(section, 1);
 288 }
 289
 290 static void hvf_region_add(MemoryListener *listener,
 291                            MemoryRegionSection *section)
 292 {
 293     hvf_set_phys_mem(section, true);
 294 }
 295
 296 static void hvf_region_del(MemoryListener *listener,
 297                            MemoryRegionSection *section)
 298 {
 299     hvf_set_phys_mem(section, false);
 300 }
 301
 302 static MemoryListener hvf_memory_listener = {
 303     .name = "hvf",
 304     .priority = MEMORY_LISTENER_PRIORITY_ACCEL,
 305     .region_add = hvf_region_add,
 306     .region_del = hvf_region_del,
 307     .log_start = hvf_log_start,
 308     .log_stop = hvf_log_stop,
 309     .log_sync = hvf_log_sync,
 310 };
 311
 312 static void dummy_signal(int sig)
 313 {
 314 }
 315
 316 bool hvf_allowed;
 317
 318 static int hvf_accel_init(MachineState *ms)
 319 {
 320     int x;
 321     hv_return_t ret;
 322     HVFState *s;
 323     int pa_range = 36;
 324     MachineClass *mc = MACHINE_GET_CLASS(ms);
 325
 326     if (mc->hvf_get_physical_address_range) {
 327         pa_range = mc->hvf_get_physical_address_range(ms);
 328         if (pa_range < 0) {
 329             return -EINVAL;
 330         }
 331     }
 332
 333     ret = hvf_arch_vm_create(ms, (uint32_t)pa_range);
 334     assert_hvf_ok(ret);
 335
 336     s = g_new0(HVFState, 1);
 337
 338     s->num_slots = ARRAY_SIZE(s->slots);
 339     for (x = 0; x < s->num_slots; ++x) {
 340         s->slots[x].size = 0;
 341         s->slots[x].slot_id = x;
 342     }
 343
 344     QTAILQ_INIT(&s->hvf_sw_breakpoints);
 345
 346     hvf_state = s;
 347     memory_listener_register(&hvf_memory_listener, &address_space_memory);
 348
 349     return hvf_arch_init();
 350 }
 351
 352 static inline int hvf_gdbstub_sstep_flags(void)
 353 {
 354     return SSTEP_ENABLE | SSTEP_NOIRQ;
 355 }
 356
 357 static void hvf_accel_class_init(ObjectClass *oc, void *data)
 358 {
 359     AccelClass *ac = ACCEL_CLASS(oc);
 360     ac->name = "HVF";
 361     ac->init_machine = hvf_accel_init;
 362     ac->allowed = &hvf_allowed;
 363     ac->gdbstub_supported_sstep_flags = hvf_gdbstub_sstep_flags;
 364 }
 365
 366 static const TypeInfo hvf_accel_type = {
 367     .name = TYPE_HVF_ACCEL,
 368     .parent = TYPE_ACCEL,
 369     .class_init = hvf_accel_class_init,
 370 };
 371
 372 static void hvf_type_init(void)
 373 {
 374     type_register_static(&hvf_accel_type);
 375 }
 376
 377 type_init(hvf_type_init);
 378
 379 static void hvf_vcpu_destroy(CPUState *cpu)
 380 {
 381     hv_return_t ret = hv_vcpu_destroy(cpu->accel->fd);
 382     assert_hvf_ok(ret);
 383
 384     hvf_arch_vcpu_destroy(cpu);
 385     g_free(cpu->accel);
 386     cpu->accel = NULL;
 387 }
 388
 389 static int hvf_init_vcpu(CPUState *cpu)
 390 {
 391     int r;
 392
 393     cpu->accel = g_new0(AccelCPUState, 1);
 394
 395     /* init cpu signals */
 396     struct sigaction sigact;
 397
 398     memset(&sigact, 0, sizeof(sigact));
 399     sigact.sa_handler = dummy_signal;
 400     sigaction(SIG_IPI, &sigact, NULL);
 401
 402     pthread_sigmask(SIG_BLOCK, NULL, &cpu->accel->unblock_ipi_mask);
 403     sigdelset(&cpu->accel->unblock_ipi_mask, SIG_IPI);
 404
 405 #ifdef __aarch64__
 406     r = hv_vcpu_create(&cpu->accel->fd,
 407                        (hv_vcpu_exit_t **)&cpu->accel->exit, NULL);
 408 #else
 409     r = hv_vcpu_create(&cpu->accel->fd, HV_VCPU_DEFAULT);
 410 #endif
 411     cpu->accel->dirty = true;
 412     assert_hvf_ok(r);
 413
 414     cpu->accel->guest_debug_enabled = false;
 415
 416     return hvf_arch_init_vcpu(cpu);
 417 }
 418
 419 /*
 420  * The HVF-specific vCPU thread function. This one should only run when the host
 421  * CPU supports the VMX "unrestricted guest" feature.
 422  */
 423 static void *hvf_cpu_thread_fn(void *arg)
 424 {
 425     CPUState *cpu = arg;
 426
 427     int r;
 428
 429     assert(hvf_enabled());
 430
 431     rcu_register_thread();
 432
 433     bql_lock();
 434     qemu_thread_get_self(cpu->thread);
 435
 436     cpu->thread_id = qemu_get_thread_id();
 437     current_cpu = cpu;
 438
 439     hvf_init_vcpu(cpu);
 440
 441     /* signal CPU creation */
 442     cpu_thread_signal_created(cpu);
 443     qemu_guest_random_seed_thread_part2(cpu->random_seed);
 444
 445     do {
 446         if (cpu_can_run(cpu)) {
 447             r = hvf_vcpu_exec(cpu);
 448             if (r == EXCP_DEBUG) {
 449                 cpu_handle_guest_debug(cpu);
 450             }
 451         }
 452         qemu_wait_io_event(cpu);
 453     } while (!cpu->unplug || cpu_can_run(cpu));
 454
 455     hvf_vcpu_destroy(cpu);
 456     cpu_thread_signal_destroyed(cpu);
 457     bql_unlock();
 458     rcu_unregister_thread();
 459     return NULL;
 460 }
 461
 462 static void hvf_start_vcpu_thread(CPUState *cpu)
 463 {
 464     char thread_name[VCPU_THREAD_NAME_SIZE];
 465
 466     /*
 467      * HVF currently does not support TCG, and only runs in
 468      * unrestricted-guest mode.
 469      */
 470     assert(hvf_enabled());
 471
 472     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/HVF",
 473              cpu->cpu_index);
 474     qemu_thread_create(cpu->thread, thread_name, hvf_cpu_thread_fn,
 475                        cpu, QEMU_THREAD_JOINABLE);
 476 }
 477
 478 static int hvf_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
 479 {
 480     struct hvf_sw_breakpoint *bp;
 481     int err;
 482
 483     if (type == GDB_BREAKPOINT_SW) {
 484         bp = hvf_find_sw_breakpoint(cpu, addr);
 485         if (bp) {
 486             bp->use_count++;
 487             return 0;
 488         }
 489
 490         bp = g_new(struct hvf_sw_breakpoint, 1);
 491         bp->pc = addr;
 492         bp->use_count = 1;
 493         err = hvf_arch_insert_sw_breakpoint(cpu, bp);
 494         if (err) {
 495             g_free(bp);
 496             return err;
 497         }
 498
 499         QTAILQ_INSERT_HEAD(&hvf_state->hvf_sw_breakpoints, bp, entry);
 500     } else {
 501         err = hvf_arch_insert_hw_breakpoint(addr, len, type);
 502         if (err) {
 503             return err;
 504         }
 505     }
 506
 507     CPU_FOREACH(cpu) {
 508         err = hvf_update_guest_debug(cpu);
 509         if (err) {
 510             return err;
 511         }
 512     }
 513     return 0;
 514 }
 515
 516 static int hvf_remove_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
 517 {
 518     struct hvf_sw_breakpoint *bp;
 519     int err;
 520
 521     if (type == GDB_BREAKPOINT_SW) {
 522         bp = hvf_find_sw_breakpoint(cpu, addr);
 523         if (!bp) {
 524             return -ENOENT;
 525         }
 526
 527         if (bp->use_count > 1) {
 528             bp->use_count--;
 529             return 0;
 530         }
 531
 532         err = hvf_arch_remove_sw_breakpoint(cpu, bp);
 533         if (err) {
 534             return err;
 535         }
 536
 537         QTAILQ_REMOVE(&hvf_state->hvf_sw_breakpoints, bp, entry);
 538         g_free(bp);
 539     } else {
 540         err = hvf_arch_remove_hw_breakpoint(addr, len, type);
 541         if (err) {
 542             return err;
 543         }
 544     }
 545
 546     CPU_FOREACH(cpu) {
 547         err = hvf_update_guest_debug(cpu);
 548         if (err) {
 549             return err;
 550         }
 551     }
 552     return 0;
 553 }
 554
 555 static void hvf_remove_all_breakpoints(CPUState *cpu)
 556 {
 557     struct hvf_sw_breakpoint *bp, *next;
 558     CPUState *tmpcpu;
 559
 560     QTAILQ_FOREACH_SAFE(bp, &hvf_state->hvf_sw_breakpoints, entry, next) {
 561         if (hvf_arch_remove_sw_breakpoint(cpu, bp) != 0) {
 562             /* Try harder to find a CPU that currently sees the breakpoint. */
 563             CPU_FOREACH(tmpcpu)
 564             {
 565                 if (hvf_arch_remove_sw_breakpoint(tmpcpu, bp) == 0) {
 566                     break;
 567                 }
 568             }
 569         }
 570         QTAILQ_REMOVE(&hvf_state->hvf_sw_breakpoints, bp, entry);
 571         g_free(bp);
 572     }
 573     hvf_arch_remove_all_hw_breakpoints();
 574
 575     CPU_FOREACH(cpu) {
 576         hvf_update_guest_debug(cpu);
 577     }
 578 }
 579
 580 static void hvf_accel_ops_class_init(ObjectClass *oc, void *data)
 581 {
 582     AccelOpsClass *ops = ACCEL_OPS_CLASS(oc);
 583
 584     ops->create_vcpu_thread = hvf_start_vcpu_thread;
 585     ops->kick_vcpu_thread = hvf_kick_vcpu_thread;
 586
 587     ops->synchronize_post_reset = hvf_cpu_synchronize_post_reset;
 588     ops->synchronize_post_init = hvf_cpu_synchronize_post_init;
 589     ops->synchronize_state = hvf_cpu_synchronize_state;
 590     ops->synchronize_pre_loadvm = hvf_cpu_synchronize_pre_loadvm;
 591
 592     ops->insert_breakpoint = hvf_insert_breakpoint;
 593     ops->remove_breakpoint = hvf_remove_breakpoint;
 594     ops->remove_all_breakpoints = hvf_remove_all_breakpoints;
 595     ops->update_guest_debug = hvf_update_guest_debug;
 596     ops->supports_guest_debug = hvf_arch_supports_guest_debug;
 597 };
 598 static const TypeInfo hvf_accel_ops_type = {
 599     .name = ACCEL_OPS_NAME("hvf"),
 600
 601     .parent = TYPE_ACCEL_OPS,
 602     .class_init = hvf_accel_ops_class_init,
 603     .abstract = true,
 604 };
 605 static void hvf_accel_ops_register_types(void)
 606 {
 607     type_register_static(&hvf_accel_ops_type);
 608 }
 609 type_init(hvf_accel_ops_register_types);