← Back to branch summary

~ubuntu-branches/ubuntu/raring/virtualbox-ose/raring

« back to all changes in this revision

Viewing changes to include/VBox/tm.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2011-01-30 23:27:25 UTC
  • mfrom: (0.3.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20110130232725-2ouajjd2ggdet0zd
Tags: 4.0.2-dfsg-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Add Apport hook.
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Drop *-source packages.
* Drop ubuntu-01-fix-build-gcc45.patch, fixed upstream.
* Drop ubuntu-02-as-needed.patch, added to the Debian package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/VBox/tm.h
1
 
/** @file
2
 
 * TM - Time Manager. (VMM)
3
 
 */
4
 
 
5
 
/*
6
 
 * Copyright (C) 2006-2010 Oracle Corporation
7
 
 *
8
 
 * This file is part of VirtualBox Open Source Edition (OSE), as
9
 
 * available from http://www.virtualbox.org. This file is free software;
10
 
 * you can redistribute it and/or modify it under the terms of the GNU
11
 
 * General Public License (GPL) as published by the Free Software
12
 
 * Foundation, in version 2 as it comes in the "COPYING" file of the
13
 
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14
 
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15
 
 *
16
 
 * The contents of this file may alternatively be used under the terms
17
 
 * of the Common Development and Distribution License Version 1.0
18
 
 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19
 
 * VirtualBox OSE distribution, in which case the provisions of the
20
 
 * CDDL are applicable instead of those of the GPL.
21
 
 *
22
 
 * You may elect to license modified versions of this file under the
23
 
 * terms and conditions of either the GPL or the CDDL or both.
24
 
 */
25
 
 
26
 
#ifndef ___VBox_tm_h
27
 
#define ___VBox_tm_h
28
 
 
29
 
#include <VBox/cdefs.h>
30
 
#include <VBox/types.h>
31
 
#ifdef IN_RING3
32
 
# include <iprt/time.h>
33
 
#endif
34
 
 
35
 
RT_C_DECLS_BEGIN
36
 
 
37
 
/** @defgroup grp_tm        The Time Manager API
38
 
 * @{
39
 
 */
40
 
 
41
 
/** Enable a timer hack which improves the timer response/resolution a bit. */
42
 
#define VBOX_HIGH_RES_TIMERS_HACK
43
 
 
44
 
 
45
 
/**
46
 
 * Clock type.
47
 
 */
48
 
typedef enum TMCLOCK
49
 
{
50
 
    /** Real host time.
51
 
     * This clock ticks all the time, so use with care. */
52
 
    TMCLOCK_REAL = 0,
53
 
    /** Virtual guest time.
54
 
     * This clock only ticks when the guest is running.  It's implemented
55
 
     * as an offset to monotonic real time (GIP). */
56
 
    TMCLOCK_VIRTUAL,
57
 
    /** Virtual guest synchronized timer time.
58
 
     * This is a special clock and timer queue for synchronizing virtual timers
59
 
     * and virtual time sources.  This clock is trying to keep up with
60
 
     * TMCLOCK_VIRTUAL, but will wait for timers to be executed.  If it lags
61
 
     * too far behind TMCLOCK_VIRTUAL, it will try speed up to close the
62
 
     * distance.
63
 
     * @remarks Do not use this unless you really *must*. */
64
 
    TMCLOCK_VIRTUAL_SYNC,
65
 
    /** Virtual CPU timestamp.
66
 
     * By default this is a function of TMCLOCK_VIRTUAL_SYNC and the virtual
67
 
     * CPU frequency. */
68
 
    TMCLOCK_TSC,
69
 
    /** Number of clocks. */
70
 
    TMCLOCK_MAX
71
 
} TMCLOCK;
72
 
 
73
 
 
74
 
/** @defgroup grp_tm_timer_flags Timer flags.
75
 
 * @{ */
76
 
/** Use the default critical section for the class of timers. */
77
 
#define TMTIMER_FLAGS_DEFAULT_CRIT_SECT 0
78
 
/** No critical section needed or a custom one is set using
79
 
 *  TMR3TimerSetCritSect(). */
80
 
#define TMTIMER_FLAGS_NO_CRIT_SECT      RT_BIT_32(0)
81
 
/** @} */
82
 
 
83
 
 
84
 
VMMDECL(void)           TMNotifyStartOfExecution(PVMCPU pVCpu);
85
 
VMMDECL(void)           TMNotifyEndOfExecution(PVMCPU pVCpu);
86
 
VMM_INT_DECL(void)      TMNotifyStartOfHalt(PVMCPU pVCpu);
87
 
VMM_INT_DECL(void)      TMNotifyEndOfHalt(PVMCPU pVCpu);
88
 
#ifdef IN_RING3
89
 
VMMR3DECL(int)          TMR3NotifySuspend(PVM pVM, PVMCPU pVCpu);
90
 
VMMR3DECL(int)          TMR3NotifyResume(PVM pVM, PVMCPU pVCpu);
91
 
VMMR3DECL(int)          TMR3SetWarpDrive(PVM pVM, uint32_t u32Percent);
92
 
#endif
93
 
VMMDECL(uint32_t)       TMGetWarpDrive(PVM pVM);
94
 
 
95
 
 
96
 
/** @name Real Clock Methods
97
 
 * @{
98
 
 */
99
 
VMM_INT_DECL(uint64_t)  TMRealGet(PVM pVM);
100
 
VMM_INT_DECL(uint64_t)  TMRealGetFreq(PVM pVM);
101
 
/** @} */
102
 
 
103
 
 
104
 
/** @name Virtual Clock Methods
105
 
 * @{
106
 
 */
107
 
VMM_INT_DECL(uint64_t)  TMVirtualGet(PVM pVM);
108
 
VMM_INT_DECL(uint64_t)  TMVirtualGetNoCheck(PVM pVM);
109
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGetLag(PVM pVM);
110
 
VMM_INT_DECL(uint32_t)  TMVirtualSyncGetCatchUpPct(PVM pVM);
111
 
VMM_INT_DECL(uint64_t)  TMVirtualGetFreq(PVM pVM);
112
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGet(PVM pVM);
113
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGetNoCheck(PVM pVM);
114
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGetEx(PVM pVM, bool fCheckTimers);
115
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGetWithDeadlineNoCheck(PVM pVM, uint64_t *pcNsToDeadline);
116
 
VMM_INT_DECL(uint64_t)  TMVirtualSyncGetNsToDeadline(PVM pVM);
117
 
VMM_INT_DECL(uint64_t)  TMVirtualToNano(PVM pVM, uint64_t u64VirtualTicks);
118
 
VMM_INT_DECL(uint64_t)  TMVirtualToMicro(PVM pVM, uint64_t u64VirtualTicks);
119
 
VMM_INT_DECL(uint64_t)  TMVirtualToMilli(PVM pVM, uint64_t u64VirtualTicks);
120
 
VMM_INT_DECL(uint64_t)  TMVirtualFromNano(PVM pVM, uint64_t u64NanoTS);
121
 
VMM_INT_DECL(uint64_t)  TMVirtualFromMicro(PVM pVM, uint64_t u64MicroTS);
122
 
VMM_INT_DECL(uint64_t)  TMVirtualFromMilli(PVM pVM, uint64_t u64MilliTS);
123
 
/** @} */
124
 
 
125
 
 
126
 
/** @name CPU Clock Methods
127
 
 * @{
128
 
 */
129
 
VMMDECL(uint64_t)       TMCpuTickGet(PVMCPU pVCpu);
130
 
VMM_INT_DECL(uint64_t)  TMCpuTickGetNoCheck(PVMCPU pVCpu);
131
 
VMM_INT_DECL(bool)      TMCpuTickCanUseRealTSC(PVMCPU pVCpu, uint64_t *poffRealTSC);
132
 
VMM_INT_DECL(uint64_t)  TMCpuTickGetDeadlineAndTscOffset(PVMCPU pVCpu, bool *pfOffsettedTsc, uint64_t *poffRealTSC);
133
 
VMM_INT_DECL(int)       TMCpuTickSet(PVM pVM, PVMCPU pVCpu, uint64_t u64Tick);
134
 
VMM_INT_DECL(int)       TMCpuTickSetLastSeen(PVMCPU pVCpu, uint64_t u64LastSeenTick);
135
 
VMM_INT_DECL(uint64_t)  TMCpuTickGetLastSeen(PVMCPU pVCpu);
136
 
VMMDECL(uint64_t)       TMCpuTicksPerSecond(PVM pVM);
137
 
/** @} */
138
 
 
139
 
 
140
 
/** @name Timer Methods
141
 
 * @{
142
 
 */
143
 
/**
144
 
 * Device timer callback function.
145
 
 *
146
 
 * @param   pDevIns         Device instance of the device which registered the timer.
147
 
 * @param   pTimer          The timer handle.
148
 
 * @param   pvUser          User argument specified upon timer creation.
149
 
 */
150
 
typedef DECLCALLBACK(void) FNTMTIMERDEV(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
151
 
/** Pointer to a device timer callback function. */
152
 
typedef FNTMTIMERDEV *PFNTMTIMERDEV;
153
 
 
154
 
/**
155
 
 * Device timer callback function.
156
 
 *
157
 
 * @param   pUsbIns         The USB device instance the timer is associated
158
 
 *                          with.
159
 
 * @param   pTimer          The timer handle.
160
 
 * @param   pvUser          User argument specified upon timer creation.
161
 
 */
162
 
typedef DECLCALLBACK(void) FNTMTIMERUSB(PPDMUSBINS pUsbIns, PTMTIMER pTimer, void *pvUser);
163
 
/** Pointer to a timer callback for a USB device. */
164
 
typedef FNTMTIMERUSB *PFNTMTIMERUSB;
165
 
 
166
 
/**
167
 
 * Driver timer callback function.
168
 
 *
169
 
 * @param   pDrvIns         Device instance of the device which registered the timer.
170
 
 * @param   pTimer          The timer handle.
171
 
 * @param   pvUser          User argument specified upon timer creation.
172
 
 */
173
 
typedef DECLCALLBACK(void) FNTMTIMERDRV(PPDMDRVINS pDrvIns, PTMTIMER pTimer, void *pvUser);
174
 
/** Pointer to a driver timer callback function. */
175
 
typedef FNTMTIMERDRV *PFNTMTIMERDRV;
176
 
 
177
 
/**
178
 
 * Service timer callback function.
179
 
 *
180
 
 * @param   pSrvIns         Service instance of the device which registered the timer.
181
 
 * @param   pTimer          The timer handle.
182
 
 */
183
 
typedef DECLCALLBACK(void) FNTMTIMERSRV(PPDMSRVINS pSrvIns, PTMTIMER pTimer);
184
 
/** Pointer to a service timer callback function. */
185
 
typedef FNTMTIMERSRV *PFNTMTIMERSRV;
186
 
 
187
 
/**
188
 
 * Internal timer callback function.
189
 
 *
190
 
 * @param   pVM             The VM.
191
 
 * @param   pTimer          The timer handle.
192
 
 * @param   pvUser          User argument specified upon timer creation.
193
 
 */
194
 
typedef DECLCALLBACK(void) FNTMTIMERINT(PVM pVM, PTMTIMER pTimer, void *pvUser);
195
 
/** Pointer to internal timer callback function. */
196
 
typedef FNTMTIMERINT *PFNTMTIMERINT;
197
 
 
198
 
/**
199
 
 * External timer callback function.
200
 
 *
201
 
 * @param   pvUser          User argument as specified when the timer was created.
202
 
 */
203
 
typedef DECLCALLBACK(void) FNTMTIMEREXT(void *pvUser);
204
 
/** Pointer to an external timer callback function. */
205
 
typedef FNTMTIMEREXT *PFNTMTIMEREXT;
206
 
 
207
 
VMMDECL(PTMTIMERR3)     TMTimerR3Ptr(PTMTIMER pTimer);
208
 
VMMDECL(PTMTIMERR0)     TMTimerR0Ptr(PTMTIMER pTimer);
209
 
VMMDECL(PTMTIMERRC)     TMTimerRCPtr(PTMTIMER pTimer);
210
 
VMMDECL(int)            TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire);
211
 
VMMDECL(int)            TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now);
212
 
VMMDECL(int)            TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext);
213
 
VMMDECL(int)            TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext);
214
 
VMMDECL(int)            TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext);
215
 
VMMDECL(uint64_t)       TMTimerGet(PTMTIMER pTimer);
216
 
VMMDECL(uint64_t)       TMTimerGetNano(PTMTIMER pTimer);
217
 
VMMDECL(uint64_t)       TMTimerGetMicro(PTMTIMER pTimer);
218
 
VMMDECL(uint64_t)       TMTimerGetMilli(PTMTIMER pTimer);
219
 
VMMDECL(uint64_t)       TMTimerGetFreq(PTMTIMER pTimer);
220
 
VMMDECL(uint64_t)       TMTimerGetExpire(PTMTIMER pTimer);
221
 
VMMDECL(uint64_t)       TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks);
222
 
VMMDECL(uint64_t)       TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks);
223
 
VMMDECL(uint64_t)       TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks);
224
 
VMMDECL(uint64_t)       TMTimerFromNano(PTMTIMER pTimer, uint64_t u64NanoTS);
225
 
VMMDECL(uint64_t)       TMTimerFromMicro(PTMTIMER pTimer, uint64_t u64MicroTS);
226
 
VMMDECL(uint64_t)       TMTimerFromMilli(PTMTIMER pTimer, uint64_t u64MilliTS);
227
 
VMMDECL(int)            TMTimerStop(PTMTIMER pTimer);
228
 
VMMDECL(bool)           TMTimerIsActive(PTMTIMER pTimer);
229
 
VMMDECL(bool)           TMTimerPollBool(PVM pVM, PVMCPU pVCpu);
230
 
VMM_INT_DECL(void)      TMTimerPollVoid(PVM pVM, PVMCPU pVCpu);
231
 
VMM_INT_DECL(uint64_t)  TMTimerPollGIP(PVM pVM, PVMCPU pVCpu, uint64_t *pu64Delta);
232
 
 
233
 
/** @} */
234
 
 
235
 
 
236
 
#ifdef IN_RING3
237
 
/** @defgroup grp_tm_r3     The TM Host Context Ring-3 API
238
 
 * @ingroup grp_tm
239
 
 * @{
240
 
 */
241
 
VMM_INT_DECL(int)       TMR3Init(PVM pVM);
242
 
VMM_INT_DECL(int)       TMR3InitCPU(PVM pVM);
243
 
VMM_INT_DECL(int)       TMR3InitFinalize(PVM pVM);
244
 
VMM_INT_DECL(void)      TMR3Relocate(PVM pVM, RTGCINTPTR offDelta);
245
 
VMM_INT_DECL(int)       TMR3Term(PVM pVM);
246
 
VMM_INT_DECL(int)       TMR3TermCPU(PVM pVM);
247
 
VMM_INT_DECL(void)      TMR3Reset(PVM pVM);
248
 
VMM_INT_DECL(int)       TMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue);
249
 
VMM_INT_DECL(int)       TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer);
250
 
VMM_INT_DECL(int)       TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer);
251
 
VMMR3DECL(int)          TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERR3 ppTimer);
252
 
VMMR3DECL(PTMTIMERR3)   TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc);
253
 
VMMR3DECL(int)          TMR3TimerDestroy(PTMTIMER pTimer);
254
 
VMM_INT_DECL(int)       TMR3TimerDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
255
 
VMM_INT_DECL(int)       TMR3TimerDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
256
 
VMMR3DECL(int)          TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM);
257
 
VMMR3DECL(int)          TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM);
258
 
VMMR3DECL(int)          TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect);
259
 
VMMR3DECL(void)         TMR3TimerQueuesDo(PVM pVM);
260
 
VMM_INT_DECL(void)      TMR3VirtualSyncFF(PVM pVM, PVMCPU pVCpu);
261
 
VMM_INT_DECL(PRTTIMESPEC) TMR3UtcNow(PVM pVM, PRTTIMESPEC pTime);
262
 
/** @} */
263
 
#endif /* IN_RING3 */
264
 
 
265
 
 
266
 
/** @} */
267
 
 
268
 
RT_C_DECLS_END
269
 
 
270
 
#endif
271