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: 5356 $
 
 
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], 3      ;reserve handles for stdin stdout and stderr
        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_SWR
        mov     [edi-4096+(page_tabs shr 20)], eax
 
        lea     eax, [edi-8192]
        call    set_cr3
 
        mov     edx, [app_tabs]
        xor     edi, edi
@@:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page_table, edi, eax
        add     edi, 0x00400000
        dec     edx
        jnz     @B
 
        mov     edi, page_tabs
 
        mov     ecx, [app_tabs]
        shl     ecx, 10
        xor     eax, eax
        rep stosd
 
        mov     ecx, [img_pages]
        mov     ebx, PG_UWR
        xor     edx, edx
        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
        dec     [app_pages]
        dec     ecx
        jnz     .remap
 
        mov     ecx, [app_pages]
        test    ecx, ecx
        jz      .done
 
.alloc:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page, edx, eax, dword PG_UWR
        add     edx, 0x1000
        dec     [app_pages]
        jnz     .alloc
 
.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_SWR
        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_READ
        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_SWR
        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_workarea.right]
        mov     [ecx+8], eax
        mov     eax, [screen_workarea.bottom]
        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 5350	Rev 5356
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: 5350 $	8	$Revision: 5356 $
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_proc 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 alloc_thread_slot	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, [current_process]	251	mov ebx, [current_process]
252	mov [save_proc], ebx	252	mov [save_proc], ebx
253		253
254	stdcall create_process, [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		258
259	mov ebx, [hdr_mem]	259	mov ebx, [hdr_mem]
260	mov [eax+PROC.mem_used], ebx	260	mov [eax+PROC.mem_used], ebx
261		261
262	mov ebx, [slot_base]	262	mov ebx, [slot_base]
263	mov [ebx+APPDATA.process], eax	263	mov [ebx+APPDATA.process], eax
264		264
265	lea edx, [ebx+APPDATA.list]	265	lea edx, [ebx+APPDATA.list]
266	lea ecx, [eax+PROC.thr_list]	266	lea ecx, [eax+PROC.thr_list]
267	list_add_tail edx, ecx	267	list_add_tail edx, ecx
268		268
269	xor edx, edx	269	xor edx, edx
270	cmp word [6], '02'	270	cmp word [6], '02'
271	jne @f	271	jne @f
272		272
273	not edx	273	not edx
274	@@:	274	@@:
275	mov [ebx+APPDATA.tls_base], edx	275	mov [ebx+APPDATA.tls_base], edx
276		276
277	if GREEDY_KERNEL	277	if GREEDY_KERNEL
278	else	278	else
279	mov ecx, [hdr_mem]	279	mov ecx, [hdr_mem]
280	mov edi, [file_size]	280	mov edi, [file_size]
281	add edi, 4095	281	add edi, 4095
282	and edi, not 4095	282	and edi, not 4095
283	sub ecx, edi	283	sub ecx, edi
284	jna @F	284	jna @F
285		285
286	xor eax, eax	286	xor eax, eax
287	cld	287	cld
288	rep stosb	288	rep stosb
289	@@:	289	@@:
290	end if	290	end if
291		291
292	; release only virtual space, not phisical memory	292	; release only virtual space, not phisical memory
293		293
294	stdcall free_kernel_space, [file_base]	294	stdcall free_kernel_space, [file_base]
295	lea eax, [hdr_cmdline]	295	lea eax, [hdr_cmdline]
296	lea ebx, [cmdline]	296	lea ebx, [cmdline]
297	lea ecx, [filename]	297	lea ecx, [filename]
298	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]	298	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
299		299
300	mov eax, [save_proc]	300	mov eax, [save_proc]
301	call set_cr3	301	call set_cr3
302		302
303	mov eax, [process_number];set result	303	mov eax, [process_number];set result
304	call unlock_application_table	304	call unlock_application_table
305		305
306	jmp .final	306	jmp .final
307		307
308	.failed:	308	.failed:
309	mov eax, [save_proc]	309	mov eax, [save_proc]
310	call set_cr3	310	call set_cr3
311	.err:	311	.err:
312	.err_hdr:	312	.err_hdr:
313	stdcall kernel_free, [file_base]	313	stdcall kernel_free, [file_base]
314	.err_file:	314	.err_file:
315	call unlock_application_table	315	call unlock_application_table
316	mov eax, esi	316	mov eax, esi
317	.final:	317	.final:
318	cmp [SCR_MODE], word 0x13	318	cmp [SCR_MODE], word 0x13
319	jbe @f	319	jbe @f
320	pushad	320	pushad
321	stdcall set_cursor, [handle]	321	stdcall set_cursor, [handle]
322	mov [redrawmouse_unconditional], 1	322	mov [redrawmouse_unconditional], 1
323	call wakeup_osloop	323	call wakeup_osloop
324	popad	324	popad
325	@@:	325	@@:
326	ret	326	ret
327	endp	327	endp
328		328
329	align 4	329	align 4
330	test_app_header:	330	test_app_header:
331	virtual at eax	331	virtual at eax
332	APP_HEADER_00 APP_HEADER_00_	332	APP_HEADER_00 APP_HEADER_00_
333	end virtual	333	end virtual
334	virtual at eax	334	virtual at eax
335	APP_HEADER_01 APP_HEADER_01_	335	APP_HEADER_01 APP_HEADER_01_
336	end virtual	336	end virtual
337		337
338	cmp dword [eax], 'MENU'	338	cmp dword [eax], 'MENU'
339	jne .fail	339	jne .fail
340	cmp word [eax+4], 'ET'	340	cmp word [eax+4], 'ET'
341	jne .fail	341	jne .fail
342		342
343	cmp [eax+6], word '00'	343	cmp [eax+6], word '00'
344	jne .check_01_header	344	jne .check_01_header
345		345
346	mov ecx, [APP_HEADER_00.start]	346	mov ecx, [APP_HEADER_00.start]
347	mov [ebx+0x08], ecx ;app_eip	347	mov [ebx+0x08], ecx ;app_eip
348	mov edx, [APP_HEADER_00.mem_size]	348	mov edx, [APP_HEADER_00.mem_size]
349	mov [ebx+0x10], edx ;app_mem	349	mov [ebx+0x10], edx ;app_mem
350	shr edx, 1	350	shr edx, 1
351	sub edx, 0x10	351	sub edx, 0x10
352	mov [ebx+0x0C], edx ;app_esp	352	mov [ebx+0x0C], edx ;app_esp
353	mov ecx, [APP_HEADER_00.i_param]	353	mov ecx, [APP_HEADER_00.i_param]
354	mov [ebx], ecx ;app_cmdline	354	mov [ebx], ecx ;app_cmdline
355	mov [ebx+4], dword 0 ;app_path	355	mov [ebx+4], dword 0 ;app_path
356	mov edx, [APP_HEADER_00.i_end]	356	mov edx, [APP_HEADER_00.i_end]
357	mov [ebx+0x14], edx	357	mov [ebx+0x14], edx
358	ret	358	ret
359		359
360	.check_01_header:	360	.check_01_header:
361		361
362	cmp [eax+6], word '01'	362	cmp [eax+6], word '01'
363	je @f	363	je @f
364	cmp [eax+6], word '02'	364	cmp [eax+6], word '02'
365	jne .fail	365	jne .fail
366	@@:	366	@@:
367	mov ecx, [APP_HEADER_01.start]	367	mov ecx, [APP_HEADER_01.start]
368	mov [ebx+0x08], ecx ;app_eip	368	mov [ebx+0x08], ecx ;app_eip
369	mov edx, [APP_HEADER_01.mem_size]	369	mov edx, [APP_HEADER_01.mem_size]
370		370
371	; \begin{diamond}[20.08.2006]	371	; \begin{diamond}[20.08.2006]
372	; 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
373	; fit in allocated memory to prevent kernel faults)	373	; fit in allocated memory to prevent kernel faults)
374	cmp edx, [APP_HEADER_01.i_end]	374	cmp edx, [APP_HEADER_01.i_end]
375	jb .fail	375	jb .fail
376	; \end{diamond}[20.08.2006]	376	; \end{diamond}[20.08.2006]
377		377
378	mov [ebx+0x10], edx ;app_mem	378	mov [ebx+0x10], edx ;app_mem
379	mov ecx, [APP_HEADER_01.stack_top]	379	mov ecx, [APP_HEADER_01.stack_top]
380	mov [ebx+0x0C], ecx ;app_esp	380	mov [ebx+0x0C], ecx ;app_esp
381	mov edx, [APP_HEADER_01.i_param]	381	mov edx, [APP_HEADER_01.i_param]
382	mov [ebx], edx ;app_cmdline	382	mov [ebx], edx ;app_cmdline
383	mov ecx, [APP_HEADER_01.i_icon]	383	mov ecx, [APP_HEADER_01.i_icon]
384	mov [ebx+4], ecx ;app_path	384	mov [ebx+4], ecx ;app_path
385	mov edx, [APP_HEADER_01.i_end]	385	mov edx, [APP_HEADER_01.i_end]
386	mov [ebx+0x14], edx	386	mov [ebx+0x14], edx
387	ret	387	ret
388	.fail:	388	.fail:
389	xor eax, eax	389	xor eax, eax
390	ret	390	ret
391		391
392	align 4	392	align 4
393	alloc_thread_slot:	393	alloc_thread_slot:
394	;input:	394	;input:
395	; none	395	; none
396	;result:	396	;result:
397	; eax=[new_thread_slot]<>0 - ok	397	; eax=[new_thread_slot]<>0 - ok
398	; 0 - failed.	398	; 0 - failed.
399	;This function find least empty slot.	399	;This function find least empty slot.
400	;It doesn't increase [TASK_COUNT]!	400	;It doesn't increase [TASK_COUNT]!
401		401
402		402
403	mov edx, thr_slot_map	403	mov edx, thr_slot_map
404	pushfd	404	pushfd
405	cli	405	cli
406	.l1:	406	.l1:
407	bsf eax, [edx]	407	bsf eax, [edx]
408	jnz .found	408	jnz .found
409	add edx, 4	409	add edx, 4
410	cmp edx, thr_slot_map+32	410	cmp edx, thr_slot_map+32
411	jb .l1	411	jb .l1
412		412
413	popfd	413	popfd
414	xor eax, eax	414	xor eax, eax
415	ret	415	ret
416	.found:	416	.found:
417	btr [edx], eax	417	btr [edx], eax
418	sub edx, thr_slot_map	418	sub edx, thr_slot_map
419	lea eax, [eax+edx*8]	419	lea eax, [eax+edx*8]
420	popfd	420	popfd
421	ret	421	ret
422		422
423		423
424	align 4	424	align 4
425	proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword	425	proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
426	locals	426	locals
427	app_pages dd ?	427	app_pages dd ?
428	img_pages dd ?	428	img_pages dd ?
429	process dd ?	429	process dd ?
430	app_tabs dd ?	430	app_tabs dd ?
431	endl	431	endl
432		432
433	push ebx	433	push ebx
434	push esi	434	push esi
435	push edi	435	push edi
436		436
437	mov ecx, pg_data.mutex	437	mov ecx, pg_data.mutex
438	call mutex_lock	438	call mutex_lock
439		439
440	xor eax, eax	440	xor eax, eax
441	mov [process], eax	441	mov [process], eax
442		442
443	mov eax, [app_size]	443	mov eax, [app_size]
444	add eax, 4095	444	add eax, 4095
445	and eax, NOT(4095)	445	and eax, NOT(4095)
446	mov [app_size], eax	446	mov [app_size], eax
447	mov ebx, eax	447	mov ebx, eax
448	shr eax, 12	448	shr eax, 12
449	mov [app_pages], eax	449	mov [app_pages], eax
450		450
451	add ebx, 0x3FFFFF	451	add ebx, 0x3FFFFF
452	and ebx, NOT(0x3FFFFF)	452	and ebx, NOT(0x3FFFFF)
453	shr ebx, 22	453	shr ebx, 22
454	mov [app_tabs], ebx	454	mov [app_tabs], ebx
455		455
456	mov ecx, [img_size]	456	mov ecx, [img_size]
457	add ecx, 4095	457	add ecx, 4095
458	and ecx, NOT(4095)	458	and ecx, NOT(4095)
459		459
460	mov [img_size], ecx	460	mov [img_size], ecx
461	shr ecx, 12	461	shr ecx, 12
462	mov [img_pages], ecx	462	mov [img_pages], ecx
463		463
464	lea eax, [eax+ebx+2];all requested memory	464	lea eax, [eax+ebx+2];all requested memory
465		465
466	cmp eax, [pg_data.pages_free]	466	cmp eax, [pg_data.pages_free]
467	ja .fail	467	ja .fail
468		468
469	stdcall kernel_alloc, 0x2000	469	stdcall kernel_alloc, 0x2000
470	test eax, eax	470	test eax, eax
471	jz .fail	471	jz .fail
472	mov [process], eax	472	mov [process], eax
473		473
474	lea edi, [eax+PROC.heap_lock]	474	lea edi, [eax+PROC.heap_lock]
475	mov ecx, (PROC.ht_next-PROC.heap_lock)/4	475	mov ecx, (PROC.ht_next-PROC.heap_lock)/4
476		476
477	list_init eax	477	list_init eax
478	add eax, PROC.thr_list	478	add eax, PROC.thr_list
479	list_init eax	479	list_init eax
480		480
481	xor eax, eax	481	xor eax, eax
482	cld	482	cld
483	rep stosd	483	rep stosd
484		484
485	mov ecx, (PROC.pdt_0 - PROC.htab)/4	485	mov ecx, (PROC.pdt_0 - PROC.htab)/4
486	@@:	486	@@:
487	stosd	487	stosd
488	inc eax	488	inc eax
489	cmp eax, ecx	489	cmp eax, ecx
490	jbe @B	490	jbe @B
491		491
492	mov [edi-4096+PROC.ht_next], 3 ;reserve handles for stdin stdout and stderr	492	mov [edi-4096+PROC.ht_next], 3 ;reserve handles for stdin stdout and stderr
493	mov eax, edi	493	mov eax, edi
494	call get_pg_addr	494	call get_pg_addr
495	mov [edi-4096+PROC.pdt_0_phys], eax	495	mov [edi-4096+PROC.pdt_0_phys], eax
496		496
497	mov ecx, (OS_BASE shr 20)/4	497	mov ecx, (OS_BASE shr 20)/4
498	xor eax, eax	498	xor eax, eax
499	rep stosd	499	rep stosd
500		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 5350 → 5356