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                               ;;
;;                                                               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
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
 
app_code_l:
      dw ((0x80000000-std_application_base_address) shr 12) and 0xffff
      dw 0
      db 0
      dw 11010000b*256+11111010b+256*((0x80000000-std_application_base_address) shr 28)
      db std_application_base_address shr 24
 
app_data_l:
      dw (0x80000000-std_application_base_address) shr 12 and 0xffff
      dw 0
      db 0
      dw 11010000b*256+11110010b+256*((0x80000000-std_application_base_address) shr 28)
      db std_application_base_address shr 24
 
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,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15
    dd   e16,e17
    times 14 dd unknown_interrupt
 
    dd   irq0  ,irq1  ,p_irq2 ,p_irq3 ,p_irq4 ,p_irq5,p_irq6 ,p_irq7
    dd   p_irq8,p_irq9,p_irq10,p_irq11,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, 16 ; 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+0xAC]
        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 + 0xA], byte 4
        
        jmp   change_task
 
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
        movzx ecx, bl
        push  ecx
        mov   ecx, [0x3010]
        push  dword [ecx+4]    ; 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+0xA], 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   eax, [prev_user_of_fpu]
        shl   eax, 8
        add   eax, 0x80000 + 0x10
        fsave [eax]
        
        mov   eax, [0x3000]
        mov   [prev_user_of_fpu], eax
        shl   eax, 8
        add   eax, 0x80000
        cmp   [eax + 0x7f], byte 0
        je    @f
        frstor [eax+0x10]
     @@:
        mov   [eax + 0x7f], byte 1
        restore_ring3_context
        iret
        
iglobal
  prev_user_of_fpu 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+4+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,14,15
 
 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
 
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    [check_idle_semaphore],5
 
   irqnewread:
 
     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+4
        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+4
        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
        
        jmp    new_mem_resize ;resize for new type of processes
 
 
     .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
    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
    mov  esi,1
    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
    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
    mov  esi,1
    ret
 
   no_01_header:
 
    pop  eax
    mov  esi,0
    ret
 
 
start_application_fl:
    jmp new_start_application_fl
 
;************************************************************************
 
start_application_floppy:
    jmp  new_start_application_floppy
 
;********************************************************************
 
start_application_hd:
    jmp   new_start_application_hd
 
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
 
iglobal
  hd_app_string      db  'HDAPP       '
  process_loading    db 'K : Process - loading ',13,10,0
  process_running    db 'K : Process - done',13,10,0
  first_gdt_search   dd 0x2
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
    call   dispose_app_cr3_table
 
    cmp   [prev_user_of_fpu],esi   ; if user fpu last -> fpu user = 1
    jne   fpu_ok_1
    mov   [prev_user_of_fpu],1
  fpu_ok_1:
 
    mov   [0xf400],byte 0           ; empty keyboard buffer
    mov   [0xf500],byte 0           ; empty button buffer
 
 
    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   ax,[esi+0]
    mov   word [dlx],ax
    mov   bx,[esi+8]
    add   ax,bx
    mov   word [dlxe],ax
    mov   ax,[esi+4]
    mov   word [dly],ax
    mov   bx,[esi+12]
    add   ax,bx
    mov   word [dlye],ax
    mov   [esi+0],word 0
    mov   [esi+8],word 5
    mov   ax,[0xFE04]
    mov   [esi+4],ax
    mov   [esi+12],word 5
    xor   eax, eax
    mov   [esi+16],eax;dword 0
    mov   [esi+20],eax;dword 0
    mov   [esi+24],eax;dword 0
    mov   [esi+28],eax;dword 0
    popa
 
    pusha
    mov   edi,esi
    shl   edi,5
    add   edi,window_data
    mov   ecx,32/4
    xor   eax, eax
  ;  cld
    rep   stosd
 
    mov   eax,[0xFE04]      ; set window to start from maxy+1
    add   eax,2
 
    mov   edi,esi
    shl   edi,5
    add   edi,window_data
    mov   [edi+4],eax
 
    popa
 
    pusha
    mov   edi,esi
    shl   edi,5
    add   edi,draw_data
    mov   ecx,32/4
    xor   eax, eax
  ;  cld
    rep   stosd
    popa
 
; debuggee test
    pushad
    mov  edi, esi
    shl  edi, 5
    mov  eax, [0x80000+edi*8+0xAC]
    test eax, eax
    jz   .nodebug
    push 8
    pop  ecx
    push dword [0x3000+edi+0x4]   ; 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
  ;  cld
    rep   stosd
    popa
 
    pusha          ; name to spaces
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000
    mov   ecx,11
    mov   eax,' '
  ;  cld
    rep   stosb
    popa
 
    pusha                ; C000 --> C400
    mov   eax, 0xc000
    mov   esi, 0
  nlc40:
    add   eax, 2
    inc   esi
    cmp   esi, [0x3004]
    jae   nlc41
    movzx ecx, word [eax]
    mov   [0xC400 + ecx*2], si
    jmp   nlc40
  nlc41:
    popa
 
    pusha ; remove hd1 reservation
    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]
    cmp   [hd1_status],edx
    jne   no_hd1_s_remove
    mov   [hd1_status],0
  no_hd1_s_remove:
    popa
 
    pusha ; remove all irq reservations
    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]
    mov   edi,irq_owner
    mov   ecx,16
  newirqfree:
    cmp   [edi],edx
    jne   nofreeirq
    mov   [edi],dword 0
  nofreeirq:
    add    edi,4
    loop   newirqfree
    popa
 
 
    pusha                     ; remove all port reservations
    mov   [deleted_process],esi
    mov   edx,esi
    shl   edx, 5 ;imul  edx,0x20
    add   edx,0x3000
    mov   edx,[edx+4]
 
  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+0x300A],byte 9
; debugger test - terminate all debuggees
    mov  eax, 2
    mov  ecx, 0x80000+2*0x100+0xAC
.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
 
;    movzx eax,word [dlx]
;    movzx ebx,word [dly]
;    movzx ecx,word [dlxe]
;    movzx edx,word [dlye]
    call  calculatescreen
    cli
    mov  eax,[deleted_process]
    cmp  eax,[active_process]
    jne  no_activate_process
    call read_active_process_stack
  no_activate_process:
    sti
    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
 
save_active_process_stack:
    cmp   [active_proc_stack_coun],0xa400+0x400-4
    jne   @f
    mov   [active_proc_stack_coun],0xa400-4
  @@:
    push  eax
    push  ebx
    mov   eax,[active_process]
    shl   eax,5
    add   eax,0x3000
    mov   [eax-twdw+31],byte 1
    add   [active_proc_stack_coun],4
    mov   eax,[active_process]
    mov   ebx,[active_proc_stack_coun]
    mov   [ebx],eax
    pop   ebx
    pop   eax
    ret
 
read_active_process_stack:
    cmp   [active_proc_stack_coun],0xa400-4
    jne   @f
    mov   [active_proc_stack_coun],0xa400+0x400-4
  @@:
    push  eax
    push  ebx
    mov   ebx,[active_proc_stack_coun]
    mov   eax,[ebx]
    mov   [0xff01],eax     ; activate
    sub   [active_proc_stack_coun],4
    mov   [active_process_flag],1
    pop   ebx
    pop   eax
    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 58	Rev 66
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	app_code_l:	38	app_code_l:
39	dw ((0x80000000-std_application_base_address) shr 12) and 0xffff	39	dw ((0x80000000-std_application_base_address) shr 12) and 0xffff
40	dw 0	40	dw 0
41	db 0	41	db 0
42	dw 11010000b256+11111010b+256((0x80000000-std_application_base_address) shr 28)	42	dw 11010000b256+11111010b+256((0x80000000-std_application_base_address) shr 28)
43	db std_application_base_address shr 24	43	db std_application_base_address shr 24
44		44
45	app_data_l:	45	app_data_l:
46	dw (0x80000000-std_application_base_address) shr 12 and 0xffff	46	dw (0x80000000-std_application_base_address) shr 12 and 0xffff
47	dw 0	47	dw 0
48	db 0	48	db 0
49	dw 11010000b256+11110010b+256((0x80000000-std_application_base_address) shr 28)	49	dw 11010000b256+11110010b+256((0x80000000-std_application_base_address) shr 28)
50	db std_application_base_address shr 24	50	db std_application_base_address shr 24
51		51
52	graph_data_l:	52	graph_data_l:
53		53
54	dw 0x3ff	54	dw 0x3ff
55	dw 0x0000	55	dw 0x0000
56	db 0x00	56	db 0x00
57	dw 11010000b *256 +11110010b	57	dw 11010000b *256 +11110010b
58	db 0x00	58	db 0x00
59		59
60	tss0_l:	60	tss0_l:
61	times (max_processes+10) dd 0,0	61	times (max_processes+10) dd 0,0
62		62
63	gdte:	63	gdte:
64		64
65		65
66		66
67	idtreg:	67	idtreg:
68	dw 8*0x41-1	68	dw 8*0x41-1
69	dd idts+8	69	dd idts+8
70	label idts at 0xB100-8	70	label idts at 0xB100-8
71		71
72		72
73		73
74	uglobal	74	uglobal
75	tss_sceleton:	75	tss_sceleton:
76	l.back dw 0,0	76	l.back dw 0,0
77	l.esp0 dd 0	77	l.esp0 dd 0
78	l.ss0 dw 0,0	78	l.ss0 dw 0,0
79	l.esp1 dd 0	79	l.esp1 dd 0
80	l.ss1 dw 0,0	80	l.ss1 dw 0,0
81	l.esp2 dd 0	81	l.esp2 dd 0
82	l.ss2 dw 0,0	82	l.ss2 dw 0,0
83	l.cr3 dd 0	83	l.cr3 dd 0
84	l.eip dd 0	84	l.eip dd 0
85	l.eflags dd 0	85	l.eflags dd 0
86	l.eax dd 0	86	l.eax dd 0
87	l.ecx dd 0	87	l.ecx dd 0
88	l.edx dd 0	88	l.edx dd 0
89	l.ebx dd 0	89	l.ebx dd 0
90	l.esp dd 0	90	l.esp dd 0
91	l.ebp dd 0	91	l.ebp dd 0
92	l.esi dd 0	92	l.esi dd 0
93	l.edi dd 0	93	l.edi dd 0
94	l.es dw 0,0	94	l.es dw 0,0
95	l.cs dw 0,0	95	l.cs dw 0,0
96	l.ss dw 0,0	96	l.ss dw 0,0
97	l.ds dw 0,0	97	l.ds dw 0,0
98	l.fs dw 0,0	98	l.fs dw 0,0
99	l.gs dw 0,0	99	l.gs dw 0,0
100	l.ldt dw 0,0	100	l.ldt dw 0,0
101	l.trap dw 0	101	l.trap dw 0
102	l.io dw 0	102	l.io dw 0
103	endg	103	endg
104		104
105		105
106	build_process_gdt_tss_pointer:	106	build_process_gdt_tss_pointer:
107		107
108	mov ecx,tss_data	108	mov ecx,tss_data
109	mov edi,0	109	mov edi,0
110	setgdtl2:	110	setgdtl2:
111	mov [edi+gdts+ tss0 +0], word tss_step	111	mov [edi+gdts+ tss0 +0], word tss_step
112	mov [edi+gdts+ tss0 +2], cx	112	mov [edi+gdts+ tss0 +2], cx
113	mov eax,ecx	113	mov eax,ecx
114	shr eax,16	114	shr eax,16
115	mov [edi+gdts+ tss0 +4], al	115	mov [edi+gdts+ tss0 +4], al
116	mov [edi+gdts+ tss0 +7], ah	116	mov [edi+gdts+ tss0 +7], ah
117	mov [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b	117	mov [edi+gdts+ tss0 +5], word 01010000b *256 +11101001b
118	add ecx,tss_step	118	add ecx,tss_step
119	add edi,8	119	add edi,8
120	cmp edi,8*(max_processes+5)	120	cmp edi,8*(max_processes+5)
121	jbe setgdtl2	121	jbe setgdtl2
122		122
123	ret	123	ret
124		124
125		125
126	build_interrupt_table:	126	build_interrupt_table:
127		127
128	mov edi, idts+8	128	mov edi, idts+8
129	mov esi, sys_int	129	mov esi, sys_int
130	mov ecx, 0x40	130	mov ecx, 0x40
131	@@:	131	@@:
132	mov eax, [esi]	132	mov eax, [esi]
133	mov [edi], ax ; lower part of offset	133	mov [edi], ax ; lower part of offset
134	mov [edi+2], word os_code ; segment selector	134	mov [edi+2], word os_code ; segment selector
135	shr eax, 16	135	shr eax, 16
136	mov [edi+4], word 10001110b shl 8 ; interrupt descriptor	136	mov [edi+4], word 10001110b shl 8 ; interrupt descriptor
137	mov [edi+6], ax	137	mov [edi+6], ax
138	add esi, 4	138	add esi, 4
139	add edi, 8	139	add edi, 8
140	dec ecx	140	dec ecx
141	jnz @b	141	jnz @b
142		142
143	;mov edi,8*0x40+idts+8	143	;mov edi,8*0x40+idts+8
144	mov [edi + 0], word (i40 and ((1 shl 16)-1))	144	mov [edi + 0], word (i40 and ((1 shl 16)-1))
145	mov [edi + 2], word os_code	145	mov [edi + 2], word os_code
146	mov [edi + 4], word 11101110b*256	146	mov [edi + 4], word 11101110b*256
147	mov [edi + 6], word (i40 shr 16)	147	mov [edi + 6], word (i40 shr 16)
148		148
149	ret	149	ret
150		150
151		151
152		152
153	iglobal	153	iglobal
154	sys_int:	154	sys_int:
155	dd e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15	155	dd e0,debug_exc,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15
156	dd e16,e17	156	dd e16,e17
157	times 14 dd unknown_interrupt	157	times 14 dd unknown_interrupt
158		158
159	dd irq0 ,irq1 ,p_irq2 ,p_irq3 ,p_irq4 ,p_irq5,p_irq6 ,p_irq7	159	dd irq0 ,irq1 ,p_irq2 ,p_irq3 ,p_irq4 ,p_irq5,p_irq6 ,p_irq7
160	dd p_irq8,p_irq9,p_irq10,p_irq11,p_irq12,irqD ,p_irq14,p_irq15	160	dd p_irq8,p_irq9,p_irq10,p_irq11,p_irq12,irqD ,p_irq14,p_irq15
161		161
162	times 16 dd unknown_interrupt	162	times 16 dd unknown_interrupt
163		163
164	dd i40	164	dd i40
165	endg	165	endg
166		166
167	macro save_ring3_context	167	macro save_ring3_context
168	{	168	{
169	push ds es	169	push ds es
170	pushad	170	pushad
171	}	171	}
172	macro restore_ring3_context	172	macro restore_ring3_context
173	{	173	{
174	popad	174	popad
175	pop es ds	175	pop es ds
176	}	176	}
177		177
178	; simply return control to interrupted process	178	; simply return control to interrupted process
179	unknown_interrupt:	179	unknown_interrupt:
180	iret	180	iret
181		181
182	macro exc_wo_code [num]	182	macro exc_wo_code [num]
183	{	183	{
184	forward	184	forward
185	e#num :	185	e#num :
186	save_ring3_context	186	save_ring3_context
187	mov bl, num	187	mov bl, num
188	jmp exc_c	188	jmp exc_c
189	}	189	}
190		190
191	macro exc_w_code [num]	191	macro exc_w_code [num]
192	{	192	{
193	forward	193	forward
194	e#num :	194	e#num :
195	add esp, 4	195	add esp, 4
196	save_ring3_context	196	save_ring3_context
197	mov bl, num	197	mov bl, num
198	jmp exc_c	198	jmp exc_c
199	}	199	}
200		200
201	exc_wo_code 0, 1, 2, 3, 4, 5, 6, 9, 15, 16 ; 18, 19	201	exc_wo_code 0, 1, 2, 3, 4, 5, 6, 9, 15, 16 ; 18, 19
202	exc_w_code 8, 10, 11, 12, 13, 14, 17	202	exc_w_code 8, 10, 11, 12, 13, 14, 17
203		203
204	exc_c:	204	exc_c:
205	mov ax, os_data	205	mov ax, os_data
206	mov ds, ax	206	mov ds, ax
207	mov es, ax	207	mov es, ax
208		208
209	; test if debugging	209	; test if debugging
210	cli	210	cli
211	mov eax, [0x3000]	211	mov eax, [0x3000]
212	shl eax, 8	212	shl eax, 8
213	mov eax, [0x80000+eax+0xAC]	213	mov eax, [0x80000+eax+0xAC]
214	test eax, eax	214	test eax, eax
215	jnz .debug	215	jnz .debug
216	sti	216	sti
217	; not debuggee => say error and terminate	217	; not debuggee => say error and terminate
218	add esp, 28h	218	add esp, 28h
219	movzx eax, bl	219	movzx eax, bl
220	mov [error_interrupt], eax	220	mov [error_interrupt], eax
221	call show_error_parameters	221	call show_error_parameters
222		222
223	mov edx, [0x3010]	223	mov edx, [0x3010]
224	mov [edx + 0xA], byte 4	224	mov [edx + 0xA], byte 4
225		225
226	jmp change_task	226	jmp change_task
227		227
228	.debug:	228	.debug:
229	; we are debugged process, notify debugger and suspend ourself	229	; we are debugged process, notify debugger and suspend ourself
230	; eax=debugger PID	230	; eax=debugger PID
231	movzx ecx, bl	231	movzx ecx, bl
232	push ecx	232	push ecx
233	mov ecx, [0x3010]	233	mov ecx, [0x3010]
234	push dword [ecx+4] ; PID of current process	234	push dword [ecx+4] ; PID of current process
235	push 12	235	push 12
236	pop ecx	236	pop ecx
237	push 1 ; 1=exception	237	push 1 ; 1=exception
238	call debugger_notify	238	call debugger_notify
239	pop ecx	239	pop ecx
240	pop ecx	240	pop ecx
241	pop ecx	241	pop ecx
242	mov edx, [0x3010]	242	mov edx, [0x3010]
243	mov byte [edx+0xA], 1 ; suspended	243	mov byte [edx+0xA], 1 ; suspended
244	call change_task	244	call change_task
245	restore_ring3_context	245	restore_ring3_context
246	iretd	246	iretd
247		247
248	;;;;;;;;;;;;;;;;;;;;;;;	248	;;;;;;;;;;;;;;;;;;;;;;;
249	;; FPU ERROR HANDLER ;;	249	;; FPU ERROR HANDLER ;;
250	;;;;;;;;;;;;;;;;;;;;;;;	250	;;;;;;;;;;;;;;;;;;;;;;;
251		251
252	align 4	252	align 4
253	e7:	253	e7:
254	save_ring3_context	254	save_ring3_context
255	clts	255	clts
256	mov ax, os_data	256	mov ax, os_data
257	mov ds, ax	257	mov ds, ax
258	mov es, ax	258	mov es, ax
259		259
260	mov eax, [prev_user_of_fpu]	260	mov eax, [prev_user_of_fpu]
261	shl eax, 8	261	shl eax, 8
262	add eax, 0x80000 + 0x10	262	add eax, 0x80000 + 0x10
263	fsave [eax]	263	fsave [eax]
264		264
265	mov eax, [0x3000]	265	mov eax, [0x3000]
266	mov [prev_user_of_fpu], eax	266	mov [prev_user_of_fpu], eax
267	shl eax, 8	267	shl eax, 8
268	add eax, 0x80000	268	add eax, 0x80000
269	cmp [eax + 0x7f], byte 0	269	cmp [eax + 0x7f], byte 0
270	je @f	270	je @f
271	frstor [eax+0x10]	271	frstor [eax+0x10]
272	@@:	272	@@:
273	mov [eax + 0x7f], byte 1	273	mov [eax + 0x7f], byte 1
274	restore_ring3_context	274	restore_ring3_context
275	iret	275	iret
276		276
277	iglobal	277	iglobal
278	prev_user_of_fpu dd 1	278	prev_user_of_fpu dd 1
279	endg	279	endg
280		280
281		281
282	writehex:	282	writehex:
283	pusha	283	pusha
284		284
285	mov edi, [write_error_to]	285	mov edi, [write_error_to]
286	mov esi, 8	286	mov esi, 8
287	@@:	287	@@:
288	mov ecx, eax	288	mov ecx, eax
289	and ecx, 0xf	289	and ecx, 0xf
290		290
291	mov cl,[ecx+hexletters]	291	mov cl,[ecx+hexletters]
292	mov [edi],cl	292	mov [edi],cl
293	dec edi	293	dec edi
294		294
295	shr eax,4	295	shr eax,4
296	dec esi	296	dec esi
297	jnz @b	297	jnz @b
298		298
299	popa	299	popa
300	ret	300	ret
301		301
302	iglobal	302	iglobal
303	hexletters db '0123456789ABCDEF'	303	hexletters db '0123456789ABCDEF'
304		304
305	error_interrupt dd -1	305	error_interrupt dd -1
306		306
307	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0	307	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0
308	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0	308	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0
309	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0	309	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0
310	system_error db 'K : Kernel error',13,10,0	310	system_error db 'K : Kernel error',13,10,0
311	endg	311	endg
312		312
313	uglobal	313	uglobal
314	write_error_to dd 0x0	314	write_error_to dd 0x0
315	endg	315	endg
316		316
317	show_error_parameters:	317	show_error_parameters:
318		318
319	mov [write_error_to],process_pid+43	319	mov [write_error_to],process_pid+43
320	mov eax,[0x3000]	320	mov eax,[0x3000]
321	shl eax, 5	321	shl eax, 5
322	mov eax,[0x3000+4+eax]	322	mov eax,[0x3000+4+eax]
323	call writehex	323	call writehex
324		324
325	mov [write_error_to],process_error+43	325	mov [write_error_to],process_error+43
326	mov eax,[error_interrupt]	326	mov eax,[error_interrupt]
327	call writehex	327	call writehex
328		328
329	cmp dword [esp+4+4], os_code ; CS	329	cmp dword [esp+4+4], os_code ; CS
330	jnz @f	330	jnz @f
331	mov esi,system_error	331	mov esi,system_error
332	call sys_msg_board_str	332	call sys_msg_board_str
333	@@:	333	@@:
334	mov eax, [esp+4] ; EIP	334	mov eax, [esp+4] ; EIP
335		335
336	mov [write_error_to],process_eip+43	336	mov [write_error_to],process_eip+43
337	call writehex	337	call writehex
338		338
339	mov esi,process_error	339	mov esi,process_error
340	call sys_msg_board_str	340	call sys_msg_board_str
341		341
342	mov esi,process_pid	342	mov esi,process_pid
343	call sys_msg_board_str	343	call sys_msg_board_str
344		344
345	mov esi,process_eip	345	mov esi,process_eip
346	call sys_msg_board_str	346	call sys_msg_board_str
347		347
348	ret	348	ret
349		349
350		350
351		351
352	; irq1 -> hid/keyboard.inc	352	; irq1 -> hid/keyboard.inc
353		353
354		354
355	macro irqh [num]	355	macro irqh [num]
356	{	356	{
357	forward	357	forward
358	p_irq#num :	358	p_irq#num :
359	save_ring3_context	359	save_ring3_context
360	mov edi, num	360	mov edi, num
361	jmp irq_c	361	jmp irq_c
362	}	362	}
363		363
364	irqh 2,5,7,8,9,10,11,14,15	364	irqh 2,5,7,8,9,10,11,14,15
365		365
366	irq_c:	366	irq_c:
367	mov ax, os_data	367	mov ax, os_data
368	mov ds, ax	368	mov ds, ax
369	mov es, ax	369	mov es, ax
370	call irqhandler	370	call irqhandler
371	restore_ring3_context	371	restore_ring3_context
372	iret	372	iret
373		373
374	p_irq6:	374	p_irq6:
375	save_ring3_context	375	save_ring3_context
376	mov ax, os_data	376	mov ax, os_data
377	mov ds, ax	377	mov ds, ax
378	mov es, ax	378	mov es, ax
379	call fdc_irq	379	call fdc_irq
380	call ready_for_next_irq	380	call ready_for_next_irq
381	restore_ring3_context	381	restore_ring3_context
382	iret	382	iret
383		383
384	p_irq3:	384	p_irq3:
385	save_ring3_context	385	save_ring3_context
386	mov ax, os_data	386	mov ax, os_data
387	mov ds, ax	387	mov ds, ax
388	mov es, ax	388	mov es, ax
389	cmp [com2_mouse_detected],0	389	cmp [com2_mouse_detected],0
390	je old_irq3_handler	390	je old_irq3_handler
391	call check_mouse_data_com2	391	call check_mouse_data_com2
392	jmp p_irq3_1	392	jmp p_irq3_1
393	old_irq3_handler:	393	old_irq3_handler:
394	mov edi,3	394	mov edi,3
395	call irqhandler	395	call irqhandler
396	p_irq3_1:	396	p_irq3_1:
397	restore_ring3_context	397	restore_ring3_context
398	iret	398	iret
399		399
400	p_irq4:	400	p_irq4:
401	save_ring3_context	401	save_ring3_context
402	mov ax, os_data	402	mov ax, os_data
403	mov ds, ax	403	mov ds, ax
404	mov es, ax	404	mov es, ax
405	cmp [com1_mouse_detected],0	405	cmp [com1_mouse_detected],0
406	je old_irq4_handler	406	je old_irq4_handler
407	call check_mouse_data_com1	407	call check_mouse_data_com1
408	jmp p_irq4_1	408	jmp p_irq4_1
409	old_irq4_handler:	409	old_irq4_handler:
410	mov edi,4	410	mov edi,4
411	call irqhandler	411	call irqhandler
412	p_irq4_1:	412	p_irq4_1:
413	restore_ring3_context	413	restore_ring3_context
414	iret	414	iret
415		415
416	p_irq12:	416	p_irq12:
417	save_ring3_context	417	save_ring3_context
418	mov ax, os_data	418	mov ax, os_data
419	mov ds, ax	419	mov ds, ax
420	mov es, ax	420	mov es, ax
421	call check_mouse_data_ps2	421	call check_mouse_data_ps2
422	restore_ring3_context	422	restore_ring3_context
423	iret	423	iret
424		424
425	ready_for_next_irq:	425	ready_for_next_irq:
426	mov [check_idle_semaphore],5	426	mov [check_idle_semaphore],5
427	mov al, 0x20	427	mov al, 0x20
428	out 0x20, al	428	out 0x20, al
429	ret	429	ret
430		430
431	ready_for_next_irq_1:	431	ready_for_next_irq_1:
432	mov [check_idle_semaphore],5	432	mov [check_idle_semaphore],5
433	mov al, 0x20	433	mov al, 0x20
434	out 0xa0,al	434	out 0xa0,al
435	out 0x20, al	435	out 0x20, al
436	ret	436	ret
437		437
438	irqD:	438	irqD:
439	save_ring3_context	439	save_ring3_context
440	mov ax, os_data	440	mov ax, os_data
441	mov ds, ax	441	mov ds, ax
442	mov es, ax	442	mov es, ax
443		443
444	mov dx,0xf0	444	mov dx,0xf0
445	mov al,0	445	mov al,0
446	out dx,al	446	out dx,al
447		447
448	mov dx,0xa0	448	mov dx,0xa0
449	mov al,0x20	449	mov al,0x20
450	out dx,al	450	out dx,al
451	mov dx,0x20	451	mov dx,0x20
452	out dx,al	452	out dx,al
453		453
454	restore_ring3_context	454	restore_ring3_context
455		455
456	iret	456	iret
457		457
458		458
459	irqhandler:	459	irqhandler:
460		460
461	push edi	461	push edi
462		462
463	mov esi,edi ; 1	463	mov esi,edi ; 1
464	shl esi,6 ; 1	464	shl esi,6 ; 1
465	add esi,irq00read ; 1	465	add esi,irq00read ; 1
466	shl edi,12 ; 1	466	shl edi,12 ; 1
467	add edi,0x2E0000	467	add edi,0x2E0000
468		468
469	mov [check_idle_semaphore],5	469	mov [check_idle_semaphore],5
470		470
471	irqnewread:	471	irqnewread:
472		472
473	mov dx,[esi] ; 2+	473	mov dx,[esi] ; 2+
474		474
475	cmp dx,0 ; 1	475	cmp dx,0 ; 1
476	jz irqover	476	jz irqover
477	cmp [esi+3],byte 1 ; 2 ; byte read	477	cmp [esi+3],byte 1 ; 2 ; byte read
478	jne noirqbyte ; 4-11	478	jne noirqbyte ; 4-11
479		479
480	in al,dx	480	in al,dx
481		481
482	mov edx,[edi]	482	mov edx,[edi]
483	cmp edx,4000	483	cmp edx,4000
484	je irqfull	484	je irqfull
485	mov ebx,edi	485	mov ebx,edi
486	add ebx,0x10	486	add ebx,0x10
487	add ebx,edx	487	add ebx,edx
488	mov [ebx],al	488	mov [ebx],al
489	inc edx	489	inc edx
490	mov [edi],edx	490	mov [edi],edx
491		491
492	add esi,4	492	add esi,4
493	jmp irqnewread	493	jmp irqnewread
494		494
495	noirqbyte:	495	noirqbyte:
496		496
497		497
498	cmp [esi+3],byte 2 ; word read	498	cmp [esi+3],byte 2 ; word read
499	jne noirqword	499	jne noirqword
500		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 58 → 66