TRPMAll.cpp@ 4592

Last change on this file since 4592 was 4071, checked in by vboxsync, 18 years ago
Biggest check-in ever. New source code headers for all (C) innotek files.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.6 KB

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

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

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

Download in other formats: