WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/core/v86.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2007-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 897 $
 
; Virtual-8086 mode manager
; diamond, 2007, 2008
 
DEBUG_SHOW_IO = 0
 
struc V86_machine
{
; page directory
        .pagedir dd     ?
; translation table: V86 address -> flat linear address
        .pages  dd      ?
; mutex to protect all data from writing by multiple threads at one time
        .mutex  dd      ?
; i/o permission map
        .iopm   dd      ?
.size = $
}
virtual at 0
V86_machine V86_machine
end virtual
 
; 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, V86_machine.size
        call    malloc
        test    eax, eax
        jz      .fail
; initialize mutex
        and     dword [eax+V86_machine.mutex], 0
; allocate tables
        mov     ebx, eax
; We allocate 4 pages.
; First is main page directory for V86 mode.
; Second page:
; first half (0x800 bytes) is page table for addresses 0 - 0x100000,
; second half is for V86-to-linear translation.
; Third and fourth are for I/O permission map.
 
        mov ecx, 0x4000
        mov edx, PG_SW
        call    @mem_alloc@8
        test    eax, eax
        jz      .fail2
 
        mov     [ebx+V86_machine.pagedir], eax
        push    edi eax
        mov     edi, eax
        add     eax, 1800h
        mov     [ebx+V86_machine.pages], eax
; initialize tables
        mov     ecx, 2000h/4
        xor     eax, eax
        rep     stosd
        mov     [ebx+V86_machine.iopm], edi
        dec     eax
        mov     ecx, 2000h/4
        rep     stosd
        pop     eax
; page directory: first entry is page table...
        mov     edi, eax
        add     eax, 1000h
        push    eax
        call    get_pg_addr
        or      al, PG_UW
        stosd
; ...and also copy system page tables
; thx to Serge, system is located at high addresses
        add     edi, (HEAP_BASE shr 20) - 4
        push    esi
        mov     esi, (HEAP_BASE shr 20) + _sys_pdbr
        mov     ecx, 0x80000000 shr 22
        rep     movsd
 
        mov     eax, [ebx+V86_machine.pagedir]   ;root dir also is
        call    get_pg_addr                      ;used as page table
        or      al, PG_SW
        mov [edi-4096+(page_tabs shr 20)], eax
 
        pop     esi
; now V86 specific: initialize known addresses in first Mb
        pop     eax
; first page - BIOS data (shared between all machines!)
; physical address = 0x1f0000
; linear address = BOOT_VAR = OS_BASE + 0x1f0000
        mov     dword [eax], (BOOT_VAR - OS_BASE) or 111b
        mov     dword [eax+800h], BOOT_VAR
; 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     ecx, 4
        mov     edx, 0x9C000
        push    eax
        lea     edi, [eax+0x9C*4]
@@:
        lea     eax, [edx + OS_BASE]
        mov     [edi+800h], eax
        lea     eax, [edx + 111b]
        stosd
        add     edx, 0x1000
        loop    @b
        pop     eax
        pop     edi
; addresses 0xC0000 - 0xFFFFF - BIOS code (shared between all machines!)
; physical address = 0xC0000
; linear address = 0x800C0000
        mov     ecx, 0xC0
@@:
        mov     edx, ecx
        shl     edx, 12
        push    edx
        or      edx, 101b
        mov     [eax+ecx*4], edx
        pop     edx
        add     edx, OS_BASE
        mov     [eax+ecx*4+0x800], edx
        inc     cl
        jnz     @b
        mov     eax, ebx
        ret
.fail2:
        mov     eax, ebx
        call    free
.fail:
        xor     eax, eax
        ret
 
; Destroy V86 machine
; in: eax = handle
; out: nothing
; destroys: eax, ebx, ecx, edx (due to free)
v86_destroy:
        push    eax
 
        mov ecx, [eax+V86_machine.pagedir]
 
        call @mem_free@4
 
        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
        mov     edx, [esi+V86_machine.pages]
        shr     ecx, 12
        and     eax, 0xFFF
        add     eax, [edx+ecx*4]        ; atomic operation, no mutex needed
        pop     edx ecx
        ret
 
; 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     byte [BOOT_VAR + 0x500], 0xCD
        mov     byte [BOOT_VAR + 0x501], 0x13
        mov     byte [BOOT_VAR + 0x502], 0xF4
        mov     byte [BOOT_VAR + 0x503], 0xCD
        mov     byte [BOOT_VAR + 0x504], 0x10
        mov     byte [BOOT_VAR + 0x505], 0xF4
        mov     esi, eax
        mov     ebx, [eax+V86_machine.pagedir]
; one page for stack, two pages for results (0x2000 bytes = 16 sectors)
        mov     dword [ebx+0x99*4+0x1000], 0x99000 or 111b
        mov     dword [ebx+0x99*4+0x1800], OS_BASE + 0x99000
        mov     dword [ebx+0x9A*4+0x1000], 0x9A000 or 111b
        mov     dword [ebx+0x9A*4+0x1800], OS_BASE + 0x9A000
        mov     dword [ebx+0x9B*4+0x1000], 0x9B000 or 111b
        mov     dword [ebx+0x9B*4+0x1800], OS_BASE + 0x9B000
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
 
struc 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      ?
.size = $
}
virtual at 0
v86_regs v86_regs
end virtual
 
; 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_TASK]
        shl     ecx, 8
        add     ecx, SLOT_BASE
 
        mov     eax, [esi+V86_machine.iopm]
        call    get_pg_addr
        inc     eax
        push    dword [ecx+APPDATA.io_map]
        push    dword [ecx+APPDATA.io_map+4]
        mov     dword [ecx+APPDATA.io_map], eax
    ;    mov     dword [page_tabs + (tss._io_map_0 shr 10)], eax
        add     eax, 0x1000
        mov     dword [ecx+APPDATA.io_map+4], eax
    ;    mov     dword [page_tabs + (tss._io_map_1 shr 10)], eax
 
        push    [ecx+APPDATA.dir_table]
        push    [ecx+APPDATA.saved_esp0]
        mov     [ecx+APPDATA.saved_esp0], esp
        mov     [tss._esp0], esp
 
        mov     eax, [esi+V86_machine.pagedir]
        call    get_pg_addr
        mov     [ecx+APPDATA.dir_table], eax
        mov     cr3, eax
 
;        mov     [irq_tab+5*4], my05
 
; 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, v86_regs.size
        mov     esi, ebx
        mov     edi, esp
        mov     ecx, v86_regs.size/4
        rep     movsd
 
        cmp     edx, -1
        jz      .noirqhook
uglobal
v86_irqhooks    rd      16*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).
 
v86_debug_exc:
        pushad
        xor     eax, eax
        mov     dr6, eax
        mov     bl, 1
        jmp     v86_exc_c
 
v86_page_fault:
        add     esp, 4
        pushad
        mov     bl, 14
        jmp     v86_exc_c
 
v86_except_16:
        pushad
        mov     bl, 16
        jmp     v86_exc_c
v86_except_19:
        pushad
        mov     bl, 19
 
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:
        mov     ax, app_data
        mov     ds, ax
        mov     es, ax
; Did we all that we have wanted to do?
        mov     eax, [esp+v86_regs.size+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+v86_regs.size+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]
        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     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+v86_regs.size+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+v86_regs.size+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+v86_regs.size+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+v86_regs.size+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+v86_regs.size+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+v86_regs.size+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+v86_regs.size+10h+1Ch], eax
        mov     [esp+v86_regs.size+10h+18h], ebx
 
        mov     edx, [esp+v86_regs.size+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+v86_regs.size+10h+10h]
        add     edi, v86_regs.size
        mov     ecx, v86_regs.size/4
        rep     movsd
        mov     esp, esi
 
        cli
        mov     ecx, [CURRENT_TASK]
        shl     ecx, 8
        pop     eax
        mov     [SLOT_BASE+ecx+APPDATA.saved_esp0], eax
        mov     [tss._esp0], eax
        pop     eax
        mov     [SLOT_BASE+ecx+APPDATA.dir_table], eax
        pop     ebx
        mov     dword [SLOT_BASE+ecx+APPDATA.io_map+4], ebx
      ;  mov     dword [page_tabs + (tss._io_map_1 shr 10)], ebx
        pop     ebx
        mov     dword [SLOT_BASE+ecx+APPDATA.io_map], ebx
      ;  mov     dword [page_tabs + (tss._io_map_0 shr 10)], ebx
        mov     cr3, eax
;        mov     [irq_tab+5*4], 0
        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
 
v86_irq:
; push irq/pushad/jmp v86_irq
; eax = irq
        lea     esi, [esp+1Ch]
        lea     edi, [esi+4]
        mov     ecx, 8
        std
        rep     movsd
        cld
        mov     edi, eax
        pop     eax
        mov     esi, [v86_irqhooks+edi*8]       ; get VM handle
        mov     eax, [esi+V86_machine.pagedir]
        call    get_pg_addr
        mov     ecx, [CURRENT_TASK]
        shl     ecx, 8
        cmp     [SLOT_BASE+ecx+APPDATA.dir_table], eax
        jnz     .notcurrent
        lea     eax, [edi+8]
        cmp     al, 10h
        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.dir_table], eax
        jnz     .cont
        push    ecx
        mov     ecx, [ebx+APPDATA.saved_esp0]
        cmp     word [ecx-v86_regs.size+v86_regs.esp], 6
        jb      .cont2
        movzx   edx, word [ecx-v86_regs.size+v86_regs.ss]
        shl     edx, 4
        push    eax
        movzx   eax, word [ecx-v86_regs.size+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:
        loop    .scan
        mov     al, 20h
        out     20h, al
        cmp     edi, 8
        jb      @f
        out     0A0h, al
@@:
        popad
        iretd
.found:
        mov     cr3, eax
        sub     word [esi-v86_regs.size+v86_regs.esp], 6
        mov     ecx, [esi-v86_regs.size+v86_regs.eip]
        mov     word [edx], cx
        mov     ecx, [esi-v86_regs.size+v86_regs.cs]
        mov     word [edx+2], cx
        mov     ecx, [esi-v86_regs.size+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-v86_regs.size+v86_regs.eip], cx
        mov     cx, [eax*4+2]
        mov     word [esi-v86_regs.size+v86_regs.cs], cx
        and     byte [esi-v86_regs.size+v86_regs.eflags+1], not 3
        push    ebx
        call    update_counters
        pop     ebx
        sub     ebx, SLOT_BASE
        shr     ebx, 8
        mov     esi, [CURRENT_TASK]
        call    do_change_task
        popad
        iretd

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/v86.inc – Rev 887 → 897