Subversion Repositories Kolibri OS

Rev

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