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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 7136 $
 
 
GREEDY_KERNEL  = 0
 
struct  APP_HEADER_00_
        banner          dq ?
        version         dd ?    ;+8
        start           dd ?    ;+12
        i_end           dd ?    ;+16
        mem_size        dd ?    ;+20
        i_param         dd ?    ;+24
ends
 
struct  APP_HEADER_01_
        banner          dq ?
        version         dd ?    ;+8
        start           dd ?    ;+12
        i_end           dd ?    ;+16
        mem_size        dd ?    ;+20
        stack_top       dd ?    ;+24
        i_param         dd ?    ;+28
        i_icon          dd ?    ;+32
ends
 
struct  APP_HDR
        cmdline         rd 1    ;0x00
        path            rd 1    ;0x04
        eip             rd 1    ;0x08
        esp             rd 1    ;0x0C
        _edata          rd 1    ;0x10
        _emem           rd 1    ;0x14
        img_base        rd 1    ;0x18
        img_size        rd 1
        filename_size   rd 1
        cmdline_size    rd 1
        path_string     rd 1
ends
 
macro _clear_ op
{  mov ecx, op/4
        xor     eax, eax
        cld
        rep stosd
}
 
align 4
_strnlen:
        mov     edx, ecx
        xor     eax, eax
        repne scasb
        jne     @F
        inc     ecx
@@:
        mov     eax, edx
        sub     eax, ecx
        retn
 
fs_execute_from_sysdir:
        xor     ebx, ebx
fs_execute_from_sysdir_param:
        stdcall kernel_alloc, maxPathLength
        push    eax ebx
        mov     esi, ebp
        mov     edi, eax
        xor     eax, eax
        call    getFullPath
        pop     ecx ebx
        xor     edx, edx
proc fs_execute
; edx = flags
; ecx -> cmdline
; ebx -> absolute file path
; eax = string length
    locals
        cmdline         rd  1
        flags           rd  1
        slot            rd  1
        slot_base       rd  1
; app header data
        hdr_cmdline     rd  1
        hdr_path        rd  1
        hdr_eip         rd  1
        hdr_esp         rd  1
        hdr_edata       rd  1
        hdr_emem        rd  1
        file_base       rd  1
        file_size       rd  1
        filename_size   rd  1
        cmdline_size    rd  1
        path_string     rd  1
    endl
 
        mov     [flags], edx
        mov     [cmdline], ecx
        mov     [path_string], ebx
        mov     [filename_size], eax
        mov     esi, -ERROR_FILE_NOT_FOUND
        test    eax, eax
        jz      .err_file
        stdcall load_file, ebx
        test    eax, eax
        jz      .err_file
 
        mov     [file_base], eax
        mov     [file_size], ebx
        lea     ebx, [hdr_cmdline]
        call    test_app_header
        mov     esi, -0x1F
        test    eax, eax
        jz      .err_hdr
 
        call    lock_application_table
        call    alloc_thread_slot
        mov     esi, -0x20  ; too many processes
        test    eax, eax
        jz      .err_0
 
        mov     [slot], eax
        shl     eax, 8
        lea     edi, [SLOT_BASE+eax]
        mov     [slot_base], edi
; clean extended information about process
        mov     ecx, 256/4
        xor     eax, eax
        cld
        rep stosd
; write application name
        stdcall strrchr, [path_string], '/'
        lea     esi, [eax+1]    ; -> name without path
        mov     ecx, 11
        mov     edi, [slot_base]
@@:
        call    utf8to16
        call    uni2ansi_char
        cmp     al, '.'
        jz      @f
        test    al, al
        jz      @f
        stosb
        loop    @b
@@:
        mov     edi, [cmdline]
        xor     eax, eax
        test    edi, edi
        jz      @f
        mov     ecx, 65535
        call    _strnlen
        cmp     eax, 256
        jb      @f
        lea     ebx, [eax+1]
        add     [hdr_emem], ebx
@@:
        mov     [cmdline_size], eax
        stdcall create_process, [hdr_emem]
        mov     esi, -30    ; no memory
        test    eax, eax
        jz      .err_hdr
 
        mov     ebx, [sys_proc+LHEAD.prev]
        __list_add eax, ebx, sys_proc
        mov     ebx, [hdr_emem]
        mov     [eax+PROC.mem_used], ebx
        mov     ebx, [slot_base]
        mov     [ebx+APPDATA.process], eax
        lea     edx, [ebx+APPDATA.list]
        lea     ecx, [eax+PROC.thr_list]
        list_add_tail edx, ecx
        mov     eax, [cmdline_size]
        add     eax, sizeof.APP_HDR
        stdcall kernel_alloc, eax
        mov     [ebx+APPDATA.exec_params], eax
        mov     edi, eax
        lea     esi, [hdr_cmdline]
        mov     ecx, sizeof.APP_HDR/4
        rep movsd
        mov     ecx, [cmdline_size]
        mov     esi, [cmdline]
        rep movsb
        lea     eax, [hdr_cmdline]
        stdcall set_app_params , [slot], eax, [flags]
        mov     eax, [process_number]   ;set result
        call    unlock_application_table
        ret
 
.err_0:
        call    unlock_application_table
.err_hdr:
        stdcall kernel_free, [file_base]
.err_file:
        stdcall kernel_free, [path_string]
        mov     eax, esi
        ret
endp
 
align 4
test_app_header:
       virtual at eax
         APP_HEADER_00 APP_HEADER_00_
       end virtual
       virtual at eax
         APP_HEADER_01 APP_HEADER_01_
       end virtual
 
        cmp     dword [eax], 'MENU'
        jne     .fail
        cmp     word [eax+4], 'ET'
        jne     .fail
 
        cmp     [eax+6], word '00'
        jne     .check_01_header
 
        mov     ecx, [APP_HEADER_00.start]
        mov     [ebx+APP_HDR.eip], ecx
        mov     edx, [APP_HEADER_00.mem_size]
        mov     [ebx+APP_HDR._emem], edx
        shr     edx, 1
        sub     edx, 0x10
        mov     [ebx+APP_HDR.esp], edx
        mov     ecx, [APP_HEADER_00.i_param]
        mov     [ebx+APP_HDR.cmdline], ecx
        mov     [ebx+APP_HDR.path], 0
        mov     edx, [APP_HEADER_00.i_end]
        mov     [ebx+APP_HDR._edata], edx
        ret
 
 .check_01_header:
 
        cmp     [eax+6], word '01'
        je      @f
        cmp     [eax+6], word '02'
        jne     .fail
@@:
        mov     ecx, [APP_HEADER_01.start]
        mov     [ebx+0x08], ecx
        mov     edx, [APP_HEADER_01.mem_size]
 
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
        cmp     edx, [APP_HEADER_01.i_end]
        jb      .fail
; \end{diamond}[20.08.2006]
 
        mov     [ebx+APP_HDR._emem], edx
        mov     ecx, [APP_HEADER_01.stack_top]
        mov     [ebx+APP_HDR.esp], ecx
        mov     edx, [APP_HEADER_01.i_param]
        mov     [ebx+APP_HDR.cmdline], edx
        mov     ecx, [APP_HEADER_01.i_icon]
        mov     [ebx+APP_HDR.path], ecx
        mov     edx, [APP_HEADER_01.i_end]
        mov     [ebx+APP_HDR._edata], edx
        ret
.fail:
        xor     eax, eax
        ret
 
align 4
alloc_thread_slot:
;input:
;  none
;result:
;  eax=[new_thread_slot]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
 
 
        mov     edx, thr_slot_map
        pushfd
        cli
.l1:
        bsf     eax, [edx]
        jnz     .found
        add     edx, 4
        cmp     edx, thr_slot_map+32
        jb      .l1
 
        popfd
        xor     eax, eax
        ret
.found:
        btr     [edx], eax
        sub     edx, thr_slot_map
        lea     eax, [eax+edx*8]
        popfd
        ret
 
align 4
proc create_process stdcall, app_size:dword
       locals
         process     dd ?
         app_tabs    dd ?
       endl
 
        push    ebx
        push    esi
        push    edi
 
        xor     eax, eax
        mov     [process], eax
 
        mov     eax, [app_size]
        add     eax, 0x3FFFFF
        shr     eax, 22
        mov     [app_tabs], eax
 
        stdcall kernel_alloc, 0x2000
        test    eax, eax
        jz      .fail
        mov     [process], eax
 
        lea     edi, [eax+PROC.heap_lock]
        mov     ecx, (PROC.ht_free-PROC.heap_lock)/4
 
        list_init eax
        add     eax, PROC.thr_list
        list_init eax
 
        xor     eax, eax
        cld
        rep stosd
 
        mov     [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
        mov     [edi+4], dword 3           ;reserve handles for stdin stdout and stderr
        mov     ecx, (PROC.pdt_0 - PROC.htab)/4
        add     edi, 8
        inc     eax
@@:
        stosd
        inc     eax
        cmp     eax, ecx
        jbe     @B
 
        mov     eax, edi
        call    get_pg_addr
        mov     [edi-4096+PROC.pdt_0_phys], eax
 
        mov     ecx, (OS_BASE shr 20)/4
        xor     eax, eax
        rep stosd
 
        mov     ecx, (OS_BASE shr 20)/4
        mov     esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
        rep movsd
 
        mov     eax, [edi-8192+PROC.pdt_0_phys]
        or      eax, PG_SWR
        mov     [edi-4096+(page_tabs shr 20)], eax
 
        lea     edx, [edi-4096]
        mov     esi, [app_tabs]
 
.alloc_page_dir:
        call    alloc_page
        test    eax, eax
        jz      .fail
        or      eax, PG_UWR
        mov     [edx], eax
 
        mov     edi, [tmp_task_ptab]
        stdcall map_page, edi, eax, PG_SWR
        mov     ecx, 1024
        xor     eax, eax
        rep stosd
 
        add     edx, 4
        dec     esi
        jnz     .alloc_page_dir
 
        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
        mov     eax, [process]
 
        pop     edi
        pop     esi
        pop     ebx
        ret
.fail:
        mov     ecx, [process]
        jcxz    @F
 
        call    destroy_process
@@:
        xor     eax, eax
        pop     edi
        pop     esi
        pop     ebx
        ret
endp
 
align 4
proc destroy_page_table stdcall, pg_tab:dword
 
        push    esi
 
        mov     esi, [pg_tab]
        mov     ecx, 1024
.free:
        mov     eax, [esi]
        test    eax, 1
        jz      .next
        test    eax, 2
        jz      .next
        test    eax, 1 shl 9
        jnz     .next                     ;skip shared pages
        call    free_page
.next:
        add     esi, 4
        dec     ecx
        jnz     .free
        pop     esi
        ret
endp
 
align 4
destroy_process: ;fastcall ecx= ptr to process
 
        lea     eax, [ecx+PROC.thr_list]
        cmp     eax, [eax+LHEAD.next]
        jne     .exit
 
align 4
.internal:
        push    ecx
 
        mov     esi, ecx
        list_del esi
 
        mov     esi, [esi+PROC.dlls_list_ptr]
        call    destroy_all_hdlls
 
        mov     esi, [esp]
        add     esi, PROC.pdt_0
        mov     edi, (0x80000000 shr 20)/4
.destroy:
        mov     eax, [esi]
        test    eax, 1
        jz      .next
        and     eax, not 0xFFF
        stdcall map_page, [tmp_task_ptab], eax, PG_SWR
        stdcall destroy_page_table, [tmp_task_ptab]
        mov     eax, [esi]
        call    free_page
.next:
        add     esi, 4
        dec     edi
        jnz     .destroy
 
        call    kernel_free     ;ecx still in stack
        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
.exit:
        ret
 
align 4
get_pid:
        mov     eax, [TASK_BASE]
        mov     eax, [eax+TASKDATA.pid]
        ret
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
        push    ebx
        push    ecx
        mov     ebx, [TASK_COUNT]
        shl     ebx, 5
        mov     ecx, 2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
        cmp     byte [CURRENT_TASK+ecx+0xa], 9
        jz      .endloop ;skip empty slots
        cmp     [CURRENT_TASK+ecx+0x4], eax;check PID
        jz      .pid_found
.endloop:
        add     ecx, 32
        cmp     ecx, ebx
        jle     .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
 
.pid_found:
        shr     ecx, 5
        mov     eax, ecx ;convert offset to index of slot
        pop     ecx
        pop     ebx
        ret
 
check_region:
;input:
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
        mov     eax, 1
        ret
if 0
        mov     eax, [CURRENT_TASK]
;     jmp  check_process_region
;-----------------------------------------------------------------------------
;check_process_region:
;input:
;  eax - slot
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
        test    edx, edx
        jle     .ok
        shl     eax, 5
        cmp     word [CURRENT_TASK+eax+0xa], 0
        jnz     .failed
        shl     eax, 3
        mov     eax, [SLOT_BASE+eax+0xb8]
        test    eax, eax
        jz      .failed
 
        mov     eax, 1
        ret
.ok:
        mov     eax, 1
        ret
.failed:
        xor     eax, eax
        ret
end if
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ecx - buffer address
;  edx - buffer size
;  esi - start address in other process
;Output:
;  eax - number of bytes read.
       locals
         slot   dd ?
         buff   dd ?
         r_count    dd ?
         offset dd ?
         tmp_r_cnt  dd ?
       endl
 
        mov     [slot], eax
        mov     [buff], ecx
        and     [r_count], 0
        mov     [tmp_r_cnt], edx
        mov     [offset], esi
 
        pushad
.read_mem:
        mov     edx, [offset]
        mov     ebx, [tmp_r_cnt]
 
        mov     ecx, 0x400000
        and     edx, 0x3FFFFF
        sub     ecx, edx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        cmp     ecx, 0x8000
        jna     @F
        mov     ecx, 0x8000
@@:
        mov     ebx, [offset]
 
        push    ecx
        stdcall map_memEx, [proc_mem_map], \
                [slot], ebx, ecx, PG_READ
        pop     ecx
 
        mov     esi, [offset]
        and     esi, 0xfff
        sub     eax, esi
        jbe     .ret
        cmp     ecx, eax
        jbe     @f
        mov     ecx, eax
        mov     [tmp_r_cnt], eax
@@:
        add     esi, [proc_mem_map]
        mov     edi, [buff]
        mov     edx, ecx
        rep movsb
        add     [r_count], edx
 
        add     [offset], edx
        sub     [tmp_r_cnt], edx
        jnz     .read_mem
.ret:
        popad
        mov     eax, [r_count]
        ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ecx - buffer address
;  edx - buffer size
;  esi - start address in other process
;Output:
;  eax - number of bytes written
 
       locals
         slot   dd ?
         buff   dd ?
         w_count    dd ?
         offset dd ?
         tmp_w_cnt  dd ?
       endl
 
        mov     [slot], eax
        mov     [buff], ecx
        and     [w_count], 0
        mov     [tmp_w_cnt], edx
        mov     [offset], esi
 
        pushad
.read_mem:
        mov     edx, [offset]
        mov     ebx, [tmp_w_cnt]
 
        mov     ecx, 0x400000
        and     edx, 0x3FFFFF
        sub     ecx, edx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        cmp     ecx, 0x8000
        jna     @F
        mov     ecx, 0x8000
@@:
        mov     ebx, [offset]
        push    ecx
        stdcall map_memEx, [proc_mem_map], \
                [slot], ebx, ecx, PG_SWR
        pop     ecx
 
        mov     edi, [offset]
        and     edi, 0xfff
        sub     eax, edi
        jbe     .ret
        cmp     ecx, eax
        jbe     @f
        mov     ecx, eax
        mov     [tmp_w_cnt], eax
@@:
        add     edi, [proc_mem_map]
        mov     esi, [buff]
        mov     edx, ecx
        rep movsb
 
        add     [w_count], edx
        add     [offset], edx
        sub     [tmp_w_cnt], edx
        jnz     .read_mem
.ret:
        popad
        mov     eax, [w_count]
        ret
endp
 
;ebx = 1 - kernel thread
;ecx=thread entry point
;edx=thread stack pointer
;creation flags  0x01 - debugged
;                0x02 - kernel
 
align 4
proc new_sys_threads
       locals
         slot          dd ?
         flags         dd ?
         app_cmdline   dd ? ;0x00
         app_path      dd ? ;0x04
         app_eip       dd ? ;0x08
         app_esp       dd ? ;0x0C
         app_mem       dd ? ;0x10
       endl
 
        shl     ebx, 1
        mov     [flags], ebx
 
        xor     eax, eax
        mov     [app_eip], ecx
        mov     [app_cmdline], eax
        mov     [app_esp], edx
        mov     [app_path], eax
 
        call    lock_application_table
 
        call    alloc_thread_slot
        test    eax, eax
        jz      .failed
 
        mov     [slot], eax
 
        mov     esi, [current_slot]
        mov     ebx, esi      ;ebx=esi - pointer to extended information about current thread
 
        mov     edi, eax
        shl     edi, 8
        add     edi, SLOT_BASE
        mov     edx, edi      ;edx=edi - pointer to extended infomation about new thread
        mov     ecx, 256/4
        xor     eax, eax
        cld
        rep stosd             ;clean extended information about new thread
        mov     esi, ebx
        mov     edi, edx
        mov     ecx, 11
        rep movsb             ;copy process name
 
 
        mov     eax, [ebx+APPDATA.tls_base]
        test    eax, eax
        jz      @F
 
        push    edx
        stdcall user_alloc, 4096
        pop     edx
        test    eax, eax
        jz      .failed1;eax=0
@@:
        mov     [edx+APPDATA.tls_base], eax
 
        mov     eax, [ebx+APPDATA.process]
        mov     [edx+APPDATA.process], eax
 
        lea     ebx, [edx+APPDATA.list]
        lea     ecx, [eax+PROC.thr_list]
        list_add_tail ebx, ecx               ;add thread to process child's list
 
        lea     eax, [app_cmdline]
        stdcall set_app_params , [slot], eax, [flags]
 
        mov     eax, [process_number]           ;set result
        call    unlock_application_table
        ret
.failed:
        xor     eax, eax
.failed1:
        call    unlock_application_table
        dec     eax     ;-1
        ret
endp
 
proc map_process_image stdcall, img_size:dword, file_base:dword, file_size:dword
 
        mov     edx, [img_size]
        mov     esi, [file_base]
        mov     ecx, [file_size]
        add     edx, 4095
        add     ecx, 4095
        shr     edx, 12        ; total pages
        shr     ecx, 12        ; image pages
 
        mov     edi, page_tabs
        shr     esi, 10
        add     esi, edi
 
.map_image:
        lodsd
        and     eax, -4096
        or      eax, PG_UWR
        stosd
        dec     edx
        loop    .map_image
 
        test    edx, edx
        jz      .done
.map_bss:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        or      eax, PG_UWR
        stosd
        dec     edx
        jnz     .map_bss
 
        mov     edi, [file_size]
        mov     ecx, [img_size]
        add     edi, 4095
        and     edi, -4096
        add     ecx, 4095
        and     ecx, -4096
        sub     ecx, edi
        shr     ecx, 2
        xor     eax, eax
        rep stosd
.done:
.fail:
        ret
endp
 
align 4
common_app_entry:
        mov     ebp, [current_slot]
        mov     ebp, [ebp+APPDATA.exec_params]
        test    ebp, ebp
        jz      .exit
        stdcall map_process_image, [ebp+APP_HDR._emem],\
                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]
        mov     esi, [ebp+APP_HDR.path_string]
        mov     edi, [ebp+APP_HDR.path]
        mov     ecx, [ebp+APP_HDR.filename_size]
        cmp     ecx, 1023
        jc      @f
        mov     ecx, 1022
@@:
        push    esi
        test    edi, edi
        jz      @f
        mov     al, '/'
        stosb
        rep movsb
        mov     byte [edi], 0
@@:
        call    kernel_free
        mov     edi, [ebp+APP_HDR.cmdline]
        test    edi, edi
        jz      .check_tls_header
        lea     esi, [ebp+sizeof.APP_HDR]
        mov     ecx, [ebp+APP_HDR.cmdline_size]
        cmp     ecx, 256
        jb      .copy_cmdline
        mov     edi, [ebp+APP_HDR._emem]
        add     edi, 4095
        and     edi, -4096
        sub     edi, ecx
        dec     edi
        cmp     word [6], '00'
        jne     @f
        mov     [APP_HEADER_00_.i_param], edi
        jmp     .copy_cmdline
@@:
        mov     [APP_HEADER_01_.i_param], edi
.copy_cmdline:
        rep movsb
        mov     byte [edi], 0
.check_tls_header:
        cmp     word [6], '02'
        jne     .cleanup
        call    init_heap
        stdcall user_alloc, 4096
        mov     edx, [current_slot]
        mov     [edx+APPDATA.tls_base], eax
        mov     [tls_data_l+2], ax
        shr     eax, 16
        mov     [tls_data_l+4], al
        mov     [tls_data_l+7], ah
        mov     dx, app_tls
        mov     fs, dx
.cleanup:
        stdcall free_kernel_space, [ebp+APP_HDR.img_base]
        stdcall kernel_free, ebp
        mov     ebx, [current_slot]
        cmp     [ebx+APPDATA.debugger_slot], 0
        je      .exit
        mov     eax, [TASK_BASE]
        mov     [eax+TASKDATA.state], 1
        call    change_task
.exit:
        popad
        iretd
 
EFL_IF      = 0x0200
EFL_IOPL1   = 0x1000
EFL_IOPL2   = 0x2000
EFL_IOPL3   = 0x3000
 
align 4
proc set_app_params stdcall,slot:dword, params:dword, flags:dword
 
       locals
         pl0_stack dd ?
       endl
 
        mov     eax, [xsave_area_size]
        add     eax, RING0_STACK_SIZE
        stdcall kernel_alloc, eax
        mov     [pl0_stack], eax
 
        lea     edi, [eax+RING0_STACK_SIZE]
 
        mov     eax, [slot]
        mov     ebx, eax
 
        shl     eax, 8
        mov     [eax+SLOT_BASE+APPDATA.fpu_state], edi
        mov     [eax+SLOT_BASE+APPDATA.exc_handler], 0
        mov     [eax+SLOT_BASE+APPDATA.except_mask], 0
        mov     [eax+SLOT_BASE+APPDATA.terminate_protection], 80000001h
 
;set default io permission map
        mov     ecx, [SLOT_BASE+256+APPDATA.io_map]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [SLOT_BASE+256+APPDATA.io_map+4]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
 
        mov     esi, fpu_data
        mov     ecx, 512/4
        rep movsd
 
        cmp     ebx, [TASK_COUNT]
        jle     .noinc
        inc     dword [TASK_COUNT]     ;update number of processes
.noinc:
        shl     ebx, 8
        lea     edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
        mov     [SLOT_BASE+APPDATA.fd_ev+ebx], edx
        mov     [SLOT_BASE+APPDATA.bk_ev+ebx], edx
 
        add     edx, APP_OBJ_OFFSET-APP_EV_OFFSET
        mov     [SLOT_BASE+APPDATA.fd_obj+ebx], edx
        mov     [SLOT_BASE+APPDATA.bk_obj+ebx], edx
 
        mov     ecx, [def_cursor]
        mov     [SLOT_BASE+APPDATA.cursor+ebx], ecx
        mov     eax, [pl0_stack]
        mov     [SLOT_BASE+APPDATA.pl0_stack+ebx], eax
        add     eax, RING0_STACK_SIZE
        mov     [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
 
        push    ebx
        stdcall kernel_alloc, maxPathLength
        pop     ebx
        mov     esi, [current_slot]
        mov     esi, [esi+APPDATA.cur_dir]
        mov     ecx, maxPathLength/4
        mov     edi, eax
        mov     [ebx+SLOT_BASE+APPDATA.cur_dir], eax
        rep movsd
 
        shr     ebx, 3
        mov     dword [CURRENT_TASK+ebx+0x10], 0
 
        mov     ebx, [slot]
        mov     eax, ebx
        shl     ebx, 5
        lea     ecx, [draw_data+ebx];ecx - pointer to draw data
 
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
        mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
        mov     [ebx+window_data+WDATA.fl_redraw], 1
        add     ebx, CURRENT_TASK     ;ebx - pointer to information about process
        mov     [ebx+TASKDATA.wnd_number], al;set window number on screen = process slot
 
        mov     [ebx+TASKDATA.event_mask], dword 1+2+4;set default event flags (see 40 function)
 
        inc     dword [process_number]
        mov     eax, [process_number]
        mov     [ebx+4], eax    ;set PID
 
;set draw data to full screen
        xor     eax, eax
        mov     [ecx+0], dword eax
        mov     [ecx+4], dword eax
        mov     eax, [screen_workarea.right]
        mov     [ecx+8], eax
        mov     eax, [screen_workarea.bottom]
        mov     [ecx+12], eax
 
        mov     ebx, [pl0_stack]
        mov     esi, [params]
        lea     ecx, [ebx+REG_EIP]
        xor     eax, eax
 
        mov     [ebx+REG_RET], dword common_app_entry
        mov     [ebx+REG_EDI], eax
        mov     [ebx+REG_ESI], eax
        mov     [ebx+REG_EBP], eax
        mov     [ebx+REG_ESP], ecx;ebx+REG_EIP
        mov     [ebx+REG_EBX], eax
        mov     [ebx+REG_EDX], eax
        mov     [ebx+REG_ECX], eax
        mov     [ebx+REG_EAX], eax
 
        mov     eax, [esi+APP_HDR.eip]
        mov     [ebx+REG_EIP], eax
        mov     [ebx+REG_CS], dword app_code
        mov     ecx, USER_PRIORITY
 
        test    byte [flags], 2
        jz      @F
 
        mov     [ebx+REG_CS], dword os_code ; kernel thread
        mov     ecx, MAX_PRIORITY
@@:
        mov     [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
 
        mov     eax, [esi+APP_HDR.esp]
        mov     [ebx+REG_APP_ESP], eax
        mov     [ebx+REG_SS], dword app_data
 
        lea     edx, [ebx+REG_RET]
        mov     ebx, [slot]
        shl     ebx, 5
        mov     [ebx*8+SLOT_BASE+APPDATA.saved_esp], edx
 
        xor     edx, edx; process state - running
; set if debuggee
        test    byte [flags], 1
        jz      .no_debug
        mov     eax, [CURRENT_TASK]
        mov     [SLOT_BASE+ebx*8+APPDATA.debugger_slot], eax
.no_debug:
        mov     [CURRENT_TASK+ebx+TASKDATA.state], dl
        lea     edx, [SLOT_BASE+ebx*8]
        call    scheduler_add_thread
        ret
endp
 
align 4
get_stack_base:
        mov     eax, [current_slot]
        mov     eax, [eax+APPDATA.pl0_stack]
        ret
 
 
include "debug.inc"

Rev 7124	Rev 7136
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License. ;;	4	;; Distributed under terms of the GNU General Public License. ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 7124 $	8	$Revision: 7136 $
9		9
10		10
11	GREEDY_KERNEL equ 0	11	GREEDY_KERNEL = 0
12		12
13	struct APP_HEADER_00_	13	struct APP_HEADER_00_
14	banner dq ?	14	banner dq ?
15	version dd ? ;+8	15	version dd ? ;+8
16	start dd ? ;+12	16	start dd ? ;+12
17	i_end dd ? ;+16	17	i_end dd ? ;+16
18	mem_size dd ? ;+20	18	mem_size dd ? ;+20
19	i_param dd ? ;+24	19	i_param dd ? ;+24
20	ends	20	ends
21		21
22	struct APP_HEADER_01_	22	struct APP_HEADER_01_
23	banner dq ?	23	banner dq ?
24	version dd ? ;+8	24	version dd ? ;+8
25	start dd ? ;+12	25	start dd ? ;+12
26	i_end dd ? ;+16	26	i_end dd ? ;+16
27	mem_size dd ? ;+20	27	mem_size dd ? ;+20
28	stack_top dd ? ;+24	28	stack_top dd ? ;+24
29	i_param dd ? ;+28	29	i_param dd ? ;+28
30	i_icon dd ? ;+32	30	i_icon dd ? ;+32
31	ends	31	ends
32		32
33	struct APP_HDR	33	struct APP_HDR
34	cmdline rd 1 ;0x00	34	cmdline rd 1 ;0x00
35	path rd 1 ;0x04	35	path rd 1 ;0x04
36	eip rd 1 ;0x08	36	eip rd 1 ;0x08
37	esp rd 1 ;0x0C	37	esp rd 1 ;0x0C
38	_edata rd 1 ;0x10	38	_edata rd 1 ;0x10
39	_emem rd 1 ;0x14	39	_emem rd 1 ;0x14
40	img_base rd 1 ;0x18	40	img_base rd 1 ;0x18
41	img_size rd 1	41	img_size rd 1
42	filename_size rd 1	42	filename_size rd 1
43	cmdline_size rd 1	43	cmdline_size rd 1
44	path_string rd 1	44	path_string rd 1
45	ends	45	ends
46		46
47	macro _clear_ op	47	macro _clear_ op
48	{ mov ecx, op/4	48	{ mov ecx, op/4
49	xor eax, eax	49	xor eax, eax
50	cld	50	cld
51	rep stosd	51	rep stosd
52	}	52	}
53		53
54	align 4	54	align 4
55	_strnlen:	55	_strnlen:
56	mov edx, ecx	56	mov edx, ecx
57	xor eax, eax	57	xor eax, eax
58	repne scasb	58	repne scasb
59	jne @F	59	jne @F
60	inc ecx	60	inc ecx
61	@@:	61	@@:
62	mov eax, edx	62	mov eax, edx
63	sub eax, ecx	63	sub eax, ecx
64	retn	64	retn
65		65
66	fs_execute_from_sysdir:	66	fs_execute_from_sysdir:
67	xor ebx, ebx	67	xor ebx, ebx
68	fs_execute_from_sysdir_param:	68	fs_execute_from_sysdir_param:
69	stdcall kernel_alloc, maxPathLength	69	stdcall kernel_alloc, maxPathLength
70	push eax ebx	70	push eax ebx
71	mov esi, ebp	71	mov esi, ebp
72	mov edi, eax	72	mov edi, eax
73	xor eax, eax	73	xor eax, eax
74	call getFullPath	74	call getFullPath
75	pop ecx ebx	75	pop ecx ebx
76	xor edx, edx	76	xor edx, edx
77	proc fs_execute	77	proc fs_execute
78	; edx = flags	78	; edx = flags
79	; ecx -> cmdline	79	; ecx -> cmdline
80	; ebx -> absolute file path	80	; ebx -> absolute file path
81	; eax = string length	81	; eax = string length
82	locals	82	locals
83	cmdline rd 1	83	cmdline rd 1
84	flags rd 1	84	flags rd 1
85	slot rd 1	85	slot rd 1
86	slot_base rd 1	86	slot_base rd 1
87	; app header data	87	; app header data
88	hdr_cmdline rd 1	88	hdr_cmdline rd 1
89	hdr_path rd 1	89	hdr_path rd 1
90	hdr_eip rd 1	90	hdr_eip rd 1
91	hdr_esp rd 1	91	hdr_esp rd 1
92	hdr_edata rd 1	92	hdr_edata rd 1
93	hdr_emem rd 1	93	hdr_emem rd 1
94	file_base rd 1	94	file_base rd 1
95	file_size rd 1	95	file_size rd 1
96	filename_size rd 1	96	filename_size rd 1
97	cmdline_size rd 1	97	cmdline_size rd 1
98	path_string rd 1	98	path_string rd 1
99	endl	99	endl
100		100
101	mov [flags], edx	101	mov [flags], edx
102	mov [cmdline], ecx	102	mov [cmdline], ecx
103	mov [path_string], ebx	103	mov [path_string], ebx
104	mov [filename_size], eax	104	mov [filename_size], eax
105	mov esi, -ERROR_FILE_NOT_FOUND	105	mov esi, -ERROR_FILE_NOT_FOUND
106	test eax, eax	106	test eax, eax
107	jz .err_file	107	jz .err_file
108	stdcall load_file, ebx	108	stdcall load_file, ebx
109	test eax, eax	109	test eax, eax
110	jz .err_file	110	jz .err_file
111		111
112	mov [file_base], eax	112	mov [file_base], eax
113	mov [file_size], ebx	113	mov [file_size], ebx
114	lea ebx, [hdr_cmdline]	114	lea ebx, [hdr_cmdline]
115	call test_app_header	115	call test_app_header
116	mov esi, -0x1F	116	mov esi, -0x1F
117	test eax, eax	117	test eax, eax
118	jz .err_hdr	118	jz .err_hdr
119		119
120	call lock_application_table	120	call lock_application_table
121	call alloc_thread_slot	121	call alloc_thread_slot
122	mov esi, -0x20 ; too many processes	122	mov esi, -0x20 ; too many processes
123	test eax, eax	123	test eax, eax
124	jz .err_0	124	jz .err_0
125		125
126	mov [slot], eax	126	mov [slot], eax
127	shl eax, 8	127	shl eax, 8
128	lea edi, [SLOT_BASE+eax]	128	lea edi, [SLOT_BASE+eax]
129	mov [slot_base], edi	129	mov [slot_base], edi
130	; clean extended information about process	130	; clean extended information about process
131	mov ecx, 256/4	131	mov ecx, 256/4
132	xor eax, eax	132	xor eax, eax
133	cld	133	cld
134	rep stosd	134	rep stosd
135	; write application name	135	; write application name
136	stdcall strrchr, [path_string], '/'	136	stdcall strrchr, [path_string], '/'
137	lea esi, [eax+1] ; -> name without path	137	lea esi, [eax+1] ; -> name without path
138	mov ecx, 11	138	mov ecx, 11
139	mov edi, [slot_base]	139	mov edi, [slot_base]
140	@@:	140	@@:
141	call utf8to16	141	call utf8to16
142	call uni2ansi_char	142	call uni2ansi_char
143	cmp al, '.'	143	cmp al, '.'
144	jz @f	144	jz @f
145	test al, al	145	test al, al
146	jz @f	146	jz @f
147	stosb	147	stosb
148	loop @b	148	loop @b
149	@@:	149	@@:
150	mov edi, [cmdline]	150	mov edi, [cmdline]
151	xor eax, eax	151	xor eax, eax
152	test edi, edi	152	test edi, edi
153	jz @f	153	jz @f
154	mov ecx, 65535	154	mov ecx, 65535
155	call _strnlen	155	call _strnlen
156	cmp eax, 256	156	cmp eax, 256
157	jb @f	157	jb @f
158	lea ebx, [eax+1]	158	lea ebx, [eax+1]
159	add [hdr_emem], ebx	159	add [hdr_emem], ebx
160	@@:	160	@@:
161	mov [cmdline_size], eax	161	mov [cmdline_size], eax
162	stdcall create_process, [hdr_emem]	162	stdcall create_process, [hdr_emem]
163	mov esi, -30 ; no memory	163	mov esi, -30 ; no memory
164	test eax, eax	164	test eax, eax
165	jz .err_hdr	165	jz .err_hdr
166		166
167	mov ebx, [sys_proc+LHEAD.prev]	167	mov ebx, [sys_proc+LHEAD.prev]
168	__list_add eax, ebx, sys_proc	168	__list_add eax, ebx, sys_proc
169	mov ebx, [hdr_emem]	169	mov ebx, [hdr_emem]
170	mov [eax+PROC.mem_used], ebx	170	mov [eax+PROC.mem_used], ebx
171	mov ebx, [slot_base]	171	mov ebx, [slot_base]
172	mov [ebx+APPDATA.process], eax	172	mov [ebx+APPDATA.process], eax
173	lea edx, [ebx+APPDATA.list]	173	lea edx, [ebx+APPDATA.list]
174	lea ecx, [eax+PROC.thr_list]	174	lea ecx, [eax+PROC.thr_list]
175	list_add_tail edx, ecx	175	list_add_tail edx, ecx
176	mov eax, [cmdline_size]	176	mov eax, [cmdline_size]
177	add eax, sizeof.APP_HDR	177	add eax, sizeof.APP_HDR
178	stdcall kernel_alloc, eax	178	stdcall kernel_alloc, eax
179	mov [ebx+APPDATA.exec_params], eax	179	mov [ebx+APPDATA.exec_params], eax
180	mov edi, eax	180	mov edi, eax
181	lea esi, [hdr_cmdline]	181	lea esi, [hdr_cmdline]
182	mov ecx, sizeof.APP_HDR/4	182	mov ecx, sizeof.APP_HDR/4
183	rep movsd	183	rep movsd
184	mov ecx, [cmdline_size]	184	mov ecx, [cmdline_size]
185	mov esi, [cmdline]	185	mov esi, [cmdline]
186	rep movsb	186	rep movsb
187	lea eax, [hdr_cmdline]	187	lea eax, [hdr_cmdline]
188	stdcall set_app_params , [slot], eax, [flags]	188	stdcall set_app_params , [slot], eax, [flags]
189	mov eax, [process_number] ;set result	189	mov eax, [process_number] ;set result
190	call unlock_application_table	190	call unlock_application_table
191	ret	191	ret
192		192
193	.err_0:	193	.err_0:
194	call unlock_application_table	194	call unlock_application_table
195	.err_hdr:	195	.err_hdr:
196	stdcall kernel_free, [file_base]	196	stdcall kernel_free, [file_base]
197	.err_file:	197	.err_file:
198	stdcall kernel_free, [path_string]	198	stdcall kernel_free, [path_string]
199	mov eax, esi	199	mov eax, esi
200	ret	200	ret
201	endp	201	endp
202		202
203	align 4	203	align 4
204	test_app_header:	204	test_app_header:
205	virtual at eax	205	virtual at eax
206	APP_HEADER_00 APP_HEADER_00_	206	APP_HEADER_00 APP_HEADER_00_
207	end virtual	207	end virtual
208	virtual at eax	208	virtual at eax
209	APP_HEADER_01 APP_HEADER_01_	209	APP_HEADER_01 APP_HEADER_01_
210	end virtual	210	end virtual
211		211
212	cmp dword [eax], 'MENU'	212	cmp dword [eax], 'MENU'
213	jne .fail	213	jne .fail
214	cmp word [eax+4], 'ET'	214	cmp word [eax+4], 'ET'
215	jne .fail	215	jne .fail
216		216
217	cmp [eax+6], word '00'	217	cmp [eax+6], word '00'
218	jne .check_01_header	218	jne .check_01_header
219		219
220	mov ecx, [APP_HEADER_00.start]	220	mov ecx, [APP_HEADER_00.start]
221	mov [ebx+APP_HDR.eip], ecx	221	mov [ebx+APP_HDR.eip], ecx
222	mov edx, [APP_HEADER_00.mem_size]	222	mov edx, [APP_HEADER_00.mem_size]
223	mov [ebx+APP_HDR._emem], edx	223	mov [ebx+APP_HDR._emem], edx
224	shr edx, 1	224	shr edx, 1
225	sub edx, 0x10	225	sub edx, 0x10
226	mov [ebx+APP_HDR.esp], edx	226	mov [ebx+APP_HDR.esp], edx
227	mov ecx, [APP_HEADER_00.i_param]	227	mov ecx, [APP_HEADER_00.i_param]
228	mov [ebx+APP_HDR.cmdline], ecx	228	mov [ebx+APP_HDR.cmdline], ecx
229	mov [ebx+APP_HDR.path], 0	229	mov [ebx+APP_HDR.path], 0
230	mov edx, [APP_HEADER_00.i_end]	230	mov edx, [APP_HEADER_00.i_end]
231	mov [ebx+APP_HDR._edata], edx	231	mov [ebx+APP_HDR._edata], edx
232	ret	232	ret
233		233
234	.check_01_header:	234	.check_01_header:
235		235
236	cmp [eax+6], word '01'	236	cmp [eax+6], word '01'
237	je @f	237	je @f
238	cmp [eax+6], word '02'	238	cmp [eax+6], word '02'
239	jne .fail	239	jne .fail
240	@@:	240	@@:
241	mov ecx, [APP_HEADER_01.start]	241	mov ecx, [APP_HEADER_01.start]
242	mov [ebx+0x08], ecx	242	mov [ebx+0x08], ecx
243	mov edx, [APP_HEADER_01.mem_size]	243	mov edx, [APP_HEADER_01.mem_size]
244		244
245	; \begin{diamond}[20.08.2006]	245	; \begin{diamond}[20.08.2006]
246	; sanity check (functions 19,58 load app_i_end bytes and that must	246	; sanity check (functions 19,58 load app_i_end bytes and that must
247	; fit in allocated memory to prevent kernel faults)	247	; fit in allocated memory to prevent kernel faults)
248	cmp edx, [APP_HEADER_01.i_end]	248	cmp edx, [APP_HEADER_01.i_end]
249	jb .fail	249	jb .fail
250	; \end{diamond}[20.08.2006]	250	; \end{diamond}[20.08.2006]
251		251
252	mov [ebx+APP_HDR._emem], edx	252	mov [ebx+APP_HDR._emem], edx
253	mov ecx, [APP_HEADER_01.stack_top]	253	mov ecx, [APP_HEADER_01.stack_top]
254	mov [ebx+APP_HDR.esp], ecx	254	mov [ebx+APP_HDR.esp], ecx
255	mov edx, [APP_HEADER_01.i_param]	255	mov edx, [APP_HEADER_01.i_param]
256	mov [ebx+APP_HDR.cmdline], edx	256	mov [ebx+APP_HDR.cmdline], edx
257	mov ecx, [APP_HEADER_01.i_icon]	257	mov ecx, [APP_HEADER_01.i_icon]
258	mov [ebx+APP_HDR.path], ecx	258	mov [ebx+APP_HDR.path], ecx
259	mov edx, [APP_HEADER_01.i_end]	259	mov edx, [APP_HEADER_01.i_end]
260	mov [ebx+APP_HDR._edata], edx	260	mov [ebx+APP_HDR._edata], edx
261	ret	261	ret
262	.fail:	262	.fail:
263	xor eax, eax	263	xor eax, eax
264	ret	264	ret
265		265
266	align 4	266	align 4
267	alloc_thread_slot:	267	alloc_thread_slot:
268	;input:	268	;input:
269	; none	269	; none
270	;result:	270	;result:
271	; eax=[new_thread_slot]<>0 - ok	271	; eax=[new_thread_slot]<>0 - ok
272	; 0 - failed.	272	; 0 - failed.
273	;This function find least empty slot.	273	;This function find least empty slot.
274	;It doesn't increase [TASK_COUNT]!	274	;It doesn't increase [TASK_COUNT]!
275		275
276		276
277	mov edx, thr_slot_map	277	mov edx, thr_slot_map
278	pushfd	278	pushfd
279	cli	279	cli
280	.l1:	280	.l1:
281	bsf eax, [edx]	281	bsf eax, [edx]
282	jnz .found	282	jnz .found
283	add edx, 4	283	add edx, 4
284	cmp edx, thr_slot_map+32	284	cmp edx, thr_slot_map+32
285	jb .l1	285	jb .l1
286		286
287	popfd	287	popfd
288	xor eax, eax	288	xor eax, eax
289	ret	289	ret
290	.found:	290	.found:
291	btr [edx], eax	291	btr [edx], eax
292	sub edx, thr_slot_map	292	sub edx, thr_slot_map
293	lea eax, [eax+edx*8]	293	lea eax, [eax+edx*8]
294	popfd	294	popfd
295	ret	295	ret
296		296
297	align 4	297	align 4
298	proc create_process stdcall, app_size:dword	298	proc create_process stdcall, app_size:dword
299	locals	299	locals
300	process dd ?	300	process dd ?
301	app_tabs dd ?	301	app_tabs dd ?
302	endl	302	endl
303		303
304	push ebx	304	push ebx
305	push esi	305	push esi
306	push edi	306	push edi
307		307
308	xor eax, eax	308	xor eax, eax
309	mov [process], eax	309	mov [process], eax
310		310
311	mov eax, [app_size]	311	mov eax, [app_size]
312	add eax, 0x3FFFFF	312	add eax, 0x3FFFFF
313	shr eax, 22	313	shr eax, 22
314	mov [app_tabs], eax	314	mov [app_tabs], eax
315		315
316	stdcall kernel_alloc, 0x2000	316	stdcall kernel_alloc, 0x2000
317	test eax, eax	317	test eax, eax
318	jz .fail	318	jz .fail
319	mov [process], eax	319	mov [process], eax
320		320
321	lea edi, [eax+PROC.heap_lock]	321	lea edi, [eax+PROC.heap_lock]
322	mov ecx, (PROC.ht_free-PROC.heap_lock)/4	322	mov ecx, (PROC.ht_free-PROC.heap_lock)/4
323		323
324	list_init eax	324	list_init eax
325	add eax, PROC.thr_list	325	add eax, PROC.thr_list
326	list_init eax	326	list_init eax
327		327
328	xor eax, eax	328	xor eax, eax
329	cld	329	cld
330	rep stosd	330	rep stosd
331		331
332	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3	332	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
333	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr	333	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr
334	mov ecx, (PROC.pdt_0 - PROC.htab)/4	334	mov ecx, (PROC.pdt_0 - PROC.htab)/4
335	add edi, 8	335	add edi, 8
336	inc eax	336	inc eax
337	@@:	337	@@:
338	stosd	338	stosd
339	inc eax	339	inc eax
340	cmp eax, ecx	340	cmp eax, ecx
341	jbe @B	341	jbe @B
342		342
343	mov eax, edi	343	mov eax, edi
344	call get_pg_addr	344	call get_pg_addr
345	mov [edi-4096+PROC.pdt_0_phys], eax	345	mov [edi-4096+PROC.pdt_0_phys], eax
346		346
347	mov ecx, (OS_BASE shr 20)/4	347	mov ecx, (OS_BASE shr 20)/4
348	xor eax, eax	348	xor eax, eax
349	rep stosd	349	rep stosd
350		350
351	mov ecx, (OS_BASE shr 20)/4	351	mov ecx, (OS_BASE shr 20)/4
352	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)	352	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
353	rep movsd	353	rep movsd
354		354
355	mov eax, [edi-8192+PROC.pdt_0_phys]	355	mov eax, [edi-8192+PROC.pdt_0_phys]
356	or eax, PG_SWR	356	or eax, PG_SWR
357	mov [edi-4096+(page_tabs shr 20)], eax	357	mov [edi-4096+(page_tabs shr 20)], eax
358		358
359	lea edx, [edi-4096]	359	lea edx, [edi-4096]
360	mov esi, [app_tabs]	360	mov esi, [app_tabs]
361		361
362	.alloc_page_dir:	362	.alloc_page_dir:
363	call alloc_page	363	call alloc_page
364	test eax, eax	364	test eax, eax
365	jz .fail	365	jz .fail
366	or eax, PG_UWR	366	or eax, PG_UWR
367	mov [edx], eax	367	mov [edx], eax
368		368
369	mov edi, [tmp_task_ptab]	369	mov edi, [tmp_task_ptab]
370	stdcall map_page, edi, eax, PG_SWR	370	stdcall map_page, edi, eax, PG_SWR
371	mov ecx, 1024	371	mov ecx, 1024
372	xor eax, eax	372	xor eax, eax
373	rep stosd	373	rep stosd
374		374
375	add edx, 4	375	add edx, 4
376	dec esi	376	dec esi
377	jnz .alloc_page_dir	377	jnz .alloc_page_dir
378		378
379	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	379	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
380	mov eax, [process]	380	mov eax, [process]
381		381
382	pop edi	382	pop edi
383	pop esi	383	pop esi
384	pop ebx	384	pop ebx
385	ret	385	ret
386	.fail:	386	.fail:
387	mov ecx, [process]	387	mov ecx, [process]
388	jcxz @F	388	jcxz @F
389		389
390	call destroy_process	390	call destroy_process
391	@@:	391	@@:
392	xor eax, eax	392	xor eax, eax
393	pop edi	393	pop edi
394	pop esi	394	pop esi
395	pop ebx	395	pop ebx
396	ret	396	ret
397	endp	397	endp
398		398
399	align 4	399	align 4
400	proc destroy_page_table stdcall, pg_tab:dword	400	proc destroy_page_table stdcall, pg_tab:dword
401		401
402	push esi	402	push esi
403		403
404	mov esi, [pg_tab]	404	mov esi, [pg_tab]
405	mov ecx, 1024	405	mov ecx, 1024
406	.free:	406	.free:
407	mov eax, [esi]	407	mov eax, [esi]
408	test eax, 1	408	test eax, 1
409	jz .next	409	jz .next
410	test eax, 2	410	test eax, 2
411	jz .next	411	jz .next
412	test eax, 1 shl 9	412	test eax, 1 shl 9
413	jnz .next ;skip shared pages	413	jnz .next ;skip shared pages
414	call free_page	414	call free_page
415	.next:	415	.next:
416	add esi, 4	416	add esi, 4
417	dec ecx	417	dec ecx
418	jnz .free	418	jnz .free
419	pop esi	419	pop esi
420	ret	420	ret
421	endp	421	endp
422		422
423	align 4	423	align 4
424	destroy_process: ;fastcall ecx= ptr to process	424	destroy_process: ;fastcall ecx= ptr to process
425		425
426	lea eax, [ecx+PROC.thr_list]	426	lea eax, [ecx+PROC.thr_list]
427	cmp eax, [eax+LHEAD.next]	427	cmp eax, [eax+LHEAD.next]
428	jne .exit	428	jne .exit
429		429
430	align 4	430	align 4
431	.internal:	431	.internal:
432	push ecx	432	push ecx
433		433
434	mov esi, ecx	434	mov esi, ecx
435	list_del esi	435	list_del esi
436		436
437	mov esi, [esi+PROC.dlls_list_ptr]	437	mov esi, [esi+PROC.dlls_list_ptr]
438	call destroy_all_hdlls	438	call destroy_all_hdlls
439		439
440	mov esi, [esp]	440	mov esi, [esp]
441	add esi, PROC.pdt_0	441	add esi, PROC.pdt_0
442	mov edi, (0x80000000 shr 20)/4	442	mov edi, (0x80000000 shr 20)/4
443	.destroy:	443	.destroy:
444	mov eax, [esi]	444	mov eax, [esi]
445	test eax, 1	445	test eax, 1
446	jz .next	446	jz .next
447	and eax, not 0xFFF	447	and eax, not 0xFFF
448	stdcall map_page, [tmp_task_ptab], eax, PG_SWR	448	stdcall map_page, [tmp_task_ptab], eax, PG_SWR
449	stdcall destroy_page_table, [tmp_task_ptab]	449	stdcall destroy_page_table, [tmp_task_ptab]
450	mov eax, [esi]	450	mov eax, [esi]
451	call free_page	451	call free_page
452	.next:	452	.next:
453	add esi, 4	453	add esi, 4
454	dec edi	454	dec edi
455	jnz .destroy	455	jnz .destroy
456		456
457	call kernel_free ;ecx still in stack	457	call kernel_free ;ecx still in stack
458	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	458	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
459	.exit:	459	.exit:
460	ret	460	ret
461		461
462	align 4	462	align 4
463	get_pid:	463	get_pid:
464	mov eax, [TASK_BASE]	464	mov eax, [TASK_BASE]
465	mov eax, [eax+TASKDATA.pid]	465	mov eax, [eax+TASKDATA.pid]
466	ret	466	ret
467		467
468	pid_to_slot:	468	pid_to_slot:
469	;Input:	469	;Input:
470	; eax - pid of process	470	; eax - pid of process
471	;Output:	471	;Output:
472	; eax - slot of process or 0 if process don't exists	472	; eax - slot of process or 0 if process don't exists
473	;Search process by PID.	473	;Search process by PID.
474	push ebx	474	push ebx
475	push ecx	475	push ecx
476	mov ebx, [TASK_COUNT]	476	mov ebx, [TASK_COUNT]
477	shl ebx, 5	477	shl ebx, 5
478	mov ecx, 2*32	478	mov ecx, 2*32
479		479
480	.loop:	480	.loop:
481	;ecx=offset of current process info entry	481	;ecx=offset of current process info entry
482	;ebx=maximum permitted offset	482	;ebx=maximum permitted offset
483	cmp byte [CURRENT_TASK+ecx+0xa], 9	483	cmp byte [CURRENT_TASK+ecx+0xa], 9
484	jz .endloop ;skip empty slots	484	jz .endloop ;skip empty slots
485	cmp [CURRENT_TASK+ecx+0x4], eax;check PID	485	cmp [CURRENT_TASK+ecx+0x4], eax;check PID
486	jz .pid_found	486	jz .pid_found
487	.endloop:	487	.endloop:
488	add ecx, 32	488	add ecx, 32
489	cmp ecx, ebx	489	cmp ecx, ebx
490	jle .loop	490	jle .loop
491		491
492	pop ecx	492	pop ecx
493	pop ebx	493	pop ebx
494	xor eax, eax	494	xor eax, eax
495	ret	495	ret
496		496
497	.pid_found:	497	.pid_found:
498	shr ecx, 5	498	shr ecx, 5
499	mov eax, ecx ;convert offset to index of slot	499	mov eax, ecx ;convert offset to index of slot
500	pop ecx	500	pop ecx

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 7124 → 7136