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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 6792 → 6926