← Back to branch summary

~ubuntu-branches/ubuntu/raring/virtualbox-ose/raring

« back to all changes in this revision

Viewing changes to src/VBox/VMM/DBGFStack.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-12-18 16:44:29 UTC
  • mfrom: (0.3.3 upstream) (0.4.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091218164429-jd34ccexpv5na11a
Tags: 3.1.2-dfsg-1ubuntu1
https://launchpad.net/bugs/498219
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/474625
https://launchpad.net/bugs/495935
https://launchpad.net/bugs/473334
* Merge from Debian unstable (LP: #498219), remaining changes:
  - Disable update action
    - debian/patches/u01-disable-update-action.dpatch
  - VirtualBox should go in Accessories, not in System tools (LP: #288590)
    - debian/virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add Apport hook
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Add Launchpad integration
    - debian/control
    - debian/lpi-bug.xpm
    - debian/patches/u02-lp-integration.dpatch
* Fixes the following bugs:
  - Kernel module fails to build with Linux >= 2.6.32 (LP: #474625)
  - X.Org drivers need to be rebuilt against X-Server 1.7 (LP: #495935)
  - The *-source packages try to build the kernel modules even though the
    kernel headers aren't available (LP: #473334)
* Replace *-source packages with transitional packages for *-dkms.
* Adapt u01-disable-update-action.dpatch and u02-lp-integration.dpatch for
  new upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/VMM/DBGFStack.cpp
80
80
 * @todo Add AMD64 support (needs teaming up with the module management for
81
81
 *       unwind tables).
82
82
 */
83
 
static int dbgfR3StackWalk(PVM pVM, VMCPUID idCpu, PDBGFSTACKFRAME pFrame)
 
83
static int dbgfR3StackWalk(PVM pVM, VMCPUID idCpu, RTDBGAS hAs, PDBGFSTACKFRAME pFrame)
84
84
{
85
85
    /*
86
86
     * Stop if we got a read error in the previous run.
100
100
        case DBGFADDRESS_FLAGS_FAR32: cbStackItem = 4; break;
101
101
        case DBGFADDRESS_FLAGS_FAR64: cbStackItem = 8; break;
102
102
        case DBGFADDRESS_FLAGS_RING0: cbStackItem = sizeof(RTHCUINTPTR); break;
103
 
        default:                      cbStackItem = 4; break; /// @todo 64-bit guests.
 
103
        default:
 
104
            switch (pFrame->enmReturnType)
 
105
            {
 
106
                case DBGFRETURNTYPE_FAR16:
 
107
                case DBGFRETURNTYPE_IRET16:
 
108
                case DBGFRETURNTYPE_IRET32_V86:
 
109
                case DBGFRETURNTYPE_NEAR16: cbStackItem = 2; break;
 
110
 
 
111
                case DBGFRETURNTYPE_FAR32:
 
112
                case DBGFRETURNTYPE_IRET32:
 
113
                case DBGFRETURNTYPE_IRET32_PRIV:
 
114
                case DBGFRETURNTYPE_NEAR32: cbStackItem = 4; break;
 
115
 
 
116
                case DBGFRETURNTYPE_FAR64:
 
117
                case DBGFRETURNTYPE_IRET64:
 
118
                case DBGFRETURNTYPE_NEAR64: cbStackItem = 8; break;
 
119
 
 
120
                default:
 
121
                    AssertMsgFailed(("%d\n", pFrame->enmReturnType));
 
122
                    cbStackItem = 4;
 
123
                    break;
 
124
            }
104
125
    }
105
126
 
106
127
    union
138
159
        /* Current PC - set by caller, just find symbol & line. */
139
160
        if (DBGFADDRESS_IS_VALID(&pFrame->AddrPC))
140
161
        {
141
 
            pFrame->pSymPC  = DBGFR3SymbolByAddrAlloc(pVM, pFrame->AddrPC.FlatPtr, NULL);
 
162
            pFrame->pSymPC  = DBGFR3AsSymbolByAddrA(pVM, hAs, &pFrame->AddrPC, NULL /*offDisp*/, NULL /*phMod*/);
142
163
            pFrame->pLinePC = DBGFR3LineByAddrAlloc(pVM, pFrame->AddrPC.FlatPtr, NULL);
143
164
        }
144
165
    }
234
255
            return VERR_INVALID_PARAMETER;
235
256
    }
236
257
 
237
 
    pFrame->pSymReturnPC  = DBGFR3SymbolByAddrAlloc(pVM, pFrame->AddrReturnPC.FlatPtr, NULL);
 
258
    pFrame->pSymReturnPC  = DBGFR3AsSymbolByAddrA(pVM, hAs, &pFrame->AddrReturnPC, NULL /*offDisp*/, NULL /*phMod*/);
238
259
    pFrame->pLineReturnPC = DBGFR3LineByAddrAlloc(pVM, pFrame->AddrReturnPC.FlatPtr, NULL);
239
260
 
240
261
    /*
 
262
     * Frame bitness flag.
 
263
     */
 
264
    switch (cbStackItem)
 
265
    {
 
266
        case 2: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_16BIT; break;
 
267
        case 4: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_32BIT; break;
 
268
        case 8: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_64BIT; break;
 
269
        default:    AssertMsgFailed(("cbStackItem=%d\n", cbStackItem)); return VERR_INTERNAL_ERROR;
 
270
    }
 
271
 
 
272
    /*
241
273
     * The arguments.
242
274
     */
243
275
    memcpy(&pFrame->Args, uArgs.pv, sizeof(pFrame->Args));
249
281
/**
250
282
 * Walks the entire stack allocating memory as we walk.
251
283
 */
252
 
static DECLCALLBACK(int) dbgfR3StackWalkCtxFull(PVM pVM, VMCPUID idCpu, PCCPUMCTXCORE pCtxCore,
 
284
static DECLCALLBACK(int) dbgfR3StackWalkCtxFull(PVM pVM, VMCPUID idCpu, PCCPUMCTXCORE pCtxCore, RTDBGAS hAs,
253
285
                                                DBGFCODETYPE enmCodeType,
254
286
                                                PCDBGFADDRESS pAddrFrame,
255
287
                                                PCDBGFADDRESS pAddrStack,
281
313
                case DBGFADDRESS_FLAGS_FAR16: pCur->enmReturnType = DBGFRETURNTYPE_NEAR16; break;
282
314
                case DBGFADDRESS_FLAGS_FAR32: pCur->enmReturnType = DBGFRETURNTYPE_NEAR32; break;
283
315
                case DBGFADDRESS_FLAGS_FAR64: pCur->enmReturnType = DBGFRETURNTYPE_NEAR64; break;
284
 
                case DBGFADDRESS_FLAGS_RING0: pCur->enmReturnType = (HC_ARCH_BITS == 64) ? DBGFRETURNTYPE_NEAR64 : DBGFRETURNTYPE_NEAR32; break;
 
316
                case DBGFADDRESS_FLAGS_RING0: pCur->enmReturnType = HC_ARCH_BITS == 64 ? DBGFRETURNTYPE_NEAR64 : DBGFRETURNTYPE_NEAR32; break;
285
317
                default:                      pCur->enmReturnType = DBGFRETURNTYPE_NEAR32; break; /// @todo 64-bit guests
286
318
            }
287
319
 
288
 
        uint64_t fAddrMask = UINT64_MAX;
 
320
        uint64_t fAddrMask;
289
321
        if (enmCodeType == DBGFCODETYPE_RING0)
290
 
            fAddrMask = (HC_ARCH_BITS == 64) ? UINT64_MAX : UINT32_MAX;
291
 
        else
292
 
        if (enmCodeType == DBGFCODETYPE_HYPER)
 
322
            fAddrMask = HC_ARCH_BITS == 64 ? UINT64_MAX : UINT32_MAX;
 
323
        else if (enmCodeType == DBGFCODETYPE_HYPER)
293
324
            fAddrMask = UINT32_MAX;
294
325
        else if (DBGFADDRESS_IS_FAR16(&pCur->AddrPC))
295
326
            fAddrMask = UINT16_MAX;
296
327
        else if (DBGFADDRESS_IS_FAR32(&pCur->AddrPC))
297
328
            fAddrMask = UINT32_MAX;
298
 
        else if (DBGFADDRESS_IS_FLAT(&pCur->AddrPC))
 
329
        else if (DBGFADDRESS_IS_FAR64(&pCur->AddrPC))
 
330
            fAddrMask = UINT64_MAX;
 
331
        else
299
332
        {
300
 
            CPUMMODE CpuMode = CPUMGetGuestMode(VMMGetCpuById(pVM, idCpu));
 
333
            PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
 
334
            CPUMMODE CpuMode = CPUMGetGuestMode(pVCpu);
301
335
            if (CpuMode == CPUMMODE_REAL)
302
336
                fAddrMask = UINT16_MAX;
303
 
            else if (CpuMode == CPUMMODE_PROTECTED)
 
337
            else if (   CpuMode == CPUMMODE_PROTECTED
 
338
                     || !CPUMIsGuestIn64BitCode(pVCpu, pCtxCore))
304
339
                fAddrMask = UINT32_MAX;
 
340
            else
 
341
                fAddrMask = UINT64_MAX;
305
342
        }
306
343
 
307
344
        if (pAddrStack)
321
358
     * The first frame.
322
359
     */
323
360
    if (RT_SUCCESS(rc))
324
 
        rc = dbgfR3StackWalk(pVM, idCpu, pCur);
 
361
        rc = dbgfR3StackWalk(pVM, idCpu, hAs, pCur);
325
362
    if (RT_FAILURE(rc))
326
363
    {
327
364
        DBGFR3StackWalkEnd(pCur);
335
372
    while (!(pCur->fFlags & (DBGFSTACKFRAME_FLAGS_LAST | DBGFSTACKFRAME_FLAGS_MAX_DEPTH | DBGFSTACKFRAME_FLAGS_LOOP)))
336
373
    {
337
374
        /* try walk. */
338
 
        rc = dbgfR3StackWalk(pVM, idCpu, &Next);
 
375
        rc = dbgfR3StackWalk(pVM, idCpu, hAs, &Next);
339
376
        if (RT_FAILURE(rc))
340
377
            break;
341
378
 
389
426
    if (enmCodeType == DBGFCODETYPE_RING0)
390
427
        return VINF_SUCCESS;
391
428
#endif
 
429
 
392
430
    /*
393
431
     * Validate parameters.
394
432
     */
395
433
    *ppFirstFrame = NULL;
396
434
    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
397
 
    AssertReturn(idCpu < pVM->cCPUs, VERR_INVALID_CPU_ID);
 
435
    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
398
436
    if (pAddrFrame)
399
437
        AssertReturn(DBGFR3AddrIsValid(pVM, pAddrFrame), VERR_INVALID_PARAMETER);
400
438
    if (pAddrStack)
406
444
    /*
407
445
     * Get the CPUM context pointer and pass it on the specified EMT.
408
446
     */
 
447
    RTDBGAS         hAs;
409
448
    PCCPUMCTXCORE   pCtxCore;
410
449
    switch (enmCodeType)
411
450
    {
412
451
        case DBGFCODETYPE_GUEST:
413
452
            pCtxCore = CPUMGetGuestCtxCore(VMMGetCpuById(pVM, idCpu));
 
453
            hAs = DBGF_AS_GLOBAL;
414
454
            break;
415
455
        case DBGFCODETYPE_HYPER:
416
456
            pCtxCore = CPUMGetHyperCtxCore(VMMGetCpuById(pVM, idCpu));
 
457
            hAs = DBGF_AS_RC_AND_GC_GLOBAL;
417
458
            break;
418
459
        case DBGFCODETYPE_RING0:
419
460
            pCtxCore = NULL;    /* No valid context present. */
 
461
            hAs = DBGF_AS_R0;
420
462
            break;
421
463
        default:
422
464
            AssertFailedReturn(VERR_INVALID_PARAMETER);
423
465
    }
424
 
    PVMREQ pReq;
425
 
    int rc = VMR3ReqCall(pVM, idCpu, &pReq, RT_INDEFINITE_WAIT,
426
 
                         (PFNRT)dbgfR3StackWalkCtxFull, 9,
427
 
                         pVM, idCpu, pCtxCore, enmCodeType,
428
 
                         pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
429
 
    if (RT_SUCCESS(rc))
430
 
        rc = pReq->iStatus;
431
 
    VMR3ReqFree(pReq);
432
 
 
433
 
    return rc;
434
 
 
 
466
    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3StackWalkCtxFull, 10,
 
467
                           pVM, idCpu, pCtxCore, hAs, enmCodeType,
 
468
                           pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
435
469
}
436
470
 
437
471
 
547
581
                pFrame->pLineReturnPC = NULL;
548
582
        }
549
583
 
550
 
        DBGFR3SymbolFree(pCur->pSymPC);
551
 
        DBGFR3SymbolFree(pCur->pSymReturnPC);
 
584
        RTDbgSymbolFree(pCur->pSymPC);
 
585
        RTDbgSymbolFree(pCur->pSymReturnPC);
552
586
        DBGFR3LineFree(pCur->pLinePC);
553
587
        DBGFR3LineFree(pCur->pLineReturnPC);
554
588