WebSVN – Kolibri OS – Diff – /kernel/trunk/core/dll.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;;  Distributed under terms of the GNU General Public License.  ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9976 $
 
 
DRV_COMPAT   =  5  ;minimal required drivers version
DRV_CURRENT  =  6  ;current drivers model version
 
DRV_VERSION = (DRV_COMPAT shl 16) or DRV_CURRENT
PID_KERNEL  = 1    ;os_idle thread
 
 
 
align 4
proc get_notify stdcall, p_ev:dword
 
.wait:
        mov     ebx, [current_slot]
        test    dword [ebx + APPDATA.event_mask], EVENT_NOTIFY
        jz      @f
        and     dword [ebx + APPDATA.event_mask], not EVENT_NOTIFY
        mov     edi, [p_ev]
        mov     dword [edi], EV_INTR
        mov     eax, [ebx + APPDATA.event]
        mov     dword [edi+4], eax
        ret
@@:
        call    change_task
        jmp     .wait
endp
 
 
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
 
align 4
proc srv_handler stdcall, ioctl:dword
        mov     esi, [ioctl]
        test    esi, esi
        jz      .err
 
        mov     edi, [esi + handle]
        cmp     [edi + SRV.magic], ' SRV'
        jne     .fail
 
        cmp     [edi + SRV.size], sizeof.SRV
        jne     .fail
 
;        stdcall [edi+SRV.srv_proc], esi
        mov     eax, [edi + SRV.srv_proc]
        test    eax, eax
        jz      .fail
        stdcall eax, esi
        ret
.fail:
        xor     eax, eax
        not     eax
        mov     [esi + output], eax
        mov     [esi + out_size], 4
        ret
.err:
        xor     eax, eax
        not     eax
        ret
endp
 
; param
;  ecx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
        cmp     ecx, OS_BASE
        jae     .fail
 
        mov     eax, [ecx + handle]
 
        cmp     eax, OS_BASE
        jbe     .fail
 
        cmp     [eax + SRV.magic], ' SRV'
        jne     .fail
 
        cmp     [eax + SRV.size], sizeof.SRV
        jne     .fail
 
;        stdcall [eax+SRV.srv_proc], ecx
        mov     eax, [eax + SRV.srv_proc]
        test    eax, eax
        jz      .fail
        stdcall eax, ecx
        ret
.fail:
        or      eax, -1
        ret
 
restore  handle
restore  io_code
restore  input
restore  inp_size
restore  output
restore  out_size
 
align 4
proc get_service stdcall, sz_name:dword
        mov     eax, [sz_name]
        test    eax, eax
        jnz     @F
        ret
@@:
        mov     edx, [srv.fd]
@@:
        cmp     edx, srv.fd - SRV.fd
        je      .not_load
 
        stdcall strncmp, edx, [sz_name], 16
        test    eax, eax
        mov     eax, edx
        je      .nothing
 
        mov     edx, [edx + SRV.fd]
        jmp     @B
.not_load:
        mov     eax, [sz_name]
        push    edi
        sub     esp, 36
        mov     edi, esp
        mov     dword [edi], '/sys'
        mov     dword [edi+4], '/dri'
        mov     dword [edi+8], 'vers'
        mov     byte [edi+12], '/'
@@:
        mov     dl, [eax]
        mov     [edi+13], dl
        inc     eax
        inc     edi
        test    dl, dl
        jnz     @b
        mov     dword [edi+12], '.sys'
        mov     byte [edi+16], 0
        mov     edi, esp
        stdcall load_pe_driver, edi, 0
        add     esp, 36
        pop     edi
.nothing:
        ret
endp
 
reg_service:
        xor     eax, eax
        mov     ecx, [esp+8]
        ;jecxz   .nothing
        push    sizeof.SRV
        push    ecx
        pushd   [esp+12]
        call    reg_service_ex
.nothing:
        ret     8
 
reg_usb_driver:
        push    sizeof.USBSRV
        pushd   [esp+12]
        pushd   [esp+12]
        call    reg_service_ex
        test    eax, eax
        jz      .nothing
        mov     ecx, [esp+12]
        mov     [eax+USBSRV.usb_func], ecx
.nothing:
        ret     12
 
proc reg_service_ex stdcall, name:dword, handler:dword, srvsize:dword
 
        push    ebx
 
        xor     eax, eax
 
        cmp     [name], eax
        je      .fail
 
;        cmp     [handler], eax
;        je      .fail
 
        mov     eax, [srvsize]
        call    malloc
        test    eax, eax
        jz      .fail
 
        push    esi
        push    edi
        mov     edi, eax
        mov     esi, [name]
        movsd
        movsd
        movsd
        movsd
        pop     edi
        pop     esi
 
        mov     [eax + SRV.magic], ' SRV'
        mov     [eax + SRV.size], sizeof.SRV
 
        mov     ebx, srv.fd - SRV.fd
        mov     edx, [ebx + SRV.fd]
        mov     [eax + SRV.fd], edx
        mov     [eax + SRV.bk], ebx
        mov     [ebx + SRV.fd], eax
        mov     [edx + SRV.bk], eax
 
        mov     ecx, [handler]
        mov     [eax + SRV.srv_proc], ecx
        ;dec     [count_services]
        pop     ebx
        ret
.fail:
        xor     eax, eax
        pop     ebx
        ret
endp
 
align 4
stop_all_services:      ;used in shutdown system
        push    ebp
        mov     edx, [srv.fd]
.next:
        cmp     edx, srv.fd - SRV.fd
        je      .done
        cmp     [edx + SRV.magic], ' SRV'
        jne     .next
        cmp     [edx + SRV.size], sizeof.SRV
        jne     .next
 
        mov     ebx, [edx + SRV.entry]
        mov     edx, [edx + SRV.fd]
        test    ebx, ebx
        jz      .next
 
        push    edx
        mov     ebp, esp
        push    0
        push    DRV_EXIT
        call    ebx  ;stdcall
        mov     esp, ebp
        pop     edx
        jmp     .next
.done:
        pop     ebp
        ret
 
align 4
proc get_proc stdcall, exp:dword, sz_name:dword
 
        mov     edx, [exp]
.next:
        mov     eax, [edx]
        test    eax, eax
        jz      .end
 
        push    edx
        stdcall strncmp, eax, [sz_name], 16
        pop     edx
        test    eax, eax
        jz      .ok
 
        add     edx, 8
        jmp     .next
.ok:
        mov     eax, [edx+4]
.end:
        ret
endp
 
align 4
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
 
@@:
        stdcall strncmp, [pSym], [sz_sym], sizeof.COFF_SYM.Name
        test    eax, eax
        jz      .ok
        add     [pSym], sizeof.COFF_SYM
        dec     [count]
        jnz     @b
        xor     eax, eax
        ret
.ok:
        mov     eax, [pSym]
        mov     eax, [eax+COFF_SYM.Value]
        ret
endp
 
 
align 4
proc get_fileinfo stdcall, file_name:dword, info:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
        xor     eax, eax
        mov     ebx, [file_name]
        mov     ecx, [info]
 
        mov     [cmd], 5
        mov     [offset], eax
        mov     [offset+4], eax
        mov     [count], eax
        mov     [buff], ecx
        mov     byte [buff+4], al
        mov     [name], ebx
 
        mov     eax, 70
        lea     ebx, [cmd]
        pushad
        cld
        call    protect_from_terminate
        call    file_system_lfn
        call    unprotect_from_terminate
        popad
        ret
endp
 
align 4
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
                                     bytes:dword
           locals
             cmd     dd ?
             offset  dd ?
                     dd ?
             count   dd ?
             buff    dd ?
                     db ?
             name    dd ?
           endl
 
        xor     eax, eax
        mov     ebx, [file_name]
        mov     ecx, [off]
        mov     edx, [bytes]
        mov     esi, [buffer]
 
        mov     [cmd], eax
        mov     [offset], ecx
        mov     [offset+4], eax
        mov     [count], edx
        mov     [buff], esi
        mov     byte [buff+4], al
        mov     [name], ebx
 
        pushad
        lea     ebx, [cmd]
        call    file_system_lfn_protected
        popad
        ret
endp
 
align 4
; @brief Allocate kernel memory and loads the specified file
;
; @param file_name Path to file
;
; @returns File image in kernel memory in `eax` and size of file in `ebx`
;
; @warning You must call kernel_free() to delete each file loaded by the
;          load_file() function
proc load_file stdcall, file_name:dword
           locals
             attr       dd ?
             flags      dd ?
             cr_time    dd ?
             cr_date    dd ?
             acc_time   dd ?
             acc_date   dd ?
             mod_time   dd ?
             mod_date   dd ?
             file_size  dd ?
 
             file       dd ?
             file2      dd ?
           endl
 
        push    esi
        push    edi
 
        lea     eax, [attr]
        stdcall get_fileinfo, [file_name], eax
        test    eax, eax
        jnz     .fail
 
        mov     eax, [file_size]
        cmp     eax, 1024*1024*16
        ja      .fail
 
        stdcall kernel_alloc, [file_size]
        mov     [file], eax
        test    eax, eax
        jz      .fail
 
        stdcall read_file, [file_name], eax, dword 0, [file_size]
        cmp     ebx, [file_size]
        jne     .cleanup
 
        mov     eax, [file]
        cmp     dword [eax], 'KPCK'
        jne     .exit
        mov     ebx, [eax+4]
        mov     [file_size], ebx
        stdcall kernel_alloc, ebx
 
        test    eax, eax
        jz      .cleanup
 
        mov     [file2], eax
 
        pushad
        mov     ecx, unpack_mutex
        call    mutex_lock
        popad
 
        stdcall unpack, [file], eax
 
        pushad
        mov     ecx, unpack_mutex
        call    mutex_unlock
        popad
 
        stdcall kernel_free, [file]
        mov     eax, [file2]
        mov     ebx, [file_size]
.exit:
        push    eax
        lea     edi, [eax+ebx]    ;cleanup remain space
        mov     ecx, 4096         ;from file end
        and     ebx, 4095
        jz      @f
        sub     ecx, ebx
        xor     eax, eax
        cld
        rep stosb
@@:
        mov     ebx, [file_size]
        pop     eax
        pop     edi
        pop     esi
        ret
.cleanup:
        stdcall kernel_free, [file]
.fail:
        xor     eax, eax
        xor     ebx, ebx
        pop     edi
        pop     esi
        ret
endp
 
; description
;  allocate user memory and loads the specified file
;
; param
;  file_name= path to file
;
; retval
;  eax= file image in user memory
;  ebx= size of file
;
; warging
;  You mast call kernel_free() to delete each file
;  loaded by the load_file() function
 
align 4
proc load_file_umode stdcall, file_name:dword
           locals
             attr       dd ?
             flags      dd ?
             cr_time    dd ?
             cr_date    dd ?
             acc_time   dd ?
             acc_date   dd ?
             mod_time   dd ?
             mod_date   dd ?
             file_size  dd ?
 
             km_file    dd ?
             um_file    dd ?
           endl
 
        push    esi
        push    edi
        push    ebx
 
        lea     eax, [attr]
        stdcall get_fileinfo, [file_name], eax   ;find file and get info
        test    eax, eax
        jnz     .err_1
 
        mov     eax, [file_size]
        cmp     eax, 1024*1024*1024                ;to be enough for anybody 1Gbt(c)
        ja      .err_1
                                                 ;it is very likely that the file is packed
        stdcall kernel_alloc, [file_size]        ;with kpack, so allocate memory from kernel heap
        mov     [km_file], eax
        test    eax, eax
        jz      .err_1
 
        stdcall read_file, [file_name], eax, dword 0, [file_size]
        cmp     ebx, [file_size]
 
        jne     .err_2
 
        mov     eax, [km_file]
        cmp     dword [eax], 'KPCK'              ; check kpack signature
        jne     .raw_file
 
        mov     ebx, [eax+4]                     ;get real size of file
        mov     [file_size], ebx
        stdcall user_alloc, ebx                  ;and allocate space from user heap
        mov     [um_file], eax
        test    eax, eax
        jz      .err_2
 
        mov     edx, [file_size]                 ;preallocate page memory
        shr     eax, 10
        lea     edi, [page_tabs + eax]
        add     edx, 4095
        shr     edx, 12
@@:
        call    alloc_page
        test    eax, eax
        jz      .err_3
 
        or      eax, PG_UWR
        stosd
        dec     edx
        jnz     @B
 
        pushad
        mov     ecx, unpack_mutex
        call    mutex_lock
 
        stdcall unpack, [km_file], [um_file]
 
        mov     ecx, unpack_mutex
        call    mutex_unlock
        popad
 
        stdcall kernel_free, [km_file]           ;we don't need packed file anymore
.exit:
 
        mov     edi, [um_file]
        mov     esi, [um_file]
        mov     eax, [file_size]
        mov     edx, eax
 
        add     edi, eax                         ;cleanup remain space
        mov     ecx, 4096                        ;from file end
        and     eax, 4095
        jz      @f
        sub     ecx, eax
        xor     eax, eax
        cld
        rep stosb
@@:
        mov     eax, [um_file]
 
        pop     ebx
        pop     edi
        pop     esi
        ret
 
.raw_file:                                       ; sometimes we load unpacked file
        stdcall user_alloc, ebx                  ; allocate space from user heap
        mov     [um_file], eax
 
        test    eax, eax
        jz      .err_2
 
        shr     eax, 10                          ; and remap pages.
 
        mov     ecx, [file_size]
        add     ecx, 4095
        shr     ecx, 12
 
        mov     esi, [km_file]
        shr     esi, 10
        add     esi, page_tabs
 
        lea     edi, [page_tabs+eax]
 
        cld
@@:
        lodsd
        and     eax, 0xFFFFF000
        or      eax, PG_UWR
        stosd
        loop    @B
 
        stdcall free_kernel_space, [km_file]     ; release allocated kernel space
        jmp     .exit                            ; physical pages still in use
.err_3:
        stdcall user_free, [um_file]
.err_2:
        stdcall kernel_free, [km_file]
.err_1:
        xor     eax, eax
        xor     edx, edx
 
        pop     ebx
        pop     edi
        pop     esi
        ret
endp
 
 
uglobal
align 4
unpack_mutex MUTEX
endg
 
align 4
proc get_proc_ex stdcall uses ebx esi, proc_name:dword, imports:dword
        mov     ebx, [imports]
        test    ebx, ebx
        jz      .end
        xor     esi, esi
.look_up:
 
        mov     eax, [ebx+32]
        mov     eax, [OS_BASE + eax + esi*4]
        add     eax, OS_BASE
        stdcall strncmp, eax, [proc_name], 256
        test    eax, eax
        jz      .ok
 
        inc     esi
        cmp     esi, [ebx+24]
        jb      .look_up
.end:
        xor     eax, eax
        ret
.ok:
        mov     eax, [ebx+28]
        mov     eax, [OS_BASE + eax + esi*4]
        add     eax, OS_BASE
        ret
endp
 
align 4
proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\
                      sym_count:dword, strings:dword, imports:dword
           locals
             retval dd ?
           endl
 
        mov     edi, [symbols]
        mov     [retval], 1
.fix:
        movzx   ebx, [edi + COFF_SYM.SectionNumber]
        test    ebx, ebx
        jnz     .internal
        mov     eax, dword [edi + COFF_SYM.Name]
        test    eax, eax
        jnz     @F
 
        mov     edi, [edi+4]
        add     edi, [strings]
@@:
        push    edi
        stdcall get_proc_ex, edi, [imports]
        pop     edi
 
        xor     ebx, ebx
        test    eax, eax
        jnz     @F
 
        ; disable debug msg
        ;mov     esi, msg_unresolved
        ;call    sys_msg_board_str
        ;mov     esi, edi
        ;call    sys_msg_board_str
        ;mov     esi, msg_CR
        ;call    sys_msg_board_str
 
        mov     [retval], 0
@@:
        mov     edi, [symbols]
        mov     [edi + COFF_SYM.Value], eax
        jmp     .next
.internal:
        cmp     bx, -1
        je      .next
        cmp     bx, -2
        je      .next
 
        dec     ebx
        shl     ebx, 3
        lea     ebx, [ebx + ebx*4]
        add     ebx, [sec]
 
        mov     eax, [ebx + COFF_SECTION.VirtualAddress]
        add     [edi + COFF_SYM.Value], eax
.next:
        add     edi, sizeof.COFF_SYM
        mov     [symbols], edi
        dec     [sym_count]
        jnz     .fix
        mov     eax, [retval]
        ret
endp
 
align 4
proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \
        delta:dword
           locals
             n_sec     dd ?
           endl
 
        mov     eax, [coff]
        movzx   ebx, [eax + COFF_HEADER.nSections]
        mov     [n_sec], ebx
        lea     esi, [eax+20]
.fix_sec:
        mov     edi, [esi + COFF_SECTION.PtrReloc]
        add     edi, [coff]
 
        movzx   ecx, [esi + COFF_SECTION.NumReloc]
        test    ecx, ecx
        jz      .next
.reloc_loop:
        mov     ebx, [edi + COFF_RELOC.SymIndex]
        add     ebx, ebx
        lea     ebx, [ebx+ebx*8]
        add     ebx, [sym]
 
        mov     edx, [ebx + COFF_SYM.Value]
 
        cmp     [edi + COFF_RELOC.Type], 6
        je      .dir_32
 
        cmp     [edi + COFF_RELOC.Type], 20
        jne     .next_reloc
.rel_32:
        mov     eax, [edi + COFF_RELOC.VirtualAddress]
        add     eax, [esi + COFF_SECTION.VirtualAddress]
        sub     edx, eax
        sub     edx, 4
        jmp     .fix
.dir_32:
        mov     eax, [edi + COFF_RELOC.VirtualAddress]
        add     eax, [esi + COFF_SECTION.VirtualAddress]
.fix:
        add     eax, [delta]
        add     [eax], edx
.next_reloc:
        add     edi, 10
        dec     ecx
        jnz     .reloc_loop
.next:
        add     esi, sizeof.COFF_SECTION
        dec     [n_sec]
        jnz     .fix_sec
.exit:
        ret
endp
 
align 4
proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
        delta:dword
           locals
             n_sec     dd ?
           endl
 
        mov     eax, [coff]
        movzx   ebx, [eax + COFF_HEADER.nSections]
        mov     [n_sec], ebx
        lea     esi, [eax+20]
        mov     edx, [delta]
.fix_sec:
        mov     edi, [esi + COFF_SECTION.PtrReloc]
        add     edi, [coff]
 
        movzx   ecx, [esi + COFF_SECTION.NumReloc]
        test    ecx, ecx
        jz      .next
.reloc_loop:
        cmp     [edi + COFF_RELOC.Type], 6
        jne     .next_reloc
.dir_32:
        mov     eax, [edi + COFF_RELOC.VirtualAddress]
        add     eax, [esi + COFF_SECTION.VirtualAddress]
        add     [eax + edx], edx
.next_reloc:
        add     edi, 10
        dec     ecx
        jnz     .reloc_loop
.next:
        add     esi, sizeof.COFF_SECTION
        dec     [n_sec]
        jnz     .fix_sec
.exit:
        ret
endp
 
; in: edx -> COFF_SECTION struct
; out: eax = alignment as mask for bits to drop
coff_get_align:
; Rules:
; - if alignment is not given, use default = 4K;
; - if alignment is given and is no more than 4K, use it;
; - if alignment is more than 4K, revert to 4K.
        push    ecx
        mov     cl, byte [edx + COFF_SECTION.Characteristics+2]
        mov     eax, 1
        shr     cl, 4
        dec     cl
        js      .default
        cmp     cl, 12
        jbe     @f
.default:
        mov     cl, 12
@@:
        shl     eax, cl
        pop     ecx
        dec     eax
        ret
 
align 4
proc load_library stdcall, file_name:dword, encoding:dword
    locals
        fullname    dd  ?
        fileinfo    rb  40
        coff        dd  ?
        img_base    dd  ?
    endl
 
; resolve file name
        stdcall kernel_alloc, maxPathLength
        mov     [fullname], eax
        mov     edi, eax
        mov     esi, [file_name]
        mov     eax, [encoding]
        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
        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     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
 
; calculate size of loaded DLL
        mov     edx, [coff]
        movzx   ecx, [edx + COFF_HEADER.nSections]
        xor     ebx, ebx
 
        add     edx, sizeof.COFF_HEADER
@@:
        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
        test    ebx, ebx
        jz      .fail_and_free_dll
        cmp     ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR
        ja      .fail_and_free_dll
; allocate memory for kernel-side image
        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]
@@:
        mov     [esi + DLLDESCR.defaultbase], ecx
        mov     [dll_cur_addr], edx
 
; copy sections and set correct values for VirtualAddress'es in headers
        push    esi
        mov     edx, [coff]
        movzx   ebx, [edx + COFF_HEADER.nSections]
        mov     edi, eax
        add     edx, 20
        cld
@@:
        call    coff_get_align
        add     ecx, eax
        add     edi, eax
        not     eax
        and     ecx, eax
        and     edi, eax
        mov     [edx + COFF_SECTION.VirtualAddress], ecx
        add     ecx, [edx + COFF_SECTION.SizeOfRawData]
        mov     esi, [edx + COFF_SECTION.PtrRawData]
        push    ecx
        mov     ecx, [edx + COFF_SECTION.SizeOfRawData]
        test    esi, esi
        jnz     .copy
        xor     eax, eax
        rep stosb
        jmp     .next
.copy:
        add     esi, [coff]
        rep movsb
.next:
        pop     ecx
        add     edx, sizeof.COFF_SECTION
        dec     ebx
        jnz     @B
        pop     esi
 
; save some additional data from COFF file
; later we will use COFF header, headers for sections and symbol table
; 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, sizeof.COFF_HEADER
@@:
        movzx   eax, [edx + COFF_SECTION.NumReloc]
        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
        jz      .fail_and_free_data
        mov     edx, [coff]
        movzx   ecx, [edx + COFF_HEADER.nSections]
        lea     ecx, [ecx*5]
        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
        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     edx, sizeof.COFF_SECTION
        dec     eax
        jnz     @b
        pop     esi
 
; fixup symbols
        mov     edx, ebx
        mov     eax, [ebx + COFF_HEADER.nSymbols]
        add     edx, sizeof.COFF_HEADER
        mov     ecx, [esi + DLLDESCR.symbols_num]
        lea     ecx, [ecx*9]
        add     ecx, ecx
        add     ecx, [esi + DLLDESCR.symbols_ptr]
 
        stdcall fix_coff_symbols, edx, [esi + DLLDESCR.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 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]
        mov     edx, [ebx + APPDATA.tid]
        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, -PAGE_SIZE
        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
        add     edi, PAGE_SIZE
        cmp     edi, [esi + DLLDESCR.size]
        jb      .map_pages_loop
 
; 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     eax, [esi + DLLDESCR.exports]
        sub     eax, [esi + DLLDESCR.defaultbase]
        add     eax, [img_base]
        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
 
.fail_and_free_user:
        stdcall user_free, [img_base]
.fail_and_dereference:
        mov     eax, 1  ; delete 1 reference
        call    dereference_dll
        sti
        xor     eax, eax
        ret
endp
 
; 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
        test    eax, eax
        jz      .ret
 
        mov     [eax], eax
        mov     [eax+4], eax
 
        mov     ebx, [current_process]
        mov     [ebx + PROC.dlls_list_ptr], eax
.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
        pop     edi esi ecx ebx
        ret
 
; ecx -> APPDATA for slot, esi = dlls_list_ptr
destroy_all_hdlls:
        test    esi, esi
        jz      .ret
.loop:
        mov     eax, [esi + HDLL.fd]
        cmp     eax, esi
        jz      free
        call    destroy_hdll
        jmp     .loop
.ret:
        ret
 
; param
;  eax= size
;  ebx= pid
 
align 4
create_kernel_object:
 
        push    ebx
        call    malloc
        pop     ebx
        test    eax, eax
        jz      .fail
 
        mov     ecx, [current_slot]
        add     ecx, APP_OBJ_OFFSET
 
        pushfd
        cli
        mov     edx, [ecx + APPOBJ.fd]
        mov     [eax + APPOBJ.fd], edx
        mov     [eax + APPOBJ.bk], ecx
        mov     [eax + APPOBJ.pid], ebx
 
        mov     [ecx + APPOBJ.fd], eax
        mov     [edx + APPOBJ.bk], eax
        popfd
.fail:
        ret
 
; param
;  eax= object
 
align 4
destroy_kernel_object:
 
        pushfd
        cli
        mov     ebx, [eax + APPOBJ.fd]
        mov     ecx, [eax + APPOBJ.bk]
        mov     [ebx + APPOBJ.bk], ecx
        mov     [ecx + APPOBJ.fd], ebx
        popfd
 
        xor     edx, edx       ;clear common header
        mov     [eax], edx
        mov     [eax+4], edx
        mov     [eax+8], edx
        mov     [eax+12], edx
        mov     [eax+16], edx
 
        call    free           ;release object memory
        ret
 
 
;void* __fastcall create_object(size_t size)
; param
;  ecx= size
 
align 4
create_object:
 
        push    esi
        push    edi
        pushfd
        cli
 
        mov     esi, [current_process]
        mov     eax, [esi + PROC.ht_free]
        mov     edi, [esi + PROC.ht_next]
        dec     eax
        js      .err0
 
        mov     [esi + PROC.ht_free], eax
        mov     eax, [esi + PROC.htab + edi*4]
        mov     [esi + PROC.ht_next], eax
        popfd
 
        mov     eax, ecx
        call    malloc
        test    eax, eax
        jz      .err1
 
        mov     [eax + FUTEX.handle], edi
        mov     [esi + PROC.htab+edi*4], eax
        pop     edi
        pop     esi
        ret
 
.err1:
        pushfd
        cli
 
        mov     eax, [esi + PROC.ht_next]
        mov     [esi + PROC.htab+edi*4], eax
        mov     [esi + PROC.ht_next], edi
        inc     [esi + PROC.ht_free]
.err0:
        popfd
        pop     edi
        pop     esi
        xor     eax, eax
        ret
 
 
;int __fastcall destroy_object(struct object *obj)
 
align 4
destroy_object:
        push    esi
        mov     esi, [current_process]
        mov     edx, [ecx + FUTEX.handle]
 
        pushfd
        cli
 
        mov     eax, [esi + PROC.ht_next]
        mov     [esi + PROC.htab + edx*4], eax
        mov     [esi + PROC.ht_next], edx
        inc     [esi + PROC.ht_free]
 
        popfd
        pop     esi
 
        mov     eax, ecx
        call    free
        xor     eax, eax
        ret
.fail:
        popfd
        pop     esi
        mov     eax, -1
        ret

Rev 9872	Rev 9976
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2022. 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: 9872 $	8	$Revision: 9976 $
9		9
10		10
11	DRV_COMPAT = 5 ;minimal required drivers version	11	DRV_COMPAT = 5 ;minimal required drivers version
12	DRV_CURRENT = 6 ;current drivers model version	12	DRV_CURRENT = 6 ;current drivers model version
13		13
14	DRV_VERSION = (DRV_COMPAT shl 16) or DRV_CURRENT	14	DRV_VERSION = (DRV_COMPAT shl 16) or DRV_CURRENT
15	PID_KERNEL = 1 ;os_idle thread	15	PID_KERNEL = 1 ;os_idle thread
16		16
17		17
18		18
19	align 4	19	align 4
20	proc get_notify stdcall, p_ev:dword	20	proc get_notify stdcall, p_ev:dword
21		21
22	.wait:	22	.wait:
23	mov ebx, [current_slot]	23	mov ebx, [current_slot]
24	test dword [ebx + APPDATA.event_mask], EVENT_NOTIFY	24	test dword [ebx + APPDATA.event_mask], EVENT_NOTIFY
25	jz @f	25	jz @f
26	and dword [ebx + APPDATA.event_mask], not EVENT_NOTIFY	26	and dword [ebx + APPDATA.event_mask], not EVENT_NOTIFY
27	mov edi, [p_ev]	27	mov edi, [p_ev]
28	mov dword [edi], EV_INTR	28	mov dword [edi], EV_INTR
29	mov eax, [ebx + APPDATA.event]	29	mov eax, [ebx + APPDATA.event]
30	mov dword [edi+4], eax	30	mov dword [edi+4], eax
31	ret	31	ret
32	@@:	32	@@:
33	call change_task	33	call change_task
34	jmp .wait	34	jmp .wait
35	endp	35	endp
36		36
37		37
38		38
39	handle equ IOCTL.handle	39	handle equ IOCTL.handle
40	io_code equ IOCTL.io_code	40	io_code equ IOCTL.io_code
41	input equ IOCTL.input	41	input equ IOCTL.input
42	inp_size equ IOCTL.inp_size	42	inp_size equ IOCTL.inp_size
43	output equ IOCTL.output	43	output equ IOCTL.output
44	out_size equ IOCTL.out_size	44	out_size equ IOCTL.out_size
45		45
46		46
47	align 4	47	align 4
48	proc srv_handler stdcall, ioctl:dword	48	proc srv_handler stdcall, ioctl:dword
49	mov esi, [ioctl]	49	mov esi, [ioctl]
50	test esi, esi	50	test esi, esi
51	jz .err	51	jz .err
52		52
53	mov edi, [esi + handle]	53	mov edi, [esi + handle]
54	cmp [edi + SRV.magic], ' SRV'	54	cmp [edi + SRV.magic], ' SRV'
55	jne .fail	55	jne .fail
56		56
57	cmp [edi + SRV.size], sizeof.SRV	57	cmp [edi + SRV.size], sizeof.SRV
58	jne .fail	58	jne .fail
59		59
60	; stdcall [edi+SRV.srv_proc], esi	60	; stdcall [edi+SRV.srv_proc], esi
61	mov eax, [edi + SRV.srv_proc]	61	mov eax, [edi + SRV.srv_proc]
62	test eax, eax	62	test eax, eax
63	jz .fail	63	jz .fail
64	stdcall eax, esi	64	stdcall eax, esi
65	ret	65	ret
66	.fail:	66	.fail:
67	xor eax, eax	67	xor eax, eax
68	not eax	68	not eax
69	mov [esi + output], eax	69	mov [esi + output], eax
70	mov [esi + out_size], 4	70	mov [esi + out_size], 4
71	ret	71	ret
72	.err:	72	.err:
73	xor eax, eax	73	xor eax, eax
74	not eax	74	not eax
75	ret	75	ret
76	endp	76	endp
77		77
78	; param	78	; param
79	; ecx= io_control	79	; ecx= io_control
80	;	80	;
81	; retval	81	; retval
82	; eax= error code	82	; eax= error code
83		83
84	align 4	84	align 4
85	srv_handlerEx:	85	srv_handlerEx:
86	cmp ecx, OS_BASE	86	cmp ecx, OS_BASE
87	jae .fail	87	jae .fail
88		88
89	mov eax, [ecx + handle]	89	mov eax, [ecx + handle]
90		90
91	cmp eax, OS_BASE	91	cmp eax, OS_BASE
92	jbe .fail	92	jbe .fail
93		93
94	cmp [eax + SRV.magic], ' SRV'	94	cmp [eax + SRV.magic], ' SRV'
95	jne .fail	95	jne .fail
96		96
97	cmp [eax + SRV.size], sizeof.SRV	97	cmp [eax + SRV.size], sizeof.SRV
98	jne .fail	98	jne .fail
99		99
100	; stdcall [eax+SRV.srv_proc], ecx	100	; stdcall [eax+SRV.srv_proc], ecx
101	mov eax, [eax + SRV.srv_proc]	101	mov eax, [eax + SRV.srv_proc]
102	test eax, eax	102	test eax, eax
103	jz .fail	103	jz .fail
104	stdcall eax, ecx	104	stdcall eax, ecx
105	ret	105	ret
106	.fail:	106	.fail:
107	or eax, -1	107	or eax, -1
108	ret	108	ret
109		109
110	restore handle	110	restore handle
111	restore io_code	111	restore io_code
112	restore input	112	restore input
113	restore inp_size	113	restore inp_size
114	restore output	114	restore output
115	restore out_size	115	restore out_size
116		116
117	align 4	117	align 4
118	proc get_service stdcall, sz_name:dword	118	proc get_service stdcall, sz_name:dword
119	mov eax, [sz_name]	119	mov eax, [sz_name]
120	test eax, eax	120	test eax, eax
121	jnz @F	121	jnz @F
122	ret	122	ret
123	@@:	123	@@:
124	mov edx, [srv.fd]	124	mov edx, [srv.fd]
125	@@:	125	@@:
126	cmp edx, srv.fd - SRV.fd	126	cmp edx, srv.fd - SRV.fd
127	je .not_load	127	je .not_load
128		128
129	stdcall strncmp, edx, [sz_name], 16	129	stdcall strncmp, edx, [sz_name], 16
130	test eax, eax	130	test eax, eax
131	mov eax, edx	131	mov eax, edx
132	je .nothing	132	je .nothing
133		133
134	mov edx, [edx + SRV.fd]	134	mov edx, [edx + SRV.fd]
135	jmp @B	135	jmp @B
136	.not_load:	136	.not_load:
137	mov eax, [sz_name]	137	mov eax, [sz_name]
138	push edi	138	push edi
139	sub esp, 36	139	sub esp, 36
140	mov edi, esp	140	mov edi, esp
141	mov dword [edi], '/sys'	141	mov dword [edi], '/sys'
142	mov dword [edi+4], '/dri'	142	mov dword [edi+4], '/dri'
143	mov dword [edi+8], 'vers'	143	mov dword [edi+8], 'vers'
144	mov byte [edi+12], '/'	144	mov byte [edi+12], '/'
145	@@:	145	@@:
146	mov dl, [eax]	146	mov dl, [eax]
147	mov [edi+13], dl	147	mov [edi+13], dl
148	inc eax	148	inc eax
149	inc edi	149	inc edi
150	test dl, dl	150	test dl, dl
151	jnz @b	151	jnz @b
152	mov dword [edi+12], '.sys'	152	mov dword [edi+12], '.sys'
153	mov byte [edi+16], 0	153	mov byte [edi+16], 0
154	mov edi, esp	154	mov edi, esp
155	stdcall load_pe_driver, edi, 0	155	stdcall load_pe_driver, edi, 0
156	add esp, 36	156	add esp, 36
157	pop edi	157	pop edi
158	.nothing:	158	.nothing:
159	ret	159	ret
160	endp	160	endp
161		161
162	reg_service:	162	reg_service:
163	xor eax, eax	163	xor eax, eax
164	mov ecx, [esp+8]	164	mov ecx, [esp+8]
165	;jecxz .nothing	165	;jecxz .nothing
166	push sizeof.SRV	166	push sizeof.SRV
167	push ecx	167	push ecx
168	pushd [esp+12]	168	pushd [esp+12]
169	call reg_service_ex	169	call reg_service_ex
170	.nothing:	170	.nothing:
171	ret 8	171	ret 8
172		172
173	reg_usb_driver:	173	reg_usb_driver:
174	push sizeof.USBSRV	174	push sizeof.USBSRV
175	pushd [esp+12]	175	pushd [esp+12]
176	pushd [esp+12]	176	pushd [esp+12]
177	call reg_service_ex	177	call reg_service_ex
178	test eax, eax	178	test eax, eax
179	jz .nothing	179	jz .nothing
180	mov ecx, [esp+12]	180	mov ecx, [esp+12]
181	mov [eax+USBSRV.usb_func], ecx	181	mov [eax+USBSRV.usb_func], ecx
182	.nothing:	182	.nothing:
183	ret 12	183	ret 12
184		184
185	proc reg_service_ex stdcall, name:dword, handler:dword, srvsize:dword	185	proc reg_service_ex stdcall, name:dword, handler:dword, srvsize:dword
186		186
187	push ebx	187	push ebx
188		188
189	xor eax, eax	189	xor eax, eax
190		190
191	cmp [name], eax	191	cmp [name], eax
192	je .fail	192	je .fail
193		193
194	; cmp [handler], eax	194	; cmp [handler], eax
195	; je .fail	195	; je .fail
196		196
197	mov eax, [srvsize]	197	mov eax, [srvsize]
198	call malloc	198	call malloc
199	test eax, eax	199	test eax, eax
200	jz .fail	200	jz .fail
201		201
202	push esi	202	push esi
203	push edi	203	push edi
204	mov edi, eax	204	mov edi, eax
205	mov esi, [name]	205	mov esi, [name]
206	movsd	206	movsd
207	movsd	207	movsd
208	movsd	208	movsd
209	movsd	209	movsd
210	pop edi	210	pop edi
211	pop esi	211	pop esi
212		212
213	mov [eax + SRV.magic], ' SRV'	213	mov [eax + SRV.magic], ' SRV'
214	mov [eax + SRV.size], sizeof.SRV	214	mov [eax + SRV.size], sizeof.SRV
215		215
216	mov ebx, srv.fd - SRV.fd	216	mov ebx, srv.fd - SRV.fd
217	mov edx, [ebx + SRV.fd]	217	mov edx, [ebx + SRV.fd]
218	mov [eax + SRV.fd], edx	218	mov [eax + SRV.fd], edx
219	mov [eax + SRV.bk], ebx	219	mov [eax + SRV.bk], ebx
220	mov [ebx + SRV.fd], eax	220	mov [ebx + SRV.fd], eax
221	mov [edx + SRV.bk], eax	221	mov [edx + SRV.bk], eax
222		222
223	mov ecx, [handler]	223	mov ecx, [handler]
224	mov [eax + SRV.srv_proc], ecx	224	mov [eax + SRV.srv_proc], ecx
225	;dec [count_services]	225	;dec [count_services]
226	pop ebx	226	pop ebx
227	ret	227	ret
228	.fail:	228	.fail:
229	xor eax, eax	229	xor eax, eax
230	pop ebx	230	pop ebx
231	ret	231	ret
232	endp	232	endp
233		233
234	align 4	234	align 4
235	stop_all_services: ;used in shutdown system	235	stop_all_services: ;used in shutdown system
236	push ebp	236	push ebp
237	mov edx, [srv.fd]	237	mov edx, [srv.fd]
238	.next:	238	.next:
239	cmp edx, srv.fd - SRV.fd	239	cmp edx, srv.fd - SRV.fd
240	je .done	240	je .done
241	cmp [edx + SRV.magic], ' SRV'	241	cmp [edx + SRV.magic], ' SRV'
242	jne .next	242	jne .next
243	cmp [edx + SRV.size], sizeof.SRV	243	cmp [edx + SRV.size], sizeof.SRV
244	jne .next	244	jne .next
245		245
246	mov ebx, [edx + SRV.entry]	246	mov ebx, [edx + SRV.entry]
247	mov edx, [edx + SRV.fd]	247	mov edx, [edx + SRV.fd]
248	test ebx, ebx	248	test ebx, ebx
249	jz .next	249	jz .next
250		250
251	push edx	251	push edx
252	mov ebp, esp	252	mov ebp, esp
253	push 0	253	push 0
254	push DRV_EXIT	254	push DRV_EXIT
255	call ebx ;stdcall	255	call ebx ;stdcall
256	mov esp, ebp	256	mov esp, ebp
257	pop edx	257	pop edx
258	jmp .next	258	jmp .next
259	.done:	259	.done:
260	pop ebp	260	pop ebp
261	ret	261	ret
262		262
263	align 4	263	align 4
264	proc get_proc stdcall, exp:dword, sz_name:dword	264	proc get_proc stdcall, exp:dword, sz_name:dword
265		265
266	mov edx, [exp]	266	mov edx, [exp]
267	.next:	267	.next:
268	mov eax, [edx]	268	mov eax, [edx]
269	test eax, eax	269	test eax, eax
270	jz .end	270	jz .end
271		271
272	push edx	272	push edx
273	stdcall strncmp, eax, [sz_name], 16	273	stdcall strncmp, eax, [sz_name], 16
274	pop edx	274	pop edx
275	test eax, eax	275	test eax, eax
276	jz .ok	276	jz .ok
277		277
278	add edx, 8	278	add edx, 8
279	jmp .next	279	jmp .next
280	.ok:	280	.ok:
281	mov eax, [edx+4]	281	mov eax, [edx+4]
282	.end:	282	.end:
283	ret	283	ret
284	endp	284	endp
285		285
286	align 4	286	align 4
287	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	287	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
288		288
289	@@:	289	@@:
290	stdcall strncmp, [pSym], [sz_sym], sizeof.COFF_SYM.Name	290	stdcall strncmp, [pSym], [sz_sym], sizeof.COFF_SYM.Name
291	test eax, eax	291	test eax, eax
292	jz .ok	292	jz .ok
293	add [pSym], sizeof.COFF_SYM	293	add [pSym], sizeof.COFF_SYM
294	dec [count]	294	dec [count]
295	jnz @b	295	jnz @b
296	xor eax, eax	296	xor eax, eax
297	ret	297	ret
298	.ok:	298	.ok:
299	mov eax, [pSym]	299	mov eax, [pSym]
300	mov eax, [eax+COFF_SYM.Value]	300	mov eax, [eax+COFF_SYM.Value]
301	ret	301	ret
302	endp	302	endp
303		303
304		304
305	align 4	305	align 4
306	proc get_fileinfo stdcall, file_name:dword, info:dword	306	proc get_fileinfo stdcall, file_name:dword, info:dword
307	locals	307	locals
308	cmd dd ?	308	cmd dd ?
309	offset dd ?	309	offset dd ?
310	dd ?	310	dd ?
311	count dd ?	311	count dd ?
312	buff dd ?	312	buff dd ?
313	db ?	313	db ?
314	name dd ?	314	name dd ?
315	endl	315	endl
316		316
317	xor eax, eax	317	xor eax, eax
318	mov ebx, [file_name]	318	mov ebx, [file_name]
319	mov ecx, [info]	319	mov ecx, [info]
320		320
321	mov [cmd], 5	321	mov [cmd], 5
322	mov [offset], eax	322	mov [offset], eax
323	mov [offset+4], eax	323	mov [offset+4], eax
324	mov [count], eax	324	mov [count], eax
325	mov [buff], ecx	325	mov [buff], ecx
326	mov byte [buff+4], al	326	mov byte [buff+4], al
327	mov [name], ebx	327	mov [name], ebx
328		328
329	mov eax, 70	329	mov eax, 70
330	lea ebx, [cmd]	330	lea ebx, [cmd]
331	pushad	331	pushad
332	cld	332	cld
333	call protect_from_terminate	333	call protect_from_terminate
334	call file_system_lfn	334	call file_system_lfn
335	call unprotect_from_terminate	335	call unprotect_from_terminate
336	popad	336	popad
337	ret	337	ret
338	endp	338	endp
339		339
340	align 4	340	align 4
341	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	341	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
342	bytes:dword	342	bytes:dword
343	locals	343	locals
344	cmd dd ?	344	cmd dd ?
345	offset dd ?	345	offset dd ?
346	dd ?	346	dd ?
347	count dd ?	347	count dd ?
348	buff dd ?	348	buff dd ?
349	db ?	349	db ?
350	name dd ?	350	name dd ?
351	endl	351	endl
352		352
353	xor eax, eax	353	xor eax, eax
354	mov ebx, [file_name]	354	mov ebx, [file_name]
355	mov ecx, [off]	355	mov ecx, [off]
356	mov edx, [bytes]	356	mov edx, [bytes]
357	mov esi, [buffer]	357	mov esi, [buffer]
358		358
359	mov [cmd], eax	359	mov [cmd], eax
360	mov [offset], ecx	360	mov [offset], ecx
361	mov [offset+4], eax	361	mov [offset+4], eax
362	mov [count], edx	362	mov [count], edx
363	mov [buff], esi	363	mov [buff], esi
364	mov byte [buff+4], al	364	mov byte [buff+4], al
365	mov [name], ebx	365	mov [name], ebx
366		366
367	pushad	367	pushad
368	lea ebx, [cmd]	368	lea ebx, [cmd]
369	call file_system_lfn_protected	369	call file_system_lfn_protected
370	popad	370	popad
371	ret	371	ret
372	endp	372	endp
373		373
374	align 4	374	align 4
375	; @brief Allocate kernel memory and loads the specified file	375	; @brief Allocate kernel memory and loads the specified file
376	;	376	;
377	; @param file_name Path to file	377	; @param file_name Path to file
378	;	378	;
379	; @returns File image in kernel memory in `eax` and size of file in `ebx`	379	; @returns File image in kernel memory in `eax` and size of file in `ebx`
380	;	380	;
381	; @warning You must call kernel_free() to delete each file loaded by the	381	; @warning You must call kernel_free() to delete each file loaded by the
382	; load_file() function	382	; load_file() function
383	proc load_file stdcall, file_name:dword	383	proc load_file stdcall, file_name:dword
384	locals	384	locals
385	attr dd ?	385	attr dd ?
386	flags dd ?	386	flags dd ?
387	cr_time dd ?	387	cr_time dd ?
388	cr_date dd ?	388	cr_date dd ?
389	acc_time dd ?	389	acc_time dd ?
390	acc_date dd ?	390	acc_date dd ?
391	mod_time dd ?	391	mod_time dd ?
392	mod_date dd ?	392	mod_date dd ?
393	file_size dd ?	393	file_size dd ?
394		394
395	file dd ?	395	file dd ?
396	file2 dd ?	396	file2 dd ?
397	endl	397	endl
398		398
399	push esi	399	push esi
400	push edi	400	push edi
401		401
402	lea eax, [attr]	402	lea eax, [attr]
403	stdcall get_fileinfo, [file_name], eax	403	stdcall get_fileinfo, [file_name], eax
404	test eax, eax	404	test eax, eax
405	jnz .fail	405	jnz .fail
406		406
407	mov eax, [file_size]	407	mov eax, [file_size]
408	cmp eax, 1024102416	408	cmp eax, 1024102416
409	ja .fail	409	ja .fail
410		410
411	stdcall kernel_alloc, [file_size]	411	stdcall kernel_alloc, [file_size]
412	mov [file], eax	412	mov [file], eax
413	test eax, eax	413	test eax, eax
414	jz .fail	414	jz .fail
415		415
416	stdcall read_file, [file_name], eax, dword 0, [file_size]	416	stdcall read_file, [file_name], eax, dword 0, [file_size]
417	cmp ebx, [file_size]	417	cmp ebx, [file_size]
418	jne .cleanup	418	jne .cleanup
419		419
420	mov eax, [file]	420	mov eax, [file]
421	cmp dword [eax], 'KPCK'	421	cmp dword [eax], 'KPCK'
422	jne .exit	422	jne .exit
423	mov ebx, [eax+4]	423	mov ebx, [eax+4]
424	mov [file_size], ebx	424	mov [file_size], ebx
425	stdcall kernel_alloc, ebx	425	stdcall kernel_alloc, ebx
426		426
427	test eax, eax	427	test eax, eax
428	jz .cleanup	428	jz .cleanup
429		429
430	mov [file2], eax	430	mov [file2], eax
431		431
432	pushad	432	pushad
433	mov ecx, unpack_mutex	433	mov ecx, unpack_mutex
434	call mutex_lock	434	call mutex_lock
435	popad	435	popad
436		436
437	stdcall unpack, [file], eax	437	stdcall unpack, [file], eax
438		438
439	pushad	439	pushad
440	mov ecx, unpack_mutex	440	mov ecx, unpack_mutex
441	call mutex_unlock	441	call mutex_unlock
442	popad	442	popad
443		443
444	stdcall kernel_free, [file]	444	stdcall kernel_free, [file]
445	mov eax, [file2]	445	mov eax, [file2]
446	mov ebx, [file_size]	446	mov ebx, [file_size]
447	.exit:	447	.exit:
448	push eax	448	push eax
449	lea edi, [eax+ebx] ;cleanup remain space	449	lea edi, [eax+ebx] ;cleanup remain space
450	mov ecx, 4096 ;from file end	450	mov ecx, 4096 ;from file end
451	and ebx, 4095	451	and ebx, 4095
452	jz @f	452	jz @f
453	sub ecx, ebx	453	sub ecx, ebx
454	xor eax, eax	454	xor eax, eax
455	cld	455	cld
456	rep stosb	456	rep stosb
457	@@:	457	@@:
458	mov ebx, [file_size]	458	mov ebx, [file_size]
459	pop eax	459	pop eax
460	pop edi	460	pop edi
461	pop esi	461	pop esi
462	ret	462	ret
463	.cleanup:	463	.cleanup:
464	stdcall kernel_free, [file]	464	stdcall kernel_free, [file]
465	.fail:	465	.fail:
466	xor eax, eax	466	xor eax, eax
467	xor ebx, ebx	467	xor ebx, ebx
468	pop edi	468	pop edi
469	pop esi	469	pop esi
470	ret	470	ret
471	endp	471	endp
472		472
473	; description	473	; description
474	; allocate user memory and loads the specified file	474	; allocate user memory and loads the specified file
475	;	475	;
476	; param	476	; param
477	; file_name= path to file	477	; file_name= path to file
478	;	478	;
479	; retval	479	; retval
480	; eax= file image in user memory	480	; eax= file image in user memory
481	; ebx= size of file	481	; ebx= size of file
482	;	482	;
483	; warging	483	; warging
484	; You mast call kernel_free() to delete each file	484	; You mast call kernel_free() to delete each file
485	; loaded by the load_file() function	485	; loaded by the load_file() function
486		486
487	align 4	487	align 4
488	proc load_file_umode stdcall, file_name:dword	488	proc load_file_umode stdcall, file_name:dword
489	locals	489	locals
490	attr dd ?	490	attr dd ?
491	flags dd ?	491	flags dd ?
492	cr_time dd ?	492	cr_time dd ?
493	cr_date dd ?	493	cr_date dd ?
494	acc_time dd ?	494	acc_time dd ?
495	acc_date dd ?	495	acc_date dd ?
496	mod_time dd ?	496	mod_time dd ?
497	mod_date dd ?	497	mod_date dd ?
498	file_size dd ?	498	file_size dd ?
499		499
500	km_file dd ?	500	km_file dd ?

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 4610 – Rev 9872 → 9976