X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=palacios%2Fsrc%2Fpalacios%2Fvmm_time.c;h=48a15796bcdae939e778ed6c956ad6e03b30dfcc;hb=a0d3be5212e7a5053ba213ce7bd26c7124cf01e3;hp=c743771671c5518db057af441083a6e694669192;hpb=0adb91252edd4b093f12f57eea76687ced1aec0c;p=palacios.git diff --git a/palacios/src/palacios/vmm_time.c b/palacios/src/palacios/vmm_time.c index c743771..48a1579 100644 --- a/palacios/src/palacios/vmm_time.c +++ b/palacios/src/palacios/vmm_time.c @@ -41,18 +41,31 @@ * the passage of time: * (1) The host timestamp counter - read directly from HW and never written * (2) A monotonic guest timestamp counter used to measure the progression of - * time in the guest. This is computed as a multipler/offset from (1) above + * time in the guest. This is computed using an offsets from (1) above. * (3) The actual guest timestamp counter (which can be written by * writing to the guest TSC MSR - MSR 0x10) from the monotonic guest TSC. * This is also computed as an offset from (2) above when the TSC and * this offset is updated when the TSC MSR is written. * + * The value used to offset the guest TSC from the host TSC is the *sum* of all + * of these offsets (2 and 3) above + * * Because all other devices are slaved off of the passage of time in the guest, * it is (2) above that drives the firing of other timers in the guest, * including timer devices such as the Programmable Interrupt Timer (PIT). * - * - * + * Future additions: + * (1) Add support for temporarily skewing guest time off of where it should + * be to support slack simulation of guests. The idea is that simulators + * set this skew to be the difference between how much time passed for a + * simulated feature and a real implementation of that feature, making + * pass at a different rate from real time on this core. The VMM will then + * attempt to move this skew back towards 0 subject to resolution/accuracy + * constraints from various system timers. + * + * The main effort in doing this will be to get accuracy/resolution + * information from each local timer and to use this to bound how much skew + * is removed on each exit. */ @@ -89,35 +102,31 @@ int v3_adjust_time(struct guest_info * info) { } else { uint64_t guest_time, guest_elapsed, desired_elapsed; uint64_t host_time, target_host_time; + guest_time = v3_get_guest_time(time_state); + + /* Compute what host time this guest time should correspond to. */ 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; - host_time = v3_get_host_time(time_state); - PrintDebug("Core %d: Yielding %Lu cycles for guest frequency mismatch " - "(%Lu cycles elapsed in guest, %Lu in host).\n", - info->cpu_id, target_host_time - host_time, - guest_elapsed, host_time - time_state->initial_time); + /* Yield until that host time is reached */ host_time = v3_get_host_time(time_state); while (host_time < target_host_time) { v3_yield(info); host_time = v3_get_host_time(time_state); } - PrintDebug("Core %d: done adjusting time at host time %Lu.\n", - info->cpu_id, host_time); - time_state->guest_host_offset = guest_time - host_time; - + time_state->guest_host_offset = (sint64_t)guest_time - (sint64_t)host_time; } return 0; } -int v3_add_timer(struct guest_info * info, struct vm_timer_ops * ops, - void * private_data) { - struct vm_timer * timer = NULL; - timer = (struct vm_timer *)V3_Malloc(sizeof(struct vm_timer)); +struct v3_timer * v3_add_timer(struct guest_info * info, + struct v3_timer_ops * ops, + void * private_data) { + struct v3_timer * timer = NULL; + timer = (struct v3_timer *)V3_Malloc(sizeof(struct v3_timer)); V3_ASSERT(timer != NULL); timer->ops = ops; @@ -126,10 +135,10 @@ int v3_add_timer(struct guest_info * info, struct vm_timer_ops * ops, list_add(&(timer->timer_link), &(info->time_state.timers)); info->time_state.num_timers++; - return 0; + return timer; } -int v3_remove_timer(struct guest_info * info, struct vm_timer * timer) { +int v3_remove_timer(struct guest_info * info, struct v3_timer * timer) { list_del(&(timer->timer_link)); info->time_state.num_timers--; @@ -138,7 +147,7 @@ int v3_remove_timer(struct guest_info * info, struct vm_timer * timer) { } void v3_update_timers(struct guest_info * info) { - struct vm_timer * tmp_timer; + struct v3_timer * tmp_timer; uint64_t old_time = info->time_state.last_update; uint64_t cycles; @@ -153,8 +162,10 @@ void v3_update_timers(struct guest_info * info) { /* * Handle full virtualization of the time stamp counter. As noted * above, we don't store the actual value of the TSC, only the guest's - * offset from the host TSC. If the guest write's the to TSC, we handle - * this by changing that offset. + * offset from monotonic guest's time. If the guest writes to the TSC, we + * handle this by changing that offset. + * + * Possible TODO: Proper hooking of TSC read/writes? */ int v3_rdtsc(struct guest_info * info) { @@ -184,8 +195,7 @@ int v3_rdtscp(struct guest_info * info) { if (ret) return ret; info->vm_regs.rcx = info->vm_regs.rax; - /* Now do the TSC half of the instruction, which may hit the normal - * TSC hook if it exists */ + /* Now do the TSC half of the instruction */ ret = v3_rdtsc(info); if (ret) return ret; @@ -206,7 +216,6 @@ int v3_handle_rdtscp(struct guest_info * info) { return 0; } -#if 0 static int tsc_aux_msr_read_hook(struct guest_info *info, uint_t msr_num, struct v3_msr *msr_val, void *priv) { struct vm_time * time_state = &(info->time_state); @@ -252,12 +261,10 @@ static int tsc_msr_write_hook(struct guest_info *info, uint_t msr_num, return 0; } -#endif static int init_vm_time(struct v3_vm_info *vm_info) { int ret; -#if 0 PrintDebug("Installing TSC MSR hook.\n"); ret = v3_hook_msr(vm_info, TSC_MSR, tsc_msr_read_hook, tsc_msr_write_hook, NULL); @@ -267,7 +274,6 @@ static int init_vm_time(struct v3_vm_info *vm_info) { ret = v3_hook_msr(vm_info, TSC_AUX_MSR, tsc_aux_msr_read_hook, tsc_aux_msr_write_hook, NULL); if (ret) return ret; -#endif PrintDebug("Registering TIME_CPUFREQ hypercall.\n"); ret = v3_register_hypercall(vm_info, TIME_CPUFREQ_HCALL, @@ -316,3 +322,6 @@ void v3_init_time(struct guest_info * info) { + + +