VirtualBox

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

Last change on this file since 1122 was 1090, checked in by vboxsync, 18 years ago

Corrected assertions for v86 mode

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette