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


 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; 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                              ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 593 $
 
 
align 4
idtreg:
     dw   8*0x41-1
     dd   idts+8
 
build_interrupt_table:
 
        mov    edi, idts+8
        mov    esi, sys_int
        mov    ecx, 0x40
     @@:
        lodsd
        mov    [edi],   ax           ; lower part of offset
        mov    [edi+2], word os_code ; segment selector
        mov     ax, word 10001110b shl 8        ; type: interrupt gate
        mov     [edi+4], eax
        add    edi, 8
        loop    @b
 
        ;mov    edi,8*0x40+idts+8
        mov     dword [edi], (i40 and 0xFFFF) or (os_code shl 16)
        mov     dword [edi+4], (11101111b shl 8) or (i40 and 0xFFFF0000)
                                                ; type: trap gate
        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
if USE_COM_IRQ
    dd   irq_serv.irq_3, irq_serv.irq_4
else
    dd   p_irq3, p_irq4
end if
    dd   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, irq_serv.irq_12,irqD ,p_irq14,p_irq15
 
    times 16 dd unknown_interrupt
 
    dd   i40
endg
 
macro save_ring3_context
{
    pushad
}
macro restore_ring3_context
{
    popad
}
 
; 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, app_data  ;èñêëþ÷åíèå
        mov   ds, ax        ;çàãðóçèì ïðàâèëüíûå çíà÷åíè
        mov   es, ax        ;â ðåãèñòðû
 
; test if debugging
        cli
        mov   eax, [current_slot]
        mov   eax, [eax+APPDATA.debugger_slot]
        test  eax, eax
        jnz   .debug
        sti
; not debuggee => say error and terminate
        add   esp, 0x20  ;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
        DEBUGF 1,"%s",system_error
      @@:
        mov    eax, [esp+4] ; EIP
 
        mov    [write_error_to],process_eip+43
        call   writehex
 
        ;mov    esi,process_error
        ;call   sys_msg_board_str
        DEBUGF 1,"%s",process_error
 
        ;mov    esi,process_pid
        ;call   sys_msg_board_str
        DEBUGF 1,"%s",process_pid
 
        ;mov    esi,process_eip
        ;call   sys_msg_board_str
        DEBUGF 1,"%s",process_eip
 
        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, app_data  ;os_data
     mov   ds, ax
     mov   es, ax
     call  irqhandler
     restore_ring3_context
     iret
 
p_irq6:
     save_ring3_context
     mov   ax, app_data  ;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, app_data  ;os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com2_mouse_detected],0
     je    old_irq3_handler
     mov   esi, com2_mouse
     mov   dx, 2F8h     ;[COMPortBaseAddr]
     call  check_mouse_data_com
     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, app_data  ;os_data
     mov   ds, ax
     mov   es, ax
     cmp   [com1_mouse_detected],0
     je    old_irq4_handler
     mov   esi, com1_mouse
     mov   dx, 3F8h     ;[COMPortBaseAddr]
     call  check_mouse_data_com
     jmp   p_irq4_1
 old_irq4_handler:
     mov   edi,4
     call  irqhandler
  p_irq4_1:
     restore_ring3_context
     iret
 
p_irq14:
        save_ring3_context
        mov     ax, app_data  ;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, app_data  ;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, app_data  ;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
           DEBUGF 1,"%s",process_terminating
@@:
           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
           DEBUGF 1,"%s",msg_obj_destroy
           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
           push ebx
           mov ebx,[SLOT_BASE+ebx+APPDATA.pl0_stack]
 
           stdcall kernel_free, ebx
 
           pop ebx
           mov ebx,[SLOT_BASE+ebx+APPDATA.cur_dir]
           stdcall kernel_free, ebx
 
           mov edi, [.slot]
           shl edi,8
           add edi,SLOT_BASE
 
           mov eax, [edi+APPDATA.io_map]
           cmp eax, (tss._io_map_0-OS_BASE+PG_MAP)
           je @F
           call free_page
@@:
           mov eax, [edi+APPDATA.io_map+4]
           cmp eax, (tss._io_map_1-OS_BASE+PG_MAP)
           je @F
           call free_page
@@:
           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
        cmp     [bgrlockpid], esi
        jnz     @f
        and     [bgrlockpid], 0
        mov     [bgrlock], 0
@@:
 
    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
    DEBUGF 1,"%s",process_terminated
    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
 
        ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 566 → 593