VirtualBox

Changeset 60302 in vbox


Ignore:
Timestamp:
Apr 4, 2016 11:39:14 AM (9 years ago)
Author:
vboxsync
Message:

bs3kit,bs3-cpu-basic-2: 486 fixes. Promoted g_uLine to a genric feature and display it during trap reporting. Now called g_usBs3TestStep.

Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-basic-2-c.c

    r60291 r60302  
    5757    Bs3InitAll_rm();
    5858    Bs3TestInit("bs3-cpu-basic-2");
     59Bs3TestPrintf("g_uBs3CpuDetected=%#x\n", g_uBs3CpuDetected);
    5960
    6061    Bs3TestDoModes_rm(g_aModeTest, RT_ELEMENTS(g_aModeTest));

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-basic-2-template.c

    r60296 r60302  
    107107#define g_f16BitSys     BS3_CMN_NM(g_f16BitSys)
    108108static bool                 g_f16BitSys = 1;
    109 #define g_uLine         BS3_CMN_NM(g_uLine)
    110 static unsigned             g_uLine = 1;
    111109
    112110/** Table containing invalid CS selector types. */
    … …  
    173171
    174172/**
    175  * Wrapper around Bs3TestFailedF that prefixes the error with g_uLine and
    176  * g_pszTestMode.
     173 * Wrapper around Bs3TestFailedF that prefixes the error with g_usBs3TestStep
     174 * and g_pszTestMode.
    177175 */
     176#define bs3CpuBasic2_FailedF BS3_CMN_NM(bs3CpuBasic2_FailedF)
    178177void bs3CpuBasic2_FailedF(const char *pszFormat, ...)
    179178{
    … …  
    185184    va_end(va);
    186185
    187     Bs3TestFailedF("%u - %s: %s", g_uLine, g_pszTestMode, szTmp);
     186    Bs3TestFailedF("%u - %s: %s", g_usBs3TestStep, g_pszTestMode, szTmp);
    188187}
    189188
    … …  
    198197    CHECK_MEMBER("bXcpt",   "%#04x",    pTrapCtx->bXcpt,        bXcpt);
    199198    CHECK_MEMBER("bErrCd",  "%#06RX64", pTrapCtx->uErrCd,       0);
    200     Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, 2 /*int xx*/, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, g_pszTestMode, g_uLine);
     199    Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, 2 /*int xx*/, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, g_pszTestMode, g_usBs3TestStep);
    201200    if (Bs3TestSubErrorCount() != cErrorsBefore)
    202201    {
    203 //Bs3TestPrintf("%s\n",  __FUNCTION__);
    204202        Bs3TrapPrintFrame(pTrapCtx);
    205 ASMHalt();
     203#if 1
     204        Bs3TestPrintf("Halting: g_uBs3CpuDetected=%#x\n", BS3_DATA_NM(g_uBs3CpuDetected));
     205        Bs3TestPrintf("Halting in CompareTrapCtx1: bXcpt=%#x\n", bXcpt);
     206        ASMHalt();
     207#endif
    206208    }
    207209}
    … …  
    219221    CHECK_MEMBER("bErrCd",  "%#06RX64", pTrapCtx->uErrCd,       0);
    220222    CHECK_MEMBER("uHandlerCs", "%#06x", pTrapCtx->uHandlerCs,   uHandlerCs);
    221     Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, cbIpAdjust, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, g_pszTestMode, g_uLine);
     223    Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, cbIpAdjust, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/, g_pszTestMode, g_usBs3TestStep);
    222224    if (Bs3TestSubErrorCount() != cErrorsBefore)
    223225    {
    224 //Bs3TestPrintf("%s\n",  __FUNCTION__);
    225226        Bs3TrapPrintFrame(pTrapCtx);
    226 ASMHalt();
     227#if 1
     228        Bs3TestPrintf("Halting: g_uBs3CpuDetected=%#x\n", BS3_DATA_NM(g_uBs3CpuDetected));
     229        Bs3TestPrintf("Halting in CompareTrapCtx2: bXcpt=%#x\n", bXcpt);
     230        ASMHalt();
     231#endif
    227232    }
    228233}
    … …  
    232237 */
    233238#define bs3CpuBasic2_CompareCpuTrapCtx BS3_CMN_NM(bs3CpuBasic2_CompareCpuTrapCtx)
    234 BS3_DECL(void) bs3CpuBasic2_CompareCpuTrapCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd, uint8_t bXcpt)
     239BS3_DECL(void) bs3CpuBasic2_CompareCpuTrapCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd, uint8_t bXcpt,
     240                                              bool f486ResumeFlagHint)
    235241{
    236242    uint16_t const cErrorsBefore = Bs3TestSubErrorCount();
     243    uint32_t fExtraEfl;
     244
    237245    CHECK_MEMBER("bXcpt",   "%#04x",    pTrapCtx->bXcpt,        bXcpt);
    238     CHECK_MEMBER("bErrCd",  "%#06RX64", pTrapCtx->uErrCd,       (uint64_t)uErrCd);
    239     Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, 0 /*cbIpAdjust*/, 0 /*cbSpAdjust*/,
    240                          g_f16BitSys ? 0 : X86_EFL_RF,
    241                          g_pszTestMode, g_uLine);
     246    CHECK_MEMBER("bErrCd",  "%#06RX16", (uint16_t)pTrapCtx->uErrCd, (uint16_t)uErrCd); /* 486 only writes a word */
     247
     248    fExtraEfl = X86_EFL_RF;
     249    if (   g_f16BitSys
     250        || (   !f486ResumeFlagHint
     251            && (BS3_DATA_NM(g_uBs3CpuDetected) & BS3CPU_TYPE_MASK) <= BS3CPU_80486 ) )
     252        fExtraEfl = 0;
     253    else
     254        fExtraEfl = X86_EFL_RF;
     255    Bs3TestCheckRegCtxEx(&pTrapCtx->Ctx, pStartCtx, 0 /*cbIpAdjust*/, 0 /*cbSpAdjust*/, fExtraEfl, g_pszTestMode, g_usBs3TestStep);
    242256    if (Bs3TestSubErrorCount() != cErrorsBefore)
    243257    {
    244 //Bs3TestPrintf("%s\n",  __FUNCTION__);
    245258        Bs3TrapPrintFrame(pTrapCtx);
    246 ASMHalt();
     259#if 1
     260        Bs3TestPrintf("Halting: g_uBs3CpuDetected=%#x\n", BS3_DATA_NM(g_uBs3CpuDetected));
     261        Bs3TestPrintf("Halting: bXcpt=%#x uErrCd=%#x\n", bXcpt, uErrCd);
     262        ASMHalt();
     263#endif
    247264    }
    248265}
    … …  
    255272void bs3CpuBasic2_CompareGpCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd)
    256273{
    257     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_GP);
     274    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_GP, true /*f486ResumeFlagHint*/);
    258275}
    259276
    … …  
    264281void bs3CpuBasic2_CompareNpCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd)
    265282{
    266     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_NP);
     283    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_NP, true /*f486ResumeFlagHint*/);
    267284}
    268285
    … …  
    271288 */
    272289#define bs3CpuBasic2_CompareSsCtx BS3_CMN_NM(bs3CpuBasic2_CompareSsCtx)
    273 void bs3CpuBasic2_CompareSsCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd)
    274 {
    275     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_SS);
     290void bs3CpuBasic2_CompareSsCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd, bool f486ResumeFlagHint)
     291{
     292    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_SS, f486ResumeFlagHint);
    276293}
    277294
    … …  
    282299void bs3CpuBasic2_CompareTsCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx, uint16_t uErrCd)
    283300{
    284     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_TS);
     301    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_TS, false /*f486ResumeFlagHint*/);
    285302}
    286303
    … …  
    293310    uint64_t const uCr2Saved     = pStartCtx->cr2.u;
    294311    pStartCtx->cr2.u = uCr2Expected;
    295     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_PF);
     312    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, uErrCd, X86_XCPT_PF, true /*f486ResumeFlagHint*/);
    296313    pStartCtx->cr2.u = uCr2Saved;
    297314}
    … …  
    303320void bs3CpuBasic2_CompareUdCtx(PCBS3TRAPFRAME pTrapCtx, PCBS3REGCTX pStartCtx)
    304321{
    305     bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, 0 /*no error code*/, X86_XCPT_UD);
     322    bs3CpuBasic2_CompareCpuTrapCtx(pTrapCtx, pStartCtx, 0 /*no error code*/, X86_XCPT_UD, true /*f486ResumeFlagHint*/);
    306323}
    307324
    … …  
    394411    for (iCtx = 0; iCtx < RT_ELEMENTS(apCtx8x); iCtx++)
    395412    {
    396         g_uLine = iCtx;
     413        g_usBs3TestStep = iCtx;
    397414# if TMPL_BITS == 32
    398415        BS3_DATA_NM(g_uBs3TrapEipHint) = apCtx8x[iCtx]->rip.u32;
    … …  
    405422     * Check that the gate DPL checks works.
    406423     */
    407     g_uLine = 100;
     424    g_usBs3TestStep = 100;
    408425    for (iRing = 0; iRing <= 3; iRing++)
    409426    {
    … …  
    416433# endif
    417434            Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    418             g_uLine++;
    419435            if (iCtx < iRing)
    420436                bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, ((0x80 + iCtx) << X86_TRAP_ERR_SEL_SHIFT) | X86_TRAP_ERR_IDT);
    421437            else
    422438                bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &CtxTmp, 0x80 + iCtx /*bXcpt*/);
     439            g_usBs3TestStep++;
    423440        }
    424441    }
    … …  
    432449     *      3. GATE.CS.DPL <= CPL (non-conforming segments)
    433450     */
    434     g_uLine = 1000;
     451    g_usBs3TestStep = 1000;
    435452    for (i = 0; i <= 3; i++)
    436453    {
    … …  
    450467                    for (k = 0; k < 2; k++)
    451468                    {
    452                         g_uLine++;
    453                         /*Bs3TestPrintf("g_uLine=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_uLine,  iCtx,  iRing, i, uCs);*/
     469                        g_usBs3TestStep++;
     470                        /*Bs3TestPrintf("g_usBs3TestStep=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_usBs3TestStep,  iCtx,  iRing, i, uCs);*/
    454471                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u16Sel = uCs;
    455472                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u1Present = k;
    … …  
    477494        }
    478495    }
    479     BS3_ASSERT(g_uLine < 1600);
     496    BS3_ASSERT(g_usBs3TestStep < 1600);
    480497
    481498    /*
    … …  
    486503     * without making it impossible to handle faults.
    487504     */
    488     g_uLine = 1600;
     505    g_usBs3TestStep = 1600;
    489506    BS3_DATA_NM(Bs3GdteTestPage00) = BS3_DATA_NM(Bs3Gdt)[uSysR0Cs >> X86_SEL_SHIFT];
    490507    BS3_DATA_NM(Bs3GdteTestPage00).Gen.u1Present = 0;
    … …  
    497514    if (BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED)
    498515        bs3CpuBasic2_FailedF("selector was accessed");
    499     g_uLine++;
     516    g_usBs3TestStep++;
    500517
    501518    /* Check that GATE.DPL is checked before CS.PRESENT. */
    … …  
    508525        if (BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED)
    509526            bs3CpuBasic2_FailedF("selector was accessed");
    510         g_uLine++;
     527        g_usBs3TestStep++;
    511528    }
    512529
    … …  
    517534    if (BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED)
    518535        bs3CpuBasic2_FailedF("CS selector was accessed");
    519     g_uLine++;
     536    g_usBs3TestStep++;
    520537    for (iDpl = 1; iDpl < 4; iDpl++)
    521538    {
    … …  
    525542        if (BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED)
    526543            bs3CpuBasic2_FailedF("CS selector was accessed");
    527         g_uLine++;
    528     }
    529 
    530     /* Check all the invalid CS selector types alone. */
     544        g_usBs3TestStep++;
     545    }
     546
     547    /* 1608: Check all the invalid CS selector types alone. */
    531548    BS3_DATA_NM(Bs3GdteTestPage00) = BS3_DATA_NM(Bs3Gdt)[uSysR0Cs >> X86_SEL_SHIFT];
    532549    for (i = 0; i < RT_ELEMENTS(g_aInvalidCsTypes); i++)
    … …  
    540557                                 g_aInvalidCsTypes[i].u4Type, g_aInvalidCsTypes[i].u1DescType,
    541558                                 BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type, BS3_DATA_NM(Bs3GdteTestPage00).Gen.u1DescType);
    542         g_uLine++;
     559        g_usBs3TestStep++;
    543560
    544561        /* Incorrect CS.TYPE takes precedence over CS.PRESENT = 0. */
    … …  
    547564        bs3CpuBasic2_CompareGpCtx(&TrapCtx, &Ctx80, BS3_SEL_TEST_PAGE_00);
    548565        BS3_DATA_NM(Bs3GdteTestPage00).Gen.u1Present = 1;
    549         g_uLine++;
     566        g_usBs3TestStep++;
    550567    }
    551568
    … …  
    553570    BS3_DATA_NM(Bs3GdteTestPage00) = BS3_DATA_NM(Bs3Gdt)[uSysR0Cs >> X86_SEL_SHIFT];
    554571
    555     /* Test SS. */
     572    /* 1632: Test SS. */
    556573    if (!BS3_MODE_IS_64BIT_SYS(g_bTestMode))
    557574    {
    … …  
    571588        if (!(BS3_DATA_NM(Bs3GdteTestPage02).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    572589            bs3CpuBasic2_FailedF("CS selector was not access");
    573         g_uLine++;
     590        g_usBs3TestStep++;
    574591
    575592        /* Create a SS.DPL=2 stack segment and check that SS2.RPL matters and
    … …  
    614631                {
    615632                    *puTssSs2 = BS3_SEL_TEST_PAGE_03 | iRpl;
     633                    //Bs3TestPrintf("k=%u iDpl=%u iRpl=%u step=%u\n", k, iDpl, iRpl, g_usBs3TestStep);
    616634                    BS3_DATA_NM(Bs3GdteTestPage02).Gen.u4Type &= ~X86_SEL_TYPE_ACCESSED;
    617635                    BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type &= ~X86_SEL_TYPE_ACCESSED;
    … …  
    620638                        bs3CpuBasic2_CompareTsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
    621639                    else if (k != 0)
    622                         bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
     640                        bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03,
     641                                                  k == 2 /*f486ResumeFlagHint*/);
    623642                    else
    624643                    {
    … …  
    637656                    else if (BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type & X86_SEL_TYPE_ACCESSED)
    638657                        bs3CpuBasic2_FailedF("SS selector was accessed");
    639                     g_uLine++;
     658                    g_usBs3TestStep++;
    640659
    641660                    /* Modify the gate DPL to check that this is checked before SS.DPL and SS.PRESENT. */
    … …  
    644663                    bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, (0x83 << X86_TRAP_ERR_SEL_SHIFT) | X86_TRAP_ERR_IDT);
    645664                    paIdt[0x83 << cIdteShift].Gate.u2Dpl = 3;
    646                     g_uLine++;
     665                    g_usBs3TestStep++;
    647666
    648667                    /* Check the the CS.DPL check is done before the SS ones. Restoring the ring-0 INT 83
    … …  
    650669                    Bs3TrapSetJmpAndRestore(&Ctx83, &TrapCtx);
    651670                    bs3CpuBasic2_CompareGpCtx(&TrapCtx, &Ctx83, BS3_SEL_TEST_PAGE_02);
    652                     g_uLine++;
     671                    g_usBs3TestStep++;
    653672
    654673                    /* Now mark the CS selector not present and check that that also triggers before SS stuff. */
    … …  
    657676                    bs3CpuBasic2_CompareNpCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_02);
    658677                    BS3_DATA_NM(Bs3GdteTestPage02).Gen.u1Present = 1;
    659                     g_uLine++;
     678                    g_usBs3TestStep++;
    660679
    661680                    /* Make the CS selector some invalid type and check it triggers before SS stuff. */
    … …  
    666685                    BS3_DATA_NM(Bs3GdteTestPage02).Gen.u4Type = X86_SEL_TYPE_ER_ACC;
    667686                    BS3_DATA_NM(Bs3GdteTestPage02).Gen.u1DescType = 1;
    668                     g_uLine++;
     687                    g_usBs3TestStep++;
    669688
    670689                    /* Now, make the CS selector limit too small and that it triggers after SS trouble. */
    … …  
    676695                        bs3CpuBasic2_CompareTsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
    677696                    else if (k != 0)
    678                         bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
     697                        bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03, k == 2 /*f486ResumeFlagHint*/);
    679698                    else
    680699                        bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, 0 /*uErrCd*/);
    681700                    BS3_DATA_NM(Bs3GdteTestPage02) = BS3_DATA_NM(Bs3Gdt)[(uSysR0Cs + (2 << BS3_SEL_RING_SHIFT)) >> X86_SEL_SHIFT];
    682                     g_uLine++;
     701                    g_usBs3TestStep++;
    683702                }
    684703            }
    … …  
    691710        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    692711        bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &CtxTmp, 0x83);
    693         g_uLine++;
     712        g_usBs3TestStep++;
    694713        for (i = 0; i < RT_ELEMENTS(g_aInvalidSsTypes); i++)
    695714        {
    … …  
    702721                                     g_aInvalidSsTypes[i].u4Type, g_aInvalidSsTypes[i].u1DescType,
    703722                                     BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type, BS3_DATA_NM(Bs3GdteTestPage03).Gen.u1DescType);
    704             g_uLine++;
     723            g_usBs3TestStep++;
    705724        }
    706725
    … …  
    727746        /* First test, limit = max --> no bytes accessible --> #GP */
    728747        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    729         bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
     748        bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03, true /*f486ResumeFlagHint*/);
    730749
    731750        /* Second test, limit = 0 --> all by zero byte accessible --> works */
    … …  
    760779        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    761780        bs3CpuBasic2_CompareUdCtx(&TrapCtx, &CtxTmp2);
    762         g_uLine++;
     781        g_usBs3TestStep++;
    763782
    764783        /* Real run. */
    … …  
    769788            Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    770789            if (i > 0)
    771                 bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03);
     790                bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, BS3_SEL_TEST_PAGE_03, true /*f486ResumeFlagHint*/);
    772791            else
    773792                bs3CpuBasic2_CompareUdCtx(&TrapCtx, &CtxTmp2);
    774             g_uLine++;
     793            g_usBs3TestStep++;
    775794        }
    776795
    … …  
    797816            Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    798817            if (i > 0)
    799                 bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, 0 /*BS3_SEL_TEST_PAGE_03*/);
     818                bs3CpuBasic2_CompareSsCtx(&TrapCtx, &CtxTmp, 0 /*BS3_SEL_TEST_PAGE_03*/, true /*f486ResumeFlagHint*/);
    800819            else
    801820                bs3CpuBasic2_CompareUdCtx(&TrapCtx, &CtxTmp2);
    802             g_uLine++;
     821            g_usBs3TestStep++;
    803822        }
    804823
    … …  
    807826    }
    808827    paIdt[0x80 << cIdteShift].Gate.u16Sel = uSysR0Cs;
    809     BS3_ASSERT(g_uLine < 3000);
     828    BS3_ASSERT(g_usBs3TestStep < 3000);
    810829
    811830    /*
    812831     * Modify the gate CS value with a conforming segment.
    813832     */
    814     g_uLine = 3000;
     833    g_usBs3TestStep = 3000;
    815834    for (i = 0; i <= 3; i++) /* cs.dpl */
    816835    {
    … …  
    828847                {
    829848                    uint16_t const uCs = (uSysR0CsConf | j) + (i << BS3_SEL_RING_SHIFT);
    830                     /*Bs3TestPrintf("g_uLine=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_uLine,  iCtx,  iRing, i, uCs);*/
     849                    /*Bs3TestPrintf("g_usBs3TestStep=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_usBs3TestStep,  iCtx,  iRing, i, uCs);*/
    831850                    paIdt[(0x80 + iCtx) << cIdteShift].Gate.u16Sel = uCs;
    832851                    Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    833852                    //Bs3TestPrintf("%u/%u/%u/%u: cs=%04x hcs=%04x xcpt=%02x\n", i, iRing, iCtx, j, uCs, TrapCtx.uHandlerCs, TrapCtx.bXcpt);
    834853                    /*Bs3TrapPrintFrame(&TrapCtx);*/
    835                     g_uLine++;
     854                    g_usBs3TestStep++;
    836855                    if (iCtx < iRing)
    837856                        bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, ((0x80 + iCtx) << X86_TRAP_ERR_SEL_SHIFT) | X86_TRAP_ERR_IDT);
    … …  
    845864        }
    846865    }
    847     BS3_ASSERT(g_uLine < 3500);
     866    BS3_ASSERT(g_usBs3TestStep < 3500);
    848867
    849868    /*
    … …  
    852871    if (cIdteShift != 0)
    853872    {
    854         g_uLine = 3500;
     873        g_usBs3TestStep = 3500;
    855874        for (i = 0; i <= 3; i++)
    856875        {
    … …  
    866885                        static const uint16_t s_auCSes[2] = { BS3_SEL_R0_CS16, BS3_SEL_R0_CS32 };
    867886                        uint16_t uCs = (s_auCSes[j] | i) + (i << BS3_SEL_RING_SHIFT);
    868                         g_uLine++;
    869                         /*Bs3TestPrintf("g_uLine=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_uLine,  iCtx,  iRing, i, uCs);*/
     887                        g_usBs3TestStep++;
     888                        /*Bs3TestPrintf("g_usBs3TestStep=%u iCtx=%u iRing=%u i=%u uCs=%04x\n", g_usBs3TestStep,  iCtx,  iRing, i, uCs);*/
    870889                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u16Sel = uCs;
    871890                        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    … …  
    880899            }
    881900        }
    882         BS3_ASSERT(g_uLine < 4000);
     901        BS3_ASSERT(g_usBs3TestStep < 4000);
    883902    }
    884903
    … …  
    886905     * IDT limit check.
    887906     */
    888     g_uLine = 5000;
     907    g_usBs3TestStep = 5000;
    889908    i = (0x80 << (cIdteShift + 3)) - 1;
    890909    j = (0x82 << (cIdteShift + 3)) - 1;
    891910    k = (0x83 << (cIdteShift + 3)) - 1;
    892     for (; i <= k; i++, g_uLine++)
     911    for (; i <= k; i++, g_usBs3TestStep++)
    893912    {
    894913        Idtr = IdtrSaved;
    … …  
    902921    }
    903922    ASMSetIDTR(&IdtrSaved);
    904     BS3_ASSERT(g_uLine < 5100);
     923    BS3_ASSERT(g_usBs3TestStep < 5100);
    905924
    906925# if TMPL_BITS != 16 /* Only do the paging related stuff in 32-bit and 64-bit modes. */
    … …  
    915934     *       to real mode and back, reloading the default IDTR.
    916935     */
    917     g_uLine = 5200;
     936    g_usBs3TestStep = 5200;
    918937    if (BS3_MODE_IS_PAGED(g_bTestMode) && pbIdtCopyAlloc)
    919938    {
    … …  
    930949            Bs3TrapSetJmpAndRestore(&Ctx81, &TrapCtx);
    931950            bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx81, 0x81 /*bXcpt*/);
    932             g_uLine++;
     951            g_usBs3TestStep++;
    933952
    934953            ASMSetIDTR(&Idtr);
    935954            Bs3TrapSetJmpAndRestore(&Ctx80, &TrapCtx);
    936955            bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx80, 0x80 /*bXcpt*/);
    937             g_uLine++;
     956            g_usBs3TestStep++;
    938957
    939958            rc = Bs3PagingProtect(uCr2Expected, _4K, 0 /*fSet*/, X86_PTE_P /*fClear*/);
    … …  
    943962                Bs3TrapSetJmpAndRestore(&Ctx80, &TrapCtx);
    944963                bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx80, 0x80 /*bXcpt*/);
    945                 g_uLine++;
     964                g_usBs3TestStep++;
    946965
    947966                ASMSetIDTR(&Idtr);
    948967                Bs3TrapSetJmpAndRestore(&Ctx81, &TrapCtx);
    949968                bs3CpuBasic2_ComparePfCtx(&TrapCtx, &Ctx81, 0 /*uErrCd*/, uCr2Expected);
    950                 g_uLine++;
     969                g_usBs3TestStep++;
    951970
    952971                Bs3PagingProtect(uCr2Expected, _4K, X86_PTE_P /*fSet*/, 0 /*fClear*/);
    … …  
    960979                    Bs3TrapSetJmpAndRestore(&Ctx81, &TrapCtx);
    961980                    bs3CpuBasic2_ComparePfCtx(&TrapCtx, &Ctx81, 0 /*uErrCd*/, uCr2Expected);
    962                     g_uLine++;
     981                    g_usBs3TestStep++;
    963982
    964983                    Bs3PagingProtect(uCr2Expected, _4K, X86_PTE_P /*fSet*/, 0 /*fClear*/);
    … …  
    975994     * The read/write and user/supervisor bits the IDT PTEs are irrelevant.
    976995     */
    977     g_uLine = 5300;
     996    g_usBs3TestStep = 5300;
    978997    if (BS3_MODE_IS_PAGED(g_bTestMode) && pbIdtCopyAlloc)
    979998    {
    … …  
    9851004        Bs3TrapSetJmpAndRestore(&Ctx81, &TrapCtx);
    9861005        bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx81, 0x81 /*bXcpt*/);
    987         g_uLine++;
     1006        g_usBs3TestStep++;
    9881007
    9891008        rc = Bs3PagingProtect(Idtr.pIdt, _4K, 0 /*fSet*/, X86_PTE_RW | X86_PTE_US /*fClear*/);
    … …  
    9931012            Bs3TrapSetJmpAndRestore(&Ctx81, &TrapCtx);
    9941013            bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx81, 0x81 /*bXcpt*/);
    995             g_uLine++;
     1014            g_usBs3TestStep++;
    9961015
    9971016            Bs3PagingProtect(Idtr.pIdt, _4K, X86_PTE_RW | X86_PTE_US /*fSet*/, 0 /*fClear*/);
    … …  
    10051024     */
    10061025/** @todo Throw in SS.u1Accessed too. */
    1007     g_uLine = 5400;
     1026    g_usBs3TestStep = 5400;
    10081027    if (BS3_MODE_IS_PAGED(g_bTestMode) && pbIdtCopyAlloc)
    10091028    {
    … …  
    10221041        if (!(BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    10231042            bs3CpuBasic2_FailedF("u4Type=%#x, not accessed", BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type);
    1024         g_uLine++;
     1043        g_usBs3TestStep++;
    10251044
    10261045        Bs3MemCpy(&CtxTmp, &Ctx83, sizeof(CtxTmp));
    … …  
    10321051        if (TrapCtx.uHandlerCs != (BS3_SEL_TEST_PAGE_03 | 3))
    10331052            bs3CpuBasic2_FailedF("uHandlerCs=%#x, expected %#x", TrapCtx.uHandlerCs, (BS3_SEL_TEST_PAGE_03 | 3));
    1034         g_uLine++;
     1053        g_usBs3TestStep++;
    10351054
    10361055        /*
    … …  
    10521071            if (!(BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    10531072                bs3CpuBasic2_FailedF("u4Type=%#x, not accessed!", BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type);
    1054             g_uLine++;
     1073            g_usBs3TestStep++;
    10551074
    10561075            /* ring-3 handler */
    … …  
    10611080            if (!(BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    10621081                bs3CpuBasic2_FailedF("u4Type=%#x, not accessed!", BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type);
    1063             g_uLine++;
     1082            g_usBs3TestStep++;
    10641083
    10651084            /* clear WP and repeat the above. */
    … …  
    10731092            if (!(BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    10741093                bs3CpuBasic2_FailedF("u4Type=%#x, not accessed!", BS3_DATA_NM(Bs3GdteTestPage00).Gen.u4Type);
    1075             g_uLine++;
     1094            g_usBs3TestStep++;
    10761095
    10771096            Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    … …  
    10791098            if (!(BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type & X86_SEL_TYPE_ACCESSED))
    10801099                bs3CpuBasic2_FailedF("u4Type=%#x, not accessed!n", BS3_DATA_NM(Bs3GdteTestPage03).Gen.u4Type);
    1081             g_uLine++;
     1100            g_usBs3TestStep++;
    10821101
    10831102            Bs3PagingProtect(GdtrSaved.pGdt + BS3_SEL_TEST_PAGE_00, 8, X86_PTE_RW /*fSet*/, 0 /*fClear*/);
    … …  
    10971116            Bs3TrapSetJmpAndRestore(&Ctx80, &TrapCtx);
    10981117            bs3CpuBasic2_ComparePfCtx(&TrapCtx, &Ctx80, 0 /*uErrCd*/, GdtrSaved.pGdt + BS3_SEL_TEST_PAGE_00);
    1099             g_uLine++;
     1118            g_usBs3TestStep++;
    11001119
    11011120            /* Do it from ring-3 to check ErrCd, which doesn't set X86_TRAP_PF_US it turns out. */
    … …  
    11051124
    11061125            bs3CpuBasic2_ComparePfCtx(&TrapCtx, &CtxTmp, 0 /*uErrCd*/, GdtrSaved.pGdt + BS3_SEL_TEST_PAGE_03);
    1107             g_uLine++;
     1126            g_usBs3TestStep++;
    11081127
    11091128            Bs3PagingProtect(GdtrSaved.pGdt + BS3_SEL_TEST_PAGE_00, 8, X86_PTE_P /*fSet*/, 0 /*fClear*/);
    … …  
    11241143     * Check broad EFLAGS effects.
    11251144     */
    1126     g_uLine = 5600;
     1145    g_usBs3TestStep = 5600;
    11271146    for (iCtx = 0; iCtx < RT_ELEMENTS(apCtx8x); iCtx++)
    11281147    {
    … …  
    11561175                bs3CpuBasic2_FailedF("unexpected handler rflags value: %RX64 expected %RX32; CtxTmp.rflags=%RX64 Ctx.rflags=%RX64\n",
    11571176                                     TrapCtx.fHandlerRfl, uExpected, CtxTmp.rflags.u, TrapCtx.Ctx.rflags.u);
    1158             g_uLine++;
     1177            g_usBs3TestStep++;
    11591178
    11601179            /* all cleared */
    … …  
    11721191                bs3CpuBasic2_FailedF("unexpected handler rflags value: %RX64 expected %RX32; CtxTmp.rflags=%RX64 Ctx.rflags=%RX64\n",
    11731192                                     TrapCtx.fHandlerRfl, uExpected, CtxTmp.rflags.u, TrapCtx.Ctx.rflags.u);
    1174             g_uLine++;
     1193            g_usBs3TestStep++;
    11751194        }
    11761195    }
    … …  
    11821201     * Check invalid gate types.
    11831202     */
    1184     g_uLine = 32000;
     1203    g_usBs3TestStep = 32000;
    11851204    for (iRing = 0; iRing <= 3; iRing++)
    11861205    {
    … …  
    12211240                                     ? (s_auCSes[j] | i) + (i << BS3_SEL_RING_SHIFT)
    12221241                                     : s_auCSes[j] | i;
    1223                         /*Bs3TestPrintf("g_uLine=%u iCtx=%u iRing=%u i=%u uCs=%04x type=%#x\n", g_uLine, iCtx, iRing, i, uCs, pauInvTypes[iType]);*/
     1242                        /*Bs3TestPrintf("g_usBs3TestStep=%u iCtx=%u iRing=%u i=%u uCs=%04x type=%#x\n", g_usBs3TestStep, iCtx, iRing, i, uCs, pauInvTypes[iType]);*/
    12241243                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u16Sel = uCs;
    12251244                        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    1226                         g_uLine++;
     1245                        g_usBs3TestStep++;
    12271246                        bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, ((0x80 + iCtx) << X86_TRAP_ERR_SEL_SHIFT) | X86_TRAP_ERR_IDT);
    12281247
    … …  
    12301249                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u1Present = 0;
    12311250                        Bs3TrapSetJmpAndRestore(&CtxTmp, &TrapCtx);
    1232                         g_uLine++;
     1251                        g_usBs3TestStep++;
    12331252                        bs3CpuBasic2_CompareGpCtx(&TrapCtx, &CtxTmp, ((0x80 + iCtx) << X86_TRAP_ERR_SEL_SHIFT) | X86_TRAP_ERR_IDT);
    12341253                        paIdt[(0x80 + iCtx) << cIdteShift].Gate.u1Present = 1;
    … …  
    12431262        }
    12441263    }
    1245     BS3_ASSERT(g_uLine < 62000U && g_uLine > 32000U);
     1264    BS3_ASSERT(g_usBs3TestStep < 62000U && g_usBs3TestStep > 32000U);
    12461265
    12471266
    … …  
    12731292    BS3TRAPFRAME    TrapCtx;
    12741293    uint8_t        *pbTmp;
    1275     g_uLine = uLine;
     1294    g_usBs3TestStep = uLine;
    12761295
    12771296    Bs3MemCpy(&Ctx2, pCtx, sizeof(Ctx2));
    … …  
    13491368     */
    13501369    Bs3TrapSetJmpAndRestore(&Ctx, &TrapCtx);
    1351     g_uLine = __LINE__;
     1370    g_usBs3TestStep = __LINE__;
    13521371    bs3CpuBasic2_CompareIntCtx1(&TrapCtx, &Ctx, 0x80 /*bXcpt*/);
    13531372
    … …  
    13661385        {
    13671386            /* same ring */
    1368             g_uLine = __LINE__;
     1387            g_usBs3TestStep = __LINE__;
    13691388            Bs3MemCpy(&Ctx2, &Ctx, sizeof(Ctx2));
    13701389            Ctx2.rsp.u = Bs3SelPtrToFlat(pbAltStack + 0x1980);

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/Makefile.kmk

    r60291 r60302  
    8484       bs3-cmn-PagingInitRootForLM.c \
    8585       bs3-cmn-PagingProtect.c \
     86       bs3-cmn-PicMaskAll.c \
    8687       bs3-cmn-RegCtxRestore.asm \
    8788       bs3-cmn-RegCtxConvertToRingX.c \

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-PagingProtect.c

    r60231 r60302  
    9292                {
    9393                    X86PT BS3_FAR *pPT;
    94                     uint32_t       uPte = (pPD->a[iPde].u & ~(uint32_t)(X86_PDE_PS | X86_PTE_G)) | X86_PTE_D;
    95                     if (!pPD->a[iPde].b.u1Global)
     94                    uint32_t       uPte = (pPD->a[iPde].u & ~(uint32_t)(X86_PTE_PG_MASK | X86_PDE4M_PS | X86_PDE4M_G)) | X86_PTE_D;
     95                    if (pPD->a[iPde].b.u1Global)
    9696                        uPte |= X86_PTE_G;
    97                     if (!pPD->a[iPde].b.u1PAT)
     97                    if (pPD->a[iPde].b.u1PAT)
    9898                        uPte |= X86_PTE_PAT;
    9999
    … …  
    107107                        pPD->a[iPde].u = Bs3SelPtrToFlat(pPT)
    108108                                       | (pPD->a[iPde].u & ~(uint32_t)(X86_PTE_PG_MASK | X86_PDE4M_PS | X86_PDE4M_G | X86_PDE4M_D));
     109                        BS3PAGING_DPRINTF(("bs3PagingGetLegacyPte: iPde=%#x: %#RX32\n", iPde, pPD->a[iPde].u));
    109110                        if (fUseInvlPg)
    110111                            ASMInvalidatePage(uFlat);
    … …  
    222223    int                 rc;
    223224
     225    BS3PAGING_DPRINTF(("Bs3PagingProtect: reloading cr3=%RX32\n", (uint32_t)cr3));
     226    ASMSetCR3(cr3);
     227
    224228    /*
    225229     * Adjust the range parameters.
    … …  
    288292     * Flush the TLB if we didn't use INVLPG above.
    289293     */
     294    BS3PAGING_DPRINTF(("Bs3PagingProtect: reloading cr3=%RX32\n", (uint32_t)cr3));
    290295    //if (!fUseInvlPg)
    291296        ASMSetCR3(cr3);
     297    BS3PAGING_DPRINTF(("Bs3PagingProtect: reloaded cr3=%RX32\n", (uint32_t)cr3));
    292298
    293299    return VINF_SUCCESS;

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-TestData.c

    r59865 r60302  
    4040/** Indicates whether the VMMDev is operational. */
    4141bool        g_fbBs3VMMDevTesting = true;
     42
     43/** Alignment padding.    */
     44bool        g_fTestDataPadding0 = true;
    4245
    4346/** The number of tests that have failed. */
    … …  
    99102char        g_szBs3SubTest[64];
    100103
     104/** The current test step. */
     105uint16_t    g_usBs3TestStep;
     106
    101107#endif /* ARCH_BITS == 16 */
    102108

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-TrapPrintFrame.c

    r60097 r60302  
    3333BS3_DECL(void) Bs3TrapPrintFrame(PCBS3TRAPFRAME pTrapFrame)
    3434{
    35     Bs3TestPrintf("Trap %#04x errcd=%#06RX64 at %04x:%016RX64\n",
     35    Bs3TestPrintf("Trap %#04x errcd=%#06RX64 at %04x:%016RX64 - test step %d (%#x)\n",
    3636                  pTrapFrame->bXcpt,
    3737                  pTrapFrame->uErrCd,
    3838                  pTrapFrame->Ctx.cs,
    39                   pTrapFrame->Ctx.rip.u64);
     39                  pTrapFrame->Ctx.rip.u64,
     40                  g_usBs3TestStep, g_usBs3TestStep);
    4041    Bs3RegCtxPrint(&pTrapFrame->Ctx);
    4142}

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-mode-CpuDetect.asm

    r59949 r60302  
    189189        cpuid
    190190
    191         ; Calc the basic family value before we mess up EAX.
     191        ; Calc the extended family and model values before we mess up EAX.
    192192        mov     cl, ah
    193193        and     cl, 0fh
     194        cmp     cl, 0fh
     195        jnz     .not_extended_family
     196        mov     ecx, eax
     197        shr     ecx, 20
     198        and     cl, 7fh
     199        add     cl, 0fh
     200.not_extended_family:                   ; cl = family
     201        mov     ch, al
     202        shr     ch, 4
     203        cmp     cl, 0fh
     204        jae     .extended_model
     205        cmp     cl, 06h                 ; actually only intel, but we'll let this slip for now.
     206        jne     .done_model
     207.extended_model:
     208        shr     eax, 12
     209        and     al, 0f0h
     210        or      ch, al
     211.done_model:                            ; ch = model
    194212
    195213        ; Start assembling return flags, checking for PAE.
    … …  
    198216        shl     dx, BS3CPU_F_PAE_BIT - X86_CPUID_FEATURE_EDX_PAE_BIT
    199217        or      ax, dx
    200 
    201         ; Add the CPU type based on the family value.
     218        ;; @todo check for PSE
     219
     220        ; Add the CPU type based on the family and model values.
    202221        cmp     cl, 6
    203         or      al, BS3CPU_PPro
    204         jz      .return
     222        jne     .not_family_06h
     223        mov     al, BS3CPU_PPro
     224        cmp     ch, 1
     225        jbe     .return
     226        mov     al, BS3CPU_PProOrNewer
     227        jmp     .NewerThanPPro
     228
     229.not_family_06h:
    205230        ja      .NewerThanPPro
    206231        cmp     cl, 5
    207         or      al, BS3CPU_Pentium
     232        mov     al, BS3CPU_Pentium
    208233        je      .return
    209234        cmp     cl, 4
    210         or      al, BS3CPU_80486
     235        mov     al, BS3CPU_80486
    211236        je      .return
    212237        cmp     cl, 3
    213         or      al, BS3CPU_80386
    214         je      .return
     238        mov     al, BS3CPU_80386
     239        je      .return
     240
    215241.NewerThanPPro:
    216242
    217243        ; Check for extended leaves and long mode.
    218         push    xAX                     ; save PAE flag
     244        push    xAX                     ; save PAE+PProOrNewer
    219245        mov     eax, 0x80000000
    220246        cpuid
    … …  
    225251        mov     eax, 0x80000001
    226252        cpuid
    227         pop     xAX                     ; restore PAE flag
     253        pop     xAX                     ; restore PAE+PProOrNewer
    228254        test    edx, X86_CPUID_EXT_FEATURE_EDX_LONG_MODE
    229255        jz      .no_long_mode
    230         or      xAX, BS3CPU_PProOrNewer | BS3CPU_F_CPUID_EXT_LEAVES | BS3CPU_F_LONG_MODE
     256        or      ax, BS3CPU_F_CPUID_EXT_LEAVES | BS3CPU_F_LONG_MODE
    231257        jmp     .return
    232258.no_long_mode:
    233         or      xAX, BS3CPU_PProOrNewer | BS3CPU_F_CPUID_EXT_LEAVES
     259        or      ax, BS3CPU_F_CPUID_EXT_LEAVES
    234260        jmp     .return
    235261.no_ext_leaves:
    236         pop     xAX                     ; restore PAE flag
    237         or      al, BS3CPU_PProOrNewer
     262        pop     xAX                     ; restore PAE+PProOrNewer
    238263
    239264CPU 8086
    … …  
    242267        ; Save the return value.
    243268        ;
    244         BS3_ONLY_16BIT_STMT push    ds
    245         BS3_ONLY_16BIT_STMT mov     bx, seg g_uBs3CpuDetected
    246         BS3_ONLY_16BIT_STMT mov     ds, bx
    247269        mov     [BS3_DATA16_WRT(g_uBs3CpuDetected)], ax
    248         BS3_ONLY_16BIT_STMT pop     ds
    249270
    250271        ;
    … …  
    257278        pop     xBP
    258279        ret
     280
    259281BS3_PROC_END_MODE   Bs3CpuDetect
    260282

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-rm-InitAll.c

    r60194 r60302  
    3131#include "bs3kit-template-header.h"
    3232#include "bs3-cmn-test.h"
     33#include <iprt/asm-amd64-x86.h>
    3334
    3435
    … …  
    3738    Bs3CpuDetect_rm();
    3839    Bs3InitMemory_rm();
     40
     41    ASMIntDisable();
     42    Bs3PicMaskAll();
     43
    3944    if (BS3_DATA_NM(g_uBs3CpuDetected) & BS3CPU_F_LONG_MODE)
    4045        Bs3Trap64Init();

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit.h

    r60291 r60302  
    18621862
    18631863/**
     1864 * Disables all IRQs on the PIC.
     1865 */
     1866BS3_DECL(void) Bs3PicMaskAll_c16(void);
     1867BS3_DECL(void) Bs3PicMaskAll_c32(void); /**< @copydoc Bs3PicMaskAll_c16 */
     1868BS3_DECL(void) Bs3PicMaskAll_c64(void); /**< @copydoc Bs3PicMaskAll_c16 */
     1869#define Bs3PicMaskAll BS3_CMN_NM(Bs3PicMaskAll) /**< Selects #Bs3PicMaskAll_c16, #Bs3PicMaskAll_c32 or #Bs3PicMaskAll_c64. */
     1870
     1871
     1872
     1873/**
    18641874 * BS3 integer register.
    18651875 */
    … …  
    22402250
    22412251/**
     2252 * The current test step.
     2253 */
     2254extern uint16_t BS3_DATA_NM(g_usBs3TestStep);
     2255#define g_usBs3TestStep BS3_DATA_NM(g_usBs3TestStep)
     2256
     2257/**
    22422258 * Equivalent to RTTestCreate + RTTestBanner.
    22432259 *
Note: See TracChangeset for help on using the changeset viewer.

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