WebSVN – Kolibri OS – Diff – /kernel/branches/flat_kernel/core/sys32.inc


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/sys32.inc – Rev 405 → 420