Subversion Repositories Kolibri OS

Rev

Rev 541 | Rev 593 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. $Revision: 557 $
  2. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  3. ;;                                                              ;;
  4. ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
  5. ;; Distributed under terms of the GNU General Public License    ;;
  6. ;;                                                              ;;
  7. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  8.  
  9. DRV_COMPAT   equ  5  ;minimal required drivers version
  10. DRV_CURRENT  equ  5  ;current drivers model version
  11.  
  12. DRV_VERSION equ (DRV_COMPAT shl 16) or DRV_CURRENT
  13.  
  14. align 4
  15. proc attach_int_handler stdcall, irq:dword, handler:dword
  16.  
  17.          mov ebx, [irq]        ;irq num
  18.          test ebx, ebx
  19.          jz .err
  20.          mov eax, [handler]
  21.          test eax, eax
  22.          jz .err
  23.          mov [irq_tab+ebx*4], eax
  24.          stdcall enable_irq, [irq]
  25.          ret
  26. .err:
  27.          xor eax, eax
  28.          ret
  29. endp
  30.  
  31. align 4
  32. proc  detach_int_handler
  33.  
  34.            ret
  35. endp
  36.  
  37. align 4
  38. proc enable_irq stdcall, irq_line:dword
  39.            mov ebx, [irq_line]
  40.            mov edx, 0x21
  41.            cmp ebx, 8
  42.            jb @F
  43.            mov edx, 0xA1
  44.            sub ebx,8
  45. @@:
  46.            in al,dx
  47.            btr eax, ebx
  48.            out dx, al
  49.            ret
  50. endp
  51.  
  52. align 16
  53. ;; proc irq_serv
  54.  
  55. irq_serv:
  56.  
  57. .irq_1:
  58.            push eax
  59.            mov eax, 1
  60.            jmp .main
  61. align 4
  62. .irq_2:
  63.            push eax
  64.            mov eax, 2
  65.            jmp .main
  66. align 4
  67. .irq_3:
  68.            push eax
  69.            mov eax, 3
  70.            jmp .main
  71. align 4
  72. .irq_4:
  73.            push eax
  74.            mov eax, 4
  75.            jmp .main
  76. align 4
  77. .irq_5:
  78.            push eax
  79.            mov eax, 5
  80.            jmp .main
  81. align 4
  82. .irq_6:
  83.            push eax
  84.            mov eax, 6
  85.            jmp .main
  86. align 4
  87. .irq_7:
  88.            push eax
  89.            mov eax, 7
  90.            jmp .main
  91. align 4
  92. .irq_8:
  93.            push eax
  94.            mov eax, 8
  95.            jmp .main
  96. align 4
  97. .irq_9:
  98.            push eax
  99.            mov eax, 9
  100.            jmp .main
  101. align 4
  102. .irq_10:
  103.            push eax
  104.            mov eax, 10
  105.            jmp .main
  106. align 4
  107. .irq_11:
  108.            push eax
  109.            mov eax, 11
  110.            jmp .main
  111. align 4
  112. .irq_12:
  113.            push eax
  114.            mov eax, 12
  115.            jmp .main
  116. align 4
  117. .irq_13:
  118.            push eax
  119.            mov eax, 13
  120.            jmp .main
  121. align 4
  122. .irq_14:
  123.            push eax
  124.            mov eax, 14
  125.            jmp .main
  126. align 4
  127. .irq_15:
  128.            push eax
  129.            mov eax, 15
  130.            jmp .main
  131.  
  132. align 16
  133. .main:
  134.            save_ring3_context
  135.            mov   bx, app_data  ;os_data
  136.            mov   ds, bx
  137.            mov   es, bx
  138.  
  139.            mov ebx, [irq_tab+eax*4]
  140.            test ebx, ebx
  141.            jz .exit
  142.  
  143.            call ebx
  144.            mov  [check_idle_semaphore],5
  145.  
  146. .exit:
  147.            restore_ring3_context
  148.  
  149.            cmp eax, 8
  150.            mov al, 0x20
  151.            jb @f
  152.            out 0xa0, al
  153. @@:
  154.            out 0x20, al
  155.  
  156.            pop eax
  157.            iret
  158.  
  159. align 4
  160. proc get_notify stdcall, p_ev:dword
  161.  
  162. .wait:
  163.            mov ebx,[current_slot]
  164.            test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
  165.            jz @f
  166.            and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
  167.            mov edi, [p_ev]
  168.            mov dword [edi], EV_INTR
  169.            mov eax, [ebx+APPDATA.event]
  170.            mov dword [edi+4], eax
  171.            ret
  172. @@:
  173.            call change_task
  174.            jmp .wait
  175. endp
  176.  
  177. align 4
  178. proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
  179.            xor eax, eax
  180.            xor ebx, ebx
  181.            mov ah, byte [bus]
  182.            mov al, 6
  183.            mov bh, byte [devfn]
  184.            mov bl, byte [reg]
  185.            call pci_read_reg
  186.            ret
  187. endp
  188.  
  189. align 4
  190. proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
  191.            xor eax, eax
  192.            xor ebx, ebx
  193.            mov ah, byte [bus]
  194.            mov al, 5
  195.            mov bh, byte [devfn]
  196.            mov bl, byte [reg]
  197.            call pci_read_reg
  198.            ret
  199. endp
  200.  
  201. align 4
  202. proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
  203.            xor eax, eax
  204.            xor ebx, ebx
  205.            mov ah, byte [bus]
  206.            mov al, 4
  207.            mov bh, byte [devfn]
  208.            mov bl, byte [reg]
  209.            call pci_read_reg
  210.            ret
  211. endp
  212.  
  213. align 4
  214. proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
  215.            xor eax, eax
  216.            xor ebx, ebx
  217.            mov ah, byte [bus]
  218.            mov al, 8
  219.            mov bh, byte [devfn]
  220.            mov bl, byte [reg]
  221.            mov ecx, [val]
  222.            call pci_write_reg
  223.            ret
  224. endp
  225.  
  226. align 4
  227. proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
  228.            xor eax, eax
  229.            xor ebx, ebx
  230.            mov ah, byte [bus]
  231.            mov al, 9
  232.            mov bh, byte [devfn]
  233.            mov bl, byte [reg]
  234.            mov ecx, [val]
  235.            call pci_write_reg
  236.            ret
  237. endp
  238.  
  239. handle     equ  IOCTL.handle
  240. io_code    equ  IOCTL.io_code
  241. input      equ  IOCTL.input
  242. inp_size   equ  IOCTL.inp_size
  243. output     equ  IOCTL.output
  244. out_size   equ  IOCTL.out_size
  245.  
  246.  
  247. align 4
  248. proc srv_handler stdcall, ioctl:dword
  249.            mov esi, [ioctl]
  250.            test esi, esi
  251.            jz .err
  252.  
  253.            mov edi, [esi+handle]
  254.            cmp [edi+SRV.magic], ' SRV'
  255.            jne .fail
  256.  
  257.            cmp [edi+SRV.size], SRV_SIZE
  258.            jne .fail
  259.  
  260.            stdcall [edi+SRV.srv_proc], esi
  261.            ret
  262. .fail:
  263.            xor eax, eax
  264.            not eax
  265.            mov [esi+output], eax
  266.            mov [esi+out_size], 4
  267.            ret
  268. .err:
  269.            xor eax, eax
  270.            not eax
  271.            ret
  272. endp
  273.  
  274. ; param
  275. ;  ebx= io_control
  276. ;
  277. ; retval
  278. ;  eax= error code
  279.  
  280. align 4
  281. srv_handlerEx:
  282.            cmp ebx, OS_BASE
  283.            jae .fail
  284.  
  285.            mov eax, [ebx+handle]
  286.            cmp [eax+SRV.magic], ' SRV'
  287.            jne .fail
  288.  
  289.            cmp [eax+SRV.size], SRV_SIZE
  290.            jne .fail
  291.  
  292.            stdcall [eax+SRV.srv_proc], ebx
  293.            ret
  294. .fail:
  295.            or eax, -1
  296.            ret
  297.  
  298. restore  handle
  299. restore  io_code
  300. restore  input
  301. restore  inp_size
  302. restore  output
  303. restore  out_size
  304.  
  305. align 4
  306. proc get_service stdcall, sz_name:dword
  307.            mov eax, [sz_name]
  308.            test eax, eax
  309.            jnz @F
  310.            ret
  311. @@:
  312.            mov edx, [srv.fd]
  313. @@:
  314.            cmp edx, srv.fd-SRV_FD_OFFSET
  315.            je .not_load
  316.  
  317.            stdcall strncmp, edx, [sz_name], 16
  318.            test eax, eax
  319.            je .ok
  320.  
  321.            mov edx, [edx+SRV.fd]
  322.            jmp @B
  323. .not_load:
  324.            pop ebp
  325.            jmp load_driver
  326. .ok:
  327.            mov eax, edx
  328.            ret
  329. endp
  330.  
  331. align 4
  332. reg_service:
  333. .sz_name equ esp+4
  334. .handler equ esp+8
  335.            mov eax, [.sz_name]
  336.            test eax, eax
  337.            jz .fail
  338.  
  339.            mov ebx, [.handler]
  340.            test ebx, ebx
  341.            jz .fail
  342.  
  343.            mov eax, SRV_SIZE
  344.            call malloc           ;call alloc_service
  345.            test eax, eax
  346.            jz .fail
  347.  
  348.            mov edi, eax
  349.            mov esi, [.sz_name]
  350.            mov ecx, 16/4
  351.            rep movsd
  352.  
  353.            mov [eax+SRV.magic], ' SRV'
  354.            mov [eax+SRV.size], SRV_SIZE
  355.  
  356.            mov ebx, srv.fd-SRV_FD_OFFSET
  357.            mov edx, [ebx+SRV.fd]
  358.            mov [eax+SRV.fd], edx
  359.            mov [eax+SRV.bk], ebx
  360.            mov [ebx+SRV.fd], eax
  361.            mov [edx+SRV.bk], eax
  362.  
  363.            mov ecx, [.handler]
  364.            mov [eax+SRV.srv_proc], ecx
  365.            ret 8
  366. .fail:
  367.            xor eax, eax
  368.            ret 8
  369.  
  370. align 4
  371. proc get_proc stdcall, exp:dword, sz_name:dword
  372.  
  373.            mov edx, [exp]
  374. .next:
  375.            mov eax, [edx]
  376.            test eax, eax
  377.            jz .end
  378.  
  379.            push edx
  380.            stdcall strncmp, eax, [sz_name], 16
  381.            pop edx
  382.            test eax, eax
  383.            jz .ok
  384.  
  385.            add edx,8
  386.            jmp .next
  387. .ok:
  388.            mov eax, [edx+4]
  389. .end:
  390.            ret
  391. endp
  392.  
  393. align 4
  394. proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
  395.  
  396. @@:
  397.            stdcall strncmp, [pSym], [sz_sym], 8
  398.            test eax,eax
  399.            jz .ok
  400.            add [pSym], 18
  401.            dec [count]
  402.            jnz @b
  403.            xor eax, eax
  404.            ret
  405. .ok:
  406.            mov ebx, [pSym]
  407.            mov eax, [ebx+8]
  408.            ret
  409. endp
  410.  
  411. align 4
  412. proc get_curr_task
  413.            mov eax,[CURRENT_TASK]
  414.            shl eax, 8
  415.            ret
  416. endp
  417.  
  418. align 4
  419. proc get_fileinfo stdcall, file_name:dword, info:dword
  420.            locals
  421.              cmd     dd ?
  422.              offset  dd ?
  423.                      dd ?
  424.              count   dd ?
  425.              buff    dd ?
  426.                      db ?
  427.              name    dd ?
  428.            endl
  429.  
  430.            xor eax, eax
  431.            mov ebx, [file_name]
  432.     ;       sub ebx, new_app_base
  433.            mov ecx, [info]
  434.     ;       sub ecx, new_app_base
  435.  
  436.            mov [cmd], 5
  437.            mov [offset], eax
  438.            mov [offset+4], eax
  439.            mov [count], eax
  440.            mov [buff], ecx
  441.            mov byte [buff+4], al
  442.            mov [name], ebx
  443.  
  444.            mov eax, 70
  445.            lea ebx, [cmd]
  446.      ;      sub ebx, new_app_base
  447.            int 0x40
  448.            ret
  449. endp
  450.  
  451. align 4
  452. proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
  453.                                      bytes:dword
  454.            locals
  455.              cmd     dd ?
  456.              offset  dd ?
  457.                      dd ?
  458.              count   dd ?
  459.              buff    dd ?
  460.                      db ?
  461.              name    dd ?
  462.            endl
  463.  
  464.            xor eax, eax
  465.            mov ebx, [file_name]
  466.            mov ecx, [off]
  467.            mov edx, [bytes]
  468.            mov esi, [buffer]
  469.  
  470.            mov [cmd], eax
  471.            mov [offset], ecx
  472.            mov [offset+4], eax
  473.            mov [count], edx
  474.            mov [buff], esi
  475.            mov byte [buff+4], al
  476.            mov [name], ebx
  477.  
  478.            pushad
  479.            push eax
  480.            lea eax, [cmd]
  481.            call file_system_lfn
  482.            pop eax
  483.            popad
  484.            ret
  485. endp
  486.  
  487. ; description
  488. ;  allocate kernel memory and loads the specified file
  489. ;
  490. ; param
  491. ;  file_name= full path to file
  492. ;
  493. ; retval
  494. ;  eax= file image in kernel memory
  495. ;  ebx= size of file
  496. ;
  497. ; warging
  498. ;  You mast call kernel_free() to delete each file
  499. ;  loaded by the load_file() function
  500.  
  501. align 4
  502. proc load_file stdcall, file_name:dword
  503.            locals
  504.              attr       dd ?
  505.              flags      dd ?
  506.              cr_time    dd ?
  507.              cr_date    dd ?
  508.              acc_time   dd ?
  509.              acc_date   dd ?
  510.              mod_time   dd ?
  511.              mod_date   dd ?
  512.              file_size  dd ?
  513.  
  514.              file       dd ?
  515.              file2      dd ?
  516.            endl
  517.  
  518.            lea eax, [attr]
  519.            stdcall get_fileinfo, [file_name], eax
  520.            test eax, eax
  521.            jnz .fail
  522.  
  523.            mov eax, [file_size]
  524.            cmp eax, 1024*1024*16
  525.            ja .fail
  526.  
  527.            stdcall kernel_alloc, [file_size]
  528.            mov [file], eax
  529.  
  530.            stdcall read_file, [file_name], eax, dword 0, [file_size]
  531.            cmp ebx, [file_size]
  532.            jne .cleanup
  533.  
  534.            mov eax, [file]
  535.            cmp dword [eax], 0x4B43504B
  536.            jne .exit
  537.            mov ebx, [eax+4]
  538.            mov [file_size], ebx
  539.            stdcall kernel_alloc, ebx
  540.  
  541.            test eax, eax
  542.            jz .cleanup
  543.  
  544.            mov [file2], eax
  545.            stdcall unpack, [file], eax
  546.            stdcall kernel_free, [file]
  547.            mov eax, [file2]
  548.            mov ebx, [file_size]
  549. .exit:
  550.            push eax
  551.            lea edi, [eax+ebx]     ;cleanup remain space
  552.            mov ecx, 4096          ;from file end
  553.            and ebx, 4095
  554.            jz  @f
  555.            sub ecx, ebx
  556.            xor eax, eax
  557.            cld
  558.            rep stosb
  559. @@:
  560.            mov ebx, [file_size]
  561.            pop eax
  562.            ret
  563. .cleanup:
  564.            stdcall kernel_free, [file]
  565. .fail:
  566.            xor eax, eax
  567.            xor ebx, ebx
  568.            ret
  569. endp
  570.  
  571. align 4
  572. proc get_proc_ex stdcall, proc_name:dword, imports:dword
  573.  
  574. .look_up:
  575.            mov edx, [imports]
  576.            test edx, edx
  577.            jz .end
  578.            mov edx, [edx]
  579.            test edx, edx
  580.            jz .end
  581. .next:
  582.            mov eax, [edx]
  583.            test eax, eax
  584.            jz .next_table
  585.  
  586.            push edx
  587.            stdcall strncmp, eax, [proc_name], 16
  588.            pop edx
  589.            test eax, eax
  590.            jz .ok
  591.  
  592.            add edx,8
  593.            jmp .next
  594. .next_table:
  595.            add [imports], 4
  596.            jmp .look_up
  597. .ok:
  598.            mov eax, [edx+4]
  599.            ret
  600. .end:
  601.            xor eax, eax
  602.            ret
  603. endp
  604.  
  605. align 4
  606. proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
  607.                       sym_count:dword, strings:dword, imports:dword
  608.            locals
  609.              retval dd ?
  610.            endl
  611.  
  612.            mov edi, [symbols]
  613.            mov [retval], 1
  614. .fix:
  615.            movzx ebx, [edi+CSYM.SectionNumber]
  616.            test ebx, ebx
  617.            jnz .internal
  618.            mov eax, dword [edi+CSYM.Name]
  619.            test eax, eax
  620.            jnz @F
  621.  
  622.            mov edi, [edi+4]
  623.            add edi, [strings]
  624. @@:
  625.            push edi
  626.            stdcall get_proc_ex, edi,[imports]
  627.            pop edi
  628.  
  629.            xor ebx, ebx
  630.            test eax, eax
  631.            jnz @F
  632.  
  633.            mov esi, msg_unresolved
  634.            call sys_msg_board_str
  635.            mov esi, edi
  636.            call sys_msg_board_str
  637.            mov esi, msg_CR
  638.            call sys_msg_board_str
  639.  
  640.            mov [retval],0
  641. @@:
  642.            mov edi, [symbols]
  643.            mov [edi+CSYM.Value], eax
  644.            jmp .next
  645. .internal:
  646.            cmp bx, -1
  647.            je .next
  648.            cmp bx, -2
  649.            je .next
  650.  
  651.            dec ebx
  652.            shl ebx, 3
  653.            lea ebx, [ebx+ebx*4]
  654.            add ebx, [sec]
  655.  
  656.            mov eax, [ebx+CFS.VirtualAddress]
  657.            add [edi+CSYM.Value], eax
  658. .next:
  659.            add edi, CSYM_SIZE
  660.            mov [symbols], edi
  661.            dec [sym_count]
  662.            jnz .fix
  663.            mov eax, [retval]
  664.            ret
  665. endp
  666.  
  667. align 4
  668. proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
  669.            locals
  670.              n_sec     dd ?
  671.            endl
  672.  
  673.            mov eax, [coff]
  674.            movzx ebx, [eax+CFH.nSections]
  675.            mov [n_sec], ebx
  676. .fix_sec:
  677.            mov esi, [sec]
  678.            mov edi, [esi+CFS.PtrReloc]
  679.            add edi, [coff]
  680.  
  681.            movzx ecx, [esi+CFS.NumReloc]
  682.            test ecx, ecx
  683.            jz .next
  684. .next_reloc:
  685.            mov ebx, [edi+CRELOC.SymIndex]
  686.            add ebx,ebx
  687.            lea ebx,[ebx+ebx*8]
  688.            add ebx, [sym]
  689.  
  690.            mov edx, [ebx+CSYM.Value]
  691.  
  692.            cmp [edi+CRELOC.Type], 6
  693.            je .dir_32
  694.  
  695.            cmp [edi+CRELOC.Type], 20
  696.            jne .next_reloc
  697. .rel_32:
  698.            mov eax, [edi+CRELOC.VirtualAddress]
  699.            add eax, [esi+CFS.VirtualAddress]
  700.            sub edx, eax
  701.            sub edx, 4
  702.            jmp .fix
  703. .dir_32:
  704.            mov eax, [edi+CRELOC.VirtualAddress]
  705.            add eax, [esi+CFS.VirtualAddress]
  706. .fix:
  707.            add [eax], edx
  708.            add edi, 10
  709.            dec ecx
  710.            jnz .next_reloc
  711. .next:
  712.            add [sec], COFF_SECTION_SIZE
  713.            dec [n_sec]
  714.            jnz .fix_sec
  715. .exit:
  716.            ret
  717. endp
  718.  
  719. align 4
  720. proc load_driver stdcall, driver_name:dword
  721.            locals
  722.              coff      dd ?
  723.              sym       dd ?
  724.              strings   dd ?
  725.              img_size  dd ?
  726.              img_base  dd ?
  727.              start     dd ?
  728.  
  729.              exports   dd ?   ;fake exports table
  730.                        dd ?
  731.              file_name rb 13+16+4+1      ; '/sys/drivers/<up-to-16-chars>.obj'
  732.            endl
  733.  
  734.            lea     edx, [file_name]
  735.            mov     dword [edx], '/sys'
  736.            mov     dword [edx+4], '/dri'
  737.            mov     dword [edx+8], 'vers'
  738.            mov     byte [edx+12], '/'
  739.            mov     esi, [driver_name]
  740.            lea     edi, [edx+13]
  741.            mov     ecx, 16
  742. @@:
  743.            lodsb
  744.            test    al, al
  745.            jz      @f
  746.            stosb
  747.            loop    @b
  748. @@:
  749.            mov     dword [edi], '.obj'
  750.            mov     byte [edi+4], 0
  751.            stdcall load_file, edx
  752.  
  753.            test eax, eax
  754.            jz .exit
  755.  
  756.            mov [coff], eax
  757.  
  758.            movzx ecx, [eax+CFH.nSections]
  759.            xor ebx, ebx
  760.  
  761.            lea edx, [eax+20]
  762. @@:
  763.            add ebx, [edx+CFS.SizeOfRawData]
  764.            add ebx, 15
  765.            and ebx, not 15
  766.            add edx, COFF_SECTION_SIZE
  767.            dec ecx
  768.            jnz @B
  769.            mov [img_size], ebx
  770.  
  771.            stdcall kernel_alloc, ebx
  772.            test eax, eax
  773.            jz .fail
  774.            mov [img_base], eax
  775.  
  776.            mov edi, eax
  777.            xor eax, eax
  778.            mov ecx, [img_size]
  779.            add ecx, 4095
  780.            and ecx, not 4095
  781.            shr ecx, 2
  782.            cld
  783.            rep stosd
  784.  
  785.            mov edx, [coff]
  786.            movzx ebx, [edx+CFH.nSections]
  787.            mov edi, [img_base]
  788.            lea eax, [edx+20]
  789. @@:
  790.            mov [eax+CFS.VirtualAddress], edi
  791.            mov esi, [eax+CFS.PtrRawData]
  792.            test esi, esi
  793.            jnz .copy
  794.            add edi, [eax+CFS.SizeOfRawData]
  795.            jmp .next
  796. .copy:
  797.            add esi, edx
  798.            mov ecx, [eax+CFS.SizeOfRawData]
  799.            cld
  800.            rep movsb
  801. .next:
  802.            add edi, 15
  803.            and edi, not 15
  804.            add eax, COFF_SECTION_SIZE
  805.            dec ebx
  806.            jnz @B
  807.  
  808.            mov ebx, [edx+CFH.pSymTable]
  809.            add ebx, edx
  810.            mov [sym], ebx
  811.            mov ecx, [edx+CFH.nSymbols]
  812.            add ecx,ecx
  813.            lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
  814.            add ecx, [sym]
  815.            mov [strings], ecx
  816.  
  817.            lea ebx, [exports]
  818.            mov dword [ebx], kernel_export
  819.            mov dword [ebx+4], 0
  820.            lea eax, [edx+20]
  821.  
  822.            stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
  823.                                      [strings], ebx
  824.            test eax, eax
  825.            jz .link_fail
  826.  
  827.            mov ebx, [coff]
  828.            add ebx, 20
  829.            stdcall fix_coff_relocs, [coff], ebx, [sym]
  830.  
  831.            mov ebx, [coff]
  832.            stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
  833.            test eax, eax
  834.            jz .link_fail
  835.  
  836.            mov eax, [eax]
  837.            shr eax, 16
  838.            cmp eax, DRV_COMPAT
  839.            jb .ver_fail
  840.  
  841.            cmp eax, DRV_CURRENT
  842.            ja .ver_fail
  843.  
  844.            mov ebx, [coff]
  845.            stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
  846.            mov [start], eax
  847.  
  848.            stdcall kernel_free, [coff]
  849.  
  850.            mov ebx, [start]
  851.            stdcall ebx, DRV_ENTRY
  852.            test eax, eax
  853.            jnz .ok
  854.  
  855.            stdcall kernel_free, [img_base]
  856.            xor eax, eax
  857.            ret
  858. .ok:
  859.            mov ebx, [img_base]
  860.            mov [eax+SRV.base], ebx
  861.            mov ecx, [start]
  862.            mov [eax+SRV.entry], ecx
  863.            ret
  864.  
  865. .ver_fail:
  866.            mov esi, msg_CR
  867.            call sys_msg_board_str
  868.            mov esi, [driver_name]
  869.            call sys_msg_board_str
  870.            mov esi, msg_CR
  871.            call sys_msg_board_str
  872.            mov esi, msg_version
  873.            call sys_msg_board_str
  874.            mov esi, msg_www
  875.            call sys_msg_board_str
  876.            jmp .cleanup
  877.  
  878. .link_fail:
  879.            mov esi, msg_module
  880.            call sys_msg_board_str
  881.            mov esi, [driver_name]
  882.            call sys_msg_board_str
  883.            mov esi, msg_CR
  884.            call sys_msg_board_str
  885. .cleanup:
  886.            stdcall kernel_free,[img_base]
  887. .fail:
  888.            stdcall kernel_free, [coff]
  889. .exit:
  890.            xor eax, eax
  891.            ret
  892. endp
  893.  
  894. align 4
  895. proc load_library stdcall, file_name:dword
  896.            locals
  897.              coff      dd ?
  898.              sym       dd ?
  899.              strings   dd ?
  900.              img_size  dd ?
  901.              img_base  dd ?
  902.              exports   dd ?
  903.            endl
  904.  
  905.            cli
  906.  
  907.            stdcall load_file, [file_name]
  908.            test eax, eax
  909.            jz .fail
  910.  
  911.            mov [coff], eax
  912.            movzx ecx, [eax+CFH.nSections]
  913.            xor ebx, ebx
  914.  
  915.            lea edx, [eax+20]
  916. @@:
  917.            add ebx, [edx+CFS.SizeOfRawData]
  918.            add ebx, 15
  919.            and ebx, not 15
  920.            add edx, COFF_SECTION_SIZE
  921.            dec ecx
  922.            jnz @B
  923.            mov [img_size], ebx
  924.  
  925.            call init_heap
  926.            stdcall user_alloc, [img_size]
  927.  
  928.            test eax, eax
  929.            jz .fail
  930.            mov [img_base], eax
  931.  
  932.            mov edx, [coff]
  933.            movzx ebx, [edx+CFH.nSections]
  934.            mov edi, [img_base]
  935.            lea eax, [edx+20]
  936. @@:
  937.            mov [eax+CFS.VirtualAddress], edi
  938.            mov esi, [eax+CFS.PtrRawData]
  939.            test esi, esi
  940.            jnz .copy
  941.            add edi, [eax+CFS.SizeOfRawData]
  942.            jmp .next
  943. .copy:
  944.            add esi, edx
  945.     ;       add edi, new_app_base
  946.            mov ecx, [eax+CFS.SizeOfRawData]
  947.            cld
  948.            rep movsb
  949. .next:
  950.            add edi, 15 ;-new_app_base
  951.            and edi, -16
  952.            add eax, COFF_SECTION_SIZE
  953.            dec ebx
  954.            jnz @B
  955.  
  956.            mov ebx, [edx+CFH.pSymTable]
  957.            add ebx, edx
  958.            mov [sym], ebx
  959.            mov ecx, [edx+CFH.nSymbols]
  960.            add ecx,ecx
  961.            lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
  962.            add ecx, [sym]
  963.            mov [strings], ecx
  964.  
  965.            lea eax, [edx+20]
  966.  
  967.            stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
  968.                                      [strings], dword 0
  969.            test eax, eax
  970.            jnz @F
  971.  
  972. @@:
  973.            mov edx, [coff]
  974.            movzx ebx, [edx+CFH.nSections]
  975.            mov edi, new_app_base
  976.            lea eax, [edx+20]
  977. @@:
  978.            add [eax+CFS.VirtualAddress], edi  ;patch user space offset
  979.            add eax, COFF_SECTION_SIZE
  980.            dec ebx
  981.            jnz @B
  982.  
  983.            add edx, 20
  984.            stdcall fix_coff_relocs, [coff], edx, [sym]
  985.  
  986.            mov ebx, [coff]
  987.            stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
  988.            mov [exports], eax
  989.  
  990.            stdcall kernel_free, [coff]
  991.            mov eax, [exports]
  992.            ret
  993. .fail:
  994.            xor eax, eax
  995.            ret
  996. endp
  997.  
  998. align 4
  999. proc stop_all_services
  1000.  
  1001.            mov edx, [srv.fd]
  1002. .next:
  1003.            cmp edx,  srv.fd-SRV_FD_OFFSET
  1004.            je .done
  1005.            cmp [edx+SRV.magic], ' SRV'
  1006.            jne .next
  1007.            cmp [edx+SRV.size], SRV_SIZE
  1008.            jne .next
  1009.            mov ebx, [edx+SRV.entry]
  1010.            mov edx, [edx+SRV.fd]
  1011.            push edx
  1012.            stdcall ebx, dword -1
  1013.            pop edx
  1014.            jmp .next
  1015. .done:
  1016.            ret
  1017. endp
  1018.  
  1019. ; param
  1020. ;  eax= size
  1021. ;  ebx= pid
  1022.  
  1023. align 4
  1024. create_kernel_object:
  1025.  
  1026.            push ebx
  1027.            call malloc
  1028.            pop ebx
  1029.            test eax, eax
  1030.            jz .fail
  1031.  
  1032.            mov ecx,[current_slot]
  1033.            add ecx, APP_OBJ_OFFSET
  1034.  
  1035.            pushfd
  1036.            cli
  1037.            mov edx, [ecx+APPOBJ.fd]
  1038.            mov [eax+APPOBJ.fd], edx
  1039.            mov [eax+APPOBJ.bk], ecx
  1040.            mov [eax+APPOBJ.pid], ebx
  1041.  
  1042.            mov [ecx+APPOBJ.fd], eax
  1043.            mov [edx+APPOBJ.bk], eax
  1044.            popfd
  1045. .fail:
  1046.            ret
  1047.  
  1048. ; param
  1049. ;  eax= object
  1050.  
  1051. align 4
  1052. destroy_kernel_object:
  1053.  
  1054.            pushfd
  1055.            cli
  1056.            mov ebx, [eax+APPOBJ.fd]
  1057.            mov ecx, [eax+APPOBJ.bk]
  1058.            mov [ebx+APPOBJ.bk], ecx
  1059.            mov [ecx+APPOBJ.fd], ebx
  1060.            popfd
  1061.  
  1062.            xor edx, edx        ;clear common header
  1063.            mov [eax], edx
  1064.            mov [eax+4], edx
  1065.            mov [eax+8], edx
  1066.            mov [eax+12], edx
  1067.            mov [eax+16], edx
  1068.  
  1069.            call free           ;release object memory
  1070.            ret
  1071.  
  1072.  
  1073.  
  1074. if 0
  1075.  
  1076. irq:
  1077.  
  1078. .irq0:
  1079.            pusfd
  1080.            pushad
  1081.            push IRQ_0
  1082.            jmp .master
  1083. .irq_1:
  1084.            pusfd
  1085.            pushad
  1086.            push IRQ_1
  1087.            jmp .master
  1088.  
  1089. .master:
  1090.            mov ax, app_data
  1091.            mov ds, eax
  1092.            mov es, eax
  1093.            mov ebx, [esp+4]  ;IRQ_xx
  1094.            mov eax, [irq_handlers+ebx+4]
  1095.            call intr_handler
  1096.            mov ecx, [esp+4]
  1097.            cmp [irq_actids+ecx*4], 0
  1098.            je @F
  1099.            in al, 0x21
  1100.            bts eax, ecx
  1101.            out 0x21, al
  1102.            mov al, 0x20
  1103.            out 0x20, al
  1104.            jmp .restart
  1105.  
  1106. .slave:
  1107.            mov ax, app_data
  1108.            mov ds, eax
  1109.            mov es, eax
  1110.            mov ebx, [esp+4]  ;IRQ_xx
  1111.            mov eax, [irq_handlers+ebx+4]
  1112.            call intr_handler
  1113.            mov ecx, [esp+4]
  1114.            sub ecx, 8
  1115.            cmp [irq_actids+ecx*4], 0
  1116.            je @F
  1117.            in al, 0xA1
  1118.            bts eax, ecx
  1119.            out 0xA1, al
  1120.            mov al, 0x20
  1121.            out 0xA0, al
  1122.            out 0x20, al
  1123. .restart:
  1124.            mov ebx, [next_slot]
  1125.            test ebx, ebx
  1126.            jz @F
  1127.            mov [next_task],0
  1128.            mov esi, [prev_slot]
  1129.            call do_change_task
  1130.            add esp, 4
  1131.            iretd
  1132.  
  1133. end if
  1134.  
  1135.  
  1136.  
  1137.  
  1138.