Subversion Repositories Kolibri OS

Rev

Rev 928 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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