softmmu/cpu-timers.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qemu-common.h"
  27 #include "qemu/cutils.h"
  28 #include "migration/vmstate.h"
  29 #include "qapi/error.h"
  30 #include "qemu/error-report.h"
  31 #include "exec/exec-all.h"
  32 #include "sysemu/cpus.h"
  33 #include "qemu/main-loop.h"
  34 #include "qemu/option.h"
  35 #include "qemu/seqlock.h"
  36 #include "sysemu/replay.h"
  37 #include "sysemu/runstate.h"
  38 #include "hw/core/cpu.h"
  39 #include "sysemu/cpu-timers.h"
  40 #include "sysemu/cpu-throttle.h"
  41 #include "timers-state.h"
  42
  43 /* clock and ticks */
  44
  45 static int64_t cpu_get_ticks_locked(void)
  46 {
  47     int64_t ticks = timers_state.cpu_ticks_offset;
  48     if (timers_state.cpu_ticks_enabled) {
  49         ticks += cpu_get_host_ticks();
  50     }
  51
  52     if (timers_state.cpu_ticks_prev > ticks) {
  53         /* Non increasing ticks may happen if the host uses software suspend. */
  54         timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
  55         ticks = timers_state.cpu_ticks_prev;
  56     }
  57
  58     timers_state.cpu_ticks_prev = ticks;
  59     return ticks;
  60 }
  61
  62 /*
  63  * return the time elapsed in VM between vm_start and vm_stop.
  64  * cpu_get_ticks() uses units of the host CPU cycle counter.
  65  */
  66 int64_t cpu_get_ticks(void)
  67 {
  68     int64_t ticks;
  69
  70     qemu_spin_lock(&timers_state.vm_clock_lock);
  71     ticks = cpu_get_ticks_locked();
  72     qemu_spin_unlock(&timers_state.vm_clock_lock);
  73     return ticks;
  74 }
  75
  76 int64_t cpu_get_clock_locked(void)
  77 {
  78     int64_t time;
  79
  80     time = timers_state.cpu_clock_offset;
  81     if (timers_state.cpu_ticks_enabled) {
  82         time += get_clock();
  83     }
  84
  85     return time;
  86 }
  87
  88 /*
  89  * Return the monotonic time elapsed in VM, i.e.,
  90  * the time between vm_start and vm_stop
  91  */
  92 int64_t cpu_get_clock(void)
  93 {
  94     int64_t ti;
  95     unsigned start;
  96
  97     do {
  98         start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
  99         ti = cpu_get_clock_locked();
 100     } while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
 101
 102     return ti;
 103 }
 104
 105 /*
 106  * enable cpu_get_ticks()
 107  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
 108  */
 109 void cpu_enable_ticks(void)
 110 {
 111     seqlock_write_lock(&timers_state.vm_clock_seqlock,
 112                        &timers_state.vm_clock_lock);
 113     if (!timers_state.cpu_ticks_enabled) {
 114         timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
 115         timers_state.cpu_clock_offset -= get_clock();
 116         timers_state.cpu_ticks_enabled = 1;
 117     }
 118     seqlock_write_unlock(&timers_state.vm_clock_seqlock,
 119                        &timers_state.vm_clock_lock);
 120 }
 121
 122 /*
 123  * disable cpu_get_ticks() : the clock is stopped. You must not call
 124  * cpu_get_ticks() after that.
 125  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
 126  */
 127 void cpu_disable_ticks(void)
 128 {
 129     seqlock_write_lock(&timers_state.vm_clock_seqlock,
 130                        &timers_state.vm_clock_lock);
 131     if (timers_state.cpu_ticks_enabled) {
 132         timers_state.cpu_ticks_offset += cpu_get_host_ticks();
 133         timers_state.cpu_clock_offset = cpu_get_clock_locked();
 134         timers_state.cpu_ticks_enabled = 0;
 135     }
 136     seqlock_write_unlock(&timers_state.vm_clock_seqlock,
 137                          &timers_state.vm_clock_lock);
 138 }
 139
 140 static bool icount_state_needed(void *opaque)
 141 {
 142     return icount_enabled();
 143 }
 144
 145 static bool warp_timer_state_needed(void *opaque)
 146 {
 147     TimersState *s = opaque;
 148     return s->icount_warp_timer != NULL;
 149 }
 150
 151 static bool adjust_timers_state_needed(void *opaque)
 152 {
 153     TimersState *s = opaque;
 154     return s->icount_rt_timer != NULL;
 155 }
 156
 157 static bool icount_shift_state_needed(void *opaque)
 158 {
 159     return icount_enabled() == 2;
 160 }
 161
 162 /*
 163  * Subsection for warp timer migration is optional, because may not be created
 164  */
 165 static const VMStateDescription icount_vmstate_warp_timer = {
 166     .name = "timer/icount/warp_timer",
 167     .version_id = 1,
 168     .minimum_version_id = 1,
 169     .needed = warp_timer_state_needed,
 170     .fields = (VMStateField[]) {
 171         VMSTATE_INT64(vm_clock_warp_start, TimersState),
 172         VMSTATE_TIMER_PTR(icount_warp_timer, TimersState),
 173         VMSTATE_END_OF_LIST()
 174     }
 175 };
 176
 177 static const VMStateDescription icount_vmstate_adjust_timers = {
 178     .name = "timer/icount/timers",
 179     .version_id = 1,
 180     .minimum_version_id = 1,
 181     .needed = adjust_timers_state_needed,
 182     .fields = (VMStateField[]) {
 183         VMSTATE_TIMER_PTR(icount_rt_timer, TimersState),
 184         VMSTATE_TIMER_PTR(icount_vm_timer, TimersState),
 185         VMSTATE_END_OF_LIST()
 186     }
 187 };
 188
 189 static const VMStateDescription icount_vmstate_shift = {
 190     .name = "timer/icount/shift",
 191     .version_id = 2,
 192     .minimum_version_id = 2,
 193     .needed = icount_shift_state_needed,
 194     .fields = (VMStateField[]) {
 195         VMSTATE_INT16(icount_time_shift, TimersState),
 196         VMSTATE_INT64(last_delta, TimersState),
 197         VMSTATE_END_OF_LIST()
 198     }
 199 };
 200
 201 /*
 202  * This is a subsection for icount migration.
 203  */
 204 static const VMStateDescription icount_vmstate_timers = {
 205     .name = "timer/icount",
 206     .version_id = 1,
 207     .minimum_version_id = 1,
 208     .needed = icount_state_needed,
 209     .fields = (VMStateField[]) {
 210         VMSTATE_INT64(qemu_icount_bias, TimersState),
 211         VMSTATE_INT64(qemu_icount, TimersState),
 212         VMSTATE_END_OF_LIST()
 213     },
 214     .subsections = (const VMStateDescription * []) {
 215         &icount_vmstate_warp_timer,
 216         &icount_vmstate_adjust_timers,
 217         &icount_vmstate_shift,
 218         NULL
 219     }
 220 };
 221
 222 static const VMStateDescription vmstate_timers = {
 223     .name = "timer",
 224     .version_id = 2,
 225     .minimum_version_id = 1,
 226     .fields = (VMStateField[]) {
 227         VMSTATE_INT64(cpu_ticks_offset, TimersState),
 228         VMSTATE_UNUSED(8),
 229         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
 230         VMSTATE_END_OF_LIST()
 231     },
 232     .subsections = (const VMStateDescription * []) {
 233         &icount_vmstate_timers,
 234         NULL
 235     }
 236 };
 237
 238 static void do_nothing(CPUState *cpu, run_on_cpu_data unused)
 239 {
 240 }
 241
 242 void qemu_timer_notify_cb(void *opaque, QEMUClockType type)
 243 {
 244     if (!icount_enabled() || type != QEMU_CLOCK_VIRTUAL) {
 245         qemu_notify_event();
 246         return;
 247     }
 248
 249     if (qemu_in_vcpu_thread()) {
 250         /*
 251          * A CPU is currently running; kick it back out to the
 252          * tcg_cpu_exec() loop so it will recalculate its
 253          * icount deadline immediately.
 254          */
 255         qemu_cpu_kick(current_cpu);
 256     } else if (first_cpu) {
 257         /*
 258          * qemu_cpu_kick is not enough to kick a halted CPU out of
 259          * qemu_tcg_wait_io_event.  async_run_on_cpu, instead,
 260          * causes cpu_thread_is_idle to return false.  This way,
 261          * handle_icount_deadline can run.
 262          * If we have no CPUs at all for some reason, we don't
 263          * need to do anything.
 264          */
 265         async_run_on_cpu(first_cpu, do_nothing, RUN_ON_CPU_NULL);
 266     }
 267 }
 268
 269 TimersState timers_state;
 270
 271 /* initialize timers state and the cpu throttle for convenience */
 272 void cpu_timers_init(void)
 273 {
 274     seqlock_init(&timers_state.vm_clock_seqlock);
 275     qemu_spin_init(&timers_state.vm_clock_lock);
 276     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
 277
 278     cpu_throttle_init();
 279 }