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


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/core/dll.inc – Rev 1161 → 1206