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


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

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/taskman.inc – Rev 4423 → 5201