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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 8874 $
 
 
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  ; index of new thread slot
        slot_base       rd  1  ; base address of it
; 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  ; fill our app header data locals with values from header of given program (if its correct)
        mov     esi, -0x1F
        test    eax, eax
        jz      .err_hdr
 
        call    lock_application_table
        call    alloc_thread_slot   ; create a slot for new thread
        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, sizeof.APPDATA/4
        xor     eax, eax
        cld
        rep stosd
; write application name ( APPDATA.appname )
        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
; if cmdline length >= 256 then increase needed memory size by this length
        lea     ebx, [eax+1]
        add     [hdr_emem], ebx
@@:
        mov     [cmdline_size], eax
        stdcall create_process, [hdr_emem]  ; create a new process
        mov     esi, -30    ; no memory
        test    eax, eax
        jz      .err_hdr
 
; add new process to the list
        mov     ebx, [sys_proc+LHEAD.prev]
        __list_add eax, ebx, sys_proc
; fill the structure fields:
        mov     ebx, [hdr_emem]
        mov     [eax+PROC.mem_used], ebx
 
; write that main thread of app belongs to new process
        mov     ebx, [slot_base]
        mov     [ebx+APPDATA.process], eax
 
; initialize the thread list of process: at this moment it consists only of one main thread
        lea     edx, [ebx+APPDATA.list]
        lea     ecx, [eax+PROC.thr_list]
        list_add_tail edx, ecx
 
; allocate space and copy app header data locals and cmdline string there, put pointer to exec_params of new thread
        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
; set other parameters of application
        lea     eax, [hdr_cmdline]
        stdcall set_app_params , [slot], eax, [flags]
        mov     eax, [process_number]   ; return process number
        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 [thread_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, [thread_count]
        shl     ebx, BSF sizeof.TASKDATA ; multiply by size 
        ; add 2*32 cause:
        ; [TASK_TABLE; TASK_TABLE + 32) isnt a task actually
        ; skip first process in the task table
        mov     ecx, 2*32
 
.loop:
;ecx = offset of current process info entry
;ebx = maximum permitted offset
 
        cmp     [TASK_TABLE+ecx+TASKDATA.state], TSTATE_FREE
        jz      .endloop ;skip empty slots
        cmp     [TASK_TABLE+ecx+TASKDATA.pid], eax;check PID
        jz      .pid_found
.endloop:
        add     ecx, sizeof.TASKDATA
        cmp     ecx, ebx
        jle     .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
 
.pid_found:
        shr     ecx, BSF sizeof.TASKDATA ; divide by size
        mov     eax, ecx ;convert offset to index of slot
        pop     ecx
        pop     ebx
        ret
 
 
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, sizeof.APPDATA/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
; APPDATA.exec_params have first thread only,
; so second and next threads don't get here (they jump to .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
        stdcall is_region_userspace, edi, [ebp+APP_HDR.filename_size]
        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:
        inc     ecx  ; keep in mind about 0 in the end
        stdcall is_region_userspace, edi, ecx
        jz      .check_tls_header
        dec     ecx
        rep movsb
        mov     byte [edi], 0
.check_tls_header:
        cmp     word [6], '02'
        jne     .try_load_dll ;.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       
; { Patch by Coldy, For DLL autoload    
.try_load_dll:         
; Test app header version 
        mov     ecx, dword[ebp+APP_HDR.img_base]
        cmp     dword[ecx+8], 2
        jne     .cleanup
;if APP_HEADER.version = 2 => load lib/dll.obj & change eip to APP_STARTUP_THUNK
        DEBUGF 1, 'K : App header version 2\n'
        stdcall load_library, dll_lib_path, 0
        cmp     eax, 0
        jne     @f
; Something went wrong (TODO: Next 2 line is code copy after .cleanup)  
        stdcall free_kernel_space, [ebp+APP_HDR.img_base]
        stdcall kernel_free, ebp
        DEBUGF 1, 'K : DLL.OBJ not found! Terminate application!\n'
        mov     ebx, dll_error_msg
        mov     ebp, notifyapp
        call    fs_execute_from_sysdir_param
; Terminate process (TODO: Need jump to .cleanup after sys_end ?) 
        call    sys_end
        
@@:       
; Find APP_STARTUP_THUNK in DLL.OBJ
        sub     eax, 4
        mov     eax, [eax]
        
;.change_eip:
        mov     ecx, [current_slot]
        mov     ecx, [ecx+APPDATA.pl0_stack]
        mov     [ecx+REG_EIP], eax
        
; } End patch by Coldy, For DLL autoload
.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], TSTATE_RUN_SUSPENDED
        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+sizeof.APPDATA+APPDATA.io_map]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [SLOT_BASE+sizeof.APPDATA+APPDATA.io_map+4]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
 
        mov     esi, fpu_data
        mov     ecx, [xsave_area_size]
        add     ecx, 3
        shr     ecx, 2
        rep movsd
 
        cmp     [thread_count], ebx
        adc     [thread_count], 0   ; update number of processes
        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 [TASK_TABLE+ebx+TASKDATA.mem_start], 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, TASK_TABLE     ;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+TASKDATA.pid], 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_slot_idx]
        mov     [SLOT_BASE+ebx*8+APPDATA.debugger_slot], eax
.no_debug:
        mov     [TASK_TABLE+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 8869	Rev 8874
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2021. 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: 8869 $	8	$Revision: 8874 $
9		9
10		10
11	GREEDY_KERNEL = 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 ; index of new thread slot	85	slot rd 1 ; index of new thread slot
86	slot_base rd 1 ; base address of it	86	slot_base rd 1 ; base address of it
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 ; fill our app header data locals with values from header of given program (if its correct)	115	call test_app_header ; fill our app header data locals with values from header of given program (if its correct)
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 ; create a slot for new thread	121	call alloc_thread_slot ; create a slot for new thread
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, sizeof.APPDATA/4	131	mov ecx, sizeof.APPDATA/4
132	xor eax, eax	132	xor eax, eax
133	cld	133	cld
134	rep stosd	134	rep stosd
135	; write application name ( APPDATA.appname )	135	; write application name ( APPDATA.appname )
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	; if cmdline length >= 256 then increase needed memory size by this length	158	; if cmdline length >= 256 then increase needed memory size by this length
159	lea ebx, [eax+1]	159	lea ebx, [eax+1]
160	add [hdr_emem], ebx	160	add [hdr_emem], ebx
161	@@:	161	@@:
162	mov [cmdline_size], eax	162	mov [cmdline_size], eax
163	stdcall create_process, [hdr_emem] ; create a new process	163	stdcall create_process, [hdr_emem] ; create a new process
164	mov esi, -30 ; no memory	164	mov esi, -30 ; no memory
165	test eax, eax	165	test eax, eax
166	jz .err_hdr	166	jz .err_hdr
167		167
168	; add new process to the list	168	; add new process to the list
169	mov ebx, [sys_proc+LHEAD.prev]	169	mov ebx, [sys_proc+LHEAD.prev]
170	__list_add eax, ebx, sys_proc	170	__list_add eax, ebx, sys_proc
171	; fill the structure fields:	171	; fill the structure fields:
172	mov ebx, [hdr_emem]	172	mov ebx, [hdr_emem]
173	mov [eax+PROC.mem_used], ebx	173	mov [eax+PROC.mem_used], ebx
174		174
175	; write that main thread of app belongs to new process	175	; write that main thread of app belongs to new process
176	mov ebx, [slot_base]	176	mov ebx, [slot_base]
177	mov [ebx+APPDATA.process], eax	177	mov [ebx+APPDATA.process], eax
178		178
179	; initialize the thread list of process: at this moment it consists only of one main thread	179	; initialize the thread list of process: at this moment it consists only of one main thread
180	lea edx, [ebx+APPDATA.list]	180	lea edx, [ebx+APPDATA.list]
181	lea ecx, [eax+PROC.thr_list]	181	lea ecx, [eax+PROC.thr_list]
182	list_add_tail edx, ecx	182	list_add_tail edx, ecx
183		183
184	; allocate space and copy app header data locals and cmdline string there, put pointer to exec_params of new thread	184	; allocate space and copy app header data locals and cmdline string there, put pointer to exec_params of new thread
185	mov eax, [cmdline_size]	185	mov eax, [cmdline_size]
186	add eax, sizeof.APP_HDR	186	add eax, sizeof.APP_HDR
187	stdcall kernel_alloc, eax	187	stdcall kernel_alloc, eax
188	mov [ebx+APPDATA.exec_params], eax	188	mov [ebx+APPDATA.exec_params], eax
189	mov edi, eax	189	mov edi, eax
190	lea esi, [hdr_cmdline]	190	lea esi, [hdr_cmdline]
191	mov ecx, sizeof.APP_HDR/4	191	mov ecx, sizeof.APP_HDR/4
192	rep movsd	192	rep movsd
193	mov ecx, [cmdline_size]	193	mov ecx, [cmdline_size]
194	mov esi, [cmdline]	194	mov esi, [cmdline]
195	rep movsb	195	rep movsb
196	; set other parameters of application	196	; set other parameters of application
197	lea eax, [hdr_cmdline]	197	lea eax, [hdr_cmdline]
198	stdcall set_app_params , [slot], eax, [flags]	198	stdcall set_app_params , [slot], eax, [flags]
199	mov eax, [process_number] ; return process number	199	mov eax, [process_number] ; return process number
200	call unlock_application_table	200	call unlock_application_table
201	ret	201	ret
202		202
203	.err_0:	203	.err_0:
204	call unlock_application_table	204	call unlock_application_table
205	.err_hdr:	205	.err_hdr:
206	stdcall kernel_free, [file_base]	206	stdcall kernel_free, [file_base]
207	.err_file:	207	.err_file:
208	stdcall kernel_free, [path_string]	208	stdcall kernel_free, [path_string]
209	mov eax, esi	209	mov eax, esi
210	ret	210	ret
211	endp	211	endp
212		212
213	align 4	213	align 4
214	test_app_header:	214	test_app_header:
215	virtual at eax	215	virtual at eax
216	APP_HEADER_00 APP_HEADER_00_	216	APP_HEADER_00 APP_HEADER_00_
217	end virtual	217	end virtual
218	virtual at eax	218	virtual at eax
219	APP_HEADER_01 APP_HEADER_01_	219	APP_HEADER_01 APP_HEADER_01_
220	end virtual	220	end virtual
221		221
222	cmp dword [eax], 'MENU'	222	cmp dword [eax], 'MENU'
223	jne .fail	223	jne .fail
224	cmp word [eax+4], 'ET'	224	cmp word [eax+4], 'ET'
225	jne .fail	225	jne .fail
226		226
227	cmp [eax+6], word '00'	227	cmp [eax+6], word '00'
228	jne .check_01_header	228	jne .check_01_header
229		229
230	mov ecx, [APP_HEADER_00.start]	230	mov ecx, [APP_HEADER_00.start]
231	mov [ebx+APP_HDR.eip], ecx	231	mov [ebx+APP_HDR.eip], ecx
232	mov edx, [APP_HEADER_00.mem_size]	232	mov edx, [APP_HEADER_00.mem_size]
233	mov [ebx+APP_HDR._emem], edx	233	mov [ebx+APP_HDR._emem], edx
234	shr edx, 1	234	shr edx, 1
235	sub edx, 0x10	235	sub edx, 0x10
236	mov [ebx+APP_HDR.esp], edx	236	mov [ebx+APP_HDR.esp], edx
237	mov ecx, [APP_HEADER_00.i_param]	237	mov ecx, [APP_HEADER_00.i_param]
238	mov [ebx+APP_HDR.cmdline], ecx	238	mov [ebx+APP_HDR.cmdline], ecx
239	mov [ebx+APP_HDR.path], 0	239	mov [ebx+APP_HDR.path], 0
240	mov edx, [APP_HEADER_00.i_end]	240	mov edx, [APP_HEADER_00.i_end]
241	mov [ebx+APP_HDR._edata], edx	241	mov [ebx+APP_HDR._edata], edx
242	ret	242	ret
243		243
244	.check_01_header:	244	.check_01_header:
245		245
246	cmp [eax+6], word '01'	246	cmp [eax+6], word '01'
247	je @f	247	je @f
248	cmp [eax+6], word '02'	248	cmp [eax+6], word '02'
249	jne .fail	249	jne .fail
250	@@:	250	@@:
251	mov ecx, [APP_HEADER_01.start]	251	mov ecx, [APP_HEADER_01.start]
252	mov [ebx+0x08], ecx	252	mov [ebx+0x08], ecx
253	mov edx, [APP_HEADER_01.mem_size]	253	mov edx, [APP_HEADER_01.mem_size]
254		254
255	; \begin{diamond}[20.08.2006]	255	; \begin{diamond}[20.08.2006]
256	; sanity check (functions 19,58 load app_i_end bytes and that must	256	; sanity check (functions 19,58 load app_i_end bytes and that must
257	; fit in allocated memory to prevent kernel faults)	257	; fit in allocated memory to prevent kernel faults)
258	cmp edx, [APP_HEADER_01.i_end]	258	cmp edx, [APP_HEADER_01.i_end]
259	jb .fail	259	jb .fail
260	; \end{diamond}[20.08.2006]	260	; \end{diamond}[20.08.2006]
261		261
262	mov [ebx+APP_HDR._emem], edx	262	mov [ebx+APP_HDR._emem], edx
263	mov ecx, [APP_HEADER_01.stack_top]	263	mov ecx, [APP_HEADER_01.stack_top]
264	mov [ebx+APP_HDR.esp], ecx	264	mov [ebx+APP_HDR.esp], ecx
265	mov edx, [APP_HEADER_01.i_param]	265	mov edx, [APP_HEADER_01.i_param]
266	mov [ebx+APP_HDR.cmdline], edx	266	mov [ebx+APP_HDR.cmdline], edx
267	mov ecx, [APP_HEADER_01.i_icon]	267	mov ecx, [APP_HEADER_01.i_icon]
268	mov [ebx+APP_HDR.path], ecx	268	mov [ebx+APP_HDR.path], ecx
269	mov edx, [APP_HEADER_01.i_end]	269	mov edx, [APP_HEADER_01.i_end]
270	mov [ebx+APP_HDR._edata], edx	270	mov [ebx+APP_HDR._edata], edx
271	ret	271	ret
272	.fail:	272	.fail:
273	xor eax, eax	273	xor eax, eax
274	ret	274	ret
275		275
276	align 4	276	align 4
277	alloc_thread_slot:	277	alloc_thread_slot:
278	;input:	278	;input:
279	; none	279	; none
280	;result:	280	;result:
281	; eax=[new_thread_slot]<>0 - ok	281	; eax=[new_thread_slot]<>0 - ok
282	; 0 - failed.	282	; 0 - failed.
283	;This function find least empty slot.	283	;This function find least empty slot.
284	;It doesn't increase [thread_count]!	284	;It doesn't increase [thread_count]!
285		285
286		286
287	mov edx, thr_slot_map	287	mov edx, thr_slot_map
288	pushfd	288	pushfd
289	cli	289	cli
290	.l1:	290	.l1:
291	bsf eax, [edx]	291	bsf eax, [edx]
292	jnz .found	292	jnz .found
293	add edx, 4	293	add edx, 4
294	cmp edx, thr_slot_map+32	294	cmp edx, thr_slot_map+32
295	jb .l1	295	jb .l1
296		296
297	popfd	297	popfd
298	xor eax, eax	298	xor eax, eax
299	ret	299	ret
300	.found:	300	.found:
301	btr [edx], eax	301	btr [edx], eax
302	sub edx, thr_slot_map	302	sub edx, thr_slot_map
303	lea eax, [eax+edx*8]	303	lea eax, [eax+edx*8]
304	popfd	304	popfd
305	ret	305	ret
306		306
307	align 4	307	align 4
308	proc create_process stdcall, app_size:dword	308	proc create_process stdcall, app_size:dword
309	locals	309	locals
310	process dd ?	310	process dd ?
311	app_tabs dd ?	311	app_tabs dd ?
312	endl	312	endl
313		313
314	push ebx	314	push ebx
315	push esi	315	push esi
316	push edi	316	push edi
317		317
318	xor eax, eax	318	xor eax, eax
319	mov [process], eax	319	mov [process], eax
320		320
321	mov eax, [app_size]	321	mov eax, [app_size]
322	add eax, 0x3FFFFF	322	add eax, 0x3FFFFF
323	shr eax, 22	323	shr eax, 22
324	mov [app_tabs], eax	324	mov [app_tabs], eax
325		325
326	stdcall kernel_alloc, 0x2000	326	stdcall kernel_alloc, 0x2000
327	test eax, eax	327	test eax, eax
328	jz .fail	328	jz .fail
329	mov [process], eax	329	mov [process], eax
330		330
331	lea edi, [eax+PROC.heap_lock]	331	lea edi, [eax+PROC.heap_lock]
332	mov ecx, (PROC.ht_free-PROC.heap_lock)/4	332	mov ecx, (PROC.ht_free-PROC.heap_lock)/4
333		333
334	list_init eax	334	list_init eax
335	add eax, PROC.thr_list	335	add eax, PROC.thr_list
336	list_init eax	336	list_init eax
337		337
338	xor eax, eax	338	xor eax, eax
339	cld	339	cld
340	rep stosd	340	rep stosd
341		341
342	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3	342	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
343	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr	343	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr
344	mov ecx, (PROC.pdt_0 - PROC.htab)/4	344	mov ecx, (PROC.pdt_0 - PROC.htab)/4
345	add edi, 8	345	add edi, 8
346	inc eax	346	inc eax
347	@@:	347	@@:
348	stosd	348	stosd
349	inc eax	349	inc eax
350	cmp eax, ecx	350	cmp eax, ecx
351	jbe @B	351	jbe @B
352		352
353	mov eax, edi	353	mov eax, edi
354	call get_pg_addr	354	call get_pg_addr
355	mov [edi-4096+PROC.pdt_0_phys], eax	355	mov [edi-4096+PROC.pdt_0_phys], eax
356		356
357	mov ecx, (OS_BASE shr 20)/4	357	mov ecx, (OS_BASE shr 20)/4
358	xor eax, eax	358	xor eax, eax
359	rep stosd	359	rep stosd
360		360
361	mov ecx, (OS_BASE shr 20)/4	361	mov ecx, (OS_BASE shr 20)/4
362	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)	362	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
363	rep movsd	363	rep movsd
364		364
365	mov eax, [edi-8192+PROC.pdt_0_phys]	365	mov eax, [edi-8192+PROC.pdt_0_phys]
366	or eax, PG_SWR	366	or eax, PG_SWR
367	mov [edi-4096+(page_tabs shr 20)], eax	367	mov [edi-4096+(page_tabs shr 20)], eax
368		368
369	lea edx, [edi-4096]	369	lea edx, [edi-4096]
370	mov esi, [app_tabs]	370	mov esi, [app_tabs]
371		371
372	.alloc_page_dir:	372	.alloc_page_dir:
373	call alloc_page	373	call alloc_page
374	test eax, eax	374	test eax, eax
375	jz .fail	375	jz .fail
376	or eax, PG_UWR	376	or eax, PG_UWR
377	mov [edx], eax	377	mov [edx], eax
378		378
379	mov edi, [tmp_task_ptab]	379	mov edi, [tmp_task_ptab]
380	stdcall map_page, edi, eax, PG_SWR	380	stdcall map_page, edi, eax, PG_SWR
381	mov ecx, 1024	381	mov ecx, 1024
382	xor eax, eax	382	xor eax, eax
383	rep stosd	383	rep stosd
384		384
385	add edx, 4	385	add edx, 4
386	dec esi	386	dec esi
387	jnz .alloc_page_dir	387	jnz .alloc_page_dir
388		388
389	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	389	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
390	mov eax, [process]	390	mov eax, [process]
391		391
392	pop edi	392	pop edi
393	pop esi	393	pop esi
394	pop ebx	394	pop ebx
395	ret	395	ret
396	.fail:	396	.fail:
397	mov ecx, [process]	397	mov ecx, [process]
398	jcxz @F	398	jcxz @F
399		399
400	call destroy_process	400	call destroy_process
401	@@:	401	@@:
402	xor eax, eax	402	xor eax, eax
403	pop edi	403	pop edi
404	pop esi	404	pop esi
405	pop ebx	405	pop ebx
406	ret	406	ret
407	endp	407	endp
408		408
409	align 4	409	align 4
410	proc destroy_page_table stdcall, pg_tab:dword	410	proc destroy_page_table stdcall, pg_tab:dword
411		411
412	push esi	412	push esi
413		413
414	mov esi, [pg_tab]	414	mov esi, [pg_tab]
415	mov ecx, 1024	415	mov ecx, 1024
416	.free:	416	.free:
417	mov eax, [esi]	417	mov eax, [esi]
418	test eax, 1	418	test eax, 1
419	jz .next	419	jz .next
420	test eax, 2	420	test eax, 2
421	jz .next	421	jz .next
422	test eax, 1 shl 9	422	test eax, 1 shl 9
423	jnz .next ;skip shared pages	423	jnz .next ;skip shared pages
424	call free_page	424	call free_page
425	.next:	425	.next:
426	add esi, 4	426	add esi, 4
427	dec ecx	427	dec ecx
428	jnz .free	428	jnz .free
429	pop esi	429	pop esi
430	ret	430	ret
431	endp	431	endp
432		432
433	align 4	433	align 4
434	destroy_process: ;fastcall ecx= ptr to process	434	destroy_process: ;fastcall ecx= ptr to process
435		435
436	lea eax, [ecx+PROC.thr_list]	436	lea eax, [ecx+PROC.thr_list]
437	cmp eax, [eax+LHEAD.next]	437	cmp eax, [eax+LHEAD.next]
438	jne .exit	438	jne .exit
439		439
440	align 4	440	align 4
441	.internal:	441	.internal:
442	push ecx	442	push ecx
443		443
444	mov esi, ecx	444	mov esi, ecx
445	list_del esi	445	list_del esi
446		446
447	mov esi, [esi+PROC.dlls_list_ptr]	447	mov esi, [esi+PROC.dlls_list_ptr]
448	call destroy_all_hdlls	448	call destroy_all_hdlls
449		449
450	mov esi, [esp]	450	mov esi, [esp]
451	add esi, PROC.pdt_0	451	add esi, PROC.pdt_0
452	mov edi, (0x80000000 shr 20)/4	452	mov edi, (0x80000000 shr 20)/4
453	.destroy:	453	.destroy:
454	mov eax, [esi]	454	mov eax, [esi]
455	test eax, 1	455	test eax, 1
456	jz .next	456	jz .next
457	and eax, not 0xFFF	457	and eax, not 0xFFF
458	stdcall map_page, [tmp_task_ptab], eax, PG_SWR	458	stdcall map_page, [tmp_task_ptab], eax, PG_SWR
459	stdcall destroy_page_table, [tmp_task_ptab]	459	stdcall destroy_page_table, [tmp_task_ptab]
460	mov eax, [esi]	460	mov eax, [esi]
461	call free_page	461	call free_page
462	.next:	462	.next:
463	add esi, 4	463	add esi, 4
464	dec edi	464	dec edi
465	jnz .destroy	465	jnz .destroy
466		466
467	call kernel_free ;ecx still in stack	467	call kernel_free ;ecx still in stack
468	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	468	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
469	.exit:	469	.exit:
470	ret	470	ret
471		471
472	align 4	472	align 4
473	get_pid:	473	get_pid:
474	mov eax, [TASK_BASE]	474	mov eax, [TASK_BASE]
475	mov eax, [eax+TASKDATA.pid]	475	mov eax, [eax+TASKDATA.pid]
476	ret	476	ret
477		477
478	pid_to_slot:	478	pid_to_slot:
479	;Input:	479	;Input:
480	; eax - pid of process	480	; eax - pid of process
481	;Output:	481	;Output:
482	; eax - slot of process or 0 if process don't exists	482	; eax - slot of process or 0 if process don't exists
483	;Search process by PID.	483	;Search process by PID.
484	push ebx	484	push ebx
485	push ecx	485	push ecx
486	mov ebx, [thread_count]	486	mov ebx, [thread_count]
487	shl ebx, BSF sizeof.TASKDATA ; multiply by size	487	shl ebx, BSF sizeof.TASKDATA ; multiply by size
488	; add 2*32 cause:	488	; add 2*32 cause:
489	; [TASK_TABLE; TASK_TABLE + 32) isnt a task actually	489	; [TASK_TABLE; TASK_TABLE + 32) isnt a task actually
490	; skip first process in the task table	490	; skip first process in the task table
491	mov ecx, 2*32	491	mov ecx, 2*32
492		492
493	.loop:	493	.loop:
494	;ecx = offset of current process info entry	494	;ecx = offset of current process info entry
495	;ebx = maximum permitted offset	495	;ebx = maximum permitted offset
496	; state 9 means "not used"	-
497	cmp byte [TASK_TABLE+ecx+TASKDATA.state], TSTATE_FREE	496	cmp [TASK_TABLE+ecx+TASKDATA.state], TSTATE_FREE
498	jz .endloop ;skip empty slots	497	jz .endloop ;skip empty slots
499	cmp [TASK_TABLE+ecx+TASKDATA.pid], eax;check PID	498	cmp [TASK_TABLE+ecx+TASKDATA.pid], eax;check PID
500	jz .pid_found	499	jz .pid_found

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 8869 → 8874