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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2489 $
 
 
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
        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
        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
        je      .ok
 
        mov     edx, [edx+SRV.fd]
        jmp     @B
.not_load:
        pop     ebp
        jmp     load_driver
.ok:
        mov     eax, edx
        ret
endp
 
align 4
proc reg_service stdcall, name:dword, handler:dword
 
        push    ebx
 
        xor     eax, eax
 
        cmp     [name], eax
        je      .fail
 
        cmp     [handler], eax
        je      .fail
 
        mov     eax, sizeof.SRV
        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
        popad
        ret
endp
 
; description
;  allocate kernel memory and loads the specified file
;
; param
;  file_name= full 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
 
 
 
 
 
 
 
 
 
 
 
        mov     ecx, unpack_mutex
 
        call    mutex_lock
 
        stdcall unpack, [file], eax
 
        call    mutex_unlock
 
        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
 
uglobal
align 4
unpack_mutex MUTEX
endg
 
align 4
proc get_proc_ex stdcall, proc_name:dword, imports:dword
 
.look_up:
        mov     edx, [imports]
        test    edx, edx
        jz      .end
        mov     edx, [edx]
        test    edx, edx
        jz      .end
.next:
        mov     eax, [edx]
        test    eax, eax
        jz      .next_table
 
        push    edx
        stdcall strncmp, eax, [proc_name], 256
        pop     edx
        test    eax, eax
        jz      .ok
 
        add     edx, 8
        jmp     .next
.next_table:
        add     [imports], 4
        jmp     .look_up
.ok:
        mov     eax, [edx+4]
        ret
.end:
        xor     eax, eax
        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
 
        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
 
align 4
proc load_driver stdcall, driver_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             start     dd ?
 
             exports   dd ?   ;fake exports table
                       dd ?
             file_name rb 13+16+4+1      ; '/sys/drivers/.obj'
           endl
 
        lea     edx, [file_name]
        mov     dword [edx], '/sys'
        mov     dword [edx+4], '/dri'
        mov     dword [edx+8], 'vers'
        mov     byte [edx+12], '/'
        mov     esi, [driver_name]
.redo:
        lea     edx, [file_name]
        lea     edi, [edx+13]
        mov     ecx, 16
@@:
        lodsb
        test    al, al
        jz      @f
        stosb
        loop    @b
@@:
        mov     dword [edi], '.obj'
        mov     byte [edi+4], 0
        stdcall load_file, edx
 
        test    eax, eax
        jz      .exit
 
        mov     [coff], eax
 
        movzx   ecx, [eax+COFF_HEADER.nSections]
        xor     ebx, ebx
 
        lea     edx, [eax+20]
@@:
        add     ebx, [edx+COFF_SECTION.SizeOfRawData]
        add     ebx, 15
        and     ebx, not 15
        add     edx, sizeof.COFF_SECTION
        dec     ecx
        jnz     @B
        mov     [img_size], ebx
 
        stdcall kernel_alloc, ebx
        test    eax, eax
        jz      .fail
        mov     [img_base], eax
 
        mov     edi, eax
        xor     eax, eax
        mov     ecx, [img_size]
        add     ecx, 4095
        and     ecx, not 4095
        shr     ecx, 2
        cld
        rep stosd
 
        mov     edx, [coff]
        movzx   ebx, [edx+COFF_HEADER.nSections]
        mov     edi, [img_base]
        lea     eax, [edx+20]
@@:
        mov     [eax+COFF_SECTION.VirtualAddress], edi
        mov     esi, [eax+COFF_SECTION.PtrRawData]
        test    esi, esi
        jnz     .copy
        add     edi, [eax+COFF_SECTION.SizeOfRawData]
        jmp     .next
.copy:
        add     esi, edx
        mov     ecx, [eax+COFF_SECTION.SizeOfRawData]
        cld
        rep movsb
.next:
        add     edi, 15
        and     edi, not 15
        add     eax, sizeof.COFF_SECTION
        dec     ebx
        jnz     @B
 
        mov     ebx, [edx+COFF_HEADER.pSymTable]
        add     ebx, edx
        mov     [sym], ebx
        mov     ecx, [edx+COFF_HEADER.nSymbols]
        add     ecx, ecx
        lea     ecx, [ecx+ecx*8];ecx*=18 = nSymbols*CSYM_SIZE
        add     ecx, [sym]
        mov     [strings], ecx
 
        lea     ebx, [exports]
        mov     dword [ebx], kernel_export
        mov     dword [ebx+4], 0
        lea     eax, [edx+20]
 
        stdcall fix_coff_symbols, eax, [sym], [edx+COFF_HEADER.nSymbols], \
                [strings], ebx
        test    eax, eax
        jz      .link_fail
 
        mov     ebx, [coff]
        stdcall fix_coff_relocs, ebx, [sym], 0
 
        stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szVersion
        test    eax, eax
        jz      .link_fail
 
        mov     eax, [eax]
        shr     eax, 16
        cmp     eax, DRV_COMPAT
        jb      .ver_fail
 
        cmp     eax, DRV_CURRENT
        ja      .ver_fail
 
        mov     ebx, [coff]
        stdcall get_coff_sym, [sym], [ebx+COFF_HEADER.nSymbols], szSTART
        mov     [start], eax
 
        stdcall kernel_free, [coff]
 
        mov     ebx, [start]
        stdcall ebx, DRV_ENTRY
        test    eax, eax
        jnz     .ok
 
        stdcall kernel_free, [img_base]
        cmp     dword [file_name+13], 'SOUN'
        jnz     @f
        cmp     dword [file_name+17], 'D.ob'
        jnz     @f
        cmp     word [file_name+21], 'j'
        jnz     @f
        mov     esi, aHDA
        jmp     .redo
@@:
        xor     eax, eax
        ret
.ok:
        mov     ebx, [img_base]
        mov     [eax+SRV.base], ebx
        mov     ecx, [start]
        mov     [eax+SRV.entry], ecx
        ret
 
.ver_fail:
        mov     esi, msg_CR
        call    sys_msg_board_str
        mov     esi, [driver_name]
        call    sys_msg_board_str
        mov     esi, msg_CR
        call    sys_msg_board_str
        mov     esi, msg_version
        call    sys_msg_board_str
        mov     esi, msg_www
        call    sys_msg_board_str
        jmp     .cleanup
 
.link_fail:
        mov     esi, msg_module
        call    sys_msg_board_str
        mov     esi, [driver_name]
        call    sys_msg_board_str
        mov     esi, msg_CR
        call    sys_msg_board_str
.cleanup:
        stdcall kernel_free, [img_base]
.fail:
        stdcall kernel_free, [coff]
.exit:
        xor     eax, eax
        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
           locals
             fullname  rb 260
             fileinfo  rb 40
             coff      dd ?
             img_base  dd ?
           endl
 
        cli
 
; resolve file name
        mov     ebx, [file_name]
        lea     edi, [fullname+1]
        mov     byte [edi-1], '/'
        stdcall get_full_file_name, edi, 259
        test    al, al
        jz      .fail
 
; scan for required DLL in list of already loaded for this process,
; ignore timestamp
        mov     esi, [CURRENT_TASK]
        shl     esi, 8
        lea     edi, [fullname]
        mov     ebx, [esi+SLOT_BASE+APPDATA.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]
        ret
.next_in_process:
        mov     esi, [esi+HDLL.fd]
        jmp     .scan_in_process
.not_in_process:
 
; scan in full list, compare timestamp
        lea     eax, [fileinfo]
        stdcall get_fileinfo, edi, eax
        test    eax, eax
        jnz     .fail
        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:
; 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
; 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
 
; 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]
 
.dll_already_loaded:
        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_USER
        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]
        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:
        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
        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_slot]
        mov     eax, [ebx+APPDATA.dlls_list_ptr]
        test    eax, eax
        jnz     .ret
        push    [ebx+APPDATA.dir_table]
        mov     eax, 8
        call    malloc
        pop     edx
        test    eax, eax
        jz      .ret
        mov     [eax], eax
        mov     [eax+4], eax
        mov     ecx, [TASK_COUNT]
        mov     ebx, SLOT_BASE+256
.set:
        cmp     [ebx+APPDATA.dir_table], edx
        jnz     @f
        mov     [ebx+APPDATA.dlls_list_ptr], eax
@@:
        add     ebx, 256
        dec     ecx
        jnz     .set
.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
        push    eax
        mov     ebx, [eax+HDLL.base]
        mov     esi, [eax+HDLL.parent]
        mov     edx, [esi+DLLDESCR.size]
; The following actions require the context of application where HDLL is mapped.
; However, destroy_hdll can be called in the context of OS thread when
; cleaning up objects created by the application which is destroyed.
; So remember current cr3 and set it to page table of target.
        mov     eax, [ecx+APPDATA.dir_table]
; Because we cheat with cr3, disable interrupts: task switch would restore
; page table from APPDATA of current thread.
; Also set [current_slot] because it is used by user_free.
        pushf
        cli
        push    [current_slot]
        mov     [current_slot], ecx
        mov     ecx, cr3
        push    ecx
        mov     cr3, eax
        push    ebx     ; argument for user_free
        mov     eax, ebx
        shr     ebx, 12
        push    ebx
        mov     esi, [esi+DLLDESCR.data]
        shr     esi, 12
.unmap_loop:
        push    eax
        mov     eax, 2
        xchg    eax, [page_tabs+ebx*4]
        mov     ecx, [page_tabs+esi*4]
        and     eax, not 0xFFF
        and     ecx, not 0xFFF
        cmp     eax, ecx
        jz      @f
        call    free_page
@@:
        pop     eax
        invlpg  [eax]
        add     eax, 0x1000
        inc     ebx
        inc     esi
        sub     edx, 0x1000
        ja      .unmap_loop
        pop     ebx
        and     dword [page_tabs+(ebx-1)*4], not DONT_FREE_BLOCK
        call    user_free
; Restore context.
        pop     eax
        mov     cr3, eax
        pop     [current_slot]
        popf
; Ok, cheating is done.
        pop     eax
        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

Rev 2486	Rev 2489
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. 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: 2486 $	8	$Revision: 2489 $
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	ret	146	ret
147	.fail:	147	.fail:
148	xor eax, eax	148	xor eax, eax
149	not eax	149	not eax
150	mov [esi+output], eax	150	mov [esi+output], eax
151	mov [esi+out_size], 4	151	mov [esi+out_size], 4
152	ret	152	ret
153	.err:	153	.err:
154	xor eax, eax	154	xor eax, eax
155	not eax	155	not eax
156	ret	156	ret
157	endp	157	endp
158		158
159	; param	159	; param
160	; ecx= io_control	160	; ecx= io_control
161	;	161	;
162	; retval	162	; retval
163	; eax= error code	163	; eax= error code
164		164
165	align 4	165	align 4
166	srv_handlerEx:	166	srv_handlerEx:
167	cmp ecx, OS_BASE	167	cmp ecx, OS_BASE
168	jae .fail	168	jae .fail
169		169
170	mov eax, [ecx+handle]	170	mov eax, [ecx+handle]
171	cmp [eax+SRV.magic], ' SRV'	171	cmp [eax+SRV.magic], ' SRV'
172	jne .fail	172	jne .fail
173		173
174	cmp [eax+SRV.size], sizeof.SRV	174	cmp [eax+SRV.size], sizeof.SRV
175	jne .fail	175	jne .fail
176		176
177	stdcall [eax+SRV.srv_proc], ecx	177	stdcall [eax+SRV.srv_proc], ecx
178	ret	178	ret
179	.fail:	179	.fail:
180	or eax, -1	180	or eax, -1
181	ret	181	ret
182		182
183	restore handle	183	restore handle
184	restore io_code	184	restore io_code
185	restore input	185	restore input
186	restore inp_size	186	restore inp_size
187	restore output	187	restore output
188	restore out_size	188	restore out_size
189		189
190	align 4	190	align 4
191	proc get_service stdcall, sz_name:dword	191	proc get_service stdcall, sz_name:dword
192	mov eax, [sz_name]	192	mov eax, [sz_name]
193	test eax, eax	193	test eax, eax
194	jnz @F	194	jnz @F
195	ret	195	ret
196	@@:	196	@@:
197	mov edx, [srv.fd]	197	mov edx, [srv.fd]
198	@@:	198	@@:
199	cmp edx, srv.fd-SRV.fd	199	cmp edx, srv.fd-SRV.fd
200	je .not_load	200	je .not_load
201		201
202	stdcall strncmp, edx, [sz_name], 16	202	stdcall strncmp, edx, [sz_name], 16
203	test eax, eax	203	test eax, eax
204	je .ok	204	je .ok
205		205
206	mov edx, [edx+SRV.fd]	206	mov edx, [edx+SRV.fd]
207	jmp @B	207	jmp @B
208	.not_load:	208	.not_load:
209	pop ebp	209	pop ebp
210	jmp load_driver	210	jmp load_driver
211	.ok:	211	.ok:
212	mov eax, edx	212	mov eax, edx
213	ret	213	ret
214	endp	214	endp
215		215
216	align 4	216	align 4
217	proc reg_service stdcall, name:dword, handler:dword	217	proc reg_service stdcall, name:dword, handler:dword
218		218
219	push ebx	219	push ebx
220		220
221	xor eax, eax	221	xor eax, eax
222		222
223	cmp [name], eax	223	cmp [name], eax
224	je .fail	224	je .fail
225		225
226	cmp [handler], eax	226	cmp [handler], eax
227	je .fail	227	je .fail
228		228
229	mov eax, sizeof.SRV	229	mov eax, sizeof.SRV
230	call malloc	230	call malloc
231	test eax, eax	231	test eax, eax
232	jz .fail	232	jz .fail
233		233
234	push esi	234	push esi
235	push edi	235	push edi
236	mov edi, eax	236	mov edi, eax
237	mov esi, [name]	237	mov esi, [name]
238	movsd	238	movsd
239	movsd	239	movsd
240	movsd	240	movsd
241	movsd	241	movsd
242	pop edi	242	pop edi
243	pop esi	243	pop esi
244		244
245	mov [eax+SRV.magic], ' SRV'	245	mov [eax+SRV.magic], ' SRV'
246	mov [eax+SRV.size], sizeof.SRV	246	mov [eax+SRV.size], sizeof.SRV
247		247
248	mov ebx, srv.fd-SRV.fd	248	mov ebx, srv.fd-SRV.fd
249	mov edx, [ebx+SRV.fd]	249	mov edx, [ebx+SRV.fd]
250	mov [eax+SRV.fd], edx	250	mov [eax+SRV.fd], edx
251	mov [eax+SRV.bk], ebx	251	mov [eax+SRV.bk], ebx
252	mov [ebx+SRV.fd], eax	252	mov [ebx+SRV.fd], eax
253	mov [edx+SRV.bk], eax	253	mov [edx+SRV.bk], eax
254		254
255	mov ecx, [handler]	255	mov ecx, [handler]
256	mov [eax+SRV.srv_proc], ecx	256	mov [eax+SRV.srv_proc], ecx
257	pop ebx	257	pop ebx
258	ret	258	ret
259	.fail:	259	.fail:
260	xor eax, eax	260	xor eax, eax
261	pop ebx	261	pop ebx
262	ret	262	ret
263	endp	263	endp
264		264
265	align 4	265	align 4
266	proc get_proc stdcall, exp:dword, sz_name:dword	266	proc get_proc stdcall, exp:dword, sz_name:dword
267		267
268	mov edx, [exp]	268	mov edx, [exp]
269	.next:	269	.next:
270	mov eax, [edx]	270	mov eax, [edx]
271	test eax, eax	271	test eax, eax
272	jz .end	272	jz .end
273		273
274	push edx	274	push edx
275	stdcall strncmp, eax, [sz_name], 16	275	stdcall strncmp, eax, [sz_name], 16
276	pop edx	276	pop edx
277	test eax, eax	277	test eax, eax
278	jz .ok	278	jz .ok
279		279
280	add edx, 8	280	add edx, 8
281	jmp .next	281	jmp .next
282	.ok:	282	.ok:
283	mov eax, [edx+4]	283	mov eax, [edx+4]
284	.end:	284	.end:
285	ret	285	ret
286	endp	286	endp
287		287
288	align 4	288	align 4
289	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	289	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
290		290
291	@@:	291	@@:
292	stdcall strncmp, [pSym], [sz_sym], 8	292	stdcall strncmp, [pSym], [sz_sym], 8
293	test eax, eax	293	test eax, eax
294	jz .ok	294	jz .ok
295	add [pSym], 18	295	add [pSym], 18
296	dec [count]	296	dec [count]
297	jnz @b	297	jnz @b
298	xor eax, eax	298	xor eax, eax
299	ret	299	ret
300	.ok:	300	.ok:
301	mov eax, [pSym]	301	mov eax, [pSym]
302	mov eax, [eax+8]	302	mov eax, [eax+8]
303	ret	303	ret
304	endp	304	endp
305		305
306	align 4	306	align 4
307	proc get_curr_task	307	proc get_curr_task
308	mov eax, [CURRENT_TASK]	308	mov eax, [CURRENT_TASK]
309	shl eax, 8	309	shl eax, 8
310	ret	310	ret
311	endp	311	endp
312		312
313	align 4	313	align 4
314	proc get_fileinfo stdcall, file_name:dword, info:dword	314	proc get_fileinfo stdcall, file_name:dword, info:dword
315	locals	315	locals
316	cmd dd ?	316	cmd dd ?
317	offset dd ?	317	offset dd ?
318	dd ?	318	dd ?
319	count dd ?	319	count dd ?
320	buff dd ?	320	buff dd ?
321	db ?	321	db ?
322	name dd ?	322	name dd ?
323	endl	323	endl
324		324
325	xor eax, eax	325	xor eax, eax
326	mov ebx, [file_name]	326	mov ebx, [file_name]
327	mov ecx, [info]	327	mov ecx, [info]
328		328
329	mov [cmd], 5	329	mov [cmd], 5
330	mov [offset], eax	330	mov [offset], eax
331	mov [offset+4], eax	331	mov [offset+4], eax
332	mov [count], eax	332	mov [count], eax
333	mov [buff], ecx	333	mov [buff], ecx
334	mov byte [buff+4], al	334	mov byte [buff+4], al
335	mov [name], ebx	335	mov [name], ebx
336		336
337	mov eax, 70	337	mov eax, 70
338	lea ebx, [cmd]	338	lea ebx, [cmd]
339	int 0x40	339	int 0x40
340	ret	340	ret
341	endp	341	endp
342		342
343	align 4	343	align 4
344	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\	344	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
345	bytes:dword	345	bytes:dword
346	locals	346	locals
347	cmd dd ?	347	cmd dd ?
348	offset dd ?	348	offset dd ?
349	dd ?	349	dd ?
350	count dd ?	350	count dd ?
351	buff dd ?	351	buff dd ?
352	db ?	352	db ?
353	name dd ?	353	name dd ?
354	endl	354	endl
355		355
356	xor eax, eax	356	xor eax, eax
357	mov ebx, [file_name]	357	mov ebx, [file_name]
358	mov ecx, [off]	358	mov ecx, [off]
359	mov edx, [bytes]	359	mov edx, [bytes]
360	mov esi, [buffer]	360	mov esi, [buffer]
361		361
362	mov [cmd], eax	362	mov [cmd], eax
363	mov [offset], ecx	363	mov [offset], ecx
364	mov [offset+4], eax	364	mov [offset+4], eax
365	mov [count], edx	365	mov [count], edx
366	mov [buff], esi	366	mov [buff], esi
367	mov byte [buff+4], al	367	mov byte [buff+4], al
368	mov [name], ebx	368	mov [name], ebx
369		369
370	pushad	370	pushad
371	lea ebx, [cmd]	371	lea ebx, [cmd]
372	call file_system_lfn	372	call file_system_lfn
373	popad	373	popad
374	ret	374	ret
375	endp	375	endp
376		376
377	; description	377	; description
378	; allocate kernel memory and loads the specified file	378	; allocate kernel memory and loads the specified file
379	;	379	;
380	; param	380	; param
381	; file_name= full path to file	381	; file_name= full path to file
382	;	382	;
383	; retval	383	; retval
384	; eax= file image in kernel memory	384	; eax= file image in kernel memory
385	; ebx= size of file	385	; ebx= size of file
386	;	386	;
387	; warging	387	; warging
388	; You mast call kernel_free() to delete each file	388	; You mast call kernel_free() to delete each file
389	; loaded by the load_file() function	389	; loaded by the load_file() function
390		390
391	align 4	391	align 4
392	proc load_file stdcall, file_name:dword	392	proc load_file stdcall, file_name:dword
393	locals	393	locals
394	attr dd ?	394	attr dd ?
395	flags dd ?	395	flags dd ?
396	cr_time dd ?	396	cr_time dd ?
397	cr_date dd ?	397	cr_date dd ?
398	acc_time dd ?	398	acc_time dd ?
399	acc_date dd ?	399	acc_date dd ?
400	mod_time dd ?	400	mod_time dd ?
401	mod_date dd ?	401	mod_date dd ?
402	file_size dd ?	402	file_size dd ?
403		403
404	file dd ?	404	file dd ?
405	file2 dd ?	405	file2 dd ?
406	endl	406	endl
407		407
408	push esi	408	push esi
409	push edi	409	push edi
410		410
411	lea eax, [attr]	411	lea eax, [attr]
412	stdcall get_fileinfo, [file_name], eax	412	stdcall get_fileinfo, [file_name], eax
413	test eax, eax	413	test eax, eax
414	jnz .fail	414	jnz .fail
415		415
416	mov eax, [file_size]	416	mov eax, [file_size]
417	cmp eax, 1024102416	417	cmp eax, 1024102416
418	ja .fail	418	ja .fail
419		419
420	stdcall kernel_alloc, [file_size]	420	stdcall kernel_alloc, [file_size]
421	mov [file], eax	421	mov [file], eax
422	test eax, eax	422	test eax, eax
423	jz .fail	423	jz .fail
424		424
425	stdcall read_file, [file_name], eax, dword 0, [file_size]	425	stdcall read_file, [file_name], eax, dword 0, [file_size]
426	cmp ebx, [file_size]	426	cmp ebx, [file_size]
427	jne .cleanup	427	jne .cleanup
428		428
429	mov eax, [file]	429	mov eax, [file]
430	cmp dword [eax], 0x4B43504B	430	cmp dword [eax], 0x4B43504B
431	jne .exit	431	jne .exit
432	mov ebx, [eax+4]	432	mov ebx, [eax+4]
433	mov [file_size], ebx	433	mov [file_size], ebx
434	stdcall kernel_alloc, ebx	434	stdcall kernel_alloc, ebx
435		435
436	test eax, eax	436	test eax, eax
437	jz .cleanup	437	jz .cleanup
438		438
439	mov [file2], eax	439	mov [file2], eax
440		-
441	push eax	-
442	.wait_lock:	-
443	cmp [unpack_mutex], 0	-
444	je .get_lock	-
445	call change_task	-
446	jmp .wait_lock	-
447		-
448	.get_lock:	-
449	mov eax, 1	440
450	xchg eax, [unpack_mutex]	-
451	test eax, eax	441	mov ecx, unpack_mutex
452	jnz .wait_lock	-
453	pop eax	442	call mutex_lock
454		443
455	stdcall unpack, [file], eax	444	stdcall unpack, [file], eax
456		445
457	mov [unpack_mutex], 0	446	call mutex_unlock
458		447
459	stdcall kernel_free, [file]	448	stdcall kernel_free, [file]
460	mov eax, [file2]	449	mov eax, [file2]
461	mov ebx, [file_size]	450	mov ebx, [file_size]
462	.exit:	451	.exit:
463	push eax	452	push eax
464	lea edi, [eax+ebx] ;cleanup remain space	453	lea edi, [eax+ebx] ;cleanup remain space
465	mov ecx, 4096 ;from file end	454	mov ecx, 4096 ;from file end
466	and ebx, 4095	455	and ebx, 4095
467	jz @f	456	jz @f
468	sub ecx, ebx	457	sub ecx, ebx
469	xor eax, eax	458	xor eax, eax
470	cld	459	cld
471	rep stosb	460	rep stosb
472	@@:	461	@@:
473	mov ebx, [file_size]	462	mov ebx, [file_size]
474	pop eax	463	pop eax
475	pop edi	464	pop edi
476	pop esi	465	pop esi
477	ret	466	ret
478	.cleanup:	467	.cleanup:
479	stdcall kernel_free, [file]	468	stdcall kernel_free, [file]
480	.fail:	469	.fail:
481	xor eax, eax	470	xor eax, eax
482	xor ebx, ebx	471	xor ebx, ebx
483	pop edi	472	pop edi
484	pop esi	473	pop esi
485	ret	474	ret
486	endp	475	endp
487		476
488	iglobal	477	uglobal
489	align 4	478	align 4
490	unpack_mutex dd 0	479	unpack_mutex MUTEX
491	endg	480	endg
492		481
493	align 4	482	align 4
494	proc get_proc_ex stdcall, proc_name:dword, imports:dword	483	proc get_proc_ex stdcall, proc_name:dword, imports:dword
495		484
496	.look_up:	485	.look_up:
497	mov edx, [imports]	486	mov edx, [imports]
498	test edx, edx	487	test edx, edx
499	jz .end	488	jz .end
500	mov edx, [edx]	489	mov edx, [edx]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 2486 → 2489