WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri-process/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: 4313 $
 
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"
        push    eax ebx ecx edx
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+00]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+04]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+08]: %x\n",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+12]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+16]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+20]: %x\n",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, "K : [ESP+24]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+28]: %x",[ebx]
        add     ebx, 4
        call    .check_ESP
        test    eax, eax
        jnz     .error_ESP
        DEBUGF  1, " [ESP+32]: %x\n",[ebx]
        pop     edx ecx ebx eax
        ret
.error_ESP:
        pop     edx ecx ebx eax
        DEBUGF  1, "\n"
        DEBUGF  1, "K : Unexpected end of the stack\n"
        ret
;--------------------------------------
.check_ESP:
        push    ebx
        shr     ebx, 12
        mov     ecx, ebx
        shr     ecx, 10
        mov     edx, [master_tab+ecx*4]
        test    edx, PG_MAP
        jz      .fail             ;page table is not created
                                  ;incorrect address in the program
 
        mov     eax, [page_tabs+ebx*4]
        test    eax, 2
        jz      .fail             ;address not reserved for use. error
 
        pop     ebx
        xor     eax, eax
        ret
 
.fail:
        pop     ebx
        xor     eax, eax
        dec     eax
        ret
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
  restore  reg_ss
  restore  reg_esp3
  restore  reg_eflags
  restore  reg_cs
  restore  reg_eip
  restore  reg_eax
  restore  reg_ecx
  restore  reg_edx
  restore  reg_ebx
  restore  reg_esp0
  restore  reg_ebp
  restore  reg_esi
  restore  reg_edi
 
 
align 4
lock_application_table:
        push    eax ecx edx
        mov     ecx, application_table_mutex
        call    mutex_lock
 
        mov     eax, [CURRENT_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
 
        mov     eax, [pg_data.pages_free]
        shl     eax, 12
        cmp     eax, ecx
        jae     @f
 
        xor     eax, eax
        inc     eax
        jmp     .store_result
@@:
        stdcall new_mem_resize, ecx
.store_result:
        mov     [esp+32], eax
.no_application_mem_resize:
        ret
 
iglobal
;  process_terminating  db 'K : Process - terminating',13,10,0
;  process_terminated   db 'K : Process - done',13,10,0
  msg_obj_destroy       db 'K : destroy app object',13,10,0
endg
 
; param
;  esi= slot
 
align 4
terminate: ; terminate application
destroy_thread:
 
        .slot     equ esp+4             ;locals
        .process  equ esp               ;ptr to parent process
 
 
 
        push    esi                     ;save .slot
 
        shl     esi, 8
        mov     edx, [SLOT_BASE+esi+APPDATA.process]
        test    edx, edx
        jnz     @F
        pop     esi
        shl     esi, 5
        mov     [CURRENT_TASK+esi+TASKDATA.state], 9
        ret
@@:
        push    edx                     ;save .process
        lea     edx, [SLOT_BASE+esi]
        call    scheduler_remove_thread
        call    lock_application_table
 
; if the process is in V86 mode...
        mov     eax, [.slot]
        shl     eax, 8
        mov     esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
        add     esi, RING0_STACK_SIZE
        cmp     [eax+SLOT_BASE+APPDATA.saved_esp0], esi
        jz      .nov86
; ...it has page directory for V86 mode
        mov     esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
        mov     ecx, [esi+4]
        mov     [eax+SLOT_BASE+APPDATA.process], ecx
; ...and I/O permission map for V86 mode
        mov     ecx, [esi+12]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [esi+8]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
.nov86:
;destroy per-thread kernel objects
        mov     esi, [.slot]
        shl     esi, 8
        add     esi, SLOT_BASE+APP_OBJ_OFFSET
@@:
        mov     eax, [esi+APPOBJ.fd]
        test    eax, eax
        jz      @F
 
        cmp     eax, esi
        je      @F
 
        push    esi
        call    [eax+APPOBJ.destroy]
           DEBUGF 1,"%s",msg_obj_destroy
        pop     esi
        jmp     @B
@@:
        mov     esi, [.slot]
        cmp     [fpu_owner], esi ; if user fpu last -> fpu user = 2
        jne     @F
 
        mov     [fpu_owner], 2
        mov     eax, [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
@@:
        lea     ebx, [edi+APPDATA.list]
        list_del ebx                    ;destroys edx, ecx
 
        mov     eax, 0x20202020
        stosd
        stosd
        stosd
        mov     ecx, 244/4
        xor     eax, eax
        rep stosd
 
  ; activate window
        movzx   eax, word [WIN_STACK + esi*2]
        cmp     eax, [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
@@:
        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:
;release slot
 
 
 
        bts     [thr_slot_map], esi
 
        mov     ecx, [.process]
        lea     eax, [ecx+PROC.thr_list]
        cmp     eax, [eax+LHEAD.next]
        jne     @F
 
        call    destroy_process.internal
@@:
        sti     ; .. and life goes on
 
        mov     eax, [draw_limits.left]
        mov     ebx, [draw_limits.top]
        mov     ecx, [draw_limits.right]
        mov     edx, [draw_limits.bottom]
        call    calculatescreen
        xor     eax, eax
        xor     esi, esi
        call    redrawscreen
 
        call    unlock_application_table
    ;mov   esi,process_terminated
    ;call  sys_msg_board_str
        add     esp, 8
        ret
restore .slot
restore .process
 
; Three following procedures are used to guarantee that
; some part of kernel code will not be terminated from outside
; while it is running.
; Note: they do not protect a thread from terminating due to errors inside
; the thread; accessing a nonexisting memory would still terminate it.
 
; First two procedures must be used in pair by thread-to-be-protected
; to signal the beginning and the end of an important part.
; It is OK to have nested areas.
 
; The last procedure must be used by outside wanna-be-terminators;
; if it is safe to terminate the given thread immediately, it returns eax=1;
; otherwise, it returns eax=0 and notifies the target thread that it should
; terminate itself when leaving a critical area (the last critical area if
; they are nested).
 
; Implementation. Those procedures use one dword in APPDATA for the thread,
; APPDATA.terminate_protection.
; * The upper bit is 1 during normal operations and 0 when terminate is requested.
; * Other bits form a number = depth of critical regions,
;   plus 1 if the upper bit is 1.
; * When this dword goes to zero, the thread should be destructed,
;   and the procedure in which it happened becomes responsible for destruction.
 
; Enter critical area. Called by thread which wants to be protected.
proc protect_from_terminate
        mov     edx, [current_slot]
; Atomically increment depth of critical areas and get the old value.
        mov     eax, 1
        lock xadd [edx+APPDATA.terminate_protection], eax
; If the old value was zero, somebody has started to terminate us,
; so we are destructing and cannot do anything protected.
; Otherwise, return to the caller.
        test    eax, eax
        jz      @f
        ret
@@:
; Wait for somebody to finish us.
        call    change_task
        jmp     @b
endp
 
; Leave critical area. Called by thread which wants to be protected.
proc unprotect_from_terminate
        mov     edx, [current_slot]
; Atomically decrement depth of critical areas.
        lock dec [edx+APPDATA.terminate_protection]
; If the result of decrement is zero, somebody has requested termination,
; but at that moment we were inside a critical area; terminate now.
        jz      sys_end
; Otherwise, return to the caller.
        ret
endp
 
; Request termination of thread identified by edx = SLOT_BASE + slot*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 4459	Rev 4923
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: 4313 $	14	$Revision: 4313 $
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		250
251	DEBUGF 1, "K : Stack dump:\n"	251	DEBUGF 1, "K : Stack dump:\n"
252	push eax ebx ecx edx	252	push eax ebx ecx edx
253	call .check_ESP	253	call .check_ESP
254	test eax, eax	254	test eax, eax
255	jnz .error_ESP	255	jnz .error_ESP
256	DEBUGF 1, "K : [ESP+00]: %x",[ebx]	256	DEBUGF 1, "K : [ESP+00]: %x",[ebx]
257	add ebx, 4	257	add ebx, 4
258	call .check_ESP	258	call .check_ESP
259	test eax, eax	259	test eax, eax
260	jnz .error_ESP	260	jnz .error_ESP
261	DEBUGF 1, " [ESP+04]: %x",[ebx]	261	DEBUGF 1, " [ESP+04]: %x",[ebx]
262	add ebx, 4	262	add ebx, 4
263	call .check_ESP	263	call .check_ESP
264	test eax, eax	264	test eax, eax
265	jnz .error_ESP	265	jnz .error_ESP
266	DEBUGF 1, " [ESP+08]: %x\n",[ebx]	266	DEBUGF 1, " [ESP+08]: %x\n",[ebx]
267	add ebx, 4	267	add ebx, 4
268	call .check_ESP	268	call .check_ESP
269	test eax, eax	269	test eax, eax
270	jnz .error_ESP	270	jnz .error_ESP
271	DEBUGF 1, "K : [ESP+12]: %x",[ebx]	271	DEBUGF 1, "K : [ESP+12]: %x",[ebx]
272	add ebx, 4	272	add ebx, 4
273	call .check_ESP	273	call .check_ESP
274	test eax, eax	274	test eax, eax
275	jnz .error_ESP	275	jnz .error_ESP
276	DEBUGF 1, " [ESP+16]: %x",[ebx]	276	DEBUGF 1, " [ESP+16]: %x",[ebx]
277	add ebx, 4	277	add ebx, 4
278	call .check_ESP	278	call .check_ESP
279	test eax, eax	279	test eax, eax
280	jnz .error_ESP	280	jnz .error_ESP
281	DEBUGF 1, " [ESP+20]: %x\n",[ebx]	281	DEBUGF 1, " [ESP+20]: %x\n",[ebx]
282	add ebx, 4	282	add ebx, 4
283	call .check_ESP	283	call .check_ESP
284	test eax, eax	284	test eax, eax
285	jnz .error_ESP	285	jnz .error_ESP
286	DEBUGF 1, "K : [ESP+24]: %x",[ebx]	286	DEBUGF 1, "K : [ESP+24]: %x",[ebx]
287	add ebx, 4	287	add ebx, 4
288	call .check_ESP	288	call .check_ESP
289	test eax, eax	289	test eax, eax
290	jnz .error_ESP	290	jnz .error_ESP
291	DEBUGF 1, " [ESP+28]: %x",[ebx]	291	DEBUGF 1, " [ESP+28]: %x",[ebx]
292	add ebx, 4	292	add ebx, 4
293	call .check_ESP	293	call .check_ESP
294	test eax, eax	294	test eax, eax
295	jnz .error_ESP	295	jnz .error_ESP
296	DEBUGF 1, " [ESP+32]: %x\n",[ebx]	296	DEBUGF 1, " [ESP+32]: %x\n",[ebx]
297	pop edx ecx ebx eax	297	pop edx ecx ebx eax
298	ret	298	ret
299	.error_ESP:	299	.error_ESP:
300	pop edx ecx ebx eax	300	pop edx ecx ebx eax
301	DEBUGF 1, "\n"	301	DEBUGF 1, "\n"
302	DEBUGF 1, "K : Unexpected end of the stack\n"	302	DEBUGF 1, "K : Unexpected end of the stack\n"
303	ret	303	ret
304	;--------------------------------------	304	;--------------------------------------
305	.check_ESP:	305	.check_ESP:
306	push ebx	306	push ebx
307	shr ebx, 12	307	shr ebx, 12
308	mov ecx, ebx	308	mov ecx, ebx
309	shr ecx, 10	309	shr ecx, 10
310	mov edx, [master_tab+ecx*4]	310	mov edx, [master_tab+ecx*4]
311	test edx, PG_MAP	311	test edx, PG_MAP
312	jz .fail ;page table is not created	312	jz .fail ;page table is not created
313	;incorrect address in the program	313	;incorrect address in the program
314		314
315	mov eax, [page_tabs+ebx*4]	315	mov eax, [page_tabs+ebx*4]
316	test eax, 2	316	test eax, 2
317	jz .fail ;address not reserved for use. error	317	jz .fail ;address not reserved for use. error
318		318
319	pop ebx	319	pop ebx
320	xor eax, eax	320	xor eax, eax
321	ret	321	ret
322		322
323	.fail:	323	.fail:
324	pop ebx	324	pop ebx
325	xor eax, eax	325	xor eax, eax
326	dec eax	326	dec eax
327	ret	327	ret
328	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=	328	;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
329		329
330	restore reg_ss	330	restore reg_ss
331	restore reg_esp3	331	restore reg_esp3
332	restore reg_eflags	332	restore reg_eflags
333	restore reg_cs	333	restore reg_cs
334	restore reg_eip	334	restore reg_eip
335	restore reg_eax	335	restore reg_eax
336	restore reg_ecx	336	restore reg_ecx
337	restore reg_edx	337	restore reg_edx
338	restore reg_ebx	338	restore reg_ebx
339	restore reg_esp0	339	restore reg_esp0
340	restore reg_ebp	340	restore reg_ebp
341	restore reg_esi	341	restore reg_esi
342	restore reg_edi	342	restore reg_edi
343		343
344		344
345	align 4	345	align 4
346	lock_application_table:	346	lock_application_table:
347	push eax ecx edx	347	push eax ecx edx
348	mov ecx, application_table_mutex	348	mov ecx, application_table_mutex
349	call mutex_lock	349	call mutex_lock
350		350
351	mov eax, [CURRENT_TASK]	351	mov eax, [CURRENT_TASK]
352	shl eax, 5	352	shl eax, 5
353	add eax, CURRENT_TASK+TASKDATA.pid	353	add eax, CURRENT_TASK+TASKDATA.pid
354	mov eax, [eax]	354	mov eax, [eax]
355		355
356	mov [application_table_owner], eax	356	mov [application_table_owner], eax
357		357
358	pop edx ecx eax	358	pop edx ecx eax
359		359
360	ret	360	ret
361		361
362	align 4	362	align 4
363	unlock_application_table:	363	unlock_application_table:
364	push eax ecx edx	364	push eax ecx edx
365		365
366	mov [application_table_owner], 0	366	mov [application_table_owner], 0
367	mov ecx, application_table_mutex	367	mov ecx, application_table_mutex
368	call mutex_unlock	368	call mutex_unlock
369		369
370	pop edx ecx eax	370	pop edx ecx eax
371		371
372	ret	372	ret
373		373
374	; * eax = 64 - номер функции	374	; * eax = 64 - номер функции
375	; * ebx = 1 - единственная подфункция	375	; * ebx = 1 - единственная подфункция
376	; * ecx = новый размер памяти	376	; * ecx = новый размер памяти
377	;Возвращаемое значение:	377	;Возвращаемое значение:
378	; * eax = 0 - успешно	378	; * eax = 0 - успешно
379	; * eax = 1 - недостаточно памяти	379	; * eax = 1 - недостаточно памяти
380		380
381	align 4	381	align 4
382	sys_resize_app_memory:	382	sys_resize_app_memory:
383	; ebx = 1 - resize	383	; ebx = 1 - resize
384	; ecx = new amount of memory	384	; ecx = new amount of memory
385		385
386	; cmp eax,1	386	; cmp eax,1
387	dec ebx	387	dec ebx
388	jnz .no_application_mem_resize	388	jnz .no_application_mem_resize
389		389
390	mov eax, [pg_data.pages_free]	390	mov eax, [pg_data.pages_free]
391	shl eax, 12	391	shl eax, 12
392	cmp eax, ecx	392	cmp eax, ecx
393	jae @f	393	jae @f
394		394
395	xor eax, eax	395	xor eax, eax
396	inc eax	396	inc eax
397	jmp .store_result	397	jmp .store_result
398	@@:	398	@@:
399	stdcall new_mem_resize, ecx	399	stdcall new_mem_resize, ecx
400	.store_result:	400	.store_result:
401	mov [esp+32], eax	401	mov [esp+32], eax
402	.no_application_mem_resize:	402	.no_application_mem_resize:
403	ret	403	ret
404		404
405	iglobal	405	iglobal
406	; process_terminating db 'K : Process - terminating',13,10,0	406	; process_terminating db 'K : Process - terminating',13,10,0
407	; process_terminated db 'K : Process - done',13,10,0	407	; process_terminated db 'K : Process - done',13,10,0
408	msg_obj_destroy db 'K : destroy app object',13,10,0	408	msg_obj_destroy db 'K : destroy app object',13,10,0
409	endg	409	endg
410		410
411	; param	411	; param
412	; esi= slot	412	; esi= slot
413		413
414	align 4	414	align 4
415	terminate: ; terminate application	415	terminate: ; terminate application
416	destroy_thread:	416	destroy_thread:
417		417
418	.slot equ esp+4 ;locals	418	.slot equ esp+4 ;locals
419	.process equ esp ;ptr to parent process	419	.process equ esp ;ptr to parent process
420		-
421	xchg bx, bx	420
422		421
423	push esi ;save .slot	422	push esi ;save .slot
424		423
425	shl esi, 8	424	shl esi, 8
426	mov edx, [SLOT_BASE+esi+APPDATA.process]	425	mov edx, [SLOT_BASE+esi+APPDATA.process]
427	test edx, edx	426	test edx, edx
428	jnz @F	427	jnz @F
429	pop esi	428	pop esi
430	shl esi, 5	429	shl esi, 5
431	mov [CURRENT_TASK+esi+TASKDATA.state], 9	430	mov [CURRENT_TASK+esi+TASKDATA.state], 9
432	ret	431	ret
433	@@:	432	@@:
434	push edx ;save .process	433	push edx ;save .process
435	lea edx, [SLOT_BASE+esi]	434	lea edx, [SLOT_BASE+esi]
436	call scheduler_remove_thread	435	call scheduler_remove_thread
437	call lock_application_table	436	call lock_application_table
438		437
439	; if the process is in V86 mode...	438	; if the process is in V86 mode...
440	mov eax, [.slot]	439	mov eax, [.slot]
441	shl eax, 8	440	shl eax, 8
442	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]	441	mov esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
443	add esi, RING0_STACK_SIZE	442	add esi, RING0_STACK_SIZE
444	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi	443	cmp [eax+SLOT_BASE+APPDATA.saved_esp0], esi
445	jz .nov86	444	jz .nov86
446	; ...it has page directory for V86 mode	445	; ...it has page directory for V86 mode
447	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]	446	mov esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
448	mov ecx, [esi+4]	447	mov ecx, [esi+4]
449	mov [eax+SLOT_BASE+APPDATA.process], ecx	448	mov [eax+SLOT_BASE+APPDATA.process], ecx
450	; ...and I/O permission map for V86 mode	449	; ...and I/O permission map for V86 mode
451	mov ecx, [esi+12]	450	mov ecx, [esi+12]
452	mov [eax+SLOT_BASE+APPDATA.io_map], ecx	451	mov [eax+SLOT_BASE+APPDATA.io_map], ecx
453	mov ecx, [esi+8]	452	mov ecx, [esi+8]
454	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx	453	mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
455	.nov86:	454	.nov86:
456	;destroy per-thread kerlen objects	455	;destroy per-thread kernel objects
457	mov esi, [.slot]	456	mov esi, [.slot]
458	shl esi, 8	457	shl esi, 8
459	add esi, SLOT_BASE+APP_OBJ_OFFSET	458	add esi, SLOT_BASE+APP_OBJ_OFFSET
460	@@:	459	@@:
461	mov eax, [esi+APPOBJ.fd]	460	mov eax, [esi+APPOBJ.fd]
462	test eax, eax	461	test eax, eax
463	jz @F	462	jz @F
464		463
465	cmp eax, esi	464	cmp eax, esi
466	je @F	465	je @F
467		466
468	push esi	467	push esi
469	call [eax+APPOBJ.destroy]	468	call [eax+APPOBJ.destroy]
470	DEBUGF 1,"%s",msg_obj_destroy	469	DEBUGF 1,"%s",msg_obj_destroy
471	pop esi	470	pop esi
472	jmp @B	471	jmp @B
473	@@:	472	@@:
474	mov esi, [.slot]	473	mov esi, [.slot]
475	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2	474	cmp [fpu_owner], esi ; if user fpu last -> fpu user = 2
476	jne @F	475	jne @F
477		476
478	mov [fpu_owner], 2	477	mov [fpu_owner], 2
479	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]	478	mov eax, [256*2+SLOT_BASE+APPDATA.fpu_state]
480	clts	479	clts
481	bt [cpu_caps], CAPS_SSE	480	bt [cpu_caps], CAPS_SSE
482	jnc .no_SSE	481	jnc .no_SSE
483	fxrstor [eax]	482	fxrstor [eax]
484	jmp @F	483	jmp @F
485	.no_SSE:	484	.no_SSE:
486	fnclex	485	fnclex
487	frstor [eax]	486	frstor [eax]
488	@@:	487	@@:
489		488
490	mov [KEY_COUNT], byte 0 ; empty keyboard buffer	489	mov [KEY_COUNT], byte 0 ; empty keyboard buffer
491	mov [BTN_COUNT], byte 0 ; empty button buffer	490	mov [BTN_COUNT], byte 0 ; empty button buffer
492		491
493		492
494	; remove defined hotkeys	493	; remove defined hotkeys
495	mov eax, hotkey_list	494	mov eax, hotkey_list
496	.loop:	495	.loop:
497	cmp [eax+8], esi	496	cmp [eax+8], esi
498	jnz .cont	497	jnz .cont
499	mov ecx, [eax]	498	mov ecx, [eax]
500	jecxz @f	499	jecxz @f

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri-process/core/sys32.inc – Rev 4459 → 4923