From: Patrick Bridges Date: Thu, 9 Jun 2011 16:50:28 +0000 (-0600) Subject: Cleanup of time handling code X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=commitdiff_plain;h=3676fa947d261206ceff968e4f6b5956900ed277;p=palacios.releases.git Cleanup of time handling code --- diff --git a/palacios/src/devices/8254.c b/palacios/src/devices/8254.c index fcde0a1..9a9ee99 100644 --- a/palacios/src/devices/8254.c +++ b/palacios/src/devices/8254.c @@ -608,11 +608,6 @@ static int pit_write_command(struct guest_info * core, ushort_t port, void * src return -1; } - if (cmd->op_mode == 0) { - V3_Print("SETTING PIT MODE TO 0!!!!!\n"); - v3_print_guest_state(core); - } - switch (cmd->channel) { case 0: if (handle_channel_cmd(&(state->ch_0), *cmd) == -1) { diff --git a/palacios/src/palacios/svm.c b/palacios/src/palacios/svm.c index 4b5b0a9..52d3201 100644 --- a/palacios/src/palacios/svm.c +++ b/palacios/src/palacios/svm.c @@ -462,7 +462,9 @@ int v3_svm_enter(struct guest_info * info) { // disable global interrupts for vm state transition v3_clgi(); - // Update timer devices prior to entering VM. + // Update timer devices right before entering the VM. Doing it + // here makes sure the guest sees any timers that fired while + // it was in the VMM v3_update_timers(info); // Synchronize the guest state to the VMCB diff --git a/palacios/src/palacios/vmm_halt.c b/palacios/src/palacios/vmm_halt.c index fc6d3d5..dcc6dbc 100644 --- a/palacios/src/palacios/vmm_halt.c +++ b/palacios/src/palacios/vmm_halt.c @@ -20,7 +20,7 @@ #include #include - +#include #ifndef V3_CONFIG_DEBUG_HALT #undef PrintDebug @@ -42,18 +42,25 @@ int v3_handle_halt(struct guest_info * info) { while (!v3_intr_pending(info)) { /* Since we're in an exit, time is already paused here, so no need to pause again. */ + // V3_Print("palacios: halt->yield\n"); + v3_yield(info); - v3_update_timers(info); + v3_disable_ints(); + v3_update_timers(info); + v3_enable_ints(); + /* At this point, we either have some combination of interrupts, including perhaps a timer interrupt, or no interrupt. */ if (!v3_intr_pending(info)) { /* if no interrupt, then we do halt */ - asm("hlt"); + /* asm("hlt"); */ } } + + V3_Print("palacios: done with halt\n"); info->rip += 1; } diff --git a/palacios/src/palacios/vmm_time.c b/palacios/src/palacios/vmm_time.c index fc2e37e..781bae7 100644 --- a/palacios/src/palacios/vmm_time.c +++ b/palacios/src/palacios/vmm_time.c @@ -104,23 +104,44 @@ int v3_offset_time( struct guest_info * info, sint64_t offset ) return 0; } -// Control guest time in relation to host time so that the two stay -// appropriately synchronized to the extent possible. -int v3_adjust_time(struct guest_info * info) { +static uint64_t compute_target_host_time(struct guest_info * info) +{ + struct vm_time * time_state = &(info->time_state); + uint64_t guest_elapsed, desired_elapsed; + + guest_elapsed = (v3_get_guest_time(time_state) - time_state->initial_time); + desired_elapsed = (guest_elapsed * time_state->host_cpu_freq) / time_state->guest_cpu_freq; + return time_state->initial_time + desired_elapsed; +} + +static uint64_t compute_target_guest_time(struct guest_info *info) +{ + struct vm_time * time_state = &(info->time_state); + uint64_t host_elapsed, desired_elapsed; + + host_elapsed = v3_get_host_time(time_state) - time_state->initial_time; + desired_elapsed = (host_elapsed * time_state->guest_cpu_freq) / time_state->host_cpu_freq; + + return time_state->initial_time + desired_elapsed; + +} + +/* Yield time in the host to deal with a guest that wants to run slower than + * the native host cycle frequency */ +static int yield_host_time(struct guest_info * info) { struct vm_time * time_state = &(info->time_state); uint64_t host_time, target_host_time; - uint64_t guest_time, target_guest_time, old_guest_time; - uint64_t guest_elapsed, host_elapsed, desired_elapsed; + uint64_t guest_time, old_guest_time; /* Compute the target host time given how much time has *already* * passed in the guest */ - guest_time = v3_get_guest_time(time_state); - guest_elapsed = (guest_time - time_state->initial_time); - desired_elapsed = (guest_elapsed * time_state->host_cpu_freq) / time_state->guest_cpu_freq; - target_host_time = time_state->initial_time + desired_elapsed; - + target_host_time = compute_target_host_time(info); + /* Now, let the host run while the guest is stopped to make the two - * sync up. */ + * sync up. Note that this doesn't assume that guest time is stopped; + * the offsetting in the next step will change add an offset to guest + * time to account for the time paused even if the geust isn't + * usually paused in the VMM. */ host_time = v3_get_host_time(time_state); old_guest_time = v3_get_guest_time(time_state); @@ -131,38 +152,60 @@ int v3_adjust_time(struct guest_info * info) { guest_time = v3_get_guest_time(time_state); - // We do *not* assume the guest timer was paused in the VM. If it was - // this offseting is 0. If it wasn't we need this. + /* We do *not* assume the guest timer was paused in the VM. If it was + * this offseting is 0. If it wasn't, we need this. */ v3_offset_time(info, (sint64_t)old_guest_time - (sint64_t)guest_time); + return 0; +} + +static int skew_guest_time(struct guest_info * info) { + struct vm_time * time_state = &(info->time_state); + uint64_t target_guest_time, guest_time; /* Now the host may have gotten ahead of the guest because * yielding is a coarse grained thing. Figure out what guest time * we want to be at, and use the use the offsetting mechanism in * the VMM to make the guest run forward. We limit *how* much we skew * it forward to prevent the guest time making large jumps, * however. */ - host_elapsed = host_time - time_state->initial_time; - desired_elapsed = (host_elapsed * time_state->guest_cpu_freq) / time_state->host_cpu_freq; - target_guest_time = time_state->initial_time + desired_elapsed; + target_guest_time = compute_target_guest_time(info); + guest_time = v3_get_guest_time(time_state); if (guest_time < target_guest_time) { uint64_t max_skew, desired_skew, skew; if (time_state->enter_time) { - max_skew = (time_state->exit_time - time_state->enter_time) / 10; + /* Limit forward skew to 10% of the amount the guest has + * run since we last could skew time */ + max_skew = (guest_time - time_state->enter_time) / 10; } else { max_skew = 0; } desired_skew = target_guest_time - guest_time; skew = desired_skew > max_skew ? max_skew : desired_skew; -/* PrintDebug("Guest %llu cycles behind where it should be.\n", + PrintDebug("Guest %llu cycles behind where it should be.\n", desired_skew); PrintDebug("Limit on forward skew is %llu. Skewing forward %llu.\n", - max_skew, skew); */ + max_skew, skew); v3_offset_time(info, skew); } + + return 0; +} + +// Control guest time in relation to host time so that the two stay +// appropriately synchronized to the extent possible. +int v3_adjust_time(struct guest_info * info) { + + /* First deal with yielding if we want to slow down the guest */ + yield_host_time(info); + + /* Now, if the guest is too slow, (either from excess yielding above, + * or because the VMM is doing something that takes a long time to emulate) + * allow guest time to jump forward a bit */ + skew_guest_time(info); return 0; } @@ -190,11 +233,6 @@ v3_time_enter_vm( struct guest_info * info ) time_state->enter_time = host_time; time_state->guest_host_offset = guest_time - host_time; - // Because we just modified the offset - shouldn't matter as this should be - // the last time-related call prior to entering the VMM, but worth it - // just in case. - time_state->exit_time = host_time; - return 0; } @@ -232,7 +270,9 @@ void v3_update_timers(struct guest_info * info) { time_state->last_update = v3_get_guest_time(time_state); cycles = time_state->last_update - old_time; + V3_ASSERT(cycles >= 0); + // V3_Print("Updating timers with %lld elapsed cycles.\n", cycles); list_for_each_entry(tmp_timer, &(time_state->timers), timer_link) { tmp_timer->ops->update_timer(info, cycles, time_state->guest_cpu_freq, tmp_timer->private_data); } diff --git a/palacios/src/palacios/vmx.c b/palacios/src/palacios/vmx.c index 123e23b..1a23de7 100644 --- a/palacios/src/palacios/vmx.c +++ b/palacios/src/palacios/vmx.c @@ -745,19 +745,19 @@ int v3_vmx_enter(struct guest_info * info) { // Perform any additional yielding needed for time adjustment v3_adjust_time(info); - // Update timer devices prior to entering VM. - v3_update_timers(info); - // disable global interrupts for vm state transition v3_disable_ints(); + // Update timer devices prior to entering VM. Doing it here + // makes sure the guest sees any timers that fired while it + // was in the VMM + v3_update_timers(info); if (active_vmcs_ptrs[V3_Get_CPU()] != vmx_info->vmcs_ptr_phys) { vmcs_load(vmx_info->vmcs_ptr_phys); active_vmcs_ptrs[V3_Get_CPU()] = vmx_info->vmcs_ptr_phys; } - v3_vmx_restore_vmcs(info);