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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 76 → 92