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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 3296 → 3325