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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2971 $
 
 
DRV_COMPAT   equ  5  ;minimal required drivers version
DRV_CURRENT  equ  5  ;current drivers model version
 
DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
PID_KERNEL  equ 1    ;os_idle thread
 
align 4
proc attach_int_handler stdcall, irq:dword, handler:dword, access_rights:dword
 
         push ebx
 
           mov  ebx, [irq]                   ;irq num
           test ebx, ebx
           jz   .err
           cmp  ebx, 15                      ; hidnplayr says: we only have 16 IRQ's
           ja   .err
           mov  eax, [handler]
           test eax, eax
           jz   .err
           cmp  [irq_owner + 4 * ebx], 0
           je   @f
 
           mov  ecx, [irq_rights + 4 * ebx]  ; Rights : 0 - full access, 1 - read only, 2 - forbidden
           test ecx, ecx
           jnz  .err
 
@@:
           mov  [irq_tab+ebx*4], eax
 
           mov  eax, [access_rights]
           mov  [irq_rights + 4 * ebx], eax
 
           mov  [irq_owner + 4 * ebx], PID_KERNEL  ; all handlers belong to a kernel
 
           stdcall enable_irq, [irq]
         pop ebx
           mov eax, 1
           ret
.err:
         pop ebx
           xor eax, eax
           ret
endp
 
uglobal
 
irq_rights   rd  16
 
endg
 
proc get_int_handler stdcall, irq:dword
 
           mov eax, [irq]
 
           cmp [irq_rights + 4 * eax], dword 1
           ja  .err
 
           mov eax, [irq_tab + 4 * eax]
           ret
 
.err:
           xor eax, eax
           ret
endp
 
align 4
proc  detach_int_handler
 
           ret
endp
 
align 4
proc enable_irq stdcall, irq_line:dword
           mov ebx, [irq_line]
           mov edx, 0x21
           cmp ebx, 8
           jb @F
           mov edx, 0xA1
           sub ebx,8
@@:
           in al,dx
           btr eax, ebx
           out dx, al
           ret
endp
 
align 16
;; proc irq_serv
 
irq_serv:
 
.irq_1:
           push 1
           jmp .main
align 4
.irq_2:
           push 2
           jmp .main
align 4
.irq_3:
           push 3
           jmp .main
align 4
.irq_4:
           push 4
           jmp .main
align 4
.irq_5:
           push 5
           jmp .main
align 4
.irq_6:
           push 6
           jmp .main
align 4
.irq_7:
           push 7
           jmp .main
align 4
.irq_8:
           push 8
           jmp .main
align 4
.irq_9:
           push 9
           jmp .main
align 4
.irq_10:
           push 10
           jmp .main
align 4
.irq_11:
           push 11
           jmp .main
align 4
.irq_12:
           push 12
           jmp .main
align 4
.irq_13:
           push 13
           jmp .main
align 4
.irq_14:
           push 14
           jmp .main
align 4
.irq_15:
           push 15
           jmp .main
 
align 16
.main:
           save_ring3_context
           mov   eax, [esp + 32]
           mov   bx, sel_app_data
           mov   ds, bx
           mov   es, bx
 
           cmp   [v86_irqhooks+eax*8], 0
           jnz   v86_irq
 
           mov ebx, [irq_tab+eax*4]
           test ebx, ebx
           jz .exit
 
           call ebx
           mov  [check_idle_semaphore],5
 
.exit:
 
           cmp dword [esp + 32], 8
           mov al, 0x20
           jb @f
 
           out 0xa0, al
@@:
           out 0x20, al
 
           restore_ring3_context
           add   esp, 4
 
           iret
 
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
_PciRead32:
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
_PciRead16:
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
_PciRead8:
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
_PciWrite8:
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
_PciWrite16:
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
_PciWrite32:
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], SRV_SIZE
           jne .fail
 
           stdcall [edi+SRV.srv_proc], esi
           ret
.fail:
           xor eax, eax
           not eax
           mov [esi+output], eax
           mov [esi+out_size], 4
           ret
.err:
           xor eax, eax
           not eax
           ret
endp
 
; param
;  ebx= io_control
;
; retval
;  eax= error code
 
align 4
srv_handlerEx:
           cmp ebx, OS_BASE
           jae .fail
 
           mov eax, [ebx+handle]
           cmp [eax+SRV.magic], ' SRV'
           jne .fail
 
           cmp [eax+SRV.size], SRV_SIZE
           jne .fail
 
           stdcall [eax+SRV.srv_proc], ebx
           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_OFFSET
           je .not_load
 
           stdcall strncmp, edx, [sz_name], 16
           test eax, eax
           je .ok
 
           mov edx, [edx+SRV.fd]
           jmp @B
.not_load:
           pop ebp
           jmp load_driver
.ok:
           mov eax, edx
           ret
endp
 
align 4
_RegService:
proc reg_service stdcall, name:dword, handler:dword
 
           push ebx
 
           xor eax, eax
 
           cmp [name], eax
           je .fail
 
           cmp [handler], eax
           je .fail
 
           mov eax, SRV_SIZE
           call malloc       ;call alloc_service
           test eax, eax
           jz .fail
 
           push esi
           push edi
           mov edi, eax
           mov esi, [name]
           mov ecx, 16/4
           rep movsd
           pop edi
           pop esi
 
           mov [eax+SRV.magic], ' SRV'
           mov [eax+SRV.size], SRV_SIZE
 
           mov ebx, srv.fd-SRV_FD_OFFSET
           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 ebx, [pSym]
           mov eax, [ebx+8]
           ret
endp
 
align 4
get_curr_task:
           mov eax,[CURRENT_TASK]
           shl eax, 8
           ret
 
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 0x41
           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
           push eax
           lea eax, [cmd]
           call file_system_lfn
           pop eax
           popad
           ret
endp
 
; description
;  allocate kernel memory and loads the specified file
;
; param
;  file_name= full path to file
;
; retval
;  eax= file image in kernel memory
;  ebx= size of file
;
; warging
;  You mast call mem_free() to delete each file
;  loaded by the load_file() function
 
align 4
_LoadFile:
_load_file@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 ecx, [file_size]
           cmp ecx, 1024*1024*16
           ja .fail
 
           mov edx, PG_SW
           call @mem_alloc@8
           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 ecx, [eax+4]
           mov [file_size], ecx
           mov edx, PG_SW
           call @mem_alloc@8
           test eax, eax
           jz .cleanup
 
           mov [file2], eax
           stdcall unpack, [file], eax
 
           mov ecx, [file]
           call @mem_free@4
 
           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:
           mov ecx, [file]
           call @mem_free@4
.fail:
           xor eax, eax
           xor ebx, ebx
           pop edi
           pop esi
           ret
endp
 
align 4
proc get_proc_ex stdcall, proc_name:dword, imports:dword
 
.look_up:
           mov edx, [imports]
           test edx, edx
           jz .end
           mov edx, [edx]
           test edx, edx
           jz .end
.next:
           mov eax, [edx]
           test eax, eax
           jz .next_table
 
           push edx
           stdcall strncmp, eax, [proc_name], 16
           pop edx
           test eax, eax
           jz .ok
 
           add edx,8
           jmp .next
.next_table:
           add [imports], 4
           jmp .look_up
.ok:
           mov eax, [edx+4]
           ret
.end:
           xor eax, eax
           ret
endp
 
align 4
proc fix_coff_symbols stdcall, 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+CSYM.SectionNumber]
           test ebx, ebx
           jnz .internal
           mov eax, dword [edi+CSYM.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+CSYM.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+CFS.VirtualAddress]
           add [edi+CSYM.Value], eax
.next:
           add edi, CSYM_SIZE
           mov [symbols], edi
           dec [sym_count]
           jnz .fix
           mov eax, [retval]
           ret
endp
 
align 4
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
           locals
             n_sec     dd ?
           endl
 
           mov eax, [coff]
           movzx ebx, [eax+CFH.nSections]
           mov [n_sec], ebx
.fix_sec:
           mov esi, [sec]
           mov edi, [esi+CFS.PtrReloc]
           add edi, [coff]
 
           movzx ecx, [esi+CFS.NumReloc]
           test ecx, ecx
           jz .next
.next_reloc:
           mov ebx, [edi+CRELOC.SymIndex]
           add ebx,ebx
           lea ebx,[ebx+ebx*8]
           add ebx, [sym]
 
           mov edx, [ebx+CSYM.Value]
 
           cmp [edi+CRELOC.Type], 6
           je .dir_32
 
           cmp [edi+CRELOC.Type], 20
           jne .next_reloc
.rel_32:
           mov eax, [edi+CRELOC.VirtualAddress]
           add eax, [esi+CFS.VirtualAddress]
           sub edx, eax
           sub edx, 4
           jmp .fix
.dir_32:
           mov eax, [edi+CRELOC.VirtualAddress]
           add eax, [esi+CFS.VirtualAddress]
.fix:
           add [eax], edx
           add edi, 10
           dec ecx
           jnz .next_reloc
.next:
           add [sec], COFF_SECTION_SIZE
           dec [n_sec]
           jnz .fix_sec
.exit:
           ret
endp
 
align 4
proc load_driver stdcall, driver_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             start     dd ?
 
             exports   dd ?   ;fake exports table
                   dd ?
             file_name rb 13+16+4+1  ; '/sys/drivers/.obj'
           endl
 
           lea     edx, [file_name]
           mov     dword [edx], '/sys'
           mov     dword [edx+4], '/dri'
           mov     dword [edx+8], 'vers'
           mov     byte [edx+12], '/'
           mov     esi, [driver_name]
.redo:
           lea     edx, [file_name]
           lea     edi, [edx+13]
           mov     ecx, 16
@@:
           lodsb
           test    al, al
           jz      @f
           stosb
           loop    @b
@@:
           mov     dword [edi], '.obj'
           mov     byte [edi+4], 0
           stdcall load_file, edx
           mov [coff], eax
           test eax, eax
           jz .exit
 
           movzx ebx, [eax+CFH.nSections]
           lea edx, [eax+20]
           xor ecx, ecx
@@:
           add ecx, [edx+CFS.SizeOfRawData]
           add ecx, 15
           and ecx, not 15
           add edx, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov [img_size], ecx
           mov edx, PG_SW
           call @mem_alloc@8
           test eax, eax
           mov [img_base], eax
           jz .fail
 
           mov [img_base], eax
 
           mov edi, eax
           xor eax, eax
           mov ecx, [img_size]
           add ecx, 4095
           and ecx, not 4095
           shr ecx, 2
           cld
           rep stosd
 
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, [img_base]
           lea eax, [edx+20]
@@:
           mov [eax+CFS.VirtualAddress], edi
           mov esi, [eax+CFS.PtrRawData]
           test esi, esi
           jnz .copy
           add edi, [eax+CFS.SizeOfRawData]
           jmp .next
.copy:
           add esi, edx
           mov ecx, [eax+CFS.SizeOfRawData]
           cld
           rep movsb
.next:
           add edi, 15
           and edi, not 15
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea ebx, [exports]
           mov dword [ebx], kernel_export
           mov dword [ebx+4], 0
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                         [strings], ebx
           test eax, eax
           jz .link_fail
 
           mov ebx, [coff]
           add ebx, 20
           stdcall fix_coff_relocs, [coff], ebx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
           test eax, eax
           jz .link_fail
 
           mov eax, [eax]
           shr eax, 16
           cmp eax, DRV_COMPAT
           jb .ver_fail
 
           cmp eax, DRV_CURRENT
           ja .ver_fail
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
           mov [start], eax
 
           mov ecx, [coff]
           call @mem_free@4
 
           mov ebx, [start]
           stdcall ebx, DRV_ENTRY
           test eax, eax
           jnz .ok
 
           mov ecx, [img_base]
           call @mem_free@4
           xor eax, eax
           ret
.ok:
           mov ebx, [img_base]
           mov [eax+SRV.base], ebx
           mov ecx, [start]
           mov [eax+SRV.entry], ecx
           ret
 
.ver_fail:
           mov esi, msg_CR
           call sys_msg_board_str
           mov esi, [driver_name]
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
           mov esi, msg_version
           call sys_msg_board_str
           mov esi, msg_www
           call sys_msg_board_str
           jmp .cleanup
 
.link_fail:
           mov esi, msg_module
           call sys_msg_board_str
           mov esi, [driver_name]
           call sys_msg_board_str
           mov esi, msg_CR
           call sys_msg_board_str
.cleanup:
           mov ecx, [img_base]
           call @mem_free@4
.fail:
           mov ecx, [coff]
           call @mem_free@4
.exit:
           xor eax, eax
           ret
endp
 
align 4
proc load_library stdcall, file_name:dword
           locals
             coff      dd ?
             sym       dd ?
             strings   dd ?
             img_size  dd ?
             img_base  dd ?
             exports   dd ?
           endl
 
           cli
 
           stdcall load_file, [file_name]
           test eax, eax
           jz .fail
 
           mov [coff], eax
           movzx ecx, [eax+CFH.nSections]
           xor ebx, ebx
 
           lea edx, [eax+20]
@@:
           add ebx, [edx+CFS.SizeOfRawData]
           add ebx, 15
           and ebx, not 15
           add edx, COFF_SECTION_SIZE
           dec ecx
           jnz @B
           mov [img_size], ebx
 
           call init_heap
           stdcall user_alloc, [img_size]
 
           test eax, eax
           jz .fail
           mov [img_base], eax
 
           mov edx, [coff]
           movzx ebx, [edx+CFH.nSections]
           mov edi, [img_base]
           lea eax, [edx+20]
@@:
           mov [eax+CFS.VirtualAddress], edi
           mov esi, [eax+CFS.PtrRawData]
           test esi, esi
           jnz .copy
           add edi, [eax+CFS.SizeOfRawData]
           jmp .next
.copy:
           add esi, edx
           mov ecx, [eax+CFS.SizeOfRawData]
           cld
           rep movsb
.next:
           add edi, 15 ;-new_app_base
           and edi, -16
           add eax, COFF_SECTION_SIZE
           dec ebx
           jnz @B
 
           mov ebx, [edx+CFH.pSymTable]
           add ebx, edx
           mov [sym], ebx
           mov ecx, [edx+CFH.nSymbols]
           add ecx,ecx
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
           add ecx, [sym]
           mov [strings], ecx
 
           lea eax, [edx+20]
 
           stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
                         [strings], dword 0
           test eax, eax
           jnz @F
 
@@:
           mov edx, [coff]
 
;           movzx ebx, [edx+CFH.nSections]
;           xor edi, edi
;           lea eax, [edx+20]
;@@:
;           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
;           add eax, COFF_SECTION_SIZE
;           dec ebx
;           jnz @B
 
           add edx, 20
           stdcall fix_coff_relocs, [coff], edx, [sym]
 
           mov ebx, [coff]
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
           mov [exports], eax
 
           mov ecx, [coff]
           call @mem_free@4
 
           mov eax, [exports]
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc stop_all_services
 
           mov edx, [srv.fd]
.next:
           cmp edx,  srv.fd-SRV_FD_OFFSET
           je .done
           cmp [edx+SRV.magic], ' SRV'
           jne .next
           cmp [edx+SRV.size], SRV_SIZE
           jne .next
 
           mov ebx, [edx+SRV.entry]
           mov edx, [edx+SRV.fd]
           test ebx, ebx
           jz .next
 
           push edx
           stdcall ebx, dword -1
           pop edx
           jmp .next
.done:
           ret
endp
 
; param
;  eax= size
;  ebx= pid
 
align 4
_CreateObject:
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
_DestroyObject:
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
 
 
 
if 0
 
irq:
 
.irq0:
	   pusfd
	   pushad
	   push IRQ_0
	   jmp .master
.irq_1:
	   pusfd
	   pushad
	   push IRQ_1
	   jmp .master
 
.master:
	   mov ax, app_data
	   mov ds, eax
	   mov es, eax
	   mov ebx, [esp+4]  ;IRQ_xx
	   mov eax, [irq_handlers+ebx+4]
	   call intr_handler
	   mov ecx, [esp+4]
	   cmp [irq_actids+ecx*4], 0
	   je @F
	   in al, 0x21
	   bts eax, ecx
	   out 0x21, al
	   mov al, 0x20
	   out 0x20, al
	   jmp .restart
 
.slave:
	   mov ax, app_data
	   mov ds, eax
	   mov es, eax
	   mov ebx, [esp+4]  ;IRQ_xx
	   mov eax, [irq_handlers+ebx+4]
	   call intr_handler
	   mov ecx, [esp+4]
	   sub ecx, 8
	   cmp [irq_actids+ecx*4], 0
	   je @F
	   in al, 0xA1
	   bts eax, ecx
	   out 0xA1, al
	   mov al, 0x20
	   out 0xA0, al
	   out 0x20, al
.restart:
	   mov ebx, [next_slot]
	   test ebx, ebx
	   jz @F
	   mov [next_task],0
	   mov esi, [prev_slot]
	   call do_change_task
	   add esp, 4
	   iretd
 
end if

Rev 928	Rev 2971
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. 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: 928 $	8	$Revision: 2971 $
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 5 ;current drivers model version	12	DRV_CURRENT equ 5 ;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	align 4	17	align 4
18	proc attach_int_handler stdcall, irq:dword, handler:dword, access_rights:dword	18	proc attach_int_handler stdcall, irq:dword, handler:dword, access_rights:dword
-		19
-		20	push ebx
19		21
20	mov ebx, [irq] ;irq num	22	mov ebx, [irq] ;irq num
21	test ebx, ebx	23	test ebx, ebx
22	jz .err	24	jz .err
23	cmp ebx, 15 ; hidnplayr says: we only have 16 IRQ's	25	cmp ebx, 15 ; hidnplayr says: we only have 16 IRQ's
24	ja .err	26	ja .err
25	mov eax, [handler]	27	mov eax, [handler]
26	test eax, eax	28	test eax, eax
27	jz .err	29	jz .err
28	cmp [irq_owner + 4 * ebx], 0	30	cmp [irq_owner + 4 * ebx], 0
29	je @f	31	je @f
30		32
31	mov ecx, [irq_rights + 4 * ebx] ; Rights : 0 - full access, 1 - read only, 2 - forbidden	33	mov ecx, [irq_rights + 4 * ebx] ; Rights : 0 - full access, 1 - read only, 2 - forbidden
32	test ecx, ecx	34	test ecx, ecx
33	jnz .err	35	jnz .err
34		36
35	@@:	37	@@:
36	mov [irq_tab+ebx*4], eax	38	mov [irq_tab+ebx*4], eax
37		39
38	mov eax, [access_rights]	40	mov eax, [access_rights]
39	mov [irq_rights + 4 * ebx], eax	41	mov [irq_rights + 4 * ebx], eax
40		42
41	mov [irq_owner + 4 * ebx], PID_KERNEL ; all handlers belong to a kernel	43	mov [irq_owner + 4 * ebx], PID_KERNEL ; all handlers belong to a kernel
42		44
43	stdcall enable_irq, [irq]	45	stdcall enable_irq, [irq]
-		46	pop ebx
44	mov eax, 1	47	mov eax, 1
45	ret	48	ret
46	.err:	49	.err:
-		50	pop ebx
47	xor eax, eax	51	xor eax, eax
48	ret	52	ret
49	endp	53	endp
50		54
51	uglobal	55	uglobal
52		56
53	irq_rights rd 16	57	irq_rights rd 16
54		58
55	endg	59	endg
56		60
57	proc get_int_handler stdcall, irq:dword	61	proc get_int_handler stdcall, irq:dword
58		62
59	mov eax, [irq]	63	mov eax, [irq]
60		64
61	cmp [irq_rights + 4 * eax], dword 1	65	cmp [irq_rights + 4 * eax], dword 1
62	ja .err	66	ja .err
63		67
64	mov eax, [irq_tab + 4 * eax]	68	mov eax, [irq_tab + 4 * eax]
65	ret	69	ret
66		70
67	.err:	71	.err:
68	xor eax, eax	72	xor eax, eax
69	ret	73	ret
70	endp	74	endp
71		75
72	align 4	76	align 4
73	proc detach_int_handler	77	proc detach_int_handler
74		78
75	ret	79	ret
76	endp	80	endp
77		81
78	align 4	82	align 4
79	proc enable_irq stdcall, irq_line:dword	83	proc enable_irq stdcall, irq_line:dword
80	mov ebx, [irq_line]	84	mov ebx, [irq_line]
81	mov edx, 0x21	85	mov edx, 0x21
82	cmp ebx, 8	86	cmp ebx, 8
83	jb @F	87	jb @F
84	mov edx, 0xA1	88	mov edx, 0xA1
85	sub ebx,8	89	sub ebx,8
86	@@:	90	@@:
87	in al,dx	91	in al,dx
88	btr eax, ebx	92	btr eax, ebx
89	out dx, al	93	out dx, al
90	ret	94	ret
91	endp	95	endp
92		96
93	align 16	97	align 16
94	;; proc irq_serv	98	;; proc irq_serv
95		99
96	irq_serv:	100	irq_serv:
97		101
98	.irq_1:	102	.irq_1:
99	push 1	103	push 1
100	jmp .main	104	jmp .main
101	align 4	105	align 4
102	.irq_2:	106	.irq_2:
103	push 2	107	push 2
104	jmp .main	108	jmp .main
105	align 4	109	align 4
106	.irq_3:	110	.irq_3:
107	push 3	111	push 3
108	jmp .main	112	jmp .main
109	align 4	113	align 4
110	.irq_4:	114	.irq_4:
111	push 4	115	push 4
112	jmp .main	116	jmp .main
113	align 4	117	align 4
114	.irq_5:	118	.irq_5:
115	push 5	119	push 5
116	jmp .main	120	jmp .main
117	align 4	121	align 4
118	.irq_6:	122	.irq_6:
119	push 6	123	push 6
120	jmp .main	124	jmp .main
121	align 4	125	align 4
122	.irq_7:	126	.irq_7:
123	push 7	127	push 7
124	jmp .main	128	jmp .main
125	align 4	129	align 4
126	.irq_8:	130	.irq_8:
127	push 8	131	push 8
128	jmp .main	132	jmp .main
129	align 4	133	align 4
130	.irq_9:	134	.irq_9:
131	push 9	135	push 9
132	jmp .main	136	jmp .main
133	align 4	137	align 4
134	.irq_10:	138	.irq_10:
135	push 10	139	push 10
136	jmp .main	140	jmp .main
137	align 4	141	align 4
138	.irq_11:	142	.irq_11:
139	push 11	143	push 11
140	jmp .main	144	jmp .main
141	align 4	145	align 4
142	.irq_12:	146	.irq_12:
143	push 12	147	push 12
144	jmp .main	148	jmp .main
145	align 4	149	align 4
146	.irq_13:	150	.irq_13:
147	push 13	151	push 13
148	jmp .main	152	jmp .main
149	align 4	153	align 4
150	.irq_14:	154	.irq_14:
151	push 14	155	push 14
152	jmp .main	156	jmp .main
153	align 4	157	align 4
154	.irq_15:	158	.irq_15:
155	push 15	159	push 15
156	jmp .main	160	jmp .main
157		161
158	align 16	162	align 16
159	.main:	163	.main:
160	save_ring3_context	164	save_ring3_context
161	mov eax, [esp + 32]	165	mov eax, [esp + 32]
162	mov bx, sel_app_data	166	mov bx, sel_app_data
163	mov ds, bx	167	mov ds, bx
164	mov es, bx	168	mov es, bx
165		169
166	cmp [v86_irqhooks+eax*8], 0	170	cmp [v86_irqhooks+eax*8], 0
167	jnz v86_irq	171	jnz v86_irq
168		172
169	mov ebx, [irq_tab+eax*4]	173	mov ebx, [irq_tab+eax*4]
170	test ebx, ebx	174	test ebx, ebx
171	jz .exit	175	jz .exit
172		176
173	call ebx	177	call ebx
174	mov [check_idle_semaphore],5	178	mov [check_idle_semaphore],5
175		179
176	.exit:	180	.exit:
177		181
178	cmp dword [esp + 32], 8	182	cmp dword [esp + 32], 8
179	mov al, 0x20	183	mov al, 0x20
180	jb @f	184	jb @f
181		185
182	out 0xa0, al	186	out 0xa0, al
183	@@:	187	@@:
184	out 0x20, al	188	out 0x20, al
185		189
186	restore_ring3_context	190	restore_ring3_context
187	add esp, 4	191	add esp, 4
188		192
189	iret	193	iret
190		194
191	align 4	195	align 4
192	proc get_notify stdcall, p_ev:dword	196	proc get_notify stdcall, p_ev:dword
193		197
194	.wait:	198	.wait:
195	mov ebx,[current_slot]	199	mov ebx,[current_slot]
196	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY	200	test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
197	jz @f	201	jz @f
198		202
199	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY	203	and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
200	mov edi, [p_ev]	204	mov edi, [p_ev]
201	mov dword [edi], EV_INTR	205	mov dword [edi], EV_INTR
202	mov eax, [ebx+APPDATA.event]	206	mov eax, [ebx+APPDATA.event]
203	mov dword [edi+4], eax	207	mov dword [edi+4], eax
204	ret	208	ret
205	@@:	209	@@:
206	call change_task	210	call change_task
207	jmp .wait	211	jmp .wait
208	endp	212	endp
209		213
210	align 4	214	align 4
211	_PciRead32:	215	_PciRead32:
212	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword	216	proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
213	push ebx	217	push ebx
214	xor eax, eax	218	xor eax, eax
215	xor ebx, ebx	219	xor ebx, ebx
216	mov ah, byte [bus]	220	mov ah, byte [bus]
217	mov al, 6	221	mov al, 6
218	mov bh, byte [devfn]	222	mov bh, byte [devfn]
219	mov bl, byte [reg]	223	mov bl, byte [reg]
220	call pci_read_reg	224	call pci_read_reg
221	pop ebx	225	pop ebx
222	ret	226	ret
223	endp	227	endp
224		228
225	align 4	229	align 4
226	_PciRead16:	230	_PciRead16:
227	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword	231	proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
228	push ebx	232	push ebx
229	xor eax, eax	233	xor eax, eax
230	xor ebx, ebx	234	xor ebx, ebx
231	mov ah, byte [bus]	235	mov ah, byte [bus]
232	mov al, 5	236	mov al, 5
233	mov bh, byte [devfn]	237	mov bh, byte [devfn]
234	mov bl, byte [reg]	238	mov bl, byte [reg]
235	call pci_read_reg	239	call pci_read_reg
236	pop ebx	240	pop ebx
237	ret	241	ret
238	endp	242	endp
239		243
240	align 4	244	align 4
241	_PciRead8:	245	_PciRead8:
242	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword	246	proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
243	push ebx	247	push ebx
244	xor eax, eax	248	xor eax, eax
245	xor ebx, ebx	249	xor ebx, ebx
246	mov ah, byte [bus]	250	mov ah, byte [bus]
247	mov al, 4	251	mov al, 4
248	mov bh, byte [devfn]	252	mov bh, byte [devfn]
249	mov bl, byte [reg]	253	mov bl, byte [reg]
250	call pci_read_reg	254	call pci_read_reg
251	pop ebx	255	pop ebx
252	ret	256	ret
253	endp	257	endp
254		258
255	align 4	259	align 4
256	_PciWrite8:	260	_PciWrite8:
257	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	261	proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
258	push ebx	262	push ebx
259	xor eax, eax	263	xor eax, eax
260	xor ebx, ebx	264	xor ebx, ebx
261	mov ah, byte [bus]	265	mov ah, byte [bus]
262	mov al, 8	266	mov al, 8
263	mov bh, byte [devfn]	267	mov bh, byte [devfn]
264	mov bl, byte [reg]	268	mov bl, byte [reg]
265	mov ecx, [val]	269	mov ecx, [val]
266	call pci_write_reg	270	call pci_write_reg
267	pop ebx	271	pop ebx
268	ret	272	ret
269	endp	273	endp
270		274
271	align 4	275	align 4
272	_PciWrite16:	276	_PciWrite16:
273	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	277	proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
274	push ebx	278	push ebx
275	xor eax, eax	279	xor eax, eax
276	xor ebx, ebx	280	xor ebx, ebx
277	mov ah, byte [bus]	281	mov ah, byte [bus]
278	mov al, 9	282	mov al, 9
279	mov bh, byte [devfn]	283	mov bh, byte [devfn]
280	mov bl, byte [reg]	284	mov bl, byte [reg]
281	mov ecx, [val]	285	mov ecx, [val]
282	call pci_write_reg	286	call pci_write_reg
283	pop ebx	287	pop ebx
284	ret	288	ret
285	endp	289	endp
286		290
287	align 4	291	align 4
288	_PciWrite32:	292	_PciWrite32:
289	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword	293	proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
290	push ebx	294	push ebx
291	xor eax, eax	295	xor eax, eax
292	xor ebx, ebx	296	xor ebx, ebx
293	mov ah, byte [bus]	297	mov ah, byte [bus]
294	mov al, 10	298	mov al, 10
295	mov bh, byte [devfn]	299	mov bh, byte [devfn]
296	mov bl, byte [reg]	300	mov bl, byte [reg]
297	mov ecx, [val]	301	mov ecx, [val]
298	call pci_write_reg	302	call pci_write_reg
299	pop ebx	303	pop ebx
300	ret	304	ret
301	endp	305	endp
302		306
303	handle equ IOCTL.handle	307	handle equ IOCTL.handle
304	io_code equ IOCTL.io_code	308	io_code equ IOCTL.io_code
305	input equ IOCTL.input	309	input equ IOCTL.input
306	inp_size equ IOCTL.inp_size	310	inp_size equ IOCTL.inp_size
307	output equ IOCTL.output	311	output equ IOCTL.output
308	out_size equ IOCTL.out_size	312	out_size equ IOCTL.out_size
309		313
310		314
311	align 4	315	align 4
312	proc srv_handler stdcall, ioctl:dword	316	proc srv_handler stdcall, ioctl:dword
313	mov esi, [ioctl]	317	mov esi, [ioctl]
314	test esi, esi	318	test esi, esi
315	jz .err	319	jz .err
316		320
317	mov edi, [esi+handle]	321	mov edi, [esi+handle]
318	cmp [edi+SRV.magic], ' SRV'	322	cmp [edi+SRV.magic], ' SRV'
319	jne .fail	323	jne .fail
320		324
321	cmp [edi+SRV.size], SRV_SIZE	325	cmp [edi+SRV.size], SRV_SIZE
322	jne .fail	326	jne .fail
323		327
324	stdcall [edi+SRV.srv_proc], esi	328	stdcall [edi+SRV.srv_proc], esi
325	ret	329	ret
326	.fail:	330	.fail:
327	xor eax, eax	331	xor eax, eax
328	not eax	332	not eax
329	mov [esi+output], eax	333	mov [esi+output], eax
330	mov [esi+out_size], 4	334	mov [esi+out_size], 4
331	ret	335	ret
332	.err:	336	.err:
333	xor eax, eax	337	xor eax, eax
334	not eax	338	not eax
335	ret	339	ret
336	endp	340	endp
337		341
338	; param	342	; param
339	; ebx= io_control	343	; ebx= io_control
340	;	344	;
341	; retval	345	; retval
342	; eax= error code	346	; eax= error code
343		347
344	align 4	348	align 4
345	srv_handlerEx:	349	srv_handlerEx:
346	cmp ebx, OS_BASE	350	cmp ebx, OS_BASE
347	jae .fail	351	jae .fail
348		352
349	mov eax, [ebx+handle]	353	mov eax, [ebx+handle]
350	cmp [eax+SRV.magic], ' SRV'	354	cmp [eax+SRV.magic], ' SRV'
351	jne .fail	355	jne .fail
352		356
353	cmp [eax+SRV.size], SRV_SIZE	357	cmp [eax+SRV.size], SRV_SIZE
354	jne .fail	358	jne .fail
355		359
356	stdcall [eax+SRV.srv_proc], ebx	360	stdcall [eax+SRV.srv_proc], ebx
357	ret	361	ret
358	.fail:	362	.fail:
359	or eax, -1	363	or eax, -1
360	ret	364	ret
361		365
362	restore handle	366	restore handle
363	restore io_code	367	restore io_code
364	restore input	368	restore input
365	restore inp_size	369	restore inp_size
366	restore output	370	restore output
367	restore out_size	371	restore out_size
368		372
369	align 4	373	align 4
370	proc get_service stdcall, sz_name:dword	374	proc get_service stdcall, sz_name:dword
371	mov eax, [sz_name]	375	mov eax, [sz_name]
372	test eax, eax	376	test eax, eax
373	jnz @F	377	jnz @F
374	ret	378	ret
375	@@:	379	@@:
376	mov edx, [srv.fd]	380	mov edx, [srv.fd]
377	@@:	381	@@:
378	cmp edx, srv.fd-SRV_FD_OFFSET	382	cmp edx, srv.fd-SRV_FD_OFFSET
379	je .not_load	383	je .not_load
380		384
381	stdcall strncmp, edx, [sz_name], 16	385	stdcall strncmp, edx, [sz_name], 16
382	test eax, eax	386	test eax, eax
383	je .ok	387	je .ok
384		388
385	mov edx, [edx+SRV.fd]	389	mov edx, [edx+SRV.fd]
386	jmp @B	390	jmp @B
387	.not_load:	391	.not_load:
388	pop ebp	392	pop ebp
389	jmp load_driver	393	jmp load_driver
390	.ok:	394	.ok:
391	mov eax, edx	395	mov eax, edx
392	ret	396	ret
393	endp	397	endp
394		398
395	align 4	399	align 4
396	_RegService:	400	_RegService:
397	proc reg_service stdcall, name:dword, handler:dword	401	proc reg_service stdcall, name:dword, handler:dword
398		402
399	push ebx	403	push ebx
400		404
401	xor eax, eax	405	xor eax, eax
402		406
403	cmp [name], eax	407	cmp [name], eax
404	je .fail	408	je .fail
405		409
406	cmp [handler], eax	410	cmp [handler], eax
407	je .fail	411	je .fail
408		412
409	mov eax, SRV_SIZE	413	mov eax, SRV_SIZE
410	call malloc ;call alloc_service	414	call malloc ;call alloc_service
411	test eax, eax	415	test eax, eax
412	jz .fail	416	jz .fail
413		417
414	push esi	418	push esi
415	push edi	419	push edi
416	mov edi, eax	420	mov edi, eax
417	mov esi, [name]	421	mov esi, [name]
418	mov ecx, 16/4	422	mov ecx, 16/4
419	rep movsd	423	rep movsd
420	pop edi	424	pop edi
421	pop esi	425	pop esi
422		426
423	mov [eax+SRV.magic], ' SRV'	427	mov [eax+SRV.magic], ' SRV'
424	mov [eax+SRV.size], SRV_SIZE	428	mov [eax+SRV.size], SRV_SIZE
425		429
426	mov ebx, srv.fd-SRV_FD_OFFSET	430	mov ebx, srv.fd-SRV_FD_OFFSET
427	mov edx, [ebx+SRV.fd]	431	mov edx, [ebx+SRV.fd]
428	mov [eax+SRV.fd], edx	432	mov [eax+SRV.fd], edx
429	mov [eax+SRV.bk], ebx	433	mov [eax+SRV.bk], ebx
430	mov [ebx+SRV.fd], eax	434	mov [ebx+SRV.fd], eax
431	mov [edx+SRV.bk], eax	435	mov [edx+SRV.bk], eax
432		436
433	mov ecx, [handler]	437	mov ecx, [handler]
434	mov [eax+SRV.srv_proc], ecx	438	mov [eax+SRV.srv_proc], ecx
435	pop ebx	439	pop ebx
436	ret	440	ret
437	.fail:	441	.fail:
438	xor eax, eax	442	xor eax, eax
439	pop ebx	443	pop ebx
440	ret	444	ret
441	endp	445	endp
442		446
443	align 4	447	align 4
444	proc get_proc stdcall, exp:dword, sz_name:dword	448	proc get_proc stdcall, exp:dword, sz_name:dword
445		449
446	mov edx, [exp]	450	mov edx, [exp]
447	.next:	451	.next:
448	mov eax, [edx]	452	mov eax, [edx]
449	test eax, eax	453	test eax, eax
450	jz .end	454	jz .end
451		455
452	push edx	456	push edx
453	stdcall strncmp, eax, [sz_name], 16	457	stdcall strncmp, eax, [sz_name], 16
454	pop edx	458	pop edx
455	test eax, eax	459	test eax, eax
456	jz .ok	460	jz .ok
457		461
458	add edx,8	462	add edx,8
459	jmp .next	463	jmp .next
460	.ok:	464	.ok:
461	mov eax, [edx+4]	465	mov eax, [edx+4]
462	.end:	466	.end:
463	ret	467	ret
464	endp	468	endp
465		469
466	align 4	470	align 4
467	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword	471	proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
468		472
469	@@:	473	@@:
470	stdcall strncmp, [pSym], [sz_sym], 8	474	stdcall strncmp, [pSym], [sz_sym], 8
471	test eax,eax	475	test eax,eax
472	jz .ok	476	jz .ok
473	add [pSym], 18	477	add [pSym], 18
474	dec [count]	478	dec [count]
475	jnz @b	479	jnz @b
476		480
477	xor eax, eax	481	xor eax, eax
478	ret	482	ret
479	.ok:	483	.ok:
480	mov ebx, [pSym]	484	mov ebx, [pSym]
481	mov eax, [ebx+8]	485	mov eax, [ebx+8]
482	ret	486	ret
483	endp	487	endp
484		488
485	align 4	489	align 4
486	get_curr_task:	490	get_curr_task:
487	mov eax,[CURRENT_TASK]	491	mov eax,[CURRENT_TASK]
488	shl eax, 8	492	shl eax, 8
489	ret	493	ret
490		494
491	align 4	495	align 4
492	proc get_fileinfo stdcall, file_name:dword, info:dword	496	proc get_fileinfo stdcall, file_name:dword, info:dword
493	locals	497	locals
494	cmd dd ?	498	cmd dd ?
495	offset dd ?	499	offset dd ?
496	dd ?	500	dd ?

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/dll.inc – Rev 928 → 2971