/* $Id$ */
/** @file
* CPU Instruction Decoding & Execution Tests - Ring-3 Driver Application.
*/
/*
* Copyright (C) 2014 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include "cidet.h"
#include <iprt/asm-amd64-x86.h>
#include <iprt/buildconfig.h>
#include <iprt/initterm.h>
#ifdef RT_OS_WINDOWS
# include <Windows.h>
#else
# define USE_SIGNALS
# include <signal.h>
# include <unistd.h>
# include <sys/ucontext.h>
#endif
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/** @def CIDET_LEAVE_GS_ALONE
* Leave GS alone on 64-bit darwin (gs is 0, no ldt or gdt entry to load that'll
* restore the lower 32-bits of the base when saving and restoring the register).
*/
#if defined(RT_OS_DARWIN) && defined(RT_ARCH_AMD64)
# define CIDET_LEAVE_GS_ALONE
#endif
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* CIDET driver app buffer.
*/
typedef struct CIDETAPPBUF
{
/** The buffer size. */
/** The normal allocation.
* There is a fence page before this as well as at pbNormal+cb. */
/** The low memory allocation (32-bit addressable if 64-bit host, 16-bit
* addressable if 32-bit host). */
/** Set if we're using the normal buffer, clear if it's the low one. */
/** Set if the buffer is armed, clear if mostly accessible. */
/** Set if this is a code buffer. */
/** The memory protection for the pages (RTMEM_PROT_XXX). */
/** The memory protection for the last page (RTMEM_PROT_XXX). */
/** The buffer index. */
} CIDETAPPBUF;
/** Pointer to a CIDET driver app buffer. */
/** Number of code buffers. */
/** Number of data buffers. */
/**
* CIDET driver app instance.
*/
typedef struct CIDETAPP
{
/** The core structure. */
/** The execute return context. */
/** Code buffers (runs parallel to g_aCodeBufCfgs). */
/** Data buffers (runs parallel to g_aDataBufCfgs). */
/** The lowest stack address. */
/** The end of the stack allocation (highest address). */
/** Stack size (= pbStackEnd - pbStackLow). */
/** Whether we're currently using the 'lock int3' to deal with tricky stack. */
bool fUsingLockedInt3;
} CIDETAPP;
/** Pointer to a CIDET driver app instance. */
/** Pointer to a pointer to a CIDET driver app instance. */
/*******************************************************************************
* Global Variables *
*******************************************************************************/
/** The test instance handle. */
/** Points to the instance data while executing, NULL if not executing or if
* we've already handled the first exception while executing. */
#ifdef USE_SIGNALS
/** The default signal mask. */
/** The alternative signal stack. */
#endif
/** Code buffer configurations (parallel to CIDETAPP::aCodeBuffers). */
{
{
"Normal",
},
};
/** Data buffer configurations (parallel to CIDETAPP::aDataBuffers). */
{
{
"Normal",
},
};
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
DECLASM(void) CidetAppSaveAndRestoreCtx(void);
/*
*
*
* Exception and signal handling.
* Exception and signal handling.
* Exception and signal handling.
*
*
*/
#ifdef RT_OS_WINDOWS
{
/*
* Grab the this point. We expect at most one signal.
*/
{
/* we're up the infamous creek... */
for (;;) ExitProcess(2);
}
/*
* Gather CPU state information from the context structure.
*/
# ifdef RT_ARCH_AMD64
__debugbreak();
{
/* ... */
}
{
/* ... */
}
# elif defined(RT_ARCH_X86)
__debugbreak();
{
/* ... */
}
{
/* ... */
}
{
/* ... */
}
# else
# error "Not supported"
# endif
/*
*/
{
break;
case EXCEPTION_SINGLE_STEP:
break;
case EXCEPTION_BREAKPOINT:
break;
case EXCEPTION_INT_OVERFLOW:
break;
break;
break;
break;
{
if (VirtualQuery((PVOID)pXcptPtrs->ExceptionRecord->ExceptionInformation[1], &MemInfo, sizeof(MemInfo)) > 0)
{
case PAGE_NOACCESS:
break;
case PAGE_READONLY:
case PAGE_READWRITE:
case PAGE_WRITECOPY:
case PAGE_EXECUTE:
case PAGE_EXECUTE_READ:
case PAGE_EXECUTE_READWRITE:
case PAGE_EXECUTE_WRITECOPY:
break;
default:
}
break;
}
case EXCEPTION_FLT_OVERFLOW:
case EXCEPTION_FLT_UNDERFLOW:
break;
break;
default:
break;
}
/*
* Our own personal long jump implementation.
*/
/* Won't return...*/
return EXCEPTION_EXECUTE_HANDLER;
}
/**
* Vectored exception handler.
*
* @returns Long jumps or terminates the process.
* @param pXcptPtrs The exception record.
*/
{
/* won't get here. */
return EXCEPTION_CONTINUE_SEARCH;
}
/**
* Unhandled exception filter.
*
* @returns Long jumps or terminates the process.
* @param pXcptPtrs The exception record.
*/
{
/* won't get here. */
return EXCEPTION_CONTINUE_SEARCH;
}
#elif defined(USE_SIGNALS)
/**
* Signal handler.
*/
{
# if 1
if ( !g_pExecutingThis
{
if (pSigInfo)
}
# endif
/*
* Grab the this point. We expect at most one signal.
*/
{
/* we're up the infamous creek... */
for (;;) _exit(2);
}
/*
* Gather all the CPU state information available.
*/
# ifdef RT_OS_LINUX
# ifdef RT_ARCH_AMD64
pThis->Core.ActualCtx.aSRegs[X86_SREG_CS] = RT_LO_U16((uint32_t)pCtx->uc_mcontext.gregs[REG_CSGSFS]);
pThis->Core.ActualCtx.aSRegs[X86_SREG_GS] = RT_HI_U16((uint32_t)pCtx->uc_mcontext.gregs[REG_CSGSFS]);
pThis->Core.ActualCtx.aSRegs[X86_SREG_FS] = (uint16_t)RT_HI_U32(pCtx->uc_mcontext.gregs[REG_CSGSFS]);
/* Fudge the FS and GS registers as setup_sigcontext returns 0. */
# elif defined(RT_ARCH_X86)
# else
# error "Unsupported arch."
# endif
/* Adjust uErr. */
{
case X86_XCPT_TS:
case X86_XCPT_NP:
case X86_XCPT_SS:
case X86_XCPT_GP:
case X86_XCPT_PF:
case X86_XCPT_AC:
case X86_XCPT_DF:
break;
default:
break;
}
# if 0
/* Fudge the resume flag (it's probably always set here). */
# endif
# else
/** @todo */
# endif
/*
* Check for the 'lock int3' instruction used for tricky stacks.
*/
if ( pThis->fUsingLockedInt3
{
}
/*
* Jump back to CidetAppCbExecute.
*/
}
#endif
/*
*
* Buffer handling
* Buffer handling
* Buffer handling
*
*
*/
static int cidetAppAllocateAndConfigureOneBuffer(PCIDETAPP pThis, PCIDETAPPBUF pBuf, uint16_t idxBuf, bool fIsCode,
{
{
/* [0] = */ RTMEM_PROT_NONE,
/* [4] = */ RTMEM_PROT_READ,
/* [8] = */ RTMEM_PROT_NONE,
/* [9] = */ RTMEM_PROT_NONE,
/* [10] = */ RTMEM_PROT_NONE,
/* [11] = */ RTMEM_PROT_NONE,
/* [12] = */ RTMEM_PROT_NONE,
/* [13] = */ RTMEM_PROT_NONE,
/* [14] = */ RTMEM_PROT_NONE,
/* [15] = */ RTMEM_PROT_NONE,
};
{
/* [0] = */ RTMEM_PROT_NONE,
/* [4] = */ RTMEM_PROT_READ,
/* [5] = */ RTMEM_PROT_NONE,
/* [7] = */ RTMEM_PROT_READ,
/* [8] = */ RTMEM_PROT_NONE,
/* [9] = */ RTMEM_PROT_NONE,
/* [10] = */ RTMEM_PROT_NONE,
/* [11] = */ RTMEM_PROT_NONE,
/* [12] = */ RTMEM_PROT_NONE,
/* [13] = */ RTMEM_PROT_NONE,
/* [14] = */ RTMEM_PROT_NONE,
/* [15] = */ RTMEM_PROT_NONE,
};
int rc;
pBuf->fUsingNormal = true;
{
/*
* Allocate a 3 page buffer plus two fence pages.
*/
{
/* Set up fence pages. */
if (RT_SUCCESS(rc))
/* Default protection + read + write. */
if (RT_SUCCESS(rc))
rc = RTMemProtect(pBuf->pbNormal, pBuf->cb, pBuf->fDefaultProt | RTMEM_PROT_READ | RTMEM_PROT_WRITE);
/*
* Allocate a low memory buffer or LDT if necessary.
*/
if ( RT_SUCCESS(rc)
{
/** @todo Buffers for the other addressing mode. */
}
else
if (RT_SUCCESS(rc))
return VINF_SUCCESS;
}
else
}
else
rc = RTTestIFailedRc(VERR_NO_PAGE_MEMORY, "Unsupported buffer config: fFlags=%#x, idxBuf=%u", fFlags, idxBuf);
return rc;
}
{
RTMemProtect(pBuf->pbNormal - PAGE_SIZE, PAGE_SIZE + pBuf->cb + PAGE_SIZE, RTMEM_PROT_READ | RTMEM_PROT_WRITE);
{
}
}
{
{
if ((pAppBuf->fDefaultProt & (RTMEM_PROT_READ | RTMEM_PROT_WRITE)) != (RTMEM_PROT_READ | RTMEM_PROT_WRITE))
RTTESTI_CHECK_RC_RET(RTMemProtect(pbUsingBuf, pAppBuf->cb, pAppBuf->fDefaultProt), VINF_SUCCESS, false);
}
else
{
if ((pAppBuf->fDefaultProt & (RTMEM_PROT_READ | RTMEM_PROT_WRITE)) != (RTMEM_PROT_READ | RTMEM_PROT_WRITE))
RTTESTI_CHECK_RC_RET(RTMemProtect(pbUsingBuf, pAppBuf->cb - PAGE_SIZE, pAppBuf->fDefaultProt), VINF_SUCCESS, false);
RTTESTI_CHECK_RC_RET(RTMemProtect(pbUsingBuf + pAppBuf->cb - PAGE_SIZE, PAGE_SIZE, pAppBuf->fLastPageProt),
VINF_SUCCESS, false);
}
return true;
}
{
int rc = RTMemProtect(pbUsingBuf, pAppBuf->cb, pAppBuf->fDefaultProt | RTMEM_PROT_READ | RTMEM_PROT_WRITE);
if (RT_FAILURE(rc))
{
RTTestIFailed("RTMemProtect failed on %s buf #%u: %Rrc", pAppBuf->fIsCode ? "code" : "data", pAppBuf->idxCfg, rc);
return false;
}
return true;
}
/**
* @interface_method_impl{CIDETCORE::pfnReInitDataBuf}
*/
{
/*
* De-arm the buffer.
*/
return false;
/*
* Check the allocation requirements.
*/
{
RTTestIFailed("Buffer too small; off=%#x cb=%#x pAppBuf->cb=%#x (%s)",
return false;
}
/*
* Do we need to use the low buffer? Check that we have one, if we need it.
*/
return false;
/*
* Update the state.
*/
pBuf->cbPrologue = 0;
pBuf->cbEpilogue = 0;
if (fUseNormal)
else
return true;
}
/**
* @interface_method_impl{CIDETCORE::pfnSetupDataBuf}
*/
static DECLCALLBACK(bool) CidetAppCbSetupDataBuf(PCIDETCORE pThis, PCIDETBUF pBuf, void const *pvSrc)
{
/*
* Copy over the data.
*/
/*
* Arm the buffer.
*/
}
/**
* @interface_method_impl{CIDETCORE::pfnIsBufEqual}
*/
static DECLCALLBACK(bool) CidetAppCbIsBufEqual(PCIDETCORE pThis, struct CIDETBUF *pBuf, void const *pvExpected)
{
/*
* Disarm the buffer if we can't read it all.
*/
return false;
/*
* Do the comparing.
*/
{
/** @todo RTMEM_PROT_NONE may kill content on some hosts... */
return false;
}
/** @todo check padding. */
return true;
}
/*
*
* Code buffer, prologue, epilogue, and execution.
* Code buffer, prologue, epilogue, and execution.
* Code buffer, prologue, epilogue, and execution.
*
*
*/
/**
* @interface_method_impl{CIDETCORE::pfnReInitCodeBuf}
*/
{
/*
* De-arm the buffer.
*/
return false;
/*
* Determin the prologue and epilogue sizes.
*/
uint16_t cbPrologue = 0;
cbEpilogue = 16;
/*
* Check the allocation requirements.
*/
{
RTTestIFailed("Buffer too small; off=%#x cb=%#x cbPro=%#x cbEpi=%#x pAppBuf->cb=%#x (%s)",
return false;
}
/*
* Update the state.
*/
pAppBuf->fUsingNormal = true;
return true;
}
/**
* @interface_method_impl{CIDETCORE::pfnSetupCodeBuf}
*/
static DECLCALLBACK(bool) CidetAppCbSetupCodeBuf(PCIDETCORE pThis, PCIDETBUF pBuf, void const *pvInstr)
{
/*
* Emit prologue code.
*/
/*
* Copy over the code.
*/
/*
* Emit epilogue code.
*/
{
/*
* The stack is reasonably good, do minimal work.
*
* Note! Ideally, we would just fill in 16 int3s here and check that
* we hit the first right one. However, if we wish to run this
* code with IEM, we better skip unnecessary trips to ring-0.
*/
/* jmp $+6 */
*pbDst++ = 0xeb;
/* Six int3s for trapping incorrectly decoded instructions. */
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
/* push rip / call $+0 */
*pbDst++ = 0xe8;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
/* push xCX */
*pbDst++ = 0x51;
/* mov xCX, [xSP + xCB] */
*pbDst++ = 0x48;
*pbDst++ = 0x8b;
*pbDst++ = 0x4c;
*pbDst++ = 0x24;
/* lea xCX, [xCX - 24] */
*pbDst++ = 0x48;
*pbDst++ = 0x8d;
*pbDst++ = 0x49;
*pbDst++ = offRipAdjust;
/* mov xCX, [xSP + xCB] */
*pbDst++ = 0x48;
*pbDst++ = 0x89;
*pbDst++ = 0x4c;
*pbDst++ = 0x24;
/* mov xCX, &pThis->ActualCtx */
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0xb9;
/* pop [ss:rcx + ActualCtx.aGRegs[X86_GREG_xCX]] */
*pbDst++ = 0x36;
*pbDst++ = 0x8f;
*pbDst++ = 0x41;
/* mov [ss:rcx + ActualCtx.aGRegs[X86_GREG_xDX]], rdx */
*pbDst++ = 0x36;
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0x89;
*pbDst++ = 0x51;
/* mov [ss:rcx + ActualCtx.aSRegs[X86_GREG_DS]], ds */
*pbDst++ = 0x36;
*pbDst++ = 0x8c;
*pbDst++ = 0x99;
/* mov edx, 0XXYYh */
*pbDst++ = 0xba;
/* mov ds, dx */
*pbDst++ = 0x8e;
*pbDst++ = 0xda;
/* mov xDX, &pThisApp->ExecuteCtx */
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0xba;
#ifdef RT_ARCH_AMD64
/* jmp [cs:$ wrt rip] */
*pbDst++ = 0xff;
*pbDst++ = 0x25;
#else
/* jmp NAME(CidetAppSaveAndRestoreCtx) */
*pbDst++ = 0xb9;
#endif
/* int3 */
*pbDst++ = 0xcc;
pThisApp->fUsingLockedInt3 = false;
}
else
{
/*
* Tricky stack, so just make it raise #UD after a successful run.
*/
pbDst += 15;
pThisApp->fUsingLockedInt3 = true;
}
("cbEpilogue=%#x, actual %#x\n", pBuf->cbEpilogue, pbDst - &pAppBuf->pbNormal[pBuf->offActive + pBuf->cb]));
/*
* Arm the buffer.
*/
}
/**
* @interface_method_impl{CIDETCORE::pfnExecute}
*/
{
#if defined(RT_OS_WINDOWS) || defined(RT_OS_DARWIN)
return false;
#endif
#ifdef RT_OS_WINDOWS
{
}
{
/* Won't end up here... */
}
#else
if (g_pExecutingThis)
else
{
}
#endif
return true;
}
/*
*
*
* CIDET Application.
* CIDET Application.
* CIDET Application.
*
*
*/
/**
* @interface_method_impl{CIDETCORE::pfnSetupBuf}
*/
{
}
{
/*
* Code buffers.
*/
{
g_aCodeBufCfgs[i].fFlags);
if (RT_FAILURE(rc))
return rc;
}
/*
* Data buffers.
*/
{
g_aDataBufCfgs[i].fFlags);
if (RT_FAILURE(rc))
return rc;
}
/*
* Stack.
*/
if (!pThis->pbStackLow)
{
return false;
}
return true;
}
{
if (!pThis)
/* Create a random source. */
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
/* Initialize the CIDET structure. */
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
#if !defined(RT_OS_WINDOWS)
#endif
#if !defined(CIDET_LEAVE_GS_ALONE)
#endif
return VINF_SUCCESS;
}
}
}
else
{
}
}
else
return rc;
}
{
}
static void CidetAppTestBunch(PCIDETAPP pThis, PCCIDETINSTR paInstructions, uint32_t cInstructions, const char *pszBunchName)
{
{
}
}
{
/*
* Initialize the runtime.
*/
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
/*
* Parse arguments.
*/
{
};
int chOpt;
{
switch (chOpt)
{
case 'n':
break;
case 'h':
return RTEXITCODE_SUCCESS;
case 'V':
return RTEXITCODE_SUCCESS;
default:
}
}
#ifdef USE_SIGNALS
/*
* Set up signal handlers with alternate stack.
*/
/* Get the default signal mask. */
g_AltStack.ss_flags = 0;
# ifdef SIGSTKSZ
# else
# endif
#ifdef RT_OS_FREEBSD
#else
#endif
/* Default signal action config. */
/* Hook the signals we might need. */
# ifdef SIGEMT
# endif
#elif defined(RT_OS_WINDOWS)
/*
* Register vectored exception handler and override the default unhandled
* exception filter, just to be on the safe side...
*/
#endif
/*
* Do the work.
*/
if (RT_SUCCESS(rc))
{
}
return RTTestSummaryAndDestroy(g_hTest);
}