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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc @ 473 – Rev 9976 → 10002