VirtualBox

忽略:
時間撮記:
2016-3-9 下午11:00:02 (9 年 以前)
作者:
vboxsync
訊息:

bs3kit: updates and fixes.

位置:
trunk/src/VBox/ValidationKit/bootsectors/bs3kit
檔案:
新增 2 筆資料
刪除 1 筆資料
修改 12 筆資料

圖例:

未更動
新增
刪除

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

    r59934 r59975  
    8282       bs3-cmn-PagingInitRootForPAE.c \
    8383       bs3-cmn-PagingInitRootForLM.c \
     84       bs3-cmn-RegCtxRestore.asm \
     85       bs3-cmn-RegCtxConvertToRingX.c \
    8486       bs3-cmn-SelProtFar32ToFlat32.c \
    8587       bs3-cmn-SlabInit.c \
    … …  
    169171        bs3-wc32-U8RS.asm \
    170172        bs3-wc32-U8LS.asm \
    171        bs3-c32-Trap32Generic.asm \
    172        bs3-c32-Trap32ResumeFrame.asm
     173       bs3-c32-Trap32Generic.asm
    173174
    174175# The 64-bit BS3Kit library.

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

    r59952 r59975  
    104104
    105105        ; save the registers.
    106         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.rax], eax
    107         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.rsp], esp
    108         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.rbp], ebp
     106        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.rax], eax
     107        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.rsp], esp
     108        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.rbp], ebp
    109109        mov     ax, ss
    110         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.ss], ax
     110        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.ss], ax
    111111        mov     ax, ds
    112         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.ds], ax
     112        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.ds], ax
    113113        mov     ax, es
    114         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.es], ax
     114        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.es], ax
    115115        mov     ax, fs
    116         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.fs], ax
     116        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.fs], ax
    117117        mov     ax, gs
    118118
    … …  
    134134        pushfd
    135135        pop     eax
    136         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rflags], eax
    137         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rbx], ebx
    138         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rcx], ecx
    139         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rdx], edx
    140         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rsi], esi
    141         mov     [BS3_ADDR_REG_SAVE + BS3REGS.rdi], edi
     136        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rflags], eax
     137        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rbx], ebx
     138        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rcx], ecx
     139        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rdx], edx
     140        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rsi], esi
     141        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.rdi], edi
    142142        mov     eax, cr2
    143         mov     [BS3_ADDR_REG_SAVE + BS3REGS.cr2], eax
     143        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.cr2], eax
    144144        mov     eax, cr3
    145         mov     [BS3_ADDR_REG_SAVE + BS3REGS.cr3], eax
     145        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.cr3], eax
    146146        mov     eax, cr4
    147         mov     [BS3_ADDR_REG_SAVE + BS3REGS.cr4], eax
    148         mov     byte [BS3_ADDR_REG_SAVE + BS3REGS.bMode], BS3_MODE_RM
     147        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.cr4], eax
     148        mov     byte [BS3_ADDR_REG_SAVE + BS3REGCTX.bMode], BS3_MODE_RM
    149149        xor     eax, eax
    150         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.cs], ax
     150        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.cs], ax
    151151        mov     ax, start
    152         mov     [cs:BS3_ADDR_REG_SAVE + BS3REGS.rip], eax
     152        mov     [cs:BS3_ADDR_REG_SAVE + BS3REGCTX.rip], eax
    153153
    154154        ; Make sure caching is enabled and alignment is off.
    155155        mov     eax, cr0
    156         mov     [BS3_ADDR_REG_SAVE + BS3REGS.cr0], eax
     156        mov     [BS3_ADDR_REG_SAVE + BS3REGCTX.cr0], eax
    157157        and     eax, ~(X86_CR0_NW | X86_CR0_CD | X86_CR0_AM)
    158158        mov     cr0, eax

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-c32-Trap32Generic.asm

    r59287 r59975  
    2525;
    2626
     27;*********************************************************************************************************************************
     28;*  Header Files                                                                                                                 *
     29;*********************************************************************************************************************************
    2730%include "bs3kit-template-header.mac"
    2831
    … …  
    3134%endif
    3235
     36
     37;*********************************************************************************************************************************
     38;*  External Symbols                                                                                                             *
     39;*********************************************************************************************************************************
     40BS3_EXTERN_DATA16 g_bBs3CurrentMode
     41TMPL_BEGIN_TEXT
     42BS3_EXTERN_CMN Bs3TrapDefaultHandler
     43BS3_EXTERN_CMN Bs3RegCtxRestore
     44TMPL_BEGIN_TEXT
     45
     46
     47;*********************************************************************************************************************************
     48;*  Global Variables                                                                                                             *
     49;*********************************************************************************************************************************
    3350BS3_BEGIN_DATA16
    3451;; Easy to access flat address of Bs3Trap32GenericEntries.
    … …  
    4461        resd 256
    4562
    46 
    47 TMPL_BEGIN_TEXT
    48 BS3_EXTERN_CMN Bs3TrapDefaultHandler
    49 BS3_EXTERN_CMN Bs3Trap32ResumeFrame
    5063
    5164
    … …  
    210223
    211224        ;
     225        ; Copy and update the mode now that we've got a flat DS.
     226        ;
     227        mov     al, [BS3_DATA16_WRT(g_bBs3CurrentMode)]
     228        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bMode], al
     229        and     al, ~BS3_MODE_CODE_MASK
     230        or      al, BS3_MODE_CODE_32
     231        mov     [BS3_DATA16_WRT(g_bBs3CurrentMode)], al
     232
     233        ;
    212234        ; Copy iret info.
    213235        ;
    … …  
    216238        mov     ecx, [ebp + 12]
    217239        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.rflags], ecx
    218         mov     cx, [ebp + 8]
     240        mov     cl, [ebp + 8]
    219241        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.cs], cx
    220242        test    dword [ebp + 12], X86_EFL_VM
    221243        jnz     .iret_frame_v8086
    222244        mov     ax, ss
    223         and     ax, 3
    224         and     cx, 3
    225         cmp     ax, ax
     245        and     al, 3
     246        and     cl, 3
     247        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bCpl], cl
     248        cmp     cl, al
    226249        je      .iret_frame_same_cpl
    227250
    … …  
    244267
    245268.iret_frame_v8086:
     269        mov     byte [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bCpl], 3
     270        or      byte [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bMode], BS3_MODE_CODE_V86 ; paranoia ^ 2
    246271        lea     ecx, [ebp + 12]
    247272        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.rsp], ecx
    … …  
    282307.clear_and_dispatch_to_handler:         ; The double fault code joins us here.
    283308        xor     edx, edx
    284         mov     dword [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.cBits], 32
    285         mov     dword [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.abPadding + 3], edx
     309        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.abPadding], dx
     310        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.abPadding + 2], edx
    286311        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.rax    + 4], edx
    287312        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.rcx    + 4], edx
    … …  
    311336        ;
    312337        movzx   ebx, byte [esp + BS3TRAPFRAME.bXcpt]
    313         mov     eax, [BS3_DATA_NM(g_apfnBs3TrapHandlers_c32) + ebx * 4]
     338        mov     eax, [ebx * 4 + BS3_DATA16_WRT(_g_apfnBs3TrapHandlers_c32)]
    314339        or      eax, eax
    315340        jnz     .call_handler
    … …  
    324349        ;
    325350        push    0
     351        add     edi, BS3TRAPFRAME.Ctx
    326352        push    edi
    327         call    Bs3Trap32ResumeFrame
     353        call    Bs3RegCtxRestore
    328354.panic:
    329         int3
    330355        hlt
    331356        jmp     .panic
    … …  
    443468        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.cr3], ecx
    444469
    445         mov     dword [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.cBits], 32
     470        ;
     471        ; Set CPL; copy and update mode.
     472        ;
     473        mov     cl, [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.ss]
     474        and     cl, 3
     475        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bCpl], cl
     476
     477        mov     cl, [BS3_DATA16_WRT(g_bBs3CurrentMode)]
     478        mov     [esp + BS3TRAPFRAME.Ctx + BS3REGCTX.bMode], cl
     479        and     cl, ~BS3_MODE_CODE_MASK
     480        or      cl, BS3_MODE_CODE_32
     481        mov     [BS3_DATA16_WRT(g_bBs3CurrentMode)], cl
    446482
    447483        ;

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

    r59286 r59975  
    3333BS3_DECL(void) Bs3TrapDefaultHandler(PBS3TRAPFRAME pTrapFrame)
    3434{
     35#if TMPL_BITS != 64
     36    /*
     37     * Deal with GPs in V8086 mode.
     38     */
     39Bs3Printf("bXcpt=%#x\n", pTrapFrame->bXcpt);
     40Bs3Printf("bXcpt=%#x\n", pTrapFrame->bXcpt);
     41Bs3Printf("eflags=%#RX32 (%d)\n", pTrapFrame->Ctx.rflags.u32, RT_BOOL(pTrapFrame->Ctx.rflags.u32 & X86_EFL_VM));
     42Bs3Printf("cs=%#x\n", pTrapFrame->Ctx.cs);
     43for (;;) { }
     44    if (    pTrapFrame->bXcpt == X86_XCPT_GP
     45        && (pTrapFrame->Ctx.rflags.u32 & X86_EFL_VM)
     46        && pTrapFrame->Ctx.cs == BS3_SEL_TEXT16)
     47    {
     48        bool                    fHandled    = true;
     49        uint8_t                 cBitsOpcode = 16;
     50        uint8_t                 bOpCode;
     51        uint8_t const BS3_FAR  *pbCodeStart;
     52        uint8_t const BS3_FAR  *pbCode;
     53        uint16_t BS3_FAR       *pusStack;
     54for (;;) { }
     55
     56        pusStack    = (uint16_t      BS3_FAR *)BS3_MAKE_PROT_R0PTR_FROM_REAL(pTrapFrame->Ctx.ss, pTrapFrame->Ctx.rsp.u16);
     57        pbCode      = (uint8_t const BS3_FAR *)BS3_MAKE_PROT_R0PTR_FROM_REAL(pTrapFrame->Ctx.cs, pTrapFrame->Ctx.rip.u16);
     58        pbCodeStart = pbCode;
     59
     60        bOpCode = *++pbCode;
     61        if (bOpCode == 0x66)
     62        {
     63            cBitsOpcode = 32;
     64            bOpCode = *++pbCode;
     65        }
     66
     67        /* INT xx: Real mode behaviour, but intercepting and implementing most of our syscall interface. */
     68        if (bOpCode == 0xcd)
     69        {
     70            uint8_t bVector = *++pbCode;
     71            if (bVector == BS3_TRAP_SYSCALL)
     72            {
     73                /* Minimal syscall. */
     74                if (pTrapFrame->Ctx.rax.u16 == BS3_SYSCALL_PRINT_CHR)
     75                    Bs3PrintChr(pTrapFrame->Ctx.rax.u8);
     76                else if (   pTrapFrame->Ctx.rax.u16 == BS3_SYSCALL_TO_RING0
     77                         || pTrapFrame->Ctx.rax.u16 == BS3_SYSCALL_TO_RING1
     78                         || pTrapFrame->Ctx.rax.u16 == BS3_SYSCALL_TO_RING2
     79                         || pTrapFrame->Ctx.rax.u16 == BS3_SYSCALL_TO_RING3)
     80                {
     81                    Bs3RegCtxConvertToRingX(&pTrapFrame->Ctx, pTrapFrame->Ctx.rax.u16 - BS3_SYSCALL_TO_RING0);
     82for (;;) { }
     83                }
     84                else
     85                    Bs3Panic();
     86            }
     87            else
     88            {
     89                /* Real mode behaviour. */
     90                uint16_t BS3_FAR *pusIvte = (uint16_t BS3_FAR *)BS3_MAKE_PROT_R0PTR_FROM_REAL(0, 0);
     91                pusIvte += (uint16_t)bVector *2;
     92
     93                pusStack[0] = pTrapFrame->Ctx.rflags.u16;
     94                pusStack[1] = pTrapFrame->Ctx.cs;
     95                pusStack[2] = pTrapFrame->Ctx.rip.u16 + (uint16_t)(pbCode - pbCodeStart);
     96
     97                pTrapFrame->Ctx.rip.u16 = pusIvte[0];
     98                pTrapFrame->Ctx.cs      = pusIvte[1];
     99                pTrapFrame->Ctx.rflags.u16 &= ~X86_EFL_IF; /** @todo this isn't all, but it'll do for now, I hope. */
     100                Bs3RegCtxRestore(&pTrapFrame->Ctx, 0/*fFlags*/); /* does not return. */
     101            }
     102        }
     103        /* PUSHF: Real mode behaviour. */
     104        else if (bOpCode == 0x9c)
     105        {
     106            if (cBitsOpcode == 32)
     107                *pusStack++ = pTrapFrame->Ctx.rflags.au16[1] & ~(X86_EFL_VM | X86_EFL_RF);
     108            *pusStack++ = pTrapFrame->Ctx.rflags.u16;
     109            pTrapFrame->Ctx.rsp.u16 += cBitsOpcode / 8;
     110        }
     111        /* POPF:  Real mode behaviour. */
     112        else if (bOpCode == 0x9d)
     113        {
     114            if (cBitsOpcode == 32)
     115            {
     116                pTrapFrame->Ctx.rflags.u32 &= ~X86_EFL_POPF_BITS;
     117                pTrapFrame->Ctx.rflags.u32 |= X86_EFL_POPF_BITS & *(uint32_t const *)pusStack;
     118            }
     119            else
     120            {
     121                pTrapFrame->Ctx.rflags.u32 &= ~(X86_EFL_POPF_BITS | UINT32_C(0xffff0000)) & ~X86_EFL_RF;
     122                pTrapFrame->Ctx.rflags.u16 |= (uint16_t)X86_EFL_POPF_BITS & *pusStack;
     123            }
     124            pTrapFrame->Ctx.rsp.u16 -= cBitsOpcode / 8;
     125        }
     126        /* CLI: Real mode behaviour. */
     127        else if (bOpCode == 0xfa)
     128            pTrapFrame->Ctx.rflags.u16 &= ~X86_EFL_IF;
     129        /* STI: Real mode behaviour. */
     130        else if (bOpCode == 0xfb)
     131            pTrapFrame->Ctx.rflags.u16 |= X86_EFL_IF;
     132        /* Unexpected. */
     133        else
     134            fHandled = false;
     135for (;;) { }
     136        if (fHandled)
     137        {
     138            pTrapFrame->Ctx.rip.u16 += (uint16_t)(pbCode - pbCodeStart);
     139            Bs3RegCtxRestore(&pTrapFrame->Ctx, 0 /*fFlags*/); /* does not return. */
     140            return;
     141        }
     142    }
     143
     144#endif
     145
    35146    Bs3TrapPrintFrame(pTrapFrame);
    36147    Bs3Panic();
    37148}
    38149
    39 

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

    r59286 r59975  
    3838              pTrapFrame->uErrCd,
    3939              pTrapFrame->Ctx.cs,
    40               pTrapFrame->Ctx.rip);
     40              pTrapFrame->Ctx.rip.u64);
    4141}
    4242

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

    r59949 r59975  
    111111        ; Always 64-bit in long mode, otherwise according to TMPL_BITS.
    112112        ;
    113         mov     ax, X86DESCGENERIC_BIT_OFF_TYPE + 1 ; For clearing the busy bit in the TSS descriptor type.
    114113 %if BS3_MODE_IS_64BIT_SYS(TMPL_MODE)
    115114        BS3_EXTERN_SYSTEM16 Bs3Gdte_Tss64
    116115        TMPL_BEGIN_TEXT
    117         btr     [Bs3Gdte_Tss64 TMPL_WRT_SYSTEM16_OR_FLAT], ax
     116        and     byte [5 + Bs3Gdte_Tss64 TMPL_WRT_SYSTEM16_OR_FLAT], ~X86_SEL_TYPE_SYS_TSS_BUSY_MASK
    118117        mov     ax, BS3_SEL_TSS64
    119118
    … …  
    122121        BS3_EXTERN_SYSTEM16 Bs3Gdte_Tss16DoubleFault
    123122        TMPL_BEGIN_TEXT
    124         btr     [Bs3Gdte_Tss16            TMPL_WRT_SYSTEM16_OR_FLAT], ax
    125         btr     [Bs3Gdte_Tss16DoubleFault TMPL_WRT_SYSTEM16_OR_FLAT], ax
     123        and     byte [5 + Bs3Gdte_Tss16            TMPL_WRT_SYSTEM16_OR_FLAT], ~X86_SEL_TYPE_SYS_TSS_BUSY_MASK
     124        and     byte [5 + Bs3Gdte_Tss16DoubleFault TMPL_WRT_SYSTEM16_OR_FLAT], ~X86_SEL_TYPE_SYS_TSS_BUSY_MASK
    126125        mov     ax, BS3_SEL_TSS16
    127126
    … …  
    132131        BS3_EXTERN_SYSTEM16 Bs3Tss32DoubleFault
    133132        TMPL_BEGIN_TEXT
    134         btr     [Bs3Gdte_Tss32            TMPL_WRT_SYSTEM16_OR_FLAT], ax
    135         btr     [Bs3Gdte_Tss32DoubleFault TMPL_WRT_SYSTEM16_OR_FLAT], ax
     133        and     byte [5 + Bs3Gdte_Tss32            TMPL_WRT_SYSTEM16_OR_FLAT], ~X86_SEL_TYPE_SYS_TSS_BUSY_MASK
     134        and     byte [5 + Bs3Gdte_Tss32DoubleFault TMPL_WRT_SYSTEM16_OR_FLAT], ~X86_SEL_TYPE_SYS_TSS_BUSY_MASK
    136135        mov     eax, cr3
    137136        mov     [X86TSS32.cr3 + Bs3Tss32            TMPL_WRT_SYSTEM16_OR_FLAT], eax

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

    r59950 r59975  
    6363        ;
    6464        ; Protected mode.
    65         ;
     65        ; 80286 requirements for PE16 clutters the code a little.
     66        ;
     67 %if TMPL_MODE == BS3_MODE_PE16
     68        mov     ax, BS3_SEL_DATA16
     69        mov     ds, ax                  ; Bs3EnterMode_rm will set ds, so no need to preserve it
     70        cmp     byte [BS3_DATA16_WRT(g_uBs3CpuDetected)], BS3CPU_80286
     71        ja      .do_386_prologue
     72        push    bp
     73        push    ax
     74        push    bx
     75        pushf
     76        push    word 1
     77        jmp     .done_prologue
     78 %endif
     79.do_386_prologue:
     80        push    sBP
    6681        push    sAX
    6782        push    sBX
    6883        sPUSHF
     84 %if TMPL_MODE == BS3_MODE_PE16
     85        push    word 0
     86 %endif
     87.done_prologue:
    6988
    7089        ;
    … …  
    8099        ; On 80286 we must reset the CPU to get back to real mode.
    81100        ;
    82         mov     ax, BS3_SEL_DATA16
    83         mov     ds, ax
    84         cmp     byte [BS3_DATA16_WRT(g_uBs3CpuDetected)], BS3CPU_80286
    85         jne     .is_386_or_better
     101        pop     ax
     102        push    ax
     103        test    ax, ax
     104        jz      .is_386_or_better
    86105.implement_this_later:
    87106        int3
    … …  
    143162        call    NAME(Bs3EnteredMode_rm)
    144163
    145  %if TMPL_BITS == 64
     164 %if TMPL_MODE == BS3_MODE_PE16
     165        pop     ax
     166        test    ax, ax
     167        jz      .do_386_epilogue
     168        popf
     169        pop     bx
     170        pop     ax
     171        pop     bp
     172 %endif
     173 %if TMPL_BITS != 64
     174.do_386_epilogue:
     175        popfd
     176        pop     ebx
     177        pop     eax
     178%if 0
     179        pop     ebp
     180%else
     181add     esp, 4
     182%endif
     183 %else
    146184        pop     eax
    147185        popfd
    … …  
    150188        pop     eax
    151189        pop     eax
    152  %else
    153         popfd
    154         pop     ebx
    155         pop     eax
    156  %endif
    157         retn    BS3_IF_16_32_64BIT(0, 2, 6)
     190        pop     ebp
     191        pop     ebp
     192 %endif
     193        retn    (TMPL_BITS - 16) / 8
    158194
    159195 %if TMPL_BITS != 16

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-mode-TestDoModes.c

    r59946 r59975  
    335335        }
    336336
    337         if (paEntries[i].pfnDoPAEV86 && fDoV86Mode)
     337        if (paEntries[i].pfnDoPAEV86 /*&& fDoV86Mode*/)
    338338        {
    339339            bErrNo = TMPL_NM(Bs3TestCallDoerInPAEV86)(CONV_TO_BS3TEXT16(paEntries[i].pfnDoPAEV86));

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

    r59952 r59975  
    3232TMPL_BEGIN_TEXT
    3333
     34%if TMPL_BITS == 32
     35BS3_EXTERN_CMN Bs3SelProtFar32ToFlat32
     36%endif
     37BS3_EXTERN_CMN Bs3RegCtxConvertToRingX
     38BS3_EXTERN_CMN Bs3RegCtxRestore
     39BS3_EXTERN_CMN Bs3Panic
     40TMPL_BEGIN_TEXT
     41
    3442
    3543;;
    … …  
    4250; stuff.  Generally, though, we preserve all registers not used as return
    4351; values or otherwise implicitly transformed by the call.
     52;
     53; Note! The 16-bit versions of this code must be careful with using extended
     54;       registers as we wish this code to work on real 8086 CPUs too!
    4455;
    4556BS3_PROC_BEGIN_MODE Bs3TrapSystemCallHandler
    … …  
    99110        dw      .print_chr       wrt BS3TEXT16
    100111        dw      .print_str       wrt BS3TEXT16
    101         dw      .to_ring0        wrt BS3TEXT16
    102         dw      .to_ring1        wrt BS3TEXT16
    103         dw      .to_ring2        wrt BS3TEXT16
    104         dw      .to_ring3        wrt BS3TEXT16
     112        dw      .to_ringX        wrt BS3TEXT16
     113        dw      .to_ringX        wrt BS3TEXT16
     114        dw      .to_ringX        wrt BS3TEXT16
     115        dw      .to_ringX        wrt BS3TEXT16
    105116%else
    106117        dd      .invalid_syscall wrt FLAT
    107118        dd      .print_chr       wrt FLAT
    108119        dd      .print_str       wrt FLAT
    109         dd      .to_ring0        wrt FLAT
    110         dd      .to_ring1        wrt FLAT
    111         dd      .to_ring2        wrt FLAT
    112         dd      .to_ring3        wrt FLAT
     120        dd      .to_ringX        wrt FLAT
     121        dd      .to_ringX        wrt FLAT
     122        dd      .to_ringX        wrt FLAT
     123        dd      .to_ringX        wrt FLAT
    113124%endif
    114125
    … …  
    120131        jmp     .return
    121132
     133
    122134        ;
    123135        ; Print char in the CL register.
    … …  
    132144%endif
    133145.print_chr:
     146        push    xDI
     147        push    xSI
    134148%ifndef TMPL_CMN_R86
    135149        ; Switch to real mode (20h param scratch area not required).
    … …  
    151165        BS3_SET_BITS TMPL_BITS
    152166%endif
     167        pop     xSI
     168        pop     xDI
    153169        jmp     .return
    154170%ifndef TMPL_16BIT
    155171TMPL_BEGIN_TEXT
    156172%endif
     173
    157174
    158175        ;
    … …  
    179196
    180197        ;
    181         ; Switch the caller to ring-0.
    182         ;
    183 .to_ring0:
    184         sub     xSP, BS3REGS_size
    185         mov     xBX, xSP                ; xBP = BS3REGS pointer.
     198        ; Switch the caller to ring-0, ring-1, ring-2 or ring-3.
     199        ;
     200        ; This implement this by saving the entire register context, calling
     201        ; a transformation function (C) and restoring the modified register
     202        ; context using a generic worker.
     203        ;
     204.to_ringX:
     205        sub     xSP, BS3REGCTX_size
     206        mov     xBX, xSP                ; xBP = BS3REGCTX pointer.
    186207        call    .save_context
    187208
    188 
    189         jmp     .return
    190 
    191 ;; @todo the remainder could be implemented in client code using SwitchToRing0
    192 .to_ring1:
    193         int3
    194         jmp     .return
    195 
    196 .to_ring2:
    197         int3
    198         jmp     .return
    199 
    200 .to_ring3:
    201         int3
    202         jmp     .return
     209%if TMPL_BITS == 32
     210        ; Convert xBP to flat pointer in 32-bit
     211        push    ss
     212        push    xBX
     213        call    Bs3SelProtFar32ToFlat32
     214        add     sSP, 8
     215        mov     xBX, xAX
     216%endif
     217        ; Prepare the last call frame.
     218        BS3_ONLY_16BIT_STMT push    ss
     219        push    xBX
     220
     221        ; Convert the register context from whatever it is to ring-0.
     222        BS3_ONLY_16BIT_STMT push    ss
     223        push    xBX
     224        mov     ax, VAR_CALLER_AX
     225        sub     ax, BS3_SYSCALL_TO_RING0
     226        push    xAX
     227        BS3_CALL Bs3RegCtxConvertToRingX, 2
     228        add     xSP, sCB
     229
     230        ; Restore the register context (does not return).
     231        pop     xBX                     ; restore saved pointer.
     232        BS3_ONLY_16BIT_STMT push    ss
     233        push    xBX
     234        BS3_CALL Bs3RegCtxRestore, 1
     235        jmp     Bs3Panic
    203236
    204237
    … …  
    236269
    237270        ;
    238         ; Internal function. ss:xBX = Pointer to register frame (BS3REGS).
     271        ; Internal function. ss:xBX = Pointer to register frame (BS3REGCTX).
    239272        ; @uses xAX
    240273        ;
    … …  
    257290        mov     word [ss:bx + di + 6], 0
    258291        add     di, 8
    259         cmp     di, BS3REGS_size
     292        cmp     di, BS3REGCTX_size
    260293        jb      .save_context_16_clear_loop
    261294        pop     di
    … …  
    263296        ; Do the 8086/80186/80286 state saving.
    264297        mov     ax, VAR_CALLER_AX
    265         mov     [ss:bx + BS3REGS.rax], ax
     298        mov     [ss:bx + BS3REGCTX.rax], ax
    266299        mov     cx, VAR_CALLER_CX
    267         mov     [ss:bx + BS3REGS.rcx], ax
     300        mov     [ss:bx + BS3REGCTX.rcx], ax
    268301        mov     ax, VAR_CALLER_DX
    269         mov     [ss:bx + BS3REGS.rdx], ax
     302        mov     [ss:bx + BS3REGCTX.rdx], ax
    270303        mov     ax, VAR_CALLER_BX
    271         mov     [ss:bx + BS3REGS.rbx], ax
    272         mov     [ss:bx + BS3REGS.rsi], si
    273         mov     [ss:bx + BS3REGS.rdi], di
     304        mov     [ss:bx + BS3REGCTX.rbx], ax
     305        mov     [ss:bx + BS3REGCTX.rsi], si
     306        mov     [ss:bx + BS3REGCTX.rdi], di
    274307        mov     ax, VAR_CALLER_BP
    275         mov     [ss:bx + BS3REGS.rbp], ax
    276         mov     [ss:bx + BS3REGS.es], es
     308        mov     [ss:bx + BS3REGCTX.rbp], ax
     309        mov     [ss:bx + BS3REGCTX.es], es
    277310        mov     ax, [xBP + xCB]
    278         mov     [ss:bx + BS3REGS.rip], ax
     311        mov     [ss:bx + BS3REGCTX.rip], ax
    279312        mov     ax, [xBP + xCB*2]
    280         mov     [ss:bx + BS3REGS.cs], ax
     313        mov     [ss:bx + BS3REGCTX.cs], ax
    281314        and     al, X86_SEL_RPL
    282         mov     [ss:bx + BS3REGS.bCpl], al
     315        mov     [ss:bx + BS3REGCTX.bCpl], al
    283316        cmp     al, 0
    284317        je      .save_context_16_same
    285318        mov     ax, [xBP + xCB*4]
    286         mov     [ss:bx + BS3REGS.rsp], ax
     319        mov     [ss:bx + BS3REGCTX.rsp], ax
    287320        mov     ax, [xBP + xCB*5]
    288         mov     [ss:bx + BS3REGS.ss], ax
     321        mov     [ss:bx + BS3REGCTX.ss], ax
    289322        jmp     .save_context_16_done_stack
    290323.save_context_16_same:
    291324        mov     ax, bp
    292325        add     ax, xCB * (1 + 3)
    293         mov     [ss:bx + BS3REGS.rsp], ax
     326        mov     [ss:bx + BS3REGCTX.rsp], ax
    294327        mov     ax, ss
    295         mov     [ss:bx + BS3REGS.ss], ax
     328        mov     [ss:bx + BS3REGCTX.ss], ax
    296329.save_context_16_done_stack:
    297330        mov     ax, [xBP + xCB*3]
    298         mov     [ss:bx + BS3REGS.rflags], ax
     331        mov     [ss:bx + BS3REGCTX.rflags], ax
    299332        mov     al, VAR_CALLER_MODE
    300         mov     [ss:bx + BS3REGS.bMode], al
     333        mov     [ss:bx + BS3REGCTX.bMode], al
    301334        cmp     byte [g_uBs3CpuDetected], BS3CPU_80286
    302335        jne     .save_context_16_return
    303         smsw    [ss:bx + BS3REGS.cr0]
    304         str     [ss:bx + BS3REGS.tr]
    305         sldt    [ss:bx + BS3REGS.ldtr]
     336        smsw    [ss:bx + BS3REGCTX.cr0]
     337        str     [ss:bx + BS3REGCTX.tr]
     338        sldt    [ss:bx + BS3REGCTX.ldtr]
    306339.save_context_16_return:
    307340        ret
    … …  
    321354        mov     dword [ss:xBX + xDI + 4], 0
    322355        add     xDI, 8
    323         cmp     xDI, BS3REGS_size
     356        cmp     xDI, BS3REGCTX_size
    324357        jb      .save_context_32_clear_loop
    325358        pop     xDI
    … …  
    328361        ; Do the 386+ state saving.
    329362%if TMPL_BITS == 16                     ; save the high word of registered pushed on the stack.
    330         mov     [ss:bx + BS3REGS.rax], eax
    331         mov     [ss:bx + BS3REGS.rcx], ecx
    332         mov     [ss:bx + BS3REGS.rdx], edx
    333         mov     [ss:bx + BS3REGS.rbx], ebx
    334         mov     [ss:bx + BS3REGS.rbp], ebp
    335         mov     [ss:bx + BS3REGS.rsp], esp
     363        mov     [ss:bx + BS3REGCTX.rax], eax
     364        mov     [ss:bx + BS3REGCTX.rcx], ecx
     365        mov     [ss:bx + BS3REGCTX.rdx], edx
     366        mov     [ss:bx + BS3REGCTX.rbx], ebx
     367        mov     [ss:bx + BS3REGCTX.rbp], ebp
     368        mov     [ss:bx + BS3REGCTX.rsp], esp
     369        pushfd
     370        pop     dword [ss:bx + BS3REGCTX.rflags]
    336371%endif
    337372        mov     xAX, VAR_CALLER_AX
    338         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rax], xAX
     373        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rax], xAX
    339374        mov     xCX, VAR_CALLER_CX
    340         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rcx], xCX
     375        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rcx], xCX
    341376        mov     xAX, VAR_CALLER_DX
    342         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rdx], xAX
     377        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rdx], xAX
    343378        mov     xAX, VAR_CALLER_BX
    344         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rbx], xAX
    345         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rsi], sSI
    346         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rdi], sDI
     379        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rbx], xAX
     380        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rsi], sSI
     381        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rdi], sDI
    347382        mov     xAX, VAR_CALLER_BP
    348         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rbp], xAX
    349         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.es], es
     383        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rbp], xAX
     384        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.es], es
     385        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.fs], fs
     386        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.gs], gs
    350387        mov     xAX, [xBP + xCB]
    351         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rip], xAX
     388        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rip], xAX
    352389        mov     ax, [xBP + xCB*2]
    353         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cs], ax
     390        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.cs], ax
    354391%if TMPL_MODE != BS3_MODE_RM
    355392        and     al, X86_SEL_RPL
    356         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.bCpl], al
     393        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.bCpl], al
    357394        cmp     al, 0
    358395        je      .save_context_full_same
    359396        mov     xAX, [xBP + xCB*4]
    360         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rsp], xAX
     397        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rsp], xAX
    361398        mov     ax, [xBP + xCB*5]
    362         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.ss], ax
     399        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.ss], ax
    363400        jmp     .save_context_full_done_stack
    364401%else
    365         mov     byte [BS3_NOT_64BIT(ss:) xBX + BS3REGS.bCpl], 0
     402        mov     byte [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.bCpl], 0
    366403%endif
    367404.save_context_full_same:
    368405        mov     xAX, xBP
    369406        add     xAX, xCB * (1 + 3)
    370         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rsp], xAX
     407        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rsp], xAX
    371408        mov     ax, ss
    372         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.ss], ax
     409        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.ss], ax
    373410.save_context_full_done_stack:
    374411        mov     xAX, [xBP + xCB*3]
    375         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.rflags], xAX
     412        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rflags], sAX
     413
    376414        mov     al, VAR_CALLER_MODE
    377         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.bMode], al
     415        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.bMode], al
    378416%if TMPL_BITS == 64
    379         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r8], r8
    380         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r9], r9
    381         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r10], r10
    382         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r11], r11
    383         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r12], r12
    384         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r13], r13
    385         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r14], r14
    386         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.r15], r15
    387 %endif
    388         ; Save state according to detected CPU.
    389         str     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.tr]
    390         sldt    [BS3_NOT_64BIT(ss:) xBX + BS3REGS.ldtr]
    391         cmp     byte [g_uBs3CpuDetected], BS3CPU_80286
    392         ja      .save_context_full_return
    393         smsw    [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cr0]
    394         jmp     .save_context_full_return
    395 
    396 .save_context_full_386_plus:
     417        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r8], r8
     418        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r9], r9
     419        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r10], r10
     420        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r11], r11
     421        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r12], r12
     422        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r13], r13
     423        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r14], r14
     424        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.r15], r15
     425%endif
     426        str     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.tr]
     427        sldt    [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.ldtr]
    397428        mov     sAX, cr0
    398         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cr0], sAX
     429        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.cr0], sAX
    399430        mov     sAX, cr2
    400         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cr2], sAX
     431        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.cr2], sAX
    401432        mov     sAX, cr3
    402         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cr3], sAX
     433        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.cr3], sAX
    403434        mov     sAX, cr4
    404         mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGS.cr4], sAX
    405 
     435        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.cr4], sAX
     436
     437%if TMPL_BITS != 64
     438        ; Deal with extended v8086 frame.
     439 %if TMPL_BITS == 32
     440        test    dword [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rflags], X86_EFL_VM
     441        jz      .save_context_full_return
     442 %else
     443        mov     al, VAR_CALLER_MODE
     444        and     al, BS3_MODE_CODE_MASK
     445        cmp     al, BS3_MODE_CODE_V86
     446        jne     .save_context_full_return
     447        mov     dword [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rflags], X86_EFL_VM
     448 %endif
     449        mov     xAX, [xBP + xCB*4]
     450        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.rsp], xAX
     451        mov     ax, [xBP + xCB*5]
     452        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.ss], ax
     453        mov     ax, [xBP + xCB*6]
     454        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.es], ax
     455        mov     ax, [xBP + xCB*7]
     456        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.ds], ax
     457        mov     ax, [xBP + xCB*8]
     458        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.fs], ax
     459        mov     ax, [xBP + xCB*9]
     460        mov     [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.gs], ax
     461        mov     byte [BS3_NOT_64BIT(ss:) xBX + BS3REGCTX.bCpl], 3
     462%endif
    406463.save_context_full_return:
    407464        ret

  • trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-wc32-U8RS.asm

    r58809 r59975  
    5959        jmp     .return
    6060
     61

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

    r59952 r59975  
    138138/** Where we save the boot registers during init.
    139139 * Located right before the code. */
    140 #define BS3_ADDR_REG_SAVE       (BS3_ADDR_LOAD - sizeof(BS3REGS) - 8)
     140#define BS3_ADDR_REG_SAVE       (BS3_ADDR_LOAD - sizeof(BS3REGCTX) - 8)
    141141/** Where the stack starts (initial RSP value).
    142142 * Located 16 bytes (assumed by boot sector) before the saved registers.
    … …  
    210210
    211211#define BS3_SEL_RING_SHIFT          8      /**< For the formula: BS3_SEL_R0_XXX + ((cs & 3) << BS3_SEL_RING_SHIFT) */
     212#define BS3_SEL_RING_SUB_MASK       0x00f8 /**< Mask for getting the sub-selector. For use with BS3_SEL_R*_FIRST. */
    212213
    213214#define BS3_SEL_R0_FIRST            0x0100 /**< The first selector in the ring-0 block. */
    … …  
    376377/** @def BS3_FP_SEG
    377378 * Get the selector (segment) part of a far pointer.
     379 *
    378380 * @returns selector.
    379381 * @param   a_pv        Far pointer.
    … …  
    382384/** @def BS3_FP_OFF
    383385 * Get the segment offset part of a far pointer.
     386 *
    384387 * @returns offset.
    385388 * @param   a_pv        Far pointer.
    … …  
    388391/** @def BS3_FP_MAKE
    389392 * Create a far pointer.
    390  * @returns selector.
    391  * @param   a_pv        Far pointer.
     393 *
     394 * @returns Far pointer.
     395 * @param   a_uSeg      The selector/segment.
     396 * @param   a_off       The offset into the segment.
    392397 */
    393398# define BS3_FP_MAKE(a_uSeg, a_off)  (((__segment)(a_uSeg)) :> ((void __near *)(a_off)))
     399
    394400#endif
     401
     402/** @def BS3_MAKE_PROT_PTR_FROM_FLAT
     403 * Creates a protected mode pointer from a flat address.
     404 *
     405 * For sake of convenience, this macro also works in 32-bit and 64-bit mode,
     406 * only there it doesn't return a far pointer but a flat point.
     407 *
     408 * @returns far void pointer if 16-bit code, near/flat void pointer in 32-bit
     409 *          and 64-bit.
     410 * @param   a_uFlat     Flat address in the first 16MB. */
     411#if ARCH_BITS == 16
     412# define BS3_MAKE_PROT_R0PTR_FROM_FLAT(a_uFlat)  \
     413    BS3_FP_MAKE(((uint16_t)(a_uFlat >> 16) << 3) + BS3_SEL_TILED, (uint16_t)(a_uFlat))
     414#else
     415# define BS3_MAKE_PROT_R0PTR_FROM_FLAT(a_uFlat)  ((void *)(uintptr_t)(a_uFlat))
     416#endif
     417
     418/** @def BS3_MAKE_PROT_R0PTR_FROM_REAL
     419 * Creates a protected mode pointer from a far real mode address.
     420 *
     421 * For sake of convenience, this macro also works in 32-bit and 64-bit mode,
     422 * only there it doesn't return a far pointer but a flat point.
     423 *
     424 * @returns far void pointer if 16-bit code, near/flat void pointer in 32-bit
     425 *          and 64-bit.
     426 * @param   a_uSeg      The selector/segment.
     427 * @param   a_off       The offset into the segment.
     428 */
     429#if ARCH_BITS == 16
     430# define BS3_MAKE_PROT_R0PTR_FROM_REAL(a_uSeg, a_off) BS3_FP_MAKE(((a_uSeg) << 3) + BS3_SEL_TILED, a_off)
     431#else
     432# define BS3_MAKE_PROT_R0PTR_FROM_REAL(a_uSeg, a_off) ( (void *)(uintptr_t)(((uint32_t)(a_uSeg) << 16) | (uint16_t)(a_off)) )
     433#endif
     434
    395435
    396436/** @def BS3_CALL
    … …  
    19221962typedef struct BS3REGCTX
    19231963{
    1924     BS3REG      rax;
    1925     BS3REG      rcx;
    1926     BS3REG      rdx;
    1927     BS3REG      rbx;
    1928     BS3REG      rsp;
    1929     BS3REG      rbp;
    1930     BS3REG      rsi;
    1931     BS3REG      rdi;
    1932     BS3REG      r8;
    1933     BS3REG      r9;
    1934     BS3REG      r10;
    1935     BS3REG      r11;
    1936     BS3REG      r12;
    1937     BS3REG      r13;
    1938     BS3REG      r14;
    1939     BS3REG      r15;
    1940     BS3REG      rflags;
    1941     BS3REG      rip;
    1942     uint16_t    cs;
    1943     uint16_t    ds;
    1944     uint16_t    es;
    1945     uint16_t    fs;
    1946     uint16_t    gs;
    1947     uint16_t    ss;
    1948     uint16_t    tr;
    1949     uint16_t    ldtr;
    1950     uint8_t     bMode;                  /**< BS3_MODE_XXX. */
    1951     uint8_t     bCpl;                   /**< 0-3, 0 is used for real mode. */
    1952     uint8_t     abPadding[6];
    1953     BS3REG      cr0;
    1954     BS3REG      cr2;
    1955     BS3REG      cr3;
    1956     BS3REG      cr4;
     1964    BS3REG      rax;                    /**< 0x00  */
     1965    BS3REG      rcx;                    /**< 0x08  */
     1966    BS3REG      rdx;                    /**< 0x10  */
     1967    BS3REG      rbx;                    /**< 0x18  */
     1968    BS3REG      rsp;                    /**< 0x20  */
     1969    BS3REG      rbp;                    /**< 0x28  */
     1970    BS3REG      rsi;                    /**< 0x30  */
     1971    BS3REG      rdi;                    /**< 0x38  */
     1972    BS3REG      r8;                     /**< 0x40  */
     1973    BS3REG      r9;                     /**< 0x48  */
     1974    BS3REG      r10;                    /**< 0x50  */
     1975    BS3REG      r11;                    /**< 0x58  */
     1976    BS3REG      r12;                    /**< 0x60  */
     1977    BS3REG      r13;                    /**< 0x68  */
     1978    BS3REG      r14;                    /**< 0x70  */
     1979    BS3REG      r15;                    /**< 0x78  */
     1980    BS3REG      rflags;                 /**< 0x80  */
     1981    BS3REG      rip;                    /**< 0x88  */
     1982    uint16_t    cs;                     /**< 0x90  */
     1983    uint16_t    ds;                     /**< 0x92  */
     1984    uint16_t    es;                     /**< 0x94  */
     1985    uint16_t    fs;                     /**< 0x96  */
     1986    uint16_t    gs;                     /**< 0x98  */
     1987    uint16_t    ss;                     /**< 0x9a  */
     1988    uint16_t    tr;                     /**< 0x9c  */
     1989    uint16_t    ldtr;                   /**< 0x9e  */
     1990    uint8_t     bMode;                  /**< 0xa0:  BS3_MODE_XXX. */
     1991    uint8_t     bCpl;                   /**< 0xa1: 0-3, 0 is used for real mode. */
     1992    uint8_t     abPadding[6];           /**< 0xa2  */
     1993    BS3REG      cr0;                    /**< 0xa8  */
     1994    BS3REG      cr2;                    /**< 0xb0  */
     1995    BS3REG      cr3;                    /**< 0xb8  */
     1996    BS3REG      cr4;                    /**< 0xc0  */
    19571997} BS3REGCTX;
    19581998/** Pointer to a register context. */
    … …  
    19602000/** Pointer to a const register context. */
    19612001typedef BS3REGCTX const BS3_FAR *PCBS3REGCTX;
     2002
     2003
     2004/**
     2005 * Transforms a register context to a different ring.
     2006 *
     2007 * @param   pRegCtx     The register context.
     2008 * @param   bRing       The target ring (0..3).
     2009 */
     2010BS3_DECL(void) Bs3RegCtxConvertToRingX_c16(PBS3REGCTX pRegCtx, uint8_t bRing);
     2011BS3_DECL(void) Bs3RegCtxConvertToRingX_c32(PBS3REGCTX pRegCtx, uint8_t bRing); /**< @copydoc Bs3RegCtxConvertToRingX_c16 */
     2012BS3_DECL(void) Bs3RegCtxConvertToRingX_c64(PBS3REGCTX pRegCtx, uint8_t bRing); /**< @copydoc Bs3RegCtxConvertToRingX_c16 */
     2013#define Bs3RegCtxConvertToRingX BS3_CMN_NM(Bs3RegCtxConvertToRingX) /**< Selects #Bs3RegCtxConvertToRingX_c16, #Bs3RegCtxConvertToRingX_c32 or #Bs3RegCtxConvertToRingX_c64. */
     2014
     2015/**
     2016 * Restores a register context.
     2017 *
     2018 * @param   pRegCtx     The register context to be restored and resumed.
     2019 * @param   fFlags      BS3REGCTXRESTORE_F_XXX.
     2020 *
     2021 * @remarks Caller must be in ring-0!
     2022 * @remarks Does not return.
     2023 */
     2024BS3_DECL(void) Bs3RegCtxRestore_c16(PCBS3REGCTX pRegCtx, uint16_t fFlags);
     2025BS3_DECL(void) Bs3RegCtxRestore_c32(PCBS3REGCTX pRegCtx, uint16_t fFlags); /**< @copydoc Bs3RegCtxRestore_c16 */
     2026BS3_DECL(void) Bs3RegCtxRestore_c64(PCBS3REGCTX pRegCtx, uint16_t fFlags); /**< @copydoc Bs3RegCtxRestore_c16 */
     2027#define Bs3RegCtxRestore BS3_CMN_NM(Bs3RegCtxRestore) /**< Selects #Bs3RegCtxRestore_c16, #Bs3RegCtxRestore_c32 or #Bs3RegCtxRestore_c64. */
     2028
     2029/** Skip restoring the CRx registers. */
     2030#define BS3REGCTXRESTORE_F_SKIP_CRX     UINT16_C(0x0001)
    19622031
    19632032
    … …  
    19752044    /** The handler SS. */
    19762045    uint16_t    uHandlerSs;
     2046    /** Explicit alignment. */
     2047    uint16_t    usAlignment;
    19772048    /** The handler RSP (top of iret frame). */
    19782049    uint64_t    uHandlerRsp;
    … …  
    19892060typedef BS3TRAPFRAME const BS3_FAR *PCBS3TRAPFRAME;
    19902061
    1991 /**
    1992  * Resumes execution of a 32-bit trap frame.
    1993  *
    1994  * @param   pTrapFrame      Trap frame to resume.
    1995  * @param   fFlags          Flags, BS3TRAPRESUME_F_XXX.
    1996  */
    1997 BS3_DECL(void) Bs3Trap32ResumeFrame_c32(BS3TRAPFRAME BS3_FAR *pTrapFrame, uint16_t fFlags);
    1998 #define Bs3Trap32ResumeFrame BS3_CMN_NM(Bs3Trap32ResumeFrame) /**< Selects Bs3Trap32ResumeFrame_c16 (not implemented), #Bs3Trap32ResumeFrame_c32 or Bs3Trap32ResumeFrame_c64 (not implemented). */
    1999 
    2000 /** Skip restoring the CRx registers. */
    2001 #define BS3TRAPRESUME_F_SKIP_CRX    UINT16_C(0x0001)
     2062
    20022063
    20032064/**

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

    r59952 r59975  
    10851085;; Where we save the boot registers during init.
    10861086; Located right before the code.
    1087 %define BS3_ADDR_REG_SAVE       (BS3_ADDR_LOAD - BS3REGS_size - 8)
     1087%define BS3_ADDR_REG_SAVE       (BS3_ADDR_LOAD - BS3REGCTX_size - 8)
    10881088;; Where the stack starts (initial RSP value).
    10891089; Located 16 bytes (assumed by boot sector) before the saved registers. SS.BASE=0.
    … …  
    11231123
    11241124;;
    1125 ; Registers.  Used by traps and such.
    1126 ;
    1127 struc BS3REGS
    1128         .rax        resq 1
    1129         .rcx        resq 1
    1130         .rdx        resq 1
    1131         .rbx        resq 1
    1132         .rsp        resq 1
    1133         .rbp        resq 1
    1134         .rsi        resq 1
    1135         .rdi        resq 1
    1136         .r8         resq 1
    1137         .r9         resq 1
    1138         .r10        resq 1
    1139         .r11        resq 1
    1140         .r12        resq 1
    1141         .r13        resq 1
    1142         .r14        resq 1
    1143         .r15        resq 1
    1144         .rflags     resq 1
    1145         .rip        resq 1
    1146         .cs         resw 1
    1147         .ds         resw 1
    1148         .es         resw 1
    1149         .fs         resw 1
    1150         .gs         resw 1
    1151         .ss         resw 1
    1152         .tr         resw 1
    1153         .ldtr       resw 1
    1154         .bMode      resb 1
    1155         .bCpl       resb 1
    1156         .abPadding  resb 6
    1157         .cr0        resq 1
    1158         .cr2        resq 1
    1159         .cr3        resq 1
    1160         .cr4        resq 1
    1161 
    1162         ;; @todo Add floating point registers when they are active.
     1125; BS3 register context.  Used by traps and such.
     1126;
     1127struc BS3REGCTX
     1128        .rax        resq 1              ; BS3REG      rax;                    /**< 0x00  */
     1129        .rcx        resq 1              ; BS3REG      rcx;                    /**< 0x08  */
     1130        .rdx        resq 1              ; BS3REG      rdx;                    /**< 0x10  */
     1131        .rbx        resq 1              ; BS3REG      rbx;                    /**< 0x18  */
     1132        .rsp        resq 1              ; BS3REG      rsp;                    /**< 0x20  */
     1133        .rbp        resq 1              ; BS3REG      rbp;                    /**< 0x28  */
     1134        .rsi        resq 1              ; BS3REG      rsi;                    /**< 0x30  */
     1135        .rdi        resq 1              ; BS3REG      rdi;                    /**< 0x38  */
     1136        .r8         resq 1              ; BS3REG      r8;                     /**< 0x40  */
     1137        .r9         resq 1              ; BS3REG      r9;                     /**< 0x48  */
     1138        .r10        resq 1              ; BS3REG      r10;                    /**< 0x50  */
     1139        .r11        resq 1              ; BS3REG      r11;                    /**< 0x58  */
     1140        .r12        resq 1              ; BS3REG      r12;                    /**< 0x60  */
     1141        .r13        resq 1              ; BS3REG      r13;                    /**< 0x68  */
     1142        .r14        resq 1              ; BS3REG      r14;                    /**< 0x70  */
     1143        .r15        resq 1              ; BS3REG      r15;                    /**< 0x78  */
     1144        .rflags     resq 1              ; BS3REG      rflags;                 /**< 0x80  */
     1145        .rip        resq 1              ; BS3REG      rip;                    /**< 0x88  */
     1146        .cs         resw 1              ; uint16_t    cs;                     /**< 0x90  */
     1147        .ds         resw 1              ; uint16_t    ds;                     /**< 0x92  */
     1148        .es         resw 1              ; uint16_t    es;                     /**< 0x94  */
     1149        .fs         resw 1              ; uint16_t    fs;                     /**< 0x96  */
     1150        .gs         resw 1              ; uint16_t    gs;                     /**< 0x98  */
     1151        .ss         resw 1              ; uint16_t    ss;                     /**< 0x9a  */
     1152        .tr         resw 1              ; uint16_t    tr;                     /**< 0x9c  */
     1153        .ldtr       resw 1              ; uint16_t    ldtr;                   /**< 0x9e  */
     1154        .bMode      resb 1              ; uint8_t     bMode;                  /**< 0xa0:  BS3_MODE_XXX. */
     1155        .bCpl       resb 1              ; uint8_t     bCpl;                   /**< 0xa1: 0-3, 0 is used for real mode. */
     1156        .abPadding  resb 6              ; uint8_t     abPadding[6];           /**< 0xa2  */
     1157        .cr0        resq 1              ; BS3REG      cr0;                    /**< 0xa8  */
     1158        .cr2        resq 1              ; BS3REG      cr2;                    /**< 0xb0  */
     1159        .cr3        resq 1              ; BS3REG      cr3;                    /**< 0xb8  */
     1160        .cr4        resq 1              ; BS3REG      cr4;                    /**< 0xc0  */
    11631161endstruc
    11641162
     1163;;
     1164; BS3 Trap Frame.
     1165;
     1166struc BS3TRAPFRAME
     1167        .bXcpt          resb 1
     1168        .bAlignment     resb 1
     1169        .uHandlerCs     resw 1
     1170        .uHandlerSs     resw 1
     1171        .usAlignment    resw 1
     1172        .uHandlerRsp    resq 1
     1173        .fHandlerRfl    resq 1
     1174        .uErrCd         resq 1
     1175        .Ctx            resb BS3REGCTX_size
     1176endstruc
     1177
     1178;; Flag for Bs3TrapXxResumeFrame methods.
     1179%define BS3TRAPRESUME_F_SKIP_CRX 1
    11651180
    11661181
    … …  
    13801395%endif
    13811396
    1382 ;
    1383 ; BS3 register context (without FPU).
    1384 ;
    1385 struc BS3REGCTX
    1386         .rax            resq 1
    1387         .rcx            resq 1
    1388         .rdx            resq 1
    1389         .rbx            resq 1
    1390         .rsp            resq 1
    1391         .rbp            resq 1
    1392         .rsi            resq 1
    1393         .rdi            resq 1
    1394         .r8             resq 1
    1395         .r9             resq 1
    1396         .r10            resq 1
    1397         .r11            resq 1
    1398         .r12            resq 1
    1399         .r13            resq 1
    1400         .r14            resq 1
    1401         .r15            resq 1
    1402         .rflags         resq 1
    1403         .rip            resq 1
    1404         .cs             resw 1
    1405         .ds             resw 1
    1406         .es             resw 1
    1407         .fs             resw 1
    1408         .gs             resw 1
    1409         .ss             resw 1
    1410         .tr             resw 1
    1411         .ldtr           resw 1
    1412         .cBits          resb 1
    1413         .abPadding      resb 7
    1414         .cr0            resq 1
    1415         .cr2            resq 1
    1416         .cr3            resq 1
    1417         .cr4            resq 1
    1418 endstruc
    1419 
    1420 ;;
    1421 ; BS3 Trap Frame.
    1422 ;
    1423 struc BS3TRAPFRAME
    1424         .bXcpt          resb 1
    1425         .bAlignment     resb 1
    1426         .uHandlerCs     resw 1
    1427         .uHandlerSs     resw 1
    1428         .uHandlerRsp    resq 1
    1429         .fHandlerRfl    resq 1
    1430         .uErrCd         resq 1
    1431         .Ctx            resb BS3REGCTX_size
    1432 endstruc
    1433 
    1434 ;; Flag for Bs3TrapXxResumeFrame methods.
    1435 %define BS3TRAPRESUME_F_SKIP_CRX 1
    1436 
    14371397
    14381398;; @name BS3CPU_XXX - Bs3CpuDetect_mmm return value and g_bBs3CpuDetected.
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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