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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2007-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2151 $
 
; 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.
        push    8000h           ; blocks less than 8 pages are discontinuous
        call    kernel_alloc
        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, (OS_BASE shr 20) - 4
        push    esi
        mov     esi, (OS_BASE shr 20) + sys_pgdir
        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 = 0
; linear address = OS_BASE
        mov     dword [eax], 111b
        mov     dword [eax+800h], 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     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, 111b
        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
        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
        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 [OS_BASE + 0x500], 0xCD
        mov     byte [OS_BASE + 0x501], 0x13
        mov     byte [OS_BASE + 0x502], 0xF4
        mov     byte [OS_BASE + 0x503], 0xCD
        mov     byte [OS_BASE + 0x504], 0x10
        mov     byte [OS_BASE + 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      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+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]
        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+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
 
        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.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
        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.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	eax, edi
	call	IRQ_EOI
 
        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
        call    update_counters
        lea     edi, [ebx + 0x100000000 - SLOT_BASE]
        shr     edi, 3
        add     edi, TASK_DATA
        call    find_next_task.found
        call    do_change_task
        popad
        iretd

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/v86.inc – Rev 2150 → 2151