WebSVN – Kolibri OS – Diff – /kernel/trunk/core/v86.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2007-2021. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 8866 $
 
; Virtual-8086 mode manager
; diamond, 2007, 2008
 
DEBUG_SHOW_IO = 0
 
struct  V86_machine
; page directory
        process         dd ?
; mutex to protect all data from writing by multiple threads at one time
        mutex           dd ?
; i/o permission map
        iopm            dd ?
ends
 
; Create V86 machine
; in: nothing
; out: eax = handle (pointer to struc V86_machine)
;      eax = NULL => failure
; destroys: ebx, ecx, edx (due to malloc)
v86_create:
; allocate V86_machine structure
        mov     eax, sizeof.V86_machine
        call    malloc
        test    eax, eax
        jz      .fail
; initialize mutex
        and     dword [eax+V86_machine.mutex], 0
; allocate tables
        mov     ebx, eax
 
        stdcall create_process, 4096
        test    eax, eax
        jz      .fail2
 
        mov     [eax+PROC.mem_used], 4096
        mov     [ebx+V86_machine.process], eax
 
        push    2000h
        call    kernel_alloc
        test    eax, eax
        jz      .fail2
 
        mov     [ebx+V86_machine.iopm], eax
 
; initialize tables
        push    edi
        mov     edi, eax
        mov     eax, -1
        mov     ecx, 2000h/4
        rep stosd
 
        mov     eax, [ebx+V86_machine.process]
        mov     eax, [eax+PROC.pdt_0_phys]
 
        pushfd
        cli
        mov     cr3, eax
 
; now V86 specific: initialize known addresses in first Mb
 
; first page - BIOS data (shared between all machines!)
; physical address = 0
; linear address = OS_BASE
; page before 0xA0000 - Extended BIOS Data Area (shared between all machines!)
; physical address = 0x9C000
; linear address = 0x8009C000
; (I have seen one computer with EBDA segment = 0x9D80,
; all other computers use less memory)
 
        mov     eax, PG_UWR
        mov     [page_tabs], eax
        invlpg  [eax]
 
        mov     byte [0x500], 0xCD
        mov     byte [0x501], 0x13
        mov     byte [0x502], 0xF4
        mov     byte [0x503], 0xCD
        mov     byte [0x504], 0x10
        mov     byte [0x505], 0xF4
 
        mov     eax, 0x98000+PG_UWR
        mov     edi, page_tabs+0x98*4
        mov     edx, 0x1000
        mov     ecx, 8
@@:
        stosd
        add     eax, edx
        loop    @b
 
; addresses 0xC0000 - 0xFFFFF - BIOS code (shared between all machines!)
; physical address = 0xC0000
 
        mov     eax, 0xC0000+PG_UWR
        mov     edi, page_tabs+0xC0*4
        mov     ecx, 64
@@:
        stosd
        add     eax, edx
        loop    @b
 
        mov     eax, [sys_proc+PROC.pdt_0_phys]
        mov     cr3, eax
        popfd
 
        pop     edi
 
        mov     eax, ebx
        ret
.fail2:
        mov     eax, ebx
        call    free
.fail:
        xor     eax, eax
        ret
 
;not used
; Destroy V86 machine
; in: eax = handle
; out: nothing
; destroys: eax, ebx, ecx, edx (due to free)
;v86_destroy:
;        push    eax
;        stdcall kernel_free, [eax+V86_machine.pagedir]
;        pop     eax
;        jmp     free
 
; Translate V86-address to linear address
; in: eax=V86 address
;     esi=handle
; out: eax=linear address
; destroys: nothing
v86_get_lin_addr:
        push    ecx edx
        mov     ecx, eax
        shr     ecx, 12
        mov     edx, [page_tabs+ecx*4]
        and     eax, 0xFFF
        and     edx, 0xFFFFF000
        or      eax, edx
        pop     edx ecx
        ret
 
;not used
; Sets linear address for V86-page
; in: eax=linear address (must be page-aligned)
;     ecx=V86 page (NOT address!)
;     esi=handle
; out: nothing
; destroys: nothing
;v86_set_page:
;        push    eax ebx
;        mov     ebx, [esi+V86_machine.pagedir]
;        mov     [ebx+ecx*4+0x1800], eax
;        call    get_pg_addr
;        or      al, 111b
;        mov     [ebx+ecx*4+0x1000], eax
;        pop     ebx eax
;        ret
 
; Allocate memory in V86 machine
; in: eax=size (in bytes)
;     esi=handle
; out: eax=V86 address, para-aligned (0x10 multiple)
; destroys: nothing
; недописана!!!
;v86_alloc:
;        push    ebx ecx edx edi
;        lea     ebx, [esi+V86_machine.mutex]
;        call    wait_mutex
;        add     eax, 0x1F
;        shr     eax, 4
;        mov     ebx, 0x1000  ; start with address 0x1000 (second page)
;        mov     edi, [esi+V86_machine.tables]
;.l:
;        mov     ecx, ebx
;        shr     ecx, 12
;        mov     edx, [edi+0x1000+ecx*4] ; get linear address
;        test    edx, edx                ; page allocated?
;        jz      .unalloc
;        mov     ecx, ebx
;        and     ecx, 0xFFF
;        add     edx, ecx
;        cmp     dword [edx], 0          ; free block?
;        jnz     .n
;        cmp     dword [edx+4],
;        and     [esi+V86_machine.mutex], 0
;        pop     edi edx ecx ebx
;        ret
 
uglobal
sys_v86_machine dd      ?
endg
 
; Called from kernel.asm at first stages of loading
; Initialize system V86 machine (used to simulate BIOS int 13h)
init_sys_v86:
        call    v86_create
        mov     [sys_v86_machine], eax
        test    eax, eax
        jz      .ret
        mov     esi, eax
if ~DEBUG_SHOW_IO
; allow access to all ports
        mov     ecx, [esi+V86_machine.iopm]
        xor     eax, eax
        mov     edi, ecx
        mov     ecx, 10000h/8/4
        rep stosd
end if
.ret:
        ret
 
struct  v86_regs
; don't change the order, it is important
        edi             dd ?
        esi             dd ?
        ebp             dd ?
                        dd ?    ; ignored
        ebx             dd ?
        edx             dd ?
        ecx             dd ?
        eax             dd ?
        eip             dd ?
        cs              dd ?
        eflags          dd ?    ; VM flag must be set!
        esp             dd ?
        ss              dd ?
        es              dd ?
        ds              dd ?
        fs              dd ?
        gs              dd ?
ends
 
; Run V86 machine
; in: ebx -> registers for V86 (two structures: in and out)
;     esi = handle
;     ecx = expected end address (CS:IP)
;     edx = IRQ to hook or -1 if not required
; out: structure pointed to by ebx is filled with new values
;     eax = 1 - exception has occured, cl contains code
;     eax = 2 - access to disabled i/o port, ecx contains port address
;     eax = 3 - IRQ is already hooked by another VM
; destroys: nothing
v86_start:
 
        pushad
 
        cli
 
        mov     ecx, [current_slot]
 
        push    dword [ecx+APPDATA.io_map]
        push    dword [ecx+APPDATA.io_map+4]
        push    [ecx+APPDATA.process]
        push    [ecx+APPDATA.saved_esp0]
        mov     [ecx+APPDATA.saved_esp0], esp
        mov     [tss._esp0], esp
 
        mov     eax, [esi+V86_machine.iopm]
        call    get_pg_addr
        inc     eax
        mov     dword [ecx+APPDATA.io_map], eax
        mov     dword [page_tabs + (tss._io_map_0 shr 10)], eax
 
        mov     eax, [esi+V86_machine.iopm]
        add     eax, 0x1000
        call    get_pg_addr
        inc     eax
        mov     dword [ecx+APPDATA.io_map+4], eax
        mov     dword [page_tabs + (tss._io_map_1 shr 10)], eax
 
        mov     eax, [esi+V86_machine.process]
        mov     [ecx+APPDATA.process], eax
        mov     [current_process], eax
        mov     eax, [eax+PROC.pdt_0_phys]
        mov     cr3, eax
 
; We do not enable interrupts, because V86 IRQ redirector assumes that
; machine is running
; They will be enabled by IRET.
;        sti
 
        mov     eax, esi
        sub     esp, sizeof.v86_regs
        mov     esi, ebx
        mov     edi, esp
        mov     ecx, sizeof.v86_regs/4
        rep movsd
 
        cmp     edx, -1
        jz      .noirqhook
uglobal
v86_irqhooks    rd      IRQ_RESERVED * 2
endg
        cmp     [v86_irqhooks+edx*8], 0
        jz      @f
        cmp     [v86_irqhooks+edx*8], eax
        jz      @f
        mov     esi, v86_irqerr
        call    sys_msg_board_str
        inc     [v86_irqhooks+edx*8+4]
        mov     eax, 3
        jmp     v86_exc_c.exit
@@:
        mov     [v86_irqhooks+edx*8], eax
        inc     [v86_irqhooks+edx*8+4]
.noirqhook:
 
        popad
        iretd
 
; It is only possible to leave virtual-8086 mode by faulting to
; a protected-mode interrupt handler (typically the general-protection
; exception handler, which in turn calls the virtual 8086-mode monitor).
 
iglobal
  v86_exc_str1  db      'V86 : unexpected exception ',0
  v86_exc_str2  db      ' at ',0
  v86_exc_str3  db      ':',0
  v86_exc_str4  db      13,10,'V86 : faulted code:',0
  v86_exc_str5  db      ' (unavailable)',0
  v86_newline   db      13,10,0
  v86_io_str1   db      'V86 : access to disabled i/o port ',0
  v86_io_byte   db      ' (byte)',13,10,0
  v86_io_word   db      ' (word)',13,10,0
  v86_io_dword  db      ' (dword)',13,10,0
  v86_irqerr    db      'V86 : IRQ already hooked',13,10,0
endg
 
v86_exc_c:
; Did we all that we have wanted to do?
        cmp     bl, 1
        jne     @f
        xor     eax, eax
        mov     dr6, eax
  @@:
        mov     eax, [esp+sizeof.v86_regs+10h+18h]
        cmp     word [esp+v86_regs.eip], ax
        jnz     @f
        shr     eax, 16
        cmp     word [esp+v86_regs.cs], ax
        jz      .done
@@:
; Various system events, which must be handled, result in #GP
        cmp     bl, 13
        jnz     .nogp
; If faulted EIP exceeds 0xFFFF, we have #GP and it is an error
        cmp     word [esp+v86_regs.eip+2], 0
        jnz     .nogp
; Otherwise we can safely access byte at CS:IP
; (because it is #GP, not #PF handler)
; If we could get an exception just because of reading code bytes,
; we would have got it already and it wouldn't be #GP
        movzx   esi, word [esp+v86_regs.cs]
        shl     esi, 4
        add     esi, [esp+v86_regs.eip]
        lodsb
        cmp     al, 0xCD        ; int xx command = CD xx
        jz      .handle_int
        cmp     al, 0xCF
        jz      .handle_iret
        cmp     al, 0xF3
        jz      .handle_rep
        cmp     al, 0xEC
        jz      .handle_in
        cmp     al, 0xED
        jz      .handle_in_word
        cmp     al, 0xEE
        jz      .handle_out
        cmp     al, 0xEF
        jz      .handle_out_word
        cmp     al, 0xE4
        jz      .handle_in_imm
        cmp     al, 0xE6
        jz      .handle_out_imm
        cmp     al, 0x9C
        jz      .handle_pushf
        cmp     al, 0x9D
        jz      .handle_popf
        cmp     al, 0xFA
        jz      .handle_cli
        cmp     al, 0xFB
        jz      .handle_sti
        cmp     al, 0x66
        jz      .handle_66
        jmp     .nogp
.handle_int:
        cmp     word [esp+v86_regs.eip], 0xFFFF
        jae     .nogp
        xor     eax, eax
        lodsb
;        call    sys_msg_board_byte
; simulate INT command
; N.B. It is possible that some checks need to be corrected,
;      but at least in case of normal execution the code works.
.simulate_int:
        cmp     word [esp+v86_regs.esp], 6
        jae     @f
        mov     bl, 12          ; #SS exception
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        push    eax
        movzx   eax, word [esp+4+v86_regs.esp]
        sub     eax, 6
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+4+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        lea     eax, [edx+5]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        sub     word [esp+4+v86_regs.esp], 6
        mov     eax, [esp+4+v86_regs.eip]
        cmp     byte [esp+1], 0
        jnz     @f
        inc     eax
        inc     eax
@@:
        mov     word [edx], ax
        mov     eax, [esp+4+v86_regs.cs]
        mov     word [edx+2], ax
        mov     eax, [esp+4+v86_regs.eflags]
        mov     word [edx+4], ax
        pop     eax
        mov     ah, 0
        mov     cx, [eax*4]
        mov     word [esp+v86_regs.eip], cx
        mov     cx, [eax*4+2]
        mov     word [esp+v86_regs.cs], cx
; note that interrupts will be disabled globally at IRET
        and     byte [esp+v86_regs.eflags+1], not 3 ; clear IF and TF flags
; continue V86 execution
        popad
        iretd
.handle_iret:
        cmp     word [esp+v86_regs.esp], 0x10000 - 6
        jbe     @f
        mov     bl, 12
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        movzx   eax, word [esp+v86_regs.esp]
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        lea     eax, [edx+5]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        mov     ax, [edx]
        mov     word [esp+v86_regs.eip], ax
        mov     ax, [edx+2]
        mov     word [esp+v86_regs.cs], ax
        mov     ax, [edx+4]
        mov     word [esp+v86_regs.eflags], ax
        add     word [esp+v86_regs.esp], 6
        popad
        iretd
.handle_pushf:
        cmp     word [esp+v86_regs.esp], 1
        jnz     @f
        mov     bl, 12
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        mov     eax, [esp+v86_regs.esp]
        sub     eax, 2
        movzx   eax, ax
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        lea     eax, [edx+1]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        sub     word [esp+v86_regs.esp], 2
        mov     eax, [esp+v86_regs.eflags]
        mov     [edx], ax
        inc     word [esp+v86_regs.eip]
        popad
        iretd
.handle_pushfd:
        cmp     word [esp+v86_regs.esp], 4
        jae     @f
        mov     bl, 12          ; #SS exception
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        movzx   eax, word [esp+v86_regs.esp]
        sub     eax, 4
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        lea     eax, [edx+3]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        sub     word [esp+v86_regs.esp], 4
        movzx   eax, word [esp+v86_regs.eflags]
        mov     [edx], eax
        add     word [esp+v86_regs.eip], 2
        popad
        iretd
.handle_popf:
        cmp     word [esp+v86_regs.esp], 0xFFFF
        jnz     @f
        mov     bl, 12
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        movzx   eax, word [esp+v86_regs.esp]
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14          ; #PF exception
        jmp     .nogp
@@:
        lea     eax, [edx+1]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        mov     ax, [edx]
        mov     word [esp+v86_regs.eflags], ax
        add     word [esp+v86_regs.esp], 2
        inc     word [esp+v86_regs.eip]
        popad
        iretd
.handle_popfd:
        cmp     word [esp+v86_regs.esp], 0x10000 - 4
        jbe     @f
        mov     bl, 12
        jmp     .nogp
@@:
        movzx   edx, word [esp+v86_regs.ss]
        shl     edx, 4
        movzx   eax, word [esp+v86_regs.esp]
        add     edx, eax
        mov     eax, edx
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        lea     eax, [edx+3]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jae     @f
        mov     bl, 14
        jmp     .nogp
@@:
        mov     eax, [edx]
        mov     word [esp+v86_regs.eflags], ax
        add     word [esp+v86_regs.esp], 4
        add     word [esp+v86_regs.eip], 2
        popad
        iretd
.handle_cli:
        and     byte [esp+v86_regs.eflags+1], not 2
        inc     word [esp+v86_regs.eip]
        popad
        iretd
.handle_sti:
        or      byte [esp+v86_regs.eflags+1], 2
        inc     word [esp+v86_regs.eip]
        popad
        iretd
.handle_rep:
        cmp     word [esp+v86_regs.eip], 0xFFFF
        jae     .nogp
        lodsb
        cmp     al, 6Eh
        jz      .handle_rep_outsb
        jmp     .nogp
.handle_rep_outsb:
.handle_in:
.handle_out:
.invalid_io_byte:
        movzx   ebx, word [esp+v86_regs.edx]
        mov     ecx, 1
        jmp     .invalid_io
.handle_in_imm:
.handle_out_imm:
        cmp     word [esp+v86_regs.eip], 0xFFFF
        jae     .nogp
        lodsb
        movzx   ebx, al
        mov     ecx, 1
        jmp     .invalid_io
.handle_66:
        cmp     word [esp+v86_regs.eip], 0xFFFF
        jae     .nogp
        lodsb
        cmp     al, 0x9C
        jz      .handle_pushfd
        cmp     al, 0x9D
        jz      .handle_popfd
        cmp     al, 0xEF
        jz      .handle_out_dword
        cmp     al, 0xED
        jz      .handle_in_dword
        jmp     .nogp
.handle_in_word:
.handle_out_word:
        movzx   ebx, word [esp+v86_regs.edx]
        mov     ecx, 2
        jmp     .invalid_io
.handle_in_dword:
.handle_out_dword:
.invalid_io_dword:
        movzx   ebx, word [esp+v86_regs.edx]
        mov     ecx, 4
.invalid_io:
        mov     esi, v86_io_str1
        call    sys_msg_board_str
        mov     eax, ebx
        call    sys_msg_board_dword
        mov     esi, v86_io_byte
        cmp     ecx, 1
        jz      @f
        mov     esi, v86_io_word
        cmp     ecx, 2
        jz      @f
        mov     esi, v86_io_dword
@@:
        call    sys_msg_board_str
if DEBUG_SHOW_IO
        mov     edx, ebx
        mov     ebx, 200
        call    delay_hs
        mov     esi, [esp+v86_regs.size+10h+4]
        mov     eax, [esi+V86_machine.iopm]
@@:
        btr     [eax], edx
        inc     edx
        loop    @b
        popad
        iretd
else
        mov     eax, 2
        jmp     .exit
end if
.nogp:
 
        mov     esi, v86_exc_str1
        call    sys_msg_board_str
        mov     al, bl
        call    sys_msg_board_byte
        mov     esi, v86_exc_str2
        call    sys_msg_board_str
        mov     ax, [esp+32+4]
        call    sys_msg_board_word
        mov     esi, v86_exc_str3
        call    sys_msg_board_str
        mov     ax, [esp+32]
        call    sys_msg_board_word
        mov     esi, v86_exc_str4
        call    sys_msg_board_str
        mov     ecx, 8
        movzx   edx, word [esp+32+4]
        shl     edx, 4
        add     edx, [esp+32]
@@:
        mov     esi, [esp+sizeof.v86_regs+10h+4]
        mov     eax, edx
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jb      .nopage
        mov     esi, v86_exc_str3-2
        call    sys_msg_board_str
        mov     al, [edx]
        call    sys_msg_board_byte
        inc     edx
        loop    @b
        jmp     @f
.nopage:
        mov     esi, v86_exc_str5
        call    sys_msg_board_str
@@:
        mov     esi, v86_newline
        call    sys_msg_board_str
        mov     eax, 1
        jmp     .exit
 
.done:
        xor     eax, eax
 
.exit:
        mov     [esp+sizeof.v86_regs+10h+1Ch], eax
        mov     [esp+sizeof.v86_regs+10h+18h], ebx
 
        mov     edx, [esp+sizeof.v86_regs+10h+14h]
        cmp     edx, -1
        jz      @f
        dec     [v86_irqhooks+edx*8+4]
        jnz     @f
        and     [v86_irqhooks+edx*8], 0
@@:
 
        mov     esi, esp
        mov     edi, [esi+sizeof.v86_regs+10h+10h]
        add     edi, sizeof.v86_regs
        mov     ecx, sizeof.v86_regs/4
        rep movsd
        mov     esp, esi
 
        cli
        mov     ecx, [current_slot]
        pop     eax
 
        mov     [ecx+APPDATA.saved_esp0], eax
        mov     [tss._esp0], eax
        pop     eax
        mov     [ecx+APPDATA.process], eax
        mov     [current_process], eax
        pop     ebx
        mov     dword [ecx+APPDATA.io_map+4], ebx
        mov     dword [page_tabs + (tss._io_map_1 shr 10)], ebx
        pop     ebx
        mov     dword [ecx+APPDATA.io_map], ebx
        mov     dword [page_tabs + (tss._io_map_0 shr 10)], ebx
        mov     eax, [eax+PROC.pdt_0_phys]
        mov     cr3, eax
        sti
 
        popad
        ret
 
;my05:
;        mov     dx, 30C2h
;        mov     cx, 4
;.0:
;        in      al, dx
;        cmp     al, 0FFh
;        jz      @f
;        test    al, 4
;        jnz     .1
;@@:
;        add     dx, 8
;        in      al, dx
;        cmp     al, 0FFh
;        jz      @f
;        test    al, 4
;        jnz     .1
;@@:
;        loop    .0
;        ret
;.1:
;        or      al, 84h
;        out     dx, al
;.2:
;        mov     dx, 30F7h
;        in      al, dx
;        mov     byte [BOOT_VAR + 48Eh], 0FFh
;        ret
 
align 4
v86_irq:
; push irq/pushad/jmp v86_irq
; ebp = irq
        lea     esi, [esp+1Ch]
        lea     edi, [esi+4]
        mov     ecx, 8
        std
        rep movsd
        cld
        mov     edi, ebp
        pop     eax
v86_irq2:
        mov     esi, [v86_irqhooks+edi*8]       ; get VM handle
        mov     eax, [esi+V86_machine.process]
        mov     ecx, [CURRENT_TASK]
        shl     ecx, 8
        cmp     [SLOT_BASE+ecx+APPDATA.process], eax
        jnz     .notcurrent
        lea     eax, [edi+8]
        cmp     al, 10h
        mov     ah, 1
        jb      @f
        add     al, 60h
@@:
        jmp     v86_exc_c.simulate_int
.notcurrent:
        mov     ebx, SLOT_BASE + 0x100
        mov     ecx, [thread_count]
.scan:
        cmp     [ebx+APPDATA.process], eax
        jnz     .cont
        push    ecx
        mov     ecx, [ebx+APPDATA.saved_esp0]
        cmp     word [ecx-sizeof.v86_regs+v86_regs.esp], 6
        jb      .cont2
        movzx   edx, word [ecx-sizeof.v86_regs+v86_regs.ss]
        shl     edx, 4
        push    eax
        movzx   eax, word [ecx-sizeof.v86_regs+v86_regs.esp]
        sub     eax, 6
        add     edx, eax
        mov     eax, edx
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jb      .cont3
        lea     eax, [edx+5]
        call    v86_get_lin_addr
        cmp     eax, 0x1000
        jb      .cont3
        pop     eax
        pop     ecx
        jmp     .found
.cont3:
        pop     eax
.cont2:
        pop     ecx
.cont:
        add     ebx, 0x100
        loop    .scan
        mov     ecx, edi
        call    irq_eoi
        popad
        iretd
.found:
        mov     eax, [eax+PROC.pdt_0_phys]
        mov     cr3, eax
        mov     esi, [ebx+APPDATA.saved_esp0]
        sub     word [esi-sizeof.v86_regs+v86_regs.esp], 6
        mov     ecx, [esi-sizeof.v86_regs+v86_regs.eip]
        mov     word [edx], cx
        mov     ecx, [esi-sizeof.v86_regs+v86_regs.cs]
        mov     word [edx+2], cx
        mov     ecx, [esi-sizeof.v86_regs+v86_regs.eflags]
        mov     word [edx+4], cx
        lea     eax, [edi+8]
        cmp     al, 10h
        jb      @f
        add     al, 60h
@@:
        mov     cx, [eax*4]
        mov     word [esi-sizeof.v86_regs+v86_regs.eip], cx
        mov     cx, [eax*4+2]
        mov     word [esi-sizeof.v86_regs+v86_regs.cs], cx
        and     byte [esi-sizeof.v86_regs+v86_regs.eflags+1], not 3
        call    update_counters
        lea     edi, [ebx + 0x100000000 - SLOT_BASE]
        shr     edi, 3
        add     edi, CURRENT_TASK
        call    find_next_task.found
        call    do_change_task
        popad
        iretd

Rev 8052	Rev 8866
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2007-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2007-2021. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 8052 $	8	$Revision: 8866 $
9		9
10	; Virtual-8086 mode manager	10	; Virtual-8086 mode manager
11	; diamond, 2007, 2008	11	; diamond, 2007, 2008
12		12
13	DEBUG_SHOW_IO = 0	13	DEBUG_SHOW_IO = 0
14		14
15	struct V86_machine	15	struct V86_machine
16	; page directory	16	; page directory
17	process dd ?	17	process dd ?
18	; mutex to protect all data from writing by multiple threads at one time	18	; mutex to protect all data from writing by multiple threads at one time
19	mutex dd ?	19	mutex dd ?
20	; i/o permission map	20	; i/o permission map
21	iopm dd ?	21	iopm dd ?
22	ends	22	ends
23		23
24	; Create V86 machine	24	; Create V86 machine
25	; in: nothing	25	; in: nothing
26	; out: eax = handle (pointer to struc V86_machine)	26	; out: eax = handle (pointer to struc V86_machine)
27	; eax = NULL => failure	27	; eax = NULL => failure
28	; destroys: ebx, ecx, edx (due to malloc)	28	; destroys: ebx, ecx, edx (due to malloc)
29	v86_create:	29	v86_create:
30	; allocate V86_machine structure	30	; allocate V86_machine structure
31	mov eax, sizeof.V86_machine	31	mov eax, sizeof.V86_machine
32	call malloc	32	call malloc
33	test eax, eax	33	test eax, eax
34	jz .fail	34	jz .fail
35	; initialize mutex	35	; initialize mutex
36	and dword [eax+V86_machine.mutex], 0	36	and dword [eax+V86_machine.mutex], 0
37	; allocate tables	37	; allocate tables
38	mov ebx, eax	38	mov ebx, eax
39		39
40	stdcall create_process, 4096	40	stdcall create_process, 4096
41	test eax, eax	41	test eax, eax
42	jz .fail2	42	jz .fail2
43		43
44	mov [eax+PROC.mem_used], 4096	44	mov [eax+PROC.mem_used], 4096
45	mov [ebx+V86_machine.process], eax	45	mov [ebx+V86_machine.process], eax
46		46
47	push 2000h	47	push 2000h
48	call kernel_alloc	48	call kernel_alloc
49	test eax, eax	49	test eax, eax
50	jz .fail2	50	jz .fail2
51		51
52	mov [ebx+V86_machine.iopm], eax	52	mov [ebx+V86_machine.iopm], eax
53		53
54	; initialize tables	54	; initialize tables
55	push edi	55	push edi
56	mov edi, eax	56	mov edi, eax
57	mov eax, -1	57	mov eax, -1
58	mov ecx, 2000h/4	58	mov ecx, 2000h/4
59	rep stosd	59	rep stosd
60		60
61	mov eax, [ebx+V86_machine.process]	61	mov eax, [ebx+V86_machine.process]
62	mov eax, [eax+PROC.pdt_0_phys]	62	mov eax, [eax+PROC.pdt_0_phys]
63		63
64	pushfd	64	pushfd
65	cli	65	cli
66	mov cr3, eax	66	mov cr3, eax
67		67
68	; now V86 specific: initialize known addresses in first Mb	68	; now V86 specific: initialize known addresses in first Mb
69		69
70	; first page - BIOS data (shared between all machines!)	70	; first page - BIOS data (shared between all machines!)
71	; physical address = 0	71	; physical address = 0
72	; linear address = OS_BASE	72	; linear address = OS_BASE
73	; page before 0xA0000 - Extended BIOS Data Area (shared between all machines!)	73	; page before 0xA0000 - Extended BIOS Data Area (shared between all machines!)
74	; physical address = 0x9C000	74	; physical address = 0x9C000
75	; linear address = 0x8009C000	75	; linear address = 0x8009C000
76	; (I have seen one computer with EBDA segment = 0x9D80,	76	; (I have seen one computer with EBDA segment = 0x9D80,
77	; all other computers use less memory)	77	; all other computers use less memory)
78		78
79	mov eax, PG_UWR	79	mov eax, PG_UWR
80	mov [page_tabs], eax	80	mov [page_tabs], eax
81	invlpg [eax]	81	invlpg [eax]
82		82
83	mov byte [0x500], 0xCD	83	mov byte [0x500], 0xCD
84	mov byte [0x501], 0x13	84	mov byte [0x501], 0x13
85	mov byte [0x502], 0xF4	85	mov byte [0x502], 0xF4
86	mov byte [0x503], 0xCD	86	mov byte [0x503], 0xCD
87	mov byte [0x504], 0x10	87	mov byte [0x504], 0x10
88	mov byte [0x505], 0xF4	88	mov byte [0x505], 0xF4
89		89
90	mov eax, 0x98000+PG_UWR	90	mov eax, 0x98000+PG_UWR
91	mov edi, page_tabs+0x98*4	91	mov edi, page_tabs+0x98*4
92	mov edx, 0x1000	92	mov edx, 0x1000
93	mov ecx, 8	93	mov ecx, 8
94	@@:	94	@@:
95	stosd	95	stosd
96	add eax, edx	96	add eax, edx
97	loop @b	97	loop @b
98		98
99	; addresses 0xC0000 - 0xFFFFF - BIOS code (shared between all machines!)	99	; addresses 0xC0000 - 0xFFFFF - BIOS code (shared between all machines!)
100	; physical address = 0xC0000	100	; physical address = 0xC0000
101		101
102	mov eax, 0xC0000+PG_UWR	102	mov eax, 0xC0000+PG_UWR
103	mov edi, page_tabs+0xC0*4	103	mov edi, page_tabs+0xC0*4
104	mov ecx, 64	104	mov ecx, 64
105	@@:	105	@@:
106	stosd	106	stosd
107	add eax, edx	107	add eax, edx
108	loop @b	108	loop @b
109		109
110	mov eax, [sys_proc+PROC.pdt_0_phys]	110	mov eax, [sys_proc+PROC.pdt_0_phys]
111	mov cr3, eax	111	mov cr3, eax
112	popfd	112	popfd
113		113
114	pop edi	114	pop edi
115		115
116	mov eax, ebx	116	mov eax, ebx
117	ret	117	ret
118	.fail2:	118	.fail2:
119	mov eax, ebx	119	mov eax, ebx
120	call free	120	call free
121	.fail:	121	.fail:
122	xor eax, eax	122	xor eax, eax
123	ret	123	ret
124		124
125	;not used	125	;not used
126	; Destroy V86 machine	126	; Destroy V86 machine
127	; in: eax = handle	127	; in: eax = handle
128	; out: nothing	128	; out: nothing
129	; destroys: eax, ebx, ecx, edx (due to free)	129	; destroys: eax, ebx, ecx, edx (due to free)
130	;v86_destroy:	130	;v86_destroy:
131	; push eax	131	; push eax
132	; stdcall kernel_free, [eax+V86_machine.pagedir]	132	; stdcall kernel_free, [eax+V86_machine.pagedir]
133	; pop eax	133	; pop eax
134	; jmp free	134	; jmp free
135		135
136	; Translate V86-address to linear address	136	; Translate V86-address to linear address
137	; in: eax=V86 address	137	; in: eax=V86 address
138	; esi=handle	138	; esi=handle
139	; out: eax=linear address	139	; out: eax=linear address
140	; destroys: nothing	140	; destroys: nothing
141	v86_get_lin_addr:	141	v86_get_lin_addr:
142	push ecx edx	142	push ecx edx
143	mov ecx, eax	143	mov ecx, eax
144	shr ecx, 12	144	shr ecx, 12
145	mov edx, [page_tabs+ecx*4]	145	mov edx, [page_tabs+ecx*4]
146	and eax, 0xFFF	146	and eax, 0xFFF
147	and edx, 0xFFFFF000	147	and edx, 0xFFFFF000
148	or eax, edx	148	or eax, edx
149	pop edx ecx	149	pop edx ecx
150	ret	150	ret
151		151
152	;not used	152	;not used
153	; Sets linear address for V86-page	153	; Sets linear address for V86-page
154	; in: eax=linear address (must be page-aligned)	154	; in: eax=linear address (must be page-aligned)
155	; ecx=V86 page (NOT address!)	155	; ecx=V86 page (NOT address!)
156	; esi=handle	156	; esi=handle
157	; out: nothing	157	; out: nothing
158	; destroys: nothing	158	; destroys: nothing
159	;v86_set_page:	159	;v86_set_page:
160	; push eax ebx	160	; push eax ebx
161	; mov ebx, [esi+V86_machine.pagedir]	161	; mov ebx, [esi+V86_machine.pagedir]
162	; mov [ebx+ecx*4+0x1800], eax	162	; mov [ebx+ecx*4+0x1800], eax
163	; call get_pg_addr	163	; call get_pg_addr
164	; or al, 111b	164	; or al, 111b
165	; mov [ebx+ecx*4+0x1000], eax	165	; mov [ebx+ecx*4+0x1000], eax
166	; pop ebx eax	166	; pop ebx eax
167	; ret	167	; ret
168		168
169	; Allocate memory in V86 machine	169	; Allocate memory in V86 machine
170	; in: eax=size (in bytes)	170	; in: eax=size (in bytes)
171	; esi=handle	171	; esi=handle
172	; out: eax=V86 address, para-aligned (0x10 multiple)	172	; out: eax=V86 address, para-aligned (0x10 multiple)
173	; destroys: nothing	173	; destroys: nothing
174	; недописана!!!	174	; недописана!!!
175	;v86_alloc:	175	;v86_alloc:
176	; push ebx ecx edx edi	176	; push ebx ecx edx edi
177	; lea ebx, [esi+V86_machine.mutex]	177	; lea ebx, [esi+V86_machine.mutex]
178	; call wait_mutex	178	; call wait_mutex
179	; add eax, 0x1F	179	; add eax, 0x1F
180	; shr eax, 4	180	; shr eax, 4
181	; mov ebx, 0x1000 ; start with address 0x1000 (second page)	181	; mov ebx, 0x1000 ; start with address 0x1000 (second page)
182	; mov edi, [esi+V86_machine.tables]	182	; mov edi, [esi+V86_machine.tables]
183	;.l:	183	;.l:
184	; mov ecx, ebx	184	; mov ecx, ebx
185	; shr ecx, 12	185	; shr ecx, 12
186	; mov edx, [edi+0x1000+ecx*4] ; get linear address	186	; mov edx, [edi+0x1000+ecx*4] ; get linear address
187	; test edx, edx ; page allocated?	187	; test edx, edx ; page allocated?
188	; jz .unalloc	188	; jz .unalloc
189	; mov ecx, ebx	189	; mov ecx, ebx
190	; and ecx, 0xFFF	190	; and ecx, 0xFFF
191	; add edx, ecx	191	; add edx, ecx
192	; cmp dword [edx], 0 ; free block?	192	; cmp dword [edx], 0 ; free block?
193	; jnz .n	193	; jnz .n
194	; cmp dword [edx+4],	194	; cmp dword [edx+4],
195	; and [esi+V86_machine.mutex], 0	195	; and [esi+V86_machine.mutex], 0
196	; pop edi edx ecx ebx	196	; pop edi edx ecx ebx
197	; ret	197	; ret
198		198
199	uglobal	199	uglobal
200	sys_v86_machine dd ?	200	sys_v86_machine dd ?
201	endg	201	endg
202		202
203	; Called from kernel.asm at first stages of loading	203	; Called from kernel.asm at first stages of loading
204	; Initialize system V86 machine (used to simulate BIOS int 13h)	204	; Initialize system V86 machine (used to simulate BIOS int 13h)
205	init_sys_v86:	205	init_sys_v86:
206	call v86_create	206	call v86_create
207	mov [sys_v86_machine], eax	207	mov [sys_v86_machine], eax
208	test eax, eax	208	test eax, eax
209	jz .ret	209	jz .ret
210	mov esi, eax	210	mov esi, eax
211	if ~DEBUG_SHOW_IO	211	if ~DEBUG_SHOW_IO
212	; allow access to all ports	212	; allow access to all ports
213	mov ecx, [esi+V86_machine.iopm]	213	mov ecx, [esi+V86_machine.iopm]
214	xor eax, eax	214	xor eax, eax
215	mov edi, ecx	215	mov edi, ecx
216	mov ecx, 10000h/8/4	216	mov ecx, 10000h/8/4
217	rep stosd	217	rep stosd
218	end if	218	end if
219	.ret:	219	.ret:
220	ret	220	ret
221		221
222	struct v86_regs	222	struct v86_regs
223	; don't change the order, it is important	223	; don't change the order, it is important
224	edi dd ?	224	edi dd ?
225	esi dd ?	225	esi dd ?
226	ebp dd ?	226	ebp dd ?
227	dd ? ; ignored	227	dd ? ; ignored
228	ebx dd ?	228	ebx dd ?
229	edx dd ?	229	edx dd ?
230	ecx dd ?	230	ecx dd ?
231	eax dd ?	231	eax dd ?
232	eip dd ?	232	eip dd ?
233	cs dd ?	233	cs dd ?
234	eflags dd ? ; VM flag must be set!	234	eflags dd ? ; VM flag must be set!
235	esp dd ?	235	esp dd ?
236	ss dd ?	236	ss dd ?
237	es dd ?	237	es dd ?
238	ds dd ?	238	ds dd ?
239	fs dd ?	239	fs dd ?
240	gs dd ?	240	gs dd ?
241	ends	241	ends
242		242
243	; Run V86 machine	243	; Run V86 machine
244	; in: ebx -> registers for V86 (two structures: in and out)	244	; in: ebx -> registers for V86 (two structures: in and out)
245	; esi = handle	245	; esi = handle
246	; ecx = expected end address (CS:IP)	246	; ecx = expected end address (CS:IP)
247	; edx = IRQ to hook or -1 if not required	247	; edx = IRQ to hook or -1 if not required
248	; out: structure pointed to by ebx is filled with new values	248	; out: structure pointed to by ebx is filled with new values
249	; eax = 1 - exception has occured, cl contains code	249	; eax = 1 - exception has occured, cl contains code
250	; eax = 2 - access to disabled i/o port, ecx contains port address	250	; eax = 2 - access to disabled i/o port, ecx contains port address
251	; eax = 3 - IRQ is already hooked by another VM	251	; eax = 3 - IRQ is already hooked by another VM
252	; destroys: nothing	252	; destroys: nothing
253	v86_start:	253	v86_start:
254		254
255	pushad	255	pushad
256		256
257	cli	257	cli
258		258
259	mov ecx, [current_slot]	259	mov ecx, [current_slot]
260		260
261	push dword [ecx+APPDATA.io_map]	261	push dword [ecx+APPDATA.io_map]
262	push dword [ecx+APPDATA.io_map+4]	262	push dword [ecx+APPDATA.io_map+4]
263	push [ecx+APPDATA.process]	263	push [ecx+APPDATA.process]
264	push [ecx+APPDATA.saved_esp0]	264	push [ecx+APPDATA.saved_esp0]
265	mov [ecx+APPDATA.saved_esp0], esp	265	mov [ecx+APPDATA.saved_esp0], esp
266	mov [tss._esp0], esp	266	mov [tss._esp0], esp
267		267
268	mov eax, [esi+V86_machine.iopm]	268	mov eax, [esi+V86_machine.iopm]
269	call get_pg_addr	269	call get_pg_addr
270	inc eax	270	inc eax
271	mov dword [ecx+APPDATA.io_map], eax	271	mov dword [ecx+APPDATA.io_map], eax
272	mov dword [page_tabs + (tss._io_map_0 shr 10)], eax	272	mov dword [page_tabs + (tss._io_map_0 shr 10)], eax
273		273
274	mov eax, [esi+V86_machine.iopm]	274	mov eax, [esi+V86_machine.iopm]
275	add eax, 0x1000	275	add eax, 0x1000
276	call get_pg_addr	276	call get_pg_addr
277	inc eax	277	inc eax
278	mov dword [ecx+APPDATA.io_map+4], eax	278	mov dword [ecx+APPDATA.io_map+4], eax
279	mov dword [page_tabs + (tss._io_map_1 shr 10)], eax	279	mov dword [page_tabs + (tss._io_map_1 shr 10)], eax
280		280
281	mov eax, [esi+V86_machine.process]	281	mov eax, [esi+V86_machine.process]
282	mov [ecx+APPDATA.process], eax	282	mov [ecx+APPDATA.process], eax
283	mov [current_process], eax	283	mov [current_process], eax
284	mov eax, [eax+PROC.pdt_0_phys]	284	mov eax, [eax+PROC.pdt_0_phys]
285	mov cr3, eax	285	mov cr3, eax
286		286
287	; We do not enable interrupts, because V86 IRQ redirector assumes that	287	; We do not enable interrupts, because V86 IRQ redirector assumes that
288	; machine is running	288	; machine is running
289	; They will be enabled by IRET.	289	; They will be enabled by IRET.
290	; sti	290	; sti
291		291
292	mov eax, esi	292	mov eax, esi
293	sub esp, sizeof.v86_regs	293	sub esp, sizeof.v86_regs
294	mov esi, ebx	294	mov esi, ebx
295	mov edi, esp	295	mov edi, esp
296	mov ecx, sizeof.v86_regs/4	296	mov ecx, sizeof.v86_regs/4
297	rep movsd	297	rep movsd
298		298
299	cmp edx, -1	299	cmp edx, -1
300	jz .noirqhook	300	jz .noirqhook
301	uglobal	301	uglobal
302	v86_irqhooks rd IRQ_RESERVED * 2	302	v86_irqhooks rd IRQ_RESERVED * 2
303	endg	303	endg
304	cmp [v86_irqhooks+edx*8], 0	304	cmp [v86_irqhooks+edx*8], 0
305	jz @f	305	jz @f
306	cmp [v86_irqhooks+edx*8], eax	306	cmp [v86_irqhooks+edx*8], eax
307	jz @f	307	jz @f
308	mov esi, v86_irqerr	308	mov esi, v86_irqerr
309	call sys_msg_board_str	309	call sys_msg_board_str
310	inc [v86_irqhooks+edx*8+4]	310	inc [v86_irqhooks+edx*8+4]
311	mov eax, 3	311	mov eax, 3
312	jmp v86_exc_c.exit	312	jmp v86_exc_c.exit
313	@@:	313	@@:
314	mov [v86_irqhooks+edx*8], eax	314	mov [v86_irqhooks+edx*8], eax
315	inc [v86_irqhooks+edx*8+4]	315	inc [v86_irqhooks+edx*8+4]
316	.noirqhook:	316	.noirqhook:
317		317
318	popad	318	popad
319	iretd	319	iretd
320		320
321	; It is only possible to leave virtual-8086 mode by faulting to	321	; It is only possible to leave virtual-8086 mode by faulting to
322	; a protected-mode interrupt handler (typically the general-protection	322	; a protected-mode interrupt handler (typically the general-protection
323	; exception handler, which in turn calls the virtual 8086-mode monitor).	323	; exception handler, which in turn calls the virtual 8086-mode monitor).
324		324
325	iglobal	325	iglobal
326	v86_exc_str1 db 'V86 : unexpected exception ',0	326	v86_exc_str1 db 'V86 : unexpected exception ',0
327	v86_exc_str2 db ' at ',0	327	v86_exc_str2 db ' at ',0
328	v86_exc_str3 db ':',0	328	v86_exc_str3 db ':',0
329	v86_exc_str4 db 13,10,'V86 : faulted code:',0	329	v86_exc_str4 db 13,10,'V86 : faulted code:',0
330	v86_exc_str5 db ' (unavailable)',0	330	v86_exc_str5 db ' (unavailable)',0
331	v86_newline db 13,10,0	331	v86_newline db 13,10,0
332	v86_io_str1 db 'V86 : access to disabled i/o port ',0	332	v86_io_str1 db 'V86 : access to disabled i/o port ',0
333	v86_io_byte db ' (byte)',13,10,0	333	v86_io_byte db ' (byte)',13,10,0
334	v86_io_word db ' (word)',13,10,0	334	v86_io_word db ' (word)',13,10,0
335	v86_io_dword db ' (dword)',13,10,0	335	v86_io_dword db ' (dword)',13,10,0
336	v86_irqerr db 'V86 : IRQ already hooked',13,10,0	336	v86_irqerr db 'V86 : IRQ already hooked',13,10,0
337	endg	337	endg
338		338
339	v86_exc_c:	339	v86_exc_c:
340	; Did we all that we have wanted to do?	340	; Did we all that we have wanted to do?
341	cmp bl, 1	341	cmp bl, 1
342	jne @f	342	jne @f
343	xor eax, eax	343	xor eax, eax
344	mov dr6, eax	344	mov dr6, eax
345	@@:	345	@@:
346	mov eax, [esp+sizeof.v86_regs+10h+18h]	346	mov eax, [esp+sizeof.v86_regs+10h+18h]
347	cmp word [esp+v86_regs.eip], ax	347	cmp word [esp+v86_regs.eip], ax
348	jnz @f	348	jnz @f
349	shr eax, 16	349	shr eax, 16
350	cmp word [esp+v86_regs.cs], ax	350	cmp word [esp+v86_regs.cs], ax
351	jz .done	351	jz .done
352	@@:	352	@@:
353	; Various system events, which must be handled, result in #GP	353	; Various system events, which must be handled, result in #GP
354	cmp bl, 13	354	cmp bl, 13
355	jnz .nogp	355	jnz .nogp
356	; If faulted EIP exceeds 0xFFFF, we have #GP and it is an error	356	; If faulted EIP exceeds 0xFFFF, we have #GP and it is an error
357	cmp word [esp+v86_regs.eip+2], 0	357	cmp word [esp+v86_regs.eip+2], 0
358	jnz .nogp	358	jnz .nogp
359	; Otherwise we can safely access byte at CS:IP	359	; Otherwise we can safely access byte at CS:IP
360	; (because it is #GP, not #PF handler)	360	; (because it is #GP, not #PF handler)
361	; If we could get an exception just because of reading code bytes,	361	; If we could get an exception just because of reading code bytes,
362	; we would have got it already and it wouldn't be #GP	362	; we would have got it already and it wouldn't be #GP
363	movzx esi, word [esp+v86_regs.cs]	363	movzx esi, word [esp+v86_regs.cs]
364	shl esi, 4	364	shl esi, 4
365	add esi, [esp+v86_regs.eip]	365	add esi, [esp+v86_regs.eip]
366	lodsb	366	lodsb
367	cmp al, 0xCD ; int xx command = CD xx	367	cmp al, 0xCD ; int xx command = CD xx
368	jz .handle_int	368	jz .handle_int
369	cmp al, 0xCF	369	cmp al, 0xCF
370	jz .handle_iret	370	jz .handle_iret
371	cmp al, 0xF3	371	cmp al, 0xF3
372	jz .handle_rep	372	jz .handle_rep
373	cmp al, 0xEC	373	cmp al, 0xEC
374	jz .handle_in	374	jz .handle_in
375	cmp al, 0xED	375	cmp al, 0xED
376	jz .handle_in_word	376	jz .handle_in_word
377	cmp al, 0xEE	377	cmp al, 0xEE
378	jz .handle_out	378	jz .handle_out
379	cmp al, 0xEF	379	cmp al, 0xEF
380	jz .handle_out_word	380	jz .handle_out_word
381	cmp al, 0xE4	381	cmp al, 0xE4
382	jz .handle_in_imm	382	jz .handle_in_imm
383	cmp al, 0xE6	383	cmp al, 0xE6
384	jz .handle_out_imm	384	jz .handle_out_imm
385	cmp al, 0x9C	385	cmp al, 0x9C
386	jz .handle_pushf	386	jz .handle_pushf
387	cmp al, 0x9D	387	cmp al, 0x9D
388	jz .handle_popf	388	jz .handle_popf
389	cmp al, 0xFA	389	cmp al, 0xFA
390	jz .handle_cli	390	jz .handle_cli
391	cmp al, 0xFB	391	cmp al, 0xFB
392	jz .handle_sti	392	jz .handle_sti
393	cmp al, 0x66	393	cmp al, 0x66
394	jz .handle_66	394	jz .handle_66
395	jmp .nogp	395	jmp .nogp
396	.handle_int:	396	.handle_int:
397	cmp word [esp+v86_regs.eip], 0xFFFF	397	cmp word [esp+v86_regs.eip], 0xFFFF
398	jae .nogp	398	jae .nogp
399	xor eax, eax	399	xor eax, eax
400	lodsb	400	lodsb
401	; call sys_msg_board_byte	401	; call sys_msg_board_byte
402	; simulate INT command	402	; simulate INT command
403	; N.B. It is possible that some checks need to be corrected,	403	; N.B. It is possible that some checks need to be corrected,
404	; but at least in case of normal execution the code works.	404	; but at least in case of normal execution the code works.
405	.simulate_int:	405	.simulate_int:
406	cmp word [esp+v86_regs.esp], 6	406	cmp word [esp+v86_regs.esp], 6
407	jae @f	407	jae @f
408	mov bl, 12 ; #SS exception	408	mov bl, 12 ; #SS exception
409	jmp .nogp	409	jmp .nogp
410	@@:	410	@@:
411	movzx edx, word [esp+v86_regs.ss]	411	movzx edx, word [esp+v86_regs.ss]
412	shl edx, 4	412	shl edx, 4
413	push eax	413	push eax
414	movzx eax, word [esp+4+v86_regs.esp]	414	movzx eax, word [esp+4+v86_regs.esp]
415	sub eax, 6	415	sub eax, 6
416	add edx, eax	416	add edx, eax
417	mov eax, edx	417	mov eax, edx
418	mov esi, [esp+4+sizeof.v86_regs+10h+4]	418	mov esi, [esp+4+sizeof.v86_regs+10h+4]
419	call v86_get_lin_addr	419	call v86_get_lin_addr
420	cmp eax, 0x1000	420	cmp eax, 0x1000
421	jae @f	421	jae @f
422	mov bl, 14 ; #PF exception	422	mov bl, 14 ; #PF exception
423	jmp .nogp	423	jmp .nogp
424	@@:	424	@@:
425	lea eax, [edx+5]	425	lea eax, [edx+5]
426	call v86_get_lin_addr	426	call v86_get_lin_addr
427	cmp eax, 0x1000	427	cmp eax, 0x1000
428	jae @f	428	jae @f
429	mov bl, 14 ; #PF exception	429	mov bl, 14 ; #PF exception
430	jmp .nogp	430	jmp .nogp
431	@@:	431	@@:
432	sub word [esp+4+v86_regs.esp], 6	432	sub word [esp+4+v86_regs.esp], 6
433	mov eax, [esp+4+v86_regs.eip]	433	mov eax, [esp+4+v86_regs.eip]
434	cmp byte [esp+1], 0	434	cmp byte [esp+1], 0
435	jnz @f	435	jnz @f
436	inc eax	436	inc eax
437	inc eax	437	inc eax
438	@@:	438	@@:
439	mov word [edx], ax	439	mov word [edx], ax
440	mov eax, [esp+4+v86_regs.cs]	440	mov eax, [esp+4+v86_regs.cs]
441	mov word [edx+2], ax	441	mov word [edx+2], ax
442	mov eax, [esp+4+v86_regs.eflags]	442	mov eax, [esp+4+v86_regs.eflags]
443	mov word [edx+4], ax	443	mov word [edx+4], ax
444	pop eax	444	pop eax
445	mov ah, 0	445	mov ah, 0
446	mov cx, [eax*4]	446	mov cx, [eax*4]
447	mov word [esp+v86_regs.eip], cx	447	mov word [esp+v86_regs.eip], cx
448	mov cx, [eax*4+2]	448	mov cx, [eax*4+2]
449	mov word [esp+v86_regs.cs], cx	449	mov word [esp+v86_regs.cs], cx
450	; note that interrupts will be disabled globally at IRET	450	; note that interrupts will be disabled globally at IRET
451	and byte [esp+v86_regs.eflags+1], not 3 ; clear IF and TF flags	451	and byte [esp+v86_regs.eflags+1], not 3 ; clear IF and TF flags
452	; continue V86 execution	452	; continue V86 execution
453	popad	453	popad
454	iretd	454	iretd
455	.handle_iret:	455	.handle_iret:
456	cmp word [esp+v86_regs.esp], 0x10000 - 6	456	cmp word [esp+v86_regs.esp], 0x10000 - 6
457	jbe @f	457	jbe @f
458	mov bl, 12	458	mov bl, 12
459	jmp .nogp	459	jmp .nogp
460	@@:	460	@@:
461	movzx edx, word [esp+v86_regs.ss]	461	movzx edx, word [esp+v86_regs.ss]
462	shl edx, 4	462	shl edx, 4
463	movzx eax, word [esp+v86_regs.esp]	463	movzx eax, word [esp+v86_regs.esp]
464	add edx, eax	464	add edx, eax
465	mov eax, edx	465	mov eax, edx
466	mov esi, [esp+sizeof.v86_regs+10h+4]	466	mov esi, [esp+sizeof.v86_regs+10h+4]
467	call v86_get_lin_addr	467	call v86_get_lin_addr
468	cmp eax, 0x1000	468	cmp eax, 0x1000
469	jae @f	469	jae @f
470	mov bl, 14	470	mov bl, 14
471	jmp .nogp	471	jmp .nogp
472	@@:	472	@@:
473	lea eax, [edx+5]	473	lea eax, [edx+5]
474	call v86_get_lin_addr	474	call v86_get_lin_addr
475	cmp eax, 0x1000	475	cmp eax, 0x1000
476	jae @f	476	jae @f
477	mov bl, 14	477	mov bl, 14
478	jmp .nogp	478	jmp .nogp
479	@@:	479	@@:
480	mov ax, [edx]	480	mov ax, [edx]
481	mov word [esp+v86_regs.eip], ax	481	mov word [esp+v86_regs.eip], ax
482	mov ax, [edx+2]	482	mov ax, [edx+2]
483	mov word [esp+v86_regs.cs], ax	483	mov word [esp+v86_regs.cs], ax
484	mov ax, [edx+4]	484	mov ax, [edx+4]
485	mov word [esp+v86_regs.eflags], ax	485	mov word [esp+v86_regs.eflags], ax
486	add word [esp+v86_regs.esp], 6	486	add word [esp+v86_regs.esp], 6
487	popad	487	popad
488	iretd	488	iretd
489	.handle_pushf:	489	.handle_pushf:
490	cmp word [esp+v86_regs.esp], 1	490	cmp word [esp+v86_regs.esp], 1
491	jnz @f	491	jnz @f
492	mov bl, 12	492	mov bl, 12
493	jmp .nogp	493	jmp .nogp
494	@@:	494	@@:
495	movzx edx, word [esp+v86_regs.ss]	495	movzx edx, word [esp+v86_regs.ss]
496	shl edx, 4	496	shl edx, 4
497	mov eax, [esp+v86_regs.esp]	497	mov eax, [esp+v86_regs.esp]
498	sub eax, 2	498	sub eax, 2
499	movzx eax, ax	499	movzx eax, ax
500	add edx, eax	500	add edx, eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/v86.inc – Rev 8052 → 8866