← Back to branch summary

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

« back to all changes in this revision

Viewing changes to include/VBox/vmm/cpum.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/vmm/cpum.h
 
1
/** @file
 
2
 * CPUM - CPU Monitor(/ Manager).
 
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_vmm_cpum_h
 
27
#define ___VBox_vmm_cpum_h
 
28
 
 
29
#include <iprt/types.h>
 
30
#include <VBox/x86.h>
 
31
#include <VBox/vmm/cpumctx.h>
 
32
 
 
33
RT_C_DECLS_BEGIN
 
34
 
 
35
/** @defgroup grp_cpum      The CPU Monitor / Manager API
 
36
 * @{
 
37
 */
 
38
 
 
39
/**
 
40
 * CPUID feature to set or clear.
 
41
 */
 
42
typedef enum CPUMCPUIDFEATURE
 
43
{
 
44
    CPUMCPUIDFEATURE_INVALID = 0,
 
45
    /** The APIC feature bit. (Std+Ext) */
 
46
    CPUMCPUIDFEATURE_APIC,
 
47
    /** The sysenter/sysexit feature bit. (Std) */
 
48
    CPUMCPUIDFEATURE_SEP,
 
49
    /** The SYSCALL/SYSEXIT feature bit (64 bits mode only for Intel CPUs). (Ext) */
 
50
    CPUMCPUIDFEATURE_SYSCALL,
 
51
    /** The PAE feature bit. (Std+Ext) */
 
52
    CPUMCPUIDFEATURE_PAE,
 
53
    /** The NXE feature bit. (Ext) */
 
54
    CPUMCPUIDFEATURE_NXE,
 
55
    /** The LAHF/SAHF feature bit (64 bits mode only). (Ext) */
 
56
    CPUMCPUIDFEATURE_LAHF,
 
57
    /** The LONG MODE feature bit. (Ext) */
 
58
    CPUMCPUIDFEATURE_LONG_MODE,
 
59
    /** The PAT feature bit. (Std+Ext) */
 
60
    CPUMCPUIDFEATURE_PAT,
 
61
    /** The x2APIC  feature bit. (Std) */
 
62
    CPUMCPUIDFEATURE_X2APIC,
 
63
    /** The RDTSCP feature bit. (Ext) */
 
64
    CPUMCPUIDFEATURE_RDTSCP,
 
65
    /** 32bit hackishness. */
 
66
    CPUMCPUIDFEATURE_32BIT_HACK = 0x7fffffff
 
67
} CPUMCPUIDFEATURE;
 
68
 
 
69
/**
 
70
 * CPU Vendor.
 
71
 */
 
72
typedef enum CPUMCPUVENDOR
 
73
{
 
74
    CPUMCPUVENDOR_INVALID = 0,
 
75
    CPUMCPUVENDOR_INTEL,
 
76
    CPUMCPUVENDOR_AMD,
 
77
    CPUMCPUVENDOR_VIA,
 
78
    CPUMCPUVENDOR_UNKNOWN,
 
79
    CPUMCPUVENDOR_SYNTHETIC,
 
80
    /** 32bit hackishness. */
 
81
    CPUMCPUVENDOR_32BIT_HACK = 0x7fffffff
 
82
} CPUMCPUVENDOR;
 
83
 
 
84
 
 
85
/** @name Guest Register Getters.
 
86
 * @{ */
 
87
VMMDECL(void)       CPUMGetGuestGDTR(PVMCPU pVCpu, PVBOXGDTR pGDTR);
 
88
VMMDECL(RTGCPTR)    CPUMGetGuestIDTR(PVMCPU pVCpu, uint16_t *pcbLimit);
 
89
VMMDECL(RTSEL)      CPUMGetGuestTR(PVMCPU pVCpu, PCPUMSELREGHID pHidden);
 
90
VMMDECL(RTSEL)      CPUMGetGuestLDTR(PVMCPU pVCpu);
 
91
VMMDECL(uint64_t)   CPUMGetGuestCR0(PVMCPU pVCpu);
 
92
VMMDECL(uint64_t)   CPUMGetGuestCR2(PVMCPU pVCpu);
 
93
VMMDECL(uint64_t)   CPUMGetGuestCR3(PVMCPU pVCpu);
 
94
VMMDECL(uint64_t)   CPUMGetGuestCR4(PVMCPU pVCpu);
 
95
VMMDECL(uint64_t)   CPUMGetGuestCR8(PVMCPU pVCpu);
 
96
VMMDECL(int)        CPUMGetGuestCRx(PVMCPU pVCpu, unsigned iReg, uint64_t *pValue);
 
97
VMMDECL(uint32_t)   CPUMGetGuestEFlags(PVMCPU pVCpu);
 
98
VMMDECL(uint32_t)   CPUMGetGuestEIP(PVMCPU pVCpu);
 
99
VMMDECL(uint64_t)   CPUMGetGuestRIP(PVMCPU pVCpu);
 
100
VMMDECL(uint32_t)   CPUMGetGuestEAX(PVMCPU pVCpu);
 
101
VMMDECL(uint32_t)   CPUMGetGuestEBX(PVMCPU pVCpu);
 
102
VMMDECL(uint32_t)   CPUMGetGuestECX(PVMCPU pVCpu);
 
103
VMMDECL(uint32_t)   CPUMGetGuestEDX(PVMCPU pVCpu);
 
104
VMMDECL(uint32_t)   CPUMGetGuestESI(PVMCPU pVCpu);
 
105
VMMDECL(uint32_t)   CPUMGetGuestEDI(PVMCPU pVCpu);
 
106
VMMDECL(uint32_t)   CPUMGetGuestESP(PVMCPU pVCpu);
 
107
VMMDECL(uint32_t)   CPUMGetGuestEBP(PVMCPU pVCpu);
 
108
VMMDECL(RTSEL)      CPUMGetGuestCS(PVMCPU pVCpu);
 
109
VMMDECL(RTSEL)      CPUMGetGuestDS(PVMCPU pVCpu);
 
110
VMMDECL(RTSEL)      CPUMGetGuestES(PVMCPU pVCpu);
 
111
VMMDECL(RTSEL)      CPUMGetGuestFS(PVMCPU pVCpu);
 
112
VMMDECL(RTSEL)      CPUMGetGuestGS(PVMCPU pVCpu);
 
113
VMMDECL(RTSEL)      CPUMGetGuestSS(PVMCPU pVCpu);
 
114
VMMDECL(uint64_t)   CPUMGetGuestDR0(PVMCPU pVCpu);
 
115
VMMDECL(uint64_t)   CPUMGetGuestDR1(PVMCPU pVCpu);
 
116
VMMDECL(uint64_t)   CPUMGetGuestDR2(PVMCPU pVCpu);
 
117
VMMDECL(uint64_t)   CPUMGetGuestDR3(PVMCPU pVCpu);
 
118
VMMDECL(uint64_t)   CPUMGetGuestDR6(PVMCPU pVCpu);
 
119
VMMDECL(uint64_t)   CPUMGetGuestDR7(PVMCPU pVCpu);
 
120
VMMDECL(int)        CPUMGetGuestDRx(PVMCPU pVCpu, uint32_t iReg, uint64_t *pValue);
 
121
VMMDECL(void)       CPUMGetGuestCpuId(PVMCPU pVCpu, uint32_t iLeaf, uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx);
 
122
VMMDECL(uint32_t)   CPUMGetGuestCpuIdStdMax(PVM pVM);
 
123
VMMDECL(uint32_t)   CPUMGetGuestCpuIdExtMax(PVM pVM);
 
124
VMMDECL(uint32_t)   CPUMGetGuestCpuIdCentaurMax(PVM pVM);
 
125
VMMDECL(uint64_t)   CPUMGetGuestEFER(PVMCPU pVCpu);
 
126
VMMDECL(int)        CPUMQueryGuestMsr(PVMCPU pVCpu, uint32_t idMsr, uint64_t *puValue);
 
127
VMMDECL(int)        CPUMSetGuestMsr(PVMCPU pVCpu, uint32_t idMsr, uint64_t uValue);
 
128
VMMDECL(CPUMCPUVENDOR)  CPUMGetGuestCpuVendor(PVM pVM);
 
129
VMMDECL(CPUMCPUVENDOR)  CPUMGetHostCpuVendor(PVM pVM);
 
130
/** @} */
 
131
 
 
132
/** @name Guest Register Setters.
 
133
 * @{ */
 
134
VMMDECL(int)        CPUMSetGuestGDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
 
135
VMMDECL(int)        CPUMSetGuestIDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
 
136
VMMDECL(int)        CPUMSetGuestTR(PVMCPU pVCpu, uint16_t tr);
 
137
VMMDECL(int)        CPUMSetGuestLDTR(PVMCPU pVCpu, uint16_t ldtr);
 
138
VMMDECL(int)        CPUMSetGuestCR0(PVMCPU pVCpu, uint64_t cr0);
 
139
VMMDECL(int)        CPUMSetGuestCR2(PVMCPU pVCpu, uint64_t cr2);
 
140
VMMDECL(int)        CPUMSetGuestCR3(PVMCPU pVCpu, uint64_t cr3);
 
141
VMMDECL(int)        CPUMSetGuestCR4(PVMCPU pVCpu, uint64_t cr4);
 
142
VMMDECL(int)        CPUMSetGuestDR0(PVMCPU pVCpu, uint64_t uDr0);
 
143
VMMDECL(int)        CPUMSetGuestDR1(PVMCPU pVCpu, uint64_t uDr1);
 
144
VMMDECL(int)        CPUMSetGuestDR2(PVMCPU pVCpu, uint64_t uDr2);
 
145
VMMDECL(int)        CPUMSetGuestDR3(PVMCPU pVCpu, uint64_t uDr3);
 
146
VMMDECL(int)        CPUMSetGuestDR6(PVMCPU pVCpu, uint64_t uDr6);
 
147
VMMDECL(int)        CPUMSetGuestDR7(PVMCPU pVCpu, uint64_t uDr7);
 
148
VMMDECL(int)        CPUMSetGuestDRx(PVMCPU pVCpu, uint32_t iReg, uint64_t Value);
 
149
VMMDECL(int)        CPUMSetGuestEFlags(PVMCPU pVCpu, uint32_t eflags);
 
150
VMMDECL(int)        CPUMSetGuestEIP(PVMCPU pVCpu, uint32_t eip);
 
151
VMMDECL(int)        CPUMSetGuestEAX(PVMCPU pVCpu, uint32_t eax);
 
152
VMMDECL(int)        CPUMSetGuestEBX(PVMCPU pVCpu, uint32_t ebx);
 
153
VMMDECL(int)        CPUMSetGuestECX(PVMCPU pVCpu, uint32_t ecx);
 
154
VMMDECL(int)        CPUMSetGuestEDX(PVMCPU pVCpu, uint32_t edx);
 
155
VMMDECL(int)        CPUMSetGuestESI(PVMCPU pVCpu, uint32_t esi);
 
156
VMMDECL(int)        CPUMSetGuestEDI(PVMCPU pVCpu, uint32_t edi);
 
157
VMMDECL(int)        CPUMSetGuestESP(PVMCPU pVCpu, uint32_t esp);
 
158
VMMDECL(int)        CPUMSetGuestEBP(PVMCPU pVCpu, uint32_t ebp);
 
159
VMMDECL(int)        CPUMSetGuestCS(PVMCPU pVCpu, uint16_t cs);
 
160
VMMDECL(int)        CPUMSetGuestDS(PVMCPU pVCpu, uint16_t ds);
 
161
VMMDECL(int)        CPUMSetGuestES(PVMCPU pVCpu, uint16_t es);
 
162
VMMDECL(int)        CPUMSetGuestFS(PVMCPU pVCpu, uint16_t fs);
 
163
VMMDECL(int)        CPUMSetGuestGS(PVMCPU pVCpu, uint16_t gs);
 
164
VMMDECL(int)        CPUMSetGuestSS(PVMCPU pVCpu, uint16_t ss);
 
165
VMMDECL(void)       CPUMSetGuestEFER(PVMCPU pVCpu, uint64_t val);
 
166
VMMDECL(void)       CPUMSetGuestCpuIdFeature(PVM pVM, CPUMCPUIDFEATURE enmFeature);
 
167
VMMDECL(void)       CPUMClearGuestCpuIdFeature(PVM pVM, CPUMCPUIDFEATURE enmFeature);
 
168
VMMDECL(bool)       CPUMGetGuestCpuIdFeature(PVM pVM, CPUMCPUIDFEATURE enmFeature);
 
169
VMMDECL(void)       CPUMSetGuestCtx(PVMCPU pVCpu, const PCPUMCTX pCtx);
 
170
/** @} */
 
171
 
 
172
 
 
173
/** @name Misc Guest Predicate Functions.
 
174
 * @{  */
 
175
 
 
176
VMMDECL(bool)       CPUMIsGuestIn16BitCode(PVMCPU pVCpu);
 
177
VMMDECL(bool)       CPUMIsGuestIn32BitCode(PVMCPU pVCpu);
 
178
VMMDECL(bool)       CPUMIsGuestNXEnabled(PVMCPU pVCpu);
 
179
VMMDECL(bool)       CPUMIsGuestPageSizeExtEnabled(PVMCPU pVCpu);
 
180
VMMDECL(bool)       CPUMIsGuestPagingEnabled(PVMCPU pVCpu);
 
181
VMMDECL(bool)       CPUMIsGuestR0WriteProtEnabled(PVMCPU pVCpu);
 
182
VMMDECL(bool)       CPUMIsGuestInRealMode(PVMCPU pVCpu);
 
183
VMMDECL(bool)       CPUMIsGuestInProtectedMode(PVMCPU pVCpu);
 
184
VMMDECL(bool)       CPUMIsGuestInPagedProtectedMode(PVMCPU pVCpu);
 
185
VMMDECL(bool)       CPUMIsGuestInLongMode(PVMCPU pVCpu);
 
186
VMMDECL(bool)       CPUMIsGuestInPAEMode(PVMCPU pVCpu);
 
187
 
 
188
#ifndef VBOX_WITHOUT_UNNAMED_UNIONS
 
189
 
 
190
/**
 
191
 * Tests if the guest is running in real mode or not.
 
192
 *
 
193
 * @returns true if in real mode, otherwise false.
 
194
 * @param   pCtx    Current CPU context
 
195
 */
 
196
DECLINLINE(bool)    CPUMIsGuestInRealModeEx(PCPUMCTX pCtx)
 
197
{
 
198
    return !(pCtx->cr0 & X86_CR0_PE);
 
199
}
 
200
 
 
201
/**
 
202
 * Tests if the guest is running in paged protected or not.
 
203
 *
 
204
 * @returns true if in paged protected mode, otherwise false.
 
205
 * @param   pVM     The VM handle.
 
206
 */
 
207
DECLINLINE(bool)    CPUMIsGuestInPagedProtectedModeEx(PCPUMCTX pCtx)
 
208
{
 
209
    return (pCtx->cr0 & (X86_CR0_PE | X86_CR0_PG)) == (X86_CR0_PE | X86_CR0_PG);
 
210
}
 
211
 
 
212
/**
 
213
 * Tests if the guest is running in long mode or not.
 
214
 *
 
215
 * @returns true if in long mode, otherwise false.
 
216
 * @param   pCtx    Current CPU context
 
217
 */
 
218
DECLINLINE(bool)    CPUMIsGuestInLongModeEx(PCPUMCTX pCtx)
 
219
{
 
220
    return (pCtx->msrEFER & MSR_K6_EFER_LMA) == MSR_K6_EFER_LMA;
 
221
}
 
222
 
 
223
/**
 
224
 * Tests if the guest is running in 64 bits mode or not.
 
225
 *
 
226
 * @returns true if in 64 bits protected mode, otherwise false.
 
227
 * @param   pVM     The VM handle.
 
228
 * @param   pCtx    Current CPU context
 
229
 */
 
230
DECLINLINE(bool)    CPUMIsGuestIn64BitCode(PVMCPU pVCpu, PCCPUMCTXCORE pCtx)
 
231
{
 
232
    if (!CPUMIsGuestInLongMode(pVCpu))
 
233
        return false;
 
234
 
 
235
    return pCtx->csHid.Attr.n.u1Long;
 
236
}
 
237
 
 
238
/**
 
239
 * Tests if the guest is running in 64 bits mode or not.
 
240
 *
 
241
 * @returns true if in 64 bits protected mode, otherwise false.
 
242
 * @param   pVM     The VM handle.
 
243
 * @param   pCtx    Current CPU context
 
244
 */
 
245
DECLINLINE(bool)    CPUMIsGuestIn64BitCodeEx(PCCPUMCTX pCtx)
 
246
{
 
247
    if (!(pCtx->msrEFER & MSR_K6_EFER_LMA))
 
248
        return false;
 
249
 
 
250
    return pCtx->csHid.Attr.n.u1Long;
 
251
}
 
252
 
 
253
/**
 
254
 * Tests if the guest is running in PAE mode or not.
 
255
 *
 
256
 * @returns true if in PAE mode, otherwise false.
 
257
 * @param   pCtx    Current CPU context
 
258
 */
 
259
DECLINLINE(bool)    CPUMIsGuestInPAEModeEx(PCPUMCTX pCtx)
 
260
{
 
261
    return (    (pCtx->cr4 & X86_CR4_PAE)
 
262
            &&  CPUMIsGuestInPagedProtectedModeEx(pCtx)
 
263
            &&  !CPUMIsGuestInLongModeEx(pCtx));
 
264
}
 
265
 
 
266
#endif /* VBOX_WITHOUT_UNNAMED_UNIONS */
 
267
 
 
268
/** @} */
 
269
 
 
270
 
 
271
/** @name Hypervisor Register Getters.
 
272
 * @{ */
 
273
VMMDECL(RTSEL)          CPUMGetHyperCS(PVMCPU pVCpu);
 
274
VMMDECL(RTSEL)          CPUMGetHyperDS(PVMCPU pVCpu);
 
275
VMMDECL(RTSEL)          CPUMGetHyperES(PVMCPU pVCpu);
 
276
VMMDECL(RTSEL)          CPUMGetHyperFS(PVMCPU pVCpu);
 
277
VMMDECL(RTSEL)          CPUMGetHyperGS(PVMCPU pVCpu);
 
278
VMMDECL(RTSEL)          CPUMGetHyperSS(PVMCPU pVCpu);
 
279
#if 0 /* these are not correct. */
 
280
VMMDECL(uint32_t)       CPUMGetHyperCR0(PVMCPU pVCpu);
 
281
VMMDECL(uint32_t)       CPUMGetHyperCR2(PVMCPU pVCpu);
 
282
VMMDECL(uint32_t)       CPUMGetHyperCR3(PVMCPU pVCpu);
 
283
VMMDECL(uint32_t)       CPUMGetHyperCR4(PVMCPU pVCpu);
 
284
#endif
 
285
/** This register is only saved on fatal traps. */
 
286
VMMDECL(uint32_t)       CPUMGetHyperEAX(PVMCPU pVCpu);
 
287
VMMDECL(uint32_t)       CPUMGetHyperEBX(PVMCPU pVCpu);
 
288
/** This register is only saved on fatal traps. */
 
289
VMMDECL(uint32_t)       CPUMGetHyperECX(PVMCPU pVCpu);
 
290
/** This register is only saved on fatal traps. */
 
291
VMMDECL(uint32_t)       CPUMGetHyperEDX(PVMCPU pVCpu);
 
292
VMMDECL(uint32_t)       CPUMGetHyperESI(PVMCPU pVCpu);
 
293
VMMDECL(uint32_t)       CPUMGetHyperEDI(PVMCPU pVCpu);
 
294
VMMDECL(uint32_t)       CPUMGetHyperEBP(PVMCPU pVCpu);
 
295
VMMDECL(uint32_t)       CPUMGetHyperESP(PVMCPU pVCpu);
 
296
VMMDECL(uint32_t)       CPUMGetHyperEFlags(PVMCPU pVCpu);
 
297
VMMDECL(uint32_t)       CPUMGetHyperEIP(PVMCPU pVCpu);
 
298
VMMDECL(uint64_t)       CPUMGetHyperRIP(PVMCPU pVCpu);
 
299
VMMDECL(uint32_t)       CPUMGetHyperIDTR(PVMCPU pVCpu, uint16_t *pcbLimit);
 
300
VMMDECL(uint32_t)       CPUMGetHyperGDTR(PVMCPU pVCpu, uint16_t *pcbLimit);
 
301
VMMDECL(RTSEL)          CPUMGetHyperLDTR(PVMCPU pVCpu);
 
302
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR0(PVMCPU pVCpu);
 
303
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR1(PVMCPU pVCpu);
 
304
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR2(PVMCPU pVCpu);
 
305
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR3(PVMCPU pVCpu);
 
306
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR6(PVMCPU pVCpu);
 
307
VMMDECL(RTGCUINTREG)    CPUMGetHyperDR7(PVMCPU pVCpu);
 
308
VMMDECL(void)           CPUMGetHyperCtx(PVMCPU pVCpu, PCPUMCTX pCtx);
 
309
VMMDECL(uint32_t)       CPUMGetHyperCR3(PVMCPU pVCpu);
 
310
/** @} */
 
311
 
 
312
/** @name Hypervisor Register Setters.
 
313
 * @{ */
 
314
VMMDECL(void)           CPUMSetHyperGDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
 
315
VMMDECL(void)           CPUMSetHyperLDTR(PVMCPU pVCpu, RTSEL SelLDTR);
 
316
VMMDECL(void)           CPUMSetHyperIDTR(PVMCPU pVCpu, uint32_t addr, uint16_t limit);
 
317
VMMDECL(void)           CPUMSetHyperCR3(PVMCPU pVCpu, uint32_t cr3);
 
318
VMMDECL(void)           CPUMSetHyperTR(PVMCPU pVCpu, RTSEL SelTR);
 
319
VMMDECL(void)           CPUMSetHyperCS(PVMCPU pVCpu, RTSEL SelCS);
 
320
VMMDECL(void)           CPUMSetHyperDS(PVMCPU pVCpu, RTSEL SelDS);
 
321
VMMDECL(void)           CPUMSetHyperES(PVMCPU pVCpu, RTSEL SelDS);
 
322
VMMDECL(void)           CPUMSetHyperFS(PVMCPU pVCpu, RTSEL SelDS);
 
323
VMMDECL(void)           CPUMSetHyperGS(PVMCPU pVCpu, RTSEL SelDS);
 
324
VMMDECL(void)           CPUMSetHyperSS(PVMCPU pVCpu, RTSEL SelSS);
 
325
VMMDECL(void)           CPUMSetHyperESP(PVMCPU pVCpu, uint32_t u32ESP);
 
326
VMMDECL(int)            CPUMSetHyperEFlags(PVMCPU pVCpu, uint32_t Efl);
 
327
VMMDECL(void)           CPUMSetHyperEIP(PVMCPU pVCpu, uint32_t u32EIP);
 
328
VMMDECL(void)           CPUMSetHyperDR0(PVMCPU pVCpu, RTGCUINTREG uDr0);
 
329
VMMDECL(void)           CPUMSetHyperDR1(PVMCPU pVCpu, RTGCUINTREG uDr1);
 
330
VMMDECL(void)           CPUMSetHyperDR2(PVMCPU pVCpu, RTGCUINTREG uDr2);
 
331
VMMDECL(void)           CPUMSetHyperDR3(PVMCPU pVCpu, RTGCUINTREG uDr3);
 
332
VMMDECL(void)           CPUMSetHyperDR6(PVMCPU pVCpu, RTGCUINTREG uDr6);
 
333
VMMDECL(void)           CPUMSetHyperDR7(PVMCPU pVCpu, RTGCUINTREG uDr7);
 
334
VMMDECL(void)           CPUMSetHyperCtx(PVMCPU pVCpu, const PCPUMCTX pCtx);
 
335
VMMDECL(int)            CPUMRecalcHyperDRx(PVMCPU pVCpu);
 
336
/** @} */
 
337
 
 
338
VMMDECL(void)           CPUMPushHyper(PVMCPU pVCpu, uint32_t u32);
 
339
VMMDECL(void)           CPUMHyperSetCtxCore(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore);
 
340
VMMDECL(int)            CPUMQueryHyperCtxPtr(PVMCPU pVCpu, PCPUMCTX *ppCtx);
 
341
VMMDECL(PCCPUMCTXCORE)  CPUMGetHyperCtxCore(PVMCPU pVCpu);
 
342
VMMDECL(PCPUMCTX)       CPUMQueryGuestCtxPtr(PVMCPU pVCpu);
 
343
VMMDECL(PCCPUMCTXCORE)  CPUMGetGuestCtxCore(PVMCPU pVCpu);
 
344
VMMDECL(void)           CPUMSetGuestCtxCore(PVMCPU pVCpu, PCCPUMCTXCORE pCtxCore);
 
345
VMMR3DECL(int)          CPUMR3RawEnter(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore);
 
346
VMMR3DECL(int)          CPUMR3RawLeave(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, int rc);
 
347
VMMDECL(uint32_t)       CPUMRawGetEFlags(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore);
 
348
VMMDECL(void)           CPUMRawSetEFlags(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, uint32_t eflags);
 
349
VMMDECL(int)            CPUMHandleLazyFPU(PVMCPU pVCpu);
 
350
 
 
351
/** @name Changed flags
 
352
 * These flags are used to keep track of which important register that
 
353
 * have been changed since last they were reset. The only one allowed
 
354
 * to clear them is REM!
 
355
 * @{
 
356
 */
 
357
#define CPUM_CHANGED_FPU_REM                    RT_BIT(0)
 
358
#define CPUM_CHANGED_CR0                        RT_BIT(1)
 
359
#define CPUM_CHANGED_CR4                        RT_BIT(2)
 
360
#define CPUM_CHANGED_GLOBAL_TLB_FLUSH           RT_BIT(3)
 
361
#define CPUM_CHANGED_CR3                        RT_BIT(4)
 
362
#define CPUM_CHANGED_GDTR                       RT_BIT(5)
 
363
#define CPUM_CHANGED_IDTR                       RT_BIT(6)
 
364
#define CPUM_CHANGED_LDTR                       RT_BIT(7)
 
365
#define CPUM_CHANGED_TR                         RT_BIT(8)
 
366
#define CPUM_CHANGED_SYSENTER_MSR               RT_BIT(9)
 
367
#define CPUM_CHANGED_HIDDEN_SEL_REGS            RT_BIT(10)
 
368
#define CPUM_CHANGED_CPUID                      RT_BIT(11)
 
369
#define CPUM_CHANGED_ALL                        \
 
370
    ( CPUM_CHANGED_FPU_REM | CPUM_CHANGED_CR0 | CPUM_CHANGED_CR3 | CPUM_CHANGED_CR4 | CPUM_CHANGED_GDTR | CPUM_CHANGED_IDTR \
 
371
     | CPUM_CHANGED_LDTR | CPUM_CHANGED_TR | CPUM_CHANGED_SYSENTER_MSR | CPUM_CHANGED_HIDDEN_SEL_REGS | CPUM_CHANGED_CPUID )
 
372
/** This one is used by raw-mode to indicate that the hidden register
 
373
 * information is not longer reliable and have to be re-determined.
 
374
 *
 
375
 * @remarks This must not be part of CPUM_CHANGED_ALL! */
 
376
#define CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID    RT_BIT(12)
 
377
/** @} */
 
378
 
 
379
VMMDECL(void)           CPUMSetChangedFlags(PVMCPU pVCpu, uint32_t fChangedFlags);
 
380
VMMR3DECL(uint32_t)     CPUMR3RemEnter(PVMCPU pVCpu, uint32_t *puCpl);
 
381
VMMR3DECL(void)         CPUMR3RemLeave(PVMCPU pVCpu, bool fNoOutOfSyncSels);
 
382
VMMDECL(bool)           CPUMSupportsFXSR(PVM pVM);
 
383
VMMDECL(bool)           CPUMIsHostUsingSysEnter(PVM pVM);
 
384
VMMDECL(bool)           CPUMIsHostUsingSysCall(PVM pVM);
 
385
VMMDECL(bool)           CPUMIsGuestFPUStateActive(PVMCPU pVCPU);
 
386
VMMDECL(void)           CPUMDeactivateGuestFPUState(PVMCPU pVCpu);
 
387
VMMDECL(bool)           CPUMIsGuestDebugStateActive(PVMCPU pVCpu);
 
388
VMMDECL(void)           CPUMDeactivateGuestDebugState(PVMCPU pVCpu);
 
389
VMMDECL(bool)           CPUMIsHyperDebugStateActive(PVMCPU pVCpu);
 
390
VMMDECL(void)           CPUMDeactivateHyperDebugState(PVMCPU pVCpu);
 
391
VMMDECL(uint32_t)       CPUMGetGuestCPL(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore);
 
392
VMMDECL(bool)           CPUMAreHiddenSelRegsValid(PVMCPU pVCpu);
 
393
VMMDECL(CPUMMODE)       CPUMGetGuestMode(PVMCPU pVCpu);
 
394
 
 
395
 
 
396
#ifdef IN_RING3
 
397
/** @defgroup grp_cpum_r3    The CPU Monitor(/Manager) API
 
398
 * @ingroup grp_cpum
 
399
 * @{
 
400
 */
 
401
 
 
402
VMMR3DECL(int)          CPUMR3Init(PVM pVM);
 
403
VMMR3DECL(void)         CPUMR3Relocate(PVM pVM);
 
404
VMMR3DECL(int)          CPUMR3Term(PVM pVM);
 
405
VMMR3DECL(void)         CPUMR3Reset(PVM pVM);
 
406
VMMR3DECL(void)         CPUMR3ResetCpu(PVMCPU pVCpu);
 
407
VMMDECL(bool)           CPUMR3IsStateRestorePending(PVM pVM);
 
408
VMMR3DECL(void)         CPUMR3SetHWVirtEx(PVM pVM, bool fHWVirtExEnabled);
 
409
# ifdef DEBUG
 
410
VMMR3DECL(void)         CPUMR3SaveEntryCtx(PVM pVM);
 
411
# endif
 
412
VMMR3DECL(int)          CPUMR3SetCR4Feature(PVM pVM, RTHCUINTREG fOr, RTHCUINTREG fAnd);
 
413
VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdStdRCPtr(PVM pVM);
 
414
VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdExtRCPtr(PVM pVM);
 
415
VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdCentaurRCPtr(PVM pVM);
 
416
VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdDefRCPtr(PVM pVM);
 
417
 
 
418
/** @} */
 
419
#endif /* IN_RING3 */
 
420
 
 
421
#ifdef IN_RC
 
422
/** @defgroup grp_cpum_gc    The CPU Monitor(/Manager) API
 
423
 * @ingroup grp_cpum
 
424
 * @{
 
425
 */
 
426
 
 
427
/**
 
428
 * Calls a guest trap/interrupt handler directly
 
429
 *
 
430
 * Assumes a trap stack frame has already been setup on the guest's stack!
 
431
 * This function does not return!
 
432
 *
 
433
 * @param   pRegFrame   Original trap/interrupt context
 
434
 * @param   selCS       Code selector of handler
 
435
 * @param   pHandler    GC virtual address of handler
 
436
 * @param   eflags      Callee's EFLAGS
 
437
 * @param   selSS       Stack selector for handler
 
438
 * @param   pEsp        Stack address for handler
 
439
 */
 
440
DECLASM(void)           CPUMGCCallGuestTrapHandler(PCPUMCTXCORE pRegFrame, uint32_t selCS, RTRCPTR pHandler,
 
441
                                                   uint32_t eflags, uint32_t selSS, RTRCPTR pEsp);
 
442
 
 
443
/**
 
444
 * Call guest V86 code directly.
 
445
 *
 
446
 * This function does not return!
 
447
 *
 
448
 * @param   pRegFrame   Original trap/interrupt context
 
449
 */
 
450
DECLASM(void)           CPUMGCCallV86Code(PCPUMCTXCORE pRegFrame);
 
451
 
 
452
/** @} */
 
453
#endif /* IN_RC */
 
454
 
 
455
#ifdef IN_RING0
 
456
/** @defgroup grp_cpum_r0    The CPU Monitor(/Manager) API
 
457
 * @ingroup grp_cpum
 
458
 * @{
 
459
 */
 
460
VMMR0DECL(int)          CPUMR0ModuleInit(void);
 
461
VMMR0DECL(int)          CPUMR0ModuleTerm(void);
 
462
VMMR0DECL(int)          CPUMR0Init(PVM pVM);
 
463
VMMR0DECL(int)          CPUMR0LoadGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
 
464
VMMR0DECL(int)          CPUMR0SaveGuestFPU(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
 
465
VMMR0DECL(int)          CPUMR0SaveGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6);
 
466
VMMR0DECL(int)          CPUMR0LoadGuestDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6);
 
467
VMMR0DECL(int)          CPUMR0LoadHostDebugState(PVM pVM, PVMCPU pVCpu);
 
468
VMMR0DECL(int)          CPUMR0SaveHostDebugState(PVM pVM, PVMCPU pVCpu);
 
469
VMMR0DECL(int)          CPUMR0LoadHyperDebugState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx, bool fDR6);
 
470
#ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
 
471
VMMR0DECL(void)         CPUMR0SetLApic(PVM pVM, RTCPUID idHostCpu);
 
472
#endif
 
473
 
 
474
/** @} */
 
475
#endif /* IN_RING0 */
 
476
 
 
477
/** @} */
 
478
RT_C_DECLS_END
 
479
 
 
480
 
 
481
#endif
 
482