Subversion Repositories Kolibri OS

Rev

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

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