TMAllCpu.cpp@ 66920

Last change on this file since 66920 was 66227, checked in by vboxsync, 8 years ago
VMM: Nested Hw.virt: Implement SVM VMRUN and #VMEXIT in IEM.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 19.1 KB

Line
1	/* $Id: TMAllCpu.cpp 66227 2017-03-23 14:50:07Z vboxsync $ */
2	/** @file
3	* TM - Timeout Manager, CPU Time, All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_TM
23	#include <VBox/vmm/tm.h>
24	#include <iprt/asm-amd64-x86.h> /* for SUPGetCpuHzFromGIP */
25	#include "TMInternal.h"
26	#include <VBox/vmm/vm.h>
27	#include <VBox/vmm/gim.h>
28	#include <VBox/vmm/dbgf.h>
29	#include <VBox/sup.h>
30
31	#include <VBox/param.h>
32	#include <VBox/err.h>
33	#include <iprt/asm-math.h>
34	#include <iprt/assert.h>
35	#include <VBox/log.h>
36
37
38	/**
39	* Gets the raw cpu tick from current virtual time.
40	*
41	* @param pVM The cross context VM structure.
42	* @param fCheckTimers Whether to check timers.
43	*/
44	DECLINLINE(uint64_t) tmCpuTickGetRawVirtual(PVM pVM, bool fCheckTimers)
45	{
46	uint64_t u64;
47	if (fCheckTimers)
48	u64 = TMVirtualSyncGet(pVM);
49	else
50	u64 = TMVirtualSyncGetNoCheck(pVM);
51	if (u64 != TMCLOCK_FREQ_VIRTUAL) /* what's the use of this test, document! */
52	u64 = ASMMultU64ByU32DivByU32(u64, pVM->tm.s.cTSCTicksPerSecond, TMCLOCK_FREQ_VIRTUAL);
53	return u64;
54	}
55
56
57	#ifdef IN_RING3
58	/**
59	* Used by tmR3CpuTickParavirtEnable and tmR3CpuTickParavirtDisable.
60	*
61	* @param pVM The cross context VM structure.
62	*/
63	uint64_t tmR3CpuTickGetRawVirtualNoCheck(PVM pVM)
64	{
65	return tmCpuTickGetRawVirtual(pVM, false /fCheckTimers/);
66	}
67	#endif
68
69
70	/**
71	* Resumes the CPU timestamp counter ticking.
72	*
73	* @returns VBox status code.
74	* @param pVM The cross context VM structure.
75	* @param pVCpu The cross context virtual CPU structure.
76	* @internal
77	*/
78	int tmCpuTickResume(PVM pVM, PVMCPU pVCpu)
79	{
80	if (!pVCpu->tm.s.fTSCTicking)
81	{
82	pVCpu->tm.s.fTSCTicking = true;
83
84	/** @todo Test that pausing and resuming doesn't cause lag! (I.e. that we're
85	* unpaused before the virtual time and stopped after it. */
86	if (pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET)
87	pVCpu->tm.s.offTSCRawSrc = SUPReadTsc() - pVCpu->tm.s.u64TSC;
88	else
89	pVCpu->tm.s.offTSCRawSrc = tmCpuTickGetRawVirtual(pVM, false /* don't check for pending timers */)
90	- pVCpu->tm.s.u64TSC;
91	return VINF_SUCCESS;
92	}
93	AssertFailed();
94	return VERR_TM_TSC_ALREADY_TICKING;
95	}
96
97
98	/**
99	* Resumes the CPU timestamp counter ticking.
100	*
101	* @returns VINF_SUCCESS or VERR_TM_VIRTUAL_TICKING_IPE (asserted).
102	* @param pVM The cross context VM structure.
103	* @param pVCpu The cross context virtual CPU structure.
104	*/
105	int tmCpuTickResumeLocked(PVM pVM, PVMCPU pVCpu)
106	{
107	if (!pVCpu->tm.s.fTSCTicking)
108	{
109	/* TSC must be ticking before calling tmCpuTickGetRawVirtual()! */
110	pVCpu->tm.s.fTSCTicking = true;
111	uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cTSCsTicking);
112	AssertMsgReturn(c <= pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_TM_VIRTUAL_TICKING_IPE);
113	if (c == 1)
114	{
115	/* The first VCPU to resume. */
116	uint64_t offTSCRawSrcOld = pVCpu->tm.s.offTSCRawSrc;
117
118	STAM_COUNTER_INC(&pVM->tm.s.StatTSCResume);
119
120	/* When resuming, use the TSC value of the last stopped VCPU to avoid the TSC going back. */
121	if (pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET)
122	pVCpu->tm.s.offTSCRawSrc = SUPReadTsc() - pVM->tm.s.u64LastPausedTSC;
123	else
124	pVCpu->tm.s.offTSCRawSrc = tmCpuTickGetRawVirtual(pVM, false /* don't check for pending timers */)
125	- pVM->tm.s.u64LastPausedTSC;
126
127	/* Calculate the offset for other VCPUs to use. */
128	pVM->tm.s.offTSCPause = pVCpu->tm.s.offTSCRawSrc - offTSCRawSrcOld;
129	}
130	else
131	{
132	/* All other VCPUs (if any). */
133	pVCpu->tm.s.offTSCRawSrc += pVM->tm.s.offTSCPause;
134	}
135	}
136	return VINF_SUCCESS;
137	}
138
139
140	/**
141	* Pauses the CPU timestamp counter ticking.
142	*
143	* @returns VBox status code.
144	* @param pVCpu The cross context virtual CPU structure.
145	* @internal
146	*/
147	int tmCpuTickPause(PVMCPU pVCpu)
148	{
149	if (pVCpu->tm.s.fTSCTicking)
150	{
151	pVCpu->tm.s.u64TSC = TMCpuTickGetNoCheck(pVCpu);
152	pVCpu->tm.s.fTSCTicking = false;
153	return VINF_SUCCESS;
154	}
155	AssertFailed();
156	return VERR_TM_TSC_ALREADY_PAUSED;
157	}
158
159
160	/**
161	* Pauses the CPU timestamp counter ticking.
162	*
163	* @returns VBox status code.
164	* @param pVM The cross context VM structure.
165	* @param pVCpu The cross context virtual CPU structure.
166	* @internal
167	*/
168	int tmCpuTickPauseLocked(PVM pVM, PVMCPU pVCpu)
169	{
170	if (pVCpu->tm.s.fTSCTicking)
171	{
172	pVCpu->tm.s.u64TSC = TMCpuTickGetNoCheck(pVCpu);
173	pVCpu->tm.s.fTSCTicking = false;
174
175	uint32_t c = ASMAtomicDecU32(&pVM->tm.s.cTSCsTicking);
176	AssertMsgReturn(c < pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_TM_VIRTUAL_TICKING_IPE);
177	if (c == 0)
178	{
179	/* When the last TSC stops, remember the value. */
180	STAM_COUNTER_INC(&pVM->tm.s.StatTSCPause);
181	pVM->tm.s.u64LastPausedTSC = pVCpu->tm.s.u64TSC;
182	}
183	return VINF_SUCCESS;
184	}
185	AssertFailed();
186	return VERR_TM_TSC_ALREADY_PAUSED;
187	}
188
189
190	#ifdef VBOX_WITH_STATISTICS
191	/**
192	* Record why we refused to use offsetted TSC.
193	*
194	* Used by TMCpuTickCanUseRealTSC() and TMCpuTickGetDeadlineAndTscOffset().
195	*
196	* @param pVM The cross context VM structure.
197	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
198	*/
199	DECLINLINE(void) tmCpuTickRecordOffsettedTscRefusal(PVM pVM, PVMCPU pVCpu)
200	{
201	/* Sample the reason for refusing. */
202	if (pVM->tm.s.enmTSCMode != TMTSCMODE_DYNAMIC)
203	STAM_COUNTER_INC(&pVM->tm.s.StatTSCNotFixed);
204	else if (!pVCpu->tm.s.fTSCTicking)
205	STAM_COUNTER_INC(&pVM->tm.s.StatTSCNotTicking);
206	else if (pVM->tm.s.enmTSCMode != TMTSCMODE_REAL_TSC_OFFSET)
207	{
208	if (pVM->tm.s.fVirtualSyncCatchUp)
209	{
210	if (pVM->tm.s.u32VirtualSyncCatchUpPercentage <= 10)
211	STAM_COUNTER_INC(&pVM->tm.s.StatTSCCatchupLE010);
212	else if (pVM->tm.s.u32VirtualSyncCatchUpPercentage <= 25)
213	STAM_COUNTER_INC(&pVM->tm.s.StatTSCCatchupLE025);
214	else if (pVM->tm.s.u32VirtualSyncCatchUpPercentage <= 100)
215	STAM_COUNTER_INC(&pVM->tm.s.StatTSCCatchupLE100);
216	else
217	STAM_COUNTER_INC(&pVM->tm.s.StatTSCCatchupOther);
218	}
219	else if (!pVM->tm.s.fVirtualSyncTicking)
220	STAM_COUNTER_INC(&pVM->tm.s.StatTSCSyncNotTicking);
221	else if (pVM->tm.s.fVirtualWarpDrive)
222	STAM_COUNTER_INC(&pVM->tm.s.StatTSCWarp);
223	}
224	}
225	#endif /* VBOX_WITH_STATISTICS */
226
227
228	/**
229	* Checks if AMD-V / VT-x can use an offsetted hardware TSC or not.
230	*
231	* @returns true/false accordingly.
232	* @param pVM The cross context VM structure.
233	* @param pVCpu The cross context virtual CPU structure.
234	* @param poffRealTsc The offset against the TSC of the current host CPU,
235	* if pfOffsettedTsc is set to true.
236	* @param pfParavirtTsc Where to return whether paravirt TSC is enabled.
237	*
238	* @thread EMT(pVCpu).
239	* @see TMCpuTickGetDeadlineAndTscOffset().
240	*/
241	VMM_INT_DECL(bool) TMCpuTickCanUseRealTSC(PVM pVM, PVMCPU pVCpu, uint64_t poffRealTsc, bool pfParavirtTsc)
242	{
243	Assert(pVCpu->tm.s.fTSCTicking \|\| DBGFIsStepping(pVCpu));
244
245	*pfParavirtTsc = pVM->tm.s.fParavirtTscEnabled;
246
247	/*
248	* In real TSC mode it's easy, we just need the delta & offTscRawSrc and
249	* the CPU will add them to RDTSC and RDTSCP at runtime.
250	*
251	* In tmCpuTickGetInternal we do:
252	* SUPReadTsc() - pVCpu->tm.s.offTSCRawSrc;
253	* Where SUPReadTsc() does:
254	* ASMReadTSC() - pGipCpu->i64TscDelta;
255	* Which means tmCpuTickGetInternal actually does:
256	* ASMReadTSC() - pGipCpu->i64TscDelta - pVCpu->tm.s.offTSCRawSrc;
257	* So, the offset to be ADDED to RDTSC[P] is:
258	* offRealTsc = -(pGipCpu->i64TscDelta + pVCpu->tm.s.offTSCRawSrc)
259	*/
260	if (pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET)
261	{
262	/** @todo We should negate both deltas! It's soo weird that we do the
263	* exact opposite of what the hardware implements. */
264	#ifdef IN_RING3
265	*poffRealTsc = 0 - pVCpu->tm.s.offTSCRawSrc - SUPGetTscDelta();
266	#else
267	*poffRealTsc = 0 - pVCpu->tm.s.offTSCRawSrc - SUPGetTscDeltaByCpuSetIndex(pVCpu->iHostCpuSet);
268	#endif
269	return true;
270	}
271
272	/*
273	* We require:
274	* 1. A fixed TSC, this is checked at init time.
275	* 2. That the TSC is ticking (we shouldn't be here if it isn't)
276	* 3. Either that we're using the real TSC as time source or
277	* a) we don't have any lag to catch up, and
278	* b) the virtual sync clock hasn't been halted by an expired timer, and
279	* c) we're not using warp drive (accelerated virtual guest time).
280	*/
281	if ( pVM->tm.s.enmTSCMode == TMTSCMODE_DYNAMIC
282	&& !pVM->tm.s.fVirtualSyncCatchUp
283	&& RT_LIKELY(pVM->tm.s.fVirtualSyncTicking)
284	&& !pVM->tm.s.fVirtualWarpDrive)
285	{
286	/* The source is the timer synchronous virtual clock. */
287	uint64_t u64Now = tmCpuTickGetRawVirtual(pVM, false /* don't check for pending timers */)
288	- pVCpu->tm.s.offTSCRawSrc;
289	/** @todo When we start collecting statistics on how much time we spend executing
290	* guest code before exiting, we should check this against the next virtual sync
291	* timer timeout. If it's lower than the avg. length, we should trap rdtsc to increase
292	* the chance that we'll get interrupted right after the timer expired. */
293	if (u64Now >= pVCpu->tm.s.u64TSCLastSeen)
294	{
295	*poffRealTsc = u64Now - ASMReadTSC();
296	return true; /** @todo count this? */
297	}
298	}
299
300	#ifdef VBOX_WITH_STATISTICS
301	tmCpuTickRecordOffsettedTscRefusal(pVM, pVCpu);
302	#endif
303	return false;
304	}
305
306
307	/**
308	* Calculates the number of host CPU ticks till the next virtual sync deadline.
309	*
310	* @note To save work, this function will not bother calculating the accurate
311	* tick count for deadlines that are more than a second ahead.
312	*
313	* @returns The number of host cpu ticks to the next deadline. Max one second.
314	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
315	* @param cNsToDeadline The number of nano seconds to the next virtual
316	* sync deadline.
317	*/
318	DECLINLINE(uint64_t) tmCpuCalcTicksToDeadline(PVMCPU pVCpu, uint64_t cNsToDeadline)
319	{
320	AssertCompile(TMCLOCK_FREQ_VIRTUAL <= _4G);
321	#ifdef IN_RING3
322	RT_NOREF_PV(pVCpu);
323	uint64_t uCpuHz = SUPGetCpuHzFromGip(g_pSUPGlobalInfoPage);
324	#else
325	uint64_t uCpuHz = SUPGetCpuHzFromGipBySetIndex(g_pSUPGlobalInfoPage, pVCpu->iHostCpuSet);
326	#endif
327	if (RT_UNLIKELY(cNsToDeadline >= TMCLOCK_FREQ_VIRTUAL))
328	return uCpuHz;
329	uint64_t cTicks = ASMMultU64ByU32DivByU32(uCpuHz, cNsToDeadline, TMCLOCK_FREQ_VIRTUAL);
330	if (cTicks > 4000)
331	cTicks -= 4000; /* fudge to account for overhead */
332	else
333	cTicks >>= 1;
334	return cTicks;
335	}
336
337
338	/**
339	* Gets the next deadline in host CPU clock ticks and the TSC offset if we can
340	* use the raw TSC.
341	*
342	* @returns The number of host CPU clock ticks to the next timer deadline.
343	* @param pVM The cross context VM structure.
344	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
345	* @param poffRealTsc The offset against the TSC of the current host CPU,
346	* if pfOffsettedTsc is set to true.
347	* @param pfOffsettedTsc Where to return whether TSC offsetting can be used.
348	* @param pfParavirtTsc Where to return whether paravirt TSC is enabled.
349	*
350	* @thread EMT(pVCpu).
351	* @see TMCpuTickCanUseRealTSC().
352	*/
353	VMM_INT_DECL(uint64_t) TMCpuTickGetDeadlineAndTscOffset(PVM pVM, PVMCPU pVCpu, uint64_t *poffRealTsc,
354	bool pfOffsettedTsc, bool pfParavirtTsc)
355	{
356	Assert(pVCpu->tm.s.fTSCTicking \|\| DBGFIsStepping(pVCpu));
357
358	*pfParavirtTsc = pVM->tm.s.fParavirtTscEnabled;
359
360	/*
361	* Same logic as in TMCpuTickCanUseRealTSC.
362	*/
363	if (pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET)
364	{
365	/** @todo We should negate both deltas! It's soo weird that we do the
366	* exact opposite of what the hardware implements. */
367	#ifdef IN_RING3
368	*poffRealTsc = 0 - pVCpu->tm.s.offTSCRawSrc - SUPGetTscDelta();
369	#else
370	*poffRealTsc = 0 - pVCpu->tm.s.offTSCRawSrc - SUPGetTscDeltaByCpuSetIndex(pVCpu->iHostCpuSet);
371	#endif
372	*pfOffsettedTsc = true;
373	return tmCpuCalcTicksToDeadline(pVCpu, TMVirtualSyncGetNsToDeadline(pVM));
374	}
375
376	/*
377	* Same logic as in TMCpuTickCanUseRealTSC.
378	*/
379	if ( pVM->tm.s.enmTSCMode == TMTSCMODE_DYNAMIC
380	&& !pVM->tm.s.fVirtualSyncCatchUp
381	&& RT_LIKELY(pVM->tm.s.fVirtualSyncTicking)
382	&& !pVM->tm.s.fVirtualWarpDrive)
383	{
384	/* The source is the timer synchronous virtual clock. */
385	uint64_t cNsToDeadline;
386	uint64_t u64NowVirtSync = TMVirtualSyncGetWithDeadlineNoCheck(pVM, &cNsToDeadline);
387	uint64_t u64Now = u64NowVirtSync != TMCLOCK_FREQ_VIRTUAL /* what's the use of this? */
388	? ASMMultU64ByU32DivByU32(u64NowVirtSync, pVM->tm.s.cTSCTicksPerSecond, TMCLOCK_FREQ_VIRTUAL)
389	: u64NowVirtSync;
390	u64Now -= pVCpu->tm.s.offTSCRawSrc;
391	*poffRealTsc = u64Now - ASMReadTSC();
392	*pfOffsettedTsc = u64Now >= pVCpu->tm.s.u64TSCLastSeen;
393	return tmCpuCalcTicksToDeadline(pVCpu, cNsToDeadline);
394	}
395
396	#ifdef VBOX_WITH_STATISTICS
397	tmCpuTickRecordOffsettedTscRefusal(pVM, pVCpu);
398	#endif
399	*pfOffsettedTsc = false;
400	*poffRealTsc = 0;
401	return tmCpuCalcTicksToDeadline(pVCpu, TMVirtualSyncGetNsToDeadline(pVM));
402	}
403
404
405	/**
406	* Read the current CPU timestamp counter.
407	*
408	* @returns Gets the CPU tsc.
409	* @param pVCpu The cross context virtual CPU structure.
410	* @param fCheckTimers Whether to check timers.
411	*/
412	DECLINLINE(uint64_t) tmCpuTickGetInternal(PVMCPU pVCpu, bool fCheckTimers)
413	{
414	uint64_t u64;
415
416	if (RT_LIKELY(pVCpu->tm.s.fTSCTicking))
417	{
418	PVM pVM = pVCpu->CTX_SUFF(pVM);
419	if (pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET)
420	u64 = SUPReadTsc();
421	else
422	u64 = tmCpuTickGetRawVirtual(pVM, fCheckTimers);
423	u64 -= pVCpu->tm.s.offTSCRawSrc;
424
425	/* Always return a value higher than what the guest has already seen. */
426	if (RT_LIKELY(u64 > pVCpu->tm.s.u64TSCLastSeen))
427	pVCpu->tm.s.u64TSCLastSeen = u64;
428	else
429	{
430	STAM_COUNTER_INC(&pVM->tm.s.StatTSCUnderflow);
431	pVCpu->tm.s.u64TSCLastSeen += 64; /** @todo choose a good increment here */
432	u64 = pVCpu->tm.s.u64TSCLastSeen;
433	}
434	}
435	else
436	u64 = pVCpu->tm.s.u64TSC;
437	/** @todo @bugref{7243}: SVM TSC offset. */
438	return u64;
439	}
440
441
442	/**
443	* Read the current CPU timestamp counter.
444	*
445	* @returns Gets the CPU tsc.
446	* @param pVCpu The cross context virtual CPU structure.
447	*/
448	VMMDECL(uint64_t) TMCpuTickGet(PVMCPU pVCpu)
449	{
450	return tmCpuTickGetInternal(pVCpu, true /* fCheckTimers */);
451	}
452
453
454	/**
455	* Read the current CPU timestamp counter, don't check for expired timers.
456	*
457	* @returns Gets the CPU tsc.
458	* @param pVCpu The cross context virtual CPU structure.
459	*/
460	VMM_INT_DECL(uint64_t) TMCpuTickGetNoCheck(PVMCPU pVCpu)
461	{
462	return tmCpuTickGetInternal(pVCpu, false /* fCheckTimers */);
463	}
464
465
466	/**
467	* Sets the current CPU timestamp counter.
468	*
469	* @returns VBox status code.
470	* @param pVM The cross context VM structure.
471	* @param pVCpu The cross context virtual CPU structure.
472	* @param u64Tick The new timestamp value.
473	*
474	* @thread EMT which TSC is to be set.
475	*/
476	VMM_INT_DECL(int) TMCpuTickSet(PVM pVM, PVMCPU pVCpu, uint64_t u64Tick)
477	{
478	VMCPU_ASSERT_EMT(pVCpu);
479	STAM_COUNTER_INC(&pVM->tm.s.StatTSCSet);
480
481	/*
482	* This is easier to do when the TSC is paused since resume will
483	* do all the calculations for us. Actually, we don't need to
484	* call tmCpuTickPause here since we overwrite u64TSC anyway.
485	*/
486	bool fTSCTicking = pVCpu->tm.s.fTSCTicking;
487	pVCpu->tm.s.fTSCTicking = false;
488	pVCpu->tm.s.u64TSC = u64Tick;
489	pVCpu->tm.s.u64TSCLastSeen = u64Tick;
490	if (fTSCTicking)
491	tmCpuTickResume(pVM, pVCpu);
492	/** @todo Try help synchronizing it better among the virtual CPUs? */
493
494	return VINF_SUCCESS;
495	}
496
497	/**
498	* Sets the last seen CPU timestamp counter.
499	*
500	* @returns VBox status code.
501	* @param pVCpu The cross context virtual CPU structure.
502	* @param u64LastSeenTick The last seen timestamp value.
503	*
504	* @thread EMT which TSC is to be set.
505	*/
506	VMM_INT_DECL(int) TMCpuTickSetLastSeen(PVMCPU pVCpu, uint64_t u64LastSeenTick)
507	{
508	VMCPU_ASSERT_EMT(pVCpu);
509
510	LogFlow(("TMCpuTickSetLastSeen %RX64\n", u64LastSeenTick));
511	if (pVCpu->tm.s.u64TSCLastSeen < u64LastSeenTick)
512	pVCpu->tm.s.u64TSCLastSeen = u64LastSeenTick;
513	return VINF_SUCCESS;
514	}
515
516	/**
517	* Gets the last seen CPU timestamp counter of the guest.
518	*
519	* @returns the last seen TSC.
520	* @param pVCpu The cross context virtual CPU structure.
521	*
522	* @thread EMT(pVCpu).
523	*/
524	VMM_INT_DECL(uint64_t) TMCpuTickGetLastSeen(PVMCPU pVCpu)
525	{
526	VMCPU_ASSERT_EMT(pVCpu);
527
528	return pVCpu->tm.s.u64TSCLastSeen;
529	}
530
531
532	/**
533	* Get the timestamp frequency.
534	*
535	* @returns Number of ticks per second.
536	* @param pVM The cross context VM structure.
537	*/
538	VMMDECL(uint64_t) TMCpuTicksPerSecond(PVM pVM)
539	{
540	if ( pVM->tm.s.enmTSCMode == TMTSCMODE_REAL_TSC_OFFSET
541	&& g_pSUPGlobalInfoPage->u32Mode != SUPGIPMODE_INVARIANT_TSC)
542	{
543	#ifdef IN_RING3
544	uint64_t cTSCTicksPerSecond = SUPGetCpuHzFromGip(g_pSUPGlobalInfoPage);
545	#elif defined(IN_RING0)
546	uint64_t cTSCTicksPerSecond = SUPGetCpuHzFromGipBySetIndex(g_pSUPGlobalInfoPage, RTMpCpuIdToSetIndex(RTMpCpuId()));
547	#else
548	uint64_t cTSCTicksPerSecond = SUPGetCpuHzFromGipBySetIndex(g_pSUPGlobalInfoPage, VMMGetCpu(pVM)->iHostCpuSet);
549	#endif
550	if (RT_LIKELY(cTSCTicksPerSecond != ~(uint64_t)0))
551	return cTSCTicksPerSecond;
552	}
553	return pVM->tm.s.cTSCTicksPerSecond;
554	}
555
556
557	/**
558	* Whether the TSC is ticking for the VCPU.
559	*
560	* @returns true if ticking, false otherwise.
561	* @param pVCpu The cross context virtual CPU structure.
562	*/
563	VMM_INT_DECL(bool) TMCpuTickIsTicking(PVMCPU pVCpu)
564	{
565	return pVCpu->tm.s.fTSCTicking;
566	}
567

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMAll/TMAllCpu.cpp@ 66920

Download in other formats: