WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/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: 3626 $
 
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
        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     [hd1_status], esi
        jnz     @f
        call    free_hd_channel
        and     [hd1_status], 0
@@:
        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 3555	Rev 3626
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: 3555 $	14	$Revision: 3626 $
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	jmp change_task ; stack - here it does not matter at all, SEE: core/shed.inc	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.
-		166	hlt
-		167	jmp $-1
164	.debug:	168	.debug:
165	; we are debugged process, notify debugger and suspend ourself	169	; we are debugged process, notify debugger and suspend ourself
166	; eax=debugger PID	170	; eax=debugger PID
167	mov ecx, 1 ; debug_message code=other_exception	171	mov ecx, 1 ; debug_message code=other_exception
168	cmp bl, 1 ; #DB	172	cmp bl, 1 ; #DB
169	jne .notify ; notify debugger and suspend ourself	173	jne .notify ; notify debugger and suspend ourself
170	mov ebx, dr6 ; debug_message data=DR6_image	174	mov ebx, dr6 ; debug_message data=DR6_image
171	xor edx, edx	175	xor edx, edx
172	mov dr6, edx	176	mov dr6, edx
173	mov edx, dr7	177	mov edx, dr7
174	mov cl, not 8	178	mov cl, not 8
175	.l1:	179	.l1:
176	shl dl, 2	180	shl dl, 2
177	jc @f	181	jc @f
178	and bl, cl	182	and bl, cl
179	@@:	183	@@:
180	sar cl, 1	184	sar cl, 1
181	jc .l1	185	jc .l1
182	mov cl, 3 ; debug_message code=debug_exception	186	mov cl, 3 ; debug_message code=debug_exception
183	.notify:	187	.notify:
184	push ebx ; debug_message data	188	push ebx ; debug_message data
185	mov ebx, [TASK_BASE]	189	mov ebx, [TASK_BASE]
186	push [ebx+TASKDATA.pid] ; PID	190	push [ebx+TASKDATA.pid] ; PID
187	push ecx ; debug_message code ((here: ecx==1/3))	191	push ecx ; debug_message code ((here: ecx==1/3))
188	mov cl, 12 ; debug_message size	192	mov cl, 12 ; debug_message size
189	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc	193	call debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
190	add esp, 12	194	add esp, 12
191	mov edx, [TASK_BASE]	195	mov edx, [TASK_BASE]
192	mov byte [edx+TASKDATA.state], 1 ; suspended	196	mov byte [edx+TASKDATA.state], 1 ; suspended
193	call change_task ; SEE: core/shed.inc	197	call change_task ; SEE: core/shed.inc
194	restore_ring3_context	198	restore_ring3_context
195	iretd	199	iretd
196		200
197	IRetToUserHook:	201	IRetToUserHook:
198	xchg eax, [reg_eip]	202	xchg eax, [reg_eip]
199	sub dword[reg_esp3], 8	203	sub dword[reg_esp3], 8
200	mov edi, [reg_esp3]	204	mov edi, [reg_esp3]
201	stosd	205	stosd
202	mov [edi], ebx	206	mov [edi], ebx
203	restore_ring3_context	207	restore_ring3_context
204	; simply return control to interrupted process	208	; simply return control to interrupted process
205	unknown_interrupt:	209	unknown_interrupt:
206	iretd	210	iretd
207		211
208	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	212	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
209	; bl - error vector	213	; bl - error vector
210	show_error_parameters:	214	show_error_parameters:
211	cmp bl, 0x06	215	cmp bl, 0x06
212	jnz .no_ud	216	jnz .no_ud
213	push ebx	217	push ebx
214	mov ebx, ud_user_message	218	mov ebx, ud_user_message
215	mov ebp, notifyapp	219	mov ebp, notifyapp
216	call fs_execute_from_sysdir_param	220	call fs_execute_from_sysdir_param
217	pop ebx	221	pop ebx
218	.no_ud:	222	.no_ud:
219	mov edx, [TASK_BASE];not scratched below	223	mov edx, [TASK_BASE];not scratched below
220	if lang eq sp	224	if lang eq sp
221	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]
222	else	226	else
223	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]
224	end if	228	end if
225	cmp bl, 0x08	229	cmp bl, 0x08
226	jb .l0	230	jb .l0
227	cmp bl, 0x0e	231	cmp bl, 0x0e
228	jbe .l1	232	jbe .l1
229	.l0:	233	.l0:
230	mov bl, 0x09	234	mov bl, 0x09
231	.l1:	235	.l1:
232	mov eax, [msg_fault_sel+ebx4 - 0x084]	236	mov eax, [msg_fault_sel+ebx4 - 0x084]
233	DEBUGF 1, "K : %s\n", eax	237	DEBUGF 1, "K : %s\n", eax
234	mov eax, [reg_cs3+4]	238	mov eax, [reg_cs3+4]
235	mov edi, msg_sel_app	239	mov edi, msg_sel_app
236	mov ebx, [reg_esp3+4]	240	mov ebx, [reg_esp3+4]
237	cmp eax, app_code	241	cmp eax, app_code
238	je @f	242	je @f
239	mov edi, msg_sel_ker	243	mov edi, msg_sel_ker
240	mov ebx, [reg_esp0+4]	244	mov ebx, [reg_esp0+4]
241	@@:	245	@@:
242	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]
243	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]
244	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
245	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
246	ret	250	ret
247	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	251	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
248		252
249	restore reg_ss	253	restore reg_ss
250	restore reg_esp3	254	restore reg_esp3
251	restore reg_eflags	255	restore reg_eflags
252	restore reg_cs	256	restore reg_cs
253	restore reg_eip	257	restore reg_eip
254	restore reg_eax	258	restore reg_eax
255	restore reg_ecx	259	restore reg_ecx
256	restore reg_edx	260	restore reg_edx
257	restore reg_ebx	261	restore reg_ebx
258	restore reg_esp0	262	restore reg_esp0
259	restore reg_ebp	263	restore reg_ebp
260	restore reg_esi	264	restore reg_esi
261	restore reg_edi	265	restore reg_edi
262		266
263		267
264	align 4	268	align 4
265	lock_application_table:	269	lock_application_table:
266	push eax ecx edx	270	push eax ecx edx
267	mov ecx, application_table_mutex	271	mov ecx, application_table_mutex
268	call mutex_lock	272	call mutex_lock
269		273
270	mov eax, [CURRENT_TASK]	274	mov eax, [CURRENT_TASK]
271	shl eax, 5	275	shl eax, 5
272	add eax, CURRENT_TASK+TASKDATA.pid	276	add eax, CURRENT_TASK+TASKDATA.pid
273	mov eax, [eax]	277	mov eax, [eax]
274		278
275	mov [application_table_owner], eax	279	mov [application_table_owner], eax
276		280
277	pop edx ecx eax	281	pop edx ecx eax
278		282
279	ret	283	ret
280		284
281	align 4	285	align 4
282	unlock_application_table:	286	unlock_application_table:
283	push eax ecx edx	287	push eax ecx edx
284		288
285	mov [application_table_owner], 0	289	mov [application_table_owner], 0
286	mov ecx, application_table_mutex	290	mov ecx, application_table_mutex
287	call mutex_unlock	291	call mutex_unlock
288		292
289	pop edx ecx eax	293	pop edx ecx eax
290		294
291	ret	295	ret
292		296
293	; * eax = 64 - номер функции	297	; * eax = 64 - номер функции
294	; * ebx = 1 - единственная подфункция	298	; * ebx = 1 - единственная подфункция
295	; * ecx = новый размер памяти	299	; * ecx = новый размер памяти
296	;Возвращаемое значение:	300	;Возвращаемое значение:
297	; * eax = 0 - успешно	301	; * eax = 0 - успешно
298	; * eax = 1 - недостаточно памяти	302	; * eax = 1 - недостаточно памяти
299		303
300	align 4	304	align 4
301	sys_resize_app_memory:	305	sys_resize_app_memory:
302	; ebx = 1 - resize	306	; ebx = 1 - resize
303	; ecx = new amount of memory	307	; ecx = new amount of memory
304		308
305	; cmp eax,1	309	; cmp eax,1
306	dec ebx	310	dec ebx
307	jnz .no_application_mem_resize	311	jnz .no_application_mem_resize
308	stdcall new_mem_resize, ecx	312	stdcall new_mem_resize, ecx
309	mov [esp+32], eax	313	mov [esp+32], eax
310	.no_application_mem_resize:	314	.no_application_mem_resize:
311	ret	315	ret
312		316
313	iglobal	317	iglobal
314	; process_terminating db 'K : Process - terminating',13,10,0	318	; process_terminating db 'K : Process - terminating',13,10,0
315	; process_terminated db 'K : Process - done',13,10,0	319	; process_terminated db 'K : Process - done',13,10,0
316	msg_obj_destroy db 'K : destroy app object',13,10,0	320	msg_obj_destroy db 'K : destroy app object',13,10,0
317	endg	321	endg
318		322
319	; param	323	; param
320	; esi= slot	324	; esi= slot
321		325
322	align 4	326	align 4
323	terminate: ; terminate application	327	terminate: ; terminate application
324		328
325	.slot equ esp ;locals	329	.slot equ esp ;locals
326		330
327	push esi ;save .slot	331	push esi ;save .slot
328		332
329	shl esi, 8	333	shl esi, 8
330	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0	334	cmp [SLOT_BASE+esi+APPDATA.dir_table], 0
331	jne @F	335	jne @F
332	pop esi	336	pop esi
333	shl esi, 5	337	shl esi, 5
334	mov [CURRENT_TASK+esi+TASKDATA.state], 9	338	mov [CURRENT_TASK+esi+TASKDATA.state], 9
335	ret	339	ret
336	@@:	340	@@:
337	lea edx, [SLOT_BASE+esi]	341	lea edx, [SLOT_BASE+esi]
338	call scheduler_remove_thread	342	call scheduler_remove_thread
339	;mov esi,process_terminating	343	;mov esi,process_terminating
340	;call sys_msg_board_str	344	;call sys_msg_board_str
341	call lock_application_table	345	call lock_application_table
342		346
343	; if the process is in V86 mode...	347	; if the process is in V86 mode...
344	mov eax, [.slot]	348	mov eax, [.slot]
345	shl eax, 8	349	shl eax, 8
346	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]	350	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
347	add esi, RING0_STACK_SIZE	351	add esi, RING0_STACK_SIZE
348	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi	352	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi
349	jz .nov86	353	jz .nov86
350	; ...it has page directory for V86 mode	354	; ...it has page directory for V86 mode
351	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]	355	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
352	mov ecx, [esi+4]	356	mov ecx, [esi+4]
353	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx	357	mov [eax+SLOT_BASE+APPDATA.dir_table], ecx
354	; ...and I/O permission map for V86 mode	358	; ...and I/O permission map for V86 mode
355	mov ecx, [esi+12]	359	mov ecx, [esi+12]
356	mov [eax+SLOT_BASE+APPDATA.io_map], ecx	360	mov [eax+SLOT_BASE+APPDATA.io_map], ecx
357	mov ecx, [esi+8]	361	mov ecx, [esi+8]
358	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx	362	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
359	.nov86:	363	.nov86:
360		364
361	mov esi, [.slot]	365	mov esi, [.slot]
362	shl esi, 8	366	shl esi, 8
363	add esi, SLOT_BASE+APP_OBJ_OFFSET	367	add esi, SLOT_BASE+APP_OBJ_OFFSET
364	@@:	368	@@:
365	mov eax, [esi+APPOBJ.fd]	369	mov eax, [esi+APPOBJ.fd]
366	test eax, eax	370	test eax, eax
367	jz @F	371	jz @F
368		372
369	cmp eax, esi	373	cmp eax, esi
370	je @F	374	je @F
371		375
372	push esi	376	push esi
373	call [eax+APPOBJ.destroy]	377	call [eax+APPOBJ.destroy]
374	DEBUGF 1,"%s",msg_obj_destroy	378	DEBUGF 1,"%s",msg_obj_destroy
375	pop esi	379	pop esi
376	jmp @B	380	jmp @B
377	@@:	381	@@:
378		382
379	mov eax, [.slot]	383	mov eax, [.slot]
380	shl eax, 8	384	shl eax, 8
381	stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]	385	stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
382		386
383	mov esi, [.slot]	387	mov esi, [.slot]
384	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2	388	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2
385	jne @F	389	jne @F
386		390
387	mov [fpu_owner], 2	391	mov [fpu_owner], 2
388	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]	392	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]
389	clts	393	clts
390	bt [cpu_caps], CAPS_SSE	394	bt [cpu_caps], CAPS_SSE
391	jnc .no_SSE	395	jnc .no_SSE
392	fxrstor [eax]	396	fxrstor [eax]
393	jmp @F	397	jmp @F
394	.no_SSE:	398	.no_SSE:
395	fnclex	399	fnclex
396	frstor [eax]	400	frstor [eax]
397	@@:	401	@@:
398		402
399	mov [KEY_COUNT], byte 0 ; empty keyboard buffer	403	mov [KEY_COUNT], byte 0 ; empty keyboard buffer
400	mov [BTN_COUNT], byte 0 ; empty button buffer	404	mov [BTN_COUNT], byte 0 ; empty button buffer
401		405
402		406
403	; remove defined hotkeys	407	; remove defined hotkeys
404	mov eax, hotkey_list	408	mov eax, hotkey_list
405	.loop:	409	.loop:
406	cmp [eax+8], esi	410	cmp [eax+8], esi
407	jnz .cont	411	jnz .cont
408	mov ecx, [eax]	412	mov ecx, [eax]
409	jecxz @f	413	jecxz @f
410	push dword [eax+12]	414	push dword [eax+12]
411	pop dword [ecx+12]	415	pop dword [ecx+12]
412	@@:	416	@@:
413	mov ecx, [eax+12]	417	mov ecx, [eax+12]
414	push dword [eax]	418	push dword [eax]
415	pop dword [ecx]	419	pop dword [ecx]
416	xor ecx, ecx	420	xor ecx, ecx
417	mov [eax], ecx	421	mov [eax], ecx
418	mov [eax+4], ecx	422	mov [eax+4], ecx
419	mov [eax+8], ecx	423	mov [eax+8], ecx
420	mov [eax+12], ecx	424	mov [eax+12], ecx
421	.cont:	425	.cont:
422	add eax, 16	426	add eax, 16
423	cmp eax, hotkey_list+256*16	427	cmp eax, hotkey_list+256*16
424	jb .loop	428	jb .loop
425	; get process PID	429	; get process PID
426	mov eax, esi	430	mov eax, esi
427	shl eax, 5	431	shl eax, 5
428	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]	432	mov eax, [eax+CURRENT_TASK+TASKDATA.pid]
429	; compare current lock input with process PID	433	; compare current lock input with process PID
430	cmp eax, [PID_lock_input]	434	cmp eax, [PID_lock_input]
431	jne @f	435	jne @f
432		436
433	xor eax, eax	437	xor eax, eax
434	mov [PID_lock_input], eax	438	mov [PID_lock_input], eax
435	@@:	439	@@:
436	; remove hotkeys in buffer	440	; remove hotkeys in buffer
437	mov eax, hotkey_buffer	441	mov eax, hotkey_buffer
438	.loop2:	442	.loop2:
439	cmp [eax], esi	443	cmp [eax], esi
440	jnz .cont2	444	jnz .cont2
441	and dword [eax+4], 0	445	and dword [eax+4], 0
442	and dword [eax], 0	446	and dword [eax], 0
443	.cont2:	447	.cont2:
444	add eax, 8	448	add eax, 8
445	cmp eax, hotkey_buffer+120*8	449	cmp eax, hotkey_buffer+120*8
446	jb .loop2	450	jb .loop2
447		451
448	mov ecx, esi ; remove buttons	452	mov ecx, esi ; remove buttons
449	bnewba2:	453	bnewba2:
450	mov edi, [BTN_ADDR]	454	mov edi, [BTN_ADDR]
451	mov eax, edi	455	mov eax, edi
452	cld	456	cld
453	movzx ebx, word [edi]	457	movzx ebx, word [edi]
454	inc bx	458	inc bx
455	bnewba:	459	bnewba:
456	dec bx	460	dec bx
457	jz bnmba	461	jz bnmba
458	add eax, 0x10	462	add eax, 0x10
459	cmp cx, [eax]	463	cmp cx, [eax]
460	jnz bnewba	464	jnz bnewba
461	pusha	465	pusha
462	mov ecx, ebx	466	mov ecx, ebx
463	inc ecx	467	inc ecx
464	shl ecx, 4	468	shl ecx, 4
465	mov ebx, eax	469	mov ebx, eax
466	add eax, 0x10	470	add eax, 0x10
467	call memmove	471	call memmove
468	dec dword [edi]	472	dec dword [edi]
469	popa	473	popa
470	jmp bnewba2	474	jmp bnewba2
471	bnmba:	475	bnmba:
472		476
473	pusha ; save window coordinates for window restoring	477	pusha ; save window coordinates for window restoring
474	cld	478	cld
475	shl esi, 5	479	shl esi, 5
476	add esi, window_data	480	add esi, window_data
477	mov eax, [esi+WDATA.box.left]	481	mov eax, [esi+WDATA.box.left]
478	mov [draw_limits.left], eax	482	mov [draw_limits.left], eax
479	add eax, [esi+WDATA.box.width]	483	add eax, [esi+WDATA.box.width]
480	mov [draw_limits.right], eax	484	mov [draw_limits.right], eax
481	mov eax, [esi+WDATA.box.top]	485	mov eax, [esi+WDATA.box.top]
482	mov [draw_limits.top], eax	486	mov [draw_limits.top], eax
483	add eax, [esi+WDATA.box.height]	487	add eax, [esi+WDATA.box.height]
484	mov [draw_limits.bottom], eax	488	mov [draw_limits.bottom], eax
485		489
486	xor eax, eax	490	xor eax, eax
487	mov [esi+WDATA.box.left], eax	491	mov [esi+WDATA.box.left], eax
488	mov [esi+WDATA.box.width], eax	492	mov [esi+WDATA.box.width], eax
489	mov [esi+WDATA.box.top], eax	493	mov [esi+WDATA.box.top], eax
490	mov [esi+WDATA.box.height], eax	494	mov [esi+WDATA.box.height], eax
491	mov [esi+WDATA.cl_workarea], eax	495	mov [esi+WDATA.cl_workarea], eax
492	mov [esi+WDATA.cl_titlebar], eax	496	mov [esi+WDATA.cl_titlebar], eax
493	mov [esi+WDATA.cl_frames], eax	497	mov [esi+WDATA.cl_frames], eax
494	mov dword [esi+WDATA.reserved], eax; clear all flags: wstate, redraw, wdrawn	498	mov dword [esi+WDATA.reserved], eax; clear all flags: wstate, redraw, wdrawn
495	lea edi, [esi-window_data+draw_data]	499	lea edi, [esi-window_data+draw_data]
496	mov ecx, 32/4	500	mov ecx, 32/4

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/sys32.inc – Rev 3555 → 3626