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+APPDATA.debugger_slot]
        test  eax, eax
        jnz   .debug
        sti
; not debuggee => say error and terminate
        add   esp, 28h
        movzx eax, bl        
        mov   [error_interrupt], eax
        call  show_error_parameters
        
        mov   edx, [0x3010]
        mov   [edx + TASKDATA.state], byte 4
        
        jmp   change_task
 
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
        cld
        movzx ecx, bl
        push  ecx
        mov   ecx, [0x3010]
        push  dword [ecx+TASKDATA.pid]    ; PID of current process
        push  12
        pop   ecx
        push  1        ; 1=exception
        call  debugger_notify
        pop   ecx
        pop   ecx
        pop   ecx
        mov   edx, [0x3010]
        mov   byte [edx+TASKDATA.state], 1        ; suspended
        call  change_task
        restore_ring3_context
        iretd
 
;;;;;;;;;;;;;;;;;;;;;;;
;; FPU ERROR HANDLER ;;
;;;;;;;;;;;;;;;;;;;;;;;
 
align 4
e7:
        save_ring3_context
        clts
        mov   ax, os_data
        mov   ds, ax
        mov   es, ax
        
        mov   eax, [prev_user_of_fpu]
        shl   eax, 8
        add   eax, 0x80000 + APPDATA.fpu_save_area
        fsave [eax]
        
        mov   eax, [0x3000]
        mov   [prev_user_of_fpu], eax
        shl   eax, 8
        add   eax, 0x80000
        cmp   [eax + APPDATA.is_fpu_saved], 0
        je    @f
        frstor [eax+APPDATA.fpu_save_area]
     @@:
        mov   [eax + APPDATA.is_fpu_saved], 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+TASKDATA.pid+eax]
        call   writehex
        
        mov    [write_error_to],process_error+43
        mov    eax,[error_interrupt]
        call   writehex
 
        cmp    dword [esp+4+4], os_code ; CS
        jnz    @f
        mov    esi,system_error
        call   sys_msg_board_str
      @@:
        mov    eax, [esp+4] ; EIP
 
        mov    [write_error_to],process_eip+43
        call   writehex
 
        mov    esi,process_error
        call   sys_msg_board_str
 
        mov    esi,process_pid
        call   sys_msg_board_str
 
        mov    esi,process_eip
        call   sys_msg_board_str
 
        ret
 
 
 
; irq1  ->  hid/keyboard.inc
 
 
macro irqh [num]
{
  forward
  p_irq#num :
     save_ring3_context
     mov   edi, num
     jmp   irq_c
}
 
irqh 2,5,7,8,9,10,11
 
 irq_c:
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  irqhandler
     restore_ring3_context
     iret
 
p_irq6:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  fdc_irq
     call  ready_for_next_irq
     restore_ring3_context
     iret
 
p_irq3:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com2_mouse_detected],0
     je    old_irq3_handler
     call  check_mouse_data_com2
     jmp   p_irq3_1
 old_irq3_handler:
     mov   edi,3
     call  irqhandler
  p_irq3_1: 
     restore_ring3_context
     iret
 
p_irq4:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com1_mouse_detected],0
     je    old_irq4_handler
     call  check_mouse_data_com1
     jmp   p_irq4_1
 old_irq4_handler:
     mov   edi,4
     call  irqhandler
  p_irq4_1:   
     restore_ring3_context
     iret
 
p_irq12:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     call  check_mouse_data_ps2
     restore_ring3_context
     iret
 
p_irq14:
        save_ring3_context
        mov     ax, os_data
        mov     ds, ax
        mov     es, ax
        call    [irq14_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
p_irq15:
        save_ring3_context
        mov     ax, os_data
        mov     ds, ax
        mov     es, ax
        call    [irq15_func]
        call    ready_for_next_irq_1
        restore_ring3_context
        iret
 
ready_for_next_irq:
     mov    [check_idle_semaphore],5
     mov   al, 0x20
     out   0x20, al
     ret
 
ready_for_next_irq_1:
     mov    [check_idle_semaphore],5
     mov   al, 0x20
     out    0xa0,al
     out   0x20, al
     ret
 
irqD:
     save_ring3_context
     mov   ax, os_data
     mov   ds, ax
     mov   es, ax
     
     mov   dx,0xf0
     mov   al,0
     out   dx,al
 
     mov   dx,0xa0
     mov   al,0x20
     out   dx,al
     mov   dx,0x20
     out   dx,al
 
     restore_ring3_context
     
     iret
 
 
irqhandler:
 
     push   edi
 
     mov    esi,edi          ; 1
     shl    esi,6            ; 1
     add    esi,irq00read    ; 1
     shl    edi,12           ; 1
     add    edi,0x2E0000
     mov    ecx,16
 
     mov    [check_idle_semaphore],5
 
   irqnewread:
     dec    ecx
     js     irqover
 
     mov    dx,[esi]         ; 2+
 
     cmp    dx,0             ; 1
     jz     irqover
     cmp    [esi+3],byte 1   ; 2     ; byte read
     jne    noirqbyte        ; 4-11
 
     in     al,dx
 
     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],al
     inc    edx
     mov    [edi],edx
 
     add    esi,4
     jmp    irqnewread
 
   noirqbyte:
 
 
     cmp    [esi+3],byte 2     ; word read
     jne    noirqword
 
     in     ax,dx
 
     mov    edx,[edi]
     cmp    edx,4000
     je     irqfull
     mov    ebx,edi
     add    ebx,0x10
     add    ebx,edx
     mov    [ebx],ax
     add    edx,2
     mov    [edi],edx
     add    esi,4
     jmp    irqnewread
 
   noirqword:
   irqfull:
   irqover:
 
     mov    al,0x20            ; ready for next irq
     out    0x20,al
 
     pop    ebx
     cmp    ebx,7
     jbe    noa0
     out    0xa0,al
   noa0:
 
     ret
 
 
 
set_application_table_status:
        push eax
 
        mov  eax,[0x3000]
        shl  eax, 5
        add  eax,0x3000+TASKDATA.pid
        mov  eax,[eax]
 
        mov  [application_table_status],eax
 
        pop  eax
 
        ret
 
 
clear_application_table_status:
        push eax
 
        mov  eax,[0x3000]
        shl  eax, 5
        add  eax,0x3000+TASKDATA.pid
        mov  eax,[eax]
 
        cmp  eax,[application_table_status]
        jne  apptsl1
        mov  [application_table_status],0
      apptsl1:
 
        pop  eax
 
        ret
 
 
 
sys_resize_app_memory:
        ; eax = 1 - resize
        ;     ebx = new amount of memory
 
        cmp    eax,1
        jne    .no_application_mem_resize
        
        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
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
    cmp  eax,[app_i_end]
    jb   no_01_header
; \end{diamond}[20.08.2006]
    shr  eax,1
    sub  eax,0x10
    mov  [app_esp],eax
    mov  eax,[0x90000+24]
    mov  [app_i_param],eax
    mov  [app_i_icon],dword 0
 
    pop  eax
    clc
    ret
 
  no_00_header:
 
 
    cmp  [0x90000+6],word '01'
    jne  no_01_header
 
    mov  eax,[0x90000+12]
    mov  [app_start],eax
    mov  eax,[0x90000+16]
    mov  [app_i_end],eax
    mov  eax,[0x90000+20]
    mov  [app_mem],eax
; \begin{diamond}[20.08.2006]
    cmp  eax,[app_i_end]
    jb   no_01_header
; \end{diamond}[20.08.2006]
    mov  eax,[0x90000+24]
    mov  [app_esp],eax
    mov  eax,[0x90000+28]
    mov  [app_i_param],eax
    mov  eax,[0x90000+32]
    mov  [app_i_icon],eax
 
    pop  eax
    clc
    ret
 
   no_01_header:
 
    pop  eax
    stc
    ret
 
 
uglobal
  new_process_place  dd  0x0
  app_start    dd  0x0
  app_i_end    dd  0x0
  app_mem      dd  0x0
  app_esp      dd  0x0
  app_i_param  dd  0x0
  app_i_icon   dd  0x0
  ;app_mem_pos  dd  0x0
  appl_path        dd 0x0
  appl_path_size   dd 0x0         
endg
 
 
sys_threads:
 
; eax=1 create thread
;
;   ebx=thread start
;   ecx=thread stack value
;
; on return : eax = pid
jmp new_sys_threads
 
iglobal
  process_terminating   db 'K : Process - terminating',13,10,0
  process_terminated    db 'K : Process - done',13,10,0
endg
 
 
terminate: ; terminate application
    push   esi
    mov    esi,process_terminating
    call   sys_msg_board_str
    pop    esi
 
@@:
    cli
    cmp   [application_table_status],0
    je    term9
    sti
    call  change_task
    jmp   @b
  term9:
 
    call  set_application_table_status
    
    mov    eax,esi
    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   eax,[esi+WDATA.box.left]
    mov   [dlx],eax
    add   eax,[esi+WDATA.box.width]
    mov   [dlxe],eax
    mov   eax,[esi+WDATA.box.top]
    mov   [dly],eax
    add   eax,[esi+WDATA.box.height]
    mov   [dlye],eax
 
    xor   eax, eax
    mov   [esi+WDATA.box.left],eax
    mov   [esi+WDATA.box.width],eax
    mov   [esi+WDATA.box.top],eax
    mov   [esi+WDATA.box.height],eax
    mov   [esi+WDATA.cl_workarea],eax
    mov   [esi+WDATA.cl_titlebar],eax
    mov   [esi+WDATA.cl_frames],eax
    mov   dword [esi+WDATA.reserved],eax ; clear all flags: wstate, redraw, wdrawn
    lea   edi, [esi-window_data+draw_data]
    mov   ecx,32/4
    rep   stosd
    popa
 
; debuggee test
    pushad
    mov  edi, esi
    shl  edi, 5
    mov  eax, [0x80000+edi*8+APPDATA.debugger_slot]
    test eax, eax
    jz   .nodebug
    push 8
    pop  ecx
    push dword [0x3000+edi+TASKDATA.pid]   ; PID
    push 2
    call debugger_notify
    pop  ecx
    pop  ecx
.nodebug:
    popad
 
    pusha         ; at 0x80000+
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000
    mov   ecx,256/4
    xor   eax, eax
    rep   stosd
    popa
 
    pusha          ; name to spaces
    mov   edi,esi
    shl   edi,8
    add   edi,0x80000+APPDATA.app_name
    mov   ecx,11
    mov   eax,' '
    rep   stosb
    popa
 
 
  ; activate window
        movzx  eax, word [0xC000 + esi*2]
        cmp    eax, [0x3004]
        jne    .dont_activate
        pushad
 .check_next_window:
        dec    eax
        cmp    eax, 1
        jbe    .nothing_to_activate
        lea    esi, [0xc400+eax*2]
        movzx  edi, word [esi]               ; edi = process
        shl    edi, 5
        cmp    [0x3000 + edi + TASKDATA.state], byte 9  ; skip dead slots
        je     .check_next_window
        add    edi, window_data
; \begin{diamond}[19.09.2006]
; skip minimized windows
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .check_next_window
; \end{diamond}
        call   waredraw
 .nothing_to_activate:
        popad
 .dont_activate:
 
        push    esi     ; remove hd1 & cd & flp reservation
        shl     esi, 5
        mov     esi, [esi+0x3000+TASKDATA.pid]
        cmp     [hd1_status], esi
        jnz     @f
        mov     [hd1_status], 0
@@:
        cmp     [cd_status], esi
        jnz     @f
        mov     [cd_status], 0
@@:
        cmp     [flp_status], esi
        jnz     @f
        mov     [flp_status], 0
@@:
        pop     esi
 
    pusha ; remove all irq reservations
    mov   eax,esi
    shl   eax, 5
    mov   eax,[eax+0x3000+TASKDATA.pid]
    mov   edi,irq_owner
    mov   ecx,16
  newirqfree:
    scasd
    jne   nofreeirq
    mov   [edi-4],dword 0
  nofreeirq:
    loop   newirqfree
    popa
 
 
    pusha                     ; remove all port reservations
    mov   edx,esi
    shl   edx, 5
    add   edx,0x3000
    mov   edx,[edx+TASKDATA.pid]
 
  rmpr0:
 
    mov   esi,[0x2d0000]
 
    cmp   esi,0
    je    rmpr9
 
  rmpr3:
 
    mov   edi,esi
    shl   edi,4
    add   edi,0x2d0000
 
    cmp   edx,[edi]
    je    rmpr4
 
    dec   esi
    jnz   rmpr3
 
    jmp   rmpr9
 
  rmpr4:
 
    mov   ecx,256
    sub   ecx,esi
    shl   ecx,4
 
    mov   esi,edi
    add   esi,16
    cld
    rep   movsb
 
    dec   dword [0x2d0000]
 
    jmp   rmpr0
 
  rmpr9:
 
    popa
    mov  edi,esi         ; do not run this process slot
    shl  edi, 5
    mov  [edi+0x3000 + TASKDATA.state],byte 9
; debugger test - terminate all debuggees
    mov  eax, 2
    mov  ecx, 0x80000+2*0x100+APPDATA.debugger_slot
.xd0:
    cmp  eax, [0x3004]
    ja   .xd1
    cmp  dword [ecx], esi
    jnz  @f
    and  dword [ecx], 0
    pushad
    xchg eax, ebx
    mov  eax, 2
    call sys_system
    popad
@@:
    inc  eax
    add  ecx, 0x100
    jmp  .xd0
.xd1:
;    call  systest
    sti  ; .. and life goes on
 
    mov   eax, [dlx]
    mov   ebx, [dly]
    mov   ecx, [dlxe]
    mov   edx, [dlye]
    call  calculatescreen
    xor   eax, eax
    xor   esi, esi
    call  redrawscreen
 
    mov   [0xfff4],byte 0  ; no mouse background
    mov   [0xfff5],byte 0  ; draw mouse
 
    mov   [application_table_status],0
    mov   esi,process_terminated
    call  sys_msg_board_str
 
    ret
 
iglobal
  boot_sched_1    db   'Building gdt tss pointer',0
  boot_sched_2    db   'Building IDT table',0
endg
 
 
build_scheduler:
 
        mov    esi,boot_sched_1
        call   boot_log
        call   build_process_gdt_tss_pointer
 
        mov    esi,boot_sched_2
        call   boot_log
        call   build_interrupt_table
 
        ret

Rev 154	Rev 160
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+APPDATA.debugger_slot]	231	mov eax, [0x80000+eax+APPDATA.debugger_slot]
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 + TASKDATA.state], byte 4	242	mov [edx + TASKDATA.state], 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	cld	249	cld
250	movzx ecx, bl	250	movzx ecx, bl
251	push ecx	251	push ecx
252	mov ecx, [0x3010]	252	mov ecx, [0x3010]
253	push dword [ecx+TASKDATA.pid] ; PID of current process	253	push dword [ecx+TASKDATA.pid] ; PID of current process
254	push 12	254	push 12
255	pop ecx	255	pop ecx
256	push 1 ; 1=exception	256	push 1 ; 1=exception
257	call debugger_notify	257	call debugger_notify
258	pop ecx	258	pop ecx
259	pop ecx	259	pop ecx
260	pop ecx	260	pop ecx
261	mov edx, [0x3010]	261	mov edx, [0x3010]
262	mov byte [edx+TASKDATA.state], 1 ; suspended	262	mov byte [edx+TASKDATA.state], 1 ; suspended
263	call change_task	263	call change_task
264	restore_ring3_context	264	restore_ring3_context
265	iretd	265	iretd
266		266
267	;;;;;;;;;;;;;;;;;;;;;;;	267	;;;;;;;;;;;;;;;;;;;;;;;
268	;; FPU ERROR HANDLER ;;	268	;; FPU ERROR HANDLER ;;
269	;;;;;;;;;;;;;;;;;;;;;;;	269	;;;;;;;;;;;;;;;;;;;;;;;
270		270
271	align 4	271	align 4
272	e7:	272	e7:
273	save_ring3_context	273	save_ring3_context
274	clts	274	clts
275	mov ax, os_data	275	mov ax, os_data
276	mov ds, ax	276	mov ds, ax
277	mov es, ax	277	mov es, ax
278		278
279	mov eax, [prev_user_of_fpu]	279	mov eax, [prev_user_of_fpu]
280	shl eax, 8	280	shl eax, 8
281	add eax, 0x80000 + APPDATA.fpu_save_area	281	add eax, 0x80000 + APPDATA.fpu_save_area
282	fsave [eax]	282	fsave [eax]
283		283
284	mov eax, [0x3000]	284	mov eax, [0x3000]
285	mov [prev_user_of_fpu], eax	285	mov [prev_user_of_fpu], eax
286	shl eax, 8	286	shl eax, 8
287	add eax, 0x80000	287	add eax, 0x80000
288	cmp [eax + APPDATA.is_fpu_saved], 0	288	cmp [eax + APPDATA.is_fpu_saved], 0
289	je @f	289	je @f
290	frstor [eax+APPDATA.fpu_save_area]	290	frstor [eax+APPDATA.fpu_save_area]
291	@@:	291	@@:
292	mov [eax + APPDATA.is_fpu_saved], 1	292	mov [eax + APPDATA.is_fpu_saved], 1
293	restore_ring3_context	293	restore_ring3_context
294	iret	294	iret
295		295
296	iglobal	296	iglobal
297	prev_user_of_fpu dd 1	297	prev_user_of_fpu dd 1
298	endg	298	endg
299		299
300		300
301	writehex:	301	writehex:
302	pusha	302	pusha
303		303
304	mov edi, [write_error_to]	304	mov edi, [write_error_to]
305	mov esi, 8	305	mov esi, 8
306	@@:	306	@@:
307	mov ecx, eax	307	mov ecx, eax
308	and ecx, 0xf	308	and ecx, 0xf
309		309
310	mov cl,[ecx+hexletters]	310	mov cl,[ecx+hexletters]
311	mov [edi],cl	311	mov [edi],cl
312	dec edi	312	dec edi
313		313
314	shr eax,4	314	shr eax,4
315	dec esi	315	dec esi
316	jnz @b	316	jnz @b
317		317
318	popa	318	popa
319	ret	319	ret
320		320
321	iglobal	321	iglobal
322	hexletters db '0123456789ABCDEF'	322	hexletters db '0123456789ABCDEF'
323		323
324	error_interrupt dd -1	324	error_interrupt dd -1
325		325
326	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0	326	process_error db 'K : Process - forced terminate INT: 00000000',13,10,0
327	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0	327	process_pid db 'K : Process - forced terminate PID: 00000000',13,10,0
328	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0	328	process_eip db 'K : Process - forced terminate EIP: 00000000',13,10,0
329	system_error db 'K : Kernel error',13,10,0	329	system_error db 'K : Kernel error',13,10,0
330	endg	330	endg
331		331
332	uglobal	332	uglobal
333	write_error_to dd 0x0	333	write_error_to dd 0x0
334	endg	334	endg
335		335
336	show_error_parameters:	336	show_error_parameters:
337		337
338	mov [write_error_to],process_pid+43	338	mov [write_error_to],process_pid+43
339	mov eax,[0x3000]	339	mov eax,[0x3000]
340	shl eax, 5	340	shl eax, 5
341	mov eax,[0x3000+TASKDATA.pid+eax]	341	mov eax,[0x3000+TASKDATA.pid+eax]
342	call writehex	342	call writehex
343		343
344	mov [write_error_to],process_error+43	344	mov [write_error_to],process_error+43
345	mov eax,[error_interrupt]	345	mov eax,[error_interrupt]
346	call writehex	346	call writehex
347		347
348	cmp dword [esp+4+4], os_code ; CS	348	cmp dword [esp+4+4], os_code ; CS
349	jnz @f	349	jnz @f
350	mov esi,system_error	350	mov esi,system_error
351	call sys_msg_board_str	351	call sys_msg_board_str
352	@@:	352	@@:
353	mov eax, [esp+4] ; EIP	353	mov eax, [esp+4] ; EIP
354		354
355	mov [write_error_to],process_eip+43	355	mov [write_error_to],process_eip+43
356	call writehex	356	call writehex
357		357
358	mov esi,process_error	358	mov esi,process_error
359	call sys_msg_board_str	359	call sys_msg_board_str
360		360
361	mov esi,process_pid	361	mov esi,process_pid
362	call sys_msg_board_str	362	call sys_msg_board_str
363		363
364	mov esi,process_eip	364	mov esi,process_eip
365	call sys_msg_board_str	365	call sys_msg_board_str
366		366
367	ret	367	ret
368		368
369		369
370		370
371	; irq1 -> hid/keyboard.inc	371	; irq1 -> hid/keyboard.inc
372		372
373		373
374	macro irqh [num]	374	macro irqh [num]
375	{	375	{
376	forward	376	forward
377	p_irq#num :	377	p_irq#num :
378	save_ring3_context	378	save_ring3_context
379	mov edi, num	379	mov edi, num
380	jmp irq_c	380	jmp irq_c
381	}	381	}
382		382
383	irqh 2,5,7,8,9,10,11,14,15	383	irqh 2,5,7,8,9,10,11
384		384
385	irq_c:	385	irq_c:
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	call irqhandler	389	call irqhandler
390	restore_ring3_context	390	restore_ring3_context
391	iret	391	iret
392		392
393	p_irq6:	393	p_irq6:
394	save_ring3_context	394	save_ring3_context
395	mov ax, os_data	395	mov ax, os_data
396	mov ds, ax	396	mov ds, ax
397	mov es, ax	397	mov es, ax
398	call fdc_irq	398	call fdc_irq
399	call ready_for_next_irq	399	call ready_for_next_irq
400	restore_ring3_context	400	restore_ring3_context
401	iret	401	iret
402		402
403	p_irq3:	403	p_irq3:
404	save_ring3_context	404	save_ring3_context
405	mov ax, os_data	405	mov ax, os_data
406	mov ds, ax	406	mov ds, ax
407	mov es, ax	407	mov es, ax
408	cmp [com2_mouse_detected],0	408	cmp [com2_mouse_detected],0
409	je old_irq3_handler	409	je old_irq3_handler
410	call check_mouse_data_com2	410	call check_mouse_data_com2
411	jmp p_irq3_1	411	jmp p_irq3_1
412	old_irq3_handler:	412	old_irq3_handler:
413	mov edi,3	413	mov edi,3
414	call irqhandler	414	call irqhandler
415	p_irq3_1:	415	p_irq3_1:
416	restore_ring3_context	416	restore_ring3_context
417	iret	417	iret
418		418
419	p_irq4:	419	p_irq4:
420	save_ring3_context	420	save_ring3_context
421	mov ax, os_data	421	mov ax, os_data
422	mov ds, ax	422	mov ds, ax
423	mov es, ax	423	mov es, ax
424	cmp [com1_mouse_detected],0	424	cmp [com1_mouse_detected],0
425	je old_irq4_handler	425	je old_irq4_handler
426	call check_mouse_data_com1	426	call check_mouse_data_com1
427	jmp p_irq4_1	427	jmp p_irq4_1
428	old_irq4_handler:	428	old_irq4_handler:
429	mov edi,4	429	mov edi,4
430	call irqhandler	430	call irqhandler
431	p_irq4_1:	431	p_irq4_1:
432	restore_ring3_context	432	restore_ring3_context
433	iret	433	iret
434		434
435	p_irq12:	435	p_irq12:
436	save_ring3_context	436	save_ring3_context
437	mov ax, os_data	437	mov ax, os_data
438	mov ds, ax	438	mov ds, ax
439	mov es, ax	439	mov es, ax
440	call check_mouse_data_ps2	440	call check_mouse_data_ps2
441	restore_ring3_context	441	restore_ring3_context
442	iret	442	iret
-		443
-		444	p_irq14:
-		445	save_ring3_context
-		446	mov ax, os_data
-		447	mov ds, ax
-		448	mov es, ax
-		449	call [irq14_func]
-		450	call ready_for_next_irq_1
-		451	restore_ring3_context
-		452	iret
-		453	p_irq15:
-		454	save_ring3_context
-		455	mov ax, os_data
-		456	mov ds, ax
-		457	mov es, ax
-		458	call [irq15_func]
-		459	call ready_for_next_irq_1
-		460	restore_ring3_context
-		461	iret
443		462
444	ready_for_next_irq:	463	ready_for_next_irq:
445	mov [check_idle_semaphore],5	464	mov [check_idle_semaphore],5
446	mov al, 0x20	465	mov al, 0x20
447	out 0x20, al	466	out 0x20, al
448	ret	467	ret
449		468
450	ready_for_next_irq_1:	469	ready_for_next_irq_1:
451	mov [check_idle_semaphore],5	470	mov [check_idle_semaphore],5
452	mov al, 0x20	471	mov al, 0x20
453	out 0xa0,al	472	out 0xa0,al
454	out 0x20, al	473	out 0x20, al
455	ret	474	ret
456		475
457	irqD:	476	irqD:
458	save_ring3_context	477	save_ring3_context
459	mov ax, os_data	478	mov ax, os_data
460	mov ds, ax	479	mov ds, ax
461	mov es, ax	480	mov es, ax
462		481
463	mov dx,0xf0	482	mov dx,0xf0
464	mov al,0	483	mov al,0
465	out dx,al	484	out dx,al
466		485
467	mov dx,0xa0	486	mov dx,0xa0
468	mov al,0x20	487	mov al,0x20
469	out dx,al	488	out dx,al
470	mov dx,0x20	489	mov dx,0x20
471	out dx,al	490	out dx,al
472		491
473	restore_ring3_context	492	restore_ring3_context
474		493
475	iret	494	iret
476		495
477		496
478	irqhandler:	497	irqhandler:
479		498
480	push edi	499	push edi
481		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 154 → 160