WebSVN – Kolibri OS – Diff – /kernel/branches/net/core/taskman.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision $
 
 
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       rd 64    ;256/4
         filename      rd 256   ;1024/4
         flags     dd ?
 
         save_cr3      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
 
        pushad
        stdcall set_cursor, [def_cursor_clock]
        mov     [handle], eax
        mov     [redrawmouse_unconditional], 1
        call    __sys_draw_pointer
        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:
 
        mov     [cmdline], ebx
        test    ebx, ebx
        jz      @F
 
        lea     eax, [cmdline]
        mov     dword [eax+252], 0
        stdcall strncpy, eax, ebx, 255
@@:
        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
 
.wait_lock:
        cmp     [application_table_status], 0
        je      .get_lock
        call    change_task
        jmp     .wait_lock
 
.get_lock:
        mov     eax, 1
        xchg    eax, [application_table_status]
        test    eax, eax
        jnz     .wait_lock
 
        call    set_application_table_status
 
        call    get_new_process_place
        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, 8; 8 chars for name
        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, cr3
        mov     [save_cr3], ebx
 
        stdcall create_app_space, [hdr_mem], [file_base], [file_size]
        mov     esi, -30; no memory
        test    eax, eax
        jz      .failed
 
        mov     ebx, [slot_base]
        mov     [ebx+APPDATA.dir_table], eax
        mov     eax, [hdr_mem]
        mov     [ebx+APPDATA.mem_size], 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_cr3]
        call    set_cr3
 
        xor     ebx, ebx
        mov     [application_table_status], ebx;unlock application_table_status mutex
        mov     eax, [process_number];set result
 
        jmp     .final
 
.failed:
        mov     eax, [save_cr3]
        call    set_cr3
.err:
.err_hdr:
        stdcall kernel_free, [file_base]
.err_file:
        xor     eax, eax
        mov     [application_table_status], eax
        mov     eax, esi
.final:
        pushad
        stdcall set_cursor, [handle]
        mov     [redrawmouse_unconditional], 1
        call    __sys_draw_pointer
        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
proc get_new_process_place
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
        mov     eax, CURRENT_TASK
        mov     ebx, [TASK_COUNT]
        inc     ebx
        shl     ebx, 5
        add     ebx, eax    ;ebx - address of process information for (last+1) slot
.newprocessplace:
;eax = address of process information for current slot
        cmp     eax, ebx
        jz      .endnewprocessplace ;empty slot after high boundary
        add     eax, 0x20
        cmp     word [eax+0xa], 9;check process state, 9 means that process slot is empty
        jnz     .newprocessplace
.endnewprocessplace:
        mov     ebx, eax
        sub     eax, CURRENT_TASK
        shr     eax, 5      ;calculate slot index
        cmp     eax, 256
        jge     .failed     ;it should be <256
        mov     word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)
        ret
.failed:
        xor     eax, eax
        ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
       locals
         app_pages   dd ?
         img_pages   dd ?
         dir_addr    dd ?
         app_tabs    dd ?
       endl
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        xor     eax, eax
        mov     [dir_addr], 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
 
if GREEDY_KERNEL
        lea     eax, [ecx+ebx+2];only image size
else
        lea     eax, [eax+ebx+2];all requested memory
end if
        cmp     eax, [pg_data.pages_free]
        ja      .fail
 
        call    alloc_page
        test    eax, eax
        jz      .fail
        mov     [dir_addr], eax
        stdcall map_page, [tmp_task_pdir], eax, dword PG_SW
 
        mov     edi, [tmp_task_pdir]
        mov     ecx, (OS_BASE shr 20)/4
        xor     eax, eax
        cld
        rep stosd
 
        mov     ecx, (OS_BASE shr 20)/4
        mov     esi, sys_pgdir+(OS_BASE shr 20)
        rep movsd
 
        mov     eax, [dir_addr]
        or      eax, PG_SW
        mov     [edi-4096+(page_tabs shr 20)], eax
 
        and     eax, -4096
        call    set_cr3
 
        mov     edx, [app_tabs]
        mov     edi, new_app_base
@@:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page_table, edi, eax
        add     edi, 0x00400000
        dec     edx
        jnz     @B
 
        mov     edi, new_app_base
        shr     edi, 10
        add     edi, page_tabs
 
        mov     ecx, [app_tabs]
        shl     ecx, 10
        xor     eax, eax
        rep stosd
 
        mov     ecx, [img_pages]
        mov     ebx, PG_UW
        mov     edx, new_app_base
        mov     esi, [img_base]
        mov     edi, new_app_base
        shr     esi, 10
        shr     edi, 10
        add     esi, page_tabs
        add     edi, page_tabs
.remap:
        lodsd
        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
 
if GREEDY_KERNEL
        mov     eax, 0x02
        rep stosd
else
 
.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
end if
 
.done:
        stdcall map_page, [tmp_task_pdir], dword 0, dword PG_UNMAP
 
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        mov     eax, [dir_addr]
        ret
.fail:
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        cmp     [dir_addr], 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.dir_table], eax
        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, 0x2
        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.dir_table], 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
 
align 4
proc new_sys_threads
       locals
         slot      dd ?
         app_cmdline   dd ? ;0x00
         app_path      dd ? ;0x04
         app_eip       dd ? ;0x08
         app_esp       dd ? ;0x0C
         app_mem       dd ? ;0x10
       endl
 
        cmp     ebx, 1
        jne     .failed     ;other subfunctions
 
        xor     eax, eax
        mov     [app_eip], ecx
        mov     [app_cmdline], eax
        mov     [app_esp], edx
        mov     [app_path], eax
       ;mov    esi,new_process_loading
       ;call   sys_msg_board_str
.wait_lock:
        cmp     [application_table_status], 0
        je      .get_lock
        call    change_task
        jmp     .wait_lock
 
.get_lock:
        mov     eax, 1
        xchg    eax, [application_table_status]
        test    eax, eax
        jnz     .wait_lock
 
        call    set_application_table_status
 
        call    get_new_process_place
        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.heap_base]
        mov     [edx+APPDATA.heap_base], eax
 
        mov     ecx, [ebx+APPDATA.heap_top]
        mov     [edx+APPDATA.heap_top], ecx
 
        mov     eax, [ebx+APPDATA.mem_size]
        mov     [edx+APPDATA.mem_size], eax
 
        mov     ecx, [ebx+APPDATA.dir_table]
        mov     [edx+APPDATA.dir_table], ecx;copy page directory
 
        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,dword 0
 
       ;mov    esi,new_process_running
       ;call   sys_msg_board_str                ;output information about succefull startup
        xor     eax, eax
        mov     [application_table_status], eax ;unlock application_table_status mutex
        mov     eax, [process_number]           ;set result
        ret
.failed:
        xor     eax, eax
.failed1:
        mov     [application_table_status], eax
        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
 
;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     byte [edx], 0  ;force empty string if no cmdline given
        mov     eax, [cmd_line]
        test    eax, eax
        jz      @f
        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     [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     ecx, [ebx+REG_RET]
        mov     ebx, [slot]
        shl     ebx, 5
        mov     [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
 
        xor     ecx, ecx; process state - running
; set if debuggee
        test    byte [flags], 1
        jz      .no_debug
        inc     ecx ; process state - suspended
        mov     eax, [CURRENT_TASK]
        mov     [SLOT_BASE+ebx*8+APPDATA.debugger_slot], eax
.no_debug:
        mov     [CURRENT_TASK+ebx+TASKDATA.state], cl
       ;mov    esi,new_process_running
       ;call   sys_msg_board_str     ;output information about succefull startup
        ret
endp
 
 
align 4
 
get_stack_base:
        mov     eax, [current_slot]
        mov     eax, [eax+APPDATA.pl0_stack]
        ret
 
 
include "debug.inc"
>

Rev 2385	Rev 2540
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. 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: 2385 $	8	$Revision $
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 rd 64 ;256/4	66	cmdline rd 64 ;256/4
67	filename rd 256 ;1024/4	67	filename rd 256 ;1024/4
68	flags dd ?	68	flags dd ?
69		69
70	save_cr3 dd ?	70	save_cr3 dd ?
71	slot dd ?	71	slot dd ?
72	slot_base dd ?	72	slot_base dd ?
73	file_base dd ?	73	file_base dd ?
74	file_size dd ?	74	file_size dd ?
-		75	handle dd ? ;temp. for default cursor handle for curr. thread
75	;app header data	76	;app header data
76	hdr_cmdline dd ? ;0x00	77	hdr_cmdline dd ? ;0x00
77	hdr_path dd ? ;0x04	78	hdr_path dd ? ;0x04
78	hdr_eip dd ? ;0x08	79	hdr_eip dd ? ;0x08
79	hdr_esp dd ? ;0x0C	80	hdr_esp dd ? ;0x0C
80	hdr_mem dd ? ;0x10	81	hdr_mem dd ? ;0x10
81	hdr_i_end dd ? ;0x14	82	hdr_i_end dd ? ;0x14
82	endl	83	endl
83		84
84	pushad	85	pushad
-		86
-		87	pushad
-		88	stdcall set_cursor, [def_cursor_clock]
-		89	mov [handle], eax
-		90	mov [redrawmouse_unconditional], 1
-		91	call __sys_draw_pointer
-		92	popad
85		93
86	mov [flags], edx	94	mov [flags], edx
87		95
88	; [ebp] pointer to filename	96	; [ebp] pointer to filename
89		97
90	lea edi, [filename]	98	lea edi, [filename]
91	lea ecx, [edi+1024]	99	lea ecx, [edi+1024]
92	mov al, '/'	100	mov al, '/'
93	stosb	101	stosb
94	@@:	102	@@:
95	cmp edi, ecx	103	cmp edi, ecx
96	jae .bigfilename	104	jae .bigfilename
97	lodsb	105	lodsb
98	stosb	106	stosb
99	test al, al	107	test al, al
100	jnz @b	108	jnz @b
101	mov esi, [ebp]	109	mov esi, [ebp]
102	test esi, esi	110	test esi, esi
103	jz .namecopied	111	jz .namecopied
104	mov byte [edi-1], '/'	112	mov byte [edi-1], '/'
105	@@:	113	@@:
106	cmp edi, ecx	114	cmp edi, ecx
107	jae .bigfilename	115	jae .bigfilename
108	lodsb	116	lodsb
109	stosb	117	stosb
110	test al, al	118	test al, al
111	jnz @b	119	jnz @b
112	jmp .namecopied	120	jmp .namecopied
113	.bigfilename:	121	.bigfilename:
114	popad	122	popad
115	mov eax, -ERROR_FILE_NOT_FOUND	123	mov eax, -ERROR_FILE_NOT_FOUND
-		124
116	ret	125	jmp .final
117		126
118	.namecopied:	127	.namecopied:
119		128
120	mov [cmdline], ebx	129	mov [cmdline], ebx
121	test ebx, ebx	130	test ebx, ebx
122	jz @F	131	jz @F
123		132
124	lea eax, [cmdline]	133	lea eax, [cmdline]
125	mov dword [eax+252], 0	134	mov dword [eax+252], 0
126	stdcall strncpy, eax, ebx, 255	135	stdcall strncpy, eax, ebx, 255
127	@@:	136	@@:
128	lea eax, [filename]	137	lea eax, [filename]
129	stdcall load_file, eax	138	stdcall load_file, eax
-		139
130	mov esi, -ERROR_FILE_NOT_FOUND	140	mov esi, -ERROR_FILE_NOT_FOUND
131	test eax, eax	141	test eax, eax
132	jz .err_file	142	jz .err_file
133		143
134	mov [file_base], eax	144	mov [file_base], eax
135	mov [file_size], ebx	145	mov [file_size], ebx
136		146
137	lea ebx, [hdr_cmdline]	147	lea ebx, [hdr_cmdline]
138	call test_app_header	148	call test_app_header
139	mov esi, -0x1F	149	mov esi, -0x1F
140	test eax, eax	150	test eax, eax
141	jz .err_hdr	151	jz .err_hdr
142		152
143	.wait_lock:	153	.wait_lock:
144	cmp [application_table_status], 0	154	cmp [application_table_status], 0
145	je .get_lock	155	je .get_lock
146	call change_task	156	call change_task
147	jmp .wait_lock	157	jmp .wait_lock
148		158
149	.get_lock:	159	.get_lock:
150	mov eax, 1	160	mov eax, 1
151	xchg eax, [application_table_status]	161	xchg eax, [application_table_status]
152	test eax, eax	162	test eax, eax
153	jnz .wait_lock	163	jnz .wait_lock
154		164
155	call set_application_table_status	165	call set_application_table_status
156		166
157	call get_new_process_place	167	call get_new_process_place
158	test eax, eax	168	test eax, eax
159	mov esi, -0x20 ; too many processes	169	mov esi, -0x20 ; too many processes
160	jz .err	170	jz .err
161		171
162	mov [slot], eax	172	mov [slot], eax
163	shl eax, 8	173	shl eax, 8
164	add eax, SLOT_BASE	174	add eax, SLOT_BASE
165	mov [slot_base], eax	175	mov [slot_base], eax
166	mov edi, eax	176	mov edi, eax
167	_clear_ 256 ;clean extended information about process	177	_clear_ 256 ;clean extended information about process
168		178
169	; write application name	179	; write application name
170	lea eax, [filename]	180	lea eax, [filename]
171	stdcall strrchr, eax, '/' ; now eax points to name without path	181	stdcall strrchr, eax, '/' ; now eax points to name without path
172		182
173	lea esi, [eax+1]	183	lea esi, [eax+1]
174	test eax, eax	184	test eax, eax
175	jnz @F	185	jnz @F
176	lea esi, [filename]	186	lea esi, [filename]
177	@@:	187	@@:
178	mov ecx, 8; 8 chars for name	188	mov ecx, 8; 8 chars for name
179	mov edi, [slot_base]	189	mov edi, [slot_base]
180	.copy_process_name_loop:	190	.copy_process_name_loop:
181	lodsb	191	lodsb
182	cmp al, '.'	192	cmp al, '.'
183	jz .copy_process_name_done	193	jz .copy_process_name_done
184	test al, al	194	test al, al
185	jz .copy_process_name_done	195	jz .copy_process_name_done
186	stosb	196	stosb
187	loop .copy_process_name_loop	197	loop .copy_process_name_loop
188	.copy_process_name_done:	198	.copy_process_name_done:
189		199
190	mov ebx, cr3	200	mov ebx, cr3
191	mov [save_cr3], ebx	201	mov [save_cr3], ebx
192		202
193	stdcall create_app_space, [hdr_mem], [file_base], [file_size]	203	stdcall create_app_space, [hdr_mem], [file_base], [file_size]
194	mov esi, -30; no memory	204	mov esi, -30; no memory
195	test eax, eax	205	test eax, eax
196	jz .failed	206	jz .failed
197		207
198	mov ebx, [slot_base]	208	mov ebx, [slot_base]
199	mov [ebx+APPDATA.dir_table], eax	209	mov [ebx+APPDATA.dir_table], eax
200	mov eax, [hdr_mem]	210	mov eax, [hdr_mem]
201	mov [ebx+APPDATA.mem_size], eax	211	mov [ebx+APPDATA.mem_size], eax
202		212
203	xor edx, edx	213	xor edx, edx
204	cmp word [6], '02'	214	cmp word [6], '02'
205	jne @f	215	jne @f
206		216
207	not edx	217	not edx
208	@@:	218	@@:
209	mov [ebx+APPDATA.tls_base], edx	219	mov [ebx+APPDATA.tls_base], edx
210		220
211	if GREEDY_KERNEL	221	if GREEDY_KERNEL
212	else	222	else
213	mov ecx, [hdr_mem]	223	mov ecx, [hdr_mem]
214	mov edi, [file_size]	224	mov edi, [file_size]
215	add edi, 4095	225	add edi, 4095
216	and edi, not 4095	226	and edi, not 4095
217	sub ecx, edi	227	sub ecx, edi
218	jna @F	228	jna @F
219		229
220	xor eax, eax	230	xor eax, eax
221	cld	231	cld
222	rep stosb	232	rep stosb
223	@@:	233	@@:
224	end if	234	end if
225		235
226	; release only virtual space, not phisical memory	236	; release only virtual space, not phisical memory
227		237
228	stdcall free_kernel_space, [file_base]	238	stdcall free_kernel_space, [file_base]
229	lea eax, [hdr_cmdline]	239	lea eax, [hdr_cmdline]
230	lea ebx, [cmdline]	240	lea ebx, [cmdline]
231	lea ecx, [filename]	241	lea ecx, [filename]
232	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]	242	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
233		243
234	mov eax, [save_cr3]	244	mov eax, [save_cr3]
235	call set_cr3	245	call set_cr3
236		246
237	xor ebx, ebx	247	xor ebx, ebx
238	mov [application_table_status], ebx;unlock application_table_status mutex	248	mov [application_table_status], ebx;unlock application_table_status mutex
239	mov eax, [process_number];set result	249	mov eax, [process_number];set result
-		250
240	ret	251	jmp .final
-		252
241	.failed:	253	.failed:
242	mov eax, [save_cr3]	254	mov eax, [save_cr3]
243	call set_cr3	255	call set_cr3
244	.err:	256	.err:
245	.err_hdr:	257	.err_hdr:
246	stdcall kernel_free, [file_base]	258	stdcall kernel_free, [file_base]
247	.err_file:	259	.err_file:
248	xor eax, eax	260	xor eax, eax
249	mov [application_table_status], eax	261	mov [application_table_status], eax
250	mov eax, esi	262	mov eax, esi
-		263	.final:
-		264	pushad
-		265	stdcall set_cursor, [handle]
-		266	mov [redrawmouse_unconditional], 1
-		267	call __sys_draw_pointer
-		268	popad
251	ret	269	ret
252	endp	270	endp
253		271
254	align 4	272	align 4
255	test_app_header:	273	test_app_header:
256	virtual at eax	274	virtual at eax
257	APP_HEADER_00 APP_HEADER_00_	275	APP_HEADER_00 APP_HEADER_00_
258	end virtual	276	end virtual
259	virtual at eax	277	virtual at eax
260	APP_HEADER_01 APP_HEADER_01_	278	APP_HEADER_01 APP_HEADER_01_
261	end virtual	279	end virtual
262		280
263	cmp dword [eax], 'MENU'	281	cmp dword [eax], 'MENU'
264	jne .fail	282	jne .fail
265	cmp word [eax+4], 'ET'	283	cmp word [eax+4], 'ET'
266	jne .fail	284	jne .fail
267		285
268	cmp [eax+6], word '00'	286	cmp [eax+6], word '00'
269	jne .check_01_header	287	jne .check_01_header
270		288
271	mov ecx, [APP_HEADER_00.start]	289	mov ecx, [APP_HEADER_00.start]
272	mov [ebx+0x08], ecx ;app_eip	290	mov [ebx+0x08], ecx ;app_eip
273	mov edx, [APP_HEADER_00.mem_size]	291	mov edx, [APP_HEADER_00.mem_size]
274	mov [ebx+0x10], edx ;app_mem	292	mov [ebx+0x10], edx ;app_mem
275	shr edx, 1	293	shr edx, 1
276	sub edx, 0x10	294	sub edx, 0x10
277	mov [ebx+0x0C], edx ;app_esp	295	mov [ebx+0x0C], edx ;app_esp
278	mov ecx, [APP_HEADER_00.i_param]	296	mov ecx, [APP_HEADER_00.i_param]
279	mov [ebx], ecx ;app_cmdline	297	mov [ebx], ecx ;app_cmdline
280	mov [ebx+4], dword 0 ;app_path	298	mov [ebx+4], dword 0 ;app_path
281	mov edx, [APP_HEADER_00.i_end]	299	mov edx, [APP_HEADER_00.i_end]
282	mov [ebx+0x14], edx	300	mov [ebx+0x14], edx
283	ret	301	ret
284		302
285	.check_01_header:	303	.check_01_header:
286		304
287	cmp [eax+6], word '01'	305	cmp [eax+6], word '01'
288	je @f	306	je @f
289	cmp [eax+6], word '02'	307	cmp [eax+6], word '02'
290	jne .fail	308	jne .fail
291	@@:	309	@@:
292	mov ecx, [APP_HEADER_01.start]	310	mov ecx, [APP_HEADER_01.start]
293	mov [ebx+0x08], ecx ;app_eip	311	mov [ebx+0x08], ecx ;app_eip
294	mov edx, [APP_HEADER_01.mem_size]	312	mov edx, [APP_HEADER_01.mem_size]
295		313
296	; \begin{diamond}[20.08.2006]	314	; \begin{diamond}[20.08.2006]
297	; sanity check (functions 19,58 load app_i_end bytes and that must	315	; sanity check (functions 19,58 load app_i_end bytes and that must
298	; fit in allocated memory to prevent kernel faults)	316	; fit in allocated memory to prevent kernel faults)
299	cmp edx, [APP_HEADER_01.i_end]	317	cmp edx, [APP_HEADER_01.i_end]
300	jb .fail	318	jb .fail
301	; \end{diamond}[20.08.2006]	319	; \end{diamond}[20.08.2006]
302		320
303	mov [ebx+0x10], edx ;app_mem	321	mov [ebx+0x10], edx ;app_mem
304	mov ecx, [APP_HEADER_01.stack_top]	322	mov ecx, [APP_HEADER_01.stack_top]
305	mov [ebx+0x0C], ecx ;app_esp	323	mov [ebx+0x0C], ecx ;app_esp
306	mov edx, [APP_HEADER_01.i_param]	324	mov edx, [APP_HEADER_01.i_param]
307	mov [ebx], edx ;app_cmdline	325	mov [ebx], edx ;app_cmdline
308	mov ecx, [APP_HEADER_01.i_icon]	326	mov ecx, [APP_HEADER_01.i_icon]
309	mov [ebx+4], ecx ;app_path	327	mov [ebx+4], ecx ;app_path
310	mov edx, [APP_HEADER_01.i_end]	328	mov edx, [APP_HEADER_01.i_end]
311	mov [ebx+0x14], edx	329	mov [ebx+0x14], edx
312	ret	330	ret
313	.fail:	331	.fail:
314	xor eax, eax	332	xor eax, eax
315	ret	333	ret
316		334
317	align 4	335	align 4
318	proc get_new_process_place	336	proc get_new_process_place
319	;input:	337	;input:
320	; none	338	; none
321	;result:	339	;result:
322	; eax=[new_process_place]<>0 - ok	340	; eax=[new_process_place]<>0 - ok
323	; 0 - failed.	341	; 0 - failed.
324	;This function find least empty slot.	342	;This function find least empty slot.
325	;It doesn't increase [TASK_COUNT]!	343	;It doesn't increase [TASK_COUNT]!
326	mov eax, CURRENT_TASK	344	mov eax, CURRENT_TASK
327	mov ebx, [TASK_COUNT]	345	mov ebx, [TASK_COUNT]
328	inc ebx	346	inc ebx
329	shl ebx, 5	347	shl ebx, 5
330	add ebx, eax ;ebx - address of process information for (last+1) slot	348	add ebx, eax ;ebx - address of process information for (last+1) slot
331	.newprocessplace:	349	.newprocessplace:
332	;eax = address of process information for current slot	350	;eax = address of process information for current slot
333	cmp eax, ebx	351	cmp eax, ebx
334	jz .endnewprocessplace ;empty slot after high boundary	352	jz .endnewprocessplace ;empty slot after high boundary
335	add eax, 0x20	353	add eax, 0x20
336	cmp word [eax+0xa], 9;check process state, 9 means that process slot is empty	354	cmp word [eax+0xa], 9;check process state, 9 means that process slot is empty
337	jnz .newprocessplace	355	jnz .newprocessplace
338	.endnewprocessplace:	356	.endnewprocessplace:
339	mov ebx, eax	357	mov ebx, eax
340	sub eax, CURRENT_TASK	358	sub eax, CURRENT_TASK
341	shr eax, 5 ;calculate slot index	359	shr eax, 5 ;calculate slot index
342	cmp eax, 256	360	cmp eax, 256
343	jge .failed ;it should be <256	361	jge .failed ;it should be <256
344	mov word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)	362	mov word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)
345	ret	363	ret
346	.failed:	364	.failed:
347	xor eax, eax	365	xor eax, eax
348	ret	366	ret
349	endp	367	endp
350		368
351	align 4	369	align 4
352	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword	370	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
353	locals	371	locals
354	app_pages dd ?	372	app_pages dd ?
355	img_pages dd ?	373	img_pages dd ?
356	dir_addr dd ?	374	dir_addr dd ?
357	app_tabs dd ?	375	app_tabs dd ?
358	endl	376	endl
359		377
360	mov ecx, pg_data.mutex	378	mov ecx, pg_data.mutex
361	call mutex_lock	379	call mutex_lock
362		380
363	xor eax, eax	381	xor eax, eax
364	mov [dir_addr], eax	382	mov [dir_addr], eax
365		383
366	mov eax, [app_size]	384	mov eax, [app_size]
367	add eax, 4095	385	add eax, 4095
368	and eax, NOT(4095)	386	and eax, NOT(4095)
369	mov [app_size], eax	387	mov [app_size], eax
370	mov ebx, eax	388	mov ebx, eax
371	shr eax, 12	389	shr eax, 12
372	mov [app_pages], eax	390	mov [app_pages], eax
373		391
374	add ebx, 0x3FFFFF	392	add ebx, 0x3FFFFF
375	and ebx, NOT(0x3FFFFF)	393	and ebx, NOT(0x3FFFFF)
376	shr ebx, 22	394	shr ebx, 22
377	mov [app_tabs], ebx	395	mov [app_tabs], ebx
378		396
379	mov ecx, [img_size]	397	mov ecx, [img_size]
380	add ecx, 4095	398	add ecx, 4095
381	and ecx, NOT(4095)	399	and ecx, NOT(4095)
382		400
383	mov [img_size], ecx	401	mov [img_size], ecx
384	shr ecx, 12	402	shr ecx, 12
385	mov [img_pages], ecx	403	mov [img_pages], ecx
386		404
387	if GREEDY_KERNEL	405	if GREEDY_KERNEL
388	lea eax, [ecx+ebx+2];only image size	406	lea eax, [ecx+ebx+2];only image size
389	else	407	else
390	lea eax, [eax+ebx+2];all requested memory	408	lea eax, [eax+ebx+2];all requested memory
391	end if	409	end if
392	cmp eax, [pg_data.pages_free]	410	cmp eax, [pg_data.pages_free]
393	ja .fail	411	ja .fail
394		412
395	call alloc_page	413	call alloc_page
396	test eax, eax	414	test eax, eax
397	jz .fail	415	jz .fail
398	mov [dir_addr], eax	416	mov [dir_addr], eax
399	stdcall map_page, [tmp_task_pdir], eax, dword PG_SW	417	stdcall map_page, [tmp_task_pdir], eax, dword PG_SW
400		418
401	mov edi, [tmp_task_pdir]	419	mov edi, [tmp_task_pdir]
402	mov ecx, (OS_BASE shr 20)/4	420	mov ecx, (OS_BASE shr 20)/4
403	xor eax, eax	421	xor eax, eax
404	cld	422	cld
405	rep stosd	423	rep stosd
406		424
407	mov ecx, (OS_BASE shr 20)/4	425	mov ecx, (OS_BASE shr 20)/4
408	mov esi, sys_pgdir+(OS_BASE shr 20)	426	mov esi, sys_pgdir+(OS_BASE shr 20)
409	rep movsd	427	rep movsd
410		428
411	mov eax, [dir_addr]	429	mov eax, [dir_addr]
412	or eax, PG_SW	430	or eax, PG_SW
413	mov [edi-4096+(page_tabs shr 20)], eax	431	mov [edi-4096+(page_tabs shr 20)], eax
414		432
415	and eax, -4096	433	and eax, -4096
416	call set_cr3	434	call set_cr3
417		435
418	mov edx, [app_tabs]	436	mov edx, [app_tabs]
419	mov edi, new_app_base	437	mov edi, new_app_base
420	@@:	438	@@:
421	call alloc_page	439	call alloc_page
422	test eax, eax	440	test eax, eax
423	jz .fail	441	jz .fail
424		442
425	stdcall map_page_table, edi, eax	443	stdcall map_page_table, edi, eax
426	add edi, 0x00400000	444	add edi, 0x00400000
427	dec edx	445	dec edx
428	jnz @B	446	jnz @B
429		447
430	mov edi, new_app_base	448	mov edi, new_app_base
431	shr edi, 10	449	shr edi, 10
432	add edi, page_tabs	450	add edi, page_tabs
433		451
434	mov ecx, [app_tabs]	452	mov ecx, [app_tabs]
435	shl ecx, 10	453	shl ecx, 10
436	xor eax, eax	454	xor eax, eax
437	rep stosd	455	rep stosd
438		456
439	mov ecx, [img_pages]	457	mov ecx, [img_pages]
440	mov ebx, PG_UW	458	mov ebx, PG_UW
441	mov edx, new_app_base	459	mov edx, new_app_base
442	mov esi, [img_base]	460	mov esi, [img_base]
443	mov edi, new_app_base	461	mov edi, new_app_base
444	shr esi, 10	462	shr esi, 10
445	shr edi, 10	463	shr edi, 10
446	add esi, page_tabs	464	add esi, page_tabs
447	add edi, page_tabs	465	add edi, page_tabs
448	.remap:	466	.remap:
449	lodsd	467	lodsd
450	or eax, ebx; force user level r/w access	468	or eax, ebx; force user level r/w access
451	stosd	469	stosd
452	add edx, 0x1000	470	add edx, 0x1000
453	dec [app_pages]	471	dec [app_pages]
454	dec ecx	472	dec ecx
455	jnz .remap	473	jnz .remap
456		474
457	mov ecx, [app_pages]	475	mov ecx, [app_pages]
458	test ecx, ecx	476	test ecx, ecx
459	jz .done	477	jz .done
460		478
461	if GREEDY_KERNEL	479	if GREEDY_KERNEL
462	mov eax, 0x02	480	mov eax, 0x02
463	rep stosd	481	rep stosd
464	else	482	else
465		483
466	.alloc:	484	.alloc:
467	call alloc_page	485	call alloc_page
468	test eax, eax	486	test eax, eax
469	jz .fail	487	jz .fail
470		488
471	stdcall map_page, edx, eax, dword PG_UW	489	stdcall map_page, edx, eax, dword PG_UW
472	add edx, 0x1000	490	add edx, 0x1000
473	dec [app_pages]	491	dec [app_pages]
474	jnz .alloc	492	jnz .alloc
475	end if	493	end if
476		494
477	.done:	495	.done:
478	stdcall map_page, [tmp_task_pdir], dword 0, dword PG_UNMAP	496	stdcall map_page, [tmp_task_pdir], dword 0, dword PG_UNMAP
479		497
480	mov ecx, pg_data.mutex	498	mov ecx, pg_data.mutex
481	call mutex_unlock	499	call mutex_unlock
482	mov eax, [dir_addr]	500	mov eax, [dir_addr]

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/taskman.inc – Rev 2385 → 2540