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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/v86.inc – Rev 5356 → 5363