VirtualBox

Changeset 10087 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jul 2, 2008 9:27:32 AM (17 years ago)
Author:
vboxsync
Message:

Fixed SELMR3GetSelectorInfo for 64 bits mode.
Got rid of obsolete VBOXDESC.

Location:
trunk/src/VBox
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp

    r9934 r10087  
    13921392                    "%sdr4=%016RX64 %sdr5=%016RX64 %sdr6=%016RX64 %sdr7=%016RX64\n"
    13931393                    "%sgdtr=%016RX64:%04x  %sidtr=%016RX64:%04x  %seflags=%08x\n"
    1394                     "%sldtr={%04x base=%08RX64 limit=%08x flags=%08x}\n"
    1395                     "%str  ={%04x base=%08RX64 limit=%08x flags=%08x}\n"
     1394                    "%sldtr={%04x base=%016RX64 limit=%08x flags=%08x}\n"
     1395                    "%str  ={%04x base=%016RX64 limit=%08x flags=%08x}\n"
    13961396                    "%sSysEnter={cs=%04llx eip=%08llx esp=%08llx}\n"
    13971397                    ,
    … …  
    17031703        const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
    17041704        const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : "   ";
    1705         uint32_t u32Base = pDesc->Gen.u16BaseLow
    1706                          | ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
    1707                          | ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
    1708         uint32_t cbLimit = pDesc->Gen.u16LimitLow | (pDesc->Gen.u4LimitHigh << 16);
     1705        uint32_t u32Base = X86DESC_BASE(*pDesc);
     1706        uint32_t cbLimit = X86DESC_LIMIT(*pDesc);
    17091707        if (pDesc->Gen.u1Granularity)
    17101708            cbLimit <<= PAGE_SHIFT;
    … …  
    17621760                const char *pszLong        = pDesc->Gen.u1Long ? "LONG" : "   ";
    17631761
    1764                 uint64_t u32Base = pDesc->Gen.u16BaseLow
    1765                                  | ((uint64_t)pDesc->Gen.u8BaseHigh1 << 16)
    1766                                  | ((uint64_t)pDesc->Gen.u8BaseHigh2 << 24)
    1767                                  | ((uint64_t)pDesc->Gen.u32BaseHigh3 << 32);
    1768                 uint32_t cbLimit = pDesc->Gen.u16LimitLow | (pDesc->Gen.u4LimitHigh << 16);
     1762                uint64_t u32Base = X86DESC64_BASE(*pDesc);
     1763                uint32_t cbLimit = X86DESC_LIMIT(*pDesc);
    17691764
    17701765                rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%016RX64 Lim=%08x DPL=%d %s %s %s %sAVL=%d R=%d%s\n",
    … …  
    17831778                const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
    17841779                RTSEL sel = pDesc->au16[1];
    1785                 uint64_t off =    pDesc->au16[0]
    1786                                 | ((uint64_t)pDesc->au16[3] << 16)
    1787                                 | ((uint64_t)pDesc->Gen.u32BaseHigh3 << 32);
     1780                uint64_t off =  X86DESC64_BASE(*pDesc);
    17881781                rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%016RX64     DPL=%d %s %s=%d%s\n",
    17891782                                        iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
    … …  
    17981791            {
    17991792                RTSEL sel = pDesc->au16[1];
    1800                 uint64_t off =    pDesc->au16[0]
    1801                                 | ((uint64_t)pDesc->au16[3] << 16)
    1802                                 | ((uint64_t)pDesc->Gen.u32BaseHigh3 << 32);
     1793                uint64_t off = X86DESC64_BASE(*pDesc);
    18031794                rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%016RX64     DPL=%d %s%s\n",
    18041795                                        iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,

  • trunk/src/VBox/VMM/SELM.cpp

    r9656 r10087  
    223223#endif
    224224    {
    225         PVBOXDESC paGdt = pVM->selm.s.paGdtHC;
     225        PX86DESC paGdt = pVM->selm.s.paGdtHC;
    226226        rc = PGMMapSetPage(pVM, MMHyperHC2GC(pVM, &paGdt[pVM->selm.s.aHyperSel[SELM_HYPER_SEL_TSS_TRAP08] >> 3]), sizeof(paGdt[0]),
    227227                           X86_PTE_RW | X86_PTE_P | X86_PTE_A | X86_PTE_D);
    … …  
    248248static void selmR3SetupHyperGDTSelectors(PVM pVM)
    249249{
    250     PVBOXDESC paGdt = pVM->selm.s.paGdtHC;
     250    PX86DESC paGdt = pVM->selm.s.paGdtHC;
    251251
    252252    /*
    … …  
    254254     * Both are wide open (base 0, limit 4GB)
    255255     */
    256     PVBOXDESC   pDesc = &paGdt[pVM->selm.s.aHyperSel[SELM_HYPER_SEL_CS] >> 3];
     256    PX86DESC   pDesc = &paGdt[pVM->selm.s.aHyperSel[SELM_HYPER_SEL_CS] >> 3];
    257257    pDesc->Gen.u16LimitLow      = 0xffff;
    258258    pDesc->Gen.u4LimitHigh      = 0xf;
    … …  
    349349SELMR3DECL(void) SELMR3Relocate(PVM pVM)
    350350{
    351     PVBOXDESC paGdt = pVM->selm.s.paGdtHC;
     351    PX86DESC paGdt = pVM->selm.s.paGdtHC;
    352352    LogFlow(("SELMR3Relocate\n"));
    353353
    … …  
    792792        VBOXGDTR    GDTR;
    793793        CPUMGetGuestGDTR(pVM, &GDTR);
    794         if (GDTR.cbGdt < sizeof(VBOXDESC))
     794        if (GDTR.cbGdt < sizeof(X86DESC))
    795795        {
    796796            Log(("No GDT entries...\n"));
    … …  
    804804         */
    805805        RTUINT      cbEffLimit = GDTR.cbGdt;
    806         PVBOXDESC   pGDTE = &pVM->selm.s.paGdtHC[1];
    807         rc = PGMPhysReadGCPtr(pVM, pGDTE, GDTR.pGdt + sizeof(VBOXDESC), cbEffLimit + 1 - sizeof(VBOXDESC));
     806        PX86DESC   pGDTE = &pVM->selm.s.paGdtHC[1];
     807        rc = PGMPhysReadGCPtr(pVM, pGDTE, GDTR.pGdt + sizeof(X86DESC), cbEffLimit + 1 - sizeof(X86DESC));
    808808        if (VBOX_FAILURE(rc))
    809809        {
    … …  
    817817             * our selectors in the high end of the GDT.
    818818             */
    819             RTUINT  cbLeft = cbEffLimit + 1 - sizeof(VBOXDESC);
    820             RTGCPTR GCPtrSrc = (RTGCPTR)GDTR.pGdt + sizeof(VBOXDESC);
     819            RTUINT  cbLeft = cbEffLimit + 1 - sizeof(X86DESC);
     820            RTGCPTR GCPtrSrc = (RTGCPTR)GDTR.pGdt + sizeof(X86DESC);
    821821            uint8_t *pu8Dst = (uint8_t *)&pVM->selm.s.paGdtHC[1];
    822822            uint8_t *pu8DstInvalid = pu8Dst;
    … …  
    875875        if (cbEffLimit >= SELM_HYPER_DEFAULT_BASE)
    876876        {
    877             PVBOXDESC pGDTEStart = pVM->selm.s.paGdtHC;
    878             PVBOXDESC pGDTE = (PVBOXDESC)((char *)pGDTEStart + GDTR.cbGdt + 1 - sizeof(VBOXDESC));
     877            PX86DESC pGDTEStart = pVM->selm.s.paGdtHC;
     878            PX86DESC pGDTE = (PX86DESC)((char *)pGDTEStart + GDTR.cbGdt + 1 - sizeof(X86DESC));
    879879            int       iGDT = 0;
    880880
    … …  
    886886                if (!pGDTE->Gen.u1Present)
    887887                {
    888                     aHyperSel[iGDT] = ((uintptr_t)pGDTE - (uintptr_t)pVM->selm.s.paGdtHC) / sizeof(VBOXDESC);
     888                    aHyperSel[iGDT] = ((uintptr_t)pGDTE - (uintptr_t)pVM->selm.s.paGdtHC) / sizeof(X86DESC);
    889889                    aHyperSel[iGDT] = aHyperSel[iGDT] << X86_SEL_SHIFT;
    890890                    Log(("SELM: Found unused GDT %04X\n", aHyperSel[iGDT]));
    … …  
    915915         * Work thru the copied GDT entries adjusting them for correct virtualization.
    916916         */
    917         PVBOXDESC pGDTEEnd = (PVBOXDESC)((char *)pGDTE + cbEffLimit + 1 - sizeof(VBOXDESC));
     917        PX86DESC pGDTEEnd = (PX86DESC)((char *)pGDTE + cbEffLimit + 1 - sizeof(X86DESC));
    918918        while (pGDTE < pGDTEEnd)
    919919        {
    … …  
    10821082         * Get the LDT selector.
    10831083         */
    1084         PVBOXDESC   pDesc = &pVM->selm.s.paGdtHC[SelLdt >> X86_SEL_SHIFT];
     1084        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelLdt >> X86_SEL_SHIFT];
    10851085        RTGCPTR     GCPtrLdt = X86DESC_BASE(*pDesc);
    10861086        unsigned    cbLdt = X86DESC_LIMIT(*pDesc);
    … …  
    11151115        }
    11161116        /** @todo check what intel does about odd limits. */
    1117         AssertMsg(RT_ALIGN(cbLdt + 1, sizeof(VBOXDESC)) == cbLdt + 1 && cbLdt <= 0xffff, ("cbLdt=%d\n", cbLdt));
     1117        AssertMsg(RT_ALIGN(cbLdt + 1, sizeof(X86DESC)) == cbLdt + 1 && cbLdt <= 0xffff, ("cbLdt=%d\n", cbLdt));
    11181118
    11191119        /*
    … …  
    11821182        pVM->selm.s.offLdtHyper = off = (GCPtrLdt & PAGE_OFFSET_MASK);
    11831183        RTGCPTR     GCPtrShadowLDT  = (RTGCPTR)((RTGCUINTPTR)pVM->selm.s.GCPtrLdt + off);
    1184         PVBOXDESC   pShadowLDT      = (PVBOXDESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
     1184        PX86DESC   pShadowLDT      = (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
    11851185
    11861186        /*
    … …  
    12091209         */
    12101210        /** @todo investigate how intel handle various operations on half present cross page entries. */
    1211         off = GCPtrLdt & (sizeof(VBOXDESC) - 1);
     1211        off = GCPtrLdt & (sizeof(X86DESC) - 1);
    12121212        AssertMsg(!off, ("LDT is not aligned on entry size! GCPtrLdt=%08x\n", GCPtrLdt));
    12131213
    12141214        /* Note: Do not skip the first selector; unlike the GDT, a zero LDT selector is perfectly valid. */
    12151215        unsigned    cbLeft = cbLdt + 1;
    1216         PVBOXDESC   pLDTE = pShadowLDT;
     1216        PX86DESC   pLDTE = pShadowLDT;
    12171217        while (cbLeft)
    12181218        {
    … …  
    12381238                 * 'next' part of the loop. The pLDTEEnd is inclusive.
    12391239                 */
    1240                 PVBOXDESC pLDTEEnd = (PVBOXDESC)((uintptr_t)pShadowLDT + cbChunk) - 1;
     1240                PX86DESC pLDTEEnd = (PX86DESC)((uintptr_t)pShadowLDT + cbChunk) - 1;
    12411241                if (pLDTE + 1 < pShadowLDT)
    1242                     pLDTE = (PVBOXDESC)((uintptr_t)pShadowLDT + off);
     1242                    pLDTE = (PX86DESC)((uintptr_t)pShadowLDT + off);
    12431243                while (pLDTE <= pLDTEEnd)
    12441244                {
    … …  
    12961296            cbLeft          -= cbChunk;
    12971297            GCPtrShadowLDT  += cbChunk;
    1298             pShadowLDT       = (PVBOXDESC)((char *)pShadowLDT + cbChunk);
     1298            pShadowLDT       = (PX86DESC)((char *)pShadowLDT + cbChunk);
    12991299            GCPtrLdt        += cbChunk;
    13001300        }
    … …  
    14191419         * Guest TR is not NULL.
    14201420         */
    1421         PVBOXDESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
     1421        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
    14221422        RTGCPTR     GCPtrTss = X86DESC_BASE(*pDesc);
    14231423        unsigned    cbTss = X86DESC_LIMIT(*pDesc);
    … …  
    15761576     */
    15771577    RTGCPTR     GCPtrGDTEGuest = GDTR.pGdt;
    1578     PVBOXDESC   pGDTE = pVM->selm.s.paGdtHC;
    1579     PVBOXDESC   pGDTEEnd = (PVBOXDESC)((uintptr_t)pGDTE + GDTR.cbGdt);
     1578    PX86DESC   pGDTE = pVM->selm.s.paGdtHC;
     1579    PX86DESC   pGDTEEnd = (PX86DESC)((uintptr_t)pGDTE + GDTR.cbGdt);
    15801580    while (pGDTE < pGDTEEnd)
    15811581    {
    1582         VBOXDESC    GDTEGuest;
     1582        X86DESC    GDTEGuest;
    15831583        int rc = PGMPhysReadGCPtr(pVM, &GDTEGuest, GCPtrGDTEGuest, sizeof(GDTEGuest));
    15841584        if (VBOX_SUCCESS(rc))
    … …  
    16021602
    16031603        /* Advance to the next descriptor. */
    1604         GCPtrGDTEGuest += sizeof(VBOXDESC);
     1604        GCPtrGDTEGuest += sizeof(X86DESC);
    16051605        pGDTE++;
    16061606    }
    … …  
    16181618        return VERR_INTERNAL_ERROR;
    16191619    }
    1620     VBOXDESC    LDTDesc;
     1620    X86DESC    LDTDesc;
    16211621    int rc = PGMPhysReadGCPtr(pVM, &LDTDesc, GDTR.pGdt + (SelLdt & X86_SEL_MASK), sizeof(LDTDesc));
    16221622    if (VBOX_FAILURE(rc))
    … …  
    16361636        return VINF_SUCCESS;
    16371637    /** @todo check what intel does about odd limits. */
    1638     AssertMsg(RT_ALIGN(cbLdt + 1, sizeof(VBOXDESC)) == cbLdt + 1 && cbLdt <= 0xffff, ("cbLdt=%d\n", cbLdt));
     1638    AssertMsg(RT_ALIGN(cbLdt + 1, sizeof(X86DESC)) == cbLdt + 1 && cbLdt <= 0xffff, ("cbLdt=%d\n", cbLdt));
    16391639    if (    LDTDesc.Gen.u1DescType
    16401640        ||  LDTDesc.Gen.u4Type != X86_SEL_TYPE_SYS_LDT
    … …  
    16491649     */
    16501650    unsigned    off = (GCPtrLDTEGuest & PAGE_OFFSET_MASK);
    1651     PVBOXDESC   pLDTE = (PVBOXDESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
    1652     PVBOXDESC   pLDTEEnd = (PVBOXDESC)((uintptr_t)pGDTE + cbLdt);
     1651    PX86DESC   pLDTE = (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
     1652    PX86DESC   pLDTEEnd = (PX86DESC)((uintptr_t)pGDTE + cbLdt);
    16531653    while (pLDTE < pLDTEEnd)
    16541654    {
    1655         VBOXDESC    LDTEGuest;
     1655        X86DESC    LDTEGuest;
    16561656        int rc = PGMPhysReadGCPtr(pVM, &LDTEGuest, GCPtrLDTEGuest, sizeof(LDTEGuest));
    16571657        if (VBOX_SUCCESS(rc))
    … …  
    16651665                || pLDTE->Gen.u1DescType  != LDTEGuest.Gen.u1DescType)
    16661666            {
    1667                 unsigned iLDT = pLDTE - (PVBOXDESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
     1667                unsigned iLDT = pLDTE - (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
    16681668                SELMR3DumpDescriptor(*pLDTE, iLDT << 3, "SELMR3DebugCheck: LDT mismatch, shadow");
    16691669                SELMR3DumpDescriptor(LDTEGuest, iLDT << 3, "SELMR3DebugCheck: LDT mismatch,  guest");
    … …  
    16721672
    16731673        /* Advance to the next descriptor. */
    1674         GCPtrLDTEGuest += sizeof(VBOXDESC);
     1674        GCPtrLDTEGuest += sizeof(X86DESC);
    16751675        pLDTE++;
    16761676    }
    … …  
    17031703         * Guest TR is not NULL.
    17041704         */
    1705         PVBOXDESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
     1705        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
    17061706        RTGCPTR     GCPtrTss = X86DESC_BASE(*pDesc);
    17071707        unsigned    cbTss = X86DESC_LIMIT(*pDesc);
    … …  
    17951795
    17961796    /* Read descriptor from GC. */
    1797     VBOXDESC Desc;
     1797    X86DESC Desc;
    17981798    int rc = PGMPhysReadGCPtr(pVM, (void *)&Desc, (RTGCPTR)(GDTR.pGdt + (SelLdt & X86_SEL_MASK)), sizeof(Desc));
    17991799    if (VBOX_FAILURE(rc))
    … …  
    18211821    return VINF_SUCCESS;
    18221822}
    1823 
    18241823
    18251824/**
    … …  
    18391838 * @param   pSelInfo    Where to store the information.
    18401839 */
     1840static int selmr3GetSelectorInfo64(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
     1841{
     1842    X86DESC64 Desc;
     1843
     1844    Assert(pSelInfo);
     1845
     1846    /*
     1847     * Read it from the guest descriptor table.
     1848     */
     1849    pSelInfo->fHyper = false;
     1850
     1851    VBOXGDTR    Gdtr;
     1852    RTGCPTR     GCPtrDesc;
     1853    CPUMGetGuestGDTR(pVM, &Gdtr);
     1854    if (!(Sel & X86_SEL_LDT))
     1855    {
     1856        /* GDT */
     1857        if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(X86DESC) - 1 > (unsigned)Gdtr.cbGdt)
     1858            return VERR_INVALID_SELECTOR;
     1859        GCPtrDesc = Gdtr.pGdt + (Sel & X86_SEL_MASK);
     1860    }
     1861    else
     1862    {
     1863        /*
     1864            * LDT - must locate the LDT first...
     1865            */
     1866        RTSEL SelLdt = CPUMGetGuestLDTR(pVM);
     1867        if (    (unsigned)(SelLdt & X86_SEL_MASK) < sizeof(X86DESC) /* the first selector is invalid, right? */
     1868            ||  (unsigned)(SelLdt & X86_SEL_MASK) + sizeof(X86DESC) - 1 > (unsigned)Gdtr.cbGdt)
     1869            return VERR_INVALID_SELECTOR;
     1870        GCPtrDesc = Gdtr.pGdt + (SelLdt & X86_SEL_MASK);
     1871        int rc = PGMPhysReadGCPtr(pVM, &Desc, GCPtrDesc, sizeof(Desc));
     1872        if (VBOX_FAILURE(rc))
     1873            return rc;
     1874
     1875        /* validate the LDT descriptor. */
     1876        if (Desc.Gen.u1Present == 0)
     1877            return VERR_SELECTOR_NOT_PRESENT;
     1878        if (    Desc.Gen.u1DescType == 1
     1879            ||  Desc.Gen.u4Type != X86_SEL_TYPE_SYS_LDT)
     1880            return VERR_INVALID_SELECTOR;
     1881
     1882        unsigned cbLimit = X86DESC_LIMIT(Desc);
     1883        if (Desc.Gen.u1Granularity)
     1884            cbLimit = (cbLimit << PAGE_SHIFT) | PAGE_OFFSET_MASK;
     1885        if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(X86DESC) - 1 > cbLimit)
     1886            return VERR_INVALID_SELECTOR;
     1887
     1888        /* calc the descriptor location. */
     1889        GCPtrDesc = X86DESC64_BASE(Desc);
     1890        GCPtrDesc += (Sel & X86_SEL_MASK);
     1891    }
     1892
     1893    /* read the descriptor. */
     1894    int rc = PGMPhysReadGCPtr(pVM, &Desc, GCPtrDesc, sizeof(Desc));
     1895    if (VBOX_FAILURE(rc))
     1896        return rc;
     1897
     1898    /*
     1899     * Extract the base and limit
     1900     */
     1901    pSelInfo->Sel = Sel;
     1902    pSelInfo->Raw64 = Desc;
     1903    pSelInfo->cbLimit = X86DESC_LIMIT(Desc);
     1904    if (Desc.Gen.u1Granularity)
     1905        pSelInfo->cbLimit = (pSelInfo->cbLimit << PAGE_SHIFT) | PAGE_OFFSET_MASK;
     1906    pSelInfo->GCPtrBase = X86DESC64_BASE(Desc);
     1907    pSelInfo->fRealMode = false;
     1908
     1909    return VINF_SUCCESS;
     1910}
     1911
     1912
     1913/**
     1914 * Gets information about a selector.
     1915 * Intended for the debugger mostly and will prefer the guest
     1916 * descriptor tables over the shadow ones.
     1917 *
     1918 * @returns VINF_SUCCESS on success.
     1919 * @returns VERR_INVALID_SELECTOR if the selector isn't fully inside the descriptor table.
     1920 * @returns VERR_SELECTOR_NOT_PRESENT if the selector wasn't present.
     1921 * @returns VERR_PAGE_TABLE_NOT_PRESENT or VERR_PAGE_NOT_PRESENT if the pagetable or page
     1922 *          backing the selector table wasn't present.
     1923 * @returns Other VBox status code on other errors.
     1924 *
     1925 * @param   pVM         VM handle.
     1926 * @param   Sel         The selector to get info about.
     1927 * @param   pSelInfo    Where to store the information.
     1928 */
    18411929SELMR3DECL(int) SELMR3GetSelectorInfo(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
    18421930{
    18431931    Assert(pSelInfo);
    18441932
     1933    if (CPUMIsGuestInLongMode(pVM))
     1934        return selmr3GetSelectorInfo64(pVM, Sel, pSelInfo);
     1935
    18451936    /*
    18461937     * Read the descriptor entry
    18471938     */
    1848     VBOXDESC    Desc;
     1939    X86DESC Desc;
    18491940    if (    !(Sel & X86_SEL_LDT)
    18501941        && (    pVM->selm.s.aHyperSel[SELM_HYPER_SEL_CS] == (Sel & X86_SEL_MASK)
    … …  
    18741965        {
    18751966            /* GDT */
    1876             if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(VBOXDESC) - 1 > (unsigned)Gdtr.cbGdt)
     1967            if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(X86DESC) - 1 > (unsigned)Gdtr.cbGdt)
    18771968                return VERR_INVALID_SELECTOR;
    18781969            GCPtrDesc = Gdtr.pGdt + (Sel & X86_SEL_MASK);
    … …  
    18841975             */
    18851976            RTSEL SelLdt = CPUMGetGuestLDTR(pVM);
    1886             if (    (unsigned)(SelLdt & X86_SEL_MASK) < sizeof(VBOXDESC) /* the first selector is invalid, right? */
    1887                 ||  (unsigned)(SelLdt & X86_SEL_MASK) + sizeof(VBOXDESC) - 1 > (unsigned)Gdtr.cbGdt)
     1977            if (    (unsigned)(SelLdt & X86_SEL_MASK) < sizeof(X86DESC) /* the first selector is invalid, right? */
     1978                ||  (unsigned)(SelLdt & X86_SEL_MASK) + sizeof(X86DESC) - 1 > (unsigned)Gdtr.cbGdt)
    18881979                return VERR_INVALID_SELECTOR;
    18891980            GCPtrDesc = Gdtr.pGdt + (SelLdt & X86_SEL_MASK);
    … …  
    19021993            if (Desc.Gen.u1Granularity)
    19031994                cbLimit = (cbLimit << PAGE_SHIFT) | PAGE_OFFSET_MASK;
    1904             if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(VBOXDESC) - 1 > cbLimit)
     1995            if ((unsigned)(Sel & X86_SEL_MASK) + sizeof(X86DESC) - 1 > cbLimit)
    19051996                return VERR_INVALID_SELECTOR;
    19061997
    … …  
    19682059     * Read the descriptor entry
    19692060     */
    1970     VBOXDESC    Desc;
     2061    X86DESC    Desc;
    19712062    if (!(Sel & X86_SEL_LDT))
    19722063    {
    … …  
    19872078         * Local Descriptor.
    19882079         */
    1989         PVBOXDESC paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     2080        PX86DESC paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    19902081        Desc = paLDT[Sel >> X86_SEL_SHIFT];
    19912082        /** @todo check if the LDT page is actually available. */
    … …  
    20172108 * @param   cchOutput   Size of output buffer.
    20182109 */
    2019 static void selmR3FormatDescriptor(VBOXDESC Desc, RTSEL Sel, char *pszOutput, size_t cchOutput)
     2110static void selmR3FormatDescriptor(X86DESC Desc, RTSEL Sel, char *pszOutput, size_t cchOutput)
    20202111{
    20212112    /*
    … …  
    21052196 * @param   pszMsg  Message to prepend the log entry with.
    21062197 */
    2107 SELMR3DECL(void) SELMR3DumpDescriptor(VBOXDESC  Desc, RTSEL Sel, const char *pszMsg)
     2198SELMR3DECL(void) SELMR3DumpDescriptor(X86DESC  Desc, RTSEL Sel, const char *pszMsg)
    21082199{
    21092200    char szOutput[128];
    … …  
    21592250    CPUMGetGuestGDTR(pVM, &GDTR);
    21602251    RTGCPTR     pGDTGC = GDTR.pGdt;
    2161     unsigned    cGDTs = ((unsigned)GDTR.cbGdt + 1) / sizeof(VBOXDESC);
     2252    unsigned    cGDTs = ((unsigned)GDTR.cbGdt + 1) / sizeof(X86DESC);
    21622253
    21632254    pHlp->pfnPrintf(pHlp, "Guest GDT (GCAddr=%VGv limit=%x):\n", pGDTGC, GDTR.cbGdt);
    2164     for (unsigned iGDT = 0; iGDT < cGDTs; iGDT++, pGDTGC += sizeof(VBOXDESC))
    2165     {
    2166         VBOXDESC GDTE;
     2255    for (unsigned iGDT = 0; iGDT < cGDTs; iGDT++, pGDTGC += sizeof(X86DESC))
     2256    {
     2257        X86DESC GDTE;
    21672258        int rc = PGMPhysReadGCPtr(pVM, &GDTE, pGDTGC, sizeof(GDTE));
    21682259        if (VBOX_SUCCESS(rc))
    … …  
    21772268        else if (rc == VERR_PAGE_NOT_PRESENT)
    21782269        {
    2179             if ((pGDTGC & PAGE_OFFSET_MASK) + sizeof(VBOXDESC) - 1 < sizeof(VBOXDESC))
     2270            if ((pGDTGC & PAGE_OFFSET_MASK) + sizeof(X86DESC) - 1 < sizeof(X86DESC))
    21802271                pHlp->pfnPrintf(pHlp, "%04x - page not present (GCAddr=%VGv)\n", iGDT << X86_SEL_SHIFT, pGDTGC);
    21812272        }
    … …  
    21962287{
    21972288    unsigned    cLDTs = ((unsigned)pVM->selm.s.cbLdtLimit + 1) >> X86_SEL_SHIFT;
    2198     PVBOXDESC   paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     2289    PX86DESC   paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    21992290    pHlp->pfnPrintf(pHlp, "Shadow LDT (GCAddr=%VGv limit=%d):\n", pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper, pVM->selm.s.cbLdtLimit);
    22002291    for (unsigned iLDT = 0; iLDT < cLDTs; iLDT++)
    … …  
    22372328    pHlp->pfnPrintf(pHlp, "Guest LDT (Sel=%x GCAddr=%VGv limit=%x):\n", SelLdt, pLdtGC, cbLdt);
    22382329    unsigned    cLdts  = (cbLdt + 1) >> X86_SEL_SHIFT;
    2239     for (unsigned iLdt = 0; iLdt < cLdts; iLdt++, pLdtGC += sizeof(VBOXDESC))
    2240     {
    2241         VBOXDESC LdtE;
     2330    for (unsigned iLdt = 0; iLdt < cLdts; iLdt++, pLdtGC += sizeof(X86DESC))
     2331    {
     2332        X86DESC LdtE;
    22422333        int rc = PGMPhysReadGCPtr(pVM, &LdtE, pLdtGC, sizeof(LdtE));
    22432334        if (VBOX_SUCCESS(rc))
    … …  
    22522343        else if (rc == VERR_PAGE_NOT_PRESENT)
    22532344        {
    2254             if ((pLdtGC & PAGE_OFFSET_MASK) + sizeof(VBOXDESC) - 1 < sizeof(VBOXDESC))
     2345            if ((pLdtGC & PAGE_OFFSET_MASK) + sizeof(X86DESC) - 1 < sizeof(X86DESC))
    22552346                pHlp->pfnPrintf(pHlp, "%04x - page not present (GCAddr=%VGv)\n", (iLdt << X86_SEL_SHIFT) | X86_SEL_LDT, pLdtGC);
    22562347        }

  • trunk/src/VBox/VMM/SELMInternal.h

    r9443 r10087  
    8989    /** Pointer to the GCs - HC Ptr.
    9090     * This size is governed by SELM_GDT_ELEMENTS. */
    91     R3R0PTRTYPE(PVBOXDESC)  paGdtHC;
     91    R3R0PTRTYPE(PX86DESC)   paGdtHC;
    9292    /** Pointer to the GCs - GC Ptr.
    9393     * This is not initialized until the first relocation because it's used to
    9494     * check if the shadow GDT virtual handler requires deregistration. */
    95     RCPTRTYPE(PVBOXDESC)    paGdtGC;
     95    RCPTRTYPE(PX86DESC)     paGdtGC;
    9696    /** Current (last) Guest's GDTR. */
    9797    VBOXGDTR                GuestGdtr;

  • trunk/src/VBox/VMM/VMMAll/SELMAll.cpp

    r10016 r10087  
    5656
    5757    /** @todo check the limit. */
    58     VBOXDESC    Desc;
     58    X86DESC    Desc;
    5959    if (!(Sel & X86_SEL_LDT))
    6060        Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
    … …  
    6363        /** @todo handle LDT pages not present! */
    6464#ifdef IN_GC
    65         PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
     65        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
    6666#else
    67         PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     67        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    6868#endif
    6969        Desc = paLDT[Sel >> X86_SEL_SHIFT];
    … …  
    289289#ifndef IN_RING0
    290290    {
    291         VBOXDESC Desc;
     291        X86DESC Desc;
    292292
    293293        if (!(Sel & X86_SEL_LDT))
    … …  
    305305            /** @todo handle LDT page(s) not present! */
    306306#ifdef IN_GC
    307             PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
     307            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
    308308#else
    309             PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     309            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    310310#endif
    311311            Desc = paLDT[Sel >> X86_SEL_SHIFT];
    … …  
    490490    else
    491491    {
    492         VBOXDESC Desc;
     492        X86DESC Desc;
    493493
    494494        if (!(Sel & X86_SEL_LDT))
    … …  
    506506            /** @todo handle LDT page(s) not present! */
    507507#ifdef IN_GC
    508             PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
     508            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
    509509#else
    510             PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     510            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    511511#endif
    512512            Desc = paLDT[Sel >> X86_SEL_SHIFT];
    … …  
    678678
    679679    /** @todo validate limit! */
    680     VBOXDESC    Desc;
     680    X86DESC    Desc;
    681681    if (!(SelCS & X86_SEL_LDT))
    682682        Desc = pVM->selm.s.CTXSUFF(paGdt)[SelCS >> X86_SEL_SHIFT];
    … …  
    685685        /** @todo handle LDT page(s) not present! */
    686686#ifdef IN_GC
    687         PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
     687        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
    688688#else
    689         PVBOXDESC    paLDT = (PVBOXDESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
     689        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
    690690#endif
    691691        Desc = paLDT[SelCS >> X86_SEL_SHIFT];
    … …  
    865865
    866866    /** @todo validate limit! */
    867     VBOXDESC Desc;
     867    X86DESC Desc;
    868868    if (!(Sel & X86_SEL_LDT))
    869869        Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
    … …  
    871871    {
    872872        /** @todo handle LDT page(s) not present! */
    873         PVBOXDESC   paLDT = (PVBOXDESC)((char *)pVM->selm.s.CTXMID(,PtrLdt) + pVM->selm.s.offLdtHyper);
     873        PX86DESC   paLDT = (PX86DESC)((char *)pVM->selm.s.CTXMID(,PtrLdt) + pVM->selm.s.offLdtHyper);
    874874        Desc = paLDT[Sel >> X86_SEL_SHIFT];
    875875    }

  • trunk/src/VBox/VMM/VMMAll/TRPMAll.cpp

    r9678 r10087  
    498498                uint32_t ss_r0;
    499499                uint32_t esp_r0;
    500                 VBOXDESC Desc;
     500                X86DESC Desc;
    501501                RTGCPTR  pGdtEntry;
    502502
    … …  
    507507                    goto failure;
    508508
    509                 pGdtEntry = (RTGCPTR)(uintptr_t)&((VBOXDESC *)gdtr.pGdt)[GuestIdte.Gen.u16SegSel >> X86_SEL_SHIFT]; /// @todo fix this
     509                pGdtEntry = (RTGCPTR)(uintptr_t)&((X86DESC *)gdtr.pGdt)[GuestIdte.Gen.u16SegSel >> X86_SEL_SHIFT]; /// @todo fix this
    510510#ifdef IN_GC
    511511                rc = MMGCRamRead(pVM, &Desc, (void *)pGdtEntry, sizeof(Desc));

  • trunk/src/VBox/VMM/VMMGC/SELMGC.cpp

    r9412 r10087  
    5656    VBOXGDTR GdtrGuest;
    5757    CPUMGetGuestGDTR(pVM, &GdtrGuest);
    58     unsigned offEntry = iGDTEntry * sizeof(VBOXDESC);
     58    unsigned offEntry = iGDTEntry * sizeof(X86DESC);
    5959    if (    iGDTEntry >= SELM_GDT_ELEMENTS
    6060        ||  offEntry > GdtrGuest.cbGdt)
    … …  
    6464     * Read the guest descriptor.
    6565     */
    66     VBOXDESC Desc;
    67     int rc = MMGCRamRead(pVM, &Desc, (uint8_t *)GdtrGuest.pGdt + offEntry, sizeof(VBOXDESC));
     66    X86DESC Desc;
     67    int rc = MMGCRamRead(pVM, &Desc, (uint8_t *)GdtrGuest.pGdt + offEntry, sizeof(X86DESC));
    6868    if (VBOX_FAILURE(rc))
    6969        return VINF_EM_RAW_EMULATE_INSTR_GDT_FAULT;
    … …  
    100100     * 'little' adjustment we do for DPL 0 selectors.
    101101     */
    102     PVBOXDESC   pShadowDescr = &pVM->selm.s.paGdtGC[iGDTEntry];
     102    PX86DESC   pShadowDescr = &pVM->selm.s.paGdtGC[iGDTEntry];
    103103    if (Desc.Gen.u1DescType)
    104104    {
    … …  
    191191     */
    192192    int rc;
    193     if (CPUMGetGuestLDTR(pVM) / sizeof(VBOXDESC) == offRange / sizeof(VBOXDESC))
     193    if (CPUMGetGuestLDTR(pVM) / sizeof(X86DESC) == offRange / sizeof(X86DESC))
    194194    {
    195195        Log(("LDTR selector change -> fall back to HC!!\n"));
    … …  
    208208        if (VBOX_SUCCESS(rc) && cb)
    209209        {
    210             unsigned iGDTE1 = offRange / sizeof(VBOXDESC);
     210            unsigned iGDTE1 = offRange / sizeof(X86DESC);
    211211            int rc2 = selmGCSyncGDTEntry(pVM, pRegFrame, iGDTE1);
    212212            if (rc2 == VINF_SUCCESS)
    213213            {
    214214                Assert(cb);
    215                 unsigned iGDTE2 = (offRange + cb - 1) / sizeof(VBOXDESC);
     215                unsigned iGDTE2 = (offRange + cb - 1) / sizeof(X86DESC);
    216216                if (iGDTE1 != iGDTE2)
    217217                    rc2 = selmGCSyncGDTEntry(pVM, pRegFrame, iGDTE2);

  • trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp

    r9430 r10087  
    106106    CHECK_SIZE(int8_t, 8/8);
    107107
    108     CHECK_SIZE(VBOXDESC, 8);
     108    CHECK_SIZE(X86DESC, 8);
     109    CHECK_SIZE(X86DESC64, 16);
    109110    CHECK_SIZE(VBOXIDTE, 8);
    110111    CHECK_SIZE(VBOXIDTR, 10);
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