TMAll.cpp@ 4787

Last change on this file since 4787 was 4787, checked in by vboxsync, 17 years ago
Eliminated HCPTRTYPE and replaced with R3R0PTRTYPE where necessary.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 44.1 KB

Line
1	/* $Id: TMAll.cpp 4787 2007-09-14 09:08:56Z vboxsync $ */
2	/** @file
3	* TM - Timeout Manager, all contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* 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/tm.h>
24	#include <VBox/mm.h>
25	#ifdef IN_RING3
26	# include <VBox/rem.h>
27	#endif
28	#include "TMInternal.h"
29	#include <VBox/vm.h>
30
31	#include <VBox/param.h>
32	#include <VBox/err.h>
33	#include <VBox/log.h>
34	#include <VBox/sup.h>
35	#include <iprt/time.h>
36	#include <iprt/assert.h>
37	#include <iprt/asm.h>
38	#ifdef IN_RING3
39	# include <iprt/thread.h>
40	#endif
41
42
43	/**
44	* Schedule the queue which was changed.
45	*/
46	DECLINLINE(void) tmSchedule(PTMTIMER pTimer)
47	{
48	PVM pVM = pTimer->CTXALLSUFF(pVM);
49	if (VM_IS_EMT(pVM))
50	{
51	STAM_PROFILE_START(&pVM->tm.s.CTXALLSUFF(StatScheduleOne), a);
52	PTMTIMERQUEUE pQueue = &pVM->tm.s.CTXALLSUFF(paTimerQueues)[pTimer->enmClock];
53	Log3(("tmSchedule: tmTimerQueueSchedule\n"));
54	tmTimerQueueSchedule(pVM, pQueue);
55	#ifdef VBOX_STRICT
56	tmTimerQueuesSanityChecks(pVM, "tmSchedule");
57	#endif
58	STAM_PROFILE_STOP(&pVM->tm.s.CTXALLSUFF(StatScheduleOne), a);
59	}
60	else if (!VM_FF_ISSET(pVM, VM_FF_TIMER)) /*@todo only do this when arming the timer. /
61	{
62	STAM_COUNTER_INC(&pVM->tm.s.StatScheduleSetFF);
63	VM_FF_SET(pVM, VM_FF_TIMER);
64	#ifdef IN_RING3
65	REMR3NotifyTimerPending(pVM);
66	VMR3NotifyFF(pVM, true);
67	#endif
68	}
69	}
70
71
72	/**
73	* Try change the state to enmStateNew from enmStateOld
74	* and link the timer into the scheduling queue.
75	*
76	* @returns Success indicator.
77	* @param pTimer Timer in question.
78	* @param enmStateNew The new timer state.
79	* @param enmStateOld The old timer state.
80	*/
81	DECLINLINE(bool) tmTimerTry(PTMTIMER pTimer, TMTIMERSTATE enmStateNew, TMTIMERSTATE enmStateOld)
82	{
83	/*
84	* Attempt state change.
85	*/
86	bool fRc;
87	TM_TRY_SET_STATE(pTimer, enmStateNew, enmStateOld, fRc);
88	return fRc;
89	}
90
91
92	/**
93	* Links the timer onto the scheduling queue.
94	*
95	* @param pQueue The timer queue the timer belongs to.
96	* @param pTimer The timer.
97	*/
98	DECLINLINE(void) tmTimerLink(PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
99	{
100	Assert(!pTimer->offScheduleNext);
101	const int32_t offHeadNew = (intptr_t)pTimer - (intptr_t)pQueue;
102	int32_t offHead;
103	do
104	{
105	offHead = pQueue->offSchedule;
106	if (offHead)
107	pTimer->offScheduleNext = ((intptr_t)pQueue + offHead) - (intptr_t)pTimer;
108	else
109	pTimer->offScheduleNext = 0;
110	} while (!ASMAtomicCmpXchgS32(&pQueue->offSchedule, offHeadNew, offHead));
111	}
112
113
114	/**
115	* Try change the state to enmStateNew from enmStateOld
116	* and link the timer into the scheduling queue.
117	*
118	* @returns Success indicator.
119	* @param pTimer Timer in question.
120	* @param enmStateNew The new timer state.
121	* @param enmStateOld The old timer state.
122	*/
123	DECLINLINE(bool) tmTimerTryWithLink(PTMTIMER pTimer, TMTIMERSTATE enmStateNew, TMTIMERSTATE enmStateOld)
124	{
125	if (tmTimerTry(pTimer, enmStateNew, enmStateOld))
126	{
127	tmTimerLink(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(paTimerQueues)[pTimer->enmClock], pTimer);
128	return true;
129	}
130	return false;
131	}
132
133
134	#ifdef VBOX_HIGH_RES_TIMERS_HACK
135	/**
136	* Set FF if we've passed the next virtual event.
137	*
138	* This function is called before FFs are checked in the inner execution EM loops.
139	*
140	* @returns Virtual timer ticks to the next event.
141	* @thread The emulation thread.
142	*/
143	TMDECL(uint64_t) TMTimerPoll(PVM pVM)
144	{
145	/*
146	* Return straight away if the timer FF is already set.
147	*/
148	if (VM_FF_ISSET(pVM, VM_FF_TIMER))
149	{
150	STAM_COUNTER_INC(&pVM->tm.s.StatPollAlreadySet);
151	return 0;
152	}
153
154	/*
155	* Get current time and check the expire times of the two relevant queues.
156	*/
157	const uint64_t u64Now = TMVirtualGet(pVM);
158
159	/*
160	* TMCLOCK_VIRTUAL
161	*/
162	const uint64_t u64Expire1 = pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL].u64Expire;
163	const int64_t i64Delta1 = u64Expire1 - u64Now;
164	if (i64Delta1 <= 0)
165	{
166	LogFlow(("TMTimerPoll: expire1=%RU64 <= now=%RU64\n", u64Expire1, u64Now));
167	STAM_COUNTER_INC(&pVM->tm.s.StatPollVirtual);
168	VM_FF_SET(pVM, VM_FF_TIMER);
169	#ifdef IN_RING3
170	REMR3NotifyTimerPending(pVM);
171	#endif
172	return 0;
173	}
174
175	/*
176	* TMCLOCK_VIRTUAL_SYNC
177	* This isn't quite as stright forward if in a catch-up, not only do
178	* we have to adjust the 'now' but when have to adjust the delta as well.
179	*/
180	const uint64_t u64Expire2 = pVM->tm.s.CTXALLSUFF(paTimerQueues)[TMCLOCK_VIRTUAL_SYNC].u64Expire;
181	uint64_t u64VirtualSyncNow;
182	if (!pVM->tm.s.fVirtualSyncTicking)
183	u64VirtualSyncNow = pVM->tm.s.u64VirtualSync;
184	else
185	{
186	if (!pVM->tm.s.fVirtualSyncCatchUp)
187	u64VirtualSyncNow = u64Now - pVM->tm.s.offVirtualSync;
188	else
189	{
190	uint64_t off = pVM->tm.s.offVirtualSync;
191	uint64_t u64Delta = u64Now - pVM->tm.s.u64VirtualSyncCatchUpPrev;
192	if (RT_LIKELY(!(u64Delta >> 32)))
193	{
194	uint64_t u64Sub = ASMMultU64ByU32DivByU32(u64Delta, pVM->tm.s.u32VirtualSyncCatchUpPercentage, 100);
195	if (off > u64Sub + pVM->tm.s.offVirtualSyncGivenUp)
196	off -= u64Sub;
197	else
198	off = pVM->tm.s.offVirtualSyncGivenUp;
199	}
200	u64VirtualSyncNow = u64Now - off;
201	}
202	}
203	int64_t i64Delta2 = u64Expire2 - u64VirtualSyncNow;
204	if (i64Delta2 <= 0)
205	{
206	LogFlow(("TMTimerPoll: expire2=%RU64 <= now=%RU64\n", u64Expire2, u64Now));
207	STAM_COUNTER_INC(&pVM->tm.s.StatPollVirtualSync);
208	VM_FF_SET(pVM, VM_FF_TIMER);
209	#ifdef IN_RING3
210	REMR3NotifyTimerPending(pVM);
211	#endif
212	return 0;
213	}
214	if (pVM->tm.s.fVirtualSyncCatchUp)
215	i64Delta2 = ASMMultU64ByU32DivByU32(i64Delta2, 100, pVM->tm.s.u32VirtualSyncCatchUpPercentage + 100);
216
217	/*
218	* Return the time left to the next event.
219	*/
220	STAM_COUNTER_INC(&pVM->tm.s.StatPollMiss);
221	return RT_MIN(i64Delta1, i64Delta2);
222	}
223	#endif
224
225
226	/**
227	* Gets the host context ring-3 pointer of the timer.
228	*
229	* @returns HC R3 pointer.
230	* @param pTimer Timer handle as returned by one of the create functions.
231	*/
232	TMDECL(PTMTIMERR3) TMTimerR3Ptr(PTMTIMER pTimer)
233	{
234	return (PTMTIMERR3)MMHyperCCToR3(pTimer->CTXALLSUFF(pVM), pTimer);
235	}
236
237
238	/**
239	* Gets the host context ring-0 pointer of the timer.
240	*
241	* @returns HC R0 pointer.
242	* @param pTimer Timer handle as returned by one of the create functions.
243	*/
244	TMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer)
245	{
246	return (PTMTIMERR0)MMHyperCCToR0(pTimer->CTXALLSUFF(pVM), pTimer);
247	}
248
249
250	/**
251	* Gets the GC pointer of the timer.
252	*
253	* @returns GC pointer.
254	* @param pTimer Timer handle as returned by one of the create functions.
255	*/
256	TMDECL(PTMTIMERGC) TMTimerGCPtr(PTMTIMER pTimer)
257	{
258	return (PTMTIMERGC)MMHyperCCToGC(pTimer->CTXALLSUFF(pVM), pTimer);
259	}
260
261
262	/**
263	* Destroy a timer
264	*
265	* @returns VBox status.
266	* @param pTimer Timer handle as returned by one of the create functions.
267	*/
268	TMDECL(int) TMTimerDestroy(PTMTIMER pTimer)
269	{
270	int cRetries = 1000;
271	do
272	{
273	/*
274	* Change to any of the DESTROY states if valid.
275	*/
276	TMTIMERSTATE enmState = pTimer->enmState;
277	Log2(("TMTimerDestroy: pTimer=%p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
278	pTimer, tmTimerState(enmState), HCSTRING(pTimer->pszDesc), cRetries));
279	switch (enmState)
280	{
281	case TMTIMERSTATE_EXPIRED:
282	if (!VM_IS_EMT(pTimer->CTXALLSUFF(pVM)))
283	{
284	AssertMsgFailed(("Attempted timer destruction from other thread while expire pending! (%s)\n", HCSTRING(pTimer->pszDesc)));
285	return VERR_INVALID_PARAMETER;
286	}
287	/* fall thru */
288	case TMTIMERSTATE_STOPPED:
289	if (tmTimerTryWithLink(pTimer, TMTIMERSTATE_PENDING_DESTROY, enmState))
290	{
291	tmSchedule(pTimer);
292	return VINF_SUCCESS;
293	}
294	break;
295
296	case TMTIMERSTATE_ACTIVE:
297	if (tmTimerTryWithLink(pTimer, TMTIMERSTATE_PENDING_STOP_DESTROY, enmState))
298	{
299	tmSchedule(pTimer);
300	return VINF_SUCCESS;
301	}
302	break;
303
304	case TMTIMERSTATE_PENDING_STOP:
305	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
306	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP_DESTROY, enmState))
307	{
308	tmSchedule(pTimer);
309	return VINF_SUCCESS;
310	}
311	break;
312
313	case TMTIMERSTATE_PENDING_DESTROY:
314	case TMTIMERSTATE_PENDING_STOP_DESTROY:
315	AssertMsgFailed(("How many times do you think you can destroy the same timer... (%s)\n", HCSTRING(pTimer->pszDesc)));
316	return VERR_INVALID_PARAMETER;
317
318	case TMTIMERSTATE_PENDING_RESCHEDULE:
319	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP_DESTROY, enmState))
320	{
321	tmSchedule(pTimer);
322	return VINF_SUCCESS;
323	}
324	break;
325
326	case TMTIMERSTATE_PENDING_SCHEDULE:
327	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_DESTROY, enmState))
328	{
329	tmSchedule(pTimer);
330	return VINF_SUCCESS;
331	}
332	break;
333
334	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
335	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
336	#ifdef IN_RING3
337	if (!RTThreadYield())
338	RTThreadSleep(1);
339	#endif
340	break;
341
342	/*
343	* Invalid states.
344	*/
345	case TMTIMERSTATE_FREE:
346	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
347	return VERR_TM_INVALID_STATE;
348	default:
349	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
350	return VERR_TM_UNKNOWN_STATE;
351	}
352	} while (cRetries-- > 0);
353
354	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, HCSTRING(pTimer->pszDesc)));
355	return VERR_INTERNAL_ERROR;
356	}
357
358
359	/**
360	* Arm a timer with a (new) expire time.
361	*
362	* @returns VBox status.
363	* @param pTimer Timer handle as returned by one of the create functions.
364	* @param u64Expire New expire time.
365	*/
366	TMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
367	{
368	STAM_PROFILE_START(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
369
370	/** @todo find the most frequently used paths and make them skip tmSchedule and tmTimerTryWithLink. */
371	int cRetries = 1000;
372	do
373	{
374	/*
375	* Change to any of the SET_EXPIRE states if valid and then to SCHEDULE or RESCHEDULE.
376	*/
377	TMTIMERSTATE enmState = pTimer->enmState;
378	Log2(("TMTimerSet: pTimer=%p:{.enmState=%s, .pszDesc='%s'} cRetries=%d u64Expire=%llu\n",
379	pTimer, tmTimerState(enmState), HCSTRING(pTimer->pszDesc), cRetries, u64Expire));
380	switch (enmState)
381	{
382	case TMTIMERSTATE_EXPIRED:
383	case TMTIMERSTATE_STOPPED:
384	if (tmTimerTryWithLink(pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
385	{
386	Assert(!pTimer->offPrev);
387	Assert(!pTimer->offNext);
388	AssertMsg( pTimer->enmClock != TMCLOCK_VIRTUAL_SYNC
389	\|\| pTimer->CTXALLSUFF(pVM)->tm.s.fVirtualSyncTicking
390	\|\| u64Expire >= pTimer->CTXALLSUFF(pVM)->tm.s.u64VirtualSync,
391	("%RU64 < %RU64 %s\n", u64Expire, pTimer->CTXALLSUFF(pVM)->tm.s.u64VirtualSync, R3STRING(pTimer->pszDesc)));
392	pTimer->u64Expire = u64Expire;
393	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
394	tmSchedule(pTimer);
395	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
396	return VINF_SUCCESS;
397	}
398	break;
399
400	case TMTIMERSTATE_PENDING_SCHEDULE:
401	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
402	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
403	{
404	Assert(!pTimer->offPrev);
405	Assert(!pTimer->offNext);
406	pTimer->u64Expire = u64Expire;
407	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_SCHEDULE);
408	tmSchedule(pTimer);
409	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
410	return VINF_SUCCESS;
411	}
412	break;
413
414
415	case TMTIMERSTATE_ACTIVE:
416	if (tmTimerTryWithLink(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
417	{
418	pTimer->u64Expire = u64Expire;
419	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
420	tmSchedule(pTimer);
421	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
422	return VINF_SUCCESS;
423	}
424	break;
425
426	case TMTIMERSTATE_PENDING_RESCHEDULE:
427	case TMTIMERSTATE_PENDING_STOP:
428	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
429	{
430	pTimer->u64Expire = u64Expire;
431	TM_SET_STATE(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE);
432	tmSchedule(pTimer);
433	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
434	return VINF_SUCCESS;
435	}
436	break;
437
438
439	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
440	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
441	#ifdef IN_RING3
442	if (!RTThreadYield())
443	RTThreadSleep(1);
444	#else
445	/** @todo call host context and yield after a couple of iterations */
446	#endif
447	break;
448
449	/*
450	* Invalid states.
451	*/
452	case TMTIMERSTATE_PENDING_DESTROY:
453	case TMTIMERSTATE_PENDING_STOP_DESTROY:
454	case TMTIMERSTATE_FREE:
455	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
456	return VERR_TM_INVALID_STATE;
457	default:
458	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
459	return VERR_TM_UNKNOWN_STATE;
460	}
461	} while (cRetries-- > 0);
462
463	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, HCSTRING(pTimer->pszDesc)));
464	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerSet), a);
465	return VERR_INTERNAL_ERROR;
466	}
467
468
469	/**
470	* Arm a timer with a (new) expire time relative to current clock.
471	*
472	* @returns VBox status.
473	* @param pTimer Timer handle as returned by one of the create functions.
474	* @param cMilliesToNext Number of millieseconds to the next tick.
475	*/
476	TMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
477	{
478	PVM pVM = pTimer->CTXALLSUFF(pVM);
479	switch (pTimer->enmClock)
480	{
481	case TMCLOCK_VIRTUAL:
482	return TMTimerSet(pTimer, cMilliesToNext * (uint64_t)TMCLOCK_FREQ_VIRTUAL / 1000 + TMVirtualGet(pVM));
483	case TMCLOCK_VIRTUAL_SYNC:
484	return TMTimerSet(pTimer, cMilliesToNext * (uint64_t)TMCLOCK_FREQ_VIRTUAL / 1000 + TMVirtualSyncGet(pVM));
485	case TMCLOCK_REAL:
486	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
487	return TMTimerSet(pTimer, cMilliesToNext + TMRealGet(pVM));
488	case TMCLOCK_TSC:
489	return TMTimerSet(pTimer, cMilliesToNext * pVM->tm.s.cTSCTicksPerSecond / 1000 + TMCpuTickGet(pVM));
490
491	default:
492	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
493	return VERR_INTERNAL_ERROR;
494	}
495	}
496
497
498	/**
499	* Stop the timer.
500	* Use TMR3TimerArm() to "un-stop" the timer.
501	*
502	* @returns VBox status.
503	* @param pTimer Timer handle as returned by one of the create functions.
504	*/
505	TMDECL(int) TMTimerStop(PTMTIMER pTimer)
506	{
507	STAM_PROFILE_START(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
508	/** @todo see if this function needs optimizing. */
509	int cRetries = 1000;
510	do
511	{
512	/*
513	* Change to any of the SET_EXPIRE states if valid and then to SCHEDULE or RESCHEDULE.
514	*/
515	TMTIMERSTATE enmState = pTimer->enmState;
516	Log2(("TMTimerStop: pTimer=%p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
517	pTimer, tmTimerState(enmState), HCSTRING(pTimer->pszDesc), cRetries));
518	switch (enmState)
519	{
520	case TMTIMERSTATE_EXPIRED:
521	//AssertMsgFailed(("You don't stop an expired timer dude!\n"));
522	return VERR_INVALID_PARAMETER;
523
524	case TMTIMERSTATE_STOPPED:
525	case TMTIMERSTATE_PENDING_STOP:
526	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
527	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
528	return VINF_SUCCESS;
529
530	case TMTIMERSTATE_PENDING_SCHEDULE:
531	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP_SCHEDULE, enmState))
532	{
533	Assert(!pTimer->offPrev);
534	Assert(!pTimer->offNext);
535	tmSchedule(pTimer);
536	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
537	return VINF_SUCCESS;
538	}
539
540	case TMTIMERSTATE_PENDING_RESCHEDULE:
541	if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_STOP, enmState))
542	{
543	tmSchedule(pTimer);
544	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
545	return VINF_SUCCESS;
546	}
547	break;
548
549	case TMTIMERSTATE_ACTIVE:
550	if (tmTimerTryWithLink(pTimer, TMTIMERSTATE_PENDING_STOP, enmState))
551	{
552	tmSchedule(pTimer);
553	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
554	return VINF_SUCCESS;
555	}
556	break;
557
558	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
559	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
560	#ifdef IN_RING3
561	if (!RTThreadYield())
562	RTThreadSleep(1);
563	#else
564	/*@todo call host and yield cpu after a while. /
565	#endif
566	break;
567
568	/*
569	* Invalid states.
570	*/
571	case TMTIMERSTATE_PENDING_DESTROY:
572	case TMTIMERSTATE_PENDING_STOP_DESTROY:
573	case TMTIMERSTATE_FREE:
574	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
575	return VERR_TM_INVALID_STATE;
576	default:
577	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
578	return VERR_TM_UNKNOWN_STATE;
579	}
580	} while (cRetries-- > 0);
581
582	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, HCSTRING(pTimer->pszDesc)));
583	STAM_PROFILE_STOP(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatTimerStop), a);
584	return VERR_INTERNAL_ERROR;
585	}
586
587
588	/**
589	* Get the current clock time.
590	* Handy for calculating the new expire time.
591	*
592	* @returns Current clock time.
593	* @param pTimer Timer handle as returned by one of the create functions.
594	*/
595	TMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
596	{
597	uint64_t u64;
598	PVM pVM = pTimer->CTXALLSUFF(pVM);
599	switch (pTimer->enmClock)
600	{
601	case TMCLOCK_VIRTUAL:
602	u64 = TMVirtualGet(pVM);
603	break;
604	case TMCLOCK_VIRTUAL_SYNC:
605	u64 = TMVirtualSyncGet(pVM);
606	break;
607	case TMCLOCK_REAL:
608	u64 = TMRealGet(pVM);
609	break;
610	case TMCLOCK_TSC:
611	u64 = TMCpuTickGet(pVM);
612	break;
613
614	default:
615	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
616	return ~(uint64_t)0;
617	}
618	//Log2(("TMTimerGet: returns %llu (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
619	// u64, pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
620	return u64;
621	}
622
623
624	/**
625	* Get the freqency of the timer clock.
626	*
627	* @returns Clock frequency (as Hz of course).
628	* @param pTimer Timer handle as returned by one of the create functions.
629	*/
630	TMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer)
631	{
632	switch (pTimer->enmClock)
633	{
634	case TMCLOCK_VIRTUAL:
635	case TMCLOCK_VIRTUAL_SYNC:
636	return TMCLOCK_FREQ_VIRTUAL;
637
638	case TMCLOCK_REAL:
639	return TMCLOCK_FREQ_REAL;
640
641	case TMCLOCK_TSC:
642	return TMCpuTicksPerSecond(pTimer->CTXALLSUFF(pVM));
643
644	default:
645	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
646	return 0;
647	}
648	}
649
650
651	/**
652	* Get the current clock time as nanoseconds.
653	*
654	* @returns The timer clock as nanoseconds.
655	* @param pTimer Timer handle as returned by one of the create functions.
656	*/
657	TMDECL(uint64_t) TMTimerGetNano(PTMTIMER pTimer)
658	{
659	return TMTimerToNano(pTimer, TMTimerGet(pTimer));
660	}
661
662
663	/**
664	* Get the current clock time as microseconds.
665	*
666	* @returns The timer clock as microseconds.
667	* @param pTimer Timer handle as returned by one of the create functions.
668	*/
669	TMDECL(uint64_t) TMTimerGetMicro(PTMTIMER pTimer)
670	{
671	return TMTimerToMicro(pTimer, TMTimerGet(pTimer));
672	}
673
674
675	/**
676	* Get the current clock time as milliseconds.
677	*
678	* @returns The timer clock as milliseconds.
679	* @param pTimer Timer handle as returned by one of the create functions.
680	*/
681	TMDECL(uint64_t) TMTimerGetMilli(PTMTIMER pTimer)
682	{
683	return TMTimerToMilli(pTimer, TMTimerGet(pTimer));
684	}
685
686
687	/**
688	* Converts the specified timer clock time to nanoseconds.
689	*
690	* @returns nanoseconds.
691	* @param pTimer Timer handle as returned by one of the create functions.
692	* @param u64Ticks The clock ticks.
693	* @remark There could be rounding errors here. We just do a simple integere divide
694	* without any adjustments.
695	*/
696	TMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks)
697	{
698	switch (pTimer->enmClock)
699	{
700	case TMCLOCK_VIRTUAL:
701	case TMCLOCK_VIRTUAL_SYNC:
702	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
703	return u64Ticks;
704
705	case TMCLOCK_REAL:
706	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
707	return u64Ticks * 1000000;
708
709	case TMCLOCK_TSC:
710	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
711	return 0;
712
713	default:
714	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
715	return 0;
716	}
717	}
718
719
720	/**
721	* Converts the specified timer clock time to microseconds.
722	*
723	* @returns microseconds.
724	* @param pTimer Timer handle as returned by one of the create functions.
725	* @param u64Ticks The clock ticks.
726	* @remark There could be rounding errors here. We just do a simple integere divide
727	* without any adjustments.
728	*/
729	TMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks)
730	{
731	switch (pTimer->enmClock)
732	{
733	case TMCLOCK_VIRTUAL:
734	case TMCLOCK_VIRTUAL_SYNC:
735	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
736	return u64Ticks / 1000;
737
738	case TMCLOCK_REAL:
739	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
740	return u64Ticks * 1000;
741
742	case TMCLOCK_TSC:
743	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
744	return 0;
745
746	default:
747	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
748	return 0;
749	}
750	}
751
752
753	/**
754	* Converts the specified timer clock time to milliseconds.
755	*
756	* @returns milliseconds.
757	* @param pTimer Timer handle as returned by one of the create functions.
758	* @param u64Ticks The clock ticks.
759	* @remark There could be rounding errors here. We just do a simple integere divide
760	* without any adjustments.
761	*/
762	TMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks)
763	{
764	switch (pTimer->enmClock)
765	{
766	case TMCLOCK_VIRTUAL:
767	case TMCLOCK_VIRTUAL_SYNC:
768	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
769	return u64Ticks / 1000000;
770
771	case TMCLOCK_REAL:
772	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
773	return u64Ticks;
774
775	case TMCLOCK_TSC:
776	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
777	return 0;
778
779	default:
780	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
781	return 0;
782	}
783	}
784
785
786	/**
787	* Converts the specified nanosecond timestamp to timer clock ticks.
788	*
789	* @returns timer clock ticks.
790	* @param pTimer Timer handle as returned by one of the create functions.
791	* @param u64NanoTS The nanosecond value ticks to convert.
792	* @remark There could be rounding and overflow errors here.
793	*/
794	TMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t u64NanoTS)
795	{
796	switch (pTimer->enmClock)
797	{
798	case TMCLOCK_VIRTUAL:
799	case TMCLOCK_VIRTUAL_SYNC:
800	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
801	return u64NanoTS;
802
803	case TMCLOCK_REAL:
804	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
805	return u64NanoTS / 1000000;
806
807	case TMCLOCK_TSC:
808	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
809	return 0;
810
811	default:
812	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
813	return 0;
814	}
815	}
816
817
818	/**
819	* Converts the specified microsecond timestamp to timer clock ticks.
820	*
821	* @returns timer clock ticks.
822	* @param pTimer Timer handle as returned by one of the create functions.
823	* @param u64MicroTS The microsecond value ticks to convert.
824	* @remark There could be rounding and overflow errors here.
825	*/
826	TMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t u64MicroTS)
827	{
828	switch (pTimer->enmClock)
829	{
830	case TMCLOCK_VIRTUAL:
831	case TMCLOCK_VIRTUAL_SYNC:
832	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
833	return u64MicroTS * 1000;
834
835	case TMCLOCK_REAL:
836	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
837	return u64MicroTS / 1000;
838
839	case TMCLOCK_TSC:
840	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
841	return 0;
842
843	default:
844	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
845	return 0;
846	}
847	}
848
849
850	/**
851	* Converts the specified millisecond timestamp to timer clock ticks.
852	*
853	* @returns timer clock ticks.
854	* @param pTimer Timer handle as returned by one of the create functions.
855	* @param u64MilliTS The millisecond value ticks to convert.
856	* @remark There could be rounding and overflow errors here.
857	*/
858	TMDECL(uint64_t) TMTimerFromMilli(PTMTIMER pTimer, uint64_t u64MilliTS)
859	{
860	switch (pTimer->enmClock)
861	{
862	case TMCLOCK_VIRTUAL:
863	case TMCLOCK_VIRTUAL_SYNC:
864	AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
865	return u64MilliTS * 1000000;
866
867	case TMCLOCK_REAL:
868	AssertCompile(TMCLOCK_FREQ_REAL == 1000);
869	return u64MilliTS;
870
871	case TMCLOCK_TSC:
872	AssertReleaseMsgFailed(("TMCLOCK_TSC conversions are not implemented\n"));
873	return 0;
874
875	default:
876	AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
877	return 0;
878	}
879	}
880
881
882	/**
883	* Get the expire time of the timer.
884	* Only valid for active timers.
885	*
886	* @returns Expire time of the timer.
887	* @param pTimer Timer handle as returned by one of the create functions.
888	*/
889	TMDECL(uint64_t) TMTimerGetExpire(PTMTIMER pTimer)
890	{
891	int cRetries = 1000;
892	do
893	{
894	TMTIMERSTATE enmState = pTimer->enmState;
895	switch (enmState)
896	{
897	case TMTIMERSTATE_EXPIRED:
898	case TMTIMERSTATE_STOPPED:
899	case TMTIMERSTATE_PENDING_STOP:
900	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
901	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
902	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
903	return ~(uint64_t)0;
904
905	case TMTIMERSTATE_ACTIVE:
906	case TMTIMERSTATE_PENDING_RESCHEDULE:
907	case TMTIMERSTATE_PENDING_SCHEDULE:
908	Log2(("TMTimerGetExpire: returns %llu (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
909	pTimer->u64Expire, pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
910	return pTimer->u64Expire;
911
912	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
913	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
914	#ifdef IN_RING3
915	if (!RTThreadYield())
916	RTThreadSleep(1);
917	#endif
918	break;
919
920	/*
921	* Invalid states.
922	*/
923	case TMTIMERSTATE_PENDING_DESTROY:
924	case TMTIMERSTATE_PENDING_STOP_DESTROY:
925	case TMTIMERSTATE_FREE:
926	AssertMsgFailed(("Invalid timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
927	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
928	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
929	return ~(uint64_t)0;
930	default:
931	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
932	return ~(uint64_t)0;
933	}
934	} while (cRetries-- > 0);
935
936	AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, HCSTRING(pTimer->pszDesc)));
937	Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
938	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
939	return ~(uint64_t)0;
940	}
941
942
943	/**
944	* Checks if a timer is active or not.
945	*
946	* @returns True if active.
947	* @returns False if not active.
948	* @param pTimer Timer handle as returned by one of the create functions.
949	*/
950	TMDECL(bool) TMTimerIsActive(PTMTIMER pTimer)
951	{
952	TMTIMERSTATE enmState = pTimer->enmState;
953	switch (enmState)
954	{
955	case TMTIMERSTATE_STOPPED:
956	case TMTIMERSTATE_EXPIRED:
957	case TMTIMERSTATE_PENDING_STOP:
958	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
959	Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
960	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
961	return false;
962
963	case TMTIMERSTATE_ACTIVE:
964	case TMTIMERSTATE_PENDING_RESCHEDULE:
965	case TMTIMERSTATE_PENDING_SCHEDULE:
966	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
967	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
968	Log2(("TMTimerIsActive: returns true (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
969	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
970	return true;
971
972	/*
973	* Invalid states.
974	*/
975	case TMTIMERSTATE_PENDING_DESTROY:
976	case TMTIMERSTATE_PENDING_STOP_DESTROY:
977	case TMTIMERSTATE_FREE:
978	AssertMsgFailed(("Invalid timer state %s (%s)\n", tmTimerState(enmState), HCSTRING(pTimer->pszDesc)));
979	Log2(("TMTimerIsActive: returns false (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
980	pTimer, tmTimerState(pTimer->enmState), HCSTRING(pTimer->pszDesc)));
981	return false;
982	default:
983	AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, HCSTRING(pTimer->pszDesc)));
984	return false;
985	}
986	}
987
988
989	/**
990	* Convert state to string.
991	*
992	* @returns Readonly status name.
993	* @param enmState State.
994	*/
995	const char *tmTimerState(TMTIMERSTATE enmState)
996	{
997	switch (enmState)
998	{
999	#define CASE(state) case state: return #state + sizeof("TMTIMERSTATE_") - 1
1000	CASE(TMTIMERSTATE_STOPPED);
1001	CASE(TMTIMERSTATE_ACTIVE);
1002	CASE(TMTIMERSTATE_EXPIRED);
1003	CASE(TMTIMERSTATE_PENDING_STOP);
1004	CASE(TMTIMERSTATE_PENDING_STOP_SCHEDULE);
1005	CASE(TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE);
1006	CASE(TMTIMERSTATE_PENDING_SCHEDULE);
1007	CASE(TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE);
1008	CASE(TMTIMERSTATE_PENDING_RESCHEDULE);
1009	CASE(TMTIMERSTATE_PENDING_STOP_DESTROY);
1010	CASE(TMTIMERSTATE_PENDING_DESTROY);
1011	CASE(TMTIMERSTATE_FREE);
1012	default:
1013	AssertMsgFailed(("Invalid state enmState=%d\n", enmState));
1014	return "Invalid state!";
1015	#undef CASE
1016	}
1017	}
1018
1019
1020	/**
1021	* Schedules the given timer on the given queue.
1022	*
1023	* @param pQueue The timer queue.
1024	* @param pTimer The timer that needs scheduling.
1025	*/
1026	DECLINLINE(void) tmTimerQueueScheduleOne(PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
1027	{
1028	/*
1029	* Processing.
1030	*/
1031	switch (pTimer->enmState)
1032	{
1033	/*
1034	* Reschedule timer (in the active list).
1035	*/
1036	case TMTIMERSTATE_PENDING_RESCHEDULE:
1037	{
1038	const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
1039	const PTMTIMER pNext = TMTIMER_GET_NEXT(pTimer);
1040	if (pPrev)
1041	TMTIMER_SET_NEXT(pPrev, pNext);
1042	else
1043	{
1044	TMTIMER_SET_HEAD(pQueue, pNext);
1045	pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
1046	}
1047	if (pNext)
1048	TMTIMER_SET_PREV(pNext, pPrev);
1049	pTimer->offNext = 0;
1050	pTimer->offPrev = 0;
1051	/* fall thru */
1052	}
1053
1054	/*
1055	* Schedule timer (insert into the active list).
1056	*/
1057	case TMTIMERSTATE_PENDING_SCHEDULE:
1058	{
1059	Assert(!pTimer->offNext); Assert(!pTimer->offPrev);
1060	TM_SET_STATE(pTimer, TMTIMERSTATE_ACTIVE);
1061	PTMTIMER pCur = TMTIMER_GET_HEAD(pQueue);
1062	if (pCur)
1063	{
1064	const uint64_t u64Expire = pTimer->u64Expire;
1065	for (;; pCur = TMTIMER_GET_NEXT(pCur))
1066	{
1067	if (pCur->u64Expire > u64Expire)
1068	{
1069	const PTMTIMER pPrev = TMTIMER_GET_PREV(pCur);
1070	TMTIMER_SET_NEXT(pTimer, pCur);
1071	TMTIMER_SET_PREV(pTimer, pPrev);
1072	if (pPrev)
1073	TMTIMER_SET_NEXT(pPrev, pTimer);
1074	else
1075	{
1076	TMTIMER_SET_HEAD(pQueue, pTimer);
1077	pQueue->u64Expire = u64Expire;
1078	}
1079	TMTIMER_SET_PREV(pCur, pTimer);
1080	break;
1081	}
1082	else if (!pCur->offNext)
1083	{
1084	TMTIMER_SET_NEXT(pCur, pTimer);
1085	TMTIMER_SET_PREV(pTimer, pCur);
1086	break;
1087	}
1088	}
1089	}
1090	else
1091	{
1092	TMTIMER_SET_HEAD(pQueue, pTimer);
1093	pQueue->u64Expire = pTimer->u64Expire;
1094	}
1095	break;
1096	}
1097
1098	/*
1099	* Stop the timer in active list.
1100	*/
1101	case TMTIMERSTATE_PENDING_STOP:
1102	{
1103	const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
1104	const PTMTIMER pNext = TMTIMER_GET_NEXT(pTimer);
1105	if (pPrev)
1106	TMTIMER_SET_NEXT(pPrev, pNext);
1107	else
1108	{
1109	TMTIMER_SET_HEAD(pQueue, pNext);
1110	pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
1111	}
1112	if (pNext)
1113	TMTIMER_SET_PREV(pNext, pPrev);
1114	pTimer->offNext = 0;
1115	pTimer->offPrev = 0;
1116	/* fall thru */
1117	}
1118
1119	/*
1120	* Stop the timer (not on the active list).
1121	*/
1122	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1123	Assert(!pTimer->offNext); Assert(!pTimer->offPrev);
1124	TM_SET_STATE(pTimer, TMTIMERSTATE_STOPPED);
1125	break;
1126
1127	/*
1128	* Stop & destroy the timer.
1129	*/
1130	case TMTIMERSTATE_PENDING_STOP_DESTROY:
1131	{
1132	const PTMTIMER pPrev = TMTIMER_GET_PREV(pTimer);
1133	const PTMTIMER pNext = TMTIMER_GET_NEXT(pTimer);
1134	if (pPrev)
1135	TMTIMER_SET_NEXT(pPrev, pNext);
1136	else
1137	{
1138	TMTIMER_SET_HEAD(pQueue, pNext);
1139	pQueue->u64Expire = pNext ? pNext->u64Expire : INT64_MAX;
1140	}
1141	if (pNext)
1142	TMTIMER_SET_PREV(pNext, pPrev);
1143	pTimer->offNext = 0;
1144	pTimer->offPrev = 0;
1145	/* fall thru */
1146	}
1147
1148	/*
1149	* Destroy the timer.
1150	*/
1151	case TMTIMERSTATE_PENDING_DESTROY:
1152	{
1153	Assert(!pTimer->offNext); Assert(!pTimer->offPrev);
1154	PVM pVM = pTimer->CTXALLSUFF(pVM);
1155	const PTMTIMER pBigPrev = (PTMTIMER)(pTimer->pBigPrev ? MMHyperR3ToCC(pVM, pTimer->pBigPrev) : NULL);
1156	const PTMTIMER pBigNext = (PTMTIMER)(pTimer->pBigNext ? MMHyperR3ToCC(pVM, pTimer->pBigNext) : NULL);
1157
1158	/* unlink from created list */
1159	if (pBigPrev)
1160	pBigPrev->pBigNext = pTimer->pBigNext;
1161	else
1162	pVM->tm.s.pCreated = pTimer->pBigNext;
1163	if (pBigNext)
1164	pBigNext->pBigPrev = pTimer->pBigPrev;
1165	pTimer->pBigNext = 0;
1166	pTimer->pBigPrev = 0;
1167
1168	/* free */
1169	Log2(("TM: Inserting %p into the free list ahead of %p!\n", pTimer, pVM->tm.s.pFree));
1170	pTimer->pBigNext = pVM->tm.s.pFree;
1171	pVM->tm.s.pFree = (PTMTIMERR3)MMHyperCCToR3(pVM, pTimer);
1172	TM_SET_STATE(pTimer, TMTIMERSTATE_FREE);
1173	break;
1174	}
1175
1176	/*
1177	* Postpone these until they get into the right state.
1178	*/
1179	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1180	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1181	tmTimerLink(pQueue, pTimer);
1182	STAM_COUNTER_INC(&pTimer->CTXALLSUFF(pVM)->tm.s.CTXALLSUFF(StatPostponed));
1183	break;
1184
1185	/*
1186	* None of these can be in the schedule.
1187	*/
1188	case TMTIMERSTATE_FREE:
1189	case TMTIMERSTATE_STOPPED:
1190	case TMTIMERSTATE_ACTIVE:
1191	case TMTIMERSTATE_EXPIRED:
1192	AssertMsgFailed(("Timer (%p) in the scheduling list has an invalid state %s (%d)!",
1193	pTimer, tmTimerState(pTimer->enmState), pTimer->enmState));
1194	break;
1195	}
1196	}
1197
1198
1199	/**
1200	* Schedules the specified timer queue.
1201	*
1202	* @param pVM The VM to run the timers for.
1203	* @param pQueue The queue to schedule.
1204	*/
1205	void tmTimerQueueSchedule(PVM pVM, PTMTIMERQUEUE pQueue)
1206	{
1207	VM_ASSERT_EMT(pVM);
1208
1209	/*
1210	* Dequeue the scheduling list and iterate it.
1211	*/
1212	int32_t offNext = ASMAtomicXchgS32(&pQueue->offSchedule, 0);
1213	Log2(("tmTimerQueueSchedule: pQueue=%p:{.enmClock=%d, offNext=%RI32}\n", pQueue, pQueue->enmClock, offNext));
1214	if (!offNext)
1215	return;
1216	PTMTIMER pNext = (PTMTIMER)((intptr_t)pQueue + offNext);
1217	while (pNext)
1218	{
1219	/*
1220	* Unlink the head timer and find the next one.
1221	*/
1222	PTMTIMER pTimer = pNext;
1223	pNext = pNext->offScheduleNext ? (PTMTIMER)((intptr_t)pNext + pNext->offScheduleNext) : NULL;
1224	pTimer->offScheduleNext = 0;
1225
1226	/*
1227	* Do the scheduling.
1228	*/
1229	Log2(("tmTimerQueueSchedule: pTimer=%p:{.enmState=%s, .enmClock=%d, .enmType=%d, .pszDesc=%s}\n",
1230	pTimer, tmTimerState(pTimer->enmState), pTimer->enmClock, pTimer->enmType, HCSTRING(pTimer->pszDesc)));
1231	tmTimerQueueScheduleOne(pQueue, pTimer);
1232	Log2(("tmTimerQueueSchedule: new %s\n", tmTimerState(pTimer->enmState)));
1233	} /* foreach timer in current schedule batch. */
1234	}
1235
1236
1237	#ifdef VBOX_STRICT
1238	/**
1239	* Checks that the timer queues are sane.
1240	*
1241	* @param pVM VM handle.
1242	*/
1243	void tmTimerQueuesSanityChecks(PVM pVM, const char *pszWhere)
1244	{
1245	/*
1246	* Check the linking of the active lists.
1247	*/
1248	for (int i = 0; i < TMCLOCK_MAX; i++)
1249	{
1250	PTMTIMERQUEUE pQueue = &pVM->tm.s.CTXALLSUFF(paTimerQueues)[i];
1251	Assert((int)pQueue->enmClock == i);
1252	PTMTIMER pPrev = NULL;
1253	for (PTMTIMER pCur = TMTIMER_GET_HEAD(pQueue); pCur; pPrev = pCur, pCur = TMTIMER_GET_NEXT(pCur))
1254	{
1255	AssertMsg((int)pCur->enmClock == i, ("%s: %d != %d\n", pszWhere, pCur->enmClock, i));
1256	AssertMsg(TMTIMER_GET_PREV(pCur) == pPrev, ("%s: %p != %p\n", pszWhere, TMTIMER_GET_PREV(pCur), pPrev));
1257	TMTIMERSTATE enmState = pCur->enmState;
1258	switch (enmState)
1259	{
1260	case TMTIMERSTATE_ACTIVE:
1261	AssertMsg(!pCur->offScheduleNext, ("%s: %RI32\n", pszWhere, pCur->offScheduleNext));
1262	break;
1263	case TMTIMERSTATE_PENDING_STOP:
1264	case TMTIMERSTATE_PENDING_STOP_DESTROY:
1265	case TMTIMERSTATE_PENDING_RESCHEDULE:
1266	break;
1267	default:
1268	AssertMsgFailed(("%s: Invalid state enmState=%d %s\n", pszWhere, enmState, tmTimerState(enmState)));
1269	break;
1270	}
1271	}
1272	}
1273
1274
1275	# ifdef IN_RING3
1276	/*
1277	* Do the big list and check that active timers all are in the active lists.
1278	*/
1279	PTMTIMERR3 pPrev = NULL;
1280	for (PTMTIMERR3 pCur = pVM->tm.s.pCreated; pCur; pPrev = pCur, pCur = pCur->pBigNext)
1281	{
1282	Assert(pCur->pBigPrev == pPrev);
1283	Assert((unsigned)pCur->enmClock < (unsigned)TMCLOCK_MAX);
1284
1285	TMTIMERSTATE enmState = pCur->enmState;
1286	switch (enmState)
1287	{
1288	case TMTIMERSTATE_ACTIVE:
1289	case TMTIMERSTATE_PENDING_STOP:
1290	case TMTIMERSTATE_PENDING_STOP_DESTROY:
1291	case TMTIMERSTATE_PENDING_RESCHEDULE:
1292	case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
1293	{
1294	PTMTIMERR3 pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
1295	Assert(pCur->offPrev \|\| pCur == pCurAct);
1296	while (pCurAct && pCurAct != pCur)
1297	pCurAct = TMTIMER_GET_NEXT(pCurAct);
1298	Assert(pCurAct == pCur);
1299	break;
1300	}
1301
1302	case TMTIMERSTATE_PENDING_DESTROY:
1303	case TMTIMERSTATE_PENDING_SCHEDULE:
1304	case TMTIMERSTATE_PENDING_STOP_SCHEDULE:
1305	case TMTIMERSTATE_STOPPED:
1306	case TMTIMERSTATE_EXPIRED:
1307	{
1308	Assert(!pCur->offNext);
1309	Assert(!pCur->offPrev);
1310	for (PTMTIMERR3 pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
1311	pCurAct;
1312	pCurAct = TMTIMER_GET_NEXT(pCurAct))
1313	{
1314	Assert(pCurAct != pCur);
1315	Assert(TMTIMER_GET_NEXT(pCurAct) != pCur);
1316	Assert(TMTIMER_GET_PREV(pCurAct) != pCur);
1317	}
1318	break;
1319	}
1320
1321	/* ignore */
1322	case TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE:
1323	break;
1324
1325	/* shouldn't get here! */
1326	default:
1327	AssertMsgFailed(("Invalid state enmState=%d %s\n", enmState, tmTimerState(enmState)));
1328	break;
1329	}
1330	}
1331	# endif /* IN_RING3 */
1332	}
1333	#endif /* !VBOX_STRICT */
1334

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

source: vbox/trunk/src/VBox/VMM/VMMAll/TMAll.cpp@ 4787

Download in other formats: