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: 4288 $
 
 
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_cr3      dd ?
         slot          dd ?
         slot_base     dd ?
         file_base     dd ?
         file_size     dd ?
         handle        dd ? ;temp. for default cursor handle for curr. thread
                      ;app header data
         hdr_cmdline   dd ? ;0x00
         hdr_path      dd ? ;0x04
         hdr_eip       dd ? ;0x08
         hdr_esp       dd ? ;0x0C
         hdr_mem       dd ? ;0x10
         hdr_i_end     dd ? ;0x14
       endl
 
        pushad
 
        cmp     [SCR_MODE], word 0x13
        jbe     @f
        pushad
        stdcall set_cursor, [def_cursor_clock]
        mov     [handle], eax
        mov     [redrawmouse_unconditional], 1
        call    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    get_new_process_place
        test    eax, eax
        mov     esi, -0x20 ; too many processes
        jz      .err
 
        mov     [slot], eax
        shl     eax, 8
        add     eax, SLOT_BASE
        mov     [slot_base], eax
        mov     edi, eax
       _clear_ 256     ;clean extended information about process
 
; write application name
        lea     eax, [filename]
        stdcall strrchr, eax, '/'  ; now eax points to name without path
 
        lea     esi, [eax+1]
        test    eax, eax
        jnz     @F
        lea     esi, [filename]
@@:
        mov     ecx, 11 ; 11 chars for name! 8 - is old value!
        mov     edi, [slot_base]
.copy_process_name_loop:
        lodsb
        cmp     al, '.'
        jz      .copy_process_name_done
        test    al, al
        jz      .copy_process_name_done
        stosb
        loop    .copy_process_name_loop
.copy_process_name_done:
 
        mov     ebx, cr3
        mov     [save_cr3], ebx
 
        stdcall create_app_space, [hdr_mem], [file_base], [file_size]
        mov     esi, -30; no memory
        test    eax, eax
        jz      .failed
 
        mov     ebx, [slot_base]
        mov     [ebx+APPDATA.dir_table], eax
        mov     eax, [hdr_mem]
        mov     [ebx+APPDATA.mem_size], eax
 
        xor     edx, edx
        cmp     word [6], '02'
        jne     @f
 
        not     edx
@@:
        mov     [ebx+APPDATA.tls_base], edx
 
if GREEDY_KERNEL
else
        mov     ecx, [hdr_mem]
        mov     edi, [file_size]
        add     edi, 4095
        and     edi, not 4095
        sub     ecx, edi
        jna     @F
 
        xor     eax, eax
        cld
        rep stosb
@@:
end if
 
; release only virtual space, not phisical memory
 
        stdcall free_kernel_space, [file_base]
        lea     eax, [hdr_cmdline]
        lea     ebx, [cmdline]
        lea     ecx, [filename]
        stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
 
        mov     eax, [save_cr3]
        call    set_cr3
 
        mov     eax, [process_number];set result
        call    unlock_application_table
 
        jmp     .final
 
.failed:
        mov     eax, [save_cr3]
        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
proc get_new_process_place
;input:
;  none
;result:
;  eax=[new_process_place]<>0 - ok
;      0 - failed.
;This function find least empty slot.
;It doesn't increase [TASK_COUNT]!
        mov     eax, CURRENT_TASK
        mov     ebx, [TASK_COUNT]
        inc     ebx
        shl     ebx, 5
        add     ebx, eax    ;ebx - address of process information for (last+1) slot
.newprocessplace:
;eax = address of process information for current slot
        cmp     eax, ebx
        jz      .endnewprocessplace ;empty slot after high boundary
        add     eax, 0x20
        cmp     word [eax+0xa], 9;check process state, 9 means that process slot is empty
        jnz     .newprocessplace
.endnewprocessplace:
        mov     ebx, eax
        sub     eax, CURRENT_TASK
        shr     eax, 5      ;calculate slot index
        cmp     eax, 256
        jge     .failed     ;it should be <256
        mov     word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)
        ret
.failed:
        xor     eax, eax
        ret
endp
 
align 4
proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
       locals
         app_pages   dd ?
         img_pages   dd ?
         dir_addr    dd ?
         app_tabs    dd ?
       endl
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        xor     eax, eax
        mov     [dir_addr], eax
 
        mov     eax, [app_size]
        add     eax, 4095
        and     eax, NOT(4095)
        mov     [app_size], eax
        mov     ebx, eax
        shr     eax, 12
        mov     [app_pages], eax
 
        add     ebx, 0x3FFFFF
        and     ebx, NOT(0x3FFFFF)
        shr     ebx, 22
        mov     [app_tabs], ebx
 
        mov     ecx, [img_size]
        add     ecx, 4095
        and     ecx, NOT(4095)
 
        mov     [img_size], ecx
        shr     ecx, 12
        mov     [img_pages], ecx
 
if GREEDY_KERNEL
        lea     eax, [ecx+ebx+2];only image size
else
        lea     eax, [eax+ebx+2];all requested memory
end if
        cmp     eax, [pg_data.pages_free]
        ja      .fail
 
        call    alloc_page
        test    eax, eax
        jz      .fail
        mov     [dir_addr], eax
        stdcall map_page, [tmp_task_pdir], eax, dword PG_SW
 
        mov     edi, [tmp_task_pdir]
        mov     ecx, (OS_BASE shr 20)/4
        xor     eax, eax
        cld
        rep stosd
 
        mov     ecx, (OS_BASE shr 20)/4
        mov     esi, sys_pgdir+(OS_BASE shr 20)
        rep movsd
 
        mov     eax, [dir_addr]
        or      eax, PG_SW
        mov     [edi-4096+(page_tabs shr 20)], eax
 
        and     eax, -4096
        call    set_cr3
 
        mov     edx, [app_tabs]
        mov     edi, new_app_base
@@:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page_table, edi, eax
        add     edi, 0x00400000
        dec     edx
        jnz     @B
 
        mov     edi, new_app_base
        shr     edi, 10
        add     edi, page_tabs
 
        mov     ecx, [app_tabs]
        shl     ecx, 10
        xor     eax, eax
        rep stosd
 
        mov     ecx, [img_pages]
        mov     ebx, PG_UW
        mov     edx, new_app_base
        mov     esi, [img_base]
        mov     edi, new_app_base
        shr     esi, 10
        shr     edi, 10
        add     esi, page_tabs
        add     edi, page_tabs
.remap:
        lodsd
        or      eax, ebx; force user level r/w access
        stosd
        add     edx, 0x1000
        dec     [app_pages]
        dec     ecx
        jnz     .remap
 
        mov     ecx, [app_pages]
        test    ecx, ecx
        jz      .done
 
if GREEDY_KERNEL
        mov     eax, 0x02
        rep stosd
else
 
.alloc:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page, edx, eax, dword PG_UW
        add     edx, 0x1000
        dec     [app_pages]
        jnz     .alloc
end if
 
.done:
        stdcall map_page, [tmp_task_pdir], dword 0, dword PG_UNMAP
 
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        mov     eax, [dir_addr]
        ret
.fail:
        mov     ecx, pg_data.mutex
        call    mutex_unlock
        cmp     [dir_addr], 0
        je      @f
        stdcall destroy_app_space, [dir_addr], 0
@@:
        xor     eax, eax
        ret
endp
 
align 4
set_cr3:
 
        mov     ebx, [current_slot]
        mov     [ebx+APPDATA.dir_table], eax
        mov     cr3, eax
        ret
 
align 4
proc destroy_page_table stdcall, pg_tab:dword
 
        push    esi
 
        mov     esi, [pg_tab]
        mov     ecx, 1024
.free:
        mov     eax, [esi]
        test    eax, 1
        jz      .next
        test    eax, 1 shl 9
        jnz     .next                     ;skip shared pages
        call    free_page
.next:
        add     esi, 4
        dec     ecx
        jnz     .free
        pop     esi
        ret
endp
 
align 4
proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword
 
        xor     edx, edx
        push    edx
        mov     eax, 0x1
        mov     ebx, [pg_dir]
.loop:
;eax = current slot of process
        mov     ecx, eax
        shl     ecx, 5
        cmp     byte [CURRENT_TASK+ecx+0xa], 9;if process running?
        jz      @f           ;skip empty slots
        shl     ecx, 3
        add     ecx, SLOT_BASE
        cmp     [ecx+APPDATA.dir_table], ebx;compare page directory addresses
        jnz     @f
        mov     [ebp-4], ecx
        inc     edx             ;thread found
@@:
        inc     eax
        cmp     eax, [TASK_COUNT]   ;exit loop if we look through all processes
        jle     .loop
 
;edx = number of threads
;our process is zombi so it isn't counted
        pop     ecx
        cmp     edx, 1
        jg      .ret
;if there isn't threads then clear memory.
        mov     esi, [dlls_list]
        call    destroy_all_hdlls;ecx=APPDATA
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        mov     eax, [pg_dir]
        and     eax, not 0xFFF
        stdcall map_page, [tmp_task_pdir], eax, PG_SW
        mov     esi, [tmp_task_pdir]
        mov     edi, (OS_BASE shr 20)/4
.destroy:
        mov     eax, [esi]
        test    eax, 1
        jz      .next
        and     eax, not 0xFFF
        stdcall map_page, [tmp_task_ptab], eax, PG_SW
        stdcall destroy_page_table, [tmp_task_ptab]
        mov     eax, [esi]
        call    free_page
.next:
        add     esi, 4
        dec     edi
        jnz     .destroy
 
        mov     eax, [pg_dir]
        call    free_page
.exit:
        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
        stdcall map_page, [tmp_task_pdir], 0, PG_UNMAP
        mov     ecx, pg_data.mutex
        call    mutex_unlock
.ret:
        ret
endp
 
align 4
get_pid:
        mov     eax, [TASK_BASE]
        mov     eax, [eax+TASKDATA.pid]
        ret
 
pid_to_slot:
;Input:
;  eax - pid of process
;Output:
;  eax - slot of process or 0 if process don't exists
;Search process by PID.
        push    ebx
        push    ecx
        mov     ebx, [TASK_COUNT]
        shl     ebx, 5
        mov     ecx, 2*32
 
.loop:
;ecx=offset of current process info entry
;ebx=maximum permitted offset
        cmp     byte [CURRENT_TASK+ecx+0xa], 9
        jz      .endloop ;skip empty slots
        cmp     [CURRENT_TASK+ecx+0x4], eax;check PID
        jz      .pid_found
.endloop:
        add     ecx, 32
        cmp     ecx, ebx
        jle     .loop
 
        pop     ecx
        pop     ebx
        xor     eax, eax
        ret
 
.pid_found:
        shr     ecx, 5
        mov     eax, ecx ;convert offset to index of slot
        pop     ecx
        pop     ebx
        ret
 
check_region:
;input:
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
        mov     eax, [CURRENT_TASK]
;     jmp  check_process_region
;-----------------------------------------------------------------------------
;check_process_region:
;input:
;  eax - slot
;  esi - start of buffer
;  edx - size of buffer
;result:
;  eax = 1 region lays in app memory
;  eax = 0 region don't lays in app memory
 
        test    edx, edx
        jle     .ok
        shl     eax, 5
        cmp     word [CURRENT_TASK+eax+0xa], 0
        jnz     .failed
        shl     eax, 3
        mov     eax, [SLOT_BASE+eax+0xb8]
        test    eax, eax
        jz      .failed
 
        mov     eax, 1
        ret
 
 
;    call MEM_Get_Linear_Address
;    push ebx
;    push ecx
;    push edx
;    mov  edx,ebx
;    and  edx,not (4096-1)
;    sub  ebx,edx
;    add  ecx,ebx
;    mov  ebx,edx
;    add  ecx,(4096-1)
;    and  ecx,not (4096-1)
;.loop:
;;eax - linear address of page directory
;;ebx - current page
;;ecx - current size
;    mov  edx,ebx
;    shr  edx,22
;    mov  edx,[eax+4*edx]
;    and  edx,not (4096-1)
;    test edx,edx
;    jz   .failed1
;    push eax
;    mov  eax,edx
;    call MEM_Get_Linear_Address
;    mov  edx,ebx
;    shr  edx,12
;    and  edx,(1024-1)
;    mov  eax,[eax+4*edx]
;    and  eax,not (4096-1)
;    test eax,eax
;    pop  eax
;    jz   .failed1
;    add  ebx,4096
;    sub  ecx,4096
;    jg   .loop
;    pop  edx
;    pop  ecx
;    pop  ebx
.ok:
        mov     eax, 1
        ret
;
;.failed1:
;    pop  edx
;    pop  ecx
;    pop  ebx
.failed:
        xor     eax, eax
        ret
 
align 4
proc read_process_memory
;Input:
;  eax - process slot
;  ecx - buffer address
;  edx - buffer size
;  esi - start address in other process
;Output:
;  eax - number of bytes read.
       locals
         slot   dd ?
         buff   dd ?
         r_count    dd ?
         offset dd ?
         tmp_r_cnt  dd ?
       endl
 
        mov     [slot], eax
        mov     [buff], ecx
        and     [r_count], 0
        mov     [tmp_r_cnt], edx
        mov     [offset], esi
 
        pushad
.read_mem:
        mov     edx, [offset]
        mov     ebx, [tmp_r_cnt]
 
        mov     ecx, 0x400000
        and     edx, 0x3FFFFF
        sub     ecx, edx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        cmp     ecx, 0x8000
        jna     @F
        mov     ecx, 0x8000
@@:
        mov     ebx, [offset]
 
        push    ecx
        stdcall map_memEx, [proc_mem_map], \
                [slot], ebx, ecx, PG_MAP
        pop     ecx
 
        mov     esi, [offset]
        and     esi, 0xfff
        sub     eax, esi
        jbe     .ret
        cmp     ecx, eax
        jbe     @f
        mov     ecx, eax
        mov     [tmp_r_cnt], eax
@@:
        add     esi, [proc_mem_map]
        mov     edi, [buff]
        mov     edx, ecx
        rep movsb
        add     [r_count], edx
 
        add     [offset], edx
        sub     [tmp_r_cnt], edx
        jnz     .read_mem
.ret:
        popad
        mov     eax, [r_count]
        ret
endp
 
align 4
proc write_process_memory
;Input:
;  eax - process slot
;  ecx - buffer address
;  edx - buffer size
;  esi - start address in other process
;Output:
;  eax - number of bytes written
 
       locals
         slot   dd ?
         buff   dd ?
         w_count    dd ?
         offset dd ?
         tmp_w_cnt  dd ?
       endl
 
        mov     [slot], eax
        mov     [buff], ecx
        and     [w_count], 0
        mov     [tmp_w_cnt], edx
        mov     [offset], esi
 
        pushad
.read_mem:
        mov     edx, [offset]
        mov     ebx, [tmp_w_cnt]
 
        mov     ecx, 0x400000
        and     edx, 0x3FFFFF
        sub     ecx, edx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        cmp     ecx, 0x8000
        jna     @F
        mov     ecx, 0x8000
@@:
        mov     ebx, [offset]
      ;     add ebx, new_app_base
        push    ecx
        stdcall map_memEx, [proc_mem_map], \
                [slot], ebx, ecx, PG_SW
        pop     ecx
 
        mov     edi, [offset]
        and     edi, 0xfff
        sub     eax, edi
        jbe     .ret
        cmp     ecx, eax
        jbe     @f
        mov     ecx, eax
        mov     [tmp_w_cnt], eax
@@:
        add     edi, [proc_mem_map]
        mov     esi, [buff]
        mov     edx, ecx
        rep movsb
 
        add     [w_count], edx
        add     [offset], edx
        sub     [tmp_w_cnt], edx
        jnz     .read_mem
.ret:
        popad
        mov     eax, [w_count]
        ret
endp
 
;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    get_new_process_place
        test    eax, eax
        jz      .failed
 
        mov     [slot], eax
 
        mov     esi, [current_slot]
        mov     ebx, esi      ;ebx=esi - pointer to extended information about current thread
 
        mov     edi, eax
        shl     edi, 8
        add     edi, SLOT_BASE
        mov     edx, edi      ;edx=edi - pointer to extended infomation about new thread
        mov     ecx, 256/4
        xor     eax, eax
        cld
        rep stosd             ;clean extended information about new thread
        mov     esi, ebx
        mov     edi, edx
        mov     ecx, 11
        rep movsb             ;copy process name
 
        mov     eax, [ebx+APPDATA.heap_base]
        mov     [edx+APPDATA.heap_base], eax
 
        mov     ecx, [ebx+APPDATA.heap_top]
        mov     [edx+APPDATA.heap_top], ecx
 
        mov     eax, [ebx+APPDATA.mem_size]
        mov     [edx+APPDATA.mem_size], eax
 
        mov     ecx, [ebx+APPDATA.dir_table]
        mov     [edx+APPDATA.dir_table], ecx;copy page directory
 
        mov     eax, [ebx+APPDATA.dlls_list_ptr]
        mov     [edx+APPDATA.dlls_list_ptr], eax
 
        mov     eax, [ebx+APPDATA.tls_base]
        test    eax, eax
        jz      @F
 
        push    edx
        stdcall user_alloc, 4096
        pop     edx
        test    eax, eax
        jz      .failed1;eax=0
@@:
        mov     [edx+APPDATA.tls_base], eax
 
        lea     eax, [app_cmdline]
        stdcall set_app_params , [slot], eax, dword 0, \
                dword 0, [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, [_display.width]
        mov     [ecx+8], eax
        mov     eax, [_display.height]
        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 4265	Rev 4288
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: 4265 $	8	$Revision: 4288 $
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_cr3 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 get_new_process_place
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, cr3
252	mov [save_cr3], ebx	252	mov [save_cr3], ebx
253		253
254	stdcall create_app_space, [hdr_mem], [file_base], [file_size]	254	stdcall create_app_space, [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, [slot_base]	259	mov ebx, [slot_base]
260	mov [ebx+APPDATA.dir_table], eax	260	mov [ebx+APPDATA.dir_table], eax
261	mov eax, [hdr_mem]	261	mov eax, [hdr_mem]
262	mov [ebx+APPDATA.mem_size], eax	262	mov [ebx+APPDATA.mem_size], eax
263		263
264	xor edx, edx	264	xor edx, edx
265	cmp word [6], '02'	265	cmp word [6], '02'
266	jne @f	266	jne @f
267		267
268	not edx	268	not edx
269	@@:	269	@@:
270	mov [ebx+APPDATA.tls_base], edx	270	mov [ebx+APPDATA.tls_base], edx
271		271
272	if GREEDY_KERNEL	272	if GREEDY_KERNEL
273	else	273	else
274	mov ecx, [hdr_mem]	274	mov ecx, [hdr_mem]
275	mov edi, [file_size]	275	mov edi, [file_size]
276	add edi, 4095	276	add edi, 4095
277	and edi, not 4095	277	and edi, not 4095
278	sub ecx, edi	278	sub ecx, edi
279	jna @F	279	jna @F
280		280
281	xor eax, eax	281	xor eax, eax
282	cld	282	cld
283	rep stosb	283	rep stosb
284	@@:	284	@@:
285	end if	285	end if
286		286
287	; release only virtual space, not phisical memory	287	; release only virtual space, not phisical memory
288		288
289	stdcall free_kernel_space, [file_base]	289	stdcall free_kernel_space, [file_base]
290	lea eax, [hdr_cmdline]	290	lea eax, [hdr_cmdline]
291	lea ebx, [cmdline]	291	lea ebx, [cmdline]
292	lea ecx, [filename]	292	lea ecx, [filename]
293	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]	293	stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
294		294
295	mov eax, [save_cr3]	295	mov eax, [save_cr3]
296	call set_cr3	296	call set_cr3
297		297
298	mov eax, [process_number];set result	298	mov eax, [process_number];set result
299	call unlock_application_table	299	call unlock_application_table
300		300
301	jmp .final	301	jmp .final
302		302
303	.failed:	303	.failed:
304	mov eax, [save_cr3]	304	mov eax, [save_cr3]
305	call set_cr3	305	call set_cr3
306	.err:	306	.err:
307	.err_hdr:	307	.err_hdr:
308	stdcall kernel_free, [file_base]	308	stdcall kernel_free, [file_base]
309	.err_file:	309	.err_file:
310	call unlock_application_table	310	call unlock_application_table
311	mov eax, esi	311	mov eax, esi
312	.final:	312	.final:
313	cmp [SCR_MODE], word 0x13	313	cmp [SCR_MODE], word 0x13
314	jbe @f	314	jbe @f
315	pushad	315	pushad
316	stdcall set_cursor, [handle]	316	stdcall set_cursor, [handle]
317	mov [redrawmouse_unconditional], 1	317	mov [redrawmouse_unconditional], 1
318	call wakeup_osloop	318	call wakeup_osloop
319	popad	319	popad
320	@@:	320	@@:
321	ret	321	ret
322	endp	322	endp
323		323
324	align 4	324	align 4
325	test_app_header:	325	test_app_header:
326	virtual at eax	326	virtual at eax
327	APP_HEADER_00 APP_HEADER_00_	327	APP_HEADER_00 APP_HEADER_00_
328	end virtual	328	end virtual
329	virtual at eax	329	virtual at eax
330	APP_HEADER_01 APP_HEADER_01_	330	APP_HEADER_01 APP_HEADER_01_
331	end virtual	331	end virtual
332		332
333	cmp dword [eax], 'MENU'	333	cmp dword [eax], 'MENU'
334	jne .fail	334	jne .fail
335	cmp word [eax+4], 'ET'	335	cmp word [eax+4], 'ET'
336	jne .fail	336	jne .fail
337		337
338	cmp [eax+6], word '00'	338	cmp [eax+6], word '00'
339	jne .check_01_header	339	jne .check_01_header
340		340
341	mov ecx, [APP_HEADER_00.start]	341	mov ecx, [APP_HEADER_00.start]
342	mov [ebx+0x08], ecx ;app_eip	342	mov [ebx+0x08], ecx ;app_eip
343	mov edx, [APP_HEADER_00.mem_size]	343	mov edx, [APP_HEADER_00.mem_size]
344	mov [ebx+0x10], edx ;app_mem	344	mov [ebx+0x10], edx ;app_mem
345	shr edx, 1	345	shr edx, 1
346	sub edx, 0x10	346	sub edx, 0x10
347	mov [ebx+0x0C], edx ;app_esp	347	mov [ebx+0x0C], edx ;app_esp
348	mov ecx, [APP_HEADER_00.i_param]	348	mov ecx, [APP_HEADER_00.i_param]
349	mov [ebx], ecx ;app_cmdline	349	mov [ebx], ecx ;app_cmdline
350	mov [ebx+4], dword 0 ;app_path	350	mov [ebx+4], dword 0 ;app_path
351	mov edx, [APP_HEADER_00.i_end]	351	mov edx, [APP_HEADER_00.i_end]
352	mov [ebx+0x14], edx	352	mov [ebx+0x14], edx
353	ret	353	ret
354		354
355	.check_01_header:	355	.check_01_header:
356		356
357	cmp [eax+6], word '01'	357	cmp [eax+6], word '01'
358	je @f	358	je @f
359	cmp [eax+6], word '02'	359	cmp [eax+6], word '02'
360	jne .fail	360	jne .fail
361	@@:	361	@@:
362	mov ecx, [APP_HEADER_01.start]	362	mov ecx, [APP_HEADER_01.start]
363	mov [ebx+0x08], ecx ;app_eip	363	mov [ebx+0x08], ecx ;app_eip
364	mov edx, [APP_HEADER_01.mem_size]	364	mov edx, [APP_HEADER_01.mem_size]
365		365
366	; \begin{diamond}[20.08.2006]	366	; \begin{diamond}[20.08.2006]
367	; sanity check (functions 19,58 load app_i_end bytes and that must	367	; sanity check (functions 19,58 load app_i_end bytes and that must
368	; fit in allocated memory to prevent kernel faults)	368	; fit in allocated memory to prevent kernel faults)
369	cmp edx, [APP_HEADER_01.i_end]	369	cmp edx, [APP_HEADER_01.i_end]
370	jb .fail	370	jb .fail
371	; \end{diamond}[20.08.2006]	371	; \end{diamond}[20.08.2006]
372		372
373	mov [ebx+0x10], edx ;app_mem	373	mov [ebx+0x10], edx ;app_mem
374	mov ecx, [APP_HEADER_01.stack_top]	374	mov ecx, [APP_HEADER_01.stack_top]
375	mov [ebx+0x0C], ecx ;app_esp	375	mov [ebx+0x0C], ecx ;app_esp
376	mov edx, [APP_HEADER_01.i_param]	376	mov edx, [APP_HEADER_01.i_param]
377	mov [ebx], edx ;app_cmdline	377	mov [ebx], edx ;app_cmdline
378	mov ecx, [APP_HEADER_01.i_icon]	378	mov ecx, [APP_HEADER_01.i_icon]
379	mov [ebx+4], ecx ;app_path	379	mov [ebx+4], ecx ;app_path
380	mov edx, [APP_HEADER_01.i_end]	380	mov edx, [APP_HEADER_01.i_end]
381	mov [ebx+0x14], edx	381	mov [ebx+0x14], edx
382	ret	382	ret
383	.fail:	383	.fail:
384	xor eax, eax	384	xor eax, eax
385	ret	385	ret
386		386
387	align 4	387	align 4
388	proc get_new_process_place	388	proc get_new_process_place
389	;input:	389	;input:
390	; none	390	; none
391	;result:	391	;result:
392	; eax=[new_process_place]<>0 - ok	392	; eax=[new_process_place]<>0 - ok
393	; 0 - failed.	393	; 0 - failed.
394	;This function find least empty slot.	394	;This function find least empty slot.
395	;It doesn't increase [TASK_COUNT]!	395	;It doesn't increase [TASK_COUNT]!
396	mov eax, CURRENT_TASK	396	mov eax, CURRENT_TASK
397	mov ebx, [TASK_COUNT]	397	mov ebx, [TASK_COUNT]
398	inc ebx	398	inc ebx
399	shl ebx, 5	399	shl ebx, 5
400	add ebx, eax ;ebx - address of process information for (last+1) slot	400	add ebx, eax ;ebx - address of process information for (last+1) slot
401	.newprocessplace:	401	.newprocessplace:
402	;eax = address of process information for current slot	402	;eax = address of process information for current slot
403	cmp eax, ebx	403	cmp eax, ebx
404	jz .endnewprocessplace ;empty slot after high boundary	404	jz .endnewprocessplace ;empty slot after high boundary
405	add eax, 0x20	405	add eax, 0x20
406	cmp word [eax+0xa], 9;check process state, 9 means that process slot is empty	406	cmp word [eax+0xa], 9;check process state, 9 means that process slot is empty
407	jnz .newprocessplace	407	jnz .newprocessplace
408	.endnewprocessplace:	408	.endnewprocessplace:
409	mov ebx, eax	409	mov ebx, eax
410	sub eax, CURRENT_TASK	410	sub eax, CURRENT_TASK
411	shr eax, 5 ;calculate slot index	411	shr eax, 5 ;calculate slot index
412	cmp eax, 256	412	cmp eax, 256
413	jge .failed ;it should be <256	413	jge .failed ;it should be <256
414	mov word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)	414	mov word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)
415	ret	415	ret
416	.failed:	416	.failed:
417	xor eax, eax	417	xor eax, eax
418	ret	418	ret
419	endp	419	endp
420		420
421	align 4	421	align 4
422	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword	422	proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
423	locals	423	locals
424	app_pages dd ?	424	app_pages dd ?
425	img_pages dd ?	425	img_pages dd ?
426	dir_addr dd ?	426	dir_addr dd ?
427	app_tabs dd ?	427	app_tabs dd ?
428	endl	428	endl
429		429
430	mov ecx, pg_data.mutex	430	mov ecx, pg_data.mutex
431	call mutex_lock	431	call mutex_lock
432		432
433	xor eax, eax	433	xor eax, eax
434	mov [dir_addr], eax	434	mov [dir_addr], eax
435		435
436	mov eax, [app_size]	436	mov eax, [app_size]
437	add eax, 4095	437	add eax, 4095
438	and eax, NOT(4095)	438	and eax, NOT(4095)
439	mov [app_size], eax	439	mov [app_size], eax
440	mov ebx, eax	440	mov ebx, eax
441	shr eax, 12	441	shr eax, 12
442	mov [app_pages], eax	442	mov [app_pages], eax
443		443
444	add ebx, 0x3FFFFF	444	add ebx, 0x3FFFFF
445	and ebx, NOT(0x3FFFFF)	445	and ebx, NOT(0x3FFFFF)
446	shr ebx, 22	446	shr ebx, 22
447	mov [app_tabs], ebx	447	mov [app_tabs], ebx
448		448
449	mov ecx, [img_size]	449	mov ecx, [img_size]
450	add ecx, 4095	450	add ecx, 4095
451	and ecx, NOT(4095)	451	and ecx, NOT(4095)
452		452
453	mov [img_size], ecx	453	mov [img_size], ecx
454	shr ecx, 12	454	shr ecx, 12
455	mov [img_pages], ecx	455	mov [img_pages], ecx
456		456
457	if GREEDY_KERNEL	457	if GREEDY_KERNEL
458	lea eax, [ecx+ebx+2];only image size	458	lea eax, [ecx+ebx+2];only image size
459	else	459	else
460	lea eax, [eax+ebx+2];all requested memory	460	lea eax, [eax+ebx+2];all requested memory
461	end if	461	end if
462	cmp eax, [pg_data.pages_free]	462	cmp eax, [pg_data.pages_free]
463	ja .fail	463	ja .fail
464		464
465	call alloc_page	465	call alloc_page
466	test eax, eax	466	test eax, eax
467	jz .fail	467	jz .fail
468	mov [dir_addr], eax	468	mov [dir_addr], eax
469	stdcall map_page, [tmp_task_pdir], eax, dword PG_SW	469	stdcall map_page, [tmp_task_pdir], eax, dword PG_SW
470		470
471	mov edi, [tmp_task_pdir]	471	mov edi, [tmp_task_pdir]
472	mov ecx, (OS_BASE shr 20)/4	472	mov ecx, (OS_BASE shr 20)/4
473	xor eax, eax	473	xor eax, eax
474	cld	474	cld
475	rep stosd	475	rep stosd
476		476
477	mov ecx, (OS_BASE shr 20)/4	477	mov ecx, (OS_BASE shr 20)/4
478	mov esi, sys_pgdir+(OS_BASE shr 20)	478	mov esi, sys_pgdir+(OS_BASE shr 20)
479	rep movsd	479	rep movsd
480		480
481	mov eax, [dir_addr]	481	mov eax, [dir_addr]
482	or eax, PG_SW	482	or eax, PG_SW
483	mov [edi-4096+(page_tabs shr 20)], eax	483	mov [edi-4096+(page_tabs shr 20)], eax
484		484
485	and eax, -4096	485	and eax, -4096
486	call set_cr3	486	call set_cr3
487		487
488	mov edx, [app_tabs]	488	mov edx, [app_tabs]
489	mov edi, new_app_base	489	mov edi, new_app_base
490	@@:	490	@@:
491	call alloc_page	491	call alloc_page
492	test eax, eax	492	test eax, eax
493	jz .fail	493	jz .fail
494		494
495	stdcall map_page_table, edi, eax	495	stdcall map_page_table, edi, eax
496	add edi, 0x00400000	496	add edi, 0x00400000
497	dec edx	497	dec edx
498	jnz @B	498	jnz @B
499		499
500	mov edi, new_app_base	500	mov edi, new_app_base

Subversion Repositories Kolibri OS

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