VirtualBox

Ignore:
Timestamp:
Apr 28, 2016 7:41:14 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
106941
Message:

bs3kit: updates

Location:
trunk/src/VBox/ValidationKit/bootsectors
Files:
4 added
11 edited
1 copied

Legend:

Unmodified
Added
Removed

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

    r60729 r60749  
    14451445}
    14461446
     1447#if TMPL_BITS == 16
    14471448
    14481449/**
    … …  
    20462047}
    20472048
     2049BS3_DECL_FAR(uint8_t) BS3_CMN_FAR_NM(bs3CpuBasic2_sidt)(uint8_t bMode)
     2050{
     2051    union
     2052    {
     2053        RTIDTR  Idtr;
     2054        uint8_t ab[16];
     2055    } Expected;
     2056
     2057    g_pszTestMode = Bs3GetModeName(bMode);
     2058    g_bTestMode   = bMode;
     2059    g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(bMode);
     2060
     2061
     2062    /*
     2063     * Pass to common worker which is only compiled once per mode.
     2064     */
     2065    Bs3MemZero(&Expected, sizeof(Expected));
     2066    ASMGetIDTR(&Expected.Idtr);
     2067    bs3CpuBasic2_sidt_sgdt_Common(bMode, g_aSidtWorkers, RT_ELEMENTS(g_aSidtWorkers), Expected.ab);
     2068
     2069    /*
     2070     * Re-initialize the IDT.
     2071     */
     2072    Bs3TrapReInit();
     2073    return 0;
     2074}
     2075
     2076
     2077BS3_DECL_FAR(uint8_t) BS3_CMN_FAR_NM(bs3CpuBasic2_sgdt)(uint8_t bMode)
     2078{
     2079    uint64_t const uOrgAddr = Bs3Lgdt_Gdt.uAddr;
     2080    uint64_t       uNew     = 0;
     2081    union
     2082    {
     2083        RTGDTR  Gdtr;
     2084        uint8_t ab[16];
     2085    } Expected;
     2086
     2087    g_pszTestMode = Bs3GetModeName(bMode);
     2088    g_bTestMode   = bMode;
     2089    g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(bMode);
     2090
     2091    /*
     2092     * If paged mode, try push the GDT way up.
     2093     */
     2094    if (BS3_MODE_IS_PAGED(bMode))
     2095    {
     2096/** @todo loading non-canonical base addresses.   */
     2097        int rc;
     2098        uNew  = BS3_MODE_IS_64BIT_SYS(bMode) ? UINT64_C(0xffff80fedcb70000) : UINT64_C(0xc2d28000);
     2099        uNew |= uOrgAddr & X86_PAGE_OFFSET_MASK;
     2100        rc = Bs3PagingAlias(uNew, uOrgAddr, Bs3Lgdt_Gdt.cb, X86_PTE_P | X86_PTE_RW | X86_PTE_US | X86_PTE_D | X86_PTE_A);
     2101        if (RT_SUCCESS(rc))
     2102        {
     2103            Bs3Lgdt_Gdt.uAddr = uNew;
     2104            Bs3UtilSetFullGdtr(Bs3Lgdt_Gdt.cb, uNew);
     2105        }
     2106    }
     2107
     2108    /*
     2109     * Pass to common worker which is only compiled once per mode.
     2110     */
     2111    Bs3MemZero(&Expected, sizeof(Expected));
     2112    ASMGetGDTR(&Expected.Gdtr);
     2113    bs3CpuBasic2_sidt_sgdt_Common(bMode, g_aSgdtWorkers, RT_ELEMENTS(g_aSgdtWorkers), Expected.ab);
     2114
     2115    /*
     2116     * Unalias the GDT.
     2117     */
     2118    if (uNew != 0)
     2119    {
     2120        Bs3Lgdt_Gdt.uAddr = uOrgAddr;
     2121        Bs3UtilSetFullGdtr(Bs3Lgdt_Gdt.cb, uOrgAddr);
     2122        Bs3PagingUnalias(uNew, Bs3Lgdt_Gdt.cb);
     2123    }
     2124
     2125    /*
     2126     * Re-initialize the IDT.
     2127     */
     2128    Bs3TrapReInit();
     2129    return 0;
     2130}
     2131
     2132
    20482133
    20492134/*
    … …  
    27512836
    27522837
     2838BS3_DECL_FAR(uint8_t) BS3_CMN_FAR_NM(bs3CpuBasic2_lidt)(uint8_t bMode)
     2839{
     2840    union
     2841    {
     2842        RTIDTR  Idtr;
     2843        uint8_t ab[32]; /* At least cbIdtr*2! */
     2844    } Expected;
     2845
     2846    g_pszTestMode = Bs3GetModeName(bMode);
     2847    g_bTestMode   = bMode;
     2848    g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(bMode);
     2849
     2850    /*
     2851     * Pass to common worker which is only compiled once per mode.
     2852     */
     2853    Bs3MemZero(&Expected, sizeof(Expected));
     2854    ASMGetIDTR(&Expected.Idtr);
     2855
     2856    if (BS3_MODE_IS_RM_SYS(bMode))
     2857        bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
     2858                                      &Bs3Lidt_Ivt, sizeof(Bs3Lidt_Ivt), Expected.ab);
     2859    else if (BS3_MODE_IS_16BIT_SYS(bMode))
     2860        bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
     2861                                      &Bs3Lidt_Idt16, sizeof(Bs3Lidt_Idt16), Expected.ab);
     2862    else if (BS3_MODE_IS_32BIT_SYS(bMode))
     2863        bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
     2864                                      &Bs3Lidt_Idt32, sizeof(Bs3Lidt_Idt32), Expected.ab);
     2865    else
     2866        bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
     2867                                      &Bs3Lidt_Idt64, sizeof(Bs3Lidt_Idt64), Expected.ab);
     2868
     2869    /*
     2870     * Re-initialize the IDT.
     2871     */
     2872    Bs3TrapReInit();
     2873    return 0;
     2874}
     2875
     2876
     2877BS3_DECL_FAR(uint8_t) BS3_CMN_FAR_NM(bs3CpuBasic2_lgdt)(uint8_t bMode)
     2878{
     2879    union
     2880    {
     2881        RTGDTR  Gdtr;
     2882        uint8_t ab[32]; /* At least cbIdtr*2! */
     2883    } Expected;
     2884
     2885    g_pszTestMode = Bs3GetModeName(bMode);
     2886    g_bTestMode   = bMode;
     2887    g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(bMode);
     2888
     2889    /*
     2890     * Pass to common worker which is only compiled once per mode.
     2891     */
     2892    if (BS3_MODE_IS_RM_SYS(bMode))
     2893        ASMSetGDTR((PRTGDTR)&Bs3LgdtDef_Gdt);
     2894    Bs3MemZero(&Expected, sizeof(Expected));
     2895    ASMGetGDTR(&Expected.Gdtr);
     2896
     2897    bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLgdtWorkers, RT_ELEMENTS(g_aLgdtWorkers),
     2898                                  &Bs3LgdtDef_Gdt, sizeof(Bs3LgdtDef_Gdt), Expected.ab);
     2899
     2900    /*
     2901     * Re-initialize the IDT.
     2902     */
     2903    Bs3TrapReInit();
     2904    return 0;
     2905}
     2906#endif /* TMPL_BITS == 16 */
     2907
     2908
    27532909# if ARCH_BITS != 64
    27542910
    … …  
    29973153
    29983154
     3155# if 0
    29993156BS3_DECL_FAR(uint8_t) TMPL_NM(bs3CpuBasic2_sidt)(uint8_t bMode)
    30003157{
    3001     union
    3002     {
    3003         RTIDTR  Idtr;
    3004         uint8_t ab[16];
    3005     } Expected;
    3006 
    3007     g_pszTestMode = TMPL_NM(g_szBs3ModeName);
    3008     g_bTestMode   = bMode;
    3009     g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(TMPL_MODE);
    3010 
    30113158    BS3_ASSERT(bMode == TMPL_MODE);
    3012 
    3013     /*
    3014      * Pass to common worker which is only compiled once per mode.
    3015      */
    3016     Bs3MemZero(&Expected, sizeof(Expected));
    3017     ASMGetIDTR(&Expected.Idtr);
    3018     bs3CpuBasic2_sidt_sgdt_Common(bMode, g_aSidtWorkers, RT_ELEMENTS(g_aSidtWorkers), Expected.ab);
    3019 
    3020     /*
    3021      * Re-initialize the IDT.
    3022      */
    3023     Bs3TrapInit();
    3024     return 0;
     3159    return BS3_CMN_FAR_NM(bs3CpuBasic2_sidt)(bMode);
    30253160}
    30263161
    3027 
    30283162BS3_DECL_FAR(uint8_t) TMPL_NM(bs3CpuBasic2_sgdt)(uint8_t bMode)
    30293163{
    3030     uint64_t const uOrgAddr = Bs3Lgdt_Gdt.uAddr;
    3031     uint64_t       uNew     = 0;
    3032     union
    3033     {
    3034         RTGDTR  Gdtr;
    3035         uint8_t ab[16];
    3036     } Expected;
    3037 
    3038     g_pszTestMode = TMPL_NM(g_szBs3ModeName);
    3039     g_bTestMode   = bMode;
    3040     g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(TMPL_MODE);
    30413164    BS3_ASSERT(bMode == TMPL_MODE);
    3042 
    3043     /*
    3044      * If paged mode, try push the GDT way up.
    3045      */
    3046     if (BS3_MODE_IS_PAGED(bMode))
    3047     {
    3048 /** @todo loading non-canonical base addresses.   */
    3049         int rc;
    3050         uNew  = BS3_MODE_IS_64BIT_SYS(bMode) ? UINT64_C(0xffff80fedcb70000) : UINT64_C(0xc2d28000);
    3051         uNew |= uOrgAddr & X86_PAGE_OFFSET_MASK;
    3052         rc = Bs3PagingAlias(uNew, uOrgAddr, Bs3Lgdt_Gdt.cb, X86_PTE_P | X86_PTE_RW | X86_PTE_US | X86_PTE_D | X86_PTE_A);
    3053         if (RT_SUCCESS(rc))
    3054         {
    3055             Bs3Lgdt_Gdt.uAddr = uNew;
    3056             Bs3UtilSetFullGdtr(Bs3Lgdt_Gdt.cb, uNew);
    3057         }
    3058     }
    3059 
    3060     /*
    3061      * Pass to common worker which is only compiled once per mode.
    3062      */
    3063     Bs3MemZero(&Expected, sizeof(Expected));
    3064     ASMGetGDTR(&Expected.Gdtr);
    3065     bs3CpuBasic2_sidt_sgdt_Common(bMode, g_aSgdtWorkers, RT_ELEMENTS(g_aSgdtWorkers), Expected.ab);
    3066 
    3067     /*
    3068      * Unalias the GDT.
    3069      */
    3070     if (uNew != 0)
    3071     {
    3072         Bs3Lgdt_Gdt.uAddr = uOrgAddr;
    3073         Bs3UtilSetFullGdtr(Bs3Lgdt_Gdt.cb, uOrgAddr);
    3074         Bs3PagingUnalias(uNew, Bs3Lgdt_Gdt.cb);
    3075     }
    3076 
    3077     /*
    3078      * Re-initialize the IDT.
    3079      */
    3080     Bs3TrapInit();
    3081     return 0;
     3165    return BS3_CMN_FAR_NM(bs3CpuBasic2_sgdt)(bMode);
    30823166}
    30833167
    3084 
    30853168BS3_DECL_FAR(uint8_t) TMPL_NM(bs3CpuBasic2_lidt)(uint8_t bMode)
    30863169{
    3087     union
    3088     {
    3089         RTIDTR  Idtr;
    3090         uint8_t ab[32]; /* At least cbIdtr*2! */
    3091     } Expected;
    3092 
    3093     g_pszTestMode = TMPL_NM(g_szBs3ModeName);
    3094     g_bTestMode   = bMode;
    3095     g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(TMPL_MODE);
    3096 
    30973170    BS3_ASSERT(bMode == TMPL_MODE);
    3098 
    3099     /*
    3100      * Pass to common worker which is only compiled once per mode.
    3101      */
    3102     Bs3MemZero(&Expected, sizeof(Expected));
    3103     ASMGetIDTR(&Expected.Idtr);
    3104 
    3105     if (BS3_MODE_IS_RM_SYS(bMode))
    3106         bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
    3107                                       &Bs3Lidt_Ivt, sizeof(Bs3Lidt_Ivt), Expected.ab);
    3108     else if (BS3_MODE_IS_16BIT_SYS(bMode))
    3109         bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
    3110                                       &Bs3Lidt_Idt16, sizeof(Bs3Lidt_Idt16), Expected.ab);
    3111     else if (BS3_MODE_IS_32BIT_SYS(bMode))
    3112         bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
    3113                                       &Bs3Lidt_Idt32, sizeof(Bs3Lidt_Idt32), Expected.ab);
    3114     else
    3115         bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLidtWorkers, RT_ELEMENTS(g_aLidtWorkers),
    3116                                       &Bs3Lidt_Idt64, sizeof(Bs3Lidt_Idt64), Expected.ab);
    3117 
    3118     /*
    3119      * Re-initialize the IDT.
    3120      */
    3121     Bs3TrapInit();
    3122     return 0;
     3171    return BS3_CMN_FAR_NM(bs3CpuBasic2_lidt)(bMode);
    31233172}
    31243173
    31253174BS3_DECL_FAR(uint8_t) TMPL_NM(bs3CpuBasic2_lgdt)(uint8_t bMode)
    31263175{
    3127     union
    3128     {
    3129         RTGDTR  Gdtr;
    3130         uint8_t ab[32]; /* At least cbIdtr*2! */
    3131     } Expected;
    3132 
    3133     g_pszTestMode = TMPL_NM(g_szBs3ModeName);
    3134     g_bTestMode   = bMode;
    3135     g_f16BitSys   = BS3_MODE_IS_16BIT_SYS(TMPL_MODE);
    3136 
    31373176    BS3_ASSERT(bMode == TMPL_MODE);
    3138 
    3139     /*
    3140      * Pass to common worker which is only compiled once per mode.
    3141      */
    3142     if (BS3_MODE_IS_RM_SYS(bMode))
    3143         ASMSetGDTR((PRTGDTR)&Bs3LgdtDef_Gdt);
    3144     Bs3MemZero(&Expected, sizeof(Expected));
    3145     ASMGetGDTR(&Expected.Gdtr);
    3146 
    3147     bs3CpuBasic2_lidt_lgdt_Common(bMode, g_aLgdtWorkers, RT_ELEMENTS(g_aLgdtWorkers),
    3148                                   &Bs3LgdtDef_Gdt, sizeof(Bs3LgdtDef_Gdt), Expected.ab);
    3149 
    3150     /*
    3151      * Re-initialize the IDT.
    3152      */
    3153     Bs3TrapInit();
    3154     return 0;
     3177    return BS3_CMN_FAR_NM(bs3CpuBasic2_lgdt)(bMode);
    31553178}
     3179# endif
    31563180
    31573181#endif /* BS3_INSTANTIATING_MODE */

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

    r60729 r60749  
    3838BS3TESTMODE_PROTOTYPES_MODE(bs3CpuBasic2_TssGateEsp);
    3939BS3TESTMODE_PROTOTYPES_MODE(bs3CpuBasic2_RaiseXcpt1);
    40 //BS3TESTMODE_PROTOTYPES_CMN(bs3CpuBasic2_iret);
    4140BS3TESTMODE_PROTOTYPES_MODE(bs3CpuBasic2_iret);
    4241BS3TESTMODE_PROTOTYPES_MODE(bs3CpuBasic2_sidt);
    … …  
    4544BS3TESTMODE_PROTOTYPES_MODE(bs3CpuBasic2_lgdt);
    4645
     46FNBS3TESTDOMODE             bs3CpuBasic2_sidt_f16;
     47FNBS3TESTDOMODE             bs3CpuBasic2_sgdt_f16;
     48FNBS3TESTDOMODE             bs3CpuBasic2_lidt_f16;
     49FNBS3TESTDOMODE             bs3CpuBasic2_lgdt_f16;
     50FNBS3TESTDOMODE             bs3CpuBasic2_iret_f16;
     51
    4752
    4853/*********************************************************************************************************************************
    4954*   Global Variables                                                                                                             *
    5055*********************************************************************************************************************************/
     56#if 0
    5157static const BS3TESTMODEENTRY g_aModeTest[] =
    5258{
    53     //BS3TESTMODEENTRY_MODE("tss / gate / esp", bs3CpuBasic2_TssGateEsp),
    54     //BS3TESTMODEENTRY_CMN("iret", bs3CpuBasic2_iret),
     59#if 0
     60    BS3TESTMODEENTRY_MODE("tss / gate / esp", bs3CpuBasic2_TssGateEsp),
     61    BS3TESTMODEENTRY_MODE("raise xcpt #1", bs3CpuBasic2_RaiseXcpt1),
     62//    BS3TESTMODEENTRY_MODE("sidt", bs3CpuBasic2_sidt),
     63//    BS3TESTMODEENTRY_MODE("sgdt", bs3CpuBasic2_sgdt),
     64//    BS3TESTMODEENTRY_MODE("lidt", bs3CpuBasic2_lidt),
     65//    BS3TESTMODEENTRY_MODE("lgdt", bs3CpuBasic2_lgdt),
     66#endif
    5567//    BS3TESTMODEENTRY_MODE("iret", bs3CpuBasic2_iret),
    56 #if 1
    57     BS3TESTMODEENTRY_MODE("raise xcpt #1", bs3CpuBasic2_RaiseXcpt1),
    58     BS3TESTMODEENTRY_MODE("sidt", bs3CpuBasic2_sidt),
    59     BS3TESTMODEENTRY_MODE("sgdt", bs3CpuBasic2_sgdt),
     68};
    6069#endif
    61     BS3TESTMODEENTRY_MODE("lidt", bs3CpuBasic2_lidt),
    62     BS3TESTMODEENTRY_MODE("lgdt", bs3CpuBasic2_lgdt),
     70
     71static const BS3TESTMODEBYONEENTRY g_aModeByOneTests[] =
     72{
     73    //{ "iret", bs3CpuBasic2_iret_f16, 0 },
     74    { "lgdt", bs3CpuBasic2_lgdt_f16, 0 },
    6375};
    6476
    … …  
    7082    Bs3TestPrintf("g_uBs3CpuDetected=%#x\n", g_uBs3CpuDetected);
    7183
    72     Bs3TestDoModes_rm(g_aModeTest, RT_ELEMENTS(g_aModeTest));
     84    //Bs3TestDoModes_rm(g_aModeTest, RT_ELEMENTS(g_aModeTest));
     85    Bs3TestDoModesByOne_rm(g_aModeByOneTests, RT_ELEMENTS(g_aModeByOneTests), 0);
    7386
    7487    Bs3TestTerm();
    75 for (;;) { }
     88for (;;) { ASMHalt(); }
    7689}
    7790

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

    r60686 r60749  
    5555        bs3-cmn-A20Disable.asm \
    5656        bs3-cmn-A20Enable.asm \
     57        bs3-cmn-GetModeName.c \
    5758        bs3-cmn-KbdRead.asm \
    5859        bs3-cmn-KbdWait.asm \
    … …  
    145146        bs3-cmn-TestCheckRegCtxEx.c \
    146147        bs3-cmn-TestPrintf.c \
     148        bs3-cmn-TrapReInit.c \
    147149        bs3-cmn-TrapRmV86Init.c \
    148150        bs3-cmn-TrapRmV86SetGate.c \
    … …  
    161163       bs3-cmn-UtilSetFullGdtr.asm \
    162164       bs3-cmn-UtilSetFullIdtr.asm \
     165       bs3-cmn-TestDoModesByOneHlp.asm \
    163166       ../../../Runtime/common/asm/ASMBitFirstClear.asm \
    164167       ../../../Runtime/common/asm/ASMBitFirstSet.asm \
    … …  
    281284        bs3-mode-TrapSystemCallHandler.asm \
    282285        bs3-mode-TestDoModes.c \
     286        bs3-mode-TestDoModesByOne.c \
    283287        bs3-mode-TestDoModesHlp.asm \
    284288
    … …  
    290294bs3kit-rm_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
    291295        bs3-first-rm.asm \
    292         bs3-mode-CpuDetect.asm
     296        bs3-mode-CpuDetect.asm \
     297        bs3-mode-TestDoModesByOneStub.asm \
    293298
    294299
    … …  
    300305bs3kit-pe16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
    301306        bs3-first-pe16.asm \
     307        bs3-mode-TestDoModesByOneStub.asm \
    302308#       bs3-mode-CpuDetect.asm
    303309
    … …  
    307313bs3kit-pe16_32_INSTTYPE = none
    308314bs3kit-pe16_32_DEFS     = TMPL_MODE=BS3_MODE_PE16_32
    309 bs3kit-pe16_32_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     315bs3kit-pe16_32_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     316        bs3-mode-TestDoModesByOneStub.asm \
    310317
    311318# The v86 BS3Kit library for 16-bit protected kernel+tss.
    … …  
    314321bs3kit-pe16_v86_INSTTYPE = none
    315322bs3kit-pe16_v86_DEFS     = TMPL_MODE=BS3_MODE_PE16_V86
    316 bs3kit-pe16_v86_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     323bs3kit-pe16_v86_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     324        bs3-mode-TestDoModesByOneStub.asm \
    317325
    318326# The 32-bit BS3Kit library for 32-bit protected kernel+tss.
    … …  
    328336bs3kit-pe32_16_INSTTYPE = none
    329337bs3kit-pe32_16_DEFS     = TMPL_MODE=BS3_MODE_PE32_16
    330 bs3kit-pe32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     338bs3kit-pe32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     339        bs3-mode-TestDoModesByOneStub.asm \
    331340
    332341# The v8086 BS3Kit library for 32-bit protected kernel+tss.
    … …  
    337346bs3kit-pev86_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
    338347
    339 
    340348# The 16-bit BS3Kit library for 16-bit paged protected kernel+tss.
    341349LIBRARIES += bs3kit-pp16
    … …  
    344352bs3kit-pp16_DEFS     = TMPL_MODE=BS3_MODE_PP16
    345353bs3kit-pp16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
    346         bs3-mode-CpuDetect.asm
     354        bs3-mode-CpuDetect.asm \
     355        bs3-mode-TestDoModesByOneStub.asm \
    347356
    348357# The 32-bit BS3Kit library for 16-bit paged protected kernel+tss.
    … …  
    372381bs3kit-pp32_16_INSTTYPE = none
    373382bs3kit-pp32_16_DEFS     = TMPL_MODE=BS3_MODE_PP32_16
    374 bs3kit-pp32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     383bs3kit-pp32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     384        bs3-mode-TestDoModesByOneStub.asm \
    375385
    376386# The v8086 BS3Kit library for 32-bit paged protected kernel+tss.
    … …  
    388398bs3kit-pae16_DEFS     = TMPL_MODE=BS3_MODE_PAE16
    389399bs3kit-pae16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
    390         bs3-mode-CpuDetect.asm
     400        bs3-mode-CpuDetect.asm \
     401        bs3-mode-TestDoModesByOneStub.asm \
    391402
    392403# The 16-bit BS3Kit library for 16-bit PAE paged protected kernel+tss.
    … …  
    416427bs3kit-pae32_16_INSTTYPE = none
    417428bs3kit-pae32_16_DEFS     = TMPL_MODE=BS3_MODE_PAE32_16
    418 bs3kit-pae32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     429bs3kit-pae32_16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     430        bs3-mode-TestDoModesByOneStub.asm \
    419431
    420432# The v8086 BS3Kit library for 32-bit PAE paged protected kernel+tss.
    … …  
    431443bs3kit-lm16_INSTTYPE = none
    432444bs3kit-lm16_DEFS     = TMPL_MODE=BS3_MODE_LM16
    433 bs3kit-lm16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES)
     445bs3kit-lm16_SOURCES  = $(VBOX_BS3KIT_MODE_SOURCES) \
     446        bs3-mode-TestDoModesByOneStub.asm \
    434447
    435448# The 32-bit long mode BS3Kit library.

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-RegCtxRestore.asm

    r60657 r60749  
    3535TMPL_BEGIN_TEXT
    3636BS3_EXTERN_CMN Bs3Syscall
     37BS3_EXTERN_CMN Bs3Panic
    3738TMPL_BEGIN_TEXT
    3839
    … …  
    8081
    8182.do_syscall_restore_ctx:
    82 %if TMPL_BITS == 16
     83%if TMPL_BITS != 16
     84.do_syscall_restore_ctx_restore_ds:
     85        mov     cx, ds
     86        mov     xSI, [xBP + xCB*2]
     87        movzx   edx, word [xBP + xCB*3]
     88        mov     eax, BS3_SYSCALL_RESTORE_CTX
     89%else
    8390        mov     si, [bp + xCB + cbCurRetAddr]
    8491        mov     cx, [bp + xCB + cbCurRetAddr + 2]
    8592        mov     dx, [bp + xCB + cbCurRetAddr + sCB]
    8693        mov     ax, BS3_SYSCALL_RESTORE_CTX
    87 %else
    88         mov     cx, ds
    89         mov     xSI, [xBP + xCB*2]
    90         movzx   edx, word [xBP + xCB*3]
    91         mov     eax, BS3_SYSCALL_RESTORE_CTX
    9294%endif
    9395        call    Bs3Syscall
     96        call    Bs3Panic
     97
     98%if TMPL_BITS == 16
     99.do_syscall_restore_ctx_restore_ds:
     100        push    es
     101        pop     ds
     102        jmp     .do_syscall_restore_ctx
     103%endif
    94104
    95105        ;
    … …  
    115125%endif
    116126
     127
     128%if TMPL_BITS != 64
     129        ; Restoring a 64-bit context is best done from 64-bit code.
     130        mov     al, [xBX + BS3REGCTX.bMode]
     131        test    al, BS3_MODE_CODE_64
     132        jnz     .do_syscall_restore_ctx_restore_ds
     133%endif
     134
    117135        ; The remainder must be done with interrupts disabled.
    118136        cli
    … …  
    121139        ; Update g_bs3CurrentMode.
    122140        ;
     141%if TMPL_BITS == 64
    123142        mov     al, [xBX + BS3REGCTX.bMode]
     143%endif
    124144        and     al, BS3_MODE_CODE_MASK
    125145        mov     ah, [BS3_ONLY_16BIT(es:) BS3_DATA16_WRT(g_bBs3CurrentMode)]

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-RegCtxSaveEx.asm

    r60657 r60749  
    7777%if TMPL_BITS != 64
    7878extern              _Bs3RegCtxSave_c64
     79extern              _Bs3SwitchTo%[TMPL_BITS]Bit_c64
    7980%endif
    8081
    … …  
    103104        and     dl, BS3_MODE_CODE_MASK
    104105%if TMPL_BITS == 16
    105         push    dx                          ; xBP - xCB*1: save space for previous CPU mode (16-bit)
     106        push    dx                          ; bp - 2: previous CPU mode (16-bit)
    106107%endif
    107108
    … …  
    286287
    287288 %if TMPL_BITS == 16
    288         cmp     byte [xBP - xCB*1], BS3_MODE_CODE_16
    289         jne     .code_32_back_to_v86
     289        cmp     byte [bp - 2], BS3_MODE_CODE_V86
     290        je      .code_32_back_to_v86
    290291        call    _Bs3SwitchTo16Bit_c32
    291292        BS3_SET_BITS TMPL_BITS
    … …  
    328329        call    _Bs3RegCtxSave_c64          ; No BS3_CALL as rcx is already ready.
    329330
    330         call    _Bs3SwitchTo16Bit_c32
    331         BS3_SET_BITS 16
     331        call    _Bs3SwitchTo%[TMPL_BITS]Bit_c64
     332        BS3_SET_BITS TMPL_BITS
    332333        jmp     .return
    333334%endif

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-cmn-SwitchTo64Bit.asm

    r60527 r60749  
    7474        push    sAX
    7575 %if TMPL_BITS == 16
    76         push    dword .sixty_four_bit
     76        push    dword .sixty_four_bit wrt FLAT
    7777        o32 retf
    7878 %else

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

    r60739 r60749  
    11/* $Id$ */
    22/** @file
    3  * BS3Kit - Bs3TrapInit
     3 * BS3Kit - Bs3TrapReInit
    44 */
    55
    … …  
    3232
    3333
    34 #undef Bs3TrapInit
    35 BS3_MODE_DEF(void, Bs3TrapInit,(void))
     34#undef Bs3TrapReInit
     35BS3_CMN_DEF(void, Bs3TrapReInit,(void))
    3636{
    37 #if BS3_MODE_IS_RM_SYS(TMPL_MODE)
    38     Bs3TrapRmV86Init();
    39 #elif BS3_MODE_IS_16BIT_SYS(TMPL_MODE)
    40     Bs3TrapRmV86Init();
    41     Bs3Trap16Init();
    42 #elif BS3_MODE_IS_32BIT_SYS(TMPL_MODE)
    43     Bs3TrapRmV86Init();
    44     Bs3Trap32Init();
    45 #elif BS3_MODE_IS_64BIT_SYS(TMPL_MODE)
    46     Bs3Trap64Init();
    47 #else
    48 # error "TMPL_MODE"
    49 #endif
     37    if (BS3_MODE_IS_RM_SYS(g_bBs3CurrentMode))
     38        Bs3TrapRmV86Init();
     39    else if (BS3_MODE_IS_16BIT_SYS(g_bBs3CurrentMode))
     40    {
     41        Bs3TrapRmV86Init();
     42        Bs3Trap16Init();
     43    }
     44    else if (BS3_MODE_IS_32BIT_SYS(g_bBs3CurrentMode))
     45    {
     46        Bs3TrapRmV86Init();
     47        Bs3Trap32Init();
     48    }
     49    else
     50    {
     51        BS3_ASSERT(BS3_MODE_IS_64BIT_SYS(g_bBs3CurrentMode));
     52        Bs3Trap64Init();
     53    }
    5054}
    5155

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

    r60728 r60749  
    3939BS3_DECL(void) Bs3InitAll_rm(void)
    4040{
    41     uint32_t volatile BS3_FAR *pcTicks = (uint32_t volatile BS3_FAR *)BS3_FP_MAKE(0x40, 0x6c);
    42     uint32_t                   cInitialTicks = *pcTicks;
    43     int                        i = 3;
     41    uint8_t volatile BS3_FAR  *pcTicksFlpyOff;
    4442
     43    /*
     44     * Detect CPU first as the memory init code will otherwise use 386
     45     * instrunctions and cause trouble on older CPUs.
     46     */
    4547    Bs3CpuDetect_rm_far();
    4648    Bs3InitMemory_rm_far();
    4749    Bs3InitGdt_rm_far();
    4850
    49     /* For for floppy to stop (a couple of ticks), then disable interrupts. */
    50     ASMIntEnable();
    51     while (i-- > 0)
     51    /*
     52     * Before we disable all interrupts, try convince the BIOS to stop the
     53     * floppy motor, as it is kind of disturbing when the floppy light remains
     54     * on for the whole testcase execution.
     55     */
     56    ASMIntDisable(); /* (probably already disabled, but no guarantees) */
     57    pcTicksFlpyOff = (uint8_t volatile BS3_FAR *)BS3_FP_MAKE(0x40, 0x40);
     58    if (*pcTicksFlpyOff)
    5259    {
     60        uint32_t volatile BS3_FAR *pcTicks = (uint32_t volatile BS3_FAR *)BS3_FP_MAKE(0x40, 0x6c);
     61        uint32_t cInitialTicks;
     62
     63        *pcTicksFlpyOff = 1;            /* speed up the countdown, don't want to wait for two seconds here. */
     64        cInitialTicks   = *pcTicks;
     65        ASMIntEnable();
     66
    5367        while (*pcTicks == cInitialTicks)
    5468            ASMHalt();
    55         *pcTicks = cInitialTicks;
    5669    }
    5770    ASMIntDisable();
    5871    Bs3PicMaskAll();
    5972
     73    /*
     74     * Initialize IDTs and such.
     75     */
    6076    if (g_uBs3CpuDetected & BS3CPU_F_LONG_MODE)
    6177        Bs3Trap64Init();
    … …  
    6581        Bs3Trap16Init();
    6682    Bs3TrapRmV86Init();
     83
     84    /*
     85     * Perform a real-mode enter to make some final environment adjustments
     86     * (like installing our syscall).
     87     */
    6788    Bs3EnteredMode_rm();
    6889}

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit-autostubs.kmk

    r60686 r60749  
    3636$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TestCheckRegCtxEx)
    3737$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3StrCpy)
     38$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3GetModeName)
    3839$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3PagingAlias)
    3940$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3PagingInitRootForLM)
    … …  
    105106$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TrapDefaultHandler)
    106107$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TrapPrintFrame)
     108$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TrapReInit)
    107109$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TrapRmV86Init)
    108110$(call BS3KIT_FN_GEN_CMN_NEARSTUB,bs3kit-common-16,Bs3TrapRmV86InitEx)

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit-mangling-code-define.h

    r60686 r60749  
    3131#define Bs3A20EnableViaKbd BS3_CMN_MANGLER(Bs3A20EnableViaKbd)
    3232#define Bs3A20EnableViaPortA BS3_CMN_MANGLER(Bs3A20EnableViaPortA)
     33#define Bs3GetModeName BS3_CMN_MANGLER(Bs3GetModeName)
    3334#define Bs3KbdRead BS3_CMN_MANGLER(Bs3KbdRead)
    3435#define Bs3KbdWait BS3_CMN_MANGLER(Bs3KbdWait)
    … …  
    131132#define Bs3TrapDefaultHandler BS3_CMN_MANGLER(Bs3TrapDefaultHandler)
    132133#define Bs3TrapPrintFrame BS3_CMN_MANGLER(Bs3TrapPrintFrame)
     134#define Bs3TrapReInit BS3_CMN_MANGLER(Bs3TrapReInit)
    133135#define Bs3TrapRmV86Init BS3_CMN_MANGLER(Bs3TrapRmV86Init)
    134136#define Bs3TrapRmV86InitEx BS3_CMN_MANGLER(Bs3TrapRmV86InitEx)
    … …  
    145147# define Bs3CpuDetect BS3_MODE_MANGLER(Bs3CpuDetect)
    146148# define Bs3TestDoModes BS3_MODE_MANGLER(Bs3TestDoModes)
     149# define Bs3TestDoModesByOne BS3_MODE_MANGLER(Bs3TestDoModesByOne)
    147150# define Bs3TrapInit BS3_MODE_MANGLER(Bs3TrapInit)
    148151#endif /* !BS3_CMN_ONLY */

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3kit-mangling-code-undef.h

    r60686 r60749  
    3131#undef Bs3A20EnableViaKbd
    3232#undef Bs3A20EnableViaPortA
     33#undef Bs3GetModeName
    3334#undef Bs3KbdRead
    3435#undef Bs3KbdWait
    … …  
    131132#undef Bs3TrapDefaultHandler
    132133#undef Bs3TrapPrintFrame
     134#undef Bs3TrapReInit
    133135#undef Bs3TrapRmV86Init
    134136#undef Bs3TrapRmV86InitEx
    … …  
    145147# undef Bs3CpuDetect
    146148# undef Bs3TestDoModes
     149# undef Bs3TestDoModesByOne
    147150# undef Bs3TrapInit
    148151#endif /* !BS3_CMN_ONLY */

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

    r60686 r60749  
    14421442#endif
    14431443
     1444
     1445/**
     1446 * Translate a mode into a string.
     1447 *
     1448 * @returns Pointer to read-only mode name string.
     1449 * @param   bMode       The mode value (BS3_MODE_XXX).
     1450 */
     1451BS3_CMN_PROTO_STUB(const char BS3_FAR *, Bs3GetModeName,(uint8_t bMode));
     1452
    14441453/**
    14451454 * Shutdown the system, never returns.
    … …  
    24822491
    24832492/**
     2493 * Re-initializes the trap handling for the current mode.
     2494 *
     2495 * Useful after a test that messes with the IDT/IVT.
     2496 *
     2497 * @sa      Bs3TrapInit
     2498 */
     2499BS3_CMN_PROTO_STUB(void, Bs3TrapReInit,(void));
     2500
     2501/**
    24842502 * Initializes real mode and v8086 trap handling.
    24852503 *
    … …  
    29442962    FNBS3TESTDOMODE   RT_CONCAT(a_BaseNm, _lm32); \
    29452963    FNBS3TESTDOMODE   RT_CONCAT(a_BaseNm, _lm64)
     2964
     2965
     2966/**
     2967 * One worker drives all modes.
     2968 *
     2969 * This is an alternative to BS3TESTMODEENTRY where one worker, typically
     2970 * 16-bit, does all the test driver work.  It's called repeatedly from all
     2971 * the modes being tested.
     2972 */
     2973typedef struct BS3TESTMODEBYONEENTRY
     2974{
     2975    const char * BS3_FAR    pszSubTest;
     2976    PFNBS3TESTDOMODE        pfnWorker;
     2977    uint32_t                u32Reserved;
     2978} BS3TESTMODEBYONEENTRY;
     2979/** Pointer to a mode-by-one sub-test entry. */
     2980typedef BS3TESTMODEBYONEENTRY const *PCBS3TESTMODEBYONEENTRY;
    29462981
    29472982
    … …  
    31603195BS3_MODE_PROTO_NOSB(void, Bs3TestDoModes,(PCBS3TESTMODEENTRY paEntries, size_t cEntries));
    31613196
     3197/**
     3198 * Executes the array of tests in every possibly mode, unitifed driver.
     3199 *
     3200 * This requires much less code space than Bs3TestDoModes as there is only one
     3201 * instace of each sub-test driver code, instead of 3 (cmn) or 22 (per-mode)
     3202 * copies.
     3203 *
     3204 * @param   paEntries       The mode sub-test-by-one entries.
     3205 * @param   cEntries        The number of sub-test-by-one entries.
     3206 * @param   fFlags          Reserved for the future, MBZ.
     3207 */
     3208BS3_MODE_PROTO_NOSB(void, Bs3TestDoModesByOne,(PCBS3TESTMODEBYONEENTRY paEntries, size_t cEntries, uint32_t fFlags));
     3209
    31623210
    31633211/** @} */
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