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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6332 $
 
 
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_HDR
        cmdline         rd 1    ;0x00
        path            rd 1    ;0x04
        eip             rd 1    ;0x08
        esp             rd 1    ;0x0C
        _edata          rd 1    ;0x10
        _emem           rd 1    ;0x14
        img_base        rd 1    ;0x18
        img_size        rd 1
        filename_size   rd 1
        cmdline_size    rd 1
ends
 
macro _clear_ op
{  mov ecx, op/4
        xor     eax, eax
        cld
        rep stosd
}
 
align 4
_strnlen:
        mov     edx, ecx
        xor     eax, eax
        repne scasb
        jne     @F
        inc     ecx
@@:
        mov     eax, edx
        sub     eax, ecx
        retn
 
fs_execute_from_sysdir:
        xor     ebx, ebx
fs_execute_from_sysdir_param:
        xor     edx, edx
 
align 4
proc fs_execute
; ebx - cmdline
; edx - flags
; ebp - full filename
 
       locals
         filename      rd 1
         cmdline       rd 1
         flags         rd 1
 
         slot          rd 1
         slot_base     rd 1
 
;app header data
 
         hdr_cmdline   rd 1 ;0x00
         hdr_path      rd 1 ;0x04
         hdr_eip       rd 1 ;0x08
         hdr_esp       rd 1 ;0x0C
         hdr_edata     rd 1 ;0x10
         hdr_emem      rd 1 ;0x14
         file_base     rd 1 ;0x18
         file_size     rd 1 ;0x1c
         filename_size rd 1 ;0x20
         cmdline_size  rd 1 ;0x24
 
       endl
 
        mov     eax, [ebp]
        mov     [flags], edx
        mov     [cmdline], ebx
        mov     [filename], eax
 
        mov     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
        mov     esi, -0x20 ; too many processes
        test    eax, eax
        jz      .err_0
 
        mov     [slot], eax
        shl     eax, 8
        lea     edi, [SLOT_BASE+eax]
        mov     [slot_base], edi
 
;clean extended information about process
        mov     ecx, 256/4
        xor     eax, eax
        cld
        rep stosd
 
; write application name
        stdcall strrchr, [filename], '/'  ; now eax points to name without path
 
        lea     esi, [eax+1]
        test    eax, eax
        jnz     @F
        mov     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     edi, [cmdline]
        xor     eax, eax
        test    edi, edi
        jz      @F
 
        mov     ecx, 65535
        call    _strnlen
        cmp     eax, 256
        jb      @F
        lea     ebx, [eax+1]
        add     [hdr_emem], ebx
@@:
        mov     [cmdline_size], eax
 
        stdcall create_process, [hdr_emem]
 
        mov     esi, -30; no memory
        test    eax, eax
        jz      .err_hdr
 
        mov     ebx, [sys_proc+LHEAD.prev]
        __list_add eax, ebx, sys_proc
 
        mov     ebx, [hdr_emem]
        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
 
        mov     esi, sizeof.APP_HDR
        add     esi, [cmdline_size]
 
        mov     edi, [filename]
        mov     ecx, 1023
        call    _strnlen
        add     esi, eax
        mov     [filename_size], eax
 
        stdcall kernel_alloc, esi
        mov     [ebx+APPDATA.exec_params], eax
        mov     edi, eax
        lea     esi, [hdr_cmdline]
        mov     ecx, sizeof.APP_HDR/4
        rep movsd
 
        mov     esi, [filename]
        mov     ecx, [filename_size]
        rep movsb
        mov     ecx, [cmdline_size]
        mov     esi, [cmdline]
        rep movsb
 
        lea     eax, [hdr_cmdline]
        stdcall set_app_params , [slot], eax, [flags]
 
        mov     eax, [process_number]       ;set result
        call    unlock_application_table
        ret
 
.err_0:
        call    unlock_application_table
 
.err_hdr:
        stdcall kernel_free, [file_base]
.err_file:
        mov     eax, esi
        ret
endp
 
align 4
test_app_header:
       virtual at eax
         APP_HEADER_00 APP_HEADER_00_
       end virtual
       virtual at eax
         APP_HEADER_01 APP_HEADER_01_
       end virtual
 
        cmp     dword [eax], 'MENU'
        jne     .fail
        cmp     word [eax+4], 'ET'
        jne     .fail
 
        cmp     [eax+6], word '00'
        jne     .check_01_header
 
        mov     ecx, [APP_HEADER_00.start]
        mov     [ebx+APP_HDR.eip], ecx
        mov     edx, [APP_HEADER_00.mem_size]
        mov     [ebx+APP_HDR._emem], edx
        shr     edx, 1
        sub     edx, 0x10
        mov     [ebx+APP_HDR.esp], edx
        mov     ecx, [APP_HEADER_00.i_param]
        mov     [ebx+APP_HDR.cmdline], ecx
        mov     [ebx+APP_HDR.path], 0
        mov     edx, [APP_HEADER_00.i_end]
        mov     [ebx+APP_HDR._edata], 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
        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+APP_HDR._emem], edx
        mov     ecx, [APP_HEADER_01.stack_top]
        mov     [ebx+APP_HDR.esp], ecx
        mov     edx, [APP_HEADER_01.i_param]
        mov     [ebx+APP_HDR.cmdline], edx
        mov     ecx, [APP_HEADER_01.i_icon]
        mov     [ebx+APP_HDR.path], ecx
        mov     edx, [APP_HEADER_01.i_end]
        mov     [ebx+APP_HDR._edata], 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
       locals
         process     dd ?
         app_tabs    dd ?
       endl
 
        push    ebx
        push    esi
        push    edi
 
        xor     eax, eax
        mov     [process], eax
 
        mov     eax, [app_size]
        add     eax, 0x3FFFFF
        shr     eax, 22
        mov     [app_tabs], eax
 
        stdcall kernel_alloc, 0x2000
        test    eax, eax
        jz      .fail
        mov     [process], eax
 
        lea     edi, [eax+PROC.heap_lock]
        mov     ecx, (PROC.ht_free-PROC.heap_lock)/4
 
        list_init eax
        add     eax, PROC.thr_list
        list_init eax
 
        xor     eax, eax
        cld
        rep stosd
 
        mov     [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
        mov     [edi+4], dword 3           ;reserve handles for stdin stdout and stderr
        mov     ecx, (PROC.pdt_0 - PROC.htab)/4
        add     edi, 8
        inc     eax
@@:
        stosd
        inc     eax
        cmp     eax, ecx
        jbe     @B
 
        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     edx, [edi-4096]
        mov     esi, [app_tabs]
 
.alloc_page_dir:
        call    alloc_page
        test    eax, eax
        jz      .fail
        or      eax, PG_UWR
        mov     [edx], eax
 
        mov     edi, [tmp_task_ptab]
        stdcall map_page, edi, eax, PG_SWR
        mov     ecx, 1024
        xor     eax, eax
        rep stosd
 
        add     edx, 4
        dec     esi
        jnz     .alloc_page_dir
 
        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
        mov     eax, [process]
 
        pop     edi
        pop     esi
        pop     ebx
        ret
.fail:
        mov     ecx, [process]
        jcxz    @F
 
        call destroy_process
@@:
        xor     eax, eax
        pop     edi
        pop     esi
        pop     ebx
        ret
endp
 
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
        list_del esi
 
        mov     esi, [esi+PROC.dlls_list_ptr]
        call    destroy_all_hdlls
 
        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
.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]
        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.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
 
        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
 
        lea     eax, [app_cmdline]
        stdcall set_app_params , [slot], eax, [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
 
proc map_process_image stdcall, img_size:dword, file_base:dword, file_size:dword
 
        mov     edx, [img_size]
        mov     esi, [file_base]
        mov     ecx, [file_size]
        add     edx, 4095
        add     ecx, 4095
        shr     edx, 12        ; total pages
        shr     ecx, 12        ; image pages
 
        mov     edi, page_tabs
        shr     esi, 10
        add     esi, edi
 
.map_image:
        lodsd
        and     eax, -4096
        or      eax, PG_UWR
        stosd
        dec     edx
        loop    .map_image
 
        test    edx, edx
        jz      .done
.map_bss:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        or      eax, PG_UWR
        stosd
        dec     edx
        jnz     .map_bss
 
        mov     edi, [file_size]
        mov     ecx, [img_size]
        add     edi, 4095
        and     edi, -4096
        add     ecx, 4095
        and     ecx, -4096
        sub     ecx, edi
        shr     ecx, 2
        xor     eax, eax
        rep stosd
 
.done:
.fail:
        ret
endp
 
align 4
common_app_entry:
 
        mov     ebp, [current_slot]
        mov     ebp, [ebp+APPDATA.exec_params]
        test    ebp, ebp
        jz      .exit
 
        stdcall map_process_image, [ebp+APP_HDR._emem],\
                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]
 
        xor     eax, eax
        mov     edi, [ebp+APP_HDR.path]
        lea     esi, [ebp+sizeof.APP_HDR]
        mov     ecx, [ebp+APP_HDR.filename_size]
        test    edi, edi
        jnz     .copy_filename
 
        add     esi, ecx
        jmp     .check_cmdline
 
.copy_filename:
        rep movsb
        stosb
 
.check_cmdline:
        mov     edi, [ebp+APP_HDR.cmdline]
        mov     ecx, [ebp+APP_HDR.cmdline_size]
        test    edi, edi
        jz      .check_tls_header
 
        cmp     ecx, 256
        jb      .copy_cmdline
 
        mov     edi, [ebp+APP_HDR._emem]
        add     edi, 4095
        and     edi, -4096
        sub     edi, ecx
        dec     edi
 
        cmp     word [6], '00'
        jne     @F
        mov     [APP_HEADER_00_.i_param], edi
        jmp     .copy_cmdline
@@:
        mov     [APP_HEADER_01_.i_param], edi
 
.copy_cmdline:
        rep movsb
        stosb
 
.check_tls_header:
 
        cmp     word [6], '02'
        jne     .cleanup
 
        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
 
.cleanup:
        stdcall free_kernel_space, [ebp+APP_HDR.img_base]
        stdcall kernel_free, ebp
.exit:
        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, 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     dword [CURRENT_TASK+ebx+0x10], 0
 
        mov     ebx, [slot]
        mov     eax, ebx
        shl     ebx, 5
        lea     ecx, [draw_data+ebx];ecx - pointer to draw data
 
; 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], dword common_app_entry
        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+APP_HDR.eip]
        mov     [ebx+REG_EIP], eax
        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+APP_HDR.esp]
        mov     [ebx+REG_APP_ESP], eax
        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 6319	Rev 6332
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. 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: 6319 $	8	$Revision: 6332 $
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	struct APP_HDR	33	struct APP_HDR
34	cmdline rd 1 ;0x00	34	cmdline rd 1 ;0x00
35	path rd 1 ;0x04	35	path rd 1 ;0x04
36	eip rd 1 ;0x08	36	eip rd 1 ;0x08
37	esp rd 1 ;0x0C	37	esp rd 1 ;0x0C
38	_edata rd 1 ;0x10	38	_edata rd 1 ;0x10
39	_emem rd 1 ;0x14	39	_emem rd 1 ;0x14
40	img_base rd 1 ;0x18	40	img_base rd 1 ;0x18
41	img_size rd 1	41	img_size rd 1
42	filename_size rd 1	42	filename_size rd 1
43	cmdline_size rd 1	43	cmdline_size rd 1
44	ends	44	ends
45		45
46	macro _clear_ op	46	macro _clear_ op
47	{ mov ecx, op/4	47	{ mov ecx, op/4
48	xor eax, eax	48	xor eax, eax
49	cld	49	cld
50	rep stosd	50	rep stosd
51	}	51	}
-		52
52		53	align 4
53	_strlen:	54	_strnlen:
54	mov ecx, 0xFFFFFFFF	55	mov edx, ecx
55	xor eax, eax	56	xor eax, eax
-		57	repne scasb
-		58	jne @F
-		59	inc ecx
56	repne scasb	60	@@:
57	mov eax, 0xFFFFFFFE	61	mov eax, edx
58	sub eax, ecx	62	sub eax, ecx
59	retn	63	retn
60		64
61	fs_execute_from_sysdir:	65	fs_execute_from_sysdir:
62	xor ebx, ebx	66	xor ebx, ebx
63	fs_execute_from_sysdir_param:	67	fs_execute_from_sysdir_param:
64	xor edx, edx	68	xor edx, edx
65		69
66	align 4	70	align 4
67	proc fs_execute	71	proc fs_execute
68	; ebx - cmdline	72	; ebx - cmdline
69	; edx - flags	73	; edx - flags
70	; ebp - full filename	74	; ebp - full filename
71		75
72	locals	76	locals
73	filename rd 1	77	filename rd 1
74	cmdline rd 1	78	cmdline rd 1
75	flags rd 1	79	flags rd 1
76		80
77	slot rd 1	81	slot rd 1
78	slot_base rd 1	82	slot_base rd 1
79		83
80	;app header data	84	;app header data
81		85
82	hdr_cmdline rd 1 ;0x00	86	hdr_cmdline rd 1 ;0x00
83	hdr_path rd 1 ;0x04	87	hdr_path rd 1 ;0x04
84	hdr_eip rd 1 ;0x08	88	hdr_eip rd 1 ;0x08
85	hdr_esp rd 1 ;0x0C	89	hdr_esp rd 1 ;0x0C
86	hdr_edata rd 1 ;0x10	90	hdr_edata rd 1 ;0x10
87	hdr_emem rd 1 ;0x14	91	hdr_emem rd 1 ;0x14
88	file_base rd 1 ;0x18	92	file_base rd 1 ;0x18
89	file_size rd 1 ;0x1c	93	file_size rd 1 ;0x1c
90	filename_size rd 1 ;0x20	94	filename_size rd 1 ;0x20
91	cmdline_size rd 1 ;0x24	95	cmdline_size rd 1 ;0x24
92		96
93	endl	97	endl
94		98
95	mov eax, [ebp]	99	mov eax, [ebp]
96	mov [flags], edx	100	mov [flags], edx
97	mov [cmdline], ebx	101	mov [cmdline], ebx
98	mov [filename], eax	102	mov [filename], eax
99		103
100	mov eax, [filename]	104	mov eax, [filename]
101	stdcall load_file, eax	105	stdcall load_file, eax
102	mov esi, -ERROR_FILE_NOT_FOUND	106	mov esi, -ERROR_FILE_NOT_FOUND
103	test eax, eax	107	test eax, eax
104	jz .err_file	108	jz .err_file
105		109
106	mov [file_base], eax	110	mov [file_base], eax
107	mov [file_size], ebx	111	mov [file_size], ebx
108		112
109	lea ebx, [hdr_cmdline]	113	lea ebx, [hdr_cmdline]
110	call test_app_header	114	call test_app_header
111	mov esi, -0x1F	115	mov esi, -0x1F
112	test eax, eax	116	test eax, eax
113	jz .err_hdr	117	jz .err_hdr
114		118
115	call lock_application_table	119	call lock_application_table
116		120
117	call alloc_thread_slot	121	call alloc_thread_slot
118	mov esi, -0x20 ; too many processes	122	mov esi, -0x20 ; too many processes
119	test eax, eax	123	test eax, eax
120	jz .err_0	124	jz .err_0
121		125
122	mov [slot], eax	126	mov [slot], eax
123	shl eax, 8	127	shl eax, 8
124	lea edi, [SLOT_BASE+eax]	128	lea edi, [SLOT_BASE+eax]
125	mov [slot_base], edi	129	mov [slot_base], edi
126		130
127	;clean extended information about process	131	;clean extended information about process
128	mov ecx, 256/4	132	mov ecx, 256/4
129	xor eax, eax	133	xor eax, eax
130	cld	134	cld
131	rep stosd	135	rep stosd
132		136
133	; write application name	137	; write application name
134	stdcall strrchr, [filename], '/' ; now eax points to name without path	138	stdcall strrchr, [filename], '/' ; now eax points to name without path
135		139
136	lea esi, [eax+1]	140	lea esi, [eax+1]
137	test eax, eax	141	test eax, eax
138	jnz @F	142	jnz @F
139	mov esi, [filename]	143	mov esi, [filename]
140	@@:	144	@@:
141	mov ecx, 11 ; 11 chars for name! 8 - is old value!	145	mov ecx, 11 ; 11 chars for name! 8 - is old value!
142	mov edi, [slot_base]	146	mov edi, [slot_base]
143	.copy_process_name_loop:	147	.copy_process_name_loop:
144	lodsb	148	lodsb
145	cmp al, '.'	149	cmp al, '.'
146	jz .copy_process_name_done	150	jz .copy_process_name_done
147	test al, al	151	test al, al
148	jz .copy_process_name_done	152	jz .copy_process_name_done
149	stosb	153	stosb
150	loop .copy_process_name_loop	154	loop .copy_process_name_loop
151		155
152	.copy_process_name_done:	156	.copy_process_name_done:
153		157
154	mov edi, [cmdline]	158	mov edi, [cmdline]
155	xor eax, eax	159	xor eax, eax
156	test edi, edi	160	test edi, edi
157	jz @F	161	jz @F
-		162
158		163	mov ecx, 65535
159	call _strlen	164	call _strnlen
160	cmp eax, 256	165	cmp eax, 256
161	jb @F	166	jb @F
162	lea ebx, [eax+1]	167	lea ebx, [eax+1]
163	add [hdr_emem], ebx	168	add [hdr_emem], ebx
164	@@:	169	@@:
165	mov [cmdline_size], eax	170	mov [cmdline_size], eax
166		171
167	stdcall create_process, [hdr_emem]	172	stdcall create_process, [hdr_emem]
168		173
169	mov esi, -30; no memory	174	mov esi, -30; no memory
170	test eax, eax	175	test eax, eax
171	jz .err_hdr	176	jz .err_hdr
172		177
173	mov ebx, [sys_proc+LHEAD.prev]	178	mov ebx, [sys_proc+LHEAD.prev]
174	__list_add eax, ebx, sys_proc	179	__list_add eax, ebx, sys_proc
175		180
176	mov ebx, [hdr_emem]	181	mov ebx, [hdr_emem]
177	mov [eax+PROC.mem_used], ebx	182	mov [eax+PROC.mem_used], ebx
178		183
179	mov ebx, [slot_base]	184	mov ebx, [slot_base]
180	mov [ebx+APPDATA.process], eax	185	mov [ebx+APPDATA.process], eax
181		186
182	lea edx, [ebx+APPDATA.list]	187	lea edx, [ebx+APPDATA.list]
183	lea ecx, [eax+PROC.thr_list]	188	lea ecx, [eax+PROC.thr_list]
184	list_add_tail edx, ecx	189	list_add_tail edx, ecx
185		190
186	mov esi, sizeof.APP_HDR	191	mov esi, sizeof.APP_HDR
187	add esi, [cmdline_size]	192	add esi, [cmdline_size]
-		193
188	mov edi, [filename]	194	mov edi, [filename]
-		195	mov ecx, 1023
189	call _strlen	196	call _strnlen
190	add esi, eax	197	add esi, eax
191	mov [filename_size], eax	198	mov [filename_size], eax
192		199
193	stdcall kernel_alloc, esi	200	stdcall kernel_alloc, esi
194	mov [ebx+APPDATA.exec_params], eax	201	mov [ebx+APPDATA.exec_params], eax
195	mov edi, eax	202	mov edi, eax
196	lea esi, [hdr_cmdline]	203	lea esi, [hdr_cmdline]
197	mov ecx, sizeof.APP_HDR/4	204	mov ecx, sizeof.APP_HDR/4
198	rep movsd	205	rep movsd
199		206
200	mov esi, [filename]	207	mov esi, [filename]
201	mov ecx, [filename_size]	208	mov ecx, [filename_size]
202	rep movsb	209	rep movsb
203	mov ecx, [cmdline_size]	210	mov ecx, [cmdline_size]
204	mov esi, [cmdline]	211	mov esi, [cmdline]
205	rep movsb	212	rep movsb
206		213
207	lea eax, [hdr_cmdline]	214	lea eax, [hdr_cmdline]
208	stdcall set_app_params , [slot], eax, [flags]	215	stdcall set_app_params , [slot], eax, [flags]
209		216
210	mov eax, [process_number] ;set result	217	mov eax, [process_number] ;set result
211	call unlock_application_table	218	call unlock_application_table
212	ret	219	ret
213		220
214	.err_0:	221	.err_0:
215	call unlock_application_table	222	call unlock_application_table
216		223
217	.err_hdr:	224	.err_hdr:
218	stdcall kernel_free, [file_base]	225	stdcall kernel_free, [file_base]
219	.err_file:	226	.err_file:
220	mov eax, esi	227	mov eax, esi
221	ret	228	ret
222	endp	229	endp
223		230
224	align 4	231	align 4
225	test_app_header:	232	test_app_header:
226	virtual at eax	233	virtual at eax
227	APP_HEADER_00 APP_HEADER_00_	234	APP_HEADER_00 APP_HEADER_00_
228	end virtual	235	end virtual
229	virtual at eax	236	virtual at eax
230	APP_HEADER_01 APP_HEADER_01_	237	APP_HEADER_01 APP_HEADER_01_
231	end virtual	238	end virtual
232		239
233	cmp dword [eax], 'MENU'	240	cmp dword [eax], 'MENU'
234	jne .fail	241	jne .fail
235	cmp word [eax+4], 'ET'	242	cmp word [eax+4], 'ET'
236	jne .fail	243	jne .fail
237		244
238	cmp [eax+6], word '00'	245	cmp [eax+6], word '00'
239	jne .check_01_header	246	jne .check_01_header
240		247
241	mov ecx, [APP_HEADER_00.start]	248	mov ecx, [APP_HEADER_00.start]
242	mov [ebx+APP_HDR.eip], ecx	249	mov [ebx+APP_HDR.eip], ecx
243	mov edx, [APP_HEADER_00.mem_size]	250	mov edx, [APP_HEADER_00.mem_size]
244	mov [ebx+APP_HDR._emem], edx	251	mov [ebx+APP_HDR._emem], edx
245	shr edx, 1	252	shr edx, 1
246	sub edx, 0x10	253	sub edx, 0x10
247	mov [ebx+APP_HDR.esp], edx	254	mov [ebx+APP_HDR.esp], edx
248	mov ecx, [APP_HEADER_00.i_param]	255	mov ecx, [APP_HEADER_00.i_param]
249	mov [ebx+APP_HDR.cmdline], ecx	256	mov [ebx+APP_HDR.cmdline], ecx
250	mov [ebx+APP_HDR.path], 0	257	mov [ebx+APP_HDR.path], 0
251	mov edx, [APP_HEADER_00.i_end]	258	mov edx, [APP_HEADER_00.i_end]
252	mov [ebx+APP_HDR._edata], edx	259	mov [ebx+APP_HDR._edata], edx
253	ret	260	ret
254		261
255	.check_01_header:	262	.check_01_header:
256		263
257	cmp [eax+6], word '01'	264	cmp [eax+6], word '01'
258	je @f	265	je @f
259	cmp [eax+6], word '02'	266	cmp [eax+6], word '02'
260	jne .fail	267	jne .fail
261	@@:	268	@@:
262	mov ecx, [APP_HEADER_01.start]	269	mov ecx, [APP_HEADER_01.start]
263	mov [ebx+0x08], ecx	270	mov [ebx+0x08], ecx
264	mov edx, [APP_HEADER_01.mem_size]	271	mov edx, [APP_HEADER_01.mem_size]
265		272
266	; \begin{diamond}[20.08.2006]	273	; \begin{diamond}[20.08.2006]
267	; sanity check (functions 19,58 load app_i_end bytes and that must	274	; sanity check (functions 19,58 load app_i_end bytes and that must
268	; fit in allocated memory to prevent kernel faults)	275	; fit in allocated memory to prevent kernel faults)
269	cmp edx, [APP_HEADER_01.i_end]	276	cmp edx, [APP_HEADER_01.i_end]
270	jb .fail	277	jb .fail
271	; \end{diamond}[20.08.2006]	278	; \end{diamond}[20.08.2006]
272		279
273	mov [ebx+APP_HDR._emem], edx	280	mov [ebx+APP_HDR._emem], edx
274	mov ecx, [APP_HEADER_01.stack_top]	281	mov ecx, [APP_HEADER_01.stack_top]
275	mov [ebx+APP_HDR.esp], ecx	282	mov [ebx+APP_HDR.esp], ecx
276	mov edx, [APP_HEADER_01.i_param]	283	mov edx, [APP_HEADER_01.i_param]
277	mov [ebx+APP_HDR.cmdline], edx	284	mov [ebx+APP_HDR.cmdline], edx
278	mov ecx, [APP_HEADER_01.i_icon]	285	mov ecx, [APP_HEADER_01.i_icon]
279	mov [ebx+APP_HDR.path], ecx	286	mov [ebx+APP_HDR.path], ecx
280	mov edx, [APP_HEADER_01.i_end]	287	mov edx, [APP_HEADER_01.i_end]
281	mov [ebx+APP_HDR._edata], edx	288	mov [ebx+APP_HDR._edata], edx
282	ret	289	ret
283	.fail:	290	.fail:
284	xor eax, eax	291	xor eax, eax
285	ret	292	ret
286		293
287	align 4	294	align 4
288	alloc_thread_slot:	295	alloc_thread_slot:
289	;input:	296	;input:
290	; none	297	; none
291	;result:	298	;result:
292	; eax=[new_thread_slot]<>0 - ok	299	; eax=[new_thread_slot]<>0 - ok
293	; 0 - failed.	300	; 0 - failed.
294	;This function find least empty slot.	301	;This function find least empty slot.
295	;It doesn't increase [TASK_COUNT]!	302	;It doesn't increase [TASK_COUNT]!
296		303
297		304
298	mov edx, thr_slot_map	305	mov edx, thr_slot_map
299	pushfd	306	pushfd
300	cli	307	cli
301	.l1:	308	.l1:
302	bsf eax, [edx]	309	bsf eax, [edx]
303	jnz .found	310	jnz .found
304	add edx, 4	311	add edx, 4
305	cmp edx, thr_slot_map+32	312	cmp edx, thr_slot_map+32
306	jb .l1	313	jb .l1
307		314
308	popfd	315	popfd
309	xor eax, eax	316	xor eax, eax
310	ret	317	ret
311	.found:	318	.found:
312	btr [edx], eax	319	btr [edx], eax
313	sub edx, thr_slot_map	320	sub edx, thr_slot_map
314	lea eax, [eax+edx*8]	321	lea eax, [eax+edx*8]
315	popfd	322	popfd
316	ret	323	ret
317		324
318	align 4	325	align 4
319	proc create_process stdcall, app_size:dword	326	proc create_process stdcall, app_size:dword
320	locals	327	locals
321	process dd ?	328	process dd ?
322	app_tabs dd ?	329	app_tabs dd ?
323	endl	330	endl
324		331
325	push ebx	332	push ebx
326	push esi	333	push esi
327	push edi	334	push edi
328		335
329	xor eax, eax	336	xor eax, eax
330	mov [process], eax	337	mov [process], eax
331		338
332	mov eax, [app_size]	339	mov eax, [app_size]
333	add eax, 0x3FFFFF	340	add eax, 0x3FFFFF
334	shr eax, 22	341	shr eax, 22
335	mov [app_tabs], eax	342	mov [app_tabs], eax
336		343
337	stdcall kernel_alloc, 0x2000	344	stdcall kernel_alloc, 0x2000
338	test eax, eax	345	test eax, eax
339	jz .fail	346	jz .fail
340	mov [process], eax	347	mov [process], eax
341		348
342	lea edi, [eax+PROC.heap_lock]	349	lea edi, [eax+PROC.heap_lock]
343	mov ecx, (PROC.ht_free-PROC.heap_lock)/4	350	mov ecx, (PROC.ht_free-PROC.heap_lock)/4
344		351
345	list_init eax	352	list_init eax
346	add eax, PROC.thr_list	353	add eax, PROC.thr_list
347	list_init eax	354	list_init eax
348		355
349	xor eax, eax	356	xor eax, eax
350	cld	357	cld
351	rep stosd	358	rep stosd
352		359
353	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3	360	mov [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
354	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr	361	mov [edi+4], dword 3 ;reserve handles for stdin stdout and stderr
355	mov ecx, (PROC.pdt_0 - PROC.htab)/4	362	mov ecx, (PROC.pdt_0 - PROC.htab)/4
356	add edi, 8	363	add edi, 8
357	inc eax	364	inc eax
358	@@:	365	@@:
359	stosd	366	stosd
360	inc eax	367	inc eax
361	cmp eax, ecx	368	cmp eax, ecx
362	jbe @B	369	jbe @B
363		370
364	mov eax, edi	371	mov eax, edi
365	call get_pg_addr	372	call get_pg_addr
366	mov [edi-4096+PROC.pdt_0_phys], eax	373	mov [edi-4096+PROC.pdt_0_phys], eax
367		374
368	mov ecx, (OS_BASE shr 20)/4	375	mov ecx, (OS_BASE shr 20)/4
369	xor eax, eax	376	xor eax, eax
370	rep stosd	377	rep stosd
371		378
372	mov ecx, (OS_BASE shr 20)/4	379	mov ecx, (OS_BASE shr 20)/4
373	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)	380	mov esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
374	rep movsd	381	rep movsd
375		382
376	mov eax, [edi-8192+PROC.pdt_0_phys]	383	mov eax, [edi-8192+PROC.pdt_0_phys]
377	or eax, PG_SWR	384	or eax, PG_SWR
378	mov [edi-4096+(page_tabs shr 20)], eax	385	mov [edi-4096+(page_tabs shr 20)], eax
379		386
380	lea edx, [edi-4096]	387	lea edx, [edi-4096]
381	mov esi, [app_tabs]	388	mov esi, [app_tabs]
382		389
383	.alloc_page_dir:	390	.alloc_page_dir:
384	call alloc_page	391	call alloc_page
385	test eax, eax	392	test eax, eax
386	jz .fail	393	jz .fail
387	or eax, PG_UWR	394	or eax, PG_UWR
388	mov [edx], eax	395	mov [edx], eax
389		396
390	mov edi, [tmp_task_ptab]	397	mov edi, [tmp_task_ptab]
391	stdcall map_page, edi, eax, PG_SWR	398	stdcall map_page, edi, eax, PG_SWR
392	mov ecx, 1024	399	mov ecx, 1024
393	xor eax, eax	400	xor eax, eax
394	rep stosd	401	rep stosd
395		402
396	add edx, 4	403	add edx, 4
397	dec esi	404	dec esi
398	jnz .alloc_page_dir	405	jnz .alloc_page_dir
399		406
400	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	407	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
401	mov eax, [process]	408	mov eax, [process]
402		409
403	pop edi	410	pop edi
404	pop esi	411	pop esi
405	pop ebx	412	pop ebx
406	ret	413	ret
407	.fail:	414	.fail:
408	mov ecx, [process]	415	mov ecx, [process]
409	jcxz @F	416	jcxz @F
410		417
411	call destroy_process	418	call destroy_process
412	@@:	419	@@:
413	xor eax, eax	420	xor eax, eax
414	pop edi	421	pop edi
415	pop esi	422	pop esi
416	pop ebx	423	pop ebx
417	ret	424	ret
418	endp	425	endp
419		426
420	align 4	427	align 4
421	proc destroy_page_table stdcall, pg_tab:dword	428	proc destroy_page_table stdcall, pg_tab:dword
422		429
423	push esi	430	push esi
424		431
425	mov esi, [pg_tab]	432	mov esi, [pg_tab]
426	mov ecx, 1024	433	mov ecx, 1024
427	.free:	434	.free:
428	mov eax, [esi]	435	mov eax, [esi]
429	test eax, 1	436	test eax, 1
430	jz .next	437	jz .next
431	test eax, 2	438	test eax, 2
432	jz .next	439	jz .next
433	test eax, 1 shl 9	440	test eax, 1 shl 9
434	jnz .next ;skip shared pages	441	jnz .next ;skip shared pages
435	call free_page	442	call free_page
436	.next:	443	.next:
437	add esi, 4	444	add esi, 4
438	dec ecx	445	dec ecx
439	jnz .free	446	jnz .free
440	pop esi	447	pop esi
441	ret	448	ret
442	endp	449	endp
443		450
444	align 4	451	align 4
445	destroy_process: ;fastcall ecx= ptr to process	452	destroy_process: ;fastcall ecx= ptr to process
446		453
447	lea eax, [ecx+PROC.thr_list]	454	lea eax, [ecx+PROC.thr_list]
448	cmp eax, [eax+LHEAD.next]	455	cmp eax, [eax+LHEAD.next]
449	jne .exit	456	jne .exit
450		457
451	align 4	458	align 4
452	.internal:	459	.internal:
453	push ecx	460	push ecx
454		461
455	mov esi, ecx	462	mov esi, ecx
456	list_del esi	463	list_del esi
457		464
458	mov esi, [esi+PROC.dlls_list_ptr]	465	mov esi, [esi+PROC.dlls_list_ptr]
459	call destroy_all_hdlls	466	call destroy_all_hdlls
460		467
461	mov esi, [esp]	468	mov esi, [esp]
462	add esi, PROC.pdt_0	469	add esi, PROC.pdt_0
463	mov edi, (0x80000000 shr 20)/4	470	mov edi, (0x80000000 shr 20)/4
464	.destroy:	471	.destroy:
465	mov eax, [esi]	472	mov eax, [esi]
466	test eax, 1	473	test eax, 1
467	jz .next	474	jz .next
468	and eax, not 0xFFF	475	and eax, not 0xFFF
469	stdcall map_page, [tmp_task_ptab], eax, PG_SWR	476	stdcall map_page, [tmp_task_ptab], eax, PG_SWR
470	stdcall destroy_page_table, [tmp_task_ptab]	477	stdcall destroy_page_table, [tmp_task_ptab]
471	mov eax, [esi]	478	mov eax, [esi]
472	call free_page	479	call free_page
473	.next:	480	.next:
474	add esi, 4	481	add esi, 4
475	dec edi	482	dec edi
476	jnz .destroy	483	jnz .destroy
477		484
478	call kernel_free ;ecx still in stack	485	call kernel_free ;ecx still in stack
479	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP	486	stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
480	.exit:	487	.exit:
481	ret	488	ret
482		489
483	align 4	490	align 4
484	get_pid:	491	get_pid:
485	mov eax, [TASK_BASE]	492	mov eax, [TASK_BASE]
486	mov eax, [eax+TASKDATA.pid]	493	mov eax, [eax+TASKDATA.pid]
487	ret	494	ret
488		495
489	pid_to_slot:	496	pid_to_slot:
490	;Input:	497	;Input:
491	; eax - pid of process	498	; eax - pid of process
492	;Output:	499	;Output:
493	; eax - slot of process or 0 if process don't exists	500	; eax - slot of process or 0 if process don't exists

Subversion Repositories Kolibri OS

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