VirtualBox

Changeset 61786 in vbox


Ignore:
Timestamp:
Jun 21, 2016 9:27:42 AM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
108180
Message:

Main/MachineDebugger: Pause the VM before querying the guest stack or we risk running into deadlocks or inconsistent stacks

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp

    r61561 r61786  
    13591359    if (SUCCEEDED(hrc))
    13601360    {
    1361         PCDBGFSTACKFRAME pFirstFrame;
    1362 
    1363         int vrc = DBGFR3StackWalkBegin(ptrVM.rawUVM(), aCpuId, DBGFCODETYPE_GUEST, &pFirstFrame);
     1361        /* Suspend the VM first or we risk deadlocks or inconsistent guest stacks. */
     1362        alock.release();
     1363        int vrc = VMR3Suspend(ptrVM.rawUVM(), VMSUSPENDREASON_USER);
     1364        alock.acquire();
    13641365        if (RT_SUCCESS(vrc))
    13651366        {
    1366             /*
    1367              * Print header.
    1368              */
    1369             try
     1367            PCDBGFSTACKFRAME pFirstFrame;
     1368
     1369            vrc = DBGFR3StackWalkBegin(ptrVM.rawUVM(), aCpuId, DBGFCODETYPE_GUEST, &pFirstFrame);
     1370            if (RT_SUCCESS(vrc))
    13701371            {
    1371                 uint32_t fBitFlags = 0;
    1372                 for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
    1373                      pFrame;
    1374                      pFrame = DBGFR3StackWalkNext(pFrame))
     1372                /*
     1373                 * Print header.
     1374                 */
     1375                try
    13751376                {
    1376                     uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT | DBGFSTACKFRAME_FLAGS_32BIT | DBGFSTACKFRAME_FLAGS_64BIT);
    1377                     if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
     1377                    uint32_t fBitFlags = 0;
     1378                    for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
     1379                         pFrame;
     1380                         pFrame = DBGFR3StackWalkNext(pFrame))
    13781381                    {
    1379                         if (fCurBitFlags != fBitFlags)
    1380                             aStack.append("SS:BP     Ret SS:BP Ret CS:EIP    Arg0     Arg1     Arg2     Arg3     CS:EIP / Symbol [line]\n");
    1381                         aStack.append(Utf8StrFmt("%04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
    1382                                                  pFrame->AddrFrame.Sel,
    1383                                                  (uint16_t)pFrame->AddrFrame.off,
    1384                                                  pFrame->AddrReturnFrame.Sel,
    1385                                                  (uint16_t)pFrame->AddrReturnFrame.off,
    1386                                                  (uint32_t)pFrame->AddrReturnPC.Sel,
    1387                                                  (uint32_t)pFrame->AddrReturnPC.off,
    1388                                                  pFrame->Args.au32[0],
    1389                                                  pFrame->Args.au32[1],
    1390                                                  pFrame->Args.au32[2],
    1391                                                  pFrame->Args.au32[3]));
     1382                        uint32_t const fCurBitFlags = pFrame->fFlags & (DBGFSTACKFRAME_FLAGS_16BIT | DBGFSTACKFRAME_FLAGS_32BIT | DBGFSTACKFRAME_FLAGS_64BIT);
     1383                        if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_16BIT)
     1384                        {
     1385                            if (fCurBitFlags != fBitFlags)
     1386                                aStack.append("SS:BP     Ret SS:BP Ret CS:EIP    Arg0     Arg1     Arg2     Arg3     CS:EIP / Symbol [line]\n");
     1387                            aStack.append(Utf8StrFmt("%04RX16:%04RX16 %04RX16:%04RX16 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
     1388                                                     pFrame->AddrFrame.Sel,
     1389                                                     (uint16_t)pFrame->AddrFrame.off,
     1390                                                     pFrame->AddrReturnFrame.Sel,
     1391                                                     (uint16_t)pFrame->AddrReturnFrame.off,
     1392                                                     (uint32_t)pFrame->AddrReturnPC.Sel,
     1393                                                     (uint32_t)pFrame->AddrReturnPC.off,
     1394                                                     pFrame->Args.au32[0],
     1395                                                     pFrame->Args.au32[1],
     1396                                                     pFrame->Args.au32[2],
     1397                                                     pFrame->Args.au32[3]));
     1398                        }
     1399                        else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
     1400                        {
     1401                            if (fCurBitFlags != fBitFlags)
     1402                                aStack.append("EBP      Ret EBP  Ret CS:EIP    Arg0     Arg1     Arg2     Arg3     CS:EIP / Symbol [line]\n");
     1403                            aStack.append(Utf8StrFmt("%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
     1404                                                     (uint32_t)pFrame->AddrFrame.off,
     1405                                                     (uint32_t)pFrame->AddrReturnFrame.off,
     1406                                                     (uint32_t)pFrame->AddrReturnPC.Sel,
     1407                                                     (uint32_t)pFrame->AddrReturnPC.off,
     1408                                                     pFrame->Args.au32[0],
     1409                                                     pFrame->Args.au32[1],
     1410                                                     pFrame->Args.au32[2],
     1411                                                     pFrame->Args.au32[3]));
     1412                        }
     1413                        else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
     1414                        {
     1415                            if (fCurBitFlags != fBitFlags)
     1416                                aStack.append("RBP              Ret SS:RBP            Ret RIP          CS:RIP / Symbol [line]\n");
     1417                            aStack.append(Utf8StrFmt("%016RX64 %04RX16:%016RX64 %016RX64",
     1418                                                     (uint64_t)pFrame->AddrFrame.off,
     1419                                                     pFrame->AddrReturnFrame.Sel,
     1420                                                     (uint64_t)pFrame->AddrReturnFrame.off,
     1421                                                     (uint64_t)pFrame->AddrReturnPC.off));
     1422                        }
     1423
     1424                        if (!pFrame->pSymPC)
     1425                            aStack.append(Utf8StrFmt(fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
     1426                                                     ? " %RTsel:%016RGv"
     1427                                                     : fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
     1428                                                     ? " %RTsel:%08RGv"
     1429                                                     : " %RTsel:%04RGv"
     1430                                                     , pFrame->AddrPC.Sel, pFrame->AddrPC.off));
     1431                        else
     1432                        {
     1433                            RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
     1434                            if (offDisp > 0)
     1435                                aStack.append(Utf8StrFmt(" %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp));
     1436                            else if (offDisp < 0)
     1437                                aStack.append(Utf8StrFmt(" %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp));
     1438                            else
     1439                                aStack.append(Utf8StrFmt(" %s", pFrame->pSymPC->szName));
     1440                        }
     1441                        if (pFrame->pLinePC)
     1442                            aStack.append(Utf8StrFmt(" [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo));
     1443                        aStack.append(Utf8StrFmt("\n"));
     1444
     1445                        fBitFlags = fCurBitFlags;
    13921446                    }
    1393                     else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT)
    1394                     {
    1395                         if (fCurBitFlags != fBitFlags)
    1396                             aStack.append("EBP      Ret EBP  Ret CS:EIP    Arg0     Arg1     Arg2     Arg3     CS:EIP / Symbol [line]\n");
    1397                         aStack.append(Utf8StrFmt("%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
    1398                                                  (uint32_t)pFrame->AddrFrame.off,
    1399                                                  (uint32_t)pFrame->AddrReturnFrame.off,
    1400                                                  (uint32_t)pFrame->AddrReturnPC.Sel,
    1401                                                  (uint32_t)pFrame->AddrReturnPC.off,
    1402                                                  pFrame->Args.au32[0],
    1403                                                  pFrame->Args.au32[1],
    1404                                                  pFrame->Args.au32[2],
    1405                                                  pFrame->Args.au32[3]));
    1406                     }
    1407                     else if (fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT)
    1408                     {
    1409                         if (fCurBitFlags != fBitFlags)
    1410                             aStack.append("RBP              Ret SS:RBP            Ret RIP          CS:RIP / Symbol [line]\n");
    1411                         aStack.append(Utf8StrFmt("%016RX64 %04RX16:%016RX64 %016RX64",
    1412                                                  (uint64_t)pFrame->AddrFrame.off,
    1413                                                  pFrame->AddrReturnFrame.Sel,
    1414                                                  (uint64_t)pFrame->AddrReturnFrame.off,
    1415                                                  (uint64_t)pFrame->AddrReturnPC.off));
    1416                     }
    1417 
    1418                     if (!pFrame->pSymPC)
    1419                         aStack.append(Utf8StrFmt(fCurBitFlags & DBGFSTACKFRAME_FLAGS_64BIT
    1420                                                  ? " %RTsel:%016RGv"
    1421                                                  : fCurBitFlags & DBGFSTACKFRAME_FLAGS_32BIT
    1422                                                  ? " %RTsel:%08RGv"
    1423                                                  : " %RTsel:%04RGv"
    1424                                                  , pFrame->AddrPC.Sel, pFrame->AddrPC.off));
    1425                     else
    1426                     {
    1427                         RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value; /** @todo this isn't 100% correct for segmented stuff. */
    1428                         if (offDisp > 0)
    1429                             aStack.append(Utf8StrFmt(" %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp));
    1430                         else if (offDisp < 0)
    1431                             aStack.append(Utf8StrFmt(" %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp));
    1432                         else
    1433                             aStack.append(Utf8StrFmt(" %s", pFrame->pSymPC->szName));
    1434                     }
    1435                     if (pFrame->pLinePC)
    1436                         aStack.append(Utf8StrFmt(" [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo));
    1437                     aStack.append(Utf8StrFmt("\n"));
    1438 
    1439                     fBitFlags = fCurBitFlags;
    14401447                }
     1448                catch (std::bad_alloc)
     1449                {
     1450                    hrc = E_OUTOFMEMORY;
     1451                }
     1452
     1453                DBGFR3StackWalkEnd(pFirstFrame);
    14411454            }
    1442             catch (std::bad_alloc)
    1443             {
    1444                 hrc = E_OUTOFMEMORY;
    1445             }
    1446 
    1447             DBGFR3StackWalkEnd(pFirstFrame);
     1455            else
     1456                hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
     1457
     1458            alock.release();
     1459            VMR3Resume(ptrVM.rawUVM(), VMRESUMEREASON_USER);
     1460            alock.acquire();
    14481461        }
    14491462        else
    1450             hrc = setError(E_FAIL, tr("DBGFR3StackWalkBegin failed with %Rrc"), vrc);
     1463            hrc = setError(E_FAIL, tr("Suspending the VM failed with %Rrc\n"), vrc);
    14511464    }
    14521465
Note: See TracChangeset for help on using the changeset viewer.

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