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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc @ 2288 – Rev 2288 → 2384