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

 ;; Copyright (C) KolibriOS team 2004-2020. All rights reserved. ;;
 ;;  Distributed under terms of the GNU General Public License.  ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 9034 $
+$Revision: 9048 $
 align 4
 proc load_library stdcall, file_name:dword, encoding:dword
     locals
         fullname    dd  ?
-        fileinfo    rb  40
+        filesize    dd  ?
         coff        dd  ?
+        img_base    dd  ?
+        img_size    dd  ?
+        symbols_ptr dd  ?
+        symbols_lim dd  ?
-        img_base    dd  ?
+        exports     dd  ?
     endl
 ; resolve file name
         push    ebp
         call    getFullPath
         pop     ebp
         test    eax, eax
         jz      .fail
-; scan for required DLL in list of already loaded for this process,
-; ignore timestamp
-        cli
-        mov     esi, [current_process]
-        mov     edi, [fullname]
-        mov     ebx, [esi+PROC.dlls_list_ptr]
-        test    ebx, ebx
-        jz      .not_in_process
-        mov     esi, [ebx+HDLL.fd]
-.scan_in_process:
-        cmp     esi, ebx
-        jz      .not_in_process
-        mov     eax, [esi+HDLL.parent]
-        add     eax, DLLDESCR.name
-        stdcall strncmp, eax, edi, -1
-        test    eax, eax
-        jnz     .next_in_process
-; simple variant: load DLL which is already loaded in this process
-; just increment reference counters and return address of exports table
-        inc     [esi+HDLL.refcount]
-        mov     ecx, [esi+HDLL.parent]
-        inc     [ecx+DLLDESCR.refcount]
-        mov     eax, [ecx+DLLDESCR.exports]
-        sub     eax, [ecx+DLLDESCR.defaultbase]
-        add     eax, [esi+HDLL.base]
-        sti
-        push    eax
-        stdcall kernel_free, [fullname]
-        pop     eax
-        ret
-.next_in_process:
-        mov     esi, [esi+HDLL.fd]
-        jmp     .scan_in_process
-.not_in_process:
-; scan in full list, compare timestamp
-        sti
-        lea     eax, [fileinfo]
-        stdcall get_fileinfo, edi, eax
-        test    eax, eax
-        jnz     .fail
-        cli
-        mov     esi, [dll_list.fd]
-.scan_for_dlls:
-        cmp     esi, dll_list
-        jz      .load_new
-        lea     eax, [esi+DLLDESCR.name]
-        stdcall strncmp, eax, edi, -1
-        test    eax, eax
-        jnz     .continue_scan
-.test_prev_dll:
-        mov     eax, dword [fileinfo+24]; last modified time
-        mov     edx, dword [fileinfo+28]; last modified date
-        cmp     dword [esi+DLLDESCR.timestamp], eax
-        jnz     .continue_scan
-        cmp     dword [esi+DLLDESCR.timestamp+4], edx
-        jz      .dll_already_loaded
-.continue_scan:
-        mov     esi, [esi+DLLDESCR.fd]
-        jmp     .scan_for_dlls
-; new DLL
-.load_new:
         sti
 ; load file
-        stdcall load_file, edi
+        stdcall load_file, [fullname]
         test    eax, eax
         jz      .fail
-        mov     [coff], eax
-        mov     dword [fileinfo+32], ebx
-; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name
-        mov     esi, edi
-        mov     ecx, -1
-        xor     eax, eax
-        repnz scasb
-        not     ecx
-        lea     eax, [ecx+sizeof.DLLDESCR]
-        push    ecx
-        call    malloc
-        pop     ecx
-        test    eax, eax
-        jz      .fail_and_free_coff
-; save timestamp
-        lea     edi, [eax+DLLDESCR.name]
-        rep movsb
+        mov     [coff], eax
-        mov     esi, eax
-        mov     eax, dword [fileinfo+24]
-        mov     dword [esi+DLLDESCR.timestamp], eax
-        mov     eax, dword [fileinfo+28]
-        mov     dword [esi+DLLDESCR.timestamp+4], eax
+        mov     [filesize], ebx
-; calculate size of loaded DLL
-        mov     edx, [coff]
+; calculate size of loaded DLL
-        movzx   ecx, [edx+COFF_HEADER.nSections]
+        movzx   ecx, [eax+COFF_HEADER.nSections]
         xor     ebx, ebx
-        add     edx, 20
+        lea     edx, [eax+20]
 @@:
         call    coff_get_align
         add     ebx, eax
         not     eax
         and     ebx, eax
         add     ebx, [edx+COFF_SECTION.SizeOfRawData]
         add     edx, sizeof.COFF_SECTION
         dec     ecx
         jnz     @B
 ; it must be nonzero and not too big
-        mov     [esi+DLLDESCR.size], ebx
+        mov     [img_size], ebx
         test    ebx, ebx
-        jz      .fail_and_free_dll
+        jz      .fail_and_free_coff
+        cmp     ebx, 0x10000000
-        cmp     ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR
+        ja      .fail_and_free_coff
-        ja      .fail_and_free_dll
+; allocate memory
-; allocate memory for kernel-side image
+        call    init_heap
-        stdcall kernel_alloc, ebx
-        test    eax, eax
-        jz      .fail_and_free_dll
-        mov     [esi+DLLDESCR.data], eax
-; calculate preferred base address
-        add     ebx, 0x1FFF
-        and     ebx, not 0xFFF
-        mov     ecx, [dll_cur_addr]
-        lea     edx, [ecx+ebx]
-        cmp     edx, MAX_DEFAULT_DLL_ADDR
-        jb      @f
-        mov     ecx, MIN_DEFAULT_DLL_ADDR
-        lea     edx, [ecx+ebx]
+        stdcall user_alloc, [img_size]
-@@:
+        test    eax, eax
-        mov     [esi+DLLDESCR.defaultbase], ecx
-        mov     [dll_cur_addr], edx
+        jz      .fail_and_free_coff
         mov	[img_base], eax
 ; copy sections and set correct values for VirtualAddress'es in headers
-        push    esi
+; copy sections and set correct values for VirtualAddress'es in headers
         mov     edx, [coff]
         movzx   ebx, [edx+COFF_HEADER.nSections]
         mov     edi, eax
-        add     edx, 20
-        cld
+        add     edx, 20
-@@:
+        cld
-        call    coff_get_align
-        add     ecx, eax
+@@:
-        add     edi, eax
+        call    coff_get_align
-        not     eax
-        and     ecx, eax
+        add     edi, eax
-        and     edi, eax
-        mov     [edx+COFF_SECTION.VirtualAddress], ecx
+        not     eax
-        add     ecx, [edx+COFF_SECTION.SizeOfRawData]
+        and     edi, eax
-        mov     esi, [edx+COFF_SECTION.PtrRawData]
+        mov     [edx+COFF_SECTION.VirtualAddress], edi
-        push    ecx
+        mov     esi, [edx+COFF_SECTION.PtrRawData]
         mov     ecx, [edx+COFF_SECTION.SizeOfRawData]
         test    esi, esi
         jnz     .copy
         xor     eax, eax
         rep stosb
         jmp     .next
-.copy:
-        add     esi, [coff]
+.copy:
-        rep movsb
+        add     esi, [coff]
-.next:
+        rep movsb
-        pop     ecx
-        add     edx, sizeof.COFF_SECTION
-        dec     ebx
-        jnz     @B
-        pop     esi
+.next:
         add     edx, sizeof.COFF_SECTION
-; save some additional data from COFF file
+        dec     ebx
-; later we will use COFF header, headers for sections and symbol table
+        jnz     @B
 ; and also relocations table for all sections
         mov     edx, [coff]
         mov     ebx, [edx+COFF_HEADER.pSymTable]
-        mov     edi, dword [fileinfo+32]
-        sub     edi, ebx
-        jc      .fail_and_free_data
-        mov     [esi+DLLDESCR.symbols_lim], edi
-        add     ebx, edx
-        movzx   ecx, [edx+COFF_HEADER.nSections]
-        lea     ecx, [ecx*5]
-        lea     edi, [edi+ecx*8+20]
-        add     edx, 20
-@@:
-        movzx   eax, [edx+COFF_SECTION.NumReloc]
+        mov     edi, [filesize]
-        lea     eax, [eax*5]
-        lea     edi, [edi+eax*2]
-        add     edx, sizeof.COFF_SECTION
-        sub     ecx, 5
-        jnz     @b
-        stdcall kernel_alloc, edi
-        test    eax, eax
+        sub     edi, ebx
-        jz      .fail_and_free_data
-        mov     edx, [coff]
-        movzx   ecx, [edx+COFF_HEADER.nSections]
-        lea     ecx, [ecx*5]
+        jc      .fail_and_free_data
-        lea     ecx, [ecx*2+5]
-        mov     [esi+DLLDESCR.coff_hdr], eax
-        push    esi
-        mov     esi, edx
-        mov     edi, eax
-        rep movsd
-        pop     esi
-        mov     [esi+DLLDESCR.symbols_ptr], edi
+        mov     [symbols_lim], edi
-        push    esi
-        mov     ecx, [edx+COFF_HEADER.nSymbols]
-        mov     [esi+DLLDESCR.symbols_num], ecx
-        mov     ecx, [esi+DLLDESCR.symbols_lim]
-        mov     esi, ebx
-        rep movsb
-        pop     esi
-        mov     ebx, [esi+DLLDESCR.coff_hdr]
-        push    esi
-        movzx   eax, [edx+COFF_HEADER.nSections]
-        lea     edx, [ebx+20]
-@@:
-        movzx   ecx, [edx+COFF_SECTION.NumReloc]
-        lea     ecx, [ecx*5]
-        mov     esi, [edx+COFF_SECTION.PtrReloc]
-        mov     [edx+COFF_SECTION.PtrReloc], edi
-        sub     [edx+COFF_SECTION.PtrReloc], ebx
-        add     esi, [coff]
-        shr     ecx, 1
-        rep movsd
-        adc     ecx, ecx
-        rep movsw
+        add     ebx, edx
-        add     edx, sizeof.COFF_SECTION
-        dec     eax
+; coff_hdr = coff
-        jnz     @b
+; symbols_num = coff.nSymbols
-        pop     esi
+	mov	[symbols_ptr], ebx
-; fixup symbols
+        mov     ebx, edx
-        mov     edx, ebx
-        mov     eax, [ebx+COFF_HEADER.nSymbols]
+; fixup symbols
-        add     edx, 20
+        mov     eax, [edx+COFF_HEADER.nSymbols]
-        mov     ecx, [esi+DLLDESCR.symbols_num]
+        add     edx, 20
-        lea     ecx, [ecx*9]
+        lea     ecx, [eax*9]
         add     ecx, ecx
-        add     ecx, [esi+DLLDESCR.symbols_ptr]
+        add     ecx, [symbols_ptr]
-        stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax, \
+        stdcall fix_coff_symbols, edx, [symbols_ptr], eax, \
                 ecx, 0
 ;          test eax, eax
 ;          jnz @F
 ;
-;@@:
-        stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], szEXPORTS
-        test    eax, eax
-        jnz     @F
+;@@:
         stdcall get_coff_sym, [esi+DLLDESCR.symbols_ptr], [ebx+COFF_HEADER.nSymbols], sz_EXPORTS
-@@:
-        mov     [esi+DLLDESCR.exports], eax
-; fix relocs in the hidden copy in kernel memory to default address
-; it is first fix; usually this will be enough, but second fix
-; can be necessary if real load address will not equal assumption
-        mov     eax, [esi+DLLDESCR.data]
-        sub     eax, [esi+DLLDESCR.defaultbase]
-        stdcall fix_coff_relocs, ebx, [esi+DLLDESCR.symbols_ptr], eax
         stdcall get_coff_sym, [symbols_ptr], [ebx+COFF_HEADER.nSymbols], szEXPORTS
-        stdcall kernel_free, [coff]
-        cli
-; initialize DLLDESCR struct
-        and     dword [esi+DLLDESCR.refcount], 0; no HDLLs yet; later it will be incremented
-        mov     [esi+DLLDESCR.fd], dll_list
-        mov     eax, [dll_list.bk]
-        mov     [dll_list.bk], esi
-        mov     [esi+DLLDESCR.bk], eax
-        mov     [eax+DLLDESCR.fd], esi
-.dll_already_loaded:
-        stdcall kernel_free, [fullname]
-        inc     [esi+DLLDESCR.refcount]
-        push    esi
-        call    init_heap
-        pop     esi
-        mov     edi, [esi+DLLDESCR.size]
-        stdcall user_alloc_at, [esi+DLLDESCR.defaultbase], edi
-        test    eax, eax
-        jnz     @f
-        stdcall user_alloc, edi
-        test    eax, eax
-        jz      .fail_and_dereference
-@@:
-        mov     [img_base], eax
-        mov     eax, sizeof.HDLL
-        call    malloc
-        test    eax, eax
-        jz      .fail_and_free_user
-        mov     ebx, [current_slot_idx]
-        shl     ebx, 5
-        mov     edx, [TASK_TABLE+ebx+TASKDATA.pid]
-        mov     [eax+HDLL.pid], edx
-        push    eax
-        call    init_dlls_in_thread
-        pop     ebx
-        test    eax, eax
-        jz      .fail_and_free_user
-        mov     edx, [eax+HDLL.fd]
-        mov     [ebx+HDLL.fd], edx
-        mov     [ebx+HDLL.bk], eax
-        mov     [eax+HDLL.fd], ebx
-        mov     [edx+HDLL.bk], ebx
-        mov     eax, ebx
-        mov     ebx, [img_base]
-        mov     [eax+HDLL.base], ebx
-        mov     [eax+HDLL.size], edi
-        mov     [eax+HDLL.refcount], 1
-        mov     [eax+HDLL.parent], esi
-        mov     edx, ebx
-        shr     edx, 12
-        or      dword [page_tabs+(edx-1)*4], MEM_BLOCK_DONT_FREE
-; copy entries of page table from kernel-side image to usermode
-; use copy-on-write for user-mode image, so map as readonly
-        xor     edi, edi
-        mov     ecx, [esi+DLLDESCR.data]
-        shr     ecx, 12
-.map_pages_loop:
-        mov     eax, [page_tabs+ecx*4]
-        and     eax, not 0xFFF
-        or      al, PG_UR
-        xchg    eax, [page_tabs+edx*4]
-        test    al, 1
-        jz      @f
-        call    free_page
-@@:
-        invlpg  [ebx+edi]
-        inc     ecx
-        inc     edx
+        test    eax, eax
-        add     edi, 0x1000
-        cmp     edi, [esi+DLLDESCR.size]
+        jnz     @F
         jb      .map_pages_loop
+        stdcall get_coff_sym, [symbols_ptr], [ebx+COFF_HEADER.nSymbols], sz_EXPORTS
-; if real user-mode base is not equal to preferred base, relocate image
-        sub     ebx, [esi+DLLDESCR.defaultbase]
-        jz      @f
-        stdcall rebase_coff, [esi+DLLDESCR.coff_hdr], [esi+DLLDESCR.symbols_ptr], ebx
+@@:
-@@:
+        mov     [exports], eax
-        mov     eax, [esi+DLLDESCR.exports]
+        stdcall fix_coff_relocs, ebx, [symbols_ptr], 0
         sub     eax, [esi+DLLDESCR.defaultbase]
-        add     eax, [img_base]
+        stdcall kernel_free, [coff]
-        sti
-        ret
-.fail_and_free_data:
-        stdcall kernel_free, [esi+DLLDESCR.data]
-.fail_and_free_dll:
-        mov     eax, esi
-        call    free
-.fail_and_free_coff:
         stdcall kernel_free, [coff]
-.fail:
-        stdcall kernel_free, [fullname]
-        xor     eax, eax
-        ret
+        stdcall kernel_free, [fullname]
-.fail_and_free_user:
-        stdcall user_free, [img_base]
+        mov     eax, [exports]
-.fail_and_dereference:
-        mov     eax, 1  ; delete 1 reference
-        call    dereference_dll
-        sti
-        xor     eax, eax
-        ret
-endp
+        ret
-; initialize [APPDATA.dlls_list_ptr] for given thread
-; DLL is per-process object, so APPDATA.dlls_list_ptr must be
-; kept in sync for all threads of one process.
-; out: eax = APPDATA.dlls_list_ptr if all is OK,
-; NULL if memory allocation failed
-init_dlls_in_thread:
-        mov     ebx, [current_process]
-        mov     eax, [ebx+PROC.dlls_list_ptr]
-        test    eax, eax
-        jnz     .ret
-        mov     eax, 8
-        call    malloc                               ; FIXME
+.fail_and_free_data:
-        test    eax, eax
+	stdcall	user_free, [img_base]
-        jz      .ret
+.fail_and_free_coff:
+        stdcall kernel_free, [coff]
-        mov     [eax], eax
+.fail:
-        mov     [eax+4], eax
+        stdcall kernel_free, [fullname]
-        mov     ebx, [current_process]
+        xor     eax, eax
-        mov     [ebx+PROC.dlls_list_ptr], eax
+        ret
-.ret:
-        ret
-; in: eax = number of references to delete, esi -> DLLDESCR struc
-dereference_dll:
-        sub     [esi+DLLDESCR.refcount], eax
-        jnz     .ret
-        mov     eax, [esi+DLLDESCR.fd]
-        mov     edx, [esi+DLLDESCR.bk]
-        mov     [eax+DLLDESCR.bk], edx
-        mov     [edx+DLLDESCR.fd], eax
-        stdcall kernel_free, [esi+DLLDESCR.coff_hdr]
-        stdcall kernel_free, [esi+DLLDESCR.data]
-        mov     eax, esi
-        call    free
-.ret:
-        ret
-destroy_hdll:
-        push    ebx ecx esi edi
-        mov     ebx, [eax+HDLL.base]
-        mov     esi, [eax+HDLL.parent]
-        mov     edx, [esi+DLLDESCR.size]
-        push    eax
-        mov     esi, [eax+HDLL.parent]
-        mov     eax, [eax+HDLL.refcount]
-        call    dereference_dll
-        pop     eax
-        mov     edx, [eax+HDLL.bk]
-        mov     ebx, [eax+HDLL.fd]
-        mov     [ebx+HDLL.bk], edx
-        mov     [edx+HDLL.fd], ebx
-        call    free
+endp
-        pop     edi esi ecx ebx
+; in: esi -> PEDESCR struct
-        ret
+proc dereference_pe
         mov     ecx, pe_list_mutex
-; ecx -> APPDATA for slot, esi = dlls_list_ptr
+        call    mutex_lock

Subversion Repositories Kolibri OS

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