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,e1,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
     call  check_mouse_data_com2
     restore_ring3_context
 
     iret
 
p_irq4:
 
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  check_mouse_data_com1
     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 33	Rev 40
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,e1,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
-		167	macro save_ring3_context
-		168	{
-		169	push ds es
-		170	pushad
-		171	}
-		172	macro restore_ring3_context
-		173	{
-		174	popad
-		175	pop es ds
-		176	}
166		177
167	; simply return control to interrupted process	178	; simply return control to interrupted process
168	unknown_interrupt:	179	unknown_interrupt:
169	iret	180	iret
170		181
171	macro exc_wo_code [num]	182	macro exc_wo_code [num]
172	{	183	{
173	forward	184	forward
174	e#num :	185	e#num :
-		186	save_ring3_context
175	mov bl, num	187	mov bl, num
176	jmp exc_c	188	jmp exc_c
177	}	189	}
178		190
179	macro exc_w_code [num]	191	macro exc_w_code [num]
180	{	192	{
181	forward	193	forward
182	e#num :	194	e#num :
183	add esp, 4	195	add esp, 4
-		196	save_ring3_context
184	mov bl, num	197	mov bl, num
185	jmp exc_c	198	jmp exc_c
186	}	199	}
187		200
188	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
189	exc_w_code 8, 10, 11, 12, 13, 14, 17	202	exc_w_code 8, 10, 11, 12, 13, 14, 17
190		203
191	exc_c:	204	exc_c:
192	mov ax, os_data	205	mov ax, os_data
193	mov ds, ax	206	mov ds, ax
194	mov es, ax	207	mov es, ax
-		208
-		209	; test if debugging
-		210	cli
-		211	mov eax, [0x3000]
-		212	shl eax, 8
-		213	mov eax, [0x80000+eax+0xAC]
-		214	test eax, eax
-		215	jnz .debug
-		216	sti
-		217	; not debuggee => say error and terminate
195		218	add esp, 28h
196	movzx eax, bl	219	movzx eax, bl
197	mov [error_interrupt], eax	220	mov [error_interrupt], eax
198	call show_error_parameters	221	call show_error_parameters
199		222
200	mov edx, [0x3010]	223	mov edx, [0x3010]
201	mov [edx + 0xA], byte 4	224	mov [edx + 0xA], byte 4
202		225
203	jmp change_task	226	jmp change_task
-		227
-		228	.debug:
-		229	; we are debugged process, notify debugger and suspend ourself
-		230	; eax=debugger PID
-		231	movzx ecx, bl
-		232	push ecx
-		233	mov ecx, [0x3010]
-		234	push dword [ecx+4] ; PID of current process
-		235	push 12
-		236	pop ecx
-		237	push 1 ; 1=exception
-		238	call debugger_notify
-		239	pop ecx
-		240	pop ecx
-		241	pop ecx
-		242	mov edx, [0x3010]
-		243	mov byte [edx+0xA], 1 ; suspended
-		244	call change_task
-		245	restore_ring3_context
204		246	iretd
205		247
206	;;;;;;;;;;;;;;;;;;;;;;;	248	;;;;;;;;;;;;;;;;;;;;;;;
207	;; FPU ERROR HANDLER ;;	249	;; FPU ERROR HANDLER ;;
208	;;;;;;;;;;;;;;;;;;;;;;;	250	;;;;;;;;;;;;;;;;;;;;;;;
209		251
210	align 4	252	align 4
211	e7:	253	e7:
-		254	save_ring3_context
212	clts	255	clts
213		-
214	push eax	-
215	push ds es	-
216		-
217	mov ax, os_data	256	mov ax, os_data
218	mov ds, ax	257	mov ds, ax
219	mov es, ax	258	mov es, ax
220		259
221	mov eax, [prev_user_of_fpu]	260	mov eax, [prev_user_of_fpu]
222	shl eax, 8	261	shl eax, 8
223	add eax, 0x80000 + 0x10	262	add eax, 0x80000 + 0x10
224	fsave [eax]	263	fsave [eax]
225		264
226	mov eax, [0x3000]	265	mov eax, [0x3000]
227	mov [prev_user_of_fpu], eax	266	mov [prev_user_of_fpu], eax
228	shl eax, 8	267	shl eax, 8
229	add eax, 0x80000	268	add eax, 0x80000
230	cmp [eax + 0x7f], byte 0	269	cmp [eax + 0x7f], byte 0
231	je @f	270	je @f
232	frstor [eax+0x10]	271	frstor [eax+0x10]
233	@@:	272	@@:
234	mov [eax + 0x7f], byte 1	273	mov [eax + 0x7f], byte 1
235		-
236	pop es ds	-
237	pop eax	274	restore_ring3_context
238		-
239	iret	275	iret
240		276
241	iglobal	277	iglobal
242	prev_user_of_fpu dd 1	278	prev_user_of_fpu dd 1
243	endg	279	endg
244		280
245		281
246	writehex:	282	writehex:
247	pusha	283	pusha
248		284
249	mov edi, [write_error_to]	285	mov edi, [write_error_to]
250	mov esi, 8	286	mov esi, 8
251	@@:	287	@@:
252	mov ecx, eax	288	mov ecx, eax
253	and ecx, 0xf	289	and ecx, 0xf
254		290
255	mov cl,[ecx+hexletters]	291	mov cl,[ecx+hexletters]
256	mov [edi],cl	292	mov [edi],cl
257	dec edi	293	dec edi
258		294
259	shr eax,4	295	shr eax,4
260	dec esi	296	dec esi
261	jnz @b	297	jnz @b
262		298
263	popa	299	popa
264	ret	300	ret
265		301
266	iglobal	302	iglobal
267	hexletters db '0123456789ABCDEF'	303	hexletters db '0123456789ABCDEF'
268		304
269	error_interrupt dd -1	305	error_interrupt dd -1
270		306
271	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
272	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
273	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
274	system_error db 'K : Kernel error',13,10,0	310	system_error db 'K : Kernel error',13,10,0
275	endg	311	endg
276		312
277	uglobal	313	uglobal
278	write_error_to dd 0x0	314	write_error_to dd 0x0
279	endg	315	endg
280		316
281	show_error_parameters:	317	show_error_parameters:
282		318
283	mov [write_error_to],process_pid+43	319	mov [write_error_to],process_pid+43
284	mov eax,[0x3000]	320	mov eax,[0x3000]
285	shl eax, 5	321	shl eax, 5
286	mov eax,[0x3000+4+eax]	322	mov eax,[0x3000+4+eax]
287	call writehex	323	call writehex
288		324
289	mov [write_error_to],process_error+43	325	mov [write_error_to],process_error+43
290	mov eax,[error_interrupt]	326	mov eax,[error_interrupt]
291	call writehex	327	call writehex
292		328
293	cmp dword [esp+4+4], os_code ; CS	329	cmp dword [esp+4+4], os_code ; CS
294	jnz @f	330	jnz @f
295	mov esi,system_error	331	mov esi,system_error
296	call sys_msg_board_str	332	call sys_msg_board_str
297	@@:	333	@@:
298	mov eax, [esp+4] ; EIP	334	mov eax, [esp+4] ; EIP
299		335
300	mov [write_error_to],process_eip+43	336	mov [write_error_to],process_eip+43
301	call writehex	337	call writehex
302		338
303	mov esi,process_error	339	mov esi,process_error
304	call sys_msg_board_str	340	call sys_msg_board_str
305		341
306	mov esi,process_pid	342	mov esi,process_pid
307	call sys_msg_board_str	343	call sys_msg_board_str
308		344
309	mov esi,process_eip	345	mov esi,process_eip
310	call sys_msg_board_str	346	call sys_msg_board_str
311		347
312	ret	348	ret
313		349
314		350
315		351
316	; irq1 -> hid/keyboard.inc	352	; irq1 -> hid/keyboard.inc
317		353
318		354
319	macro irqh [num]	355	macro irqh [num]
320	{	356	{
321	forward	357	forward
322	p_irq#num :	358	p_irq#num :
323	pushad	359	save_ring3_context
324	mov edi, num	360	mov edi, num
325	jmp irq_c	361	jmp irq_c
326	}	362	}
327		363
328	irqh 2,5,7,8,9,10,11,14,15	364	irqh 2,5,7,8,9,10,11,14,15
329		365
330	irq_c:	366	irq_c:
331	push ds es	-
332	mov ax, os_data	367	mov ax, os_data
333	mov ds, ax	368	mov ds, ax
334	mov es, ax	369	mov es, ax
335	call irqhandler	370	call irqhandler
336	pop es ds	371	restore_ring3_context
337	popad	-
338	iret	372	iret
339		373
340	p_irq6:	374	p_irq6:
341	pushad	-
342	push ds es	375	save_ring3_context
343	mov ax, os_data	376	mov ax, os_data
344	mov ds, ax	377	mov ds, ax
345	mov es, ax	378	mov es, ax
346	call fdc_irq	379	call fdc_irq
347	call ready_for_next_irq	380	call ready_for_next_irq
348	pop es ds	381	restore_ring3_context
349	popad	-
350	iret	382	iret
351		383
352	p_irq3:	384	p_irq3:
353	pushad	-
354	push ds es	385	save_ring3_context
355	mov ax, os_data	386	mov ax, os_data
356	mov ds, ax	387	mov ds, ax
357	mov es, ax	388	mov es, ax
358	call check_mouse_data_com2	389	call check_mouse_data_com2
359	pop es ds	390	restore_ring3_context
360	popad	-
361	iret	391	iret
362		392
363	p_irq4:	393	p_irq4:
364	pushad	-
365	push ds es	394	save_ring3_context
366	mov ax, os_data	395	mov ax, os_data
367	mov ds, ax	396	mov ds, ax
368	mov es, ax	397	mov es, ax
369	call check_mouse_data_com1	398	call check_mouse_data_com1
370	pop es ds	399	restore_ring3_context
371	popad	-
372	iret	400	iret
373		401
374	p_irq12:	402	p_irq12:
375	pushad	-
376	push ds es	403	save_ring3_context
377	mov ax, os_data	404	mov ax, os_data
378	mov ds, ax	405	mov ds, ax
379	mov es, ax	406	mov es, ax
380	call check_mouse_data_ps2	407	call check_mouse_data_ps2
381	pop es ds	408	restore_ring3_context
382	popad	-
383	iret	409	iret
384		410
385	ready_for_next_irq:	411	ready_for_next_irq:
386	mov [check_idle_semaphore],5	412	mov [check_idle_semaphore],5
387	mov al, 0x20	413	mov al, 0x20
388	out 0x20, al	414	out 0x20, al
389	ret	415	ret
390		416
391	ready_for_next_irq_1:	417	ready_for_next_irq_1:
392	mov [check_idle_semaphore],5	418	mov [check_idle_semaphore],5
393	mov al, 0x20	419	mov al, 0x20
394	out 0xa0,al	420	out 0xa0,al
395	out 0x20, al	421	out 0x20, al
396	ret	422	ret
397		423
398	irqD:	424	irqD:
399	pushad	-
400	push ds es	425	save_ring3_context
401	mov ax, os_data	426	mov ax, os_data
402	mov ds, ax	427	mov ds, ax
403	mov es, ax	428	mov es, ax
404		429
405	mov dx,0xf0	430	mov dx,0xf0
406	mov al,0	431	mov al,0
407	out dx,al	432	out dx,al
408		433
409	mov dx,0xa0	434	mov dx,0xa0
410	mov al,0x20	435	mov al,0x20
411	out dx,al	436	out dx,al
412	mov dx,0x20	437	mov dx,0x20
413	out dx,al	438	out dx,al
414		439
415	pop es ds	440	restore_ring3_context
416	popad	441
417	iret	442	iret
418		443
419		444
420	irqhandler:	445	irqhandler:
421		446
422	push edi	447	push edi
423		448
424	mov esi,edi ; 1	449	mov esi,edi ; 1
425	shl esi,6 ; 1	450	shl esi,6 ; 1
426	add esi,irq00read ; 1	451	add esi,irq00read ; 1
427	shl edi,12 ; 1	452	shl edi,12 ; 1
428	add edi,0x2E0000	453	add edi,0x2E0000
429		454
430	mov [check_idle_semaphore],5	455	mov [check_idle_semaphore],5
431		456
432	irqnewread:	457	irqnewread:
433		458
434	mov dx,[esi] ; 2+	459	mov dx,[esi] ; 2+
435		460
436	cmp dx,0 ; 1	461	cmp dx,0 ; 1
437	jz irqover	462	jz irqover
438	cmp [esi+3],byte 1 ; 2 ; byte read	463	cmp [esi+3],byte 1 ; 2 ; byte read
439	jne noirqbyte ; 4-11	464	jne noirqbyte ; 4-11
440		465
441	in al,dx	466	in al,dx
442		467
443	mov edx,[edi]	468	mov edx,[edi]
444	cmp edx,4000	469	cmp edx,4000
445	je irqfull	470	je irqfull
446	mov ebx,edi	471	mov ebx,edi
447	add ebx,0x10	472	add ebx,0x10
448	add ebx,edx	473	add ebx,edx
449	mov [ebx],al	474	mov [ebx],al
450	inc edx	475	inc edx
451	mov [edi],edx	476	mov [edi],edx
452		477
453	add esi,4	478	add esi,4
454	jmp irqnewread	479	jmp irqnewread
455		480
456	noirqbyte:	481	noirqbyte:
457		482

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 33 → 40