Subversion Repositories Kolibri OS

Rev

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

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