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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 802 – Rev 774 → 797