CPUMRC.cpp@ 78177

Last change on this file since 78177 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 10.0 KB

Line
1	/* $Id: CPUMRC.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* CPUM - Raw-mode Context Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 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_CPUM
23	#include <VBox/vmm/cpum.h>
24	#include <VBox/vmm/vmm.h>
25	#include <VBox/vmm/patm.h>
26	#include <VBox/vmm/trpm.h>
27	#include <VBox/vmm/em.h>
28	#include "CPUMInternal.h"
29	#include <VBox/vmm/vm.h>
30	#include <VBox/err.h>
31	#include <iprt/assert.h>
32	#include <VBox/log.h>
33	#include <iprt/asm-amd64-x86.h>
34
35
36	/*********************************************************************************************************************************
37	* Internal Functions *
38	*********************************************************************************************************************************/
39	RT_C_DECLS_BEGIN /* addressed from asm (not called so no DECLASM). */
40	DECLCALLBACK(int) cpumRCHandleNPAndGP(PVM pVM, PCPUMCTXCORE pRegFrame, uintptr_t uUser);
41	RT_C_DECLS_END
42
43
44	/**
45	* Deal with traps occurring during segment loading and IRET when resuming guest
46	* context execution.
47	*
48	* @returns VBox status code.
49	* @param pVM The cross context VM structure.
50	* @param pRegFrame The register frame.
51	* @param uUser User argument. In this case a combination of the
52	* CPUM_HANDLER_* \#defines.
53	*/
54	DECLCALLBACK(int) cpumRCHandleNPAndGP(PVM pVM, PCPUMCTXCORE pRegFrame, uintptr_t uUser)
55	{
56	Log(("********************************************************\n"));
57	Log(("cpumRCHandleNPAndGP: eip=%RX32 uUser=%#x\n", pRegFrame->eip, uUser));
58	Log(("********************************************************\n"));
59
60	/*
61	* Take action based on what's happened.
62	*/
63	switch (uUser & CPUM_HANDLER_TYPEMASK)
64	{
65	case CPUM_HANDLER_GS:
66	case CPUM_HANDLER_DS:
67	case CPUM_HANDLER_ES:
68	case CPUM_HANDLER_FS:
69	TRPMGCHyperReturnToHost(pVM, VINF_EM_RAW_STALE_SELECTOR);
70	break;
71
72	case CPUM_HANDLER_IRET:
73	TRPMGCHyperReturnToHost(pVM, VINF_EM_RAW_IRET_TRAP);
74	break;
75	}
76
77	AssertMsgFailed(("uUser=%#x eip=%#x\n", uUser, pRegFrame->eip)); RT_NOREF_PV(pRegFrame);
78	return VERR_TRPM_DONT_PANIC;
79	}
80
81
82	/**
83	* Called by TRPM and CPUM assembly code to make sure the guest state is
84	* ready for execution.
85	*
86	* @param pVM The cross context VM structure.
87	*/
88	DECLASM(void) CPUMRCAssertPreExecutionSanity(PVM pVM)
89	{
90	#ifdef VBOX_STRICT
91	/*
92	* Check some important assumptions before resuming guest execution.
93	*/
94	PVMCPU pVCpu = VMMGetCpu0(pVM);
95	PCCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
96	uint8_t const uRawCpl = CPUMGetGuestCPL(pVCpu);
97	uint32_t const u32EFlags = CPUMRawGetEFlags(pVCpu);
98	bool const fPatch = PATMIsPatchGCAddr(pVM, pCtx->eip);
99	AssertMsg(pCtx->eflags.Bits.u1IF, ("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
100	AssertMsg(pCtx->eflags.Bits.u2IOPL < RT_MAX(uRawCpl, 1U),
101	("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
102	if (!(u32EFlags & X86_EFL_VM))
103	{
104	AssertMsg((u32EFlags & X86_EFL_IF) \|\| fPatch,("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
105	AssertMsg((pCtx->cs.Sel & X86_SEL_RPL) > 0, ("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
106	AssertMsg((pCtx->ss.Sel & X86_SEL_RPL) > 0, ("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
107	}
108	AssertMsg(CPUMIsGuestInRawMode(pVCpu), ("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
109	//Log2(("cs:eip=%04x:%08x ss:esp=%04x:%08x cpl=%u raw/efl=%#x/%#x%s\n", pCtx->cs.Sel, pCtx->eip, pCtx->ss.Sel, pCtx->esp, uRawCpl, u32EFlags, pCtx->eflags.u, fPatch ? " patch" : ""));
110	#else
111	RT_NOREF_PV(pVM);
112	#endif
113	}
114
115
116	/**
117	* Get the current privilege level of the guest.
118	*
119	* @returns CPL
120	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
121	* @param pRegFrame Pointer to the register frame.
122	*
123	* @todo r=bird: This is very similar to CPUMGetGuestCPL and I cannot quite
124	* see why this variant of the code is necessary.
125	*/
126	VMMDECL(uint32_t) CPUMRCGetGuestCPL(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
127	{
128	/*
129	* CPL can reliably be found in SS.DPL (hidden regs valid) or SS if not.
130	*
131	* Note! We used to check CS.DPL here, assuming it was always equal to
132	* CPL even if a conforming segment was loaded. But this truned out to
133	* only apply to older AMD-V. With VT-x we had an ACP2 regression
134	* during install after a far call to ring 2 with VT-x. Then on newer
135	* AMD-V CPUs we have to move the VMCB.guest.u8CPL into cs.Attr.n.u2Dpl
136	* as well as ss.Attr.n.u2Dpl to make this (and other) code work right.
137	*
138	* So, forget CS.DPL, always use SS.DPL.
139	*
140	* Note! The SS RPL is always equal to the CPL, while the CS RPL
141	* isn't necessarily equal if the segment is conforming.
142	* See section 4.11.1 in the AMD manual.
143	*/
144	uint32_t uCpl;
145	if (!pRegFrame->eflags.Bits.u1VM)
146	{
147	uCpl = (pRegFrame->ss.Sel & X86_SEL_RPL);
148	#ifdef VBOX_WITH_RAW_MODE_NOT_R0
149	# ifdef VBOX_WITH_RAW_RING1
150	if (pVCpu->cpum.s.fRawEntered)
151	{
152	if ( uCpl == 2
153	&& EMIsRawRing1Enabled(pVCpu->CTX_SUFF(pVM)) )
154	uCpl = 1;
155	else if (uCpl == 1)
156	uCpl = 0;
157	}
158	Assert(uCpl != 2); /* ring 2 support not allowed anymore. */
159	# else
160	if (uCpl == 1)
161	uCpl = 0;
162	# endif
163	#endif
164	}
165	else
166	uCpl = 3; /* V86 has CPL=3; REM doesn't set DPL=3 in V8086 mode. See @bugref{5130}. */
167
168	return uCpl;
169	}
170
171
172	#ifdef VBOX_WITH_RAW_RING1
173	/**
174	* Transforms the guest CPU state to raw-ring mode.
175	*
176	* This function will change the any of the cs and ss register with DPL=0 to DPL=1.
177	*
178	* Used by emInterpretIret() after the new state has been loaded.
179	*
180	* @param pVCpu The cross context virtual CPU structure.
181	* @param pCtxCore The context core (for trap usage).
182	* @see @ref pg_raw
183	* @remarks Will be probably obsoleted by #5653 (it will leave and reenter raw
184	* mode instead, I think).
185	*/
186	VMMDECL(void) CPUMRCRecheckRawState(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore)
187	{
188	/*
189	* Are we in Ring-0?
190	*/
191	if ( pCtxCore->ss.Sel
192	&& (pCtxCore->ss.Sel & X86_SEL_RPL) == 0
193	&& !pCtxCore->eflags.Bits.u1VM)
194	{
195	/*
196	* Set CPL to Ring-1.
197	*/
198	pCtxCore->ss.Sel \|= 1;
199	if ( pCtxCore->cs.Sel
200	&& (pCtxCore->cs.Sel & X86_SEL_RPL) == 0)
201	pCtxCore->cs.Sel \|= 1;
202	}
203	else
204	{
205	if ( EMIsRawRing1Enabled(pVCpu->CTX_SUFF(pVM))
206	&& !pCtxCore->eflags.Bits.u1VM
207	&& (pCtxCore->ss.Sel & X86_SEL_RPL) == 1)
208	{
209	/* Set CPL to Ring-2. */
210	pCtxCore->ss.Sel = (pCtxCore->ss.Sel & ~X86_SEL_RPL) \| 2;
211	if (pCtxCore->cs.Sel && (pCtxCore->cs.Sel & X86_SEL_RPL) == 1)
212	pCtxCore->cs.Sel = (pCtxCore->cs.Sel & ~X86_SEL_RPL) \| 2;
213	}
214	}
215
216	/*
217	* Assert sanity.
218	*/
219	AssertMsg((pCtxCore->eflags.u32 & X86_EFL_IF), ("X86_EFL_IF is clear\n"));
220	AssertReleaseMsg(pCtxCore->eflags.Bits.u2IOPL == 0,
221	("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss.Sel & X86_SEL_RPL));
222
223	pCtxCore->eflags.u32 \|= X86_EFL_IF; /* paranoia */
224	}
225	#endif /* VBOX_WITH_RAW_RING1 */
226
227
228	/**
229	* Called by trpmGCExitTrap when VMCPU_FF_CPUM is set (by CPUMRZ.cpp).
230	*
231	* We can be called unecessarily here if we returned to ring-3 for some other
232	* reason before we tried to resume executed guest code. This is detected and
233	* ignored.
234	*
235	* @param pVCpu The cross context CPU structure for the calling EMT.
236	*/
237	VMMRCDECL(void) CPUMRCProcessForceFlag(PVMCPU pVCpu)
238	{
239	/* Only modify CR0 if we're in the post IEM state (host state saved, guest no longer active). */
240	if ((pVCpu->cpum.s.fUseFlags & (CPUM_USED_FPU_GUEST \| CPUM_USED_FPU_HOST)) == CPUM_USED_FPU_HOST)
241	{
242	/*
243	* Doing the same CR0 calculation as in AMD64andLegacy.mac so that we'll
244	* catch guest FPU accesses and load the FPU/SSE/AVX register state as needed.
245	*/
246	uint32_t cr0 = ASMGetCR0();
247	cr0 \|= pVCpu->cpum.s.Guest.cr0 & X86_CR0_EM;
248	cr0 \|= X86_CR0_TS \| X86_CR0_MP;
249	ASMSetCR0(cr0);
250	Log6(("CPUMRCProcessForceFlag: cr0=%#x\n", cr0));
251	}
252	else
253	Log6(("CPUMRCProcessForceFlag: no change - cr0=%#x\n", ASMGetCR0()));
254	}
255

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

source: vbox/trunk/src/VBox/VMM/VMMRC/CPUMRC.cpp@ 78177

Download in other formats: