TMAllCpu.cpp revision c75bbdcd0352901501738c698ec7805cef8d68a9
/* $Id$ */
/** @file
* TM - Timeout Manager, CPU Time, All Contexts.
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_TM
#include "TMInternal.h"
#include <iprt/asm-math.h>
/**
* Gets the raw cpu tick from current virtual time.
*/
{
if (fCheckTimers)
else
return u64;
}
/**
* Resumes the CPU timestamp counter ticking.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the VMCPU.
* @internal
*/
{
{
{
/** @todo Test that pausing and resuming doesn't cause lag! (I.e. that we're
* unpaused before the virtual time and stopped after it. */
else
}
return VINF_SUCCESS;
}
AssertFailed();
return VERR_TM_TSC_ALREADY_TICKING;
}
/**
* Resumes the CPU timestamp counter ticking.
*
* @returns VINF_SUCCESS or VERR_TM_VIRTUAL_TICKING_IPE (asserted).
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the VCPU.
*/
{
{
/* TSC must be ticking before calling tmCpuTickGetRawVirtual()! */
{
if (c == 1)
{
/* The first VCPU to resume. */
/* When resuming, use the TSC value of the last stopped VCPU to avoid the TSC going back. */
else
/* Calculate the offset for other VCPUs to use. */
}
else
{
/* All other VCPUs (if any). */
}
}
}
return VINF_SUCCESS;
}
/**
* Pauses the CPU timestamp counter ticking.
*
* @returns VBox status code.
* @param pVCpu Pointer to the VMCPU.
* @internal
*/
{
{
return VINF_SUCCESS;
}
AssertFailed();
return VERR_TM_TSC_ALREADY_PAUSED;
}
/**
* Pauses the CPU timestamp counter ticking.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the VMCPU.
* @internal
*/
{
{
if (c == 0)
{
/* When the last TSC stops, remember the value. */
}
return VINF_SUCCESS;
}
AssertFailed();
return VERR_TM_TSC_ALREADY_PAUSED;
}
/**
* Record why we refused to use offsetted TSC.
*
* Used by TMCpuTickCanUseRealTSC and TMCpuTickGetDeadlineAndTscOffset.
*
* @param pVM Pointer to the VM.
* @param pVCpu The current CPU.
*/
{
/* Sample the reason for refusing. */
{
{
else
}
}
}
/**
* Checks if AMD-V / VT-x can use an offsetted hardware TSC or not.
*
* @param pVCpu Pointer to the VMCPU.
* @param poffRealTSC The offset against the TSC of the current CPU.
* Can be NULL.
* @param pfParavirtTsc Where to store whether paravirt. TSC can be used or
* not.
* @thread EMT(pVCpu).
*/
{
bool fParavirtTsc = false;
/*
* We require:
* 1. Use of a paravirtualized TSC is enabled by the guest.
* (OR)
* 1. A fixed TSC, this is checked at init time.
* 2. That the TSC is ticking (we shouldn't be here if it isn't)
* 3. Either that we're using the real TSC as time source or
* a) we don't have any lag to catch up, and
* b) the virtual sync clock hasn't been halted by an expired timer, and
* c) we're not using warp drive (accelerated virtual guest time).
*/
{
{
/* The source is the timer synchronous virtual clock. */
if (poffRealTSC)
{
/** @todo When we start collecting statistics on how much time we spend executing
* guest code before exiting, we should check this against the next virtual sync
* timer timeout. If it's lower than the avg. length, we should trap rdtsc to increase
* the chance that we'll get interrupted right after the timer expired. */
}
}
else if (poffRealTSC)
{
/* The source is the real TSC. */
else
*poffRealTSC = 0;
}
/** @todo count this? */
return true;
}
#ifdef VBOX_WITH_STATISTICS
#endif
return false;
}
/**
* Calculates the number of host CPU ticks till the next virtual sync deadline.
*
* @note To save work, this function will not bother calculating the accurate
* tick count for deadlines that are more than a second ahead.
*
* @returns The number of host cpu ticks to the next deadline. Max one second.
* @param cNsToDeadline The number of nano seconds to the next virtual
* sync deadline.
*/
{
return SUPGetCpuHzFromGIP(g_pSUPGlobalInfoPage);
if (cTicks > 4000)
else
cTicks >>= 1;
return cTicks;
}
/**
* Gets the next deadline in host CPU clock ticks and the TSC offset if we can
* use the raw TSC.
*
* @returns The number of host CPU clock ticks to the next timer deadline.
* @param pVCpu The current CPU.
* @param pfParavirtTsc Where to store whether paravirt. TSC can be used or
* not.
* @param poffRealTSC The offset against the TSC of the current CPU.
*
* @thread EMT(pVCpu).
* @remarks Superset of TMCpuTickCanUseRealTSC().
*/
VMM_INT_DECL(uint64_t) TMCpuTickGetDeadlineAndTscOffset(PVMCPU pVCpu, bool *pfOffsettedTsc, bool *pfParavirtTsc,
{
/*
* We require:
* 1. Use of a paravirtualized TSC is enabled by the guest.
* (OR)
* 1. A fixed TSC, this is checked at init time.
* 2. That the TSC is ticking (we shouldn't be here if it isn't)
* 3. Either that we're using the real TSC as time source or
* a) we don't have any lag to catch up, and
* b) the virtual sync clock hasn't been halted by an expired timer, and
* c) we're not using warp drive (accelerated virtual guest time).
*/
{
*pfOffsettedTsc = true;
{
/* The source is the timer synchronous virtual clock. */
}
else
{
/* The source is the real TSC. */
else
*poffRealTSC = 0;
}
}
else
{
#ifdef VBOX_WITH_STATISTICS
#endif
*pfOffsettedTsc = false;
*poffRealTSC = 0;
}
return cTicksToDeadline;
}
/**
* Read the current CPU timestamp counter.
*
* @returns Gets the CPU tsc.
* @param pVCpu Pointer to the VMCPU.
*/
{
{
{
u64 = ASMReadTSC();
else
}
else
u64 = ASMReadTSC();
/* Always return a value higher than what the guest has already seen. */
else
{
}
}
else
return u64;
}
/**
* Read the current CPU timestamp counter.
*
* @returns Gets the CPU tsc.
* @param pVCpu Pointer to the VMCPU.
*/
{
}
/**
* Read the current CPU timestamp counter, don't check for expired timers.
*
* @returns Gets the CPU tsc.
* @param pVCpu Pointer to the VMCPU.
*/
{
}
/**
* Sets the current CPU timestamp counter.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the VMCPU.
* @param u64Tick The new timestamp value.
*
* @thread EMT which TSC is to be set.
*/
{
/*
* This is easier to do when the TSC is paused since resume will
* do all the calculations for us. Actually, we don't need to
* call tmCpuTickPause here since we overwrite u64TSC anyway.
*/
if (fTSCTicking)
/** @todo Try help synchronizing it better among the virtual CPUs? */
return VINF_SUCCESS;
}
/**
* Sets the last seen CPU timestamp counter.
*
* @returns VBox status code.
* @param pVCpu Pointer to the VMCPU.
* @param u64LastSeenTick The last seen timestamp value.
*
* @thread EMT which TSC is to be set.
*/
{
return VINF_SUCCESS;
}
/**
* Gets the last seen CPU timestamp counter of the guest.
*
* @returns the last seen TSC.
* @param pVCpu Pointer to the VMCPU.
*
* @thread EMT(pVCpu).
*/
{
}
/**
* Get the timestamp frequency.
*
* @returns Number of ticks per second.
* @param pVM The VM.
*/
{
{
return cTSCTicksPerSecond;
}
}