WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri-process/core/taskman.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 4424 $
 
 
GREEDY_KERNEL  equ 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_PARAMS
        app_cmdline     dd ?    ;0x00
        app_path        dd ?    ;0x04
        app_eip         dd ?    ;0x08
        app_esp         dd ?    ;0x0C
        app_mem         dd ?    ;0x10
ends
 
macro _clear_ op
{  mov ecx, op/4
        xor     eax, eax
        cld
        rep stosd
}
 
fs_execute_from_sysdir:
        xor     ebx, ebx
fs_execute_from_sysdir_param:
        xor     edx, edx
        mov     esi, sysdir_path
 
align 4
proc fs_execute
 
;fn_read:dword, file_size:dword, cluster:dword
 
; ebx - cmdline
; edx - flags
; ebp - full filename
; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
 
       locals
         cmdline_size  dd ? ; +0 ; cmdline -12
         cmdline_adr   dd ? ; +4 ; cmdline -8
         cmdline_flag  dd ? ; +8 ; cmdline -4
         cmdline       rd 64    ;256/4
         filename      rd 256   ;1024/4
         flags         dd ?
 
         save_proc     dd ?
         slot          dd ?
         slot_base     dd ?
         file_base     dd ?
         file_size     dd ?
         handle        dd ? ;temp. for default cursor handle for curr. thread
                      ;app header data
         hdr_cmdline   dd ? ;0x00
         hdr_path      dd ? ;0x04
         hdr_eip       dd ? ;0x08
         hdr_esp       dd ? ;0x0C
         hdr_mem       dd ? ;0x10
         hdr_i_end     dd ? ;0x14
       endl
 
        pushad
 
        cmp     [SCR_MODE], word 0x13
        jbe     @f
        pushad
        stdcall set_cursor, [def_cursor_clock]
        mov     [handle], eax
        mov     [redrawmouse_unconditional], 1
        call    wakeup_osloop
        popad
@@:
        mov     [flags], edx
 
; [ebp]  pointer to filename
 
        lea     edi, [filename]
        lea     ecx, [edi+1024]
        mov     al, '/'
        stosb
@@:
        cmp     edi, ecx
        jae     .bigfilename
        lodsb
        stosb
        test    al, al
        jnz     @b
        mov     esi, [ebp]
        test    esi, esi
        jz      .namecopied
        mov     byte [edi-1], '/'
@@:
        cmp     edi, ecx
        jae     .bigfilename
        lodsb
        stosb
        test    al, al
        jnz     @b
        jmp     .namecopied
.bigfilename:
        popad
        mov     eax, -ERROR_FILE_NOT_FOUND
 
        jmp     .final
 
.namecopied:
        xor     eax, eax
        mov     [cmdline_flag], eax
        mov     [cmdline_adr], eax
        mov     [cmdline_size], eax
 
        mov     [cmdline], ebx
        test    ebx, ebx
        jz      .no_copy
;--------------------------------------
        pushad
        pushfd
        mov     esi, ebx
        mov     ecx, 65536 ; 64 Kb max for ext.cmdline
        cld
@@:
        dec     ecx
        jz      .end_string
 
        lodsb
        test    al, al
        jnz     @b
 
.end_string:
        mov     eax, 65536 ; 64 Kb max for ext.cmdline
        sub     eax, ecx
        mov     [cmdline_size], eax
        cmp     eax, 255
        ja      @f
 
        popfd
        popad
        jmp     .old_copy
 
@@:
        xor     eax, eax
        dec     eax
        mov     [cmdline_flag], eax
        popfd
        popad
; get memory for the extended command line
        stdcall kernel_alloc, [cmdline_size] ;eax
        test    eax, eax
        jz      .old_copy ; get memory failed
 
        mov     [cmdline_adr], eax
 
        pushad
        pushfd
        mov     esi, ebx
        mov     edi, eax
        mov     ecx, [cmdline_size]
        cld
        rep movsb
        popfd
        popad
        jmp     .no_copy
 
.old_copy:
; clear flag because old method with 256 bytes
        xor     eax, eax
        mov     [cmdline_flag], eax
;--------------------------------------
        lea     eax, [cmdline]
        mov     dword [eax+252], 0
.copy:
        stdcall strncpy, eax, ebx, 255
.no_copy:
        lea     eax, [filename]
        stdcall load_file, eax
 
        mov     esi, -ERROR_FILE_NOT_FOUND
        test    eax, eax
        jz      .err_file
 
        mov     [file_base], eax
        mov     [file_size], ebx
 
        lea     ebx, [hdr_cmdline]
        call    test_app_header
        mov     esi, -0x1F
        test    eax, eax
        jz      .err_hdr
 
        call    lock_application_table
 
        call    alloc_thread_slot
        test    eax, eax
        mov     esi, -0x20 ; too many processes
        jz      .err
 
        mov     [slot], eax
        shl     eax, 8
        add     eax, SLOT_BASE
        mov     [slot_base], eax
        mov     edi, eax
       _clear_ 256     ;clean extended information about process
 
; write application name
        lea     eax, [filename]
        stdcall strrchr, eax, '/'  ; now eax points to name without path
 
        lea     esi, [eax+1]
        test    eax, eax
        jnz     @F
        lea     esi, [filename]
@@:
        mov     ecx, 11 ; 11 chars for name! 8 - is old value!
        mov     edi, [slot_base]
.copy_process_name_loop:
        lodsb
        cmp     al, '.'
        jz      .copy_process_name_done
        test    al, al
        jz      .copy_process_name_done
        stosb
        loop    .copy_process_name_loop
.copy_process_name_done:
 
        mov     ebx, [current_slot]
        mov     ebx, [ebx+APPDATA.process]
        mov     [save_proc], ebx
 
        stdcall create_process, [hdr_mem], [file_base], [file_size]
        mov     esi, -30; no memory
        test    eax, eax
        jz      .failed
 
        mov     ebx, [hdr_mem]
        mov     [eax+PROC.mem_used], ebx
 
        mov     ebx, [slot_base]
 
 
        mov     [ebx+APPDATA.process], eax
 
        xor     edx, edx
        cmp     word [6], '02'
        jne     @f
 
        not     edx
@@:
        mov     [ebx+APPDATA.tls_base], edx
 
if GREEDY_KERNEL
else
        mov     ecx, [hdr_mem]
        mov     edi, [file_size]
        add     edi, 4095
        and     edi, not 4095
        sub     ecx, edi
        jna     @F
 
        xor     eax, eax
        cld
        rep stosb
@@:
end if
 
; release only virtual space, not phisical memory
 
        stdcall free_kernel_space, [file_base]
        lea     eax, [hdr_cmdline]
        lea     ebx, [cmdline]
        lea     ecx, [filename]
        stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
 
        mov     eax, [save_proc]
        call    set_cr3
 
        mov     eax, [process_number];set result
        call    unlock_application_table
 
        jmp     .final
 
.failed:
        mov     eax, [save_proc]
        call    set_cr3
.err:
.err_hdr:
        stdcall kernel_free, [file_base]
.err_file:
        call    unlock_application_table
        mov     eax, esi
.final:
        cmp     [SCR_MODE], word 0x13
        jbe     @f
        pushad
        stdcall set_cursor, [handle]
        mov     [redrawmouse_unconditional], 1
        call    wakeup_osloop
        popad
@@:
        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+0x08], ecx             ;app_eip
        mov     edx, [APP_HEADER_00.mem_size]
        mov     [ebx+0x10], edx             ;app_mem
        shr     edx, 1
        sub     edx, 0x10
        mov     [ebx+0x0C], edx             ;app_esp
        mov     ecx, [APP_HEADER_00.i_param]
        mov     [ebx], ecx                  ;app_cmdline
        mov     [ebx+4], dword 0            ;app_path
        mov     edx, [APP_HEADER_00.i_end]
        mov     [ebx+0x14], 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             ;app_eip
        mov     edx, [APP_HEADER_01.mem_size]
 
; \begin{diamond}[20.08.2006]
; sanity check (functions 19,58 load app_i_end bytes and that must
; fit in allocated memory to prevent kernel faults)
        cmp     edx, [APP_HEADER_01.i_end]
        jb      .fail
; \end{diamond}[20.08.2006]
 
        mov     [ebx+0x10], edx             ;app_mem
        mov     ecx, [APP_HEADER_01.stack_top]
        mov     [ebx+0x0C], ecx             ;app_esp
        mov     edx, [APP_HEADER_01.i_param]
        mov     [ebx], edx                  ;app_cmdline
        mov     ecx, [APP_HEADER_01.i_icon]
        mov     [ebx+4], ecx                ;app_path
        mov     edx, [APP_HEADER_01.i_end]
        mov     [ebx+0x14], edx
        ret
.fail:
        xor     eax, eax
        ret
 
 
align 4
alloc_thread_slot:
;input:
;  none
;result:
;  eax=[new_thread_slot]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
 
 
        mov     edx, thr_slot_map
        pushfd
        cli
.l1:
        bsf     eax, [edx]
        jnz     .found
        add     edx, 4
        cmp     edx, thr_slot_map+32
        jb      .l1
 
        popfd
        xor     eax, eax
        ret
.found:
        btr     [edx], eax
        sub     edx, thr_slot_map
        lea     eax, [eax+edx*8]
        popfd
        ret
 
 
align 4
proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
       locals
         app_pages   dd ?
         img_pages   dd ?
         process     dd ?
         app_tabs    dd ?
       endl
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        xchg bx, bx
 
        xor     eax, eax
        mov     [process], eax
 
        mov     eax, [app_size]
        add     eax, 4095
        and     eax, NOT(4095)
        mov     [app_size], eax
        mov     ebx, eax
        shr     eax, 12
        mov     [app_pages], eax
 
        add     ebx, 0x3FFFFF
        and     ebx, NOT(0x3FFFFF)
        shr     ebx, 22
        mov     [app_tabs], ebx
 
        mov     ecx, [img_size]
        add     ecx, 4095
        and     ecx, NOT(4095)
 
        mov     [img_size], ecx
        shr     ecx, 12
        mov     [img_pages], ecx
 
        lea     eax, [eax+ebx+2];all requested memory
 
        cmp     eax, [pg_data.pages_free]
        ja      .fail
 
        stdcall    kernel_alloc, 0x2000
        test    eax, eax
        jz      .fail
        mov     [process], eax
 
        lea     edi, [eax+PROC.heap_lock]
        mov     ecx, (4096-PROC.heap_lock)/4
 
        list_init eax
        add     eax, PROC.thr_list
        list_init eax
 
        xor     eax, eax
        cld
        rep stosd
 
        mov     eax, edi
        call    get_pg_addr
        mov     [edi-4096+PROC.pdt_0_phys], eax
 
        mov     ecx, (OS_BASE shr 20)/4
        xor     eax, eax
        rep stosd
 
        mov     ecx, (OS_BASE shr 20)/4
        mov     esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
        rep movsd
 
        mov     eax, [edi-8192+PROC.pdt_0_phys]
        or      eax, PG_SW
        mov     [edi-4096+(page_tabs shr 20)], eax
 
        lea     eax, [edi-8192]
        call    set_cr3
 
        mov     edx, [app_tabs]
        xor     edi, edi
@@:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page_table, edi, eax
        add     edi, 0x00400000
        dec     edx
        jnz     @B
 
        mov     edi, page_tabs
 
        mov     ecx, [app_tabs]
        shl     ecx, 10
        xor     eax, eax
        rep stosd
 
        mov     ecx, [img_pages]
        mov     ebx, PG_UW
        xor     edx, edx
        mov     esi, [img_base]
        shr     esi, 10
        add     esi, page_tabs
        mov     edi, page_tabs
.remap:
        lodsd
        and     eax, 0xFFFFF000
        or      eax, ebx; force user level r/w access
        stosd
        add     edx, 0x1000
        dec     [app_pages]
        dec     ecx
        jnz     .remap
 
        mov     ecx, [app_pages]
        test    ecx, ecx
        jz      .done
 
.alloc:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page, edx, eax, dword PG_UW
        add     edx, 0x1000
        dec     [app_pages]
        jnz     .alloc
 
.done:
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        mov     eax, [process]
        ret
.fail:
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        cmp     [process], 0
        je      @f
;;        stdcall destroy_app_space, [dir_addr], 0
@@:
        xor     eax, eax
        ret
endp
 
align 4
set_cr3:
 
        mov     ebx, [current_slot]
        mov     [ebx+APPDATA.process], eax
        mov     eax, [eax+PROC.pdt_0_phys]
        mov     cr3, eax
        ret
 
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, 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
proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword
 
        xor     edx, edx
        push    edx
        mov     eax, 0x1
        mov     ebx, [pg_dir]
.loop:
;eax = current slot of process
        mov     ecx, eax
        shl     ecx, 5
        cmp     byte [CURRENT_TASK+ecx+0xa], 9;if process running?
        jz      @f           ;skip empty slots
        shl     ecx, 3
        add     ecx, SLOT_BASE
        cmp     [ecx+APPDATA.process], ebx;compare page directory addresses
        jnz     @f
        mov     [ebp-4], ecx
        inc     edx             ;thread found
@@:
        inc     eax
        cmp     eax, [TASK_COUNT]   ;exit loop if we look through all processes
        jle     .loop
 
;edx = number of threads
;our process is zombi so it isn't counted
        pop     ecx
        cmp     edx, 1
        jg      .ret
;if there isn't threads then clear memory.
        mov     esi, [dlls_list]
        call    destroy_all_hdlls;ecx=APPDATA
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        mov     eax, [pg_dir]
        and     eax, not 0xFFF
;        stdcall map_page, [tmp_task_pdir], eax, PG_SW
;        mov     esi, [tmp_task_pdir]
        mov     edi, (OS_BASE shr 20)/4
.destroy:
        mov     eax, [esi]
        test    eax, 1
        jz      .next
        and     eax, not 0xFFF
        stdcall map_page, [tmp_task_ptab], eax, PG_SW
        stdcall destroy_page_table, [tmp_task_ptab]
        mov     eax, [esi]
        call    free_page
.next:
        add     esi, 4
        dec     edi
        jnz     .destroy
 
        mov     eax, [pg_dir]
        call    free_page
.exit:
        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
;        stdcall map_page, [tmp_task_pdir], 0, PG_UNMAP
        mov     ecx, pg_data.mutex
        call    mutex_unlock
.ret:
        ret
endp
 
align 4
get_pid:
        mov     eax, [TASK_BASE]
        mov     eax, [eax+TASKDATA.pid]
        ret
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
        push    ebx
        push    ecx
        mov     ebx, [TASK_COUNT]
        shl     ebx, 5
        mov     ecx, 2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
        cmp     byte [CURRENT_TASK+ecx+0xa], 9
        jz      .endloop ;skip empty slots
        cmp     [CURRENT_TASK+ecx+0x4], eax;check PID
        jz      .pid_found
.endloop:
        add     ecx, 32
        cmp     ecx, ebx
        jle     .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
 
.pid_found:
        shr     ecx, 5
        mov     eax, ecx ;convert offset to index of slot
        pop     ecx
        pop     ebx
        ret
 
check_region:
;input:
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
        mov     eax, [CURRENT_TASK]
;     jmp  check_process_region
;-----------------------------------------------------------------------------
;check_process_region:
;input:
;  eax - slot
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
        test    edx, edx
        jle     .ok
        shl     eax, 5
        cmp     word [CURRENT_TASK+eax+0xa], 0
        jnz     .failed
        shl     eax, 3
        mov     eax, [SLOT_BASE+eax+0xb8]
        test    eax, eax
        jz      .failed
 
        mov     eax, 1
        ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
        mov     eax, 1
        ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
        xor     eax, eax
        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_MAP
        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]
      ;     add ebx, new_app_base
        push    ecx
        stdcall map_memEx, [proc_mem_map], \
                [slot], ebx, ecx, PG_SW
        pop     ecx
 
        mov     edi, [offset]
        and     edi, 0xfff
        sub     eax, edi
        jbe     .ret
        cmp     ecx, eax
        jbe     @f
        mov     ecx, eax
        mov     [tmp_w_cnt], eax
@@:
        add     edi, [proc_mem_map]
        mov     esi, [buff]
        mov     edx, ecx
        rep movsb
 
        add     [w_count], edx
        add     [offset], edx
        sub     [tmp_w_cnt], edx
        jnz     .read_mem
.ret:
        popad
        mov     eax, [w_count]
        ret
endp
 
;ebx = 1 - kernel thread
;ecx=thread entry point
;edx=thread stack pointer
;creation flags  0x01 - debugged
;                0x02 - kernel
 
align 4
proc new_sys_threads
       locals
         slot          dd ?
         flags         dd ?
         app_cmdline   dd ? ;0x00
         app_path      dd ? ;0x04
         app_eip       dd ? ;0x08
         app_esp       dd ? ;0x0C
         app_mem       dd ? ;0x10
       endl
 
        shl     ebx, 1
        mov     [flags], ebx
 
        xor     eax, eax
        mov     [app_eip], ecx
        mov     [app_cmdline], eax
        mov     [app_esp], edx
        mov     [app_path], eax
 
        call    lock_application_table
 
        call    alloc_thread_slot
        test    eax, eax
        jz      .failed
 
        mov     [slot], eax
 
        mov     esi, [current_slot]
        mov     ebx, esi      ;ebx=esi - pointer to extended information about current thread
 
        mov     edi, eax
        shl     edi, 8
        add     edi, SLOT_BASE
        mov     edx, edi      ;edx=edi - pointer to extended infomation about new thread
        mov     ecx, 256/4
        xor     eax, eax
        cld
        rep stosd             ;clean extended information about new thread
        mov     esi, ebx
        mov     edi, edx
        mov     ecx, 11
        rep movsb             ;copy process name
 
        mov     eax, [ebx+APPDATA.process]
 
 
 
 
 
 
 
 
 
        mov     [edx+APPDATA.process], eax
 
        mov     eax, [ebx+APPDATA.dlls_list_ptr]
        mov     [edx+APPDATA.dlls_list_ptr], eax
 
        mov     eax, [ebx+APPDATA.tls_base]
        test    eax, eax
        jz      @F
 
        push    edx
        stdcall user_alloc, 4096
        pop     edx
        test    eax, eax
        jz      .failed1;eax=0
@@:
        mov     [edx+APPDATA.tls_base], eax
 
        lea     eax, [app_cmdline]
        stdcall set_app_params , [slot], eax, dword 0, \
                dword 0, [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
 
align 4
tls_app_entry:
 
        call    init_heap
        stdcall user_alloc, 4096
 
        mov     edx, [current_slot]
        mov     [edx+APPDATA.tls_base], eax
        mov     [tls_data_l+2], ax
        shr     eax, 16
        mov     [tls_data_l+4], al
        mov     [tls_data_l+7], ah
        mov     dx, app_tls
        mov     fs, dx
        popad
        iretd
 
 
EFL_IF      equ 0x0200
EFL_IOPL1   equ 0x1000
EFL_IOPL2   equ 0x2000
EFL_IOPL3   equ 0x3000
 
 
align 4
proc set_app_params stdcall,slot:dword, params:dword,\
            cmd_line:dword, app_path:dword, flags:dword
 
       locals
         pl0_stack dd ?
       endl
 
        stdcall kernel_alloc, RING0_STACK_SIZE+512
        mov     [pl0_stack], eax
 
        lea     edi, [eax+RING0_STACK_SIZE]
 
        mov     eax, [slot]
        mov     ebx, eax
 
        shl     eax, 8
        mov     [eax+SLOT_BASE+APPDATA.fpu_state], edi
        mov     [eax+SLOT_BASE+APPDATA.exc_handler], 0
        mov     [eax+SLOT_BASE+APPDATA.except_mask], 0
        mov     [eax+SLOT_BASE+APPDATA.terminate_protection], 80000001h
 
;set default io permission map
        mov     ecx, [SLOT_BASE+256+APPDATA.io_map]
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
        mov     ecx, [SLOT_BASE+256+APPDATA.io_map+4]
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
 
        mov     esi, fpu_data
        mov     ecx, 512/4
        rep movsd
 
        cmp     ebx, [TASK_COUNT]
        jle     .noinc
        inc     dword [TASK_COUNT]     ;update number of processes
.noinc:
        shl     ebx, 8
        lea     edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
        mov     [SLOT_BASE+APPDATA.fd_ev+ebx], edx
        mov     [SLOT_BASE+APPDATA.bk_ev+ebx], edx
 
        add     edx, APP_OBJ_OFFSET-APP_EV_OFFSET
        mov     [SLOT_BASE+APPDATA.fd_obj+ebx], edx
        mov     [SLOT_BASE+APPDATA.bk_obj+ebx], edx
 
        mov     ecx, [def_cursor]
        mov     [SLOT_BASE+APPDATA.cursor+ebx], ecx
        mov     eax, [pl0_stack]
        mov     [SLOT_BASE+APPDATA.pl0_stack+ebx], eax
        add     eax, RING0_STACK_SIZE
        mov     [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
 
        push    ebx
        stdcall kernel_alloc, 0x1000
        pop     ebx
        mov     esi, [current_slot]
        mov     esi, [esi+APPDATA.cur_dir]
        mov     ecx, 0x1000/4
        mov     edi, eax
        mov     [ebx+SLOT_BASE+APPDATA.cur_dir], eax
        rep movsd
 
        shr     ebx, 3
        mov     eax, new_app_base
        mov     dword [CURRENT_TASK+ebx+0x10], eax
 
.add_command_line:
        mov     edx, [params]
        mov     edx, [edx] ;app_cmdline
        test    edx, edx
        jz      @f     ;application doesn't need parameters
 
        mov     eax, edx
        add     eax, 256
        jc      @f
 
;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
;        ja      @f
 
        mov     eax, [cmd_line]
 
        cmp     [edx], dword 0xffffffff ; extended destination tag
        jne     .no_ext_dest
 
        mov     edx, [edx+4] ; extended destination for cmdline
        jmp     .continue
 
.no_ext_dest:
        mov     [eax-12], dword 255
.continue:
        mov     byte [edx], 0  ;force empty string if no cmdline given
 
        test    eax, eax
        jz      @f
;--------------------------------------
        cmp     [eax-4], dword 0xffffffff ; cmdline_flag
        jne     .old_copy
 
        push    eax
        stdcall strncpy, edx, [eax-8], [eax-12]
        pop     eax
 
        stdcall kernel_free, [eax-8]
        jmp     @f
 
.old_copy:
;--------------------------------------
        stdcall strncpy, edx, eax, 256
@@:
        mov     edx, [params]
        mov     edx, [edx+4];app_path
        test    edx, edx
        jz      @F     ;application don't need path of file
        mov     eax, edx
        add     eax, 1024
        jc      @f
;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
;        ja      @f
        stdcall strncpy, edx, [app_path], 1024
@@:
        mov     ebx, [slot]
        mov     eax, ebx
        shl     ebx, 5
        lea     ecx, [draw_data+ebx];ecx - pointer to draw data
 
        mov     edx, irq0.return
        cmp     [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
        jne     @F
        mov     edx, tls_app_entry
@@:
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
        mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
        mov     [ebx+window_data+WDATA.fl_redraw], 1
        add     ebx, CURRENT_TASK     ;ebx - pointer to information about process
        mov     [ebx+TASKDATA.wnd_number], al;set window number on screen = process slot
 
        mov     [ebx+TASKDATA.event_mask], dword 1+2+4;set default event flags (see 40 function)
 
        inc     dword [process_number]
        mov     eax, [process_number]
        mov     [ebx+4], eax    ;set PID
 
;set draw data to full screen
        xor     eax, eax
        mov     [ecx+0], dword eax
        mov     [ecx+4], dword eax
        mov     eax, [Screen_Max_X]
        mov     [ecx+8], eax
        mov     eax, [Screen_Max_Y]
        mov     [ecx+12], eax
 
        mov     ebx, [pl0_stack]
        mov     esi, [params]
        lea     ecx, [ebx+REG_EIP]
        xor     eax, eax
 
        mov     [ebx+REG_RET], edx
        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+0x08]             ;app_eip
        mov     [ebx+REG_EIP], eax          ;app_entry
        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+0x0C]  ;app_esp
        mov     [ebx+REG_APP_ESP], eax;app_stack
        mov     [ebx+REG_SS], dword app_data
 
        lea     edx, [ebx+REG_RET]
        mov     ebx, [slot]
        shl     ebx, 5
        mov     [ebx*8+SLOT_BASE+APPDATA.saved_esp], edx
 
        xor     edx, edx; process state - running
; set if debuggee
        test    byte [flags], 1
        jz      .no_debug
        inc     edx ; process state - suspended
        mov     eax, [CURRENT_TASK]
        mov     [SLOT_BASE+ebx*8+APPDATA.debugger_slot], eax
.no_debug:
        mov     [CURRENT_TASK+ebx+TASKDATA.state], dl
        lea     edx, [SLOT_BASE+ebx*8]
        call    scheduler_add_thread
        ret
endp
 
 
align 4
 
get_stack_base:
        mov     eax, [current_slot]
        mov     eax, [eax+APPDATA.pl0_stack]
        ret
 
 
include "debug.inc"

Rev 4429	Rev 4430
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. 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: 4424 $	8	$Revision: 4424 $
9		9
10		10
11	GREEDY_KERNEL equ 0	11	GREEDY_KERNEL equ 0
12		12
13	struct APP_HEADER_00_	13	struct APP_HEADER_00_
14	banner dq ?	14	banner dq ?
15	version dd ? ;+8	15	version dd ? ;+8
16	start dd ? ;+12	16	start dd ? ;+12
17	i_end dd ? ;+16	17	i_end dd ? ;+16
18	mem_size dd ? ;+20	18	mem_size dd ? ;+20
19	i_param dd ? ;+24	19	i_param dd ? ;+24
20	ends	20	ends
21		21
22	struct APP_HEADER_01_	22	struct APP_HEADER_01_
23	banner dq ?	23	banner dq ?
24	version dd ? ;+8	24	version dd ? ;+8
25	start dd ? ;+12	25	start dd ? ;+12
26	i_end dd ? ;+16	26	i_end dd ? ;+16
27	mem_size dd ? ;+20	27	mem_size dd ? ;+20
28	stack_top dd ? ;+24	28	stack_top dd ? ;+24
29	i_param dd ? ;+28	29	i_param dd ? ;+28
30	i_icon dd ? ;+32	30	i_icon dd ? ;+32
31	ends	31	ends
32		32
33		33
34	struct APP_PARAMS	34	struct APP_PARAMS
35	app_cmdline dd ? ;0x00	35	app_cmdline dd ? ;0x00
36	app_path dd ? ;0x04	36	app_path dd ? ;0x04
37	app_eip dd ? ;0x08	37	app_eip dd ? ;0x08
38	app_esp dd ? ;0x0C	38	app_esp dd ? ;0x0C
39	app_mem dd ? ;0x10	39	app_mem dd ? ;0x10
40	ends	40	ends
41		41
42	macro _clear_ op	42	macro _clear_ op
43	{ mov ecx, op/4	43	{ mov ecx, op/4
44	xor eax, eax	44	xor eax, eax
45	cld	45	cld
46	rep stosd	46	rep stosd
47	}	47	}
48		48
49	fs_execute_from_sysdir:	49	fs_execute_from_sysdir:
50	xor ebx, ebx	50	xor ebx, ebx
51	fs_execute_from_sysdir_param:	51	fs_execute_from_sysdir_param:
52	xor edx, edx	52	xor edx, edx
53	mov esi, sysdir_path	53	mov esi, sysdir_path
54		54
55	align 4	55	align 4
56	proc fs_execute	56	proc fs_execute
57		57
58	;fn_read:dword, file_size:dword, cluster:dword	58	;fn_read:dword, file_size:dword, cluster:dword
59		59
60	; ebx - cmdline	60	; ebx - cmdline
61	; edx - flags	61	; edx - flags
62	; ebp - full filename	62	; ebp - full filename
63	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it	63	; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
64		64
65	locals	65	locals
66	cmdline_size dd ? ; +0 ; cmdline -12	66	cmdline_size dd ? ; +0 ; cmdline -12
67	cmdline_adr dd ? ; +4 ; cmdline -8	67	cmdline_adr dd ? ; +4 ; cmdline -8
68	cmdline_flag dd ? ; +8 ; cmdline -4	68	cmdline_flag dd ? ; +8 ; cmdline -4
69	cmdline rd 64 ;256/4	69	cmdline rd 64 ;256/4
70	filename rd 256 ;1024/4	70	filename rd 256 ;1024/4
71	flags dd ?	71	flags dd ?
72		72
73	save_proc dd ?	73	save_proc dd ?
74	slot dd ?	74	slot dd ?
75	slot_base dd ?	75	slot_base dd ?
76	file_base dd ?	76	file_base dd ?
77	file_size dd ?	77	file_size dd ?
78	handle dd ? ;temp. for default cursor handle for curr. thread	78	handle dd ? ;temp. for default cursor handle for curr. thread
79	;app header data	79	;app header data
80	hdr_cmdline dd ? ;0x00	80	hdr_cmdline dd ? ;0x00
81	hdr_path dd ? ;0x04	81	hdr_path dd ? ;0x04
82	hdr_eip dd ? ;0x08	82	hdr_eip dd ? ;0x08
83	hdr_esp dd ? ;0x0C	83	hdr_esp dd ? ;0x0C
84	hdr_mem dd ? ;0x10	84	hdr_mem dd ? ;0x10
85	hdr_i_end dd ? ;0x14	85	hdr_i_end dd ? ;0x14
86	endl	86	endl
87		87
88	pushad	88	pushad
89		89
90	cmp [SCR_MODE], word 0x13	90	cmp [SCR_MODE], word 0x13
91	jbe @f	91	jbe @f
92	pushad	92	pushad
93	stdcall set_cursor, [def_cursor_clock]	93	stdcall set_cursor, [def_cursor_clock]
94	mov [handle], eax	94	mov [handle], eax
95	mov [redrawmouse_unconditional], 1	95	mov [redrawmouse_unconditional], 1
96	call wakeup_osloop	96	call wakeup_osloop
97	popad	97	popad
98	@@:	98	@@:
99	mov [flags], edx	99	mov [flags], edx
100		100
101	; [ebp] pointer to filename	101	; [ebp] pointer to filename
102		102
103	lea edi, [filename]	103	lea edi, [filename]
104	lea ecx, [edi+1024]	104	lea ecx, [edi+1024]
105	mov al, '/'	105	mov al, '/'
106	stosb	106	stosb
107	@@:	107	@@:
108	cmp edi, ecx	108	cmp edi, ecx
109	jae .bigfilename	109	jae .bigfilename
110	lodsb	110	lodsb
111	stosb	111	stosb
112	test al, al	112	test al, al
113	jnz @b	113	jnz @b
114	mov esi, [ebp]	114	mov esi, [ebp]
115	test esi, esi	115	test esi, esi
116	jz .namecopied	116	jz .namecopied
117	mov byte [edi-1], '/'	117	mov byte [edi-1], '/'
118	@@:	118	@@:
119	cmp edi, ecx	119	cmp edi, ecx
120	jae .bigfilename	120	jae .bigfilename
121	lodsb	121	lodsb
122	stosb	122	stosb
123	test al, al	123	test al, al
124	jnz @b	124	jnz @b
125	jmp .namecopied	125	jmp .namecopied
126	.bigfilename:	126	.bigfilename:
127	popad	127	popad
128	mov eax, -ERROR_FILE_NOT_FOUND	128	mov eax, -ERROR_FILE_NOT_FOUND
129		129
130	jmp .final	130	jmp .final
131		131
132	.namecopied:	132	.namecopied:
133	xor eax, eax	133	xor eax, eax
134	mov [cmdline_flag], eax	134	mov [cmdline_flag], eax
135	mov [cmdline_adr], eax	135	mov [cmdline_adr], eax
136	mov [cmdline_size], eax	136	mov [cmdline_size], eax
137		137
138	mov [cmdline], ebx	138	mov [cmdline], ebx
139	test ebx, ebx	139	test ebx, ebx
140	jz .no_copy	140	jz .no_copy
141	;--------------------------------------	141	;--------------------------------------
142	pushad	142	pushad
143	pushfd	143	pushfd
144	mov esi, ebx	144	mov esi, ebx
145	mov ecx, 65536 ; 64 Kb max for ext.cmdline	145	mov ecx, 65536 ; 64 Kb max for ext.cmdline
146	cld	146	cld
147	@@:	147	@@:
148	dec ecx	148	dec ecx
149	jz .end_string	149	jz .end_string
150		150
151	lodsb	151	lodsb
152	test al, al	152	test al, al
153	jnz @b	153	jnz @b
154		154
155	.end_string:	155	.end_string:
156	mov eax, 65536 ; 64 Kb max for ext.cmdline	156	mov eax, 65536 ; 64 Kb max for ext.cmdline
157	sub eax, ecx	157	sub eax, ecx
158	mov [cmdline_size], eax	158	mov [cmdline_size], eax
159	cmp eax, 255	159	cmp eax, 255
160	ja @f	160	ja @f
161		161
162	popfd	162	popfd
163	popad	163	popad
164	jmp .old_copy	164	jmp .old_copy
165		165
166	@@:	166	@@:
167	xor eax, eax	167	xor eax, eax
168	dec eax	168	dec eax
169	mov [cmdline_flag], eax	169	mov [cmdline_flag], eax
170	popfd	170	popfd
171	popad	171	popad
172	; get memory for the extended command line	172	; get memory for the extended command line
173	stdcall kernel_alloc, [cmdline_size] ;eax	173	stdcall kernel_alloc, [cmdline_size] ;eax
174	test eax, eax	174	test eax, eax
175	jz .old_copy ; get memory failed	175	jz .old_copy ; get memory failed
176		176
177	mov [cmdline_adr], eax	177	mov [cmdline_adr], eax
178		178
179	pushad	179	pushad
180	pushfd	180	pushfd
181	mov esi, ebx	181	mov esi, ebx
182	mov edi, eax	182	mov edi, eax
183	mov ecx, [cmdline_size]	183	mov ecx, [cmdline_size]
184	cld	184	cld
185	rep movsb	185	rep movsb
186	popfd	186	popfd
187	popad	187	popad
188	jmp .no_copy	188	jmp .no_copy
189		189
190	.old_copy:	190	.old_copy:
191	; clear flag because old method with 256 bytes	191	; clear flag because old method with 256 bytes
192	xor eax, eax	192	xor eax, eax
193	mov [cmdline_flag], eax	193	mov [cmdline_flag], eax
194	;--------------------------------------	194	;--------------------------------------
195	lea eax, [cmdline]	195	lea eax, [cmdline]
196	mov dword [eax+252], 0	196	mov dword [eax+252], 0
197	.copy:	197	.copy:
198	stdcall strncpy, eax, ebx, 255	198	stdcall strncpy, eax, ebx, 255
199	.no_copy:	199	.no_copy:
200	lea eax, [filename]	200	lea eax, [filename]
201	stdcall load_file, eax	201	stdcall load_file, eax
202		202
203	mov esi, -ERROR_FILE_NOT_FOUND	203	mov esi, -ERROR_FILE_NOT_FOUND
204	test eax, eax	204	test eax, eax
205	jz .err_file	205	jz .err_file
206		206
207	mov [file_base], eax	207	mov [file_base], eax
208	mov [file_size], ebx	208	mov [file_size], ebx
209		209
210	lea ebx, [hdr_cmdline]	210	lea ebx, [hdr_cmdline]
211	call test_app_header	211	call test_app_header
212	mov esi, -0x1F	212	mov esi, -0x1F
213	test eax, eax	213	test eax, eax
214	jz .err_hdr	214	jz .err_hdr
215		215
216	call lock_application_table	216	call lock_application_table
217		217
218	call alloc_thread_slot	218	call alloc_thread_slot
219	test eax, eax	219	test eax, eax
220	mov esi, -0x20 ; too many processes	220	mov esi, -0x20 ; too many processes
221	jz .err	221	jz .err
222		222
223	mov [slot], eax	223	mov [slot], eax
224	shl eax, 8	224	shl eax, 8
225	add eax, SLOT_BASE	225	add eax, SLOT_BASE
226	mov [slot_base], eax	226	mov [slot_base], eax
227	mov edi, eax	227	mov edi, eax
228	_clear_ 256 ;clean extended information about process	228	_clear_ 256 ;clean extended information about process
229		229
230	; write application name	230	; write application name
231	lea eax, [filename]	231	lea eax, [filename]
232	stdcall strrchr, eax, '/' ; now eax points to name without path	232	stdcall strrchr, eax, '/' ; now eax points to name without path
233		233
234	lea esi, [eax+1]	234	lea esi, [eax+1]
235	test eax, eax	235	test eax, eax
236	jnz @F	236	jnz @F
237	lea esi, [filename]	237	lea esi, [filename]
238	@@:	238	@@:
239	mov ecx, 11 ; 11 chars for name! 8 - is old value!	239	mov ecx, 11 ; 11 chars for name! 8 - is old value!
240	mov edi, [slot_base]	240	mov edi, [slot_base]
241	.copy_process_name_loop:	241	.copy_process_name_loop:
242	lodsb	242	lodsb
243	cmp al, '.'	243	cmp al, '.'
244	jz .copy_process_name_done	244	jz .copy_process_name_done
245	test al, al	245	test al, al
246	jz .copy_process_name_done	246	jz .copy_process_name_done
247	stosb	247	stosb
248	loop .copy_process_name_loop	248	loop .copy_process_name_loop
249	.copy_process_name_done:	249	.copy_process_name_done:
250		250
251	mov ebx, [current_slot]	251	mov ebx, [current_slot]
252	mov ebx, [ebx+APPDATA.process]	252	mov ebx, [ebx+APPDATA.process]
253	mov [save_proc], ebx	253	mov [save_proc], ebx
254		254
255	stdcall create_process, [hdr_mem], [file_base], [file_size]	255	stdcall create_process, [hdr_mem], [file_base], [file_size]
256	mov esi, -30; no memory	256	mov esi, -30; no memory
257	test eax, eax	257	test eax, eax
258	jz .failed	258	jz .failed
-		259
-		260	mov ebx, [hdr_mem]
-		261	mov [eax+PROC.mem_used], ebx
259		262
260	mov ebx, [slot_base]	263	mov ebx, [slot_base]
261	mov [ebx+APPDATA.process], eax	-
262	mov eax, [hdr_mem]	-
263	mov [ebx+APPDATA.mem_size], eax	264	mov [ebx+APPDATA.process], eax
264		265
265	xor edx, edx	266	xor edx, edx
266	cmp word [6], '02'	267	cmp word [6], '02'
267	jne @f	268	jne @f
268		269
269	not edx	270	not edx
270	@@:	271	@@:
271	mov [ebx+APPDATA.tls_base], edx	272	mov [ebx+APPDATA.tls_base], edx
272		273
273	if GREEDY_KERNEL	274	if GREEDY_KERNEL
274	else	275	else
275	mov ecx, [hdr_mem]	276	mov ecx, [hdr_mem]
276	mov edi, [file_size]	277	mov edi, [file_size]
277	add edi, 4095	278	add edi, 4095
278	and edi, not 4095	279	and edi, not 4095
279	sub ecx, edi	280	sub ecx, edi
280	jna @F	281	jna @F
281		282
282	xor eax, eax	283	xor eax, eax
283	cld	284	cld
284	rep stosb	285	rep stosb
285	@@:	286	@@:
286	end if	287	end if
287		288
288	; release only virtual space, not phisical memory	289	; release only virtual space, not phisical memory
289		290
290	stdcall free_kernel_space, [file_base]	291	stdcall free_kernel_space, [file_base]
291	lea eax, [hdr_cmdline]	292	lea eax, [hdr_cmdline]
292	lea ebx, [cmdline]	293	lea ebx, [cmdline]
293	lea ecx, [filename]	294	lea ecx, [filename]
294	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]	295	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
295		296
296	mov eax, [save_proc]	297	mov eax, [save_proc]
297	call set_cr3	298	call set_cr3
298		299
299	mov eax, [process_number];set result	300	mov eax, [process_number];set result
300	call unlock_application_table	301	call unlock_application_table
301		302
302	jmp .final	303	jmp .final
303		304
304	.failed:	305	.failed:
305	mov eax, [save_proc]	306	mov eax, [save_proc]
306	call set_cr3	307	call set_cr3
307	.err:	308	.err:
308	.err_hdr:	309	.err_hdr:
309	stdcall kernel_free, [file_base]	310	stdcall kernel_free, [file_base]
310	.err_file:	311	.err_file:
311	call unlock_application_table	312	call unlock_application_table
312	mov eax, esi	313	mov eax, esi
313	.final:	314	.final:
314	cmp [SCR_MODE], word 0x13	315	cmp [SCR_MODE], word 0x13
315	jbe @f	316	jbe @f
316	pushad	317	pushad
317	stdcall set_cursor, [handle]	318	stdcall set_cursor, [handle]
318	mov [redrawmouse_unconditional], 1	319	mov [redrawmouse_unconditional], 1
319	call wakeup_osloop	320	call wakeup_osloop
320	popad	321	popad
321	@@:	322	@@:
322	ret	323	ret
323	endp	324	endp
324		325
325	align 4	326	align 4
326	test_app_header:	327	test_app_header:
327	virtual at eax	328	virtual at eax
328	APP_HEADER_00 APP_HEADER_00_	329	APP_HEADER_00 APP_HEADER_00_
329	end virtual	330	end virtual
330	virtual at eax	331	virtual at eax
331	APP_HEADER_01 APP_HEADER_01_	332	APP_HEADER_01 APP_HEADER_01_
332	end virtual	333	end virtual
333		334
334	cmp dword [eax], 'MENU'	335	cmp dword [eax], 'MENU'
335	jne .fail	336	jne .fail
336	cmp word [eax+4], 'ET'	337	cmp word [eax+4], 'ET'
337	jne .fail	338	jne .fail
338		339
339	cmp [eax+6], word '00'	340	cmp [eax+6], word '00'
340	jne .check_01_header	341	jne .check_01_header
341		342
342	mov ecx, [APP_HEADER_00.start]	343	mov ecx, [APP_HEADER_00.start]
343	mov [ebx+0x08], ecx ;app_eip	344	mov [ebx+0x08], ecx ;app_eip
344	mov edx, [APP_HEADER_00.mem_size]	345	mov edx, [APP_HEADER_00.mem_size]
345	mov [ebx+0x10], edx ;app_mem	346	mov [ebx+0x10], edx ;app_mem
346	shr edx, 1	347	shr edx, 1
347	sub edx, 0x10	348	sub edx, 0x10
348	mov [ebx+0x0C], edx ;app_esp	349	mov [ebx+0x0C], edx ;app_esp
349	mov ecx, [APP_HEADER_00.i_param]	350	mov ecx, [APP_HEADER_00.i_param]
350	mov [ebx], ecx ;app_cmdline	351	mov [ebx], ecx ;app_cmdline
351	mov [ebx+4], dword 0 ;app_path	352	mov [ebx+4], dword 0 ;app_path
352	mov edx, [APP_HEADER_00.i_end]	353	mov edx, [APP_HEADER_00.i_end]
353	mov [ebx+0x14], edx	354	mov [ebx+0x14], edx
354	ret	355	ret
355		356
356	.check_01_header:	357	.check_01_header:
357		358
358	cmp [eax+6], word '01'	359	cmp [eax+6], word '01'
359	je @f	360	je @f
360	cmp [eax+6], word '02'	361	cmp [eax+6], word '02'
361	jne .fail	362	jne .fail
362	@@:	363	@@:
363	mov ecx, [APP_HEADER_01.start]	364	mov ecx, [APP_HEADER_01.start]
364	mov [ebx+0x08], ecx ;app_eip	365	mov [ebx+0x08], ecx ;app_eip
365	mov edx, [APP_HEADER_01.mem_size]	366	mov edx, [APP_HEADER_01.mem_size]
366		367
367	; \begin{diamond}[20.08.2006]	368	; \begin{diamond}[20.08.2006]
368	; sanity check (functions 19,58 load app_i_end bytes and that must	369	; sanity check (functions 19,58 load app_i_end bytes and that must
369	; fit in allocated memory to prevent kernel faults)	370	; fit in allocated memory to prevent kernel faults)
370	cmp edx, [APP_HEADER_01.i_end]	371	cmp edx, [APP_HEADER_01.i_end]
371	jb .fail	372	jb .fail
372	; \end{diamond}[20.08.2006]	373	; \end{diamond}[20.08.2006]
373		374
374	mov [ebx+0x10], edx ;app_mem	375	mov [ebx+0x10], edx ;app_mem
375	mov ecx, [APP_HEADER_01.stack_top]	376	mov ecx, [APP_HEADER_01.stack_top]
376	mov [ebx+0x0C], ecx ;app_esp	377	mov [ebx+0x0C], ecx ;app_esp
377	mov edx, [APP_HEADER_01.i_param]	378	mov edx, [APP_HEADER_01.i_param]
378	mov [ebx], edx ;app_cmdline	379	mov [ebx], edx ;app_cmdline
379	mov ecx, [APP_HEADER_01.i_icon]	380	mov ecx, [APP_HEADER_01.i_icon]
380	mov [ebx+4], ecx ;app_path	381	mov [ebx+4], ecx ;app_path
381	mov edx, [APP_HEADER_01.i_end]	382	mov edx, [APP_HEADER_01.i_end]
382	mov [ebx+0x14], edx	383	mov [ebx+0x14], edx
383	ret	384	ret
384	.fail:	385	.fail:
385	xor eax, eax	386	xor eax, eax
386	ret	387	ret
387		388
388		389
389	align 4	390	align 4
390	alloc_thread_slot:	391	alloc_thread_slot:
391	;input:	392	;input:
392	; none	393	; none
393	;result:	394	;result:
394	; eax=[new_thread_slot]<>0 - ok	395	; eax=[new_thread_slot]<>0 - ok
395	; 0 - failed.	396	; 0 - failed.
396	;This function find least empty slot.	397	;This function find least empty slot.
397	;It doesn't increase [TASK_COUNT]!	398	;It doesn't increase [TASK_COUNT]!
398		399
399		400
400	mov edx, thr_slot_map	401	mov edx, thr_slot_map
401	pushfd	402	pushfd
402	cli	403	cli
403	.l1:	404	.l1:
404	bsf eax, [edx]	405	bsf eax, [edx]
405	jnz .found	406	jnz .found
406	add edx, 4	407	add edx, 4
407	cmp edx, thr_slot_map+32	408	cmp edx, thr_slot_map+32
408	jb .l1	409	jb .l1
409		410
410	popfd	411	popfd
411	xor eax, eax	412	xor eax, eax
412	ret	413	ret
413	.found:	414	.found:
414	btr [edx], eax	415	btr [edx], eax
415	sub edx, thr_slot_map	416	sub edx, thr_slot_map
416	lea eax, [eax+edx*8]	417	lea eax, [eax+edx*8]
417	popfd	418	popfd
418	ret	419	ret
419		420
420		421
421	align 4	422	align 4
422	proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword	423	proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
423	locals	424	locals
424	app_pages dd ?	425	app_pages dd ?
425	img_pages dd ?	426	img_pages dd ?
426	process dd ?	427	process dd ?
427	app_tabs dd ?	428	app_tabs dd ?
428	endl	429	endl
429		430
430	mov ecx, pg_data.mutex	431	mov ecx, pg_data.mutex
431	call mutex_lock	432	call mutex_lock
432		433
433	xchg bx, bx	434	xchg bx, bx
434		435
435	xor eax, eax	436	xor eax, eax
436	mov [process], eax	437	mov [process], eax
437		438
438	mov eax, [app_size]	439	mov eax, [app_size]
439	add eax, 4095	440	add eax, 4095
440	and eax, NOT(4095)	441	and eax, NOT(4095)
441	mov [app_size], eax	442	mov [app_size], eax
442	mov ebx, eax	443	mov ebx, eax
443	shr eax, 12	444	shr eax, 12
444	mov [app_pages], eax	445	mov [app_pages], eax
445		446
446	add ebx, 0x3FFFFF	447	add ebx, 0x3FFFFF
447	and ebx, NOT(0x3FFFFF)	448	and ebx, NOT(0x3FFFFF)
448	shr ebx, 22	449	shr ebx, 22
449	mov [app_tabs], ebx	450	mov [app_tabs], ebx
450		451
451	mov ecx, [img_size]	452	mov ecx, [img_size]
452	add ecx, 4095	453	add ecx, 4095
453	and ecx, NOT(4095)	454	and ecx, NOT(4095)
454		455
455	mov [img_size], ecx	456	mov [img_size], ecx
456	shr ecx, 12	457	shr ecx, 12
457	mov [img_pages], ecx	458	mov [img_pages], ecx
458		459
459	lea eax, [eax+ebx+2];all requested memory	460	lea eax, [eax+ebx+2];all requested memory
460		461
461	cmp eax, [pg_data.pages_free]	462	cmp eax, [pg_data.pages_free]
462	ja .fail	463	ja .fail
463		464
464	stdcall kernel_alloc, 0x2000	465	stdcall kernel_alloc, 0x2000
465	test eax, eax	466	test eax, eax
466	jz .fail	467	jz .fail
467	mov [process], eax	468	mov [process], eax
468		469
469	lea edi, [eax+PROC.heap_lock]	470	lea edi, [eax+PROC.heap_lock]
470	mov ecx, (4096-PROC.heap_lock)/4	471	mov ecx, (4096-PROC.heap_lock)/4
471		472
472	list_init eax	473	list_init eax
473	add eax, PROC.thr_list	474	add eax, PROC.thr_list
474	list_init eax	475	list_init eax
475		476
476	xor eax, eax	477	xor eax, eax
477	cld	478	cld
478	rep stosd	479	rep stosd
479		480
480	mov eax, edi	481	mov eax, edi
481	call get_pg_addr	482	call get_pg_addr
482	mov [edi-4096+PROC.pdt_0_phys], eax	483	mov [edi-4096+PROC.pdt_0_phys], eax
483		484
484	mov ecx, (OS_BASE shr 20)/4	485	mov ecx, (OS_BASE shr 20)/4
485	xor eax, eax	486	xor eax, eax
486	rep stosd	487	rep stosd
487		488
488	mov ecx, (OS_BASE shr 20)/4	489	mov ecx, (OS_BASE shr 20)/4
489	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)	490	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
490	rep movsd	491	rep movsd
491		492
492	mov eax, [edi-8192+PROC.pdt_0_phys]	493	mov eax, [edi-8192+PROC.pdt_0_phys]
493	or eax, PG_SW	494	or eax, PG_SW
494	mov [edi-4096+(page_tabs shr 20)], eax	495	mov [edi-4096+(page_tabs shr 20)], eax
495		496
496	lea eax, [edi-8192]	497	lea eax, [edi-8192]
497	call set_cr3	498	call set_cr3

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri-process/core/taskman.inc – Rev 4429 → 4430