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: 5577 $
 
 
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
 
 
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
;  eñõ= 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
 
 
align 4
create_futex:
        mov     ecx, sizeof.FUTEX
        call    create_object
        test    eax, eax
        jz .fail
 
        mov     [eax+FUTEX.magic], 'FUTX'
        mov     [eax+FUTEX.destroy], 0
        lea     ecx, [eax+FUTEX.wait_list]
        list_init ecx
        mov     [eax+FUTEX.pointer], 0
        mov     [eax+FUTEX.flags], 0
 
.fail:
        ret


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

Subversion Repositories Kolibri OS

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