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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 2455 → 2497