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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 593 → 662