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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/dll.inc – Rev 837 → 840