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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 203 → 214