TRPMAll.cpp@ 15420

Last change on this file since 15420 was 13832, checked in by vboxsync, 16 years ago
IN_GC -> IN_RC.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.9 KB

Line
1	/* $Id: TRPMAll.cpp 13832 2008-11-05 02:01:12Z vboxsync $ */
2	/** @file
3	* TRPM - Trap Monitor - Any Context.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_TRPM
27	#include <VBox/trpm.h>
28	#include <VBox/pgm.h>
29	#include <VBox/mm.h>
30	#include <VBox/patm.h>
31	#include <VBox/selm.h>
32	#include <VBox/stam.h>
33	#include "TRPMInternal.h"
34	#include <VBox/vm.h>
35	#include <VBox/err.h>
36	#include <VBox/x86.h>
37	#include <VBox/em.h>
38
39	#include <VBox/log.h>
40	#include <iprt/assert.h>
41	#include <iprt/asm.h>
42	#include <iprt/param.h>
43
44
45
46	/**
47	* Query info about the current active trap/interrupt.
48	* If no trap is active active an error code is returned.
49	*
50	* @returns VBox status code.
51	* @param pVM The virtual machine.
52	* @param pu8TrapNo Where to store the trap number.
53	* @param pEnmType Where to store the trap type
54	*/
55	VMMDECL(int) TRPMQueryTrap(PVM pVM, uint8_t pu8TrapNo, TRPMEVENT pEnmType)
56	{
57	/*
58	* Check if we have a trap at present.
59	*/
60	if (pVM->trpm.s.uActiveVector != ~0U)
61	{
62	if (pu8TrapNo)
63	*pu8TrapNo = (uint8_t)pVM->trpm.s.uActiveVector;
64	if (pEnmType)
65	*pEnmType = pVM->trpm.s.enmActiveType;
66	return VINF_SUCCESS;
67	}
68
69	return VERR_TRPM_NO_ACTIVE_TRAP;
70	}
71
72
73	/**
74	* Gets the trap number for the current trap.
75	*
76	* The caller is responsible for making sure there is an active trap which
77	* takes an error code when making this request.
78	*
79	* @returns The current trap number.
80	* @param pVM VM handle.
81	*/
82	VMMDECL(uint8_t) TRPMGetTrapNo(PVM pVM)
83	{
84	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
85	return (uint8_t)pVM->trpm.s.uActiveVector;
86	}
87
88
89	/**
90	* Gets the error code for the current trap.
91	*
92	* The caller is responsible for making sure there is an active trap which
93	* takes an error code when making this request.
94	*
95	* @returns Error code.
96	* @param pVM VM handle.
97	*/
98	VMMDECL(RTGCUINT) TRPMGetErrorCode(PVM pVM)
99	{
100	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
101	#ifdef VBOX_STRICT
102	switch (pVM->trpm.s.uActiveVector)
103	{
104	case 0x0a:
105	case 0x0b:
106	case 0x0c:
107	case 0x0d:
108	case 0x0e:
109	case 0x11:
110	case 0x08:
111	break;
112	default:
113	AssertMsgFailed(("This trap (%#x) doesn't have any error code\n", pVM->trpm.s.uActiveVector));
114	break;
115	}
116	#endif
117	return pVM->trpm.s.uActiveErrorCode;
118	}
119
120
121	/**
122	* Gets the fault address for the current trap.
123	*
124	* The caller is responsible for making sure there is an active trap 0x0e when
125	* making this request.
126	*
127	* @returns Fault address associated with the trap.
128	* @param pVM VM handle.
129	*/
130	VMMDECL(RTGCUINTPTR) TRPMGetFaultAddress(PVM pVM)
131	{
132	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
133	AssertMsg(pVM->trpm.s.uActiveVector == 0xe, ("Not trap 0e!\n"));
134	return pVM->trpm.s.uActiveCR2;
135	}
136
137
138	/**
139	* Clears the current active trap/exception/interrupt.
140	*
141	* The caller is responsible for making sure there is an active trap
142	* when making this request.
143	*
144	* @returns VBox status code.
145	* @param pVM The virtual machine handle.
146	*/
147	VMMDECL(int) TRPMResetTrap(PVM pVM)
148	{
149	/*
150	* Cannot reset non-existing trap!
151	*/
152	if (pVM->trpm.s.uActiveVector == ~0U)
153	{
154	AssertMsgFailed(("No active trap!\n"));
155	return VERR_TRPM_NO_ACTIVE_TRAP;
156	}
157
158	/*
159	* Reset it.
160	*/
161	pVM->trpm.s.uActiveVector = ~0U;
162	return VINF_SUCCESS;
163	}
164
165
166	/**
167	* Assert trap/exception/interrupt.
168	*
169	* The caller is responsible for making sure there is no active trap
170	* when making this request.
171	*
172	* @returns VBox status code.
173	* @param pVM The virtual machine.
174	* @param u8TrapNo The trap vector to assert.
175	* @param enmType Trap type.
176	*/
177	VMMDECL(int) TRPMAssertTrap(PVM pVM, uint8_t u8TrapNo, TRPMEVENT enmType)
178	{
179	Log2(("TRPMAssertTrap: u8TrapNo=%02x type=%d\n", u8TrapNo, enmType));
180
181	/*
182	* Cannot assert a trap when one is already active.
183	*/
184	if (pVM->trpm.s.uActiveVector != ~0U)
185	{
186	AssertMsgFailed(("Active trap %#x\n", pVM->trpm.s.uActiveVector));
187	return VERR_TRPM_ACTIVE_TRAP;
188	}
189
190	pVM->trpm.s.uActiveVector = u8TrapNo;
191	pVM->trpm.s.enmActiveType = enmType;
192	pVM->trpm.s.uActiveErrorCode = ~0;
193	pVM->trpm.s.uActiveCR2 = 0xdeadface;
194	return VINF_SUCCESS;
195	}
196
197
198	/**
199	* Sets the error code of the current trap.
200	* (This function is for use in trap handlers and such.)
201	*
202	* The caller is responsible for making sure there is an active trap
203	* which takes an errorcode when making this request.
204	*
205	* @param pVM The virtual machine.
206	* @param uErrorCode The new error code.
207	*/
208	VMMDECL(void) TRPMSetErrorCode(PVM pVM, RTGCUINT uErrorCode)
209	{
210	Log2(("TRPMSetErrorCode: uErrorCode=%RGv\n", uErrorCode)); /** @todo RTGCUINT mess! */
211	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
212	pVM->trpm.s.uActiveErrorCode = uErrorCode;
213	#ifdef VBOX_STRICT
214	switch (pVM->trpm.s.uActiveVector)
215	{
216	case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e:
217	AssertMsg(uErrorCode != ~(RTGCUINT)0, ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
218	break;
219	case 0x11: case 0x08:
220	AssertMsg(uErrorCode == 0, ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
221	break;
222	default:
223	AssertMsg(uErrorCode == ~(RTGCUINT)0, ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
224	break;
225	}
226	#endif
227	}
228
229
230	/**
231	* Sets the error code of the current trap.
232	* (This function is for use in trap handlers and such.)
233	*
234	* The caller is responsible for making sure there is an active trap 0e
235	* when making this request.
236	*
237	* @param pVM The virtual machine.
238	* @param uCR2 The new fault address (cr2 register).
239	*/
240	VMMDECL(void) TRPMSetFaultAddress(PVM pVM, RTGCUINTPTR uCR2)
241	{
242	Log2(("TRPMSetFaultAddress: uCR2=%RGv\n", uCR2));
243	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
244	AssertMsg(pVM->trpm.s.uActiveVector == 0xe, ("Not trap 0e!\n"));
245	pVM->trpm.s.uActiveCR2 = uCR2;
246	}
247
248
249	/**
250	* Checks if the current active trap/interrupt/exception/fault/whatever is a software
251	* interrupt or not.
252	*
253	* The caller is responsible for making sure there is an active trap
254	* when making this request.
255	*
256	* @returns true if software interrupt, false if not.
257	*
258	* @param pVM VM handle.
259	*/
260	VMMDECL(bool) TRPMIsSoftwareInterrupt(PVM pVM)
261	{
262	AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
263	return (pVM->trpm.s.enmActiveType == TRPM_SOFTWARE_INT);
264	}
265
266
267	/**
268	* Check if there is an active trap.
269	*
270	* @returns true if trap active, false if not.
271	* @param pVM The virtual machine.
272	*/
273	VMMDECL(bool) TRPMHasTrap(PVM pVM)
274	{
275	return pVM->trpm.s.uActiveVector != ~0U;
276	}
277
278
279	/**
280	* Query all info about the current active trap/interrupt.
281	* If no trap is active active an error code is returned.
282	*
283	* @returns VBox status code.
284	* @param pVM The virtual machine.
285	* @param pu8TrapNo Where to store the trap number.
286	* @param pEnmType Where to store the trap type
287	* @param puErrorCode Where to store the error code associated with some traps.
288	* ~0U is stored if the trap has no error code.
289	* @param puCR2 Where to store the CR2 associated with a trap 0E.
290	*/
291	VMMDECL(int) TRPMQueryTrapAll(PVM pVM, uint8_t pu8TrapNo, TRPMEVENT pEnmType, PRTGCUINT puErrorCode, PRTGCUINTPTR puCR2)
292	{
293	/*
294	* Check if we have a trap at present.
295	*/
296	if (pVM->trpm.s.uActiveVector == ~0U)
297	return VERR_TRPM_NO_ACTIVE_TRAP;
298
299	if (pu8TrapNo)
300	*pu8TrapNo = (uint8_t)pVM->trpm.s.uActiveVector;
301	if (pEnmType)
302	*pEnmType = pVM->trpm.s.enmActiveType;
303	if (puErrorCode)
304	*puErrorCode = pVM->trpm.s.uActiveErrorCode;
305	if (puCR2)
306	*puCR2 = pVM->trpm.s.uActiveCR2;
307
308	return VINF_SUCCESS;
309	}
310
311
312	/**
313	* Save the active trap.
314	*
315	* This routine useful when doing try/catch in the hypervisor.
316	* Any function which uses temporary trap handlers should
317	* probably also use this facility to save the original trap.
318	*
319	* @param pVM VM handle.
320	*/
321	VMMDECL(void) TRPMSaveTrap(PVM pVM)
322	{
323	pVM->trpm.s.uSavedVector = pVM->trpm.s.uActiveVector;
324	pVM->trpm.s.enmSavedType = pVM->trpm.s.enmActiveType;
325	pVM->trpm.s.uSavedErrorCode = pVM->trpm.s.uActiveErrorCode;
326	pVM->trpm.s.uSavedCR2 = pVM->trpm.s.uActiveCR2;
327	}
328
329
330	/**
331	* Restore a saved trap.
332	*
333	* Multiple restores of a saved trap is possible.
334	*
335	* @param pVM VM handle.
336	*/
337	VMMDECL(void) TRPMRestoreTrap(PVM pVM)
338	{
339	pVM->trpm.s.uActiveVector = pVM->trpm.s.uSavedVector;
340	pVM->trpm.s.enmActiveType = pVM->trpm.s.enmSavedType;
341	pVM->trpm.s.uActiveErrorCode = pVM->trpm.s.uSavedErrorCode;
342	pVM->trpm.s.uActiveCR2 = pVM->trpm.s.uSavedCR2;
343	}
344
345
346	#ifndef IN_RING0
347	/**
348	* Forward trap or interrupt to the guest's handler
349	*
350	*
351	* @returns VBox status code.
352	* or does not return at all (when the trap is actually forwarded)
353	*
354	* @param pVM The VM to operate on.
355	* @param pRegFrame Pointer to the register frame for the trap.
356	* @param iGate Trap or interrupt gate number
357	* @param opsize Instruction size (only relevant for software interrupts)
358	* @param enmError TRPM_TRAP_HAS_ERRORCODE or TRPM_TRAP_NO_ERRORCODE.
359	* @param enmType TRPM event type
360	* @param iOrgTrap The original trap.
361	* @internal
362	*/
363	VMMDECL(int) TRPMForwardTrap(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t opsize, TRPMERRORCODE enmError, TRPMEVENT enmType, int32_t iOrgTrap)
364	{
365	#ifdef TRPM_FORWARD_TRAPS_IN_GC
366	X86EFLAGS eflags;
367
368	STAM_PROFILE_ADV_START(&pVM->trpm.s.CTX_SUFF_Z(StatForwardProf), a);
369
370	# if defined(VBOX_STRICT) \|\| defined(LOG_ENABLED)
371	if (pRegFrame->eflags.Bits.u1VM)
372	Log(("TRPMForwardTrap-VM: eip=%04X:%04X iGate=%d\n", pRegFrame->cs, pRegFrame->eip, iGate));
373	else
374	Log(("TRPMForwardTrap: eip=%04X:%08X iGate=%d\n", pRegFrame->cs, pRegFrame->eip, iGate));
375
376	switch (iGate) {
377	case 14:
378	if (pRegFrame->eip == pVM->trpm.s.uActiveCR2)
379	{
380	int rc;
381	RTGCPTR pCallerGC;
382	# ifdef IN_RC
383	rc = MMGCRamRead(pVM, &pCallerGC, (void *)pRegFrame->esp, sizeof(pCallerGC));
384	# else
385	rc = PGMPhysSimpleReadGCPtr(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
386	# endif
387	if (RT_SUCCESS(rc))
388	Log(("TRPMForwardTrap: caller=%RGv\n", pCallerGC));
389	}
390	/* no break */
391	case 8:
392	case 10:
393	case 11:
394	case 12:
395	case 13:
396	case 17:
397	Assert(enmError == TRPM_TRAP_HAS_ERRORCODE \|\| enmType == TRPM_SOFTWARE_INT);
398	break;
399
400	default:
401	Assert(enmError == TRPM_TRAP_NO_ERRORCODE);
402	break;
403	}
404	# endif /* VBOX_STRICT \|\| LOG_ENABLED */
405
406	/* Retrieve the eflags including the virtualized bits. */
407	/* Note: hackish as the cpumctxcore structure doesn't contain the right value */
408	eflags.u32 = CPUMRawGetEFlags(pVM, pRegFrame);
409
410	/* VM_FF_INHIBIT_INTERRUPTS should be cleared upfront or don't call this function at all for dispatching hardware interrupts. */
411	Assert(enmType != TRPM_HARDWARE_INT \|\| !VM_FF_ISSET(pVM, VM_FF_INHIBIT_INTERRUPTS));
412
413	/*
414	* If it's a real guest trap and the guest's page fault handler is marked as safe for GC execution, then we call it directly.
415	* Well, only if the IF flag is set.
416	*/
417	/** @todo if the trap handler was modified and marked invalid, then we should now go back to the host context and install a new patch. */
418	if ( pVM->trpm.s.aGuestTrapHandler[iGate]
419	&& (eflags.Bits.u1IF)
420	#ifndef VBOX_RAW_V86
421	&& !(eflags.Bits.u1VM) /** @todo implement when needed (illegal for same privilege level transfers). */
422	#endif
423	&& !PATMIsPatchGCAddr(pVM, (RTRCPTR)pRegFrame->eip)
424	)
425	{
426	uint16_t cbIDT;
427	RTGCPTR GCPtrIDT = (RTGCPTR)CPUMGetGuestIDTR(pVM, &cbIDT);
428	uint32_t cpl;
429	VBOXIDTE GuestIdte;
430	RTGCPTR pIDTEntry;
431	int rc;
432
433	Assert(PATMAreInterruptsEnabledByCtxCore(pVM, pRegFrame));
434	Assert(!VM_FF_ISPENDING(pVM, VM_FF_SELM_SYNC_GDT \| VM_FF_SELM_SYNC_LDT \| VM_FF_TRPM_SYNC_IDT \| VM_FF_SELM_SYNC_TSS));
435
436	/* Get the current privilege level. */
437	cpl = CPUMGetGuestCPL(pVM, pRegFrame);
438
439	if (GCPtrIDT && iGate * sizeof(VBOXIDTE) >= cbIDT)
440	goto failure;
441
442	/*
443	* BIG TODO: The checks are not complete. see trap and interrupt dispatching section in Intel docs for details
444	* All very obscure, but still necessary.
445	* Currently only some CS & TSS selector checks are missing.
446	*
447	*/
448	pIDTEntry = (RTGCPTR)((RTGCUINTPTR)GCPtrIDT + sizeof(VBOXIDTE) * iGate);
449	#ifdef IN_RC
450	rc = MMGCRamRead(pVM, &GuestIdte, (void *)pIDTEntry, sizeof(GuestIdte));
451	#else
452	rc = PGMPhysSimpleReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
453	#endif
454	if (RT_FAILURE(rc))
455	{
456	/* The page might be out of sync. / /* @todo might cross a page boundary) */
457	Log(("Page %RGv out of sync -> prefetch and try again\n", pIDTEntry));
458	rc = PGMPrefetchPage(pVM, pIDTEntry); /** @todo r=bird: rainy day: this isn't entirely safe because of access bit virtualiziation and CSAM. */
459	if (rc != VINF_SUCCESS)
460	{
461	Log(("TRPMForwardTrap: PGMPrefetchPage failed with rc=%Rrc\n", rc));
462	goto failure;
463	}
464	#ifdef IN_RC
465	rc = MMGCRamRead(pVM, &GuestIdte, (void *)pIDTEntry, sizeof(GuestIdte));
466	#else
467	rc = PGMPhysSimpleReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
468	#endif
469	}
470	if ( RT_SUCCESS(rc)
471	&& GuestIdte.Gen.u1Present
472	&& (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_TRAP_32 \|\| GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
473	&& (GuestIdte.Gen.u2DPL == 3 \|\| GuestIdte.Gen.u2DPL == 0)
474	&& (GuestIdte.Gen.u16SegSel & 0xfffc) /* must not be zero */
475	&& (enmType == TRPM_TRAP \|\| enmType == TRPM_HARDWARE_INT \|\| cpl <= GuestIdte.Gen.u2DPL) /* CPL <= DPL if software int */
476	)
477	{
478	RTGCPTR pHandler, dummy;
479	RTGCPTR pTrapStackGC;
480
481	pHandler = (RTGCPTR)VBOXIDTE_OFFSET(GuestIdte);
482
483	/* Note: SELMValidateAndConvertCSAddr checks for code type, memory type, selector validity. */
484	/** @todo dpl <= cpl else GPF */
485
486	/* Note: don't use current eflags as we might be in V86 mode and the IDT always contains protected mode selectors */
487	X86EFLAGS fakeflags;
488	fakeflags.u32 = 0;
489
490	rc = SELMValidateAndConvertCSAddr(pVM, fakeflags, 0, GuestIdte.Gen.u16SegSel, NULL, pHandler, &dummy);
491	if (rc == VINF_SUCCESS)
492	{
493	VBOXGDTR gdtr = {0};
494	bool fConforming = false;
495	int idx = 0;
496	uint32_t dpl;
497	uint32_t ss_r0;
498	uint32_t esp_r0;
499	X86DESC Desc;
500	RTGCPTR pGdtEntry;
501
502	CPUMGetGuestGDTR(pVM, &gdtr);
503	Assert(gdtr.pGdt && gdtr.cbGdt > GuestIdte.Gen.u16SegSel);
504
505	if (!gdtr.pGdt)
506	goto failure;
507
508	pGdtEntry = (RTGCPTR)(uintptr_t)&((X86DESC *)gdtr.pGdt)[GuestIdte.Gen.u16SegSel >> X86_SEL_SHIFT]; /// @todo fix this
509	#ifdef IN_RC
510	rc = MMGCRamRead(pVM, &Desc, (void *)pGdtEntry, sizeof(Desc));
511	#else
512	rc = PGMPhysSimpleReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
513	#endif
514	if (RT_FAILURE(rc))
515	{
516	/* The page might be out of sync. / /* @todo might cross a page boundary) */
517	Log(("Page %RGv out of sync -> prefetch and try again\n", pGdtEntry));
518	rc = PGMPrefetchPage(pVM, pGdtEntry); /** @todo r=bird: rainy day: this isn't entirely safe because of access bit virtualiziation and CSAM. */
519	if (rc != VINF_SUCCESS)
520	{
521	Log(("PGMPrefetchPage failed with rc=%Rrc\n", rc));
522	goto failure;
523	}
524	#ifdef IN_RC
525	rc = MMGCRamRead(pVM, &Desc, (void *)pGdtEntry, sizeof(Desc));
526	#else
527	rc = PGMPhysSimpleReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
528	#endif
529	if (RT_FAILURE(rc))
530	{
531	Log(("MMGCRamRead failed with %Rrc\n", rc));
532	goto failure;
533	}
534	}
535
536	if (Desc.Gen.u4Type & X86_SEL_TYPE_CONF)
537	{
538	Log(("Conforming code selector\n"));
539	fConforming = true;
540	}
541	/** @todo check descriptor type!! */
542
543	dpl = Desc.Gen.u2Dpl;
544
545	if (!fConforming && dpl < cpl) /* to inner privilege level */
546	{
547	rc = SELMGetRing1Stack(pVM, &ss_r0, &esp_r0);
548	if (RT_FAILURE(rc))
549	goto failure;
550
551	Assert((ss_r0 & X86_SEL_RPL) == 1);
552
553	if ( !esp_r0
554	\|\| !ss_r0
555	\|\| (ss_r0 & X86_SEL_RPL) != ((dpl == 0) ? 1 : dpl)
556	\|\| SELMToFlatBySelEx(pVM, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
557	)
558	{
559	Log(("Invalid ring 0 stack %04X:%08RX32\n", ss_r0, esp_r0));
560	goto failure;
561	}
562	}
563	else
564	if (fConforming \|\| dpl == cpl) /* to the same privilege level */
565	{
566	ss_r0 = pRegFrame->ss;
567	esp_r0 = pRegFrame->esp;
568
569	if ( eflags.Bits.u1VM /* illegal */
570	\|\| SELMToFlatBySelEx(pVM, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
571	{
572	AssertMsgFailed(("Invalid stack %04X:%08RX32??? (VM=%d)\n", ss_r0, esp_r0, eflags.Bits.u1VM));
573	goto failure;
574	}
575	}
576	else
577	{
578	Log(("Invalid cpl-dpl combo %d vs %d\n", cpl, dpl));
579	goto failure;
580	}
581	/*
582	* Build trap stack frame on guest handler's stack
583	*/
584	uint32_t *pTrapStack;
585	#ifdef IN_RC
586	Assert(eflags.Bits.u1VM \|\| (pRegFrame->ss & X86_SEL_RPL) != 0);
587	/* Check maximum amount we need (10 when executing in V86 mode) */
588	rc = PGMVerifyAccess(pVM, (RTGCUINTPTR)pTrapStackGC - 10sizeof(uint32_t), 10 sizeof(uint32_t), X86_PTE_RW);
589	pTrapStack = (uint32_t *)pTrapStackGC;
590	#else
591	Assert(eflags.Bits.u1VM \|\| (pRegFrame->ss & X86_SEL_RPL) == 0 \|\| (pRegFrame->ss & X86_SEL_RPL) == 3);
592	/* Check maximum amount we need (10 when executing in V86 mode) */
593	if ((pTrapStackGC >> PAGE_SHIFT) != ((pTrapStackGC - 10sizeof(uint32_t)) >> PAGE_SHIFT)) / fail if we cross a page boundary */
594	goto failure;
595	PGMPAGEMAPLOCK PageMappingLock;
596	rc = PGMPhysGCPtr2CCPtr(pVM, pTrapStackGC, (void **)&pTrapStack, &PageMappingLock);
597	if (RT_FAILURE(rc))
598	{
599	AssertRC(rc);
600	goto failure;
601	}
602	#endif
603	if (rc == VINF_SUCCESS)
604	{
605	/** if eflags.Bits.u1VM then push gs, fs, ds, es */
606	if (eflags.Bits.u1VM)
607	{
608	Log(("TRAP%02X: (VM) Handler %04X:%RGv Stack %04X:%08X RPL=%d CR2=%08X\n", iGate, GuestIdte.Gen.u16SegSel, pHandler, ss_r0, esp_r0, (pRegFrame->ss & X86_SEL_RPL), pVM->trpm.s.uActiveCR2));
609	pTrapStack[--idx] = pRegFrame->gs;
610	pTrapStack[--idx] = pRegFrame->fs;
611	pTrapStack[--idx] = pRegFrame->ds;
612	pTrapStack[--idx] = pRegFrame->es;
613
614	/* clear ds, es, fs & gs in current context */
615	pRegFrame->ds = pRegFrame->es = pRegFrame->fs = pRegFrame->gs = 0;
616	}
617	else
618	Log(("TRAP%02X: Handler %04X:%RGv Stack %04X:%08X RPL=%d CR2=%08X\n", iGate, GuestIdte.Gen.u16SegSel, pHandler, ss_r0, esp_r0, (pRegFrame->ss & X86_SEL_RPL), pVM->trpm.s.uActiveCR2));
619
620	if (!fConforming && dpl < cpl)
621	{
622	if ((pRegFrame->ss & X86_SEL_RPL) == 1 && !eflags.Bits.u1VM)
623	pTrapStack[--idx] = pRegFrame->ss & ~1; /* Mask away traces of raw ring execution (ring 1). */
624	else
625	pTrapStack[--idx] = pRegFrame->ss;
626
627	pTrapStack[--idx] = pRegFrame->esp;
628	}
629
630	/* Note: We use the eflags copy, that includes the virtualized bits! */
631	/* Note: Not really necessary as we grab include those bits in the trap/irq handler trampoline */
632	pTrapStack[--idx] = eflags.u32;
633
634	if ((pRegFrame->cs & X86_SEL_RPL) == 1 && !eflags.Bits.u1VM)
635	pTrapStack[--idx] = pRegFrame->cs & ~1; /* Mask away traces of raw ring execution (ring 1). */
636	else
637	pTrapStack[--idx] = pRegFrame->cs;
638
639	if (enmType == TRPM_SOFTWARE_INT)
640	{
641	Assert(opsize);
642	pTrapStack[--idx] = pRegFrame->eip + opsize; /* return address = next instruction */
643	}
644	else
645	pTrapStack[--idx] = pRegFrame->eip;
646
647	if (enmError == TRPM_TRAP_HAS_ERRORCODE)
648	{
649	pTrapStack[--idx] = pVM->trpm.s.uActiveErrorCode;
650	}
651
652	Assert(esp_r0 > -idx*sizeof(uint32_t));
653	/* Adjust ESP accordingly */
654	esp_r0 += idx*sizeof(uint32_t);
655
656	/* Mask away dangerous flags for the trap/interrupt handler. */
657	eflags.u32 &= ~(X86_EFL_TF \| X86_EFL_VM \| X86_EFL_RF \| X86_EFL_NT);
658	#ifdef DEBUG
659	for (int j = idx; j < 0; j++)
660	Log4(("Stack %RRv pos %02d: %08x\n", &pTrapStack[j], j, pTrapStack[j]));
661
662	Log4(("eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"
663	"eip=%08x esp=%08x ebp=%08x iopl=%d\n"
664	"cs=%04x ds=%04x es=%04x fs=%04x gs=%04x eflags=%08x\n",
665	pRegFrame->eax, pRegFrame->ebx, pRegFrame->ecx, pRegFrame->edx, pRegFrame->esi, pRegFrame->edi,
666	pRegFrame->eip, pRegFrame->esp, pRegFrame->ebp, eflags.Bits.u2IOPL,
667	(RTSEL)pRegFrame->cs, (RTSEL)pRegFrame->ds, (RTSEL)pRegFrame->es,
668	(RTSEL)pRegFrame->fs, (RTSEL)pRegFrame->gs, eflags.u32));
669	#endif
670
671	Log(("PATM Handler %RRv Adjusted stack %08X new EFLAGS=%08X idx=%d dpl=%d cpl=%d\n", pVM->trpm.s.aGuestTrapHandler[iGate], esp_r0, eflags.u32, idx, dpl, cpl));
672
673	/* Make sure the internal guest context structure is up-to-date. */
674	CPUMSetGuestCR2(pVM, pVM->trpm.s.uActiveCR2);
675
676	#ifdef IN_RC
677	/* Note: shouldn't be necessary */
678	ASMSetCR2(pVM->trpm.s.uActiveCR2);
679
680	/* Turn off interrupts for interrupt gates. */
681	if (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
682	CPUMRawSetEFlags(pVM, pRegFrame, eflags.u32 & ~X86_EFL_IF);
683
684	/* The virtualized bits must be removed again!! */
685	eflags.Bits.u1IF = 1;
686	eflags.Bits.u2IOPL = 0;
687
688	Assert(eflags.Bits.u1IF);
689	Assert(eflags.Bits.u2IOPL == 0);
690	STAM_COUNTER_INC(&pVM->trpm.s.CTX_SUFF(paStatForwardedIRQ)[iGate]);
691	STAM_PROFILE_ADV_STOP(&pVM->trpm.s.CTX_SUFF_Z(StatForwardProf), a);
692	if (iOrgTrap >= 0 && iOrgTrap < (int)RT_ELEMENTS(pVM->trpm.s.aStatGCTraps))
693	STAM_PROFILE_ADV_STOP(&pVM->trpm.s.aStatGCTraps[iOrgTrap], o);
694
695	CPUMGCCallGuestTrapHandler(pRegFrame, GuestIdte.Gen.u16SegSel \| 1, pVM->trpm.s.aGuestTrapHandler[iGate], eflags.u32, ss_r0, (RTRCPTR)esp_r0);
696	/* does not return */
697	#else
698	/* Turn off interrupts for interrupt gates. */
699	if (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
700	eflags.Bits.u1IF = 0;
701
702	pRegFrame->eflags.u32 = eflags.u32;
703
704	pRegFrame->eip = pVM->trpm.s.aGuestTrapHandler[iGate];
705	pRegFrame->cs = GuestIdte.Gen.u16SegSel;
706	pRegFrame->esp = esp_r0;
707	pRegFrame->ss = ss_r0 & ~X86_SEL_RPL; /* set rpl to ring 0 */
708	STAM_PROFILE_ADV_STOP(&pVM->trpm.s.CTX_SUFF_Z(StatForwardProf), a);
709	PGMPhysReleasePageMappingLock(pVM, &PageMappingLock);
710	return VINF_SUCCESS;
711	#endif
712	}
713	else
714	Log(("TRAP%02X: PGMVerifyAccess %RGv failed with %Rrc -> forward to REM\n", iGate, pTrapStackGC, rc));
715	}
716	else
717	Log(("SELMValidateAndConvertCSAddr failed with %Rrc\n", rc));
718	}
719	else
720	Log(("MMRamRead %RGv size %d failed with %Rrc\n", (RTGCUINTPTR)GCPtrIDT + sizeof(VBOXIDTE) * iGate, sizeof(GuestIdte), rc));
721	}
722	else
723	{
724	Log(("Refused to forward trap: eflags=%08x IF=%d\n", eflags.u32, eflags.Bits.u1IF));
725	#ifdef VBOX_WITH_STATISTICS
726	if (pVM->trpm.s.aGuestTrapHandler[iGate] == TRPM_INVALID_HANDLER)
727	STAM_COUNTER_INC(&pVM->trpm.s.StatForwardFailNoHandler);
728	else if (PATMIsPatchGCAddr(pVM, (RTRCPTR)pRegFrame->eip))
729	STAM_COUNTER_INC(&pVM->trpm.s.StatForwardFailPatchAddr);
730	#endif
731	}
732	failure:
733	STAM_COUNTER_INC(&pVM->trpm.s.CTX_SUFF_Z(StatForwardFail));
734	STAM_PROFILE_ADV_STOP(&pVM->trpm.s.CTX_SUFF_Z(StatForwardProf), a);
735
736	Log(("TRAP%02X: forwarding to REM (ss rpl=%d eflags=%08X VMIF=%d handler=%08X\n", iGate, pRegFrame->ss & X86_SEL_RPL, pRegFrame->eflags.u32, PATMAreInterruptsEnabledByCtxCore(pVM, pRegFrame), pVM->trpm.s.aGuestTrapHandler[iGate]));
737	#endif
738	return VINF_EM_RAW_GUEST_TRAP;
739	}
740	#endif /* !IN_RING0 */
741
742
743	/**
744	* Raises a cpu exception which doesn't take an error code.
745	*
746	* This function may or may not dispatch the exception before returning.
747	*
748	* @returns VBox status code fit for scheduling.
749	* @retval VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
750	* @retval VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
751	* @retval VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
752	*
753	* @param pVM The VM handle.
754	* @param pCtxCore The CPU context core.
755	* @param enmXcpt The exception.
756	*/
757	VMMDECL(int) TRPMRaiseXcpt(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt)
758	{
759	LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x\n", pCtxCore->cs, pCtxCore->eip, enmXcpt));
760	/** @todo dispatch the trap. */
761	pVM->trpm.s.uActiveVector = enmXcpt;
762	pVM->trpm.s.enmActiveType = TRPM_TRAP;
763	pVM->trpm.s.uActiveErrorCode = 0xdeadbeef;
764	pVM->trpm.s.uActiveCR2 = 0xdeadface;
765	return VINF_EM_RAW_GUEST_TRAP;
766	}
767
768
769	/**
770	* Raises a cpu exception with an errorcode.
771	*
772	* This function may or may not dispatch the exception before returning.
773	*
774	* @returns VBox status code fit for scheduling.
775	* @retval VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
776	* @retval VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
777	* @retval VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
778	*
779	* @param pVM The VM handle.
780	* @param pCtxCore The CPU context core.
781	* @param enmXcpt The exception.
782	* @param uErr The error code.
783	*/
784	VMMDECL(int) TRPMRaiseXcptErr(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt, uint32_t uErr)
785	{
786	LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x uErr=%RX32\n", pCtxCore->cs, pCtxCore->eip, enmXcpt, uErr));
787	/** @todo dispatch the trap. */
788	pVM->trpm.s.uActiveVector = enmXcpt;
789	pVM->trpm.s.enmActiveType = TRPM_TRAP;
790	pVM->trpm.s.uActiveErrorCode = uErr;
791	pVM->trpm.s.uActiveCR2 = 0xdeadface;
792	return VINF_EM_RAW_GUEST_TRAP;
793	}
794
795
796	/**
797	* Raises a cpu exception with an errorcode and CR2.
798	*
799	* This function may or may not dispatch the exception before returning.
800	*
801	* @returns VBox status code fit for scheduling.
802	* @retval VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
803	* @retval VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
804	* @retval VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
805	*
806	* @param pVM The VM handle.
807	* @param pCtxCore The CPU context core.
808	* @param enmXcpt The exception.
809	* @param uErr The error code.
810	* @param uCR2 The CR2 value.
811	*/
812	VMMDECL(int) TRPMRaiseXcptErrCR2(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt, uint32_t uErr, RTGCUINTPTR uCR2)
813	{
814	LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x uErr=%RX32 uCR2=%RGv\n", pCtxCore->cs, pCtxCore->eip, enmXcpt, uErr, uCR2));
815	/** @todo dispatch the trap. */
816	pVM->trpm.s.uActiveVector = enmXcpt;
817	pVM->trpm.s.enmActiveType = TRPM_TRAP;
818	pVM->trpm.s.uActiveErrorCode = uErr;
819	pVM->trpm.s.uActiveCR2 = uCR2;
820	return VINF_EM_RAW_GUEST_TRAP;
821	}
822
823
824	/**
825	* Clear guest trap/interrupt gate handler
826	*
827	* @returns VBox status code.
828	* @param pVM The VM to operate on.
829	* @param iTrap Interrupt/trap number.
830	*/
831	VMMDECL(int) trpmClearGuestTrapHandler(PVM pVM, unsigned iTrap)
832	{
833	/*
834	* Validate.
835	*/
836	if (iTrap >= RT_ELEMENTS(pVM->trpm.s.aIdt))
837	{
838	AssertMsg(iTrap < TRPM_HANDLER_INT_BASE, ("Illegal gate number %d!\n", iTrap));
839	return VERR_INVALID_PARAMETER;
840	}
841
842	if (ASMBitTest(&pVM->trpm.s.au32IdtPatched[0], iTrap))
843	#ifdef IN_RING3
844	trpmR3ClearPassThroughHandler(pVM, iTrap);
845	#else
846	AssertFailed();
847	#endif
848
849	pVM->trpm.s.aGuestTrapHandler[iTrap] = TRPM_INVALID_HANDLER;
850	return VINF_SUCCESS;
851	}
852

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

source: vbox/trunk/src/VBox/VMM/VMMAll/TRPMAll.cpp@ 15420

Download in other formats: