VMM/VMMAll/TRPMAll.cpp

	TRPMAll.cpp revision d0d3b29a6cb3ab222a2f76e8760f810fe1cea36f
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/* $Id$ */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/** @file
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * TRPM - Trap Monitor - Any Context.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Copyright (C) 2006 InnoTek Systemberatung GmbH
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * available from http://www.virtualbox.org. This file is free software;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * you can redistribute it and/or modify it under the terms of the GNU
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * General Public License as published by the Free Software Foundation,
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * distribution. VirtualBox OSE is distributed in the hope that it will
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * be useful, but WITHOUT ANY WARRANTY of any kind.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * If you received this file as part of a commercial VirtualBox
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * distribution, then only the terms of your commercial VirtualBox
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * license agreement apply instead of the previous paragraph.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/*******************************************************************************
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync*   Header Files                                                               *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync*******************************************************************************/
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#define LOG_GROUP LOG_GROUP_TRPM
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/trpm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/pgm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/mm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/patm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/selm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include "TRPMInternal.h"
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/vm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/err.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/x86.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/em.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <VBox/log.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <iprt/assert.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <iprt/asm.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#include <iprt/param.h>
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Query info about the current active trap/interrupt.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * If no trap is active active an error code is returned.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns VBox status code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM                     The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pu8TrapNo               Where to store the trap number.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pfSoftwareInterrupt     Where to store the software interrupt indicator.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(int)  TRPMQueryTrap(PVM pVM, uint8_t *pu8TrapNo, bool *pfSoftwareInterrupt)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Check if we have a trap at present.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pVM->trpm.s.uActiveVector != ~0U)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (pu8TrapNo)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            *pu8TrapNo = (uint8_t)pVM->trpm.s.uActiveVector;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (pfSoftwareInterrupt)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            *pfSoftwareInterrupt = !!pVM->trpm.s.fActiveSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        return VINF_SUCCESS;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return VERR_TRPM_NO_ACTIVE_TRAP;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Gets the trap number for the current trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap which
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * takes an error code when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns The current trap number.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(uint8_t)  TRPMGetTrapNo(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return (uint8_t)pVM->trpm.s.uActiveVector;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Gets the error code for the current trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap which
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * takes an error code when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns Error code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(RTGCUINT)  TRPMGetErrorCode(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef VBOX_STRICT
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    switch (pVM->trpm.s.uActiveVector)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0a:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0b:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0c:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0d:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0e:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x11:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x08:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        default:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            AssertMsgFailed(("This trap (%#x) doesn't have any error code\n", pVM->trpm.s.uActiveVector));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return pVM->trpm.s.uActiveErrorCode;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Gets the fault address for the current trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap 0x0e when
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns Fault address associated with the trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(RTGCUINTPTR) TRPMGetFaultAddress(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector == 0xe, ("Not trap 0e!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return pVM->trpm.s.uActiveCR2;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Clears the current active trap/exception/interrupt.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns VBox status code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         The virtual machine handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(int) TRPMResetTrap(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Cannot reset non-existing trap!
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pVM->trpm.s.uActiveVector == ~0U)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        AssertMsgFailed(("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        return VERR_TRPM_NO_ACTIVE_TRAP;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Reset it.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveVector = ~0U;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return VINF_SUCCESS;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Assert trap/exception/interrupt.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is no active trap
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns VBox status code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM                 The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   u8TrapNo            The trap vector to assert.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   fSoftwareInterrupt  Indicate if it's a software interrupt or not.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(int)  TRPMAssertTrap(PVM pVM, uint8_t u8TrapNo, bool fSoftwareInterrupt)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    Log2(("TRPMAssertTrap: u8TrapNo=%02x fSoftwareInterrupt=%d\n", u8TrapNo, fSoftwareInterrupt));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Cannot assert a trap when one is already active.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pVM->trpm.s.uActiveVector != ~0U)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        AssertMsgFailed(("Active trap %#x\n", pVM->trpm.s.uActiveVector));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        return VERR_TRPM_ACTIVE_TRAP;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveVector               = u8TrapNo;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.fActiveSoftwareInterrupt    = fSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveErrorCode            = ~0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveCR2                  = 0xdeadface;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return VINF_SUCCESS;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Sets the error code of the current trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * (This function is for use in trap handlers and such.)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * which takes an errorcode when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   uErrorCode  The new error code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(void)  TRPMSetErrorCode(PVM pVM, RTGCUINT uErrorCode)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    Log2(("TRPMSetErrorCode: uErrorCode=%VGv\n", uErrorCode));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveErrorCode = uErrorCode;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef VBOX_STRICT
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    switch (pVM->trpm.s.uActiveVector)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            AssertMsg(uErrorCode != ~(RTGCUINT)0, ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        case 0x11: case 0x08:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            AssertMsg(uErrorCode == 0,              ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        default:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            AssertMsg(uErrorCode == ~(RTGCUINT)0, ("Invalid uErrorCode=%#x u8TrapNo=%d\n", uErrorCode, pVM->trpm.s.uActiveVector));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Sets the error code of the current trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * (This function is for use in trap handlers and such.)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap 0e
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   uCR2        The new fault address (cr2 register).
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(void)  TRPMSetFaultAddress(PVM pVM, RTGCUINTPTR uCR2)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    Log2(("TRPMSetFaultAddress: uCR2=%VGv\n", uCR2));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector == 0xe, ("Not trap 0e!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveCR2 = uCR2;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Checks if the current active trap/interrupt/exception/fault/whatever is a software
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * interrupt or not.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * The caller is responsible for making sure there is an active trap
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * when making this request.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns true if software interrupt, false if not.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(bool) TRPMIsSoftwareInterrupt(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    AssertMsg(pVM->trpm.s.uActiveVector != ~0U, ("No active trap!\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return !!pVM->trpm.s.fActiveSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Check if there is an active trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns true if trap active, false if not.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(bool)  TRPMHasTrap(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return pVM->trpm.s.uActiveVector != ~0U;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Query all info about the current active trap/interrupt.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * If no trap is active active an error code is returned.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns VBox status code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM                     The virtual machine.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pu8TrapNo               Where to store the trap number.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pfSoftwareInterrupt   Where to store the software interrupt indicator.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   puErrorCode             Where to store the error code associated with some traps.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *                                  ~0U is stored if the trap have no error code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   puCR2                   Where to store the CR2 associated with a trap 0E.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(int)  TRPMQueryTrapAll(PVM pVM, uint8_t *pu8TrapNo, bool *pfSoftwareInterrupt, PRTGCUINT puErrorCode, PRTGCUINTPTR puCR2)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Check if we have a trap at present.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pVM->trpm.s.uActiveVector == ~0U)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        return VERR_TRPM_NO_ACTIVE_TRAP;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pu8TrapNo)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        *pu8TrapNo              = (uint8_t)pVM->trpm.s.uActiveVector;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (pfSoftwareInterrupt)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        *pfSoftwareInterrupt    = !!pVM->trpm.s.fActiveSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (puErrorCode)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        *puErrorCode            = pVM->trpm.s.uActiveErrorCode;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (puCR2)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        *puCR2                  = pVM->trpm.s.uActiveCR2;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    return VINF_SUCCESS;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Save the active trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * This routine useful when doing try/catch in the hypervisor.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Any function which uses temporary trap handlers should
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * probably also use this facility to save the original trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM     VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(void) TRPMSaveTrap(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uSavedVector            = pVM->trpm.s.uActiveVector;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.fSavedSoftwareInterrupt = pVM->trpm.s.fActiveSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uSavedErrorCode         = pVM->trpm.s.uActiveErrorCode;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uSavedCR2               = pVM->trpm.s.uActiveCR2;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Restore a saved trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Multiple restores of a saved trap is possible.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM     VM handle.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(void) TRPMRestoreTrap(PVM pVM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveVector            = pVM->trpm.s.uSavedVector;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.fActiveSoftwareInterrupt = pVM->trpm.s.fSavedSoftwareInterrupt;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveErrorCode         = pVM->trpm.s.uSavedErrorCode;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    pVM->trpm.s.uActiveCR2               = pVM->trpm.s.uSavedCR2;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync}
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync/**
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * Forward trap or interrupt to the guest's handler
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @returns VBox status code.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *  or does not return at all (when the trap is actually forwarded)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pVM         The VM to operate on.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   pRegFrame   Pointer to the register frame for the trap.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   iGate       Trap or interrupt gate number
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   opsize      Instruction size (only relevant for software interrupts)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   enmError    TRPM_TRAP_HAS_ERRORCODE or TRPM_TRAP_NO_ERRORCODE.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @param   enmType     TRPM event type
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync * @internal
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsyncTRPMDECL(int) TRPMForwardTrap(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t opsize, TRPMERRORCODE enmError, TRPMEVENT enmType)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync{
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef TRPM_FORWARD_TRAPS_IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    X86EFLAGS eflags;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    STAM_PROFILE_ADV_START(CTXSUFF(&pVM->trpm.s.StatForwardProf), a);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    Log(("TRPMForwardTrap: eip=%VGv iGate=%d\n", pRegFrame->eip, iGate));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef DEBUG
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    switch (iGate) {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 14:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (pRegFrame->eip == pVM->trpm.s.uActiveCR2)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            int rc;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            RTGCPTR pCallerGC;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = MMGCRamRead(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = PGMPhysReadGCPtr(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            if (VBOX_SUCCESS(rc))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                Log(("TRPMForwardTrap: caller=%VGv\n", pCallerGC));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        /* no break */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 8:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 10:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 11:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 12:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 13:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    case 17:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        Assert(enmError == TRPM_TRAP_HAS_ERRORCODE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    default:
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        Assert(enmError == TRPM_TRAP_NO_ERRORCODE);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        break;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif /* DEBUG */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /* Retrieve the eflags including the virtualized bits. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /** @note hackish as the cpumctxcore structure doesn't contain the right value */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    eflags.u32 = CPUMRawGetEFlags(pVM, pRegFrame);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /* VM_FF_INHIBIT_INTERRUPTS should be cleared upfront or don't call this function at all for dispatching hardware interrupts. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    Assert(enmType != TRPM_HARDWARE_INT || !VM_FF_ISSET(pVM, VM_FF_INHIBIT_INTERRUPTS));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * 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.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * Well, only if the IF flag is set.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     * @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.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync     */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    if (    pVM->trpm.s.aGuestTrapHandler[iGate]
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        && (eflags.Bits.u1IF)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifndef VBOX_RAW_V86
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        && !(eflags.Bits.u1VM) /* @todo implement when needed (illegal for same privilege level transfers). */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        && !PATMIsPatchGCAddr(pVM, (RTGCPTR)pRegFrame->eip)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync       )
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        uint16_t    cbIDT;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        RTGCPTR     GCPtrIDT = (RTGCPTR)CPUMGetGuestIDTR(pVM, &cbIDT);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        uint32_t    cpl;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        VBOXIDTE    GuestIdte;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        RTGCPTR     pIDTEntry;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        int         rc;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        Assert(PATMAreInterruptsEnabledByCtxCore(pVM, pRegFrame));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        /* Must get the CPL from the SS selector (CS might be conforming) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (eflags.Bits.u1VM)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            cpl = 3;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if ((pRegFrame->ss & X86_SEL_RPL) == 1)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            cpl = 0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            cpl = (pRegFrame->ss & X86_SEL_RPL);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (GCPtrIDT && iGate * sizeof(VBOXIDTE) >= cbIDT)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        /*
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync         * BIG TODO: The checks are not complete. see trap and interrupt dispatching section in Intel docs for details
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync         *           All very obscure, but still necessary.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync         *           Currently only some CS & TSS selector checks are missing.
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync         *
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync         */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        pIDTEntry = (RTGCPTR)((RTGCUINTPTR)GCPtrIDT + sizeof(VBOXIDTE) * iGate);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        rc = MMGCRamRead(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        rc = PGMPhysReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (VBOX_FAILURE(rc))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            /* The page might be out of sync. (@todo might cross a page boundary) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            Log(("Page %VGv out of sync -> prefetch and try again\n", pIDTEntry));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = PGMPrefetchPage(pVM, pIDTEntry); /** @todo r=bird: rainy day: this isn't entirely safe because of access bit virtualiziation and CSAM. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            if (rc != VINF_SUCCESS)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                Log(("TRPMForwardTrap: PGMPrefetchPage failed with rc=%Vrc\n", rc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = MMGCRamRead(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = PGMPhysReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        if (    VBOX_SUCCESS(rc)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            &&  GuestIdte.Gen.u1Present
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            &&  (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_TRAP_32 || GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            &&  (GuestIdte.Gen.u2DPL == 3 || GuestIdte.Gen.u2DPL == 0)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            &&  (GuestIdte.Gen.u16SegSel & 0xfffc)  /* must not be zero */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            &&  (enmType == TRPM_TRAP || enmType == TRPM_HARDWARE_INT || cpl <= GuestIdte.Gen.u2DPL)  /* CPL <= DPL if software int */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync           )
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync        {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            RTGCPTR   pHandler, dummy;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            GCPTRTYPE(uint32_t *)pTrapStackGC;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifndef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            HCPTRTYPE(uint32_t *)pTrapStackHC;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            pHandler = (RTGCPTR)((GuestIdte.Gen.u16OffsetHigh << 16) | GuestIdte.Gen.u16OffsetLow);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            /* Note: SELMValidateAndConvertCSAddr checks for code type, memory type, selector validity. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            /** @todo dpl <= cpl else GPF */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            rc = SELMValidateAndConvertCSAddr(pVM, 0, GuestIdte.Gen.u16SegSel, NULL, pHandler, &dummy);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            if (rc == VINF_SUCCESS)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync            {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                VBOXGDTR gdtr = {0};
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                bool     fConforming = false;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                int      idx = 0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                uint32_t dpl;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                uint32_t ss_r0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                uint32_t esp_r0;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                VBOXDESC Desc;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                RTGCPTR  pGdtEntry;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                CPUMGetGuestGDTR(pVM, &gdtr);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                Assert(gdtr.pGdt && gdtr.cbGdt > GuestIdte.Gen.u16SegSel);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                if (!gdtr.pGdt)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                pGdtEntry = (RTGCPTR)(uintptr_t)&((VBOXDESC *)gdtr.pGdt)[GuestIdte.Gen.u16SegSel >> X86_SEL_SHIFT]; /// @todo fix this
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                rc = MMGCRamRead(pVM, &Desc, pGdtEntry, sizeof(Desc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                rc = PGMPhysReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                if (VBOX_FAILURE(rc))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    /* The page might be out of sync. (@todo might cross a page boundary) */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    Log(("Page %VGv out of sync -> prefetch and try again\n", pGdtEntry));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    rc = PGMPrefetchPage(pVM, pGdtEntry);  /** @todo r=bird: rainy day: this isn't entirely safe because of access bit virtualiziation and CSAM. */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    if (rc != VINF_SUCCESS)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        Log(("PGMPrefetchPage failed with rc=%Vrc\n", rc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#ifdef IN_GC
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    rc = MMGCRamRead(pVM, &Desc, pGdtEntry, sizeof(Desc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#else
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    rc = PGMPhysReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync#endif
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    if (VBOX_FAILURE(rc))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        Log(("MMGCRamRead failed with %Vrc\n", rc));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                if (Desc.Gen.u4Type & X86_SEL_TYPE_CONF)
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    Log(("Conforming code selector\n"));
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    fConforming = true;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                }
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                /** @todo check descriptor type!! */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                dpl = Desc.Gen.u2Dpl;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                if (!fConforming && dpl < cpl)  /* to inner privilege level */
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                {
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    rc = SELMGetRing1Stack(pVM, &ss_r0, &esp_r0);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    if (VBOX_FAILURE(rc))
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        goto failure;
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    Assert((ss_r0 & X86_SEL_RPL) == 1);
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                    if (   !esp_r0
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        || !ss_r0
4fd606d1f5abe38e1f42c38de1d2e895166bd0f4vboxsync                        || (ss_r0 & X86_SEL_RPL) != ((dpl == 0) ? 1 : dpl)
                        || SELMToFlatEx(pVM, ss_r0, (RTGCPTR)esp_r0, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
                       )
                    {
                        Log(("Invalid ring 0 stack %04X:%VGv\n", ss_r0, esp_r0));
                        goto failure;
                    }
                }
                else
                if (fConforming || dpl == cpl)  /* to the same privilege level */
                {
                    ss_r0  = pRegFrame->ss;
                    esp_r0 = pRegFrame->esp;

                    if (    eflags.Bits.u1VM    /* illegal */
                        ||  SELMToFlatEx(pVM, ss_r0, (RTGCPTR)esp_r0, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
                    {
                        AssertMsgFailed(("Invalid stack %04X:%VGv??? (VM=%d)\n", ss_r0, esp_r0, eflags.Bits.u1VM));
                        goto failure;
                    }
                }
                else
                {
                    Log(("Invalid cpl-dpl combo %d vs %d\n", cpl, dpl));
                    goto failure;
                }
                /*
                 * Build trap stack frame on guest handler's stack
                 */
#ifdef IN_GC
                Assert(eflags.Bits.u1VM || (pRegFrame->ss & X86_SEL_RPL) != 0);
                /* Check maximum amount we need (10 when executing in V86 mode) */
                rc = PGMVerifyAccess(pVM, (RTGCUINTPTR)pTrapStackGC - 10*sizeof(uint32_t), 10 * sizeof(uint32_t), X86_PTE_RW);
#else
                Assert(eflags.Bits.u1VM || (pRegFrame->ss & X86_SEL_RPL) == 0 || (pRegFrame->ss & X86_SEL_RPL) == 3);
                /* Check maximum amount we need (10 when executing in V86 mode) */
                if (    PAGE_ADDRESS(pTrapStackGC) != PAGE_ADDRESS(pTrapStackGC - 10*sizeof(uint32_t)) /* fail if we cross a page boundary */
                    ||  VBOX_FAILURE((rc = PGMPhysGCPtr2HCPtr(pVM, pTrapStackGC, (PRTHCPTR)&pTrapStackHC)))
                   )
                {
                    AssertRC(rc);
                    goto failure;
                }
#endif
                if (rc == VINF_SUCCESS)
                {
                    /** if eflags.Bits.u1VM then push gs, fs, ds, es */
                    if (eflags.Bits.u1VM)
                    {
                        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));
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->gs;
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->fs;
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->ds;
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->es;

                        /* clear ds, es, fs & gs in current context */
                        pRegFrame->ds = pRegFrame->es = pRegFrame->fs = pRegFrame->gs = 0;
                    }
                    else
                        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));

                    if (fConforming == false && dpl < cpl)
                    {
                        if ((pRegFrame->ss & X86_SEL_RPL) == 1 && !eflags.Bits.u1VM)
                            CTXSUFF(pTrapStack)[--idx] = pRegFrame->ss & ~1;    /* Mask away traces of raw ring execution (ring 1). */
                        else
                            CTXSUFF(pTrapStack)[--idx] = pRegFrame->ss;

                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->esp;
                    }

                    /* @note we use the eflags copy, that includes the virtualized bits! */
                    CTXSUFF(pTrapStack)[--idx] = eflags.u32;

                    if ((pRegFrame->cs & X86_SEL_RPL) == 1 && !eflags.Bits.u1VM)
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->cs & ~1;    /* Mask away traces of raw ring execution (ring 1). */
                    else
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->cs;

                    if (enmType == TRPM_SOFTWARE_INT)
                    {
                        Assert(opsize);
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->eip + opsize;    /* return address = next instruction */
                    }
                    else
                        CTXSUFF(pTrapStack)[--idx] = pRegFrame->eip;

                    if (enmError == TRPM_TRAP_HAS_ERRORCODE)
                    {
                        CTXSUFF(pTrapStack)[--idx] = pVM->trpm.s.uActiveErrorCode;
                    }

                    Assert(esp_r0 > -idx*sizeof(uint32_t));
                    /* Adjust ESP accordingly */
                    esp_r0 +=  idx*sizeof(uint32_t);

                    /* Mask away dangerous flags for the trap/interrupt handler. */
                    eflags.u32 &= ~(X86_EFL_TF | X86_EFL_VM | X86_EFL_RF | X86_EFL_NT);
#ifdef DEBUG
                    for (int j=idx;j<0;j++)
                    {
                        LogFlow(("Stack %VGv pos %02d: %08x\n", &CTXSUFF(pTrapStack)[j], j, CTXSUFF(pTrapStack)[j]));
                    }
                    char *pszPrefix = "";
                    char *szEFlags = "";

                    LogFlow((   "%seax=%08x %sebx=%08x %secx=%08x %sedx=%08x %sesi=%08x %sedi=%08x\n"
                            "%seip=%08x %sesp=%08x %sebp=%08x %siopl=%d %*s\n"
                            "%scs=%04x %sds=%04x %ses=%04x %sfs=%04x %sgs=%04x                       %seflags=%08x\n",
                            pszPrefix, pRegFrame->eax, pszPrefix, pRegFrame->ebx, pszPrefix, pRegFrame->ecx, pszPrefix, pRegFrame->edx, pszPrefix, pRegFrame->esi, pszPrefix, pRegFrame->edi,
                            pszPrefix, pRegFrame->eip, pszPrefix, pRegFrame->esp, pszPrefix, pRegFrame->ebp, pszPrefix, eflags.Bits.u2IOPL, *pszPrefix ? 33 : 31, szEFlags,
                            pszPrefix, (RTSEL)pRegFrame->cs, pszPrefix, (RTSEL)pRegFrame->ds, pszPrefix, (RTSEL)pRegFrame->es,
                            pszPrefix, (RTSEL)pRegFrame->fs, pszPrefix, (RTSEL)pRegFrame->gs, pszPrefix, eflags.u32));
#endif

                    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));

                    /* Make sure the internal guest context structure is up-to-date. */
                    CPUMSetGuestCR2(pVM, pVM->trpm.s.uActiveCR2);

#ifdef IN_GC
                    /** @note shouldn't be necessary */
                    ASMSetCR2(pVM->trpm.s.uActiveCR2);

                    /* Turn off interrupts for interrupt gates. */
                    if (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
                        CPUMRawSetEFlags(pVM, pRegFrame, eflags.u32 & ~X86_EFL_IF);

                    /* The virtualized bits must be removed again!! */
                    eflags.Bits.u1IF   = 1;
                    eflags.Bits.u2IOPL = 0;

                    Assert(eflags.Bits.u1IF);
                    Assert(eflags.Bits.u2IOPL == 0);
                    STAM_COUNTER_INC(&pVM->trpm.s.CTXALLSUFF(paStatForwardedIRQ)[iGate]);
                    STAM_PROFILE_ADV_STOP(CTXSUFF(&pVM->trpm.s.StatForwardProf), a);

                    CPUMGCCallGuestTrapHandler(pRegFrame, GuestIdte.Gen.u16SegSel | 1, pVM->trpm.s.aGuestTrapHandler[iGate], eflags.u32, ss_r0, (RTGCPTR)esp_r0);
                    /* does not return */
#else
                    /* Turn off interrupts for interrupt gates. */
                    if (GuestIdte.Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32)
                        eflags.Bits.u1IF = 0;

                    pRegFrame->eflags.u32 = eflags.u32;

                    pRegFrame->eip        = pVM->trpm.s.aGuestTrapHandler[iGate];
                    pRegFrame->cs         = GuestIdte.Gen.u16SegSel;
                    pRegFrame->esp        = esp_r0;
                    pRegFrame->ss         = ss_r0 & ~X86_SEL_RPL;     /* set rpl to ring 0 */
                    STAM_PROFILE_ADV_STOP(CTXSUFF(&pVM->trpm.s.StatForwardProf), a);
                    return VINF_SUCCESS;
#endif
                }
                else
                    Log(("TRAP%02X: PGMVerifyAccess %VGv failed with %Vrc -> forward to REM\n", iGate, pTrapStackGC, rc));
            }
            else
                Log(("SELMValidateAndConvertCSAddr failed with %Vrc\n", rc));
        }
        else
            Log(("MMRamRead %VGv size %d failed with %Vrc\n", (RTGCUINTPTR)GCPtrIDT + sizeof(VBOXIDTE) * iGate, sizeof(GuestIdte), rc));
    }
    else
    {
        Log(("Refused to forward trap: eflags=%08x IF=%d\n", eflags.u32, eflags.Bits.u1IF));
#ifdef VBOX_WITH_STATISTICS
        if (pVM->trpm.s.aGuestTrapHandler[iGate] == TRPM_INVALID_HANDLER)
            STAM_COUNTER_INC(&pVM->trpm.s.StatForwardFailNoHandler);
        else
        if (PATMIsPatchGCAddr(pVM, (RTGCPTR)pRegFrame->eip))
            STAM_COUNTER_INC(&pVM->trpm.s.StatForwardFailPatchAddr);
#endif
    }
failure:
    STAM_COUNTER_INC(&CTXSUFF(pVM->trpm.s.StatForwardFail));
    STAM_PROFILE_ADV_STOP(CTXSUFF(&pVM->trpm.s.StatForwardProf), a);

    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]));
#endif
    return VINF_EM_RAW_GUEST_TRAP;
}


/**
 * Raises a cpu exception which doesn't take an error code.
 *
 * This function may or may not dispatch the exception before returning.
 *
 * @returns VBox status code fit for scheduling.
 * @retval  VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
 * @retval  VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
 * @retval  VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
 *
 * @param   pVM         The VM handle.
 * @param   pCtxCore    The CPU context core.
 * @param   enmXcpt     The exception.
 */
TRPMDECL(int) TRPMRaiseXcpt(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt)
{
    LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x\n", pCtxCore->cs, pCtxCore->eip, enmXcpt));
/** @todo dispatch the trap. */
    pVM->trpm.s.uActiveVector            = enmXcpt;
    pVM->trpm.s.fActiveSoftwareInterrupt = false;
    pVM->trpm.s.uActiveErrorCode         = 0xdeadbeef;
    pVM->trpm.s.uActiveCR2               = 0xdeadface;
    return VINF_EM_RAW_GUEST_TRAP;
}


/**
 * Raises a cpu exception with an errorcode.
 *
 * This function may or may not dispatch the exception before returning.
 *
 * @returns VBox status code fit for scheduling.
 * @retval  VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
 * @retval  VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
 * @retval  VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
 *
 * @param   pVM         The VM handle.
 * @param   pCtxCore    The CPU context core.
 * @param   enmXcpt     The exception.
 * @param   uErr        The error code.
 */
TRPMDECL(int) TRPMRaiseXcptErr(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt, uint32_t uErr)
{
    LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x uErr=%RX32\n", pCtxCore->cs, pCtxCore->eip, enmXcpt, uErr));
/** @todo dispatch the trap. */
    pVM->trpm.s.uActiveVector            = enmXcpt;
    pVM->trpm.s.fActiveSoftwareInterrupt = false;
    pVM->trpm.s.uActiveErrorCode         = uErr;
    pVM->trpm.s.uActiveCR2               = 0xdeadface;
    return VINF_EM_RAW_GUEST_TRAP;
}


/**
 * Raises a cpu exception with an errorcode and CR2.
 *
 * This function may or may not dispatch the exception before returning.
 *
 * @returns VBox status code fit for scheduling.
 * @retval  VINF_EM_RAW_GUEST_TRAP if the exception was left pending.
 * @retval  VINF_TRPM_XCPT_DISPATCHED if the exception was raised and dispatched for raw-mode execution.
 * @retval  VINF_EM_RESCHEDULE_REM if the exception was dispatched and cannot be executed in raw-mode.
 *
 * @param   pVM         The VM handle.
 * @param   pCtxCore    The CPU context core.
 * @param   enmXcpt     The exception.
 * @param   uErr        The error code.
 * @param   uCR2        The CR2 value.
 */
TRPMDECL(int) TRPMRaiseXcptErrCR2(PVM pVM, PCPUMCTXCORE pCtxCore, X86XCPT enmXcpt, uint32_t uErr, RTGCUINTPTR uCR2)
{
    LogFlow(("TRPMRaiseXcptErr: cs:eip=%RTsel:%RX32 enmXcpt=%#x uErr=%RX32 uCR2=%RGv\n", pCtxCore->cs, pCtxCore->eip, enmXcpt, uErr, uCR2));
/** @todo dispatch the trap. */
    pVM->trpm.s.uActiveVector            = enmXcpt;
    pVM->trpm.s.fActiveSoftwareInterrupt = false;
    pVM->trpm.s.uActiveErrorCode         = uErr;
    pVM->trpm.s.uActiveCR2               = uCR2;
    return VINF_EM_RAW_GUEST_TRAP;
}