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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                               ;;
;;  MenuetOS process management, protected ring3                 ;;
;;                                                               ;;
;;  Distributed under GPL. See file COPYING for details.         ;;
;;  Copyright 2003 Ville Turjanmaa                               ;;
;;                                                               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
align 32
 
; GDT TABLE
 
gdts:
 
        dw     gdte-$-1
        dd     gdts
        dw     0
 
int_code_l:
os_code_l:
 
        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10011010b
        db     0x00
 
int_data_l:
os_data_l:
 
        dw     0xffff
        dw     0x0000
        db     0x00
        dw     11011111b *256 +10010010b
        db     0x00
 
; --------------- APM ---------------------
apm_code_32:
        dw     0x10        ; limit 64kb
        db     0, 0, 0
        dw     11011111b *256 +10011010b
        db     0x00
apm_code_16:
        dw     0x10
        db     0, 0, 0
        dw     10011111b *256 +10011010b
        db     0x00
apm_data_16:
        dw     0x10
        db     0, 0, 0
        dw     10011111b *256 +10010010b
        db     0x00
; -----------------------------------------
 
app_code_l:
      dw 0xFFFF;((0x80000000-std_application_base_address) shr 12) and 0xffff
      dw 0
      db 0x40
      db cpl3
      dw G32+D32+0x6000+0x7;
 
app_data_l:
      dw 0xFFFF;(0x80000000-std_application_base_address) shr 12 and 0xffff
      dw 0
      db 0x40
      db drw3
      dw G32+D32+0x6000+0x7;
 
graph_data_l:
 
        dw     0x3ff
        dw     0x0000
        db     0x00
        dw     11010000b *256 +11110010b
        db     0x00
 
tss0_l:
      times (max_processes+10) dd 0,0
 
gdte:
 
 
 
idtreg:
     dw   8*0x41-1
     dd   idts+8
;label idts at 0xB100-8
 
 
 
uglobal
 tss_sceleton:
  l.back   dw 0,0
  l.esp0   dd 0
  l.ss0    dw 0,0
  l.esp1   dd 0
  l.ss1    dw 0,0
  l.esp2   dd 0
  l.ss2    dw 0,0
  l.cr3    dd 0
  l.eip    dd 0
  l.eflags dd 0
  l.eax    dd 0
  l.ecx    dd 0
  l.edx    dd 0
  l.ebx    dd 0
  l.esp    dd 0
  l.ebp    dd 0
  l.esi    dd 0
  l.edi    dd 0
  l.es     dw 0,0
  l.cs     dw 0,0
  l.ss     dw 0,0
  l.ds     dw 0,0
  l.fs     dw 0,0
  l.gs     dw 0,0
  l.ldt    dw 0,0
  l.trap   dw 0
  l.io     dw 0
endg
 
 
build_process_gdt_tss_pointer:
 
        mov    ecx,tss_data
        mov    edi,0
      setgdtl2:
        mov    [edi+gdts+ tss0 +0], word tss_step
        mov    [edi+gdts+ tss0 +2], cx
        mov    eax,ecx
        shr    eax,16
        mov    [edi+gdts+ tss0 +4], al
        mov    [edi+gdts+ tss0 +7], ah
        mov    [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b
        add    ecx,tss_step
        add    edi,8
        cmp    edi,8*(max_processes+5)
        jbe    setgdtl2
 
        ret
 
 
build_interrupt_table:
 
        mov    edi, idts+8
        mov    esi, sys_int
        mov    ecx, 0x40
     @@:
        mov    eax, [esi]
        mov    [edi],   ax           ; lower part of offset
        mov    [edi+2], word os_code ; segment selector
        shr    eax, 16
        mov    [edi+4], word 10001110b shl 8 ; interrupt descriptor
        mov    [edi+6], ax
        add    esi, 4
        add    edi, 8
        dec    ecx
        jnz    @b
 
        ;mov    edi,8*0x40+idts+8
        mov    [edi + 0], word (i40 and ((1 shl 16)-1))
        mov    [edi + 2], word os_code
        mov    [edi + 4], word 11101110b*256
        mov    [edi + 6], word (i40 shr 16)
 
        ret
 
 
 
iglobal
  sys_int:
    dd e0,debug_exc,e2,e3
    dd e4,e5,e6,e7
    dd e8,e9,e10,e11
    dd e12,e13,page_fault_handler,e15
 
    dd except_16, e17
    times 14 dd unknown_interrupt
 
    dd   irq0  , irq_serv.irq_1, p_irq2 ,irq_serv.irq_3
    dd   p_irq4 ,irq_serv.irq_5,p_irq6,irq_serv.irq_7
    dd   irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10
    dd   irq_serv.irq_11,p_irq12,irqD ,p_irq14,p_irq15
 
    times 16 dd unknown_interrupt
 
    dd   i40
endg
 
macro save_ring3_context
{
    push    ds es
    pushad
}
macro restore_ring3_context
{
    popad
    pop    es ds
}
 
; simply return control to interrupted process
unknown_interrupt:
     iret
 
macro exc_wo_code [num]
{
  forward
  e#num :
      save_ring3_context
      mov bl, num
      jmp exc_c
}
 
macro exc_w_code [num]
{
  forward
  e#num :
      add esp, 4
      save_ring3_context
      mov bl, num
      jmp exc_c
}
 
exc_wo_code 0, 1, 2, 3, 4, 5, 6, 9, 15 ; 18, 19
exc_w_code 8, 10, 11, 12, 13, 14, 17
 
exc_c:
        mov   ax, os_data
        mov   ds, ax
        mov   es, ax
 
; test if debugging
        cli
        mov   eax, [0x3000]
        shl   eax, 8
        mov   eax, [0x80000+eax+APPDATA.debugger_slot]
        test  eax, eax
        jnz   .debug
        sti
; not debuggee => say error and terminate
        add   esp, 28h
        movzx eax, bl
        mov   [error_interrupt], eax
        call  show_error_parameters
 
        mov   edx, [0x3010]
        mov   [edx + TASKDATA.state], byte 4
 
        jmp   change_task
 
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
        cld
        movzx ecx, bl
        push  ecx
        mov   ecx, [0x3010]
        push  dword [ecx+TASKDATA.pid]    ; PID of current process
        push  12
        pop   ecx
        push  1        ; 1=exception
        call  debugger_notify
        pop   ecx
        pop   ecx
        pop   ecx
        mov   edx, [0x3010]
        mov   byte [edx+TASKDATA.state], 1        ; suspended
        call  change_task
        restore_ring3_context
        iretd
 
;;;;;;;;;;;;;;;;;;;;;;;
;; FPU ERROR HANDLER ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
e7:
        save_ring3_context
        clts
        mov ax, os_data
        mov ds, ax
        mov es, ax
 
        mov ebx, [fpu_owner]
        cmp ebx, [CURRENT_TASK]
        je .exit
 
        shl ebx, 8
        mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
        bt [cpu_caps], CAPS_FXSR
        jnc .no_SSE
 
        fxsave [eax]
        mov ebx, [CURRENT_TASK]
        mov [fpu_owner], ebx
        shl ebx, 8
        cmp dword [ebx+PROC_BASE+APPDATA.fpu_init], 0
        je .init
        mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
        fxrstor [eax]
        restore_ring3_context
        iret
.init:
        fninit                      ;­ ¬ ­¥ ­ã¦­ë ­¥¬ áª¨à®¢ ­­ë¥ ¨áª«îç¥­¨ï
        mov dword [ebx+PROC_BASE+APPDATA.fpu_init], 1
.exit:
        restore_ring3_context
        iret
.no_SSE:
        fnsave [eax]
        mov ebx, [CURRENT_TASK]
        mov [fpu_owner], ebx
        shl ebx, 8
        cmp dword [ebx+PROC_BASE+APPDATA.fpu_init], 0
 
        je .init
 
 
 
 
 
 
 
        mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
        frstor [eax]
        restore_ring3_context
        iret
 
iglobal
  fpu_owner dd 1
 endg
 
 
writehex:
      pusha
 
      mov  edi, [write_error_to]
      mov  esi, 8
    @@:
      mov  ecx, eax
      and  ecx, 0xf
 
      mov  cl,[ecx+hexletters]
      mov  [edi],cl
      dec  edi
 
      shr  eax,4
      dec  esi
      jnz  @b
 
      popa
      ret
 
iglobal
  hexletters  db '0123456789ABCDEF'
 
  error_interrupt         dd  -1
 
  process_error  db 'K : Process - forced terminate INT: 00000000',13,10,0
  process_pid    db 'K : Process - forced terminate PID: 00000000',13,10,0
  process_eip    db 'K : Process - forced terminate EIP: 00000000',13,10,0
  system_error   db 'K : Kernel error',13,10,0
endg
 
uglobal
  write_error_to  dd  0x0
endg
 
show_error_parameters:
 
        mov    [write_error_to],process_pid+43
        mov    eax,[0x3000]
        shl    eax, 5
        mov    eax,[0x3000+TASKDATA.pid+eax]
        call   writehex
 
        mov    [write_error_to],process_error+43
        mov    eax,[error_interrupt]
        call   writehex
 
        cmp    dword [esp+4+4], os_code ; CS
        jnz    @f
        mov    esi,system_error
        call   sys_msg_board_str
      @@:
        mov    eax, [esp+4] ; EIP
 
        mov    [write_error_to],process_eip+43
        call   writehex
 
        mov    esi,process_error
        call   sys_msg_board_str
 
        mov    esi,process_pid
        call   sys_msg_board_str
 
        mov    esi,process_eip
        call   sys_msg_board_str
 
        ret
 
 
 
; irq1  ->  hid/keyboard.inc
 
 
macro irqh [num]
{
  forward
  p_irq#num :
     save_ring3_context
     mov   edi, num
     jmp   irq_c
}
 
irqh 2,5,7,8,9,10,11
 
 irq_c:
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  irqhandler
     restore_ring3_context
     iret
 
p_irq6:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  fdc_irq
     call  ready_for_next_irq
     restore_ring3_context
     iret
 
p_irq3:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com2_mouse_detected],0
     je    old_irq3_handler
     call  check_mouse_data_com2
     jmp   p_irq3_1
 old_irq3_handler:
     mov   edi,3
     call  irqhandler
  p_irq3_1:
     restore_ring3_context
     iret
 
p_irq4:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com1_mouse_detected],0
     je    old_irq4_handler
     call  check_mouse_data_com1
     jmp   p_irq4_1
 old_irq4_handler:
     mov   edi,4
     call  irqhandler
  p_irq4_1:
     restore_ring3_context
     iret
 
p_irq12:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  check_mouse_data_ps2
     restore_ring3_context
     iret
 
p_irq14:
        save_ring3_context
        mov     ax, os_data
        mov     ds, ax
        mov     es, ax
        call    [irq14_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
p_irq15:
        save_ring3_context
        mov     ax, os_data
        mov     ds, ax
        mov     es, ax
        call    [irq15_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
 
ready_for_next_irq:
     mov    [check_idle_semaphore],5
     mov   al, 0x20
     out   0x20, al
     ret
 
ready_for_next_irq_1:
     mov    [check_idle_semaphore],5
     mov   al, 0x20
     out    0xa0,al
     out   0x20, al
     ret
 
irqD:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
 
     mov   dx,0xf0
     mov   al,0
     out   dx,al
 
     mov   dx,0xa0
     mov   al,0x20
     out   dx,al
     mov   dx,0x20
     out   dx,al
 
     restore_ring3_context
 
     iret
 
 
irqhandler:
 
     push   edi
 
     mov    esi,edi          ; 1
     shl    esi,6            ; 1
     add    esi,irq00read    ; 1
     shl    edi,12           ; 1
     add    edi,0x2E0000
     mov    ecx,16
 
     mov    [check_idle_semaphore],5
 
   irqnewread:
     dec    ecx
     js     irqover
 
     mov    dx,[esi]         ; 2+
 
     cmp    dx,0             ; 1
     jz     irqover
     cmp    [esi+3],byte 1   ; 2     ; byte read
     jne    noirqbyte        ; 4-11
 
     in     al,dx
 
     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],al
     inc    edx
     mov    [edi],edx
 
     add    esi,4
     jmp    irqnewread
 
   noirqbyte:
 
 
     cmp    [esi+3],byte 2     ; word read
     jne    noirqword
 
     in     ax,dx
 
     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],ax
     add    edx,2
     mov    [edi],edx
     add    esi,4
     jmp    irqnewread
 
   noirqword:
   irqfull:
   irqover:
 
     mov    al,0x20            ; ready for next irq
     out    0x20,al
 
     pop    ebx
     cmp    ebx,7
     jbe    noa0
     out    0xa0,al
   noa0:
 
     ret
 
 
 
set_application_table_status:
        push eax
 
        mov  eax,[0x3000]
        shl  eax, 5
        add  eax,0x3000+TASKDATA.pid
        mov  eax,[eax]
 
        mov  [application_table_status],eax
 
        pop  eax
 
        ret
 
 
clear_application_table_status:
        push eax
 
        mov  eax,[0x3000]
        shl  eax, 5
        add  eax,0x3000+TASKDATA.pid
        mov  eax,[eax]
 
        cmp  eax,[application_table_status]
        jne  apptsl1
        mov  [application_table_status],0
      apptsl1:
 
        pop  eax
 
        ret
 
 
 
sys_resize_app_memory:
        ; eax = 1 - resize
        ;     ebx = new amount of memory
 
        cmp    eax,1
        jne    .no_application_mem_resize
 
        stdcall new_mem_resize, ebx
        mov [esp+36], eax
        ret
 
 
.no_application_mem_resize:
        ret
 
 
 
get_app_params:
 
    push eax
 
    cmp  [0x90000+6],word '00'
    jne  no_00_header
 
    mov  eax,[0x90000+12]
    mov  [app_start],eax
    mov  eax,[0x90000+16]
    mov  [app_i_end],eax
    mov  eax,[0x90000+20]
    mov  [app_mem],eax
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
    cmp  eax,[app_i_end]
    jb   no_01_header
; \end{diamond}[20.08.2006]
    shr  eax,1
    sub  eax,0x10
    mov  [app_esp],eax
    mov  eax,[0x90000+24]
    mov  [app_i_param],eax
    mov  [app_i_icon],dword 0
 
    pop  eax
    clc
    ret
 
  no_00_header:
 
 
    cmp  [0x90000+6],word '01'
    jne  no_01_header
 
    mov  eax,[0x90000+12]
    mov  [app_start],eax
    mov  eax,[0x90000+16]
    mov  [app_i_end],eax
    mov  eax,[0x90000+20]
    mov  [app_mem],eax
; \begin{diamond}[20.08.2006]
    cmp  eax,[app_i_end]
    jb   no_01_header
; \end{diamond}[20.08.2006]
    mov  eax,[0x90000+24]
    mov  [app_esp],eax
    mov  eax,[0x90000+28]
    mov  [app_i_param],eax
    mov  eax,[0x90000+32]
    mov  [app_i_icon],eax
 
    pop  eax
    clc
    ret
 
   no_01_header:
 
    pop  eax
    stc
    ret
 
 
uglobal
  new_process_place  dd  0x0
  app_start    dd  0x0
  app_i_end    dd  0x0
  app_mem      dd  0x0
  app_esp      dd  0x0
  app_i_param  dd  0x0
  app_i_icon   dd  0x0
;  app_mem_pos  dd  0x0
  appl_path        dd 0x0
  appl_path_size   dd 0x0
endg
 
 
sys_threads:
 
; eax=1 create thread
;
;   ebx=thread start
;   ecx=thread stack value
;
; on return : eax = pid
jmp new_sys_threads
 
iglobal
  process_terminating   db 'K : Process - terminating',13,10,0
  process_terminated    db 'K : Process - done',13,10,0
endg
 
 
terminate: ; terminate application
    push   esi
    mov    esi,process_terminating
    call   sys_msg_board_str
    pop    esi
 
@@:
    cli
    cmp   [application_table_status],0
    je    term9
    sti
    call  change_task
    jmp   @b
  term9:
 
    call  set_application_table_status
 
    mov    eax,esi
 
 
    pushad
    shl   eax,8
    mov   eax,[PROC_BASE+eax+0xB8]
    stdcall destroy_app_space, eax
    popad
 
    cmp   [fpu_owner],esi   ; if user fpu last -> fpu user = 1
    jne   fpu_ok_1
    mov   [fpu_owner],1
  fpu_ok_1:
 
    mov   [0xf400],byte 0           ; empty keyboard buffer
    mov   [0xf500],byte 0           ; empty button buffer
 
 
; remove defined hotkeys
        mov     eax, hotkey_list
.loop:
        cmp     [eax+8], esi
        jnz     .cont
        mov     ecx, [eax]
        jecxz   @f
        push    dword [eax+12]
        pop     dword [ecx+12]
@@:
        mov     ecx, [eax+12]
        push    dword [eax]
        pop     dword [ecx]
        xor     ecx, ecx
        mov     [eax], ecx
        mov     [eax+4], ecx
        mov     [eax+8], ecx
        mov     [eax+12], ecx
.cont:
        add     eax, 16
        cmp     eax, hotkey_list+256*16
        jb      .loop
; remove hotkeys in buffer
        mov     eax, hotkey_buffer
.loop2:
        cmp     [eax], esi
        jnz     .cont2
        and     dword [eax+4], 0
        and     dword [eax], 0
.cont2:
        add     eax, 8
        cmp     eax, hotkey_buffer+120*8
        jb      .loop2
 
    mov   ecx,esi                 ; remove buttons
  bnewba2:
    mov   edi,[0xfe88]
    mov   eax,edi
    cld
    movzx ebx,word [edi]
    inc   bx
  bnewba:
    dec   bx
    jz    bnmba
    add   eax,0x10
    cmp   cx,[eax]
    jnz   bnewba
    pusha
    mov   ecx,ebx
    inc   ecx
    shl   ecx,4
    mov   ebx,eax
    add   eax,0x10
    call  memmove
    dec   dword [edi]
    popa
    jmp   bnewba2
  bnmba:
 
    pusha     ; save window coordinates for window restoring
    cld
    shl   esi,5
    add   esi,window_data
    mov   eax,[esi+WDATA.box.left]
    mov   [dlx],eax
    add   eax,[esi+WDATA.box.width]
    mov   [dlxe],eax
    mov   eax,[esi+WDATA.box.top]
    mov   [dly],eax
    add   eax,[esi+WDATA.box.height]
    mov   [dlye],eax
 
    xor   eax, eax
    mov   [esi+WDATA.box.left],eax
    mov   [esi+WDATA.box.width],eax
    mov   [esi+WDATA.box.top],eax
    mov   [esi+WDATA.box.height],eax
    mov   [esi+WDATA.cl_workarea],eax
    mov   [esi+WDATA.cl_titlebar],eax
    mov   [esi+WDATA.cl_frames],eax
    mov   dword [esi+WDATA.reserved],eax ; clear all flags: wstate, redraw, wdrawn
    lea   edi, [esi-window_data+draw_data]
    mov   ecx,32/4
    rep   stosd
    popa
 
; debuggee test
    pushad
    mov  edi, esi
    shl  edi, 5
    mov  eax, [0x80000+edi*8+APPDATA.debugger_slot]
    test eax, eax
    jz   .nodebug
    push 8
    pop  ecx
    push dword [0x3000+edi+TASKDATA.pid]   ; PID
    push 2
    call debugger_notify
    pop  ecx
    pop  ecx
.nodebug:
    popad
 
    pusha         ; at 0x80000+
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000
    mov   ecx,256/4
    xor   eax, eax
    rep   stosd
    popa
 
    pusha          ; name to spaces
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000+APPDATA.app_name
    mov   ecx,11
    mov   eax,' '
    rep   stosb
    popa
 
 
  ; activate window
        movzx  eax, word [0xC000 + esi*2]
        cmp    eax, [0x3004]
        jne    .dont_activate
        pushad
 .check_next_window:
        dec    eax
        cmp    eax, 1
        jbe    .nothing_to_activate
        lea    esi, [0xc400+eax*2]
        movzx  edi, word [esi]               ; edi = process
        shl    edi, 5
        cmp    [0x3000 + edi + TASKDATA.state], byte 9  ; skip dead slots
        je     .check_next_window
        add    edi, window_data
; \begin{diamond}[19.09.2006]
; skip minimized windows
        test   [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz    .check_next_window
; \end{diamond}
        call   waredraw
 .nothing_to_activate:
        popad
 .dont_activate:
 
        push    esi     ; remove hd1 & cd & flp reservation
        shl     esi, 5
        mov     esi, [esi+0x3000+TASKDATA.pid]
        cmp     [hd1_status], esi
        jnz     @f
        mov     [hd1_status], 0
@@:
        cmp     [cd_status], esi
        jnz     @f
        mov     [cd_status], 0
@@:
        cmp     [flp_status], esi
        jnz     @f
        mov     [flp_status], 0
@@:
        pop     esi
 
    pusha ; remove all irq reservations
    mov   eax,esi
    shl   eax, 5
    mov   eax,[eax+0x3000+TASKDATA.pid]
    mov   edi,irq_owner
    mov   ecx,16
  newirqfree:
    scasd
    jne   nofreeirq
    mov   [edi-4],dword 0
  nofreeirq:
    loop   newirqfree
    popa
 
 
    pusha                     ; remove all port reservations
    mov   edx,esi
    shl   edx, 5
    add   edx,0x3000
    mov   edx,[edx+TASKDATA.pid]
 
  rmpr0:
 
    mov   esi,[0x2d0000]
 
    cmp   esi,0
    je    rmpr9
 
  rmpr3:
 
    mov   edi,esi
    shl   edi,4
    add   edi,0x2d0000
 
    cmp   edx,[edi]
    je    rmpr4
 
    dec   esi
    jnz   rmpr3
 
    jmp   rmpr9
 
  rmpr4:
 
    mov   ecx,256
    sub   ecx,esi
    shl   ecx,4
 
    mov   esi,edi
    add   esi,16
    cld
    rep   movsb
 
    dec   dword [0x2d0000]
 
    jmp   rmpr0
 
  rmpr9:
 
    popa
    mov  edi,esi         ; do not run this process slot
    shl  edi, 5
    mov  [edi+0x3000 + TASKDATA.state],byte 9
; debugger test - terminate all debuggees
    mov  eax, 2
    mov  ecx, 0x80000+2*0x100+APPDATA.debugger_slot
.xd0:
    cmp  eax, [0x3004]
    ja   .xd1
    cmp  dword [ecx], esi
    jnz  @f
    and  dword [ecx], 0
    pushad
    xchg eax, ebx
    mov  eax, 2
    call sys_system
    popad
@@:
    inc  eax
    add  ecx, 0x100
    jmp  .xd0
.xd1:
;    call  systest
    sti  ; .. and life goes on
 
    mov   eax, [dlx]
    mov   ebx, [dly]
    mov   ecx, [dlxe]
    mov   edx, [dlye]
    call  calculatescreen
    xor   eax, eax
    xor   esi, esi
    call  redrawscreen
 
    mov   [0xfff4],byte 0  ; no mouse background
    mov   [0xfff5],byte 0  ; draw mouse
 
    mov   [application_table_status],0
    mov   esi,process_terminated
    call  sys_msg_board_str
 
    ret
 
iglobal
  boot_sched_1    db   'Building gdt tss pointer',0
  boot_sched_2    db   'Building IDT table',0
endg
 
 
build_scheduler:
 
        mov    esi,boot_sched_1
        call   boot_log
        call   build_process_gdt_tss_pointer
 
        mov    esi,boot_sched_2
        call   boot_log
        call   build_interrupt_table
 
        ret

Rev 160	Rev 164
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; MenuetOS process management, protected ring3 ;;	3	;; MenuetOS process management, protected ring3 ;;
4	;; ;;	4	;; ;;
5	;; Distributed under GPL. See file COPYING for details. ;;	5	;; Distributed under GPL. See file COPYING for details. ;;
6	;; Copyright 2003 Ville Turjanmaa ;;	6	;; Copyright 2003 Ville Turjanmaa ;;
7	;; ;;	7	;; ;;
8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	8	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
9		9
10	align 32	10	align 32
11		11
12	; GDT TABLE	12	; GDT TABLE
13		13
14	gdts:	14	gdts:
15		15
16	dw gdte-$-1	16	dw gdte-$-1
17	dd gdts	17	dd gdts
18	dw 0	18	dw 0
19		19
20	int_code_l:	20	int_code_l:
21	os_code_l:	21	os_code_l:
22		22
23	dw 0xffff	23	dw 0xffff
24	dw 0x0000	24	dw 0x0000
25	db 0x00	25	db 0x00
26	dw 11011111b *256 +10011010b	26	dw 11011111b *256 +10011010b
27	db 0x00	27	db 0x00
28		28
29	int_data_l:	29	int_data_l:
30	os_data_l:	30	os_data_l:
31		31
32	dw 0xffff	32	dw 0xffff
33	dw 0x0000	33	dw 0x0000
34	db 0x00	34	db 0x00
35	dw 11011111b *256 +10010010b	35	dw 11011111b *256 +10010010b
36	db 0x00	36	db 0x00
37		37
38	; --------------- APM ---------------------	38	; --------------- APM ---------------------
39	apm_code_32:	39	apm_code_32:
40	dw 0x10 ; limit 64kb	40	dw 0x10 ; limit 64kb
41	db 0, 0, 0	41	db 0, 0, 0
42	dw 11011111b *256 +10011010b	42	dw 11011111b *256 +10011010b
43	db 0x00	43	db 0x00
44	apm_code_16:	44	apm_code_16:
45	dw 0x10	45	dw 0x10
46	db 0, 0, 0	46	db 0, 0, 0
47	dw 10011111b *256 +10011010b	47	dw 10011111b *256 +10011010b
48	db 0x00	48	db 0x00
49	apm_data_16:	49	apm_data_16:
50	dw 0x10	50	dw 0x10
51	db 0, 0, 0	51	db 0, 0, 0
52	dw 10011111b *256 +10010010b	52	dw 10011111b *256 +10010010b
53	db 0x00	53	db 0x00
54	; -----------------------------------------	54	; -----------------------------------------
55		55
56	app_code_l:	56	app_code_l:
57	dw ((0x80000000-std_application_base_address) shr 12) and 0xffff	57	dw 0xFFFF;((0x80000000-std_application_base_address) shr 12) and 0xffff
58	dw 0	58	dw 0
59	db 0	59	db 0x40
60	dw 11010000b256+11111010b+256((0x80000000-std_application_base_address) shr 28)	60	db cpl3
61	db std_application_base_address shr 24	61	dw G32+D32+0x6000+0x7;
62		62
63	app_data_l:	63	app_data_l:
64	dw (0x80000000-std_application_base_address) shr 12 and 0xffff	64	dw 0xFFFF;(0x80000000-std_application_base_address) shr 12 and 0xffff
65	dw 0	65	dw 0
66	db 0	66	db 0x40
67	dw 11010000b256+11110010b+256((0x80000000-std_application_base_address) shr 28)	67	db drw3
68	db std_application_base_address shr 24	68	dw G32+D32+0x6000+0x7;
69		69
70	graph_data_l:	70	graph_data_l:
71		71
72	dw 0x3ff	72	dw 0x3ff
73	dw 0x0000	73	dw 0x0000
74	db 0x00	74	db 0x00
75	dw 11010000b *256 +11110010b	75	dw 11010000b *256 +11110010b
76	db 0x00	76	db 0x00
77		77
78	tss0_l:	78	tss0_l:
79	times (max_processes+10) dd 0,0	79	times (max_processes+10) dd 0,0
80		80
81	gdte:	81	gdte:
82		82
83		-
84		83
85	idtreg:	84	idtreg:
86	dw 8*0x41-1	85	dw 8*0x41-1
87	dd idts+8	86	dd idts+8
88	label idts at 0xB100-8	87	;label idts at 0xB100-8
89		88
90		89
91		90
92	uglobal	91	uglobal
93	tss_sceleton:	92	tss_sceleton:
94	l.back dw 0,0	93	l.back dw 0,0
95	l.esp0 dd 0	94	l.esp0 dd 0
96	l.ss0 dw 0,0	95	l.ss0 dw 0,0
97	l.esp1 dd 0	96	l.esp1 dd 0
98	l.ss1 dw 0,0	97	l.ss1 dw 0,0
99	l.esp2 dd 0	98	l.esp2 dd 0
100	l.ss2 dw 0,0	99	l.ss2 dw 0,0
101	l.cr3 dd 0	100	l.cr3 dd 0
102	l.eip dd 0	101	l.eip dd 0
103	l.eflags dd 0	102	l.eflags dd 0
104	l.eax dd 0	103	l.eax dd 0
105	l.ecx dd 0	104	l.ecx dd 0
106	l.edx dd 0	105	l.edx dd 0
107	l.ebx dd 0	106	l.ebx dd 0
108	l.esp dd 0	107	l.esp dd 0
109	l.ebp dd 0	108	l.ebp dd 0
110	l.esi dd 0	109	l.esi dd 0
111	l.edi dd 0	110	l.edi dd 0
112	l.es dw 0,0	111	l.es dw 0,0
113	l.cs dw 0,0	112	l.cs dw 0,0
114	l.ss dw 0,0	113	l.ss dw 0,0
115	l.ds dw 0,0	114	l.ds dw 0,0
116	l.fs dw 0,0	115	l.fs dw 0,0
117	l.gs dw 0,0	116	l.gs dw 0,0
118	l.ldt dw 0,0	117	l.ldt dw 0,0
119	l.trap dw 0	118	l.trap dw 0
120	l.io dw 0	119	l.io dw 0
121	endg	120	endg
122		121
123		122
124	build_process_gdt_tss_pointer:	123	build_process_gdt_tss_pointer:
125		124
126	mov ecx,tss_data	125	mov ecx,tss_data
127	mov edi,0	126	mov edi,0
128	setgdtl2:	127	setgdtl2:
129	mov [edi+gdts+ tss0 +0], word tss_step	128	mov [edi+gdts+ tss0 +0], word tss_step
130	mov [edi+gdts+ tss0 +2], cx	129	mov [edi+gdts+ tss0 +2], cx
131	mov eax,ecx	130	mov eax,ecx
132	shr eax,16	131	shr eax,16
133	mov [edi+gdts+ tss0 +4], al	132	mov [edi+gdts+ tss0 +4], al
134	mov [edi+gdts+ tss0 +7], ah	133	mov [edi+gdts+ tss0 +7], ah
135	mov [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b	134	mov [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b
136	add ecx,tss_step	135	add ecx,tss_step
137	add edi,8	136	add edi,8
138	cmp edi,8*(max_processes+5)	137	cmp edi,8*(max_processes+5)
139	jbe setgdtl2	138	jbe setgdtl2
140		139
141	ret	140	ret
142		141
143		142
144	build_interrupt_table:	143	build_interrupt_table:
145		144
146	mov edi, idts+8	145	mov edi, idts+8
147	mov esi, sys_int	146	mov esi, sys_int
148	mov ecx, 0x40	147	mov ecx, 0x40
149	@@:	148	@@:
150	mov eax, [esi]	149	mov eax, [esi]
151	mov [edi], ax ; lower part of offset	150	mov [edi], ax ; lower part of offset
152	mov [edi+2], word os_code ; segment selector	151	mov [edi+2], word os_code ; segment selector
153	shr eax, 16	152	shr eax, 16
154	mov [edi+4], word 10001110b shl 8 ; interrupt descriptor	153	mov [edi+4], word 10001110b shl 8 ; interrupt descriptor
155	mov [edi+6], ax	154	mov [edi+6], ax
156	add esi, 4	155	add esi, 4
157	add edi, 8	156	add edi, 8
158	dec ecx	157	dec ecx
159	jnz @b	158	jnz @b
160		159
161	;mov edi,8*0x40+idts+8	160	;mov edi,8*0x40+idts+8
162	mov [edi + 0], word (i40 and ((1 shl 16)-1))	161	mov [edi + 0], word (i40 and ((1 shl 16)-1))
163	mov [edi + 2], word os_code	162	mov [edi + 2], word os_code
164	mov [edi + 4], word 11101110b*256	163	mov [edi + 4], word 11101110b*256
165	mov [edi + 6], word (i40 shr 16)	164	mov [edi + 6], word (i40 shr 16)
166		165
167	ret	166	ret
168		-
169		-
170		167
171	iglobal	168	iglobal
172	sys_int:	169	sys_int:
-		170	dd e0,debug_exc,e2,e3
-		171	dd e4,e5,e6,e7
-		172	dd e8,e9,e10,e11
-		173	dd e12,e13,page_fault_handler,e15
173	dd e0,debug_exc,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15	174
174	dd e16,e17	175	dd except_16, e17
175	times 14 dd unknown_interrupt	176	times 14 dd unknown_interrupt
-		177
-		178	dd irq0 , irq_serv.irq_1, p_irq2 ,irq_serv.irq_3
176		179	dd p_irq4 ,irq_serv.irq_5,p_irq6,irq_serv.irq_7
177	dd irq0 ,irq1 ,p_irq2 ,p_irq3 ,p_irq4 ,p_irq5,p_irq6 ,p_irq7	180	dd irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10
178	dd p_irq8,p_irq9,p_irq10,p_irq11,p_irq12,irqD ,p_irq14,p_irq15	181	dd irq_serv.irq_11,p_irq12,irqD ,p_irq14,p_irq15
179		182
180	times 16 dd unknown_interrupt	183	times 16 dd unknown_interrupt
181		184
182	dd i40	185	dd i40
183	endg	186	endg
184		187
185	macro save_ring3_context	188	macro save_ring3_context
186	{	189	{
187	push ds es	190	push ds es
188	pushad	191	pushad
189	}	192	}
190	macro restore_ring3_context	193	macro restore_ring3_context
191	{	194	{
192	popad	195	popad
193	pop es ds	196	pop es ds
194	}	197	}
195		198
196	; simply return control to interrupted process	199	; simply return control to interrupted process
197	unknown_interrupt:	200	unknown_interrupt:
198	iret	201	iret
199		202
200	macro exc_wo_code [num]	203	macro exc_wo_code [num]
201	{	204	{
202	forward	205	forward
203	e#num :	206	e#num :
204	save_ring3_context	207	save_ring3_context
205	mov bl, num	208	mov bl, num
206	jmp exc_c	209	jmp exc_c
207	}	210	}
208		211
209	macro exc_w_code [num]	212	macro exc_w_code [num]
210	{	213	{
211	forward	214	forward
212	e#num :	215	e#num :
213	add esp, 4	216	add esp, 4
214	save_ring3_context	217	save_ring3_context
215	mov bl, num	218	mov bl, num
216	jmp exc_c	219	jmp exc_c
217	}	220	}
218		221
219	exc_wo_code 0, 1, 2, 3, 4, 5, 6, 9, 15, 16 ; 18, 19	222	exc_wo_code 0, 1, 2, 3, 4, 5, 6, 9, 15 ; 18, 19
220	exc_w_code 8, 10, 11, 12, 13, 14, 17	223	exc_w_code 8, 10, 11, 12, 13, 14, 17
221		224
222	exc_c:	225	exc_c:
223	mov ax, os_data	226	mov ax, os_data
224	mov ds, ax	227	mov ds, ax
225	mov es, ax	228	mov es, ax
226		229
227	; test if debugging	230	; test if debugging
228	cli	231	cli
229	mov eax, [0x3000]	232	mov eax, [0x3000]
230	shl eax, 8	233	shl eax, 8
231	mov eax, [0x80000+eax+APPDATA.debugger_slot]	234	mov eax, [0x80000+eax+APPDATA.debugger_slot]
232	test eax, eax	235	test eax, eax
233	jnz .debug	236	jnz .debug
234	sti	237	sti
235	; not debuggee => say error and terminate	238	; not debuggee => say error and terminate
236	add esp, 28h	239	add esp, 28h
237	movzx eax, bl	240	movzx eax, bl
238	mov [error_interrupt], eax	241	mov [error_interrupt], eax
239	call show_error_parameters	242	call show_error_parameters
240		243
241	mov edx, [0x3010]	244	mov edx, [0x3010]
242	mov [edx + TASKDATA.state], byte 4	245	mov [edx + TASKDATA.state], byte 4
243		246
244	jmp change_task	247	jmp change_task
245		248
246	.debug:	249	.debug:
247	; we are debugged process, notify debugger and suspend ourself	250	; we are debugged process, notify debugger and suspend ourself
248	; eax=debugger PID	251	; eax=debugger PID
249	cld	252	cld
250	movzx ecx, bl	253	movzx ecx, bl
251	push ecx	254	push ecx
252	mov ecx, [0x3010]	255	mov ecx, [0x3010]
253	push dword [ecx+TASKDATA.pid] ; PID of current process	256	push dword [ecx+TASKDATA.pid] ; PID of current process
254	push 12	257	push 12
255	pop ecx	258	pop ecx
256	push 1 ; 1=exception	259	push 1 ; 1=exception
257	call debugger_notify	260	call debugger_notify
258	pop ecx	261	pop ecx
259	pop ecx	262	pop ecx
260	pop ecx	263	pop ecx
261	mov edx, [0x3010]	264	mov edx, [0x3010]
262	mov byte [edx+TASKDATA.state], 1 ; suspended	265	mov byte [edx+TASKDATA.state], 1 ; suspended
263	call change_task	266	call change_task
264	restore_ring3_context	267	restore_ring3_context
265	iretd	268	iretd
266		269
267	;;;;;;;;;;;;;;;;;;;;;;;	270	;;;;;;;;;;;;;;;;;;;;;;;
268	;; FPU ERROR HANDLER ;;	271	;; FPU ERROR HANDLER ;;
269	;;;;;;;;;;;;;;;;;;;;;;;	272	;;;;;;;;;;;;;;;;;;;;;;;
270		273
271	align 4	274	align 4
272	e7:	275	e7:
273	save_ring3_context	276	save_ring3_context
274	clts	277	clts
275	mov ax, os_data	278	mov ax, os_data
276	mov ds, ax	279	mov ds, ax
277	mov es, ax	280	mov es, ax
278		281
-		282	mov ebx, [fpu_owner]
-		283	cmp ebx, [CURRENT_TASK]
-		284	je .exit
-		285
-		286	shl ebx, 8
-		287	mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
-		288	bt [cpu_caps], CAPS_FXSR
-		289	jnc .no_SSE
-		290
-		291	fxsave [eax]
-		292	mov ebx, [CURRENT_TASK]
279	mov eax, [prev_user_of_fpu]	293	mov [fpu_owner], ebx
-		294	shl ebx, 8
-		295	cmp dword [ebx+PROC_BASE+APPDATA.fpu_init], 0
280	shl eax, 8	296	je .init
-		297	mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
-		298	fxrstor [eax]
-		299	restore_ring3_context
-		300	iret
-		301	.init:
-		302	fninit ; ¬ ¥ ã¦ë ¥¬ áª¨à®¢ ë¥ ¨áª«îç¥¨ï
-		303	mov dword [ebx+PROC_BASE+APPDATA.fpu_init], 1
-		304	.exit:
-		305	restore_ring3_context
-		306	iret
281	add eax, 0x80000 + APPDATA.fpu_save_area	307	.no_SSE:
-		308	fnsave [eax]
-		309	mov ebx, [CURRENT_TASK]
-		310	mov [fpu_owner], ebx
-		311	shl ebx, 8
-		312	cmp dword [ebx+PROC_BASE+APPDATA.fpu_init], 0
282	fsave [eax]	-
283		313	je .init
284	mov eax, [0x3000]	314
285	mov [prev_user_of_fpu], eax	-
286	shl eax, 8	-
287	add eax, 0x80000	-
288	cmp [eax + APPDATA.is_fpu_saved], 0	-
289	je @f	-
290	frstor [eax+APPDATA.fpu_save_area]	-
291	@@:	315	mov eax, [ebx+PROC_BASE+APPDATA.fpu_state]
292	mov [eax + APPDATA.is_fpu_saved], 1	316	frstor [eax]
293	restore_ring3_context	317	restore_ring3_context
294	iret	318	iret
295		319
296	iglobal	320	iglobal
297	prev_user_of_fpu dd 1	321	fpu_owner dd 1
298	endg	322	endg
299		323
300		324
301	writehex:	325	writehex:
302	pusha	326	pusha
303		327
304	mov edi, [write_error_to]	328	mov edi, [write_error_to]
305	mov esi, 8	329	mov esi, 8
306	@@:	330	@@:
307	mov ecx, eax	331	mov ecx, eax
308	and ecx, 0xf	332	and ecx, 0xf
309		333
310	mov cl,[ecx+hexletters]	334	mov cl,[ecx+hexletters]
311	mov [edi],cl	335	mov [edi],cl
312	dec edi	336	dec edi
313		337
314	shr eax,4	338	shr eax,4
315	dec esi	339	dec esi
316	jnz @b	340	jnz @b
317		341
318	popa	342	popa
319	ret	343	ret
320		344
321	iglobal	345	iglobal
322	hexletters db '0123456789ABCDEF'	346	hexletters db '0123456789ABCDEF'
323		347
324	error_interrupt dd -1	348	error_interrupt dd -1
325		349
326	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0	350	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0
327	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0	351	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0
328	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0	352	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0
329	system_error db 'K : Kernel error',13,10,0	353	system_error db 'K : Kernel error',13,10,0
330	endg	354	endg
331		355
332	uglobal	356	uglobal
333	write_error_to dd 0x0	357	write_error_to dd 0x0
334	endg	358	endg
335		359
336	show_error_parameters:	360	show_error_parameters:
337		361
338	mov [write_error_to],process_pid+43	362	mov [write_error_to],process_pid+43
339	mov eax,[0x3000]	363	mov eax,[0x3000]
340	shl eax, 5	364	shl eax, 5
341	mov eax,[0x3000+TASKDATA.pid+eax]	365	mov eax,[0x3000+TASKDATA.pid+eax]
342	call writehex	366	call writehex
343		367
344	mov [write_error_to],process_error+43	368	mov [write_error_to],process_error+43
345	mov eax,[error_interrupt]	369	mov eax,[error_interrupt]
346	call writehex	370	call writehex
347		371
348	cmp dword [esp+4+4], os_code ; CS	372	cmp dword [esp+4+4], os_code ; CS
349	jnz @f	373	jnz @f
350	mov esi,system_error	374	mov esi,system_error
351	call sys_msg_board_str	375	call sys_msg_board_str
352	@@:	376	@@:
353	mov eax, [esp+4] ; EIP	377	mov eax, [esp+4] ; EIP
354		378
355	mov [write_error_to],process_eip+43	379	mov [write_error_to],process_eip+43
356	call writehex	380	call writehex
357		381
358	mov esi,process_error	382	mov esi,process_error
359	call sys_msg_board_str	383	call sys_msg_board_str
360		384
361	mov esi,process_pid	385	mov esi,process_pid
362	call sys_msg_board_str	386	call sys_msg_board_str
363		387
364	mov esi,process_eip	388	mov esi,process_eip
365	call sys_msg_board_str	389	call sys_msg_board_str
366		390
367	ret	391	ret
368		392
369		393
370		394
371	; irq1 -> hid/keyboard.inc	395	; irq1 -> hid/keyboard.inc
372		396
373		397
374	macro irqh [num]	398	macro irqh [num]
375	{	399	{
376	forward	400	forward
377	p_irq#num :	401	p_irq#num :
378	save_ring3_context	402	save_ring3_context
379	mov edi, num	403	mov edi, num
380	jmp irq_c	404	jmp irq_c
381	}	405	}
382		406
383	irqh 2,5,7,8,9,10,11	407	irqh 2,5,7,8,9,10,11
384		408
385	irq_c:	409	irq_c:
386	mov ax, os_data	410	mov ax, os_data
387	mov ds, ax	411	mov ds, ax
388	mov es, ax	412	mov es, ax
389	call irqhandler	413	call irqhandler
390	restore_ring3_context	414	restore_ring3_context
391	iret	415	iret
392		416
393	p_irq6:	417	p_irq6:
394	save_ring3_context	418	save_ring3_context
395	mov ax, os_data	419	mov ax, os_data
396	mov ds, ax	420	mov ds, ax
397	mov es, ax	421	mov es, ax
398	call fdc_irq	422	call fdc_irq
399	call ready_for_next_irq	423	call ready_for_next_irq
400	restore_ring3_context	424	restore_ring3_context
401	iret	425	iret
402		426
403	p_irq3:	427	p_irq3:
404	save_ring3_context	428	save_ring3_context
405	mov ax, os_data	429	mov ax, os_data
406	mov ds, ax	430	mov ds, ax
407	mov es, ax	431	mov es, ax
408	cmp [com2_mouse_detected],0	432	cmp [com2_mouse_detected],0
409	je old_irq3_handler	433	je old_irq3_handler
410	call check_mouse_data_com2	434	call check_mouse_data_com2
411	jmp p_irq3_1	435	jmp p_irq3_1
412	old_irq3_handler:	436	old_irq3_handler:
413	mov edi,3	437	mov edi,3
414	call irqhandler	438	call irqhandler
415	p_irq3_1:	439	p_irq3_1:
416	restore_ring3_context	440	restore_ring3_context
417	iret	441	iret
418		442
419	p_irq4:	443	p_irq4:
420	save_ring3_context	444	save_ring3_context
421	mov ax, os_data	445	mov ax, os_data
422	mov ds, ax	446	mov ds, ax
423	mov es, ax	447	mov es, ax
424	cmp [com1_mouse_detected],0	448	cmp [com1_mouse_detected],0
425	je old_irq4_handler	449	je old_irq4_handler
426	call check_mouse_data_com1	450	call check_mouse_data_com1
427	jmp p_irq4_1	451	jmp p_irq4_1
428	old_irq4_handler:	452	old_irq4_handler:
429	mov edi,4	453	mov edi,4
430	call irqhandler	454	call irqhandler
431	p_irq4_1:	455	p_irq4_1:
432	restore_ring3_context	456	restore_ring3_context
433	iret	457	iret
434		458
435	p_irq12:	459	p_irq12:
436	save_ring3_context	460	save_ring3_context
437	mov ax, os_data	461	mov ax, os_data
438	mov ds, ax	462	mov ds, ax
439	mov es, ax	463	mov es, ax
440	call check_mouse_data_ps2	464	call check_mouse_data_ps2
441	restore_ring3_context	465	restore_ring3_context
442	iret	466	iret
443		467
444	p_irq14:	468	p_irq14:
445	save_ring3_context	469	save_ring3_context
446	mov ax, os_data	470	mov ax, os_data
447	mov ds, ax	471	mov ds, ax
448	mov es, ax	472	mov es, ax
449	call [irq14_func]	473	call [irq14_func]
450	call ready_for_next_irq_1	474	call ready_for_next_irq_1
451	restore_ring3_context	475	restore_ring3_context
452	iret	476	iret
453	p_irq15:	477	p_irq15:
454	save_ring3_context	478	save_ring3_context
455	mov ax, os_data	479	mov ax, os_data
456	mov ds, ax	480	mov ds, ax
457	mov es, ax	481	mov es, ax
458	call [irq15_func]	482	call [irq15_func]
459	call ready_for_next_irq_1	483	call ready_for_next_irq_1
460	restore_ring3_context	484	restore_ring3_context
461	iret	485	iret
462		486
463	ready_for_next_irq:	487	ready_for_next_irq:
464	mov [check_idle_semaphore],5	488	mov [check_idle_semaphore],5
465	mov al, 0x20	489	mov al, 0x20
466	out 0x20, al	490	out 0x20, al

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/sys32.inc @ 2971 – Rev 160 → 164