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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 10002 $
 
 
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
; @brief Executes a program
; @param edx Flags
; @param ecx Commandline
; @param ebx Absolute file path
; @param eax String length
; @returns Negated error code or new process number
proc fs_execute
    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
 
        and     edx, 1  ;clear flags user. TODO: add api for start apps with user flags
        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, -TASKMAN_ERROR_NOT_A_EXECUTABLE
        test    eax, eax
        jz      .err_hdr
 
        call    lock_application_table
        call    alloc_thread_slot   ; create a slot for new thread
        mov     esi, -TASKMAN_ERROR_TOO_MANY_PROCESSES
        test    eax, eax
        jz      .err_0
 
        mov     [slot], eax
        shl     eax, BSF sizeof.APPDATA
        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, -TASKMAN_ERROR_OUT_OF_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
 
        cmp     edx, [APP_HEADER_00.i_end]
        jb      .fail
 
        cmp     edx, OS_BASE ;check memory
        jae     .fail
        mov     ecx, [pg_data.pages_free]
        shl     ecx, 12 ; ecx * 4kb
        cmp     edx, ecx
        jae     .fail
 
        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]
        cmp     edx, OS_BASE ;check memory
        jae     .fail
        mov     ecx, [pg_data.pages_free]
        shl     ecx, 12 ; ecx * 4kb
        cmp     edx, ecx
        jae     .fail
 
        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 - PAGE_SIZE + 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 - PAGE_SIZE + (page_tabs shr 20)], eax
 
        lea     edx, [edi - PAGE_SIZE]
        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, PAGE_SIZE/4
        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, -PAGE_SIZE
        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, [current_slot]
        mov     eax, [eax + APPDATA.tid]
        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.APPDATA ; multiply by size
        ; skip first process in the task table
        mov     ecx, sizeof.APPDATA
 
.loop:
;ecx = offset of current process info entry
;ebx = maximum permitted offset
        cmp     [SLOT_BASE + ecx + APPDATA.state], TSTATE_FREE
        jz      .endloop ;skip empty slots
        cmp     [SLOT_BASE + ecx + APPDATA.tid], eax
        jz      .pid_found
.endloop:
        add     ecx, sizeof.APPDATA
        cmp     ecx, ebx
        jle     .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
 
.pid_found:
        shr     ecx, BSF sizeof.APPDATA ; 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 information about current thread
 
        mov     edi, eax
        shl     edi, BSF sizeof.APPDATA
        add     edi, SLOT_BASE
        mov     edx, edi      ;edx=edi - pointer to infomation about new thread
        mov     ecx, sizeof.APPDATA/4
        xor     eax, eax
        cld
        rep stosd             ;clean 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, PAGE_SIZE
        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, PAGE_SIZE-1
        add     ecx, PAGE_SIZE-1
        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, -PAGE_SIZE
        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, PAGE_SIZE-1
        and     edi, -PAGE_SIZE
        add     ecx, PAGE_SIZE-1
        and     ecx, -PAGE_SIZE
        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]
        jnz     @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, PAGE_SIZE-1
        and     edi, -PAGE_SIZE
        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
        jnz     .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, PAGE_SIZE
        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     [ebx + APPDATA.state], TSTATE_RUN_SUSPENDED
        mov     [ebx + APPDATA.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, BSF sizeof.APPDATA
        mov     [SLOT_BASE + eax + APPDATA.fpu_state], edi
        mov     [SLOT_BASE + eax + APPDATA.exc_handler], 0
        mov     [SLOT_BASE + eax + APPDATA.except_mask], 0
        mov     [SLOT_BASE + eax + APPDATA.terminate_protection], 80000001h
 
;set default io permission map
        mov     ecx, [SLOT_BASE + sizeof.APPDATA + APPDATA.io_map]
        mov     [SLOT_BASE + eax + APPDATA.io_map], ecx
        mov     ecx, [SLOT_BASE + sizeof.APPDATA + APPDATA.io_map + 4]
        mov     [SLOT_BASE + eax + 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, BSF sizeof.APPDATA
        lea     edx, [SLOT_BASE + ebx + APP_EV_OFFSET]
        mov     [SLOT_BASE + ebx + APPDATA.fd_ev], edx
        mov     [SLOT_BASE + ebx + APPDATA.bk_ev], edx
 
        add     edx, APP_OBJ_OFFSET - APP_EV_OFFSET
        mov     [SLOT_BASE + ebx + APPDATA.fd_obj], edx
        mov     [SLOT_BASE + ebx + APPDATA.bk_obj], edx
 
        mov     eax, [pl0_stack]
        mov     [SLOT_BASE + ebx + APPDATA.pl0_stack], eax
        add     eax, RING0_STACK_SIZE
        mov     [SLOT_BASE + ebx + APPDATA.saved_esp0], eax
 
        push    ebx
        stdcall kernel_alloc, maxPathLength             ;TODO
        pop     ebx
        mov     esi, [current_slot]
        mov     esi, [esi + APPDATA.cur_dir]
        mov     ecx, maxPathLength/4
        mov     edi, eax
        mov     [SLOT_BASE + ebx + APPDATA.cur_dir], eax
        rep movsd
 
        mov     [SLOT_BASE + ebx + APPDATA.event_mask], dword 1+2+4;set default event flags (see 40 function)
        inc     dword [process_number]
        mov     eax, [process_number]
        mov     [SLOT_BASE + ebx + APPDATA.tid], eax    ;set TID
 
        mov     eax, [slot]
        mov     [SLOT_BASE + ebx + APPDATA.wnd_number], al
        ;mov     ebx, eax
        shl     eax, BSF sizeof.WDATA
        add     eax, window_data
        mov     ecx, eax
        mov     [SLOT_BASE + ebx + APPDATA.window], eax
        mov     [eax + WDATA.thread], ebx
        add     [eax + WDATA.thread], SLOT_BASE
 
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
        mov     [eax + WDATA.fl_wstate], WSTATE_NORMAL + WSTATE_USED
        mov     [eax + WDATA.fl_redraw], WSTATE_REDRAW
 
        mov     edx, [def_cursor]
        mov     [eax + WDATA.cursor], edx
 
;set draw data to full screen
        xor     eax, eax
        mov     [SLOT_BASE + ebx + APPDATA.def_priority], al
        mov     [ecx + WDATA.draw_data.left], eax
        mov     [ecx + WDATA.draw_data.top], eax
        mov     eax, [screen_workarea.right]
        mov     [ecx + WDATA.draw_data.right], eax
        mov     eax, [screen_workarea.bottom]
        mov     [ecx + WDATA.draw_data.bottom], 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, BSF sizeof.APPDATA
        mov     [SLOT_BASE + ebx + 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 + APPDATA.debugger_slot], eax
.no_debug:
        mov     [SLOT_BASE + ebx + APPDATA.state], dl
        lea     edx, [SLOT_BASE + ebx]
        call    scheduler_add_thread
        ret
endp
 
align 4
get_stack_base:
        mov     eax, [current_slot]
        mov     eax, [eax + APPDATA.pl0_stack]
        ret
 
align 4
get_curr_slot:
        mov     eax, [current_slot]
        ret
 
pid_to_appdata:
;Input:
;  eax - pid of process
;Output:
;  eax - 0 - not found or pointer on APPDATA
        push    ebx
        push    ecx
        mov     ebx, [thread_count]
        shl     ebx, BSF sizeof.APPDATA ; multiply by size
        ; skip first process in the task table
        mov     ecx, SLOT_BASE
        add     ebx, ecx
.loop:
        add     ecx, sizeof.APPDATA
        cmp     [ecx + APPDATA.state], TSTATE_FREE
        jz      @f  ;skip empty slots
        cmp     [ecx + APPDATA.tid], eax
        jz      .pid_found
@@:
        cmp     ecx, ebx
        jb      .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
.pid_found:
        mov     eax, ecx
        pop     ecx
        pop     ebx
        ret
 
include "debug.inc"

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 9974 → 10002