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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;                                                              ;;
;;  MenuetOS process management, protected ring3                ;;
;;                                                              ;;
;;  Distributed under GPL. See file COPYING for details.        ;;
;;  Copyright 2003 Ville Turjanmaa                              ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3909 $
 
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
        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 .. 0x2F - IRQ handlers
        dd      irq0, irq_serv.irq_1, irq_serv.irq_2
        dd      irq_serv.irq_3, irq_serv.irq_4
        dd      irq_serv.irq_5,  irq_serv.irq_6,  irq_serv.irq_7
        dd      irq_serv.irq_8,  irq_serv.irq_9,  irq_serv.irq_10
        dd      irq_serv.irq_11, irq_serv.irq_12, irqD, irq_serv.irq_14, irq_serv.irq_15
        dd irq_serv.irq_16
        dd irq_serv.irq_17
        dd irq_serv.irq_18
        dd irq_serv.irq_19
        dd irq_serv.irq_20
        dd irq_serv.irq_21
        dd irq_serv.irq_22
        dd irq_serv.irq_23
 
    times 32 - IRQ_RESERVED dd unknown_interrupt
    ;int_0x40 gate trap (for directly copied)
        dw      i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
 
  idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
        dw      2*($-sys_int-4)-1
        dd      idts ;0x8000B100
        dw      0    ;просто выравнивание
 
  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_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
 
  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:                 ; дуракоусточивость: селекторы испорчены...
        pop     [ss:pf_err_code]; действительно до следующего #PF
        save_ring3_context
        mov     bl, 14
 
exc_c:                          ; исключения (все, кроме 7-го - #NM)
; Фрэйм стека при исключении/прерывании из 3-го кольца + pushad (т.е., именно здесь)
  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
 ; это фрэйм от 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        ;исключение
        mov     ds, ax                  ;загрузим правильные значения
        mov     es, ax                  ;в регистры
        cld                     ; и приводим DF к стандарту
        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
        sti
; not debuggee => say error and terminate
        call    show_error_parameters ;; only ONE using, inline ???
       ;mov     edx, [TASK_BASE]
        mov     [edx + TASKDATA.state], byte 4 ; terminate
        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     byte [edx+TASKDATA.state], 1 ; 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, 0x0e
        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"
        DEBUGF  1, "K : [ESP+00]: %x [ESP+04]: %x [ESP+08]: %x\n", [ebx], [ebx+4], [ebx+8]
        DEBUGF  1, "K : [ESP+12]: %x [ESP+16]: %x [ESP+20]: %x\n", [ebx+12], [ebx+16], [ebx+20]
        DEBUGF  1, "K : [ESP+24]: %x [ESP+28]: %x [ESP+32]: %x\n", [ebx+24], [ebx+28], [ebx+32]
        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_TASK]
        shl     eax, 5
        add     eax, CURRENT_TASK+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
 
;  * eax = 64 - номер функции
;  * ebx = 1 - единственная подфункция
;  * ecx = новый размер памяти
;Возвращаемое значение:
;  * eax = 0 - успешно
;  * eax = 1 - недостаточно памяти
 
align 4
sys_resize_app_memory:
        ; ebx = 1 - resize
        ; ecx = new amount of memory
 
;        cmp    eax,1
        dec     ebx
        jnz     .no_application_mem_resize
        stdcall new_mem_resize, ecx
        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
 
           .slot equ esp   ;locals
 
        push    esi        ;save .slot
 
        shl     esi, 8
        cmp     [SLOT_BASE+esi+APPDATA.dir_table], 0
        jne     @F
        pop     esi
        shl     esi, 5
        mov     [CURRENT_TASK+esi+TASKDATA.state], 9
        ret
@@:
        lea     edx, [SLOT_BASE+esi]
        call    scheduler_remove_thread
           ;mov    esi,process_terminating
           ;call   sys_msg_board_str
        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.dir_table], 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:
 
        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     eax, [.slot]
        shl     eax, 8
        stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
 
        mov     esi, [.slot]
        cmp     [fpu_owner], esi ; if user fpu last -> fpu user = 2
        jne     @F
 
        mov     [fpu_owner], 2
        mov     eax, [256*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, 5
        mov     eax, [eax+CURRENT_TASK+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, 5
        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     [esi+WDATA.box.left], eax
        mov     [esi+WDATA.box.width], eax
        mov     [esi+WDATA.box.top], eax
        mov     [esi+WDATA.box.height], eax
        mov     [esi+WDATA.cl_workarea], eax
        mov     [esi+WDATA.cl_titlebar], eax
        mov     [esi+WDATA.cl_frames], eax
        mov     dword [esi+WDATA.reserved], eax; clear all flags: wstate, redraw, wdrawn
        lea     edi, [esi-window_data+draw_data]
        mov     ecx, 32/4
        rep stosd
        popa
 
; debuggee test
        pushad
        mov     edi, esi
        shl     edi, 5
        mov     eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
        test    eax, eax
        jz      .nodebug
        movi    ecx, 8
        push    dword [CURRENT_TASK+edi+TASKDATA.pid]; PID
        push    2
        call    debugger_notify
        pop     ecx
        pop     ecx
.nodebug:
        popad
 
        mov     ebx, [.slot]
        shl     ebx, 8
        push    ebx
        mov     ebx, [SLOT_BASE+ebx+APPDATA.pl0_stack]
 
        stdcall kernel_free, ebx
 
        pop     ebx
        mov     ebx, [SLOT_BASE+ebx+APPDATA.cur_dir]
        stdcall kernel_free, ebx
 
        mov     edi, [.slot]
        shl     edi, 8
        add     edi, SLOT_BASE
 
        mov     eax, [edi+APPDATA.io_map]
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map]
        je      @F
        call    free_page
@@:
        mov     eax, [edi+APPDATA.io_map+4]
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map+4]
        je      @F
        call    free_page
@@:
        mov     eax, 0x20202020
        stosd
        stosd
        stosd
        mov     ecx, 244/4
        xor     eax, eax
        rep stosd
 
  ; activate window
        movzx   eax, word [WIN_STACK + esi*2]
        cmp     eax, [TASK_COUNT]
        jne     .dont_activate
        pushad
 .check_next_window:
        dec     eax
        cmp     eax, 1
        jbe     .nothing_to_activate
        lea     esi, [WIN_POS+eax*2]
        movzx   edi, word [esi]              ; edi = process
        shl     edi, 5
        cmp     [CURRENT_TASK + edi + TASKDATA.state], byte 9 ; skip dead slots
        je      .check_next_window
        add     edi, window_data
; \begin{diamond}[19.09.2006]
; skip minimized windows
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
        jnz     .check_next_window
; \end{diamond}
        call    waredraw
 .nothing_to_activate:
        popad
 .dont_activate:
 
        push    esi     ; remove hd1 & cd & flp reservation
        shl     esi, 5
        mov     esi, [esi+CURRENT_TASK+TASKDATA.pid]
        cmp     [cd_status], esi
        jnz     @f
        call    free_cd_channel
        and     [cd_status], 0
@@:
        cmp     [flp_status], esi
        jnz     @f
        and     [flp_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, 5
        add     edx, CURRENT_TASK
        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, 5
        mov     [edi+CURRENT_TASK + TASKDATA.state], byte 9
; debugger test - terminate all debuggees
        mov     eax, 2
        mov     ecx, SLOT_BASE+2*0x100+APPDATA.debugger_slot
.xd0:
        cmp     eax, [TASK_COUNT]
        ja      .xd1
        cmp     dword [ecx], esi
        jnz     @f
        and     dword [ecx], 0
        pushad
        xchg    eax, ecx
        mov     ebx, 2
        call    sys_system
        popad
@@:
        inc     eax
        add     ecx, 0x100
        jmp     .xd0
.xd1:
;    call  systest
        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, 4
        ret
restore .slot
 
;build_scheduler:
;        mov     esi, boot_sched_1
;        call    boot_log
;        call   build_process_gdt_tss_pointer
 
;        mov    esi,boot_sched_2
;        call   boot_log
;        ret
 
; 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*256.
; 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 3742	Rev 3909
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. 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	;; MenuetOS process management, protected ring3 ;;	7	;; MenuetOS process management, protected ring3 ;;
8	;; ;;	8	;; ;;
9	;; Distributed under GPL. See file COPYING for details. ;;	9	;; Distributed under GPL. See file COPYING for details. ;;
10	;; Copyright 2003 Ville Turjanmaa ;;	10	;; Copyright 2003 Ville Turjanmaa ;;
11	;; ;;	11	;; ;;
12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	12	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13		13
14	$Revision: 3742 $	14	$Revision: 3909 $
15		15
16	align 4 ;3A08	16	align 4 ;3A08
17	build_interrupt_table:	17	build_interrupt_table:
18	mov edi, idts	18	mov edi, idts
19	mov esi, sys_int	19	mov esi, sys_int
20	mov ecx, 0x40	20	mov ecx, 0x40
21	mov eax, (10001110b shl 24) + os_code	21	mov eax, (10001110b shl 24) + os_code
22	@@:	22	@@:
23	movsw ;low word of code-entry	23	movsw ;low word of code-entry
24	stosd ;interrupt gate type : os_code selector	24	stosd ;interrupt gate type : os_code selector
25	movsw ;high word of code-entry	25	movsw ;high word of code-entry
26	loop @b	26	loop @b
27	movsd ;copy low dword of trap gate for int 0x40	27	movsd ;copy low dword of trap gate for int 0x40
28	movsd ;copy high dword of trap gate for int 0x40	28	movsd ;copy high dword of trap gate for int 0x40
29	lidt [esi]	29	lidt [esi]
30	ret	30	ret
31		31
32	iglobal	32	iglobal
33	align 4	33	align 4
34	sys_int:	34	sys_int:
35	;exception handlers addresses (for interrupt gate construction)	35	;exception handlers addresses (for interrupt gate construction)
36	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc	36	dd e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
37	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15	37	dd e8,e9,e10,e11,e12,e13,page_fault_exc,e15
38	dd e16, e17,e18, e19	38	dd e16, e17,e18, e19
39	times 12 dd unknown_interrupt ;int_20..int_31	39	times 12 dd unknown_interrupt ;int_20..int_31
40		40
41	;interrupt handlers addresses (for interrupt gate construction)	41	;interrupt handlers addresses (for interrupt gate construction)
42	; 0x20 .. 0x2F - IRQ handlers	42	; 0x20 .. 0x2F - IRQ handlers
43	dd irq0, irq_serv.irq_1, irq_serv.irq_2	43	dd irq0, irq_serv.irq_1, irq_serv.irq_2
44	dd irq_serv.irq_3, irq_serv.irq_4	44	dd irq_serv.irq_3, irq_serv.irq_4
45	dd irq_serv.irq_5, irq_serv.irq_6, irq_serv.irq_7	45	dd irq_serv.irq_5, irq_serv.irq_6, irq_serv.irq_7
46	dd irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10	46	dd irq_serv.irq_8, irq_serv.irq_9, irq_serv.irq_10
47	dd irq_serv.irq_11, irq_serv.irq_12, irqD, irq_serv.irq_14, irq_serv.irq_15	47	dd irq_serv.irq_11, irq_serv.irq_12, irqD, irq_serv.irq_14, irq_serv.irq_15
48	dd irq_serv.irq_16	48	dd irq_serv.irq_16
49	dd irq_serv.irq_17	49	dd irq_serv.irq_17
50	dd irq_serv.irq_18	50	dd irq_serv.irq_18
51	dd irq_serv.irq_19	51	dd irq_serv.irq_19
52	dd irq_serv.irq_20	52	dd irq_serv.irq_20
53	dd irq_serv.irq_21	53	dd irq_serv.irq_21
54	dd irq_serv.irq_22	54	dd irq_serv.irq_22
55	dd irq_serv.irq_23	55	dd irq_serv.irq_23
56		56
57	times 32 - IRQ_RESERVED dd unknown_interrupt	57	times 32 - IRQ_RESERVED dd unknown_interrupt
58	;int_0x40 gate trap (for directly copied)	58	;int_0x40 gate trap (for directly copied)
59	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16	59	dw i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
60		60
61	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)	61	idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
62	dw 2*($-sys_int-4)-1	62	dw 2*($-sys_int-4)-1
63	dd idts ;0x8000B100	63	dd idts ;0x8000B100
64	dw 0 ;просто выравнивание	64	dw 0 ;просто выравнивание
65		65
66	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b	66	msg_fault_sel dd msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
67	dd msg_exc_c,msg_exc_d,msg_exc_e	67	dd msg_exc_c,msg_exc_d,msg_exc_e
68		68
69	msg_exc_8 db "Double fault", 0	69	msg_exc_8 db "Double fault", 0
70	msg_exc_u db "Undefined Exception", 0	70	msg_exc_u db "Undefined Exception", 0
71	msg_exc_a db "Invalid TSS", 0	71	msg_exc_a db "Invalid TSS", 0
72	msg_exc_b db "Segment not present", 0	72	msg_exc_b db "Segment not present", 0
73	msg_exc_c db "Stack fault", 0	73	msg_exc_c db "Stack fault", 0
74	msg_exc_d db "General protection fault", 0	74	msg_exc_d db "General protection fault", 0
75	msg_exc_e db "Page fault", 0	75	msg_exc_e db "Page fault", 0
76		76
77	if lang eq sp	77	if lang eq sp
78	include 'core/sys32-sp.inc'	78	include 'core/sys32-sp.inc'
79	else	79	else
80	msg_sel_ker db "kernel", 0	80	msg_sel_ker db "kernel", 0
81	msg_sel_app db "application", 0	81	msg_sel_app db "application", 0
82	end if	82	end if
83		83
84	endg	84	endg
85		85
86	macro save_ring3_context {	86	macro save_ring3_context {
87	pushad	87	pushad
88	}	88	}
89	macro restore_ring3_context {	89	macro restore_ring3_context {
90	popad	90	popad
91	}	91	}
92	macro exc_wo_code [num] {	92	macro exc_wo_code [num] {
93	e#num :	93	e#num :
94	save_ring3_context	94	save_ring3_context
95	mov bl, num	95	mov bl, num
96	jmp exc_c	96	jmp exc_c
97	} exc_wo_code 0,1,2,3,4,5,6,15,16,19	97	} exc_wo_code 0,1,2,3,4,5,6,15,16,19
98		98
99	macro exc_w_code [num] {	99	macro exc_w_code [num] {
100	e#num :	100	e#num :
101	add esp, 4	101	add esp, 4
102	save_ring3_context	102	save_ring3_context
103	mov bl, num	103	mov bl, num
104	jmp exc_c	104	jmp exc_c
105	} exc_w_code 8,9,10,11,12,13,17,18	105	} exc_w_code 8,9,10,11,12,13,17,18
106		106
107		107
108	uglobal	108	uglobal
109	pf_err_code dd ?	109	pf_err_code dd ?
110	endg	110	endg
111		111
112	page_fault_exc: ; дуракоусточивость: селекторы испорчены...	112	page_fault_exc: ; дуракоусточивость: селекторы испорчены...
113	pop [ss:pf_err_code]; действительно до следующего #PF	113	pop [ss:pf_err_code]; действительно до следующего #PF
114	save_ring3_context	114	save_ring3_context
115	mov bl, 14	115	mov bl, 14
116		116
117	exc_c: ; исключения (все, кроме 7-го - #NM)	117	exc_c: ; исключения (все, кроме 7-го - #NM)
118	; Фрэйм стека при исключении/прерывании из 3-го кольца + pushad (т.е., именно здесь)	118	; Фрэйм стека при исключении/прерывании из 3-го кольца + pushad (т.е., именно здесь)
119	reg_ss equ esp+0x30	119	reg_ss equ esp+0x30
120	reg_esp3 equ esp+0x2C	120	reg_esp3 equ esp+0x2C
121	reg_eflags equ esp+0x28	121	reg_eflags equ esp+0x28
122	reg_cs3 equ esp+0x24	122	reg_cs3 equ esp+0x24
123	reg_eip equ esp+0x20	123	reg_eip equ esp+0x20
124	; это фрэйм от pushad	124	; это фрэйм от pushad
125	reg_eax equ esp+0x1C	125	reg_eax equ esp+0x1C
126	reg_ecx equ esp+0x18	126	reg_ecx equ esp+0x18
127	reg_edx equ esp+0x14	127	reg_edx equ esp+0x14
128	reg_ebx equ esp+0x10	128	reg_ebx equ esp+0x10
129	reg_esp0 equ esp+0x0C	129	reg_esp0 equ esp+0x0C
130	reg_ebp equ esp+0x08	130	reg_ebp equ esp+0x08
131	reg_esi equ esp+0x04	131	reg_esi equ esp+0x04
132	reg_edi equ esp+0x00	132	reg_edi equ esp+0x00
133		133
134	mov ax, app_data ;исключение	134	mov ax, app_data ;исключение
135	mov ds, ax ;загрузим правильные значения	135	mov ds, ax ;загрузим правильные значения
136	mov es, ax ;в регистры	136	mov es, ax ;в регистры
137	cld ; и приводим DF к стандарту	137	cld ; и приводим DF к стандарту
138	movzx ebx, bl	138	movzx ebx, bl
139	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?	139	; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
140	test byte[reg_eflags+2], 2	140	test byte[reg_eflags+2], 2
141	jnz v86_exc_c	141	jnz v86_exc_c
142	cmp bl, 14 ; #PF	142	cmp bl, 14 ; #PF
143	jne @f	143	jne @f
144	call page_fault_handler ; SEE: core/memory.inc	144	call page_fault_handler ; SEE: core/memory.inc
145	@@:	145	@@:
146	mov esi, [current_slot]	146	mov esi, [current_slot]
147	btr [esi+APPDATA.except_mask], ebx	147	btr [esi+APPDATA.except_mask], ebx
148	jnc @f	148	jnc @f
149	mov eax, [esi+APPDATA.exc_handler]	149	mov eax, [esi+APPDATA.exc_handler]
150	test eax, eax	150	test eax, eax
151	jnz IRetToUserHook	151	jnz IRetToUserHook
152	@@:	152	@@:
153	cli	153	cli
154	mov eax, [esi+APPDATA.debugger_slot]	154	mov eax, [esi+APPDATA.debugger_slot]
155	test eax, eax	155	test eax, eax
156	jnz .debug	156	jnz .debug
157	sti	157	sti
158	; not debuggee => say error and terminate	158	; not debuggee => say error and terminate
159	call show_error_parameters ;; only ONE using, inline ???	159	call show_error_parameters ;; only ONE using, inline ???
160	;mov edx, [TASK_BASE]	160	;mov edx, [TASK_BASE]
161	mov [edx + TASKDATA.state], byte 4 ; terminate	161	mov [edx + TASKDATA.state], byte 4 ; terminate
162	call wakeup_osloop	162	call wakeup_osloop
163	call change_task	163	call change_task
164	; If we're here, then the main OS thread has crashed before initializing IDLE thread.	164	; If we're here, then the main OS thread has crashed before initializing IDLE thread.
165	; Or they both have crashed. Anyway, things are hopelessly broken.	165	; Or they both have crashed. Anyway, things are hopelessly broken.
166	hlt	166	hlt
167	jmp $-1	167	jmp $-1
168	.debug:	168	.debug:
169	; we are debugged process, notify debugger and suspend ourself	169	; we are debugged process, notify debugger and suspend ourself
170	; eax=debugger PID	170	; eax=debugger PID
171	mov ecx, 1 ; debug_message code=other_exception	171	mov ecx, 1 ; debug_message code=other_exception
172	cmp bl, 1 ; #DB	172	cmp bl, 1 ; #DB
173	jne .notify ; notify debugger and suspend ourself	173	jne .notify ; notify debugger and suspend ourself
174	mov ebx, dr6 ; debug_message data=DR6_image	174	mov ebx, dr6 ; debug_message data=DR6_image
175	xor edx, edx	175	xor edx, edx
176	mov dr6, edx	176	mov dr6, edx
177	mov edx, dr7	177	mov edx, dr7
178	mov cl, not 8	178	mov cl, not 8
179	.l1:	179	.l1:
180	shl dl, 2	180	shl dl, 2
181	jc @f	181	jc @f
182	and bl, cl	182	and bl, cl
183	@@:	183	@@:
184	sar cl, 1	184	sar cl, 1
185	jc .l1	185	jc .l1
186	mov cl, 3 ; debug_message code=debug_exception	186	mov cl, 3 ; debug_message code=debug_exception
187	.notify:	187	.notify:
188	push ebx ; debug_message data	188	push ebx ; debug_message data
189	mov ebx, [TASK_BASE]	189	mov ebx, [TASK_BASE]
190	push [ebx+TASKDATA.pid] ; PID	190	push [ebx+TASKDATA.pid] ; PID
191	push ecx ; debug_message code ((here: ecx==1/3))	191	push ecx ; debug_message code ((here: ecx==1/3))
192	mov cl, 12 ; debug_message size	192	mov cl, 12 ; debug_message size
193	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc	193	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
194	add esp, 12	194	add esp, 12
195	mov edx, [TASK_BASE]	195	mov edx, [TASK_BASE]
196	mov byte [edx+TASKDATA.state], 1 ; suspended	196	mov byte [edx+TASKDATA.state], 1 ; suspended
197	call change_task ; SEE: core/shed.inc	197	call change_task ; SEE: core/shed.inc
198	restore_ring3_context	198	restore_ring3_context
199	iretd	199	iretd
200		200
201	IRetToUserHook:	201	IRetToUserHook:
202	xchg eax, [reg_eip]	202	xchg eax, [reg_eip]
203	sub dword[reg_esp3], 8	203	sub dword[reg_esp3], 8
204	mov edi, [reg_esp3]	204	mov edi, [reg_esp3]
205	stosd	205	stosd
206	mov [edi], ebx	206	mov [edi], ebx
207	restore_ring3_context	207	restore_ring3_context
208	; simply return control to interrupted process	208	; simply return control to interrupted process
209	unknown_interrupt:	209	unknown_interrupt:
210	iretd	210	iretd
211		211
212	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	212	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
213	; bl - error vector	213	; bl - error vector
214	show_error_parameters:	214	show_error_parameters:
215	cmp bl, 0x06	215	cmp bl, 0x06
216	jnz .no_ud	216	jnz .no_ud
217	push ebx	217	push ebx
218	mov ebx, ud_user_message	218	mov ebx, ud_user_message
219	mov ebp, notifyapp	219	mov ebp, notifyapp
220	call fs_execute_from_sysdir_param	220	call fs_execute_from_sysdir_param
221	pop ebx	221	pop ebx
222	.no_ud:	222	.no_ud:
223	mov edx, [TASK_BASE];not scratched below	223	mov edx, [TASK_BASE];not scratched below
224	if lang eq sp	224	if lang eq sp
225	DEBUGF 1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]	225	DEBUGF 1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
226	else	226	else
227	DEBUGF 1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]	227	DEBUGF 1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
228	end if	228	end if
229	cmp bl, 0x08	229	cmp bl, 0x08
230	jb .l0	230	jb .l0
231	cmp bl, 0x0e	231	cmp bl, 0x0e
232	jbe .l1	232	jbe .l1
233	.l0:	233	.l0:
234	mov bl, 0x09	234	mov bl, 0x09
235	.l1:	235	.l1:
236	mov eax, [msg_fault_sel+ebx4 - 0x084]	236	mov eax, [msg_fault_sel+ebx4 - 0x084]
237	DEBUGF 1, "K : %s\n", eax	237	DEBUGF 1, "K : %s\n", eax
238	mov eax, [reg_cs3+4]	238	mov eax, [reg_cs3+4]
239	mov edi, msg_sel_app	239	mov edi, msg_sel_app
240	mov ebx, [reg_esp3+4]	240	mov ebx, [reg_esp3+4]
241	cmp eax, app_code	241	cmp eax, app_code
242	je @f	242	je @f
243	mov edi, msg_sel_ker	243	mov edi, msg_sel_ker
244	mov ebx, [reg_esp0+4]	244	mov ebx, [reg_esp0+4]
245	@@:	245	@@:
246	DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]	246	DEBUGF 1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
247	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]	247	DEBUGF 1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
248	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx	248	DEBUGF 1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
249	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi	249	DEBUGF 1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
-		250	DEBUGF 1, "K : Stack dump:\n"
-		251	DEBUGF 1, "K : [ESP+00]: %x [ESP+04]: %x [ESP+08]: %x\n", [ebx], [ebx+4], [ebx+8]
-		252	DEBUGF 1, "K : [ESP+12]: %x [ESP+16]: %x [ESP+20]: %x\n", [ebx+12], [ebx+16], [ebx+20]
-		253	DEBUGF 1, "K : [ESP+24]: %x [ESP+28]: %x [ESP+32]: %x\n", [ebx+24], [ebx+28], [ebx+32]
250	ret	254	ret
251	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	255	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
252		256
253	restore reg_ss	257	restore reg_ss
254	restore reg_esp3	258	restore reg_esp3
255	restore reg_eflags	259	restore reg_eflags
256	restore reg_cs	260	restore reg_cs
257	restore reg_eip	261	restore reg_eip
258	restore reg_eax	262	restore reg_eax
259	restore reg_ecx	263	restore reg_ecx
260	restore reg_edx	264	restore reg_edx
261	restore reg_ebx	265	restore reg_ebx
262	restore reg_esp0	266	restore reg_esp0
263	restore reg_ebp	267	restore reg_ebp
264	restore reg_esi	268	restore reg_esi
265	restore reg_edi	269	restore reg_edi
266		270
267		271
268	align 4	272	align 4
269	lock_application_table:	273	lock_application_table:
270	push eax ecx edx	274	push eax ecx edx
271	mov ecx, application_table_mutex	275	mov ecx, application_table_mutex
272	call mutex_lock	276	call mutex_lock
273		277
274	mov eax, [CURRENT_TASK]	278	mov eax, [CURRENT_TASK]
275	shl eax, 5	279	shl eax, 5
276	add eax, CURRENT_TASK+TASKDATA.pid	280	add eax, CURRENT_TASK+TASKDATA.pid
277	mov eax, [eax]	281	mov eax, [eax]
278		282
279	mov [application_table_owner], eax	283	mov [application_table_owner], eax
280		284
281	pop edx ecx eax	285	pop edx ecx eax
282		286
283	ret	287	ret
284		288
285	align 4	289	align 4
286	unlock_application_table:	290	unlock_application_table:
287	push eax ecx edx	291	push eax ecx edx
288		292
289	mov [application_table_owner], 0	293	mov [application_table_owner], 0
290	mov ecx, application_table_mutex	294	mov ecx, application_table_mutex
291	call mutex_unlock	295	call mutex_unlock
292		296
293	pop edx ecx eax	297	pop edx ecx eax
294		298
295	ret	299	ret
296		300
297	; * eax = 64 - номер функции	301	; * eax = 64 - номер функции
298	; * ebx = 1 - единственная подфункция	302	; * ebx = 1 - единственная подфункция
299	; * ecx = новый размер памяти	303	; * ecx = новый размер памяти
300	;Возвращаемое значение:	304	;Возвращаемое значение:
301	; * eax = 0 - успешно	305	; * eax = 0 - успешно
302	; * eax = 1 - недостаточно памяти	306	; * eax = 1 - недостаточно памяти
303		307
304	align 4	308	align 4
305	sys_resize_app_memory:	309	sys_resize_app_memory:
306	; ebx = 1 - resize	310	; ebx = 1 - resize
307	; ecx = new amount of memory	311	; ecx = new amount of memory
308		312
309	; cmp eax,1	313	; cmp eax,1
310	dec ebx	314	dec ebx
311	jnz .no_application_mem_resize	315	jnz .no_application_mem_resize
312	stdcall new_mem_resize, ecx	316	stdcall new_mem_resize, ecx
313	mov [esp+32], eax	317	mov [esp+32], eax
314	.no_application_mem_resize:	318	.no_application_mem_resize:
315	ret	319	ret
316		320
317	iglobal	321	iglobal
318	; process_terminating db 'K : Process - terminating',13,10,0	322	; process_terminating db 'K : Process - terminating',13,10,0
319	; process_terminated db 'K : Process - done',13,10,0	323	; process_terminated db 'K : Process - done',13,10,0
320	msg_obj_destroy db 'K : destroy app object',13,10,0	324	msg_obj_destroy db 'K : destroy app object',13,10,0
321	endg	325	endg
322		326
323	; param	327	; param
324	; esi= slot	328	; esi= slot
325		329
326	align 4	330	align 4
327	terminate: ; terminate application	331	terminate: ; terminate application
328		332
329	.slot equ esp ;locals	333	.slot equ esp ;locals
330		334
331	push esi ;save .slot	335	push esi ;save .slot
332		336
333	shl esi, 8	337	shl esi, 8
334	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0	338	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0
335	jne @F	339	jne @F
336	pop esi	340	pop esi
337	shl esi, 5	341	shl esi, 5
338	mov [CURRENT_TASK+esi+TASKDATA.state], 9	342	mov [CURRENT_TASK+esi+TASKDATA.state], 9
339	ret	343	ret
340	@@:	344	@@:
341	lea edx, [SLOT_BASE+esi]	345	lea edx, [SLOT_BASE+esi]
342	call scheduler_remove_thread	346	call scheduler_remove_thread
343	;mov esi,process_terminating	347	;mov esi,process_terminating
344	;call sys_msg_board_str	348	;call sys_msg_board_str
345	call lock_application_table	349	call lock_application_table
346		350
347	; if the process is in V86 mode...	351	; if the process is in V86 mode...
348	mov eax, [.slot]	352	mov eax, [.slot]
349	shl eax, 8	353	shl eax, 8
350	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]	354	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
351	add esi, RING0_STACK_SIZE	355	add esi, RING0_STACK_SIZE
352	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi	356	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi
353	jz .nov86	357	jz .nov86
354	; ...it has page directory for V86 mode	358	; ...it has page directory for V86 mode
355	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]	359	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
356	mov ecx, [esi+4]	360	mov ecx, [esi+4]
357	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx	361	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx
358	; ...and I/O permission map for V86 mode	362	; ...and I/O permission map for V86 mode
359	mov ecx, [esi+12]	363	mov ecx, [esi+12]
360	mov [eax+SLOT_BASE+APPDATA.io_map], ecx	364	mov [eax+SLOT_BASE+APPDATA.io_map], ecx
361	mov ecx, [esi+8]	365	mov ecx, [esi+8]
362	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx	366	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
363	.nov86:	367	.nov86:
364		368
365	mov esi, [.slot]	369	mov esi, [.slot]
366	shl esi, 8	370	shl esi, 8
367	add esi, SLOT_BASE+APP_OBJ_OFFSET	371	add esi, SLOT_BASE+APP_OBJ_OFFSET
368	@@:	372	@@:
369	mov eax, [esi+APPOBJ.fd]	373	mov eax, [esi+APPOBJ.fd]
370	test eax, eax	374	test eax, eax
371	jz @F	375	jz @F
372		376
373	cmp eax, esi	377	cmp eax, esi
374	je @F	378	je @F
375		379
376	push esi	380	push esi
377	call [eax+APPOBJ.destroy]	381	call [eax+APPOBJ.destroy]
378	DEBUGF 1,"%s",msg_obj_destroy	382	DEBUGF 1,"%s",msg_obj_destroy
379	pop esi	383	pop esi
380	jmp @B	384	jmp @B
381	@@:	385	@@:
382		386
383	mov eax, [.slot]	387	mov eax, [.slot]
384	shl eax, 8	388	shl eax, 8
385	stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]	389	stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
386		390
387	mov esi, [.slot]	391	mov esi, [.slot]
388	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2	392	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2
389	jne @F	393	jne @F
390		394
391	mov [fpu_owner], 2	395	mov [fpu_owner], 2
392	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]	396	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]
393	clts	397	clts
394	bt [cpu_caps], CAPS_SSE	398	bt [cpu_caps], CAPS_SSE
395	jnc .no_SSE	399	jnc .no_SSE
396	fxrstor [eax]	400	fxrstor [eax]
397	jmp @F	401	jmp @F
398	.no_SSE:	402	.no_SSE:
399	fnclex	403	fnclex
400	frstor [eax]	404	frstor [eax]
401	@@:	405	@@:
402		406
403	mov [KEY_COUNT], byte 0 ; empty keyboard buffer	407	mov [KEY_COUNT], byte 0 ; empty keyboard buffer
404	mov [BTN_COUNT], byte 0 ; empty button buffer	408	mov [BTN_COUNT], byte 0 ; empty button buffer
405		409
406		410
407	; remove defined hotkeys	411	; remove defined hotkeys
408	mov eax, hotkey_list	412	mov eax, hotkey_list
409	.loop:	413	.loop:
410	cmp [eax+8], esi	414	cmp [eax+8], esi
411	jnz .cont	415	jnz .cont
412	mov ecx, [eax]	416	mov ecx, [eax]
413	jecxz @f	417	jecxz @f
414	push dword [eax+12]	418	push dword [eax+12]
415	pop dword [ecx+12]	419	pop dword [ecx+12]
416	@@:	420	@@:
417	mov ecx, [eax+12]	421	mov ecx, [eax+12]
418	push dword [eax]	422	push dword [eax]
419	pop dword [ecx]	423	pop dword [ecx]
420	xor ecx, ecx	424	xor ecx, ecx
421	mov [eax], ecx	425	mov [eax], ecx
422	mov [eax+4], ecx	426	mov [eax+4], ecx
423	mov [eax+8], ecx	427	mov [eax+8], ecx
424	mov [eax+12], ecx	428	mov [eax+12], ecx
425	.cont:	429	.cont:
426	add eax, 16	430	add eax, 16
427	cmp eax, hotkey_list+256*16	431	cmp eax, hotkey_list+256*16
428	jb .loop	432	jb .loop
429	; get process PID	433	; get process PID
430	mov eax, esi	434	mov eax, esi
431	shl eax, 5	435	shl eax, 5
432	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]	436	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]
433	; compare current lock input with process PID	437	; compare current lock input with process PID
434	cmp eax, [PID_lock_input]	438	cmp eax, [PID_lock_input]
435	jne @f	439	jne @f
436		440
437	xor eax, eax	441	xor eax, eax
438	mov [PID_lock_input], eax	442	mov [PID_lock_input], eax
439	@@:	443	@@:
440	; remove hotkeys in buffer	444	; remove hotkeys in buffer
441	mov eax, hotkey_buffer	445	mov eax, hotkey_buffer
442	.loop2:	446	.loop2:
443	cmp [eax], esi	447	cmp [eax], esi
444	jnz .cont2	448	jnz .cont2
445	and dword [eax+4], 0	449	and dword [eax+4], 0
446	and dword [eax], 0	450	and dword [eax], 0
447	.cont2:	451	.cont2:
448	add eax, 8	452	add eax, 8
449	cmp eax, hotkey_buffer+120*8	453	cmp eax, hotkey_buffer+120*8
450	jb .loop2	454	jb .loop2
451		455
452	mov ecx, esi ; remove buttons	456	mov ecx, esi ; remove buttons
453	bnewba2:	457	bnewba2:
454	mov edi, [BTN_ADDR]	458	mov edi, [BTN_ADDR]
455	mov eax, edi	459	mov eax, edi
456	cld	460	cld
457	movzx ebx, word [edi]	461	movzx ebx, word [edi]
458	inc bx	462	inc bx
459	bnewba:	463	bnewba:
460	dec bx	464	dec bx
461	jz bnmba	465	jz bnmba
462	add eax, 0x10	466	add eax, 0x10
463	cmp cx, [eax]	467	cmp cx, [eax]
464	jnz bnewba	468	jnz bnewba
465	pusha	469	pusha
466	mov ecx, ebx	470	mov ecx, ebx
467	inc ecx	471	inc ecx
468	shl ecx, 4	472	shl ecx, 4
469	mov ebx, eax	473	mov ebx, eax
470	add eax, 0x10	474	add eax, 0x10
471	call memmove	475	call memmove
472	dec dword [edi]	476	dec dword [edi]
473	popa	477	popa
474	jmp bnewba2	478	jmp bnewba2
475	bnmba:	479	bnmba:
476		480
477	pusha ; save window coordinates for window restoring	481	pusha ; save window coordinates for window restoring
478	cld	482	cld
479	shl esi, 5	483	shl esi, 5
480	add esi, window_data	484	add esi, window_data
481	mov eax, [esi+WDATA.box.left]	485	mov eax, [esi+WDATA.box.left]
482	mov [draw_limits.left], eax	486	mov [draw_limits.left], eax
483	add eax, [esi+WDATA.box.width]	487	add eax, [esi+WDATA.box.width]
484	mov [draw_limits.right], eax	488	mov [draw_limits.right], eax
485	mov eax, [esi+WDATA.box.top]	489	mov eax, [esi+WDATA.box.top]
486	mov [draw_limits.top], eax	490	mov [draw_limits.top], eax
487	add eax, [esi+WDATA.box.height]	491	add eax, [esi+WDATA.box.height]
488	mov [draw_limits.bottom], eax	492	mov [draw_limits.bottom], eax
489		493
490	xor eax, eax	494	xor eax, eax
491	mov [esi+WDATA.box.left], eax	495	mov [esi+WDATA.box.left], eax
492	mov [esi+WDATA.box.width], eax	496	mov [esi+WDATA.box.width], eax
493	mov [esi+WDATA.box.top], eax	497	mov [esi+WDATA.box.top], eax
494	mov [esi+WDATA.box.height], eax	498	mov [esi+WDATA.box.height], eax
495	mov [esi+WDATA.cl_workarea], eax	499	mov [esi+WDATA.cl_workarea], eax
496	mov [esi+WDATA.cl_titlebar], eax	500	mov [esi+WDATA.cl_titlebar], eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/sys32.inc @ 8093 – Rev 3742 → 3909