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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc @ 753 – Rev 10002 → 10008