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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 8876 $
 
align 4 ;3A08
build_interrupt_table:
        mov     edi, idts
        mov     esi, sys_int
        mov     ecx, 0x40
        mov     eax, (10001110b shl 24) + os_code
  @@:
        movsw   ; low word of code-entry
        stosd   ; interrupt gate type : os_code selector
        movsw   ; high word of code-entry
        loop    @b
        movsd   ; copy low  dword of trap gate for int 0x40
        movsd   ; copy high dword of trap gate for int 0x40
        mov     ecx, 23
        mov     eax, (10001110b shl 24) + os_code
  @@:
        movsw   ; low word of code-entry
        stosd   ; interrupt gate type : os_code selector
        movsw   ; high word of code-entry
        loop    @b
        lidt    [esi]
        ret
 
iglobal
  align 4
  sys_int:
    ; exception handlers addresses (for interrupt gate construction)
        dd      e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
        dd      e8,e9,e10,e11,e12,e13,page_fault_exc,e15
        dd      e16, e17,e18, e19
        times   12 dd unknown_interrupt ;int_20..int_31
 
    ; interrupt handlers addresses (for interrupt gate construction)
        ; 0x20+ are IRQ handlers
        dd irq0
        rept 12 irqn:1  \{dd irq_serv.irq_\#irqn\}
        dd irqD
        rept 18 irqn:14 \{dd irq_serv.irq_\#irqn\}
 
        ; int_0x40 gate trap (for directly copied)
        dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
 
        rept 23 irqn:33 \{dd irq_serv.irq_\#irqn\}
 
  idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
        dw      2*($-sys_int-4)-1
        dd      idts ; 0x8000B100
        dw      0    ; alignment
 
  msg_fault_sel dd  msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
                dd  msg_exc_c,msg_exc_d,msg_exc_e,msg_exc_u
                dd  msg_exc_u,msg_exc_11
 
  msg_exc_8     db "Double fault", 0
  msg_exc_u     db "Undefined Exception", 0
  msg_exc_a     db "Invalid TSS", 0
  msg_exc_b     db "Segment not present", 0
  msg_exc_c     db "Stack fault", 0
  msg_exc_d     db "General protection fault", 0
  msg_exc_e     db "Page fault", 0
  msg_exc_11    db "Alignment Check", 0
 
  if lang eq sp
    include 'core/sys32-sp.inc'
  else
    msg_sel_ker   db "kernel", 0
    msg_sel_app   db "application", 0
  end if
 
endg
 
macro save_ring3_context {
        pushad
}
macro restore_ring3_context {
        popad
}
macro exc_wo_code [num] {
  e#num :
        save_ring3_context
        mov     bl, num
        jmp     exc_c
} exc_wo_code   0,1,2,3,4,5,6,15,16,19
 
macro exc_w_code [num] {
  e#num :
        add     esp, 4
        save_ring3_context
        mov     bl, num
        jmp     exc_c
} exc_w_code    8,9,10,11,12,13,17,18
 
 
uglobal
  pf_err_code   dd ?
endg
 
page_fault_exc:                   ; foolproof: selectors are clobbered ...
        pop     [ss:pf_err_code]  ; actually, until the next #PF
        save_ring3_context
        mov     bl, 14
 
exc_c:                            ; exceptions (all but 7th - #NM)
 ; stack frame when exception/interrupt from ring3 + pushad (i.e right here)
  reg_ss        equ esp+0x30
  reg_esp3      equ esp+0x2C
  reg_eflags    equ esp+0x28
  reg_cs3       equ esp+0x24
  reg_eip       equ esp+0x20
 ; this if frame from pushad
  reg_eax       equ esp+0x1C
  reg_ecx       equ esp+0x18
  reg_edx       equ esp+0x14
  reg_ebx       equ esp+0x10
  reg_esp0      equ esp+0x0C
  reg_ebp       equ esp+0x08
  reg_esi       equ esp+0x04
  reg_edi       equ esp+0x00
 
        mov     ax, app_data       ; exception
        mov     ds, ax             ; load proper values
        mov     es, ax             ; to registers
        cld                        ; clear the direction flag
        movzx   ebx, bl
; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
        test    byte[reg_eflags+2], 2
        jnz     v86_exc_c
        cmp     bl, 14             ; #PF
        jne     @f
        call    page_fault_handler ; SEE: core/memory.inc
  @@:
        mov     esi, [current_slot]
        btr     [esi+APPDATA.except_mask], ebx
        jnc     @f
        mov     eax, [esi+APPDATA.exc_handler]
        test    eax, eax
        jnz     IRetToUserHook
  @@:
        cli
        mov     eax, [esi+APPDATA.debugger_slot]
        test    eax, eax
        jnz     .debug
; not debuggee => say error and terminate
        call    show_error_parameters
        sti
        mov     [edx + TASKDATA.state], TSTATE_TERMINATING
        call    wakeup_osloop
        call    change_task
; If we're here, then the main OS thread has crashed before initializing IDLE thread.
; Or they both have crashed. Anyway, things are hopelessly broken.
        hlt
        jmp     $-1
.debug:
; we are debugged process, notify debugger and suspend ourself
; eax=debugger PID
        mov     ecx, 1          ; debug_message code=other_exception
        cmp     bl, 1           ; #DB
        jne     .notify         ; notify debugger and suspend ourself
        mov     ebx, dr6        ; debug_message data=DR6_image
        xor     edx, edx
        mov     dr6, edx
        mov     edx, dr7
        mov     cl, not 8
  .l1:
        shl     dl, 2
        jc      @f
        and     bl, cl
  @@:
        sar     cl, 1
        jc      .l1
        mov     cl, 3           ; debug_message code=debug_exception
.notify:
        push    ebx             ; debug_message data
        mov     ebx, [TASK_BASE]
        push    [ebx+TASKDATA.pid] ; PID
        push    ecx             ; debug_message code ((here: ecx==1/3))
        mov     cl, 12          ; debug_message size
        call    debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
        add     esp, 12
        mov     edx, [TASK_BASE]
        mov     [edx+TASKDATA.state], TSTATE_RUN_SUSPENDED
        call    change_task     ; SEE: core/shed.inc
        restore_ring3_context
        iretd
 
IRetToUserHook:
        xchg    eax, [reg_eip]
        sub     dword[reg_esp3], 8
        mov     edi, [reg_esp3]
        stosd
        mov     [edi], ebx
        restore_ring3_context
; simply return control to interrupted process
unknown_interrupt:
        iretd
 
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
; bl - error vector
show_error_parameters:
        cmp     bl, 0x06
        jnz     .no_ud
        push    ebx
        mov     ebx, ud_user_message
        mov     ebp, notifyapp
        call    fs_execute_from_sysdir_param
        pop     ebx
.no_ud:
        mov     edx, [TASK_BASE];not scratched below
        if lang eq sp
        DEBUGF  1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
        else
        DEBUGF  1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
        end if
        cmp     bl, 0x08
        jb      .l0
        cmp     bl, 0x11
        jbe     .l1
  .l0:
        mov     bl, 0x09
  .l1:
        mov     eax, [msg_fault_sel+ebx*4 - 0x08*4]
        DEBUGF  1, "K : %s\n", eax
        mov     eax, [reg_cs3+4]
        mov     edi, msg_sel_app
        mov     ebx, [reg_esp3+4]
        cmp     eax, app_code
        je      @f
        mov     edi, msg_sel_ker
        mov     ebx, [reg_esp0+4]
    @@:
        DEBUGF  1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
        DEBUGF  1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
        DEBUGF  1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
        DEBUGF  1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
 
        DEBUGF  1, "K : Stack dump:\n"
        push    eax ebx ecx edx
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+00]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+04]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+08]: %x\n",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+12]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+16]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+20]: %x\n",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+24]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+28]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+32]: %x\n",[ebx]
        pop     edx ecx ebx eax
        ret
.error_ESP:
        pop     edx ecx ebx eax
        DEBUGF  1, "\n"
        DEBUGF  1, "K : Unexpected end of the stack\n"
        ret
;--------------------------------------
.check_ESP:
        push    ebx
        shr     ebx, 12
        mov     ecx, ebx
        shr     ecx, 10
        mov     edx, [master_tab+ecx*4]
        test    edx, PG_READ
        jz      .fail             ; page table is not created
                                  ; incorrect address in the program
 
        mov     eax, [page_tabs+ebx*4]
        test    eax, 2
        jz      .fail             ; address not reserved for use. error
 
        pop     ebx
        xor     eax, eax
        ret
 
.fail:
        pop     ebx
        xor     eax, eax
        dec     eax
        ret
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
  restore  reg_ss
  restore  reg_esp3
  restore  reg_eflags
  restore  reg_cs
  restore  reg_eip
  restore  reg_eax
  restore  reg_ecx
  restore  reg_edx
  restore  reg_ebx
  restore  reg_esp0
  restore  reg_ebp
  restore  reg_esi
  restore  reg_edi
 
 
align 4
lock_application_table:
        push    eax ecx edx
        mov     ecx, application_table_mutex
        call    mutex_lock
 
        mov     eax, [current_slot_idx]
        shl     eax, BSF sizeof.TASKDATA
        add     eax, TASK_TABLE+TASKDATA.pid
        mov     eax, [eax]
 
        mov     [application_table_owner], eax
 
        pop     edx ecx eax
 
        ret
 
align 4
unlock_application_table:
        push    eax ecx edx
 
        mov     [application_table_owner], 0
        mov     ecx, application_table_mutex
        call    mutex_unlock
 
        pop     edx ecx eax
 
        ret
 
; sysfn 64 implementation
align 4
sys_resize_app_memory:
; in:   eax = 64 - function number
;       ebx = 1 - number of its only subfunction
;       ecx = new amount of memory
; out:
;       eax = 0 - success
;       eax = 1 - out of memory
 
;        cmp    eax,1
        dec     ebx
        jnz     .no_application_mem_resize
 
        mov     eax, [pg_data.pages_free]
        shl     eax, 12
        cmp     eax, ecx
        jae     @f
 
        xor     eax, eax
        inc     eax
        jmp     .store_result
@@:
        stdcall new_mem_resize, ecx
.store_result:
        mov     [esp+32], eax
.no_application_mem_resize:
        ret
 
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
 
align 4
terminate: ; terminate application
destroy_thread:
 
        .slot     equ esp+4             ;locals
        .process  equ esp               ;ptr to parent process
 
 
        push    esi        ;save .slot
 
        shl     esi, 8
        mov     edx, [SLOT_BASE+esi+APPDATA.process]
        test    edx, edx
        jnz     @F
        pop     esi
        shl     esi, BSF sizeof.TASKDATA
        mov     [TASK_TABLE+esi+TASKDATA.state], TSTATE_FREE
        ret
@@:
        push    edx                     ;save .process
        lea     edx, [SLOT_BASE+esi]
        call    scheduler_remove_thread
        call    lock_application_table
 
; if the process is in V86 mode...
        mov     eax, [.slot]
        shl     eax, 8
        mov     esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
        add     esi, RING0_STACK_SIZE
        cmp     [eax+SLOT_BASE+APPDATA.saved_esp0], esi
        jz      .nov86
; ...it has page directory for V86 mode
        mov     esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
        mov     ecx, [esi+4]
        mov     [eax+SLOT_BASE+APPDATA.process], ecx
; ...and I/O permission map for V86 mode
        mov     ecx, [esi+12]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [esi+8]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
.nov86:
; destroy per-thread kernel objects
        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]
           DEBUGF 1,"%s",msg_obj_destroy
        pop     esi
        jmp     @B
@@:
        mov     esi, [.slot]
        cmp     [fpu_owner], esi ; if user fpu last -> fpu user = 2
        jne     @F
 
        mov     [fpu_owner], 2
        mov     eax, [sizeof.APPDATA*2+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
; get process PID
        mov     eax, esi
        shl     eax, BSF sizeof.TASKDATA
        mov     eax, [eax+TASK_TABLE+TASKDATA.pid]
; compare current lock input with process PID
        cmp     eax, [PID_lock_input]
        jne     @f
 
        xor     eax, eax
        mov     [PID_lock_input], eax
@@:
; 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, BSF sizeof.WDATA
        add     esi, window_data
        mov     eax, [esi+WDATA.box.left]
        mov     [draw_limits.left], eax
        add     eax, [esi+WDATA.box.width]
        mov     [draw_limits.right], eax
        mov     eax, [esi+WDATA.box.top]
        mov     [draw_limits.top], eax
        add     eax, [esi+WDATA.box.height]
        mov     [draw_limits.bottom], eax
 
        xor     eax, eax
        mov     edi, esi
        mov     ecx, sizeof.WDATA/4
        rep stosd
 
        lea     edi, [esi-window_data+draw_data]
        mov     ecx, sizeof.WDATA/4
        rep stosd
        popa
 
; debuggee test
        pushad
        mov     edi, esi
        shl     edi, BSF sizeof.TASKDATA
        mov     eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
        test    eax, eax
        jz      .nodebug
        movi    ecx, 8
        push    dword [TASK_TABLE+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, [SLOT_BASE+sizeof.APPDATA+APPDATA.io_map]
        je      @F
        call    free_page
@@:
        mov     eax, [edi+APPDATA.io_map+4]
        cmp     eax, [SLOT_BASE+sizeof.APPDATA+APPDATA.io_map+4]
        je      @F
        call    free_page
@@:
        lea     ebx, [edi+APPDATA.list]
        list_del ebx                    ;destroys edx, ecx
 
        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, [thread_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, BSF sizeof.TASKDATA
        cmp     [TASK_TABLE + edi + TASKDATA.state], TSTATE_FREE ; skip free 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, BSF sizeof.TASKDATA
        mov     esi, [esi+TASK_TABLE+TASKDATA.pid]
        cmp     [cd_status], esi
        jnz     @f
        call    free_cd_channel
        and     [cd_status], 0
@@:
        pop     esi
        cmp     [bgrlockpid], esi
        jnz     @f
        and     [bgrlockpid], 0
        and     [bgrlock], 0
@@:
 
        pusha                 ; remove all port reservations
        mov     edx, esi
        shl     edx, BSF sizeof.TASKDATA
        add     edx, TASK_TABLE
        mov     edx, [edx+TASKDATA.pid]
 
  rmpr0:
 
        mov     esi, [RESERVED_PORTS]
 
        test    esi, esi
        jz      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, BSF sizeof.TASKDATA
        mov     [edi+TASK_TABLE + TASKDATA.state], TSTATE_FREE
; debugger test - terminate all debuggees
        mov     eax, 2
        mov     ecx, SLOT_BASE+2*0x100+APPDATA.debugger_slot
.xd0:
        cmp     eax, [thread_count]
        ja      .xd1
        cmp     dword [ecx], esi
        jnz     @f
        and     dword [ecx], 0
        pushad
        xchg    eax, ecx
        mov     ebx, 2
        call    sys_system
        popad
@@:
        inc     eax
        add     ecx, 0x100
        jmp     .xd0
.xd1:
;release slot
 
        bts     [thr_slot_map], esi
 
        mov     ecx, [.process]
        lea     eax, [ecx+PROC.thr_list]
        cmp     eax, [eax+LHEAD.next]
        jne     @F
 
        call    destroy_process.internal
@@:
        sti     ; .. and life goes on
 
        mov     eax, [draw_limits.left]
        mov     ebx, [draw_limits.top]
        mov     ecx, [draw_limits.right]
        mov     edx, [draw_limits.bottom]
        call    calculatescreen
        xor     eax, eax
        xor     esi, esi
        call    redrawscreen
 
        call    unlock_application_table
    ;mov   esi,process_terminated
    ;call  sys_msg_board_str
        add     esp, 8
        ret
restore .slot
restore .process
 
; Three following procedures are used to guarantee that
; some part of kernel code will not be terminated from outside
; while it is running.
; Note: they do not protect a thread from terminating due to errors inside
; the thread; accessing a nonexisting memory would still terminate it.
 
; First two procedures must be used in pair by thread-to-be-protected
; to signal the beginning and the end of an important part.
; It is OK to have nested areas.
 
; The last procedure must be used by outside wanna-be-terminators;
; if it is safe to terminate the given thread immediately, it returns eax=1;
; otherwise, it returns eax=0 and notifies the target thread that it should
; terminate itself when leaving a critical area (the last critical area if
; they are nested).
 
; Implementation. Those procedures use one dword in APPDATA for the thread,
; APPDATA.terminate_protection.
; * The upper bit is 1 during normal operations and 0 when terminate is requested.
; * Other bits form a number = depth of critical regions,
;   plus 1 if the upper bit is 1.
; * When this dword goes to zero, the thread should be destructed,
;   and the procedure in which it happened becomes responsible for destruction.
 
; Enter critical area. Called by thread which wants to be protected.
proc protect_from_terminate
        mov     edx, [current_slot]
; Atomically increment depth of critical areas and get the old value.
        mov     eax, 1
        lock xadd [edx+APPDATA.terminate_protection], eax
; If the old value was zero, somebody has started to terminate us,
; so we are destructing and cannot do anything protected.
; Otherwise, return to the caller.
        test    eax, eax
        jz      @f
        ret
@@:
; Wait for somebody to finish us.
        call    change_task
        jmp     @b
endp
 
; Leave critical area. Called by thread which wants to be protected.
proc unprotect_from_terminate
        mov     edx, [current_slot]
; Atomically decrement depth of critical areas.
        lock dec [edx+APPDATA.terminate_protection]
; If the result of decrement is zero, somebody has requested termination,
; but at that moment we were inside a critical area; terminate now.
        jz      sys_end
; Otherwise, return to the caller.
        ret
endp
 
; Request termination of thread identified by edx = SLOT_BASE + slot*sizeof.APPDATA.
; Called by anyone.
proc request_terminate
        xor     eax, eax        ; set return value
; Atomically clear the upper bit. If it was already zero, then
; somebody has requested termination before us, so just exit.
        lock btr [edx+APPDATA.terminate_protection], 31
        jnc     .unsafe
; Atomically decrement depth of critical areas.
        lock dec [edx+APPDATA.terminate_protection]
; If the result of decrement is nonzero, the target thread is inside a
; critical area; leave termination to leaving that area.
        jnz     .unsafe
; Otherwise, it is safe to kill the target now and the caller is responsible
; for this. Return eax=1.
        inc     eax
.unsafe:
        ret
endp

Rev 8874	Rev 8876
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License. ;;	4	;; Distributed under terms of the GNU General Public License. ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 8874 $	8	$Revision: 8876 $
9		9
10	align 4 ;3A08	10	align 4 ;3A08
11	build_interrupt_table:	11	build_interrupt_table:
12	mov edi, idts	12	mov edi, idts
13	mov esi, sys_int	13	mov esi, sys_int
14	mov ecx, 0x40	14	mov ecx, 0x40
15	mov eax, (10001110b shl 24) + os_code	15	mov eax, (10001110b shl 24) + os_code
16	@@:	16	@@:
17	movsw ; low word of code-entry	17	movsw ; low word of code-entry
18	stosd ; interrupt gate type : os_code selector	18	stosd ; interrupt gate type : os_code selector
19	movsw ; high word of code-entry	19	movsw ; high word of code-entry
20	loop @b	20	loop @b
21	movsd ; copy low dword of trap gate for int 0x40	21	movsd ; copy low dword of trap gate for int 0x40
22	movsd ; copy high dword of trap gate for int 0x40	22	movsd ; copy high dword of trap gate for int 0x40
23	mov ecx, 23	23	mov ecx, 23
24	mov eax, (10001110b shl 24) + os_code	24	mov eax, (10001110b shl 24) + os_code
25	@@:	25	@@:
26	movsw ; low word of code-entry	26	movsw ; low word of code-entry
27	stosd ; interrupt gate type : os_code selector	27	stosd ; interrupt gate type : os_code selector
28	movsw ; high word of code-entry	28	movsw ; high word of code-entry
29	loop @b	29	loop @b
30	lidt [esi]	30	lidt [esi]
31	ret	31	ret
32		32
33	iglobal	33	iglobal
34	align 4	34	align 4
35	sys_int:	35	sys_int:
36	; exception handlers addresses (for interrupt gate construction)	36	; exception handlers addresses (for interrupt gate construction)
37	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc	37	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
38	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15	38	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15
39	dd e16, e17,e18, e19	39	dd e16, e17,e18, e19
40	times 12 dd unknown_interrupt ;int_20..int_31	40	times 12 dd unknown_interrupt ;int_20..int_31
41		41
42	; interrupt handlers addresses (for interrupt gate construction)	42	; interrupt handlers addresses (for interrupt gate construction)
43	; 0x20+ are IRQ handlers	43	; 0x20+ are IRQ handlers
44	dd irq0	44	dd irq0
45	rept 12 irqn:1 \{dd irq_serv.irq_\#irqn\}	45	rept 12 irqn:1 \{dd irq_serv.irq_\#irqn\}
46	dd irqD	46	dd irqD
47	rept 18 irqn:14 \{dd irq_serv.irq_\#irqn\}	47	rept 18 irqn:14 \{dd irq_serv.irq_\#irqn\}
48		48
49	; int_0x40 gate trap (for directly copied)	49	; int_0x40 gate trap (for directly copied)
50	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16	50	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
51		51
52	rept 23 irqn:33 \{dd irq_serv.irq_\#irqn\}	52	rept 23 irqn:33 \{dd irq_serv.irq_\#irqn\}
53		53
54	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)	54	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
55	dw 2*($-sys_int-4)-1	55	dw 2*($-sys_int-4)-1
56	dd idts ; 0x8000B100	56	dd idts ; 0x8000B100
57	dw 0 ; alignment	57	dw 0 ; alignment
58		58
59	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b	59	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
60	dd msg_exc_c,msg_exc_d,msg_exc_e,msg_exc_u	60	dd msg_exc_c,msg_exc_d,msg_exc_e,msg_exc_u
61	dd msg_exc_u,msg_exc_11	61	dd msg_exc_u,msg_exc_11
62		62
63	msg_exc_8 db "Double fault", 0	63	msg_exc_8 db "Double fault", 0
64	msg_exc_u db "Undefined Exception", 0	64	msg_exc_u db "Undefined Exception", 0
65	msg_exc_a db "Invalid TSS", 0	65	msg_exc_a db "Invalid TSS", 0
66	msg_exc_b db "Segment not present", 0	66	msg_exc_b db "Segment not present", 0
67	msg_exc_c db "Stack fault", 0	67	msg_exc_c db "Stack fault", 0
68	msg_exc_d db "General protection fault", 0	68	msg_exc_d db "General protection fault", 0
69	msg_exc_e db "Page fault", 0	69	msg_exc_e db "Page fault", 0
70	msg_exc_11 db "Alignment Check", 0	70	msg_exc_11 db "Alignment Check", 0
71		71
72	if lang eq sp	72	if lang eq sp
73	include 'core/sys32-sp.inc'	73	include 'core/sys32-sp.inc'
74	else	74	else
75	msg_sel_ker db "kernel", 0	75	msg_sel_ker db "kernel", 0
76	msg_sel_app db "application", 0	76	msg_sel_app db "application", 0
77	end if	77	end if
78		78
79	endg	79	endg
80		80
81	macro save_ring3_context {	81	macro save_ring3_context {
82	pushad	82	pushad
83	}	83	}
84	macro restore_ring3_context {	84	macro restore_ring3_context {
85	popad	85	popad
86	}	86	}
87	macro exc_wo_code [num] {	87	macro exc_wo_code [num] {
88	e#num :	88	e#num :
89	save_ring3_context	89	save_ring3_context
90	mov bl, num	90	mov bl, num
91	jmp exc_c	91	jmp exc_c
92	} exc_wo_code 0,1,2,3,4,5,6,15,16,19	92	} exc_wo_code 0,1,2,3,4,5,6,15,16,19
93		93
94	macro exc_w_code [num] {	94	macro exc_w_code [num] {
95	e#num :	95	e#num :
96	add esp, 4	96	add esp, 4
97	save_ring3_context	97	save_ring3_context
98	mov bl, num	98	mov bl, num
99	jmp exc_c	99	jmp exc_c
100	} exc_w_code 8,9,10,11,12,13,17,18	100	} exc_w_code 8,9,10,11,12,13,17,18
101		101
102		102
103	uglobal	103	uglobal
104	pf_err_code dd ?	104	pf_err_code dd ?
105	endg	105	endg
106		106
107	page_fault_exc: ; foolproof: selectors are clobbered ...	107	page_fault_exc: ; foolproof: selectors are clobbered ...
108	pop [ss:pf_err_code] ; actually, until the next #PF	108	pop [ss:pf_err_code] ; actually, until the next #PF
109	save_ring3_context	109	save_ring3_context
110	mov bl, 14	110	mov bl, 14
111		111
112	exc_c: ; exceptions (all but 7th - #NM)	112	exc_c: ; exceptions (all but 7th - #NM)
113	; stack frame when exception/interrupt from ring3 + pushad (i.e right here)	113	; stack frame when exception/interrupt from ring3 + pushad (i.e right here)
114	reg_ss equ esp+0x30	114	reg_ss equ esp+0x30
115	reg_esp3 equ esp+0x2C	115	reg_esp3 equ esp+0x2C
116	reg_eflags equ esp+0x28	116	reg_eflags equ esp+0x28
117	reg_cs3 equ esp+0x24	117	reg_cs3 equ esp+0x24
118	reg_eip equ esp+0x20	118	reg_eip equ esp+0x20
119	; this if frame from pushad	119	; this if frame from pushad
120	reg_eax equ esp+0x1C	120	reg_eax equ esp+0x1C
121	reg_ecx equ esp+0x18	121	reg_ecx equ esp+0x18
122	reg_edx equ esp+0x14	122	reg_edx equ esp+0x14
123	reg_ebx equ esp+0x10	123	reg_ebx equ esp+0x10
124	reg_esp0 equ esp+0x0C	124	reg_esp0 equ esp+0x0C
125	reg_ebp equ esp+0x08	125	reg_ebp equ esp+0x08
126	reg_esi equ esp+0x04	126	reg_esi equ esp+0x04
127	reg_edi equ esp+0x00	127	reg_edi equ esp+0x00
128		128
129	mov ax, app_data ; exception	129	mov ax, app_data ; exception
130	mov ds, ax ; load proper values	130	mov ds, ax ; load proper values
131	mov es, ax ; to registers	131	mov es, ax ; to registers
132	cld ; clear the direction flag	132	cld ; clear the direction flag
133	movzx ebx, bl	133	movzx ebx, bl
134	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?	134	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
135	test byte[reg_eflags+2], 2	135	test byte[reg_eflags+2], 2
136	jnz v86_exc_c	136	jnz v86_exc_c
137	cmp bl, 14 ; #PF	137	cmp bl, 14 ; #PF
138	jne @f	138	jne @f
139	call page_fault_handler ; SEE: core/memory.inc	139	call page_fault_handler ; SEE: core/memory.inc
140	@@:	140	@@:
141	mov esi, [current_slot]	141	mov esi, [current_slot]
142	btr [esi+APPDATA.except_mask], ebx	142	btr [esi+APPDATA.except_mask], ebx
143	jnc @f	143	jnc @f
144	mov eax, [esi+APPDATA.exc_handler]	144	mov eax, [esi+APPDATA.exc_handler]
145	test eax, eax	145	test eax, eax
146	jnz IRetToUserHook	146	jnz IRetToUserHook
147	@@:	147	@@:
148	cli	148	cli
149	mov eax, [esi+APPDATA.debugger_slot]	149	mov eax, [esi+APPDATA.debugger_slot]
150	test eax, eax	150	test eax, eax
151	jnz .debug	151	jnz .debug
152	; not debuggee => say error and terminate	152	; not debuggee => say error and terminate
153	call show_error_parameters	153	call show_error_parameters
154	sti	154	sti
155	mov [edx + TASKDATA.state], TSTATE_TERMINATING ; terminate	155	mov [edx + TASKDATA.state], TSTATE_TERMINATING
156	call wakeup_osloop	156	call wakeup_osloop
157	call change_task	157	call change_task
158	; If we're here, then the main OS thread has crashed before initializing IDLE thread.	158	; If we're here, then the main OS thread has crashed before initializing IDLE thread.
159	; Or they both have crashed. Anyway, things are hopelessly broken.	159	; Or they both have crashed. Anyway, things are hopelessly broken.
160	hlt	160	hlt
161	jmp $-1	161	jmp $-1
162	.debug:	162	.debug:
163	; we are debugged process, notify debugger and suspend ourself	163	; we are debugged process, notify debugger and suspend ourself
164	; eax=debugger PID	164	; eax=debugger PID
165	mov ecx, 1 ; debug_message code=other_exception	165	mov ecx, 1 ; debug_message code=other_exception
166	cmp bl, 1 ; #DB	166	cmp bl, 1 ; #DB
167	jne .notify ; notify debugger and suspend ourself	167	jne .notify ; notify debugger and suspend ourself
168	mov ebx, dr6 ; debug_message data=DR6_image	168	mov ebx, dr6 ; debug_message data=DR6_image
169	xor edx, edx	169	xor edx, edx
170	mov dr6, edx	170	mov dr6, edx
171	mov edx, dr7	171	mov edx, dr7
172	mov cl, not 8	172	mov cl, not 8
173	.l1:	173	.l1:
174	shl dl, 2	174	shl dl, 2
175	jc @f	175	jc @f
176	and bl, cl	176	and bl, cl
177	@@:	177	@@:
178	sar cl, 1	178	sar cl, 1
179	jc .l1	179	jc .l1
180	mov cl, 3 ; debug_message code=debug_exception	180	mov cl, 3 ; debug_message code=debug_exception
181	.notify:	181	.notify:
182	push ebx ; debug_message data	182	push ebx ; debug_message data
183	mov ebx, [TASK_BASE]	183	mov ebx, [TASK_BASE]
184	push [ebx+TASKDATA.pid] ; PID	184	push [ebx+TASKDATA.pid] ; PID
185	push ecx ; debug_message code ((here: ecx==1/3))	185	push ecx ; debug_message code ((here: ecx==1/3))
186	mov cl, 12 ; debug_message size	186	mov cl, 12 ; debug_message size
187	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc	187	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
188	add esp, 12	188	add esp, 12
189	mov edx, [TASK_BASE]	189	mov edx, [TASK_BASE]
190	mov [edx+TASKDATA.state], TSTATE_RUN_SUSPENDED ; suspended	190	mov [edx+TASKDATA.state], TSTATE_RUN_SUSPENDED
191	call change_task ; SEE: core/shed.inc	191	call change_task ; SEE: core/shed.inc
192	restore_ring3_context	192	restore_ring3_context
193	iretd	193	iretd
194		194
195	IRetToUserHook:	195	IRetToUserHook:
196	xchg eax, [reg_eip]	196	xchg eax, [reg_eip]
197	sub dword[reg_esp3], 8	197	sub dword[reg_esp3], 8
198	mov edi, [reg_esp3]	198	mov edi, [reg_esp3]
199	stosd	199	stosd
200	mov [edi], ebx	200	mov [edi], ebx
201	restore_ring3_context	201	restore_ring3_context
202	; simply return control to interrupted process	202	; simply return control to interrupted process
203	unknown_interrupt:	203	unknown_interrupt:
204	iretd	204	iretd
205		205
206	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	206	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
207	; bl - error vector	207	; bl - error vector
208	show_error_parameters:	208	show_error_parameters:
209	cmp bl, 0x06	209	cmp bl, 0x06
210	jnz .no_ud	210	jnz .no_ud
211	push ebx	211	push ebx
212	mov ebx, ud_user_message	212	mov ebx, ud_user_message
213	mov ebp, notifyapp	213	mov ebp, notifyapp
214	call fs_execute_from_sysdir_param	214	call fs_execute_from_sysdir_param
215	pop ebx	215	pop ebx
216	.no_ud:	216	.no_ud:
217	mov edx, [TASK_BASE];not scratched below	217	mov edx, [TASK_BASE];not scratched below
218	if lang eq sp	218	if lang eq sp
219	DEBUGF 1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]	219	DEBUGF 1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
220	else	220	else
221	DEBUGF 1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]	221	DEBUGF 1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
222	end if	222	end if
223	cmp bl, 0x08	223	cmp bl, 0x08
224	jb .l0	224	jb .l0
225	cmp bl, 0x11	225	cmp bl, 0x11
226	jbe .l1	226	jbe .l1
227	.l0:	227	.l0:
228	mov bl, 0x09	228	mov bl, 0x09
229	.l1:	229	.l1:
230	mov eax, [msg_fault_sel+ebx4 - 0x084]	230	mov eax, [msg_fault_sel+ebx4 - 0x084]
231	DEBUGF 1, "K : %s\n", eax	231	DEBUGF 1, "K : %s\n", eax
232	mov eax, [reg_cs3+4]	232	mov eax, [reg_cs3+4]
233	mov edi, msg_sel_app	233	mov edi, msg_sel_app
234	mov ebx, [reg_esp3+4]	234	mov ebx, [reg_esp3+4]
235	cmp eax, app_code	235	cmp eax, app_code
236	je @f	236	je @f
237	mov edi, msg_sel_ker	237	mov edi, msg_sel_ker
238	mov ebx, [reg_esp0+4]	238	mov ebx, [reg_esp0+4]
239	@@:	239	@@:
240	DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]	240	DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
241	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]	241	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
242	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx	242	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
243	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi	243	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
244		244
245	DEBUGF 1, "K : Stack dump:\n"	245	DEBUGF 1, "K : Stack dump:\n"
246	push eax ebx ecx edx	246	push eax ebx ecx edx
247	call .check_ESP	247	call .check_ESP
248	test eax, eax	248	test eax, eax
249	jnz .error_ESP	249	jnz .error_ESP
250	DEBUGF 1, "K : [ESP+00]: %x",[ebx]	250	DEBUGF 1, "K : [ESP+00]: %x",[ebx]
251	add ebx, 4	251	add ebx, 4
252	call .check_ESP	252	call .check_ESP
253	test eax, eax	253	test eax, eax
254	jnz .error_ESP	254	jnz .error_ESP
255	DEBUGF 1, " [ESP+04]: %x",[ebx]	255	DEBUGF 1, " [ESP+04]: %x",[ebx]
256	add ebx, 4	256	add ebx, 4
257	call .check_ESP	257	call .check_ESP
258	test eax, eax	258	test eax, eax
259	jnz .error_ESP	259	jnz .error_ESP
260	DEBUGF 1, " [ESP+08]: %x\n",[ebx]	260	DEBUGF 1, " [ESP+08]: %x\n",[ebx]
261	add ebx, 4	261	add ebx, 4
262	call .check_ESP	262	call .check_ESP
263	test eax, eax	263	test eax, eax
264	jnz .error_ESP	264	jnz .error_ESP
265	DEBUGF 1, "K : [ESP+12]: %x",[ebx]	265	DEBUGF 1, "K : [ESP+12]: %x",[ebx]
266	add ebx, 4	266	add ebx, 4
267	call .check_ESP	267	call .check_ESP
268	test eax, eax	268	test eax, eax
269	jnz .error_ESP	269	jnz .error_ESP
270	DEBUGF 1, " [ESP+16]: %x",[ebx]	270	DEBUGF 1, " [ESP+16]: %x",[ebx]
271	add ebx, 4	271	add ebx, 4
272	call .check_ESP	272	call .check_ESP
273	test eax, eax	273	test eax, eax
274	jnz .error_ESP	274	jnz .error_ESP
275	DEBUGF 1, " [ESP+20]: %x\n",[ebx]	275	DEBUGF 1, " [ESP+20]: %x\n",[ebx]
276	add ebx, 4	276	add ebx, 4
277	call .check_ESP	277	call .check_ESP
278	test eax, eax	278	test eax, eax
279	jnz .error_ESP	279	jnz .error_ESP
280	DEBUGF 1, "K : [ESP+24]: %x",[ebx]	280	DEBUGF 1, "K : [ESP+24]: %x",[ebx]
281	add ebx, 4	281	add ebx, 4
282	call .check_ESP	282	call .check_ESP
283	test eax, eax	283	test eax, eax
284	jnz .error_ESP	284	jnz .error_ESP
285	DEBUGF 1, " [ESP+28]: %x",[ebx]	285	DEBUGF 1, " [ESP+28]: %x",[ebx]
286	add ebx, 4	286	add ebx, 4
287	call .check_ESP	287	call .check_ESP
288	test eax, eax	288	test eax, eax
289	jnz .error_ESP	289	jnz .error_ESP
290	DEBUGF 1, " [ESP+32]: %x\n",[ebx]	290	DEBUGF 1, " [ESP+32]: %x\n",[ebx]
291	pop edx ecx ebx eax	291	pop edx ecx ebx eax
292	ret	292	ret
293	.error_ESP:	293	.error_ESP:
294	pop edx ecx ebx eax	294	pop edx ecx ebx eax
295	DEBUGF 1, "\n"	295	DEBUGF 1, "\n"
296	DEBUGF 1, "K : Unexpected end of the stack\n"	296	DEBUGF 1, "K : Unexpected end of the stack\n"
297	ret	297	ret
298	;--------------------------------------	298	;--------------------------------------
299	.check_ESP:	299	.check_ESP:
300	push ebx	300	push ebx
301	shr ebx, 12	301	shr ebx, 12
302	mov ecx, ebx	302	mov ecx, ebx
303	shr ecx, 10	303	shr ecx, 10
304	mov edx, [master_tab+ecx*4]	304	mov edx, [master_tab+ecx*4]
305	test edx, PG_READ	305	test edx, PG_READ
306	jz .fail ; page table is not created	306	jz .fail ; page table is not created
307	; incorrect address in the program	307	; incorrect address in the program
308		308
309	mov eax, [page_tabs+ebx*4]	309	mov eax, [page_tabs+ebx*4]
310	test eax, 2	310	test eax, 2
311	jz .fail ; address not reserved for use. error	311	jz .fail ; address not reserved for use. error
312		312
313	pop ebx	313	pop ebx
314	xor eax, eax	314	xor eax, eax
315	ret	315	ret
316		316
317	.fail:	317	.fail:
318	pop ebx	318	pop ebx
319	xor eax, eax	319	xor eax, eax
320	dec eax	320	dec eax
321	ret	321	ret
322	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	322	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
323		323
324	restore reg_ss	324	restore reg_ss
325	restore reg_esp3	325	restore reg_esp3
326	restore reg_eflags	326	restore reg_eflags
327	restore reg_cs	327	restore reg_cs
328	restore reg_eip	328	restore reg_eip
329	restore reg_eax	329	restore reg_eax
330	restore reg_ecx	330	restore reg_ecx
331	restore reg_edx	331	restore reg_edx
332	restore reg_ebx	332	restore reg_ebx
333	restore reg_esp0	333	restore reg_esp0
334	restore reg_ebp	334	restore reg_ebp
335	restore reg_esi	335	restore reg_esi
336	restore reg_edi	336	restore reg_edi
337		337
338		338
339	align 4	339	align 4
340	lock_application_table:	340	lock_application_table:
341	push eax ecx edx	341	push eax ecx edx
342	mov ecx, application_table_mutex	342	mov ecx, application_table_mutex
343	call mutex_lock	343	call mutex_lock
344		344
345	mov eax, [current_slot_idx]	345	mov eax, [current_slot_idx]
346	shl eax, BSF sizeof.TASKDATA	346	shl eax, BSF sizeof.TASKDATA
347	add eax, TASK_TABLE+TASKDATA.pid	347	add eax, TASK_TABLE+TASKDATA.pid
348	mov eax, [eax]	348	mov eax, [eax]
349		349
350	mov [application_table_owner], eax	350	mov [application_table_owner], eax
351		351
352	pop edx ecx eax	352	pop edx ecx eax
353		353
354	ret	354	ret
355		355
356	align 4	356	align 4
357	unlock_application_table:	357	unlock_application_table:
358	push eax ecx edx	358	push eax ecx edx
359		359
360	mov [application_table_owner], 0	360	mov [application_table_owner], 0
361	mov ecx, application_table_mutex	361	mov ecx, application_table_mutex
362	call mutex_unlock	362	call mutex_unlock
363		363
364	pop edx ecx eax	364	pop edx ecx eax
365		365
366	ret	366	ret
367		367
368	; sysfn 64 implementation	368	; sysfn 64 implementation
369	align 4	369	align 4
370	sys_resize_app_memory:	370	sys_resize_app_memory:
371	; in: eax = 64 - function number	371	; in: eax = 64 - function number
372	; ebx = 1 - number of its only subfunction	372	; ebx = 1 - number of its only subfunction
373	; ecx = new amount of memory	373	; ecx = new amount of memory
374	; out:	374	; out:
375	; eax = 0 - success	375	; eax = 0 - success
376	; eax = 1 - out of memory	376	; eax = 1 - out of memory
377		377
378	; cmp eax,1	378	; cmp eax,1
379	dec ebx	379	dec ebx
380	jnz .no_application_mem_resize	380	jnz .no_application_mem_resize
381		381
382	mov eax, [pg_data.pages_free]	382	mov eax, [pg_data.pages_free]
383	shl eax, 12	383	shl eax, 12
384	cmp eax, ecx	384	cmp eax, ecx
385	jae @f	385	jae @f
386		386
387	xor eax, eax	387	xor eax, eax
388	inc eax	388	inc eax
389	jmp .store_result	389	jmp .store_result
390	@@:	390	@@:
391	stdcall new_mem_resize, ecx	391	stdcall new_mem_resize, ecx
392	.store_result:	392	.store_result:
393	mov [esp+32], eax	393	mov [esp+32], eax
394	.no_application_mem_resize:	394	.no_application_mem_resize:
395	ret	395	ret
396		396
397	iglobal	397	iglobal
398	; process_terminating db 'K : Process - terminating',13,10,0	398	; process_terminating db 'K : Process - terminating',13,10,0
399	; process_terminated db 'K : Process - done',13,10,0	399	; process_terminated db 'K : Process - done',13,10,0
400	msg_obj_destroy db 'K : destroy app object',13,10,0	400	msg_obj_destroy db 'K : destroy app object',13,10,0
401	endg	401	endg
402		402
403	; param	403	; param
404	; esi= slot	404	; esi= slot
405		405
406	align 4	406	align 4
407	terminate: ; terminate application	407	terminate: ; terminate application
408	destroy_thread:	408	destroy_thread:
409		409
410	.slot equ esp+4 ;locals	410	.slot equ esp+4 ;locals
411	.process equ esp ;ptr to parent process	411	.process equ esp ;ptr to parent process
412		412
413		413
414	push esi ;save .slot	414	push esi ;save .slot
415		415
416	shl esi, 8	416	shl esi, 8
417	mov edx, [SLOT_BASE+esi+APPDATA.process]	417	mov edx, [SLOT_BASE+esi+APPDATA.process]
418	test edx, edx	418	test edx, edx
419	jnz @F	419	jnz @F
420	pop esi	420	pop esi
421	shl esi, BSF sizeof.TASKDATA	421	shl esi, BSF sizeof.TASKDATA
422	mov [TASK_TABLE+esi+TASKDATA.state], TSTATE_FREE	422	mov [TASK_TABLE+esi+TASKDATA.state], TSTATE_FREE
423	ret	423	ret
424	@@:	424	@@:
425	push edx ;save .process	425	push edx ;save .process
426	lea edx, [SLOT_BASE+esi]	426	lea edx, [SLOT_BASE+esi]
427	call scheduler_remove_thread	427	call scheduler_remove_thread
428	call lock_application_table	428	call lock_application_table
429		429
430	; if the process is in V86 mode...	430	; if the process is in V86 mode...
431	mov eax, [.slot]	431	mov eax, [.slot]
432	shl eax, 8	432	shl eax, 8
433	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]	433	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
434	add esi, RING0_STACK_SIZE	434	add esi, RING0_STACK_SIZE
435	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi	435	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi
436	jz .nov86	436	jz .nov86
437	; ...it has page directory for V86 mode	437	; ...it has page directory for V86 mode
438	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]	438	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
439	mov ecx, [esi+4]	439	mov ecx, [esi+4]
440	mov [eax+SLOT_BASE+APPDATA.process], ecx	440	mov [eax+SLOT_BASE+APPDATA.process], ecx
441	; ...and I/O permission map for V86 mode	441	; ...and I/O permission map for V86 mode
442	mov ecx, [esi+12]	442	mov ecx, [esi+12]
443	mov [eax+SLOT_BASE+APPDATA.io_map], ecx	443	mov [eax+SLOT_BASE+APPDATA.io_map], ecx
444	mov ecx, [esi+8]	444	mov ecx, [esi+8]
445	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx	445	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
446	.nov86:	446	.nov86:
447	; destroy per-thread kernel objects	447	; destroy per-thread kernel objects
448	mov esi, [.slot]	448	mov esi, [.slot]
449	shl esi, 8	449	shl esi, 8
450	add esi, SLOT_BASE+APP_OBJ_OFFSET	450	add esi, SLOT_BASE+APP_OBJ_OFFSET
451	@@:	451	@@:
452	mov eax, [esi+APPOBJ.fd]	452	mov eax, [esi+APPOBJ.fd]
453	test eax, eax	453	test eax, eax
454	jz @F	454	jz @F
455		455
456	cmp eax, esi	456	cmp eax, esi
457	je @F	457	je @F
458		458
459	push esi	459	push esi
460	call [eax+APPOBJ.destroy]	460	call [eax+APPOBJ.destroy]
461	DEBUGF 1,"%s",msg_obj_destroy	461	DEBUGF 1,"%s",msg_obj_destroy
462	pop esi	462	pop esi
463	jmp @B	463	jmp @B
464	@@:	464	@@:
465	mov esi, [.slot]	465	mov esi, [.slot]
466	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2	466	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2
467	jne @F	467	jne @F
468		468
469	mov [fpu_owner], 2	469	mov [fpu_owner], 2
470	mov eax, [sizeof.APPDATA*2+SLOT_BASE+APPDATA.fpu_state]	470	mov eax, [sizeof.APPDATA*2+SLOT_BASE+APPDATA.fpu_state]
471	clts	471	clts
472	bt [cpu_caps], CAPS_SSE	472	bt [cpu_caps], CAPS_SSE
473	jnc .no_SSE	473	jnc .no_SSE
474	fxrstor [eax]	474	fxrstor [eax]
475	jmp @F	475	jmp @F
476	.no_SSE:	476	.no_SSE:
477	fnclex	477	fnclex
478	frstor [eax]	478	frstor [eax]
479	@@:	479	@@:
480		480
481	mov [KEY_COUNT], byte 0 ; empty keyboard buffer	481	mov [KEY_COUNT], byte 0 ; empty keyboard buffer
482	mov [BTN_COUNT], byte 0 ; empty button buffer	482	mov [BTN_COUNT], byte 0 ; empty button buffer
483		483
484		484
485	; remove defined hotkeys	485	; remove defined hotkeys
486	mov eax, hotkey_list	486	mov eax, hotkey_list
487	.loop:	487	.loop:
488	cmp [eax+8], esi	488	cmp [eax+8], esi
489	jnz .cont	489	jnz .cont
490	mov ecx, [eax]	490	mov ecx, [eax]
491	jecxz @f	491	jecxz @f
492	push dword [eax+12]	492	push dword [eax+12]
493	pop dword [ecx+12]	493	pop dword [ecx+12]
494	@@:	494	@@:
495	mov ecx, [eax+12]	495	mov ecx, [eax+12]
496	push dword [eax]	496	push dword [eax]
497	pop dword [ecx]	497	pop dword [ecx]
498	xor ecx, ecx	498	xor ecx, ecx
499	mov [eax], ecx	499	mov [eax], ecx
500	mov [eax+4], ecx	500	mov [eax+4], ecx

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc – Rev 8874 → 8876