[23] | 1 | /* $Id: DBGFAllBp.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
|
---|
[1] | 2 | /** @file
|
---|
[86730] | 3 | * DBGF - Debugger Facility, All Context breakpoint management part.
|
---|
[1] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[96407] | 7 | * Copyright (C) 2006-2022 Oracle and/or its affiliates.
|
---|
[1] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[1] | 26 | */
|
---|
| 27 |
|
---|
| 28 |
|
---|
[57358] | 29 | /*********************************************************************************************************************************
|
---|
| 30 | * Header Files *
|
---|
| 31 | *********************************************************************************************************************************/
|
---|
[8793] | 32 | #define LOG_GROUP LOG_GROUP_DBGF
|
---|
[87130] | 33 | #define VMCPU_INCL_CPUM_GST_CTX
|
---|
[35346] | 34 | #include <VBox/vmm/dbgf.h>
|
---|
[87130] | 35 | #include <VBox/vmm/iem.h>
|
---|
| 36 | #include <VBox/vmm/pgm.h>
|
---|
[35346] | 37 | #include <VBox/vmm/selm.h>
|
---|
[3776] | 38 | #include <VBox/log.h>
|
---|
[1] | 39 | #include "DBGFInternal.h"
|
---|
[80274] | 40 | #include <VBox/vmm/vmcc.h>
|
---|
[1] | 41 | #include <VBox/err.h>
|
---|
| 42 | #include <iprt/assert.h>
|
---|
| 43 |
|
---|
[87594] | 44 | #include "DBGFInline.h"
|
---|
[1] | 45 |
|
---|
[86749] | 46 |
|
---|
[19288] | 47 | #ifdef IN_RC
|
---|
[86729] | 48 | # error "You lucky person have the pleasure to implement the raw mode part for this!"
|
---|
[19288] | 49 | #endif
|
---|
[1] | 50 |
|
---|
| 51 |
|
---|
[86701] | 52 | /**
|
---|
| 53 | * Returns the internal breakpoint state for the given handle.
|
---|
| 54 | *
|
---|
| 55 | * @returns Pointer to the internal breakpoint state or NULL if the handle is invalid.
|
---|
| 56 | * @param pVM The ring-0 VM structure pointer.
|
---|
| 57 | * @param hBp The breakpoint handle to resolve.
|
---|
| 58 | * @param ppBpR0 Where to store the pointer to the ring-0 only part of the breakpoint
|
---|
| 59 | * on success, optional.
|
---|
| 60 | */
|
---|
[87594] | 61 | #ifdef IN_RING0
|
---|
[86749] | 62 | DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp, PDBGFBPINTR0 *ppBpR0)
|
---|
[87594] | 63 | #else
|
---|
[86749] | 64 | DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp)
|
---|
[87594] | 65 | #endif
|
---|
[86701] | 66 | {
|
---|
| 67 | uint32_t idChunk = DBGF_BP_HND_GET_CHUNK_ID(hBp);
|
---|
| 68 | uint32_t idxEntry = DBGF_BP_HND_GET_ENTRY(hBp);
|
---|
[1] | 69 |
|
---|
[86701] | 70 | AssertReturn(idChunk < DBGF_BP_CHUNK_COUNT, NULL);
|
---|
| 71 | AssertReturn(idxEntry < DBGF_BP_COUNT_PER_CHUNK, NULL);
|
---|
| 72 |
|
---|
[87594] | 73 | #ifdef IN_RING0
|
---|
[86701] | 74 | PDBGFBPCHUNKR0 pBpChunk = &pVM->dbgfr0.s.aBpChunks[idChunk];
|
---|
[86749] | 75 | AssertPtrReturn(pBpChunk->CTX_SUFF(paBpBaseShared), NULL);
|
---|
[86701] | 76 |
|
---|
| 77 | if (ppBpR0)
|
---|
| 78 | *ppBpR0 = &pBpChunk->paBpBaseR0Only[idxEntry];
|
---|
[86749] | 79 | return &pBpChunk->CTX_SUFF(paBpBaseShared)[idxEntry];
|
---|
[87594] | 80 |
|
---|
| 81 | #elif defined(IN_RING3)
|
---|
[86749] | 82 | PUVM pUVM = pVM->pUVM;
|
---|
| 83 | PDBGFBPCHUNKR3 pBpChunk = &pUVM->dbgf.s.aBpChunks[idChunk];
|
---|
| 84 | AssertPtrReturn(pBpChunk->CTX_SUFF(pBpBase), NULL);
|
---|
[86701] | 85 |
|
---|
[86749] | 86 | return &pBpChunk->CTX_SUFF(pBpBase)[idxEntry];
|
---|
[87594] | 87 |
|
---|
| 88 | #else
|
---|
| 89 | # error "Unsupported context"
|
---|
| 90 | #endif
|
---|
[86701] | 91 | }
|
---|
[86726] | 92 |
|
---|
| 93 |
|
---|
| 94 | /**
|
---|
| 95 | * Returns the pointer to the L2 table entry from the given index.
|
---|
| 96 | *
|
---|
| 97 | * @returns Current context pointer to the L2 table entry or NULL if the provided index value is invalid.
|
---|
| 98 | * @param pVM The cross context VM structure.
|
---|
| 99 | * @param idxL2 The L2 table index to resolve.
|
---|
| 100 | *
|
---|
| 101 | * @note The content of the resolved L2 table entry is not validated!.
|
---|
| 102 | */
|
---|
[86749] | 103 | DECLINLINE(PCDBGFBPL2ENTRY) dbgfBpL2GetByIdx(PVMCC pVM, uint32_t idxL2)
|
---|
[86726] | 104 | {
|
---|
| 105 | uint32_t idChunk = DBGF_BP_L2_IDX_GET_CHUNK_ID(idxL2);
|
---|
| 106 | uint32_t idxEntry = DBGF_BP_L2_IDX_GET_ENTRY(idxL2);
|
---|
| 107 |
|
---|
| 108 | AssertReturn(idChunk < DBGF_BP_L2_TBL_CHUNK_COUNT, NULL);
|
---|
| 109 | AssertReturn(idxEntry < DBGF_BP_L2_TBL_ENTRIES_PER_CHUNK, NULL);
|
---|
| 110 |
|
---|
[87594] | 111 | #ifdef IN_RING0
|
---|
[86726] | 112 | PDBGFBPL2TBLCHUNKR0 pL2Chunk = &pVM->dbgfr0.s.aBpL2TblChunks[idChunk];
|
---|
[86749] | 113 | AssertPtrReturn(pL2Chunk->CTX_SUFF(paBpL2TblBaseShared), NULL);
|
---|
[86726] | 114 |
|
---|
| 115 | return &pL2Chunk->CTX_SUFF(paBpL2TblBaseShared)[idxEntry];
|
---|
[87594] | 116 | #elif defined(IN_RING3)
|
---|
[86749] | 117 | PUVM pUVM = pVM->pUVM;
|
---|
| 118 | PDBGFBPL2TBLCHUNKR3 pL2Chunk = &pUVM->dbgf.s.aBpL2TblChunks[idChunk];
|
---|
| 119 | AssertPtrReturn(pL2Chunk->pbmAlloc, NULL);
|
---|
| 120 | AssertReturn(ASMBitTest(pL2Chunk->pbmAlloc, idxEntry), NULL);
|
---|
| 121 |
|
---|
| 122 | return &pL2Chunk->CTX_SUFF(pL2Base)[idxEntry];
|
---|
[87594] | 123 | #endif
|
---|
[86726] | 124 | }
|
---|
| 125 |
|
---|
| 126 |
|
---|
[87594] | 127 | #ifdef IN_RING0
|
---|
[86726] | 128 | /**
|
---|
[87130] | 129 | * Returns the internal breakpoint owner state for the given handle.
|
---|
| 130 | *
|
---|
| 131 | * @returns Pointer to the internal ring-0 breakpoint owner state or NULL if the handle is invalid.
|
---|
| 132 | * @param pVM The cross context VM structure.
|
---|
| 133 | * @param hBpOwner The breakpoint owner handle to resolve.
|
---|
| 134 | */
|
---|
| 135 | DECLINLINE(PCDBGFBPOWNERINTR0) dbgfR0BpOwnerGetByHnd(PVMCC pVM, DBGFBPOWNER hBpOwner)
|
---|
| 136 | {
|
---|
| 137 | if (hBpOwner == NIL_DBGFBPOWNER)
|
---|
| 138 | return NULL;
|
---|
| 139 |
|
---|
| 140 | AssertReturn(hBpOwner < DBGF_BP_OWNER_COUNT_MAX, NULL);
|
---|
| 141 |
|
---|
| 142 | PCDBGFBPOWNERINTR0 pBpOwnerR0 = &pVM->dbgfr0.s.paBpOwnersR0[hBpOwner];
|
---|
| 143 | AssertReturn(pBpOwnerR0->cRefs > 1, NULL);
|
---|
| 144 |
|
---|
| 145 | return pBpOwnerR0;
|
---|
| 146 | }
|
---|
[87594] | 147 | #endif
|
---|
[87130] | 148 |
|
---|
| 149 |
|
---|
| 150 | /**
|
---|
[86749] | 151 | * Executes the actions associated with the given breakpoint.
|
---|
| 152 | *
|
---|
| 153 | * @returns VBox status code.
|
---|
| 154 | * @param pVM The cross context VM structure.
|
---|
| 155 | * @param pVCpu The cross context virtual CPU structure.
|
---|
| 156 | * @param pRegFrame Pointer to the register frame for the trap.
|
---|
| 157 | * @param hBp The breakpoint handle which hit.
|
---|
| 158 | * @param pBp The shared breakpoint state.
|
---|
| 159 | * @param pBpR0 The ring-0 only breakpoint state.
|
---|
| 160 | */
|
---|
[87594] | 161 | #ifdef IN_RING0
|
---|
| 162 | DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
|
---|
| 163 | #else
|
---|
| 164 | DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, DBGFBP hBp, PDBGFBPINT pBp)
|
---|
| 165 | #endif
|
---|
[86749] | 166 | {
|
---|
[87132] | 167 | uint64_t cHits = ASMAtomicIncU64(&pBp->Pub.cHits); RT_NOREF(cHits);
|
---|
[86749] | 168 |
|
---|
[87130] | 169 | RT_NOREF(pRegFrame);
|
---|
[86749] | 170 | LogFlow(("dbgfBpHit: hit breakpoint %u at %04x:%RGv cHits=0x%RX64\n",
|
---|
| 171 | hBp, pRegFrame->cs.Sel, pRegFrame->rip, cHits));
|
---|
[87130] | 172 |
|
---|
| 173 | int rc = VINF_EM_DBG_BREAKPOINT;
|
---|
[87594] | 174 | #ifdef IN_RING0
|
---|
[87130] | 175 | PCDBGFBPOWNERINTR0 pBpOwnerR0 = dbgfR0BpOwnerGetByHnd(pVM,
|
---|
| 176 | pBpR0->fInUse
|
---|
| 177 | ? pBpR0->hOwner
|
---|
| 178 | : NIL_DBGFBPOWNER);
|
---|
| 179 | if (pBpOwnerR0)
|
---|
| 180 | {
|
---|
[89924] | 181 | AssertReturn(pBpOwnerR0->pfnBpIoHitR0, VERR_DBGF_BP_IPE_1);
|
---|
| 182 |
|
---|
[87776] | 183 | VBOXSTRICTRC rcStrict = VINF_SUCCESS;
|
---|
| 184 |
|
---|
| 185 | if (DBGF_BP_PUB_IS_EXEC_BEFORE(&pBp->Pub))
|
---|
| 186 | rcStrict = pBpOwnerR0->pfnBpHitR0(pVM, pVCpu->idCpu, pBpR0->pvUserR0, hBp, &pBp->Pub, DBGF_BP_F_HIT_EXEC_BEFORE);
|
---|
[87130] | 187 | if (rcStrict == VINF_SUCCESS)
|
---|
| 188 | {
|
---|
| 189 | uint8_t abInstr[DBGF_BP_INSN_MAX];
|
---|
| 190 | RTGCPTR const GCPtrInstr = pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base;
|
---|
| 191 | rc = PGMPhysSimpleReadGCPtr(pVCpu, &abInstr[0], GCPtrInstr, sizeof(abInstr));
|
---|
| 192 | AssertRC(rc);
|
---|
| 193 | if (RT_SUCCESS(rc))
|
---|
| 194 | {
|
---|
| 195 | /* Replace the int3 with the original instruction byte. */
|
---|
| 196 | abInstr[0] = pBp->Pub.u.Int3.bOrg;
|
---|
| 197 | rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), GCPtrInstr, &abInstr[0], sizeof(abInstr));
|
---|
[87776] | 198 | if ( rcStrict == VINF_SUCCESS
|
---|
| 199 | && DBGF_BP_PUB_IS_EXEC_AFTER(&pBp->Pub))
|
---|
| 200 | {
|
---|
| 201 | rcStrict = pBpOwnerR0->pfnBpHitR0(pVM, pVCpu->idCpu, pBpR0->pvUserR0, hBp, &pBp->Pub, DBGF_BP_F_HIT_EXEC_AFTER);
|
---|
| 202 | if (rcStrict == VINF_SUCCESS)
|
---|
| 203 | rc = VINF_SUCCESS;
|
---|
| 204 | else if ( rcStrict == VINF_DBGF_BP_HALT
|
---|
| 205 | || rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 206 | {
|
---|
| 207 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
| 208 | if (rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 209 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
|
---|
| 210 | else
|
---|
| 211 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = false;
|
---|
| 212 | }
|
---|
| 213 | else /* Guru meditation. */
|
---|
| 214 | rc = VERR_DBGF_BP_OWNER_CALLBACK_WRONG_STATUS;
|
---|
| 215 | }
|
---|
| 216 | else
|
---|
| 217 | rc = VBOXSTRICTRC_VAL(rcStrict);
|
---|
[87130] | 218 | }
|
---|
| 219 | }
|
---|
| 220 | else if ( rcStrict == VINF_DBGF_BP_HALT
|
---|
| 221 | || rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 222 | {
|
---|
| 223 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
| 224 | if (rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 225 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
|
---|
| 226 | else
|
---|
| 227 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = false;
|
---|
| 228 | }
|
---|
| 229 | else /* Guru meditation. */
|
---|
| 230 | rc = VERR_DBGF_BP_OWNER_CALLBACK_WRONG_STATUS;
|
---|
| 231 | }
|
---|
| 232 | else
|
---|
| 233 | {
|
---|
| 234 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true; /* Need to check this for ring-3 only owners. */
|
---|
| 235 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
| 236 | }
|
---|
[87594] | 237 | #else
|
---|
[87130] | 238 | RT_NOREF(pVM);
|
---|
| 239 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
|
---|
| 240 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
[87594] | 241 | #endif
|
---|
[87130] | 242 |
|
---|
| 243 | return rc;
|
---|
[86749] | 244 | }
|
---|
| 245 |
|
---|
| 246 |
|
---|
| 247 | /**
|
---|
[89924] | 248 | * Executes the actions associated with the given port I/O breakpoint.
|
---|
| 249 | *
|
---|
| 250 | * @returns VBox status code.
|
---|
| 251 | * @param pVM The cross context VM structure.
|
---|
| 252 | * @param pVCpu The cross context virtual CPU structure.
|
---|
| 253 | * @param fBefore Flag whether the check is done before the access is carried out,
|
---|
| 254 | * false if it is done after the access.
|
---|
| 255 | * @param fAccess Access flags, see DBGFBPIOACCESS_XXX.
|
---|
| 256 | * @param uAddr The address of the access, for port I/O this will hold the port number.
|
---|
| 257 | * @param uValue The value read or written (the value for reads is only valid when DBGF_BP_F_HIT_EXEC_AFTER is set).
|
---|
| 258 | * @param hBp The breakpoint handle which hit.
|
---|
| 259 | * @param pBp The shared breakpoint state.
|
---|
| 260 | * @param pBpR0 The ring-0 only breakpoint state.
|
---|
| 261 | */
|
---|
| 262 | #ifdef IN_RING0
|
---|
| 263 | DECLINLINE(VBOXSTRICTRC) dbgfBpPortIoHit(PVMCC pVM, PVMCPU pVCpu, bool fBefore, uint32_t fAccess, uint64_t uAddr, uint64_t uValue,
|
---|
| 264 | DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
|
---|
| 265 | #else
|
---|
| 266 | DECLINLINE(VBOXSTRICTRC) dbgfBpPortIoHit(PVMCC pVM, PVMCPU pVCpu, bool fBefore, uint32_t fAccess, uint64_t uAddr, uint64_t uValue,
|
---|
| 267 | DBGFBP hBp, PDBGFBPINT pBp)
|
---|
| 268 | #endif
|
---|
| 269 | {
|
---|
| 270 | ASMAtomicIncU64(&pBp->Pub.cHits);
|
---|
| 271 |
|
---|
| 272 | VBOXSTRICTRC rcStrict = VINF_EM_DBG_BREAKPOINT;
|
---|
| 273 | #ifdef IN_RING0
|
---|
| 274 | PCDBGFBPOWNERINTR0 pBpOwnerR0 = dbgfR0BpOwnerGetByHnd(pVM,
|
---|
| 275 | pBpR0->fInUse
|
---|
| 276 | ? pBpR0->hOwner
|
---|
| 277 | : NIL_DBGFBPOWNER);
|
---|
| 278 | if (pBpOwnerR0)
|
---|
| 279 | {
|
---|
| 280 | AssertReturn(pBpOwnerR0->pfnBpIoHitR0, VERR_DBGF_BP_IPE_1);
|
---|
| 281 | rcStrict = pBpOwnerR0->pfnBpIoHitR0(pVM, pVCpu->idCpuUnsafe, pBpR0->pvUserR0, hBp, &pBp->Pub,
|
---|
| 282 | fBefore
|
---|
| 283 | ? DBGF_BP_F_HIT_EXEC_BEFORE
|
---|
| 284 | : DBGF_BP_F_HIT_EXEC_AFTER,
|
---|
| 285 | fAccess, uAddr, uValue);
|
---|
| 286 | }
|
---|
| 287 | else
|
---|
| 288 | {
|
---|
| 289 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true; /* Need to check this for ring-3 only owners. */
|
---|
| 290 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
| 291 | pVCpu->dbgf.s.fBpIoActive = true;
|
---|
| 292 | pVCpu->dbgf.s.fBpIoBefore = fBefore;
|
---|
| 293 | pVCpu->dbgf.s.uBpIoAddress = uAddr;
|
---|
| 294 | pVCpu->dbgf.s.fBpIoAccess = fAccess;
|
---|
| 295 | pVCpu->dbgf.s.uBpIoValue = uValue;
|
---|
| 296 | }
|
---|
| 297 | #else
|
---|
| 298 | /* Resolve owner (can be NIL_DBGFBPOWNER) and invoke callback if there is one. */
|
---|
| 299 | if (pBp->Pub.hOwner != NIL_DBGFBPOWNER)
|
---|
| 300 | {
|
---|
| 301 | PCDBGFBPOWNERINT pBpOwner = dbgfR3BpOwnerGetByHnd(pVM->pUVM, pBp->Pub.hOwner);
|
---|
| 302 | if (pBpOwner)
|
---|
| 303 | {
|
---|
| 304 | AssertReturn(pBpOwner->pfnBpIoHitR3, VERR_DBGF_BP_IPE_1);
|
---|
| 305 | rcStrict = pBpOwner->pfnBpIoHitR3(pVM, pVCpu->idCpu, pBp->pvUserR3, hBp, &pBp->Pub,
|
---|
| 306 | fBefore
|
---|
| 307 | ? DBGF_BP_F_HIT_EXEC_BEFORE
|
---|
| 308 | : DBGF_BP_F_HIT_EXEC_AFTER,
|
---|
| 309 | fAccess, uAddr, uValue);
|
---|
| 310 | }
|
---|
| 311 | }
|
---|
| 312 | #endif
|
---|
| 313 | if ( rcStrict == VINF_DBGF_BP_HALT
|
---|
| 314 | || rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 315 | {
|
---|
| 316 | pVCpu->dbgf.s.hBpActive = hBp;
|
---|
| 317 | if (rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
|
---|
| 318 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
|
---|
| 319 | else
|
---|
| 320 | pVCpu->dbgf.s.fBpInvokeOwnerCallback = false;
|
---|
| 321 | rcStrict = VINF_EM_DBG_BREAKPOINT;
|
---|
| 322 | }
|
---|
| 323 | else if ( rcStrict != VINF_SUCCESS
|
---|
| 324 | && rcStrict != VINF_EM_DBG_BREAKPOINT)
|
---|
| 325 | rcStrict = VERR_DBGF_BP_OWNER_CALLBACK_WRONG_STATUS; /* Guru meditation. */
|
---|
| 326 |
|
---|
| 327 | return rcStrict;
|
---|
| 328 | }
|
---|
| 329 |
|
---|
| 330 |
|
---|
| 331 | /**
|
---|
[86726] | 332 | * Walks the L2 table starting at the given root index searching for the given key.
|
---|
| 333 | *
|
---|
| 334 | * @returns VBox status code.
|
---|
| 335 | * @param pVM The cross context VM structure.
|
---|
| 336 | * @param pVCpu The cross context virtual CPU structure.
|
---|
| 337 | * @param pRegFrame Pointer to the register frame for the trap.
|
---|
| 338 | * @param idxL2Root L2 table index of the table root.
|
---|
| 339 | * @param GCPtrKey The key to search for.
|
---|
| 340 | */
|
---|
[86730] | 341 | static int dbgfBpL2Walk(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
|
---|
| 342 | uint32_t idxL2Root, RTGCUINTPTR GCPtrKey)
|
---|
[86726] | 343 | {
|
---|
| 344 | /** @todo We don't use the depth right now but abort the walking after a fixed amount of levels. */
|
---|
| 345 | uint8_t iDepth = 32;
|
---|
[86749] | 346 | PCDBGFBPL2ENTRY pL2Entry = dbgfBpL2GetByIdx(pVM, idxL2Root);
|
---|
[86726] | 347 |
|
---|
| 348 | while (RT_LIKELY( iDepth-- > 0
|
---|
| 349 | && pL2Entry))
|
---|
| 350 | {
|
---|
| 351 | /* Make a copy of the entry before verification. */
|
---|
| 352 | DBGFBPL2ENTRY L2Entry;
|
---|
| 353 | L2Entry.u64GCPtrKeyAndBpHnd1 = ASMAtomicReadU64((volatile uint64_t *)&pL2Entry->u64GCPtrKeyAndBpHnd1);
|
---|
| 354 | L2Entry.u64LeftRightIdxDepthBpHnd2 = ASMAtomicReadU64((volatile uint64_t *)&pL2Entry->u64LeftRightIdxDepthBpHnd2);
|
---|
| 355 |
|
---|
| 356 | RTGCUINTPTR GCPtrL2Entry = DBGF_BP_L2_ENTRY_GET_GCPTR(L2Entry.u64GCPtrKeyAndBpHnd1);
|
---|
| 357 | if (GCPtrKey == GCPtrL2Entry)
|
---|
| 358 | {
|
---|
| 359 | DBGFBP hBp = DBGF_BP_L2_ENTRY_GET_BP_HND(L2Entry.u64GCPtrKeyAndBpHnd1, L2Entry.u64LeftRightIdxDepthBpHnd2);
|
---|
| 360 |
|
---|
| 361 | /* Query the internal breakpoint state from the handle. */
|
---|
[87594] | 362 | #ifdef IN_RING3
|
---|
| 363 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp);
|
---|
| 364 | #else
|
---|
[86726] | 365 | PDBGFBPINTR0 pBpR0 = NULL;
|
---|
[87594] | 366 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
|
---|
| 367 | #endif
|
---|
[86726] | 368 | if ( pBp
|
---|
[87776] | 369 | && DBGF_BP_PUB_GET_TYPE(&pBp->Pub) == DBGFBPTYPE_INT3)
|
---|
[87594] | 370 | #ifdef IN_RING3
|
---|
| 371 | return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp);
|
---|
| 372 | #else
|
---|
| 373 | return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
|
---|
| 374 | #endif
|
---|
[86726] | 375 |
|
---|
| 376 | /* The entry got corrupted, just abort. */
|
---|
| 377 | return VERR_DBGF_BP_L2_LOOKUP_FAILED;
|
---|
| 378 | }
|
---|
| 379 |
|
---|
| 380 | /* Not found, get to the next level. */
|
---|
| 381 | uint32_t idxL2Next = (GCPtrKey < GCPtrL2Entry)
|
---|
| 382 | ? DBGF_BP_L2_ENTRY_GET_IDX_LEFT(L2Entry.u64LeftRightIdxDepthBpHnd2)
|
---|
| 383 | : DBGF_BP_L2_ENTRY_GET_IDX_RIGHT(L2Entry.u64LeftRightIdxDepthBpHnd2);
|
---|
| 384 | /* It is genuine guest trap or we hit some assertion if we are at the end. */
|
---|
| 385 | if (idxL2Next == DBGF_BP_L2_ENTRY_IDX_END)
|
---|
[86729] | 386 | return VINF_EM_RAW_GUEST_TRAP;
|
---|
[86726] | 387 |
|
---|
[86749] | 388 | pL2Entry = dbgfBpL2GetByIdx(pVM, idxL2Next);
|
---|
[86726] | 389 | }
|
---|
| 390 |
|
---|
| 391 | return VERR_DBGF_BP_L2_LOOKUP_FAILED;
|
---|
| 392 | }
|
---|
[86701] | 393 |
|
---|
[86729] | 394 |
|
---|
[86701] | 395 | /**
|
---|
[89924] | 396 | * Checks whether there is a port I/O breakpoint for the given range and access size.
|
---|
| 397 | *
|
---|
| 398 | * @returns VBox status code.
|
---|
| 399 | * @retval VINF_EM_DBG_BREAKPOINT means there is a breakpoint pending.
|
---|
| 400 | * @retval VINF_SUCCESS means everything is fine to continue.
|
---|
| 401 | * @retval anything else means a fatal error causing a guru meditation.
|
---|
| 402 | *
|
---|
| 403 | * @param pVM The current context VM structure.
|
---|
| 404 | * @param pVCpu The cross context virtual CPU structure.
|
---|
| 405 | * @param uIoPort The I/O port being accessed.
|
---|
| 406 | * @param fAccess Appropriate DBGFBPIOACCESS_XXX.
|
---|
| 407 | * @param uValue The value being written to or read from the device
|
---|
| 408 | * (The value is only valid for a read when the
|
---|
| 409 | * call is made after the access, writes are always valid).
|
---|
| 410 | * @param fBefore Flag whether the check is done before the access is carried out,
|
---|
| 411 | * false if it is done after the access.
|
---|
| 412 | */
|
---|
| 413 | VMM_INT_DECL(VBOXSTRICTRC) DBGFBpCheckPortIo(PVMCC pVM, PVMCPU pVCpu, RTIOPORT uIoPort,
|
---|
| 414 | uint32_t fAccess, uint32_t uValue, bool fBefore)
|
---|
| 415 | {
|
---|
| 416 | RT_NOREF(uValue); /** @todo Trigger only on specific values. */
|
---|
| 417 |
|
---|
| 418 | /* Don't trigger in single stepping mode. */
|
---|
| 419 | if (pVCpu->dbgf.s.fSingleSteppingRaw)
|
---|
| 420 | return VINF_SUCCESS;
|
---|
| 421 |
|
---|
| 422 | #if defined(IN_RING0)
|
---|
| 423 | uint32_t volatile *paBpLocPortIo = pVM->dbgfr0.s.CTX_SUFF(paBpLocPortIo);
|
---|
| 424 | #elif defined(IN_RING3)
|
---|
| 425 | PUVM pUVM = pVM->pUVM;
|
---|
| 426 | uint32_t volatile *paBpLocPortIo = pUVM->dbgf.s.CTX_SUFF(paBpLocPortIo);
|
---|
| 427 | #else
|
---|
| 428 | # error "Unsupported host context"
|
---|
| 429 | #endif
|
---|
| 430 | if (paBpLocPortIo)
|
---|
| 431 | {
|
---|
| 432 | const uint32_t u32Entry = ASMAtomicReadU32(&paBpLocPortIo[uIoPort]);
|
---|
| 433 | if (u32Entry != DBGF_BP_INT3_L1_ENTRY_TYPE_NULL)
|
---|
| 434 | {
|
---|
| 435 | uint8_t u8Type = DBGF_BP_INT3_L1_ENTRY_GET_TYPE(u32Entry);
|
---|
| 436 | if (RT_LIKELY(u8Type == DBGF_BP_INT3_L1_ENTRY_TYPE_BP_HND))
|
---|
| 437 | {
|
---|
| 438 | DBGFBP hBp = DBGF_BP_INT3_L1_ENTRY_GET_BP_HND(u32Entry);
|
---|
| 439 |
|
---|
| 440 | /* Query the internal breakpoint state from the handle. */
|
---|
| 441 | #ifdef IN_RING3
|
---|
| 442 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp);
|
---|
| 443 | #else
|
---|
| 444 | PDBGFBPINTR0 pBpR0 = NULL;
|
---|
| 445 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
|
---|
| 446 | #endif
|
---|
| 447 | if ( pBp
|
---|
| 448 | && DBGF_BP_PUB_GET_TYPE(&pBp->Pub) == DBGFBPTYPE_PORT_IO)
|
---|
| 449 | {
|
---|
| 450 | if ( uIoPort >= pBp->Pub.u.PortIo.uPort
|
---|
| 451 | && uIoPort < pBp->Pub.u.PortIo.uPort + pBp->Pub.u.PortIo.cPorts
|
---|
| 452 | && pBp->Pub.u.PortIo.fAccess & fAccess
|
---|
| 453 | && ( ( fBefore
|
---|
| 454 | && DBGF_BP_PUB_IS_EXEC_BEFORE(&pBp->Pub))
|
---|
| 455 | || ( !fBefore
|
---|
| 456 | && DBGF_BP_PUB_IS_EXEC_AFTER(&pBp->Pub))))
|
---|
| 457 | #ifdef IN_RING3
|
---|
| 458 | return dbgfBpPortIoHit(pVM, pVCpu, fBefore, fAccess, uIoPort, uValue, hBp, pBp);
|
---|
| 459 | #else
|
---|
| 460 | return dbgfBpPortIoHit(pVM, pVCpu, fBefore, fAccess, uIoPort, uValue, hBp, pBp, pBpR0);
|
---|
| 461 | #endif
|
---|
| 462 | /* else: No matching port I/O breakpoint. */
|
---|
| 463 | }
|
---|
| 464 | else /* Invalid breakpoint handle or not an port I/O breakpoint. */
|
---|
| 465 | return VERR_DBGF_BP_L1_LOOKUP_FAILED;
|
---|
| 466 | }
|
---|
| 467 | else /* Some invalid type. */
|
---|
| 468 | return VERR_DBGF_BP_L1_LOOKUP_FAILED;
|
---|
| 469 | }
|
---|
| 470 | }
|
---|
| 471 |
|
---|
| 472 | return VINF_SUCCESS;
|
---|
| 473 | }
|
---|
| 474 |
|
---|
| 475 |
|
---|
| 476 | /**
|
---|
[86729] | 477 | * \#DB (Debug event) handler.
|
---|
| 478 | *
|
---|
| 479 | * @returns VBox status code.
|
---|
| 480 | * VINF_SUCCESS means we completely handled this trap,
|
---|
| 481 | * other codes are passed execution to host context.
|
---|
| 482 | *
|
---|
| 483 | * @param pVM The cross context VM structure.
|
---|
| 484 | * @param pVCpu The cross context virtual CPU structure.
|
---|
| 485 | * @param pRegFrame Pointer to the register frame for the trap.
|
---|
| 486 | * @param uDr6 The DR6 hypervisor register value.
|
---|
| 487 | * @param fAltStepping Alternative stepping indicator.
|
---|
| 488 | */
|
---|
[86730] | 489 | VMM_INT_DECL(int) DBGFTrap01Handler(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCUINTREG uDr6, bool fAltStepping)
|
---|
[86729] | 490 | {
|
---|
| 491 | /** @todo Intel docs say that X86_DR6_BS has the highest priority... */
|
---|
| 492 | RT_NOREF(pRegFrame);
|
---|
| 493 |
|
---|
| 494 | /*
|
---|
| 495 | * A breakpoint?
|
---|
| 496 | */
|
---|
| 497 | AssertCompile(X86_DR6_B0 == 1 && X86_DR6_B1 == 2 && X86_DR6_B2 == 4 && X86_DR6_B3 == 8);
|
---|
| 498 | if ( (uDr6 & (X86_DR6_B0 | X86_DR6_B1 | X86_DR6_B2 | X86_DR6_B3))
|
---|
| 499 | && pVM->dbgf.s.cEnabledHwBreakpoints > 0)
|
---|
| 500 | {
|
---|
| 501 | for (unsigned iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); iBp++)
|
---|
| 502 | if ( ((uint32_t)uDr6 & RT_BIT_32(iBp))
|
---|
| 503 | && pVM->dbgf.s.aHwBreakpoints[iBp].hBp != NIL_DBGFBP)
|
---|
| 504 | {
|
---|
| 505 | pVCpu->dbgf.s.hBpActive = pVM->dbgf.s.aHwBreakpoints[iBp].hBp;
|
---|
| 506 | pVCpu->dbgf.s.fSingleSteppingRaw = false;
|
---|
| 507 | LogFlow(("DBGFRZTrap03Handler: hit hw breakpoint %x at %04x:%RGv\n",
|
---|
| 508 | pVM->dbgf.s.aHwBreakpoints[iBp].hBp, pRegFrame->cs.Sel, pRegFrame->rip));
|
---|
| 509 |
|
---|
| 510 | return VINF_EM_DBG_BREAKPOINT;
|
---|
| 511 | }
|
---|
| 512 | }
|
---|
| 513 |
|
---|
| 514 | /*
|
---|
| 515 | * Single step?
|
---|
| 516 | * Are we single stepping or is it the guest?
|
---|
| 517 | */
|
---|
[87594] | 518 | if ( (uDr6 & X86_DR6_BS)
|
---|
| 519 | && (pVCpu->dbgf.s.fSingleSteppingRaw || fAltStepping))
|
---|
[86729] | 520 | {
|
---|
| 521 | pVCpu->dbgf.s.fSingleSteppingRaw = false;
|
---|
| 522 | LogFlow(("DBGFRZTrap01Handler: single step at %04x:%RGv\n", pRegFrame->cs.Sel, pRegFrame->rip));
|
---|
| 523 | return VINF_EM_DBG_STEPPED;
|
---|
| 524 | }
|
---|
| 525 |
|
---|
| 526 | LogFlow(("DBGFRZTrap01Handler: guest debug event %#x at %04x:%RGv!\n", (uint32_t)uDr6, pRegFrame->cs.Sel, pRegFrame->rip));
|
---|
| 527 | return VINF_EM_RAW_GUEST_TRAP;
|
---|
| 528 | }
|
---|
| 529 |
|
---|
| 530 |
|
---|
| 531 | /**
|
---|
[1] | 532 | * \#BP (Breakpoint) handler.
|
---|
| 533 | *
|
---|
| 534 | * @returns VBox status code.
|
---|
| 535 | * VINF_SUCCESS means we completely handled this trap,
|
---|
| 536 | * other codes are passed execution to host context.
|
---|
| 537 | *
|
---|
[58122] | 538 | * @param pVM The cross context VM structure.
|
---|
[58123] | 539 | * @param pVCpu The cross context virtual CPU structure.
|
---|
[1] | 540 | * @param pRegFrame Pointer to the register frame for the trap.
|
---|
| 541 | */
|
---|
[92745] | 542 | VMM_INT_DECL(VBOXSTRICTRC) DBGFTrap03Handler(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame)
|
---|
[1] | 543 | {
|
---|
[87594] | 544 | #if defined(IN_RING0)
|
---|
[86749] | 545 | uint32_t volatile *paBpLocL1 = pVM->dbgfr0.s.CTX_SUFF(paBpLocL1);
|
---|
[87594] | 546 | #elif defined(IN_RING3)
|
---|
[86749] | 547 | PUVM pUVM = pVM->pUVM;
|
---|
| 548 | uint32_t volatile *paBpLocL1 = pUVM->dbgf.s.CTX_SUFF(paBpLocL1);
|
---|
[87594] | 549 | #else
|
---|
| 550 | # error "Unsupported host context"
|
---|
| 551 | #endif
|
---|
[86749] | 552 | if (paBpLocL1)
|
---|
[86701] | 553 | {
|
---|
| 554 | RTGCPTR GCPtrBp;
|
---|
| 555 | int rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss.Sel, pRegFrame->cs.Sel, &pRegFrame->cs,
|
---|
| 556 | pRegFrame->rip /* no -1 in R0 */,
|
---|
| 557 | &GCPtrBp);
|
---|
| 558 | AssertRCReturn(rc, rc);
|
---|
| 559 |
|
---|
| 560 | const uint16_t idxL1 = DBGF_BP_INT3_L1_IDX_EXTRACT_FROM_ADDR(GCPtrBp);
|
---|
[86749] | 561 | const uint32_t u32L1Entry = ASMAtomicReadU32(&paBpLocL1[idxL1]);
|
---|
[86701] | 562 |
|
---|
| 563 | LogFlowFunc(("GCPtrBp=%RGv idxL1=%u u32L1Entry=%#x\n", GCPtrBp, idxL1, u32L1Entry));
|
---|
| 564 | if (u32L1Entry != DBGF_BP_INT3_L1_ENTRY_TYPE_NULL)
|
---|
| 565 | {
|
---|
| 566 | uint8_t u8Type = DBGF_BP_INT3_L1_ENTRY_GET_TYPE(u32L1Entry);
|
---|
| 567 | if (u8Type == DBGF_BP_INT3_L1_ENTRY_TYPE_BP_HND)
|
---|
| 568 | {
|
---|
| 569 | DBGFBP hBp = DBGF_BP_INT3_L1_ENTRY_GET_BP_HND(u32L1Entry);
|
---|
| 570 |
|
---|
| 571 | /* Query the internal breakpoint state from the handle. */
|
---|
[87594] | 572 | #ifdef IN_RING3
|
---|
| 573 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp);
|
---|
| 574 | #else
|
---|
[86701] | 575 | PDBGFBPINTR0 pBpR0 = NULL;
|
---|
[87594] | 576 | PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
|
---|
[86749] | 577 | #endif
|
---|
[86701] | 578 | if ( pBp
|
---|
[87776] | 579 | && DBGF_BP_PUB_GET_TYPE(&pBp->Pub) == DBGFBPTYPE_INT3)
|
---|
[86701] | 580 | {
|
---|
| 581 | if (pBp->Pub.u.Int3.GCPtr == (RTGCUINTPTR)GCPtrBp)
|
---|
[87594] | 582 | #ifdef IN_RING3
|
---|
| 583 | rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp);
|
---|
| 584 | #else
|
---|
| 585 | rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
|
---|
[86749] | 586 | #endif
|
---|
[92745] | 587 | else
|
---|
| 588 | rc = VINF_EM_RAW_GUEST_TRAP; /* Genuine guest trap. */
|
---|
[86701] | 589 | }
|
---|
[86729] | 590 | else /* Invalid breakpoint handle or not an int3 breakpoint. */
|
---|
| 591 | rc = VERR_DBGF_BP_L1_LOOKUP_FAILED;
|
---|
[86701] | 592 | }
|
---|
| 593 | else if (u8Type == DBGF_BP_INT3_L1_ENTRY_TYPE_L2_IDX)
|
---|
[86730] | 594 | rc = dbgfBpL2Walk(pVM, pVCpu, pRegFrame, DBGF_BP_INT3_L1_ENTRY_GET_L2_IDX(u32L1Entry),
|
---|
| 595 | DBGF_BP_INT3_L2_KEY_EXTRACT_FROM_ADDR((RTGCUINTPTR)GCPtrBp));
|
---|
[86729] | 596 | else /* Some invalid type. */
|
---|
| 597 | rc = VERR_DBGF_BP_L1_LOOKUP_FAILED;
|
---|
[86701] | 598 | }
|
---|
[92745] | 599 | else
|
---|
| 600 | rc = VINF_EM_RAW_GUEST_TRAP; /* Genuine guest trap. */
|
---|
[86749] | 601 |
|
---|
| 602 | return rc;
|
---|
[86701] | 603 | }
|
---|
[1] | 604 |
|
---|
[86729] | 605 | return VINF_EM_RAW_GUEST_TRAP;
|
---|
[1] | 606 | }
|
---|
| 607 |
|
---|