WebSVN – Kolibri OS – Diff – /kernel/branches/kolibrios-pe-clevermouse/core/taskman.inc

 ;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;
 ;;  Distributed under terms of the GNU General Public License.  ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 9045 $
+$Revision: 9048 $
         img_base        rd 1    ;0x18
         img_size        rd 1
         filename_size   rd 1
         cmdline_size    rd 1
         path_string     rd 1
+        pedescr         rd 1
 ends
+; Pointer to this structure is passed as the third argument
+; to usermode PE loader by the kernel.
+struct kernel_init_data
+version         dw      ?
+flags           dw      ?
+syscall_method  dd      ?
+; either one of SYSCALL_METHOD_xxx or pointer to procedure
+exe_base        dd      ?
+stack_base      dd      ?
+stack_size      dd      ?
+exe_path        dd      ?
+command_line    dd      ?
+environment     dd      ?
+ends
+SYSCALL_METHOD_I40 = 1
+SYSCALL_METHOD_SYSENTER = 2
+SYSCALL_METHOD_SYSCALL = 3
+macro _clear_ op
-macro _clear_ op
+{
-{  mov ecx, op/4
+        mov     ecx, op/4
         xor     eax, eax
         cld
         rep stosd
         file_base       rd  1
         file_size       rd  1
         filename_size   rd  1
         cmdline_size    rd  1
         path_string     rd  1
+        pedescr         rd  1
     endl
         mov     [flags], edx
         mov     [cmdline], ecx
         mov     [path_string], ebx
         mov     [filename_size], eax
-        mov     esi, -ERROR_FILE_NOT_FOUND
+        mov     edi, -ERROR_FILE_NOT_FOUND
         test    eax, eax
         jz      .err_file
         stdcall load_file, ebx
         test    eax, eax
-        jz      .err_file
+        jz      .err_file
+        stdcall load_file_maybe_pe, [path_string]
         mov     [pedescr], esi
         mov     [file_base], eax
+        mov     [file_size], ebx
+        test    esi, esi
+        jnz     .file_ok
+        mov     edi, eax
+        cmp     eax, -0x1000
+        ja      .err_file
         mov     [file_size], ebx
         lea     ebx, [hdr_cmdline]
         call    test_app_header  ; fill our app header data locals with values from header of given program (if its correct)
-        mov     esi, -TASKMAN_ERROR_NOT_A_EXECUTABLE
+        mov     edi, -TASKMAN_ERROR_NOT_A_EXECUTABLE
         test    eax, eax
+        jz      .err_hdr
         jz      .err_hdr
 .file_ok:
         call    lock_application_table
         call    alloc_thread_slot   ; create a slot for new thread
-        mov     esi, -TASKMAN_ERROR_TOO_MANY_PROCESSES
+        mov     edi, -TASKMAN_ERROR_TOO_MANY_PROCESSES
         test    eax, eax
         jz      .err_0
 ; if cmdline length >= 256 then increase needed memory size by this length
         lea     ebx, [eax+1]
         add     [hdr_emem], ebx
 @@:
         mov     [cmdline_size], eax
+        xor     eax, eax
+        cmp     [pedescr], eax
+        jz      @f
+        mov     [hdr_eip], eax
+        mov     [hdr_esp], eax
+        mov     [hdr_emem], eax
+@@:
         stdcall create_process, [hdr_emem]  ; create a new process
-        mov     esi, -TASKMAN_ERROR_OUT_OF_MEMORY
+        mov     edi, -TASKMAN_ERROR_OUT_OF_MEMORY
         test    eax, eax
         jz      .err_hdr
 ; add new process to the list
         mov     eax, [process_number]   ; return process number
         call    unlock_application_table
         ret
+.err_0:
+        mov     esi, [pedescr]
+        test    esi, esi
+        jz      @f
+        call    dereference_pe
-.err_0:
+@@:
         call    unlock_application_table
 .err_hdr:
         stdcall kernel_free, [file_base]
 .err_file:
         stdcall kernel_free, [path_string]
-        mov     eax, esi
+        mov     eax, edi
         ret
 endp
         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
+        lea     edi, [eax+PROC.heap_base]
         list_init eax
+        add     eax, PROC.thr_list
+        list_init eax
+        add     eax, PROC.smap_list - PROC.thr_list
+        list_init eax
+        lea     ecx, [eax+PROC.heap_lock-PROC.smap_list]
-        add     eax, PROC.thr_list
+        call    mutex_init
         list_init eax
         mov     ecx, (PROC.ht_free-PROC.heap_base)/4
         xor     eax, eax
         or      eax, PG_SWR
         mov     [edi-4096+(page_tabs shr 20)], eax
         lea     edx, [edi-4096]
+        mov     esi, [app_tabs]
+        test    esi, esi
-        mov     esi, [app_tabs]
+        jz      .no_page_dirs
 .alloc_page_dir:
         call    alloc_page
         add     edx, 4
         dec     esi
+        jnz     .alloc_page_dir
         jnz     .alloc_page_dir
 .no_page_dirs:
         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
+        jecxz   @F
         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
         push    ecx
         mov     esi, ecx
+        list_del esi
-        list_del esi
+        lea     ebx, [esi+PROC.smap_list]
+        mov     edi, [esi+PROC.smap_list+SMAP.fd]
+.smap_list_destroy:
+        cmp     edi, ebx
+        jz      .smap_list_done
+        push    [edi+SMAP.fd]
+        stdcall destroy_smap, [esp+4]
+        pop     edi
-        mov     esi, [esi+PROC.dlls_list_ptr]
+        jmp     .smap_list_destroy
-        call    destroy_all_hdlls
+.smap_list_done:
         mov     esi, [esp]
          slot   dd ?
          buff   dd ?
          r_count    dd ?
          offset dd ?
          tmp_r_cnt  dd ?
+         mapped_size dd ?
        endl
         mov     [slot], eax
         mov     [buff], ecx
         and     [r_count], 0
         mov     [tmp_r_cnt], edx
         mov     [offset], esi
+        pushad
         mov     ecx, proc_mem_mutex
-        pushad
+        call    mutex_lock
 .read_mem:
         mov     edx, [offset]
 @@:
         mov     ebx, [offset]
         push    ecx
         stdcall map_memEx, [proc_mem_map], \
+                [slot], ebx, ecx, PG_READ, [proc_mem_tab]
-                [slot], ebx, ecx, PG_READ
+        mov     [mapped_size], eax
         pop     ecx
         mov     esi, [offset]
         and     esi, 0xfff
         sub     eax, esi
-        jbe     .ret
+        jbe     .ret_unmap
         cmp     ecx, eax
         jbe     @f
         mov     ecx, eax
         mov     [tmp_r_cnt], eax
 @@:
         add     esi, [proc_mem_map]
         mov     edi, [buff]
+        push    ecx
+        rep movsb
+        stdcall unmap_memEx, [proc_mem_map], \
-        mov     edx, ecx
+                [slot], ebx, [mapped_size], [proc_mem_tab]
-        rep movsb
+        pop     ecx
-        add     [r_count], edx
+        add     [r_count], ecx
-        add     [offset], edx
+        add     [offset], ecx
+        sub     [tmp_r_cnt], ecx
+        jnz     .read_mem
-        sub     [tmp_r_cnt], edx
+.ret:
-        jnz     .read_mem
+        mov     ecx, proc_mem_mutex
-.ret:
+        call    mutex_unlock
+        popad
+        mov     eax, [r_count]
+        ret
+.ret_unmap:
-        popad
+        stdcall unmap_memEx, [proc_mem_map], \
-        mov     eax, [r_count]
+                [slot], ebx, [mapped_size], [proc_mem_tab]
-        ret
+        jmp     .ret
 endp
          slot   dd ?
          buff   dd ?
          w_count    dd ?
          offset dd ?
          tmp_w_cnt  dd ?
+         mapped_size dd ?
        endl
         mov     [slot], eax
         mov     [buff], ecx
         and     [w_count], 0
         mov     [tmp_w_cnt], edx
         mov     [offset], esi
+        pushad
+        mov     ecx, proc_mem_mutex
-        pushad
+        call    mutex_lock
-.read_mem:
+.write_mem:
         mov     edx, [offset]
         mov     ebx, [tmp_w_cnt]
         mov     ecx, 0x8000
 @@:
         mov     ebx, [offset]
         push    ecx
         stdcall map_memEx, [proc_mem_map], \
-                [slot], ebx, ecx, PG_SWR
+                [slot], ebx, ecx, PG_SWR, [proc_mem_tab]
+        mov     [mapped_size], eax
         pop     ecx
         mov     edi, [offset]
         and     edi, 0xfff
         sub     eax, edi
-        jbe     .ret
+        jbe     .ret_unmap
         cmp     ecx, eax
         jbe     @f
         mov     ecx, eax
         mov     [tmp_w_cnt], eax
 @@:
         add     edi, [proc_mem_map]
         mov     esi, [buff]
-        mov     edx, ecx
+        push    ecx
+        rep movsb
+        stdcall unmap_memEx, [proc_mem_map], \
+                [slot], ebx, [mapped_size], [proc_mem_tab]
-        rep movsb
+        pop     ecx
-        add     [w_count], edx
+        add     [w_count], ecx
-        add     [offset], edx
+        add     [offset], ecx
-        sub     [tmp_w_cnt], edx
+        sub     [tmp_w_cnt], ecx
+        jnz     .write_mem
+.ret:
-        jnz     .read_mem
+        mov     ecx, proc_mem_mutex
-.ret:
+        call    mutex_unlock
         popad
+        mov     eax, [w_count]
+        ret
+.ret_unmap:
-        mov     eax, [w_count]
+        stdcall unmap_memEx, [proc_mem_map], [slot], ebx, [mapped_size], [proc_mem_tab]
-        ret
+        jmp     .ret
 endp
         mov     ebp, [ebp+APPDATA.exec_params]
         test    ebp, ebp
         jz      .exit
 ; APPDATA.exec_params have first thread only,
 ; so second and next threads don't get here (they jump to .exit)
+        cmp     [ebp+APP_HDR.pedescr], 0
+        jz      .init_legacy_app
+; init PE application
+        mov     eax, [current_process]
+        mov     [eax+PROC.mem_used], 0xF000 ; leave first 64K as unallocatable
+        call    init_heap
+        mov     eax, [current_process]
+        mov     [eax+PROC.mem_used], 0
+        stdcall map_pe_usermode, [ebp+APP_HDR.pedescr],\
+                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]
+        cmp     eax, -0x1000
+        ja      .failed
+        push    eax
+        stdcall load_file_maybe_pe, pe_loader_usermode
+        test    esi, esi
+        jz      .pe_loader_notfound
+        mov     edx, [esi+PEDESCR.entry]
+        mov     [esp+4+20h], edx
+        stdcall map_pe_usermode, esi, eax, ebx
+        cmp     eax, -0x1000
+        ja      .pe_loader_failed
+        add     [esp+4+20h], eax
+        push    eax
+        mov     eax, [ebp+APP_HDR.filename_size]
+        add     eax, [ebp+APP_HDR.cmdline_size]
+        add     eax, sizeof.kernel_init_data + 2
+        stdcall user_alloc, eax
+        test    eax, eax
+        jz      .failed
+        mov     ebx, eax
+        mov     dword [eax+kernel_init_data.version], 1 + (0 shl 16) ; version, flags
+        mov     [eax+kernel_init_data.syscall_method], SYSCALL_METHOD_I40
+        lea     edi, [eax+sizeof.kernel_init_data]
+        mov     [eax+kernel_init_data.exe_path], edi
+        mov     esi, [ebp+APP_HDR.path_string]
+        mov     ecx, [ebp+APP_HDR.filename_size]
+        rep movsb
+        mov     byte [edi], 0
+        inc     edi
+        mov     [eax+kernel_init_data.command_line], edi
+        lea     esi, [ebp+sizeof.APP_HDR]
+        mov     ecx, [ebp+APP_HDR.cmdline_size]
+        rep movsb
+        mov     byte [edi], 0
+        mov     ecx, [ebp+APP_HDR.pedescr]
+        mov     ecx, [ecx+PEDESCR.stacksize]
+        mov     [eax+kernel_init_data.stack_size], ecx
+        stdcall user_alloc, ecx
+        test    eax, eax
+        jz      .failed
+        mov     [ebx+kernel_init_data.stack_base], eax
+        add     eax, [ebx+kernel_init_data.stack_size]
+        sub     eax, 16
+        pop     dword [eax+4]
+        pop     [ebx+kernel_init_data.exe_base]
+        mov     dword [eax+8], 1 ; DLL_PROCESS_ATTACH
+        mov     dword [eax+12], ebx
+        mov     [esp+2Ch], eax
+        jmp     .common_tls
+.pe_loader_notfound:
+        cmp     eax, -0x1000
+        ja      .pe_loader_failed
+        stdcall kernel_free, eax
+.pe_loader_failed:
+        dbgstr 'Failed to load kolibri.dll'
+.failed:
+        stdcall kernel_free, [ebp+APP_HDR.path_string]
+        jmp     sys_end
+.init_legacy_app:
+; init MENUETxx application
         stdcall map_process_image, [ebp+APP_HDR._emem],\
                 [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]
         mov     esi, [ebp+APP_HDR.path_string]
         mov     edi, [ebp+APP_HDR.path]
         mov     ecx, [ebp+APP_HDR.filename_size]
         dec     ecx
         rep movsb
         mov     byte [edi], 0
 .check_tls_header:
         cmp     word [6], '02'
-        jne     .try_load_dll ;.cleanup
+        jne     .try_load_dll ;.common
         call    init_heap
+.common_tls:
         stdcall user_alloc, 4096
         mov     edx, [current_slot]
         mov     [edx+APPDATA.tls_base], eax
         mov     [tls_data_l+2], ax
         shr     eax, 16
 ; { Patch by Coldy, For DLL autoload
 .try_load_dll:
 ; Test app header version
         mov     ecx, dword[ebp+APP_HDR.img_base]
         cmp     dword[ecx+8], 2
-        jne     .cleanup
+        jne     .common
 ;if APP_HEADER.version = 2 => load lib/dll.obj & change eip to APP_STARTUP_THUNK
         DEBUGF 1, 'K : App header version 2\n'
         stdcall load_library, dll_lib_path, 0
         cmp     eax, 0
         jne     @f
         mov     ecx, [current_slot]
         mov     ecx, [ecx+APPDATA.pl0_stack]
         mov     [ecx+REG_EIP], eax
+; } End patch by Coldy, For DLL autoload
+        mov     fs, dx
-; } End patch by Coldy, For DLL autoload
-.cleanup:
+.common:
         stdcall free_kernel_space, [ebp+APP_HDR.img_base]
         stdcall kernel_free, ebp
         mov     ebx, [current_slot]
         cmp     [ebx+APPDATA.debugger_slot], 0

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibrios-pe-clevermouse/core/taskman.inc – Rev 9047 → 9048