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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 429 → 431