WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/dll.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5596 $
 
 
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
 
        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
           locals
             fullname  rb 260
             fileinfo  rb 40
             coff      dd ?
             img_base  dd ?
           endl
 
; 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
        cli
 
        mov     esi, [current_process]
        lea     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
        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:
        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:
        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
 
 
 
; 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
 
 

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/dll.inc – Rev 5593 → 5596