IOMAllMMIO.cpp revision a82df5167acec0c75d741d08c1d05a4007e3d50e
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * IOM - Input / Output Monitor - Guest Context.
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * Copyright (C) 2006-2007 innotek GmbH
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * available from http://www.virtualbox.org. This file is free software;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * General Public License as published by the Free Software Foundation,
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * distribution. VirtualBox OSE is distributed in the hope that it will
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * be useful, but WITHOUT ANY WARRANTY of any kind.
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * If you received this file as part of a commercial VirtualBox
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * distribution, then only the terms of your commercial VirtualBox
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * license agreement apply instead of the previous paragraph.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Header Files *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Internal Functions *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t u32Data);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Global Variables *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Array for accessing 32-bit general registers in VMMREGFRAME structure
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * by register's index from disasm.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic unsigned g_aReg32Index[] =
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Macro for accessing 32-bit general purpose registers in CPUMCTXCORE structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ACCESS_REG32(p, idx) (*((uint32_t *)((char *)(p) + g_aReg32Index[idx])))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Array for accessing 16-bit general registers in CPUMCTXCORE structure
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * by register's index from disasm.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncstatic unsigned g_aReg16Index[] =
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Macro for accessing 16-bit general purpose registers in CPUMCTXCORE structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ACCESS_REG16(p, idx) (*((uint16_t *)((char *)(p) + g_aReg16Index[idx])))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Array for accessing 8-bit general registers in CPUMCTXCORE structure
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * by register's index from disasm.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncstatic unsigned g_aReg8Index[] =
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync RT_OFFSETOF(CPUMCTXCORE, eax) + 1, /* USE_REG_AH */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync RT_OFFSETOF(CPUMCTXCORE, ecx) + 1, /* USE_REG_CH */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync RT_OFFSETOF(CPUMCTXCORE, edx) + 1, /* USE_REG_DH */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Macro for accessing 8-bit general purpose registers in CPUMCTXCORE structure.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync#define ACCESS_REG8(p, idx) (*((uint8_t *)((char *)(p) + g_aReg8Index[idx])))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Array for accessing segment registers in CPUMCTXCORE structure
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * by register's index from disasm.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncstatic unsigned g_aRegSegIndex[] =
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Macro for accessing segment registers in CPUMCTXCORE structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ACCESS_REGSEG(p, idx) (*((uint16_t *)((char *)(p) + g_aRegSegIndex[idx])))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Array for fast recode of the operand size (1/2/4/8 bytes) to bit shift value.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic const unsigned g_aSize2Shift[] =
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync ~0, /* 0 - invalid */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync 0, /* *1 == 2^0 */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync ~0, /* 3 - invalid */
23de3d76e5d27015e334e6ff763ab08de5969363vboxsync ~0, /* 5 - invalid */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync ~0, /* 6 - invalid */
23de3d76e5d27015e334e6ff763ab08de5969363vboxsync ~0, /* 7 - invalid */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Macro for fast recode of the operand size (1/2/4/8 bytes) to bit shift value.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Wrapper which does the write and updates range statistics when such are enabled.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @warning VBOX_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncinline int iomGCMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cbSize)
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize); /* @todo fix const!! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * Wrapper which does the read and updates range statistics when such are enabled.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncinline int iomGCMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cbSize)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync return pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync * Returns the contents of register or immediate data of instruction's parameter.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns true on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Pointer to current disassembler context.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pParam Pointer to parameter of instruction to proccess.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pu32Data Where to store retrieved data.
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync * @param pcbSize Where to store the size of data (1, 2, 4).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return false;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *pu32Data = ACCESS_REG32(pRegFrame, pParam->base.reg_gen32);
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync return true;
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync *pu32Data = ACCESS_REG16(pRegFrame, pParam->base.reg_gen16);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync *pu32Data = ACCESS_REG8(pRegFrame, pParam->base.reg_gen8);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pParam->flags & (USE_IMMEDIATE32|USE_IMMEDIATE32_SX8))
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pParam->flags & (USE_IMMEDIATE16|USE_IMMEDIATE16_SX8))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return true;
78a205e3fc6719d59e8c561b3d287d3a4f879852vboxsync *pu32Data = ACCESS_REGSEG(pRegFrame, pParam->base.reg_seg);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return true;
eb90d5a431eee79842fb6c676c05aa9ca51ca6a9vboxsync } /* Else - error. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync return false;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Saves data to 8/16/32 general purpose or segment register defined by
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * instruction's parameter.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns true on success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Pointer to current disassembler context.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pParam Pointer to parameter of instruction to proccess.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest structure.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @param u32Data 8/16/32 bit data to store.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32 | USE_IMMEDIATE8 | USE_IMMEDIATE16 | USE_IMMEDIATE32 | USE_IMMEDIATE32_SX8 | USE_IMMEDIATE16_SX8))
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync return false;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ACCESS_REG32(pRegFrame, pParam->base.reg_gen32) = u32Data;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ACCESS_REG16(pRegFrame, pParam->base.reg_gen16) = (uint16_t)u32Data;
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync return true;
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync ACCESS_REG8(pRegFrame, pParam->base.reg_gen8) = (uint8_t)u32Data;
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ACCESS_REGSEG(pRegFrame, pParam->base.reg_seg) = (uint16_t)u32Data;
f5395a2af3050ddd694b0ad505975f7b717ab4f1vboxsync return true;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Else - error. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return false;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Internal - statistics only.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncinline void iomGCMMIOStatLength(PVM pVM, unsigned cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* No way. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * MOV reg, mem (read)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * MOVZX reg, mem (read)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * MOVSX reg, mem (read)
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @returns VBox status code.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRange Pointer MMIO range.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretMOVxXRead(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If no read handler then go to ring-3 and handle it there.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the data size from parameter 2,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * and call the handler function to get the data.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync AssertMsg(cbSize > 0 && cbSize <= sizeof(uint32_t), ("cbSize=%d\n", cbSize));
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync int rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Do sign extension for MOVSX.
13d75a5db336ccb682d7ab28b397a4f0b8982ea3vboxsync /** @todo checkup MOVSX implementation! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* DWORD <- BYTE */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* DWORD <- WORD */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Store the result to register (parameter 1).
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * MOV mem, reg|imm (write)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pRange Pointer MMIO range.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretMOVxXWrite(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If no write handler then go to ring-3 and handle it there.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get data to write from second parameter,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * and call the callback to write it.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync unsigned cbSize = 0;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** @todo All the string MMIO stuff can do terrible things since physical contiguous mappings are
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * assumed all over the place! This must be addressed in a general way, like for example let EM do
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * all the interpretation and checking of selectors and addresses.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * -> I don't see the problem here. MMIO ranges are by definition linear ranges. The virtual source or destination is read/written properly.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsyncDECLINLINE(int) iomRamRead(PVM pVM, void *pDest, RTGCPTR GCSrc, uint32_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo optimize the loop; no need to convert the address all the time */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncDECLINLINE(int) iomRamWrite(PVM pVM, RTGCPTR GCDest, void *pSrc, uint32_t cb)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return MMGCRamWriteNoTrapHandler(GCDest, pSrc, cb);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo optimize the loop; no need to convert the address all the time */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] MOVSB
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] MOVSW
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] MOVSD
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * Restricted implementation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param uErrorCode CPU Error code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Trap register frame.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRange Pointer MMIO range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretMOVS(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * We do not support segment prefixes or REPNE.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get bytes/words/dwords count to copy.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (!SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid))
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync /* Get the current privilege level. */
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync * Get data size.
f5395a2af3050ddd694b0ad505975f7b717ab4f1vboxsync unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
a44cdd0b29504e3de7b8aa87f839ad62b6e66f51vboxsync int offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->iom.s.cMovsMaxBytes < (cTransfers << SIZE2SHIFT(cbSize)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVM->iom.s.cMovsMaxBytes = cTransfers << SIZE2SHIFT(cbSize);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * Write operation: [Mem] -> [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * ds:esi (Virt Src) -> es:edi (Phys Dst)
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Check callback. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Convert source address ds:esi. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = SELMToFlatEx(pVM, pRegFrame->eflags, pRegFrame->ds, (RTGCPTR)pRegFrame->esi, &pRegFrame->dsHid,
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /* Access verification first; we currently can't recover properly from traps inside this instruction */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, (cpl == 3) ? X86_PTE_US : 0);
13d75a5db336ccb682d7ab28b397a4f0b8982ea3vboxsync Log(("MOVS will generate a trap -> recompiler, rc=%d\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy loop. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomRamRead(pVM, &u32Data, (RTGCPTR)pu8Virt, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update ecx. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Read operation: [MMIO] -> [mem] or [MMIO] -> [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * ds:[eSI] (Phys Src) -> es:[eDI] (Virt Dst)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Check callback. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Convert destination address. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = SELMToFlatEx(pVM, pRegFrame->eflags, pRegFrame->es, (RTGCPTR)pRegFrame->edi, &pRegFrame->esHid,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Check if destination address is MMIO. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMGstGetPage(pVM, (RTGCPTR)pu8Virt, NULL, &PhysDst);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Extra: [MMIO] -> [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsMMIO, d);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync PhysDst |= (RTGCUINTPTR)pu8Virt & PAGE_OFFSET_MASK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync CTXALLSUFF(PIOMMMIORANGE) pMMIODst = iomMMIOGetRange(&pVM->iom.s, PhysDst);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsMMIO, d);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy loop. */
1df4b0cdc5ec23d817014f9347ef28222b51e3fbvboxsync rc = iomGCMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsMMIO, d);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Normal: [MMIO] -> [Mem]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Access verification first; we currently can't recover properly from traps inside this instruction */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("MOVS will generate a trap -> recompiler, rc=%d\n", rc));
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* copy loop. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync rc = iomRamWrite(pVM, (RTGCPTR)pu8Virt, &u32Data, cbSize);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync Log(("iomRamWrite %08X size=%d failed with %d\n", pu8Virt, cbSize, rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update ecx on exit. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* work statistics. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] STOSB
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] STOSW
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * [REP] STOSD
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Restricted implementation.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @returns VBox status code.
ab0130d1627b2b214952b929de71b89e4ba41eb1vboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Trap register frame.
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync * @param pCpu Disassembler CPU state.
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync * @param pRange Pointer MMIO range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretSTOS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * We do not support segment prefixes or REPNE..
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * Get bytes/words/dwords count to copy.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (!SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get data size.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pVM->iom.s.cStosMaxBytes < (cTransfers << SIZE2SHIFT(cbSize)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pVM->iom.s.cStosMaxBytes = cTransfers << SIZE2SHIFT(cbSize);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * Use the fill callback.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** @todo pfnFillCallback must return number of bytes successfully written!!! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* addr++ variant. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, Phys, u32Data, cbSize, cTransfers);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update registers. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRegFrame->edi += cTransfers << SIZE2SHIFT(cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* addr-- variant. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, (Phys - (cTransfers - 1)) << SIZE2SHIFT(cbSize), u32Data, cbSize, cTransfers);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update registers. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRegFrame->edi -= cTransfers << SIZE2SHIFT(cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Use the write callback.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync /* Check write callback. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* fill loop. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update ecx on exit. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Work statistics and return.
be9bc9b4ba510c4b4159c193f783d024633ef8e9vboxsync * [REP] LODSB
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] LODSW
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * [REP] LODSD
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Restricted implementation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pRegFrame Trap register frame.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pCpu Disassembler CPU state.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pRange Pointer MMIO range.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsyncstatic int iomGCInterpretLODS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstLods, a1);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * We do not support segment prefixes or REP*.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync if (pCpu->prefix & (PREFIX_SEG | PREFIX_REP | PREFIX_REPNE))
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync /* Check that we can handle it. */
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync * Get data size.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync int offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * Perform read.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync int rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cbSize);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * Work statistics and return.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * CMP [MMIO], reg|imm
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * CMP reg|imm, [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Restricted implementation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Trap register frame.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @param pRange Pointer MMIO range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretCMP(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Check read callback. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Get the operands.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync unsigned cbSize = 0;
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* cmp reg, [MMIO]. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* cmp [MMIO], reg|imm. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Emulate CMP and update guest flags. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync uint32_t eflags = EMEmulateCmp(uData1, uData2, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * AND [MMIO], reg|imm
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * AND reg, [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Restricted implementation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Trap register frame.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRange Pointer MMIO range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic int iomGCInterpretAND(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Check read callback. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned cbSize = 0;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* and reg, [MMIO]. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
b880eb99e249b300390f5eeedff304ac30ba548evboxsync /* and [MMIO], reg|imm. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (pRange->pfnReadCallback && pRange->pfnWriteCallback)
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Emulate AND and update guest flags. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /* Store result to MMIO. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Store result to register. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData1);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Update guest's eflags and finish. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * TEST [MMIO], reg|imm
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * TEST reg, [MMIO]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Restricted implementation.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @returns VBox status code.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pVM The virtual machine (GC pointer ofcourse).
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pRegFrame Trap register frame.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pRange Pointer MMIO range.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncstatic int iomGCInterpretTEST(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstTest, a1);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Check read callback. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync unsigned cbSize = 0;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* and test, [MMIO]. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /* test [MMIO], reg|imm. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /* Emulate TEST (=AND without write back) and update guest EFLAGS. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync | (eflags & (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * XCHG [MMIO], reg
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * XCHG reg, [MMIO]
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * Restricted implementation.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @returns VBox status code.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pVM The virtual machine (GC pointer ofcourse).
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param pRegFrame Trap register frame.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pCpu Disassembler CPU state.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * @param pRange Pointer MMIO range.
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsyncstatic int iomGCInterpretXCHG(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCInstTest, a1);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Check read callback. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync unsigned cbSize = 0;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (!pRange->pfnReadCallback || !pRange->pfnWriteCallback)
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* xchg reg, [MMIO]. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Store result to MMIO. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Store result to register. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData2);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(rc == VINF_IOM_HC_MMIO_WRITE || rc == VINF_PATM_HC_MMIO_PATCH_WRITE);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(rc == VINF_IOM_HC_MMIO_READ || rc == VINF_PATM_HC_MMIO_PATCH_READ);
47b5427d1a541bcd269bc625c35b19d849071edfvboxsync if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* xchg [MMIO], reg. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Store result to MMIO. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cbSize);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /* Store result to register. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param2, pRegFrame, uData1);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(rc == VINF_IOM_HC_MMIO_WRITE || rc == VINF_PATM_HC_MMIO_PATCH_WRITE);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(rc == VINF_IOM_HC_MMIO_READ || rc == VINF_PATM_HC_MMIO_PATCH_READ);
e131925debcc0add6ebecf92e6d09d62150476a4vboxsync * Read callback for disassembly function; supports reading bytes that cross a page boundary
e131925debcc0add6ebecf92e6d09d62150476a4vboxsync * @returns VBox status code.
e131925debcc0add6ebecf92e6d09d62150476a4vboxsync * @param pSrc GC source pointer
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param pDest HC destination pointer
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param size Number of bytes to read
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param dwUserdata Callback specific user data (pCpu)
e131925debcc0add6ebecf92e6d09d62150476a4vboxsyncDECLCALLBACK(int32_t) iomReadBytes(RTHCUINTPTR pSrc, uint8_t *pDest, uint32_t size, RTHCUINTPTR dwUserdata)
e131925debcc0add6ebecf92e6d09d62150476a4vboxsyncinline bool iomDisCoreOne(PVM pVM, DISCPUSTATE *pCpu, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
e131925debcc0add6ebecf92e6d09d62150476a4vboxsync return VBOX_SUCCESS(DISCoreOneEx(InstrGC, pCpu->mode, iomReadBytes, pVM, pCpu, pOpsize));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncinline bool iomDisCoreOne(PVM pVM, DISCPUSTATE *pCpu, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
9ad5e3912962c3dbccc1afc4e7d62890fe906814vboxsync * \#PF Handler callback for MMIO ranges.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Note: we are on ring0 in Hypervisor and interrupts are disabled.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code (appropriate for GC return).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM Handle.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param uErrorCode CPU Error code.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pRegFrame Trap register frame.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pvFault The fault address (cr2).
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param GCPhysFault The GC physical address corresponding to pvFault.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pvUser Pointer to the MMIO ring-3 range entry.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncIOMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, void *pvFault, RTGCPHYS GCPhysFault, void *pvUser)
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCMMIOHandler, a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync NOREF(pvUser); /** @todo implement pvUser usage! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log3(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%p eip=%RGv\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync GCPhysFault, uErrorCode, pvFault, pRegFrame->eip));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Find the corresponding MMIO range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync CTXALLSUFF(PIOMMMIORANGE) pRange = iomMMIOGetRange(&pVM->iom.s, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIORANGER3 pRangeR3 = iomMMIOGetRangeHC(&pVM->iom.s, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_START(&pVM->iom.s.StatGCMMIOHandler, a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync return (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
212d777d7378ef2a3ecc028df71ca7b82b9cb1dcvboxsync * Now, why are we here...
212d777d7378ef2a3ecc028df71ca7b82b9cb1dcvboxsync AssertMsgFailed(("Internal error! GCPhysFault=%x\n", GCPhysFault));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Convert CS:EIP to linear address and initialize the disassembler.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync cpu.mode = SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid) ? CPUMODE_32BIT : CPUMODE_16BIT;
212d777d7378ef2a3ecc028df71ca7b82b9cb1dcvboxsync int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)(cpu.mode == CPUMODE_32BIT ? pRegFrame->eip : pRegFrame->eip & 0xffff), &pvCode);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("Internal error! cs:eip=%04x:%08x rc=%Vrc\n", pRegFrame->cs, pRegFrame->eip, rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Disassemble the instruction and interprete it.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync if (iomDisCoreOne(pVM, &cpu, (RTGCUINTPTR)pvCode, &cbOp))
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync rc = iomGCInterpretMOVxXWrite(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
afc45562e8673a50bc8cb53333049d67fef30bcbvboxsync rc = iomGCInterpretMOVxXRead(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCInterpretMOVS(pVM, uErrorCode, pRegFrame, GCPhysFault, &cpu, pRange);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCInterpretSTOS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
9ad5e3912962c3dbccc1afc4e7d62890fe906814vboxsync rc = iomGCInterpretLODS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync rc = iomGCInterpretCMP(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync rc = iomGCInterpretAND(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCInterpretTEST(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = iomGCInterpretXCHG(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The instruction isn't supported. Hand it on to ring-3.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync rc = (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * On success advance EIP.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
be2589a6f7086676e45b18d204bb1064889dc586vboxsync STAM_PROFILE_STOP(&pVM->iom.s.StatGCMMIOHandler, a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Reads a MMIO register.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM handle.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param GCPhys The physical address to read.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pu32Value Where to store the value read.
9ad5e3912962c3dbccc1afc4e7d62890fe906814vboxsync * @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncIOMDECL(int) IOMMMIORead(PVM pVM, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** @todo add return to ring-3 statistics when this function is used in GC! */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Lookup the current context range node and statistics.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync CTXALLSUFF(PIOMMMIORANGE) pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
a82df5167acec0c75d741d08c1d05a4007e3d50evboxsync if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* VBOX_WITH_STATISTICS */
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync#else /* !IN_RING3 */
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync#endif /* !IN_RING3 */
e255139508b8e3745b53f3679a60efc8d06cf836vboxsync * Perform the read and deal with the result.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfRead), a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhys, pu32Value, cbValue);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfRead), a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, *pu32Value, cbValue, rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync case 4: *(uint32_t *)pu32Value = 0x00000000; break;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync default: AssertReleaseMsgFailed(("cbValue=%d GCPhys=%VGp\n", cbValue, GCPhys)); break;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, *pu32Value, cbValue, rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync case 4: *(uint32_t *)pu32Value = 0xffffffff; break;
65047a71308d9524254c8f60dc1371cf5679d53avboxsync default: AssertReleaseMsgFailed(("cbValue=%d GCPhys=%VGp\n", cbValue, GCPhys)); break;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, *pu32Value, cbValue, rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Lookup the ring-3 range.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIORANGER3 pRangeR3 = iomMMIOGetRangeHC(&pVM->iom.s, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIORead: GCPhys=%RGp *pu32=%08RX32 cb=%d rc=VINF_SUCCESS\n", GCPhys, *pu32Value, cbValue));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("Handlers and page tables are out of sync or something! GCPhys=%VGp cbValue=%d\n", GCPhys, cbValue));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Writes to a MMIO register.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns VBox status code.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM VM handle.
a82df5167acec0c75d741d08c1d05a4007e3d50evboxsync * @param GCPhys The physical address to write to.
be2589a6f7086676e45b18d204bb1064889dc586vboxsync * @param u32Value The value to write.
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync * @param cbValue The size of the register to read in bytes. 1, 2 or 4 bytes.
be2589a6f7086676e45b18d204bb1064889dc586vboxsyncIOMDECL(int) IOMMMIOWrite(PVM pVM, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue)
a82df5167acec0c75d741d08c1d05a4007e3d50evboxsync/** @todo add return to ring-3 statistics when this function is used in GC! */
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync * Lookup the current context range node.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync CTXALLSUFF(PIOMMMIORANGE) pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
9ad5e3912962c3dbccc1afc4e7d62890fe906814vboxsync pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* VBOX_WITH_STATISTICS */
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * Perform the write if we found a range.
fe376b8f218c234c1ba918513340aff917aa7925vboxsync#else /* !IN_RING3 */
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync#endif /* !IN_RING3 */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfWrite), a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhys, &u32Value, cbValue);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfWrite), a);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, u32Value, cbValue, rc));
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync * Lookup the ring-3 range.
be2589a6f7086676e45b18d204bb1064889dc586vboxsync PIOMMMIORANGER3 pRangeR3 = iomMMIOGetRangeHC(&pVM->iom.s, GCPhys);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, u32Value, cbValue));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsgFailed(("Handlers and page tables are out of sync or something! GCPhys=%VGp cbValue=%d\n", GCPhys, cbValue));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * ES:EDI,DX[,ECX]
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @remark Assumes caller checked the access privileges (IOMInterpretCheckPortIOAccess)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns Strict VBox status code. Informational status codes other than the one documented
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS Success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * status code must be passed on to EM.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_IOM_HC_IOPORT_READ Defer the read to ring-3. (R0/GC only)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_RAW_EMULATE_INSTR Defer the read to the REM.
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync * @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync * @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync * @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
f5395a2af3050ddd694b0ad505975f7b717ab4f1vboxsync * @param uPort IO Port
e255139508b8e3745b53f3679a60efc8d06cf836vboxsync * @param uPrefix IO instruction prefix
e255139508b8e3745b53f3679a60efc8d06cf836vboxsync * @param cbTransfer Size of transfer unit
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncIOMDECL(int) IOMInterpretINSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, uint32_t cbTransfer)
a64bf60e92e5cb8a76aa6c8e92193932d88a906fvboxsync * We do not support REPNE or decrementing destination
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * pointer. Segment prefixes are deliberately ignored, as per the instruction specification.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get bytes/words/dwords count to transfer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync if (!SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid))
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync /* Convert destination address es:edi. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync int rc = SELMToFlatEx(pVM, pRegFrame->eflags, pRegFrame->es, (RTGCPTR)pRegFrame->edi, &pRegFrame->esHid,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("INS destination address conversion failed -> fallback, rc=%d\n", rc));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Access verification first; we can't recover from traps inside this instruction, as the port read cannot be repeated. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = PGMVerifyAccess(pVM, (RTGCUINTPTR)GCPtrDst, cTransfers * cbTransfer,
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Log(("INS will generate a trap -> fallback, rc=%d\n", rc));
13d75a5db336ccb682d7ab28b397a4f0b8982ea3vboxsync Log(("IOM: rep ins%d port %#x count %d\n", cbTransfer * 8, uPort, cTransfers));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* If the device supports string transfers, ask it to do as
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * much as it wants. The rest is done with single-word transfers. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = IOMIOPortReadString(pVM, uPort, &GCPtrDst, &cTransfers, cbTransfer);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRegFrame->edi += (cTransfersOrg - cTransfers) * cbTransfer;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync rc = IOMIOPortRead(pVM, uPort, &u32Value, cbTransfer);
a82df5167acec0c75d741d08c1d05a4007e3d50evboxsync int rc2 = iomRamWrite(pVM, GCPtrDst, &u32Value, cbTransfer);
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbTransfer);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Update ecx on exit. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_READ || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || VBOX_FAILURE(rc), ("%Vrc\n", rc));
be9bc9b4ba510c4b4159c193f783d024633ef8e9vboxsync * ES:EDI,DX[,ECX]
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * @returns Strict VBox status code. Informational status codes other than the one documented
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_SUCCESS Success.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * status code must be passed on to EM.
fe376b8f218c234c1ba918513340aff917aa7925vboxsync * @retval VINF_IOM_HC_IOPORT_READ Defer the read to ring-3. (R0/GC only)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_EM_RAW_EMULATE_INSTR Defer the read to the REM.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync * @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pVM The virtual machine (GC pointer ofcourse).
d8df004f4caf4f71e78f0be1cc2e2a918358ae9fvboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pCpu Disassembler CPU state.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncIOMDECL(int) IOMInterpretINS(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
8f3f7a8bb1cf9f74426deee5af7432ebd63de2b1vboxsync * Get port number directly from the register (no need to bother the
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * disassembler). And get the I/O register size from the opcode / prefix.
ebe05ec36d1fcd24d62e7066dedcb4eb2e691358vboxsync unsigned cbSize = 0;
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
a796c0742e1322416c085c7493da93a7384e099avboxsync AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync return IOMInterpretINSEx(pVM, pRegFrame, uPort, pCpu->prefix, cbSize);
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * DS:ESI,DX[,ECX]
5074f08c6c2ba32f2d463a5abcab0e2ae38d1823vboxsync * @remark Assumes caller checked the access privileges (IOMInterpretCheckPortIOAccess)
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @returns Strict VBox status code. Informational status codes other than the one documented
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * here are to be treated as internal failure. Use IOM_SUCCESS() to check for success.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_SUCCESS Success.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_EM_FIRST-VINF_EM_LAST Success with some exceptions (see IOM_SUCCESS()), the
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * status code must be passed on to EM.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_IOM_HC_IOPORT_WRITE Defer the write to ring-3. (R0/GC only)
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_EM_RAW_GUEST_TRAP The exception was left pending. (TRPMRaiseXcptErr)
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
9243c25e887b8f49e764b130c132bbe1b60bed50vboxsync * @param pVM The virtual machine (GC pointer ofcourse).
9243c25e887b8f49e764b130c132bbe1b60bed50vboxsync * @param pRegFrame Pointer to CPUMCTXCORE guest registers structure.
9243c25e887b8f49e764b130c132bbe1b60bed50vboxsync * @param uPort IO Port
9243c25e887b8f49e764b130c132bbe1b60bed50vboxsync * @param uPrefix IO instruction prefix
9243c25e887b8f49e764b130c132bbe1b60bed50vboxsync * @param cbTransfer Size of transfer unit
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsyncIOMDECL(int) IOMInterpretOUTSEx(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t uPort, uint32_t uPrefix, uint32_t cbTransfer)
ebe05ec36d1fcd24d62e7066dedcb4eb2e691358vboxsync * We do not support segment prefixes, REPNE or
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * decrementing source pointer.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * Get bytes/words/dwords count to transfer.
4eff20ce85bd2f6c2e942f4b02f201d17fec1059vboxsync if (!SELMIsSelector32Bit(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid))
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync /* Convert source address ds:esi. */
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync int rc = SELMToFlatEx(pVM, pRegFrame->eflags, pRegFrame->ds, (RTGCPTR)pRegFrame->esi, &pRegFrame->dsHid,
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync Log(("OUTS source address conversion failed -> fallback, rc=%Vrc\n", rc));
ebe05ec36d1fcd24d62e7066dedcb4eb2e691358vboxsync /* Access verification first; we currently can't recover properly from traps inside this instruction */
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync rc = PGMVerifyAccess(pVM, (RTGCUINTPTR)GCPtrSrc, cTransfers * cbTransfer,
ae9ec50c70638edbb5128ccc1577e568f3fa3982vboxsync Log(("OUTS will generate a trap -> fallback, rc=%Vrc\n", rc));
996e3c380ffc191ee846a2384f2ec876d2b194a6vboxsync Log(("IOM: rep outs%d port %#x count %d\n", cbTransfer * 8, uPort, cTransfers));
996e3c380ffc191ee846a2384f2ec876d2b194a6vboxsync * If the device supports string transfers, ask it to do as
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync * much as it wants. The rest is done with single-word transfers.
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync rc = IOMIOPortWriteString(pVM, uPort, &GCPtrSrc, &cTransfers, cbTransfer);
8f3f7a8bb1cf9f74426deee5af7432ebd63de2b1vboxsync pRegFrame->esi += (cTransfersOrg - cTransfers) * cbTransfer;
#ifdef IN_GC
cTransfers--;
#ifdef IN_GC
AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_WRITE || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || VBOX_FAILURE(rc), ("%Vrc\n", rc));
return rc;
* @retval VINF_TRPM_XCPT_DISPATCHED The exception was raised and dispatched for raw-mode execution. (TRPMRaiseXcptErr)
* @retval VINF_EM_RESCHEDULE_REM The exception was dispatched and cannot be executed in raw-mode. (TRPMRaiseXcptErr)
unsigned cbSize = 0;
AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
return rc;