Subversion Repositories Kolibri OS

Rev

Rev 945 | Rev 1030 | Go to most recent revision | 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: 983 $
  9.  
  10.  
  11. align 4
  12. proc alloc_page
  13.  
  14.            pushfd
  15.            cli
  16.            push ebx
  17.            mov ebx, [page_start]
  18.            mov ecx, [page_end]
  19. .l1:
  20.            bsf eax,[ebx];
  21.            jnz .found
  22.            add ebx,4
  23.            cmp ebx, ecx
  24.            jb .l1
  25.            pop ebx
  26.            popfd
  27.            xor eax,eax
  28.            ret
  29. .found:
  30.            btr [ebx], eax
  31.            mov [page_start],ebx
  32.            sub ebx, sys_pgmap
  33.            lea eax, [eax+ebx*8]
  34.            shl eax, 12
  35.            dec [pg_data.pages_free]
  36.            pop ebx
  37.            popfd
  38.            ret
  39. endp
  40.  
  41. align 4
  42. proc alloc_pages stdcall, count:dword
  43.            pushfd
  44.            push ebx
  45.            push edi
  46.            cli
  47.            mov eax, [count]
  48.            add eax, 7
  49.            shr eax, 3
  50.            mov [count], eax
  51.            cmp eax, [pg_data.pages_free]
  52.            ja .fail
  53.  
  54.            mov ecx, [page_start]
  55.            mov ebx, [page_end]
  56. .find:
  57.            mov edx, [count]
  58.            mov edi, ecx
  59. .match:
  60.            cmp byte [ecx], 0xFF
  61.            jne .next
  62.            dec edx
  63.            jz .ok
  64.            inc ecx
  65.            cmp ecx,ebx
  66.            jb .match
  67. .fail:
  68.            xor eax, eax
  69.            pop edi
  70.            pop ebx
  71.            popfd
  72.            ret
  73. .next:
  74.            inc ecx
  75.            cmp ecx, ebx
  76.            jb .find
  77.            pop edi
  78.            pop ebx
  79.            popfd
  80.            xor eax, eax
  81.            ret
  82. .ok:
  83.            sub ecx, edi
  84.            inc ecx
  85.            push esi
  86.            mov esi, edi
  87.            xor eax, eax
  88.            rep stosb
  89.            sub esi, sys_pgmap
  90.            shl esi, 3+12
  91.            mov eax, esi
  92.            mov ebx, [count]
  93.            shl ebx, 3
  94.            sub [pg_data.pages_free], ebx
  95.            pop esi
  96.            pop edi
  97.            pop ebx
  98.            popfd
  99.            ret
  100. endp
  101.  
  102. align 4
  103. proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
  104.            push ebx
  105.            mov eax, [phis_addr]
  106.            and eax, not 0xFFF
  107.            or eax, [flags]
  108.            mov ebx, [lin_addr]
  109.            shr ebx, 12
  110.            mov [page_tabs+ebx*4], eax
  111.            mov eax, [lin_addr]
  112.            invlpg [eax]
  113.            pop ebx
  114.            ret
  115. endp
  116.  
  117. align 4
  118. map_space:    ;not implemented
  119.  
  120.  
  121.            ret
  122.  
  123.  
  124. align 4
  125. proc free_page
  126. ;arg:  eax  page address
  127.            pushfd
  128.            cli
  129.            shr eax, 12                        ;page index
  130.            bts dword [sys_pgmap], eax         ;that's all!
  131.            cmc
  132.            adc [pg_data.pages_free], 0
  133.            shr eax, 3
  134.            and eax, not 3                     ;dword offset from page_map
  135.            add eax, sys_pgmap
  136.            cmp [page_start], eax
  137.            ja @f
  138.            popfd
  139.            ret
  140. @@:
  141.            mov [page_start], eax
  142.            popfd
  143.            ret
  144. endp
  145.  
  146. proc map_io_mem stdcall, base:dword, size:dword, flags:dword
  147.  
  148.            push ebx
  149.            push edi
  150.            mov eax, [size]
  151.            add eax, 4095
  152.            and eax, -4096
  153.            mov [size], eax
  154.            stdcall alloc_kernel_space, eax
  155.            test eax, eax
  156.            jz .fail
  157.            push eax
  158.  
  159.            mov edi, 0x1000
  160.            mov ebx, eax
  161.            mov ecx,[size]
  162.            mov edx, [base]
  163.            shr eax, 12
  164.            shr ecx, 12
  165.            and edx, -4096
  166.            or edx, [flags]
  167. @@:
  168.            mov [page_tabs+eax*4], edx
  169.           ; push eax
  170.           ; invlpg [ebx]
  171.           ; pop eax
  172.            inc eax
  173.            add ebx, edi
  174.            add edx, edi
  175.            loop @B
  176.  
  177.            pop eax
  178.            mov edx, [base]
  179.            and edx, 4095
  180.            add eax, edx
  181. .fail:
  182.            pop edi
  183.            pop ebx
  184.            ret
  185. endp
  186.  
  187. ; param
  188. ;  eax= page base + page flags
  189. ;  ebx= linear address
  190. ;  ecx= count
  191.  
  192. align 4
  193. commit_pages:
  194.            push edi
  195.            test ecx, ecx
  196.            jz .fail
  197.  
  198.            mov edi, ebx
  199.            mov ebx, pg_data.pg_mutex
  200.            call wait_mutex      ;ebx
  201.  
  202.            mov edx, 0x1000
  203.            mov ebx, edi
  204.            shr ebx, 12
  205. @@:
  206.            mov [page_tabs+ebx*4], eax
  207.           ; push eax
  208.           ; invlpg [edi]
  209.           ; pop eax
  210.            add edi, edx
  211.            add eax, edx
  212.            inc ebx
  213.            dec ecx
  214.            jnz @B
  215.            mov [pg_data.pg_mutex],ecx
  216. .fail:
  217.            pop edi
  218.            ret
  219.  
  220.  
  221. ; param
  222. ;  eax= base
  223. ;  ecx= count
  224.  
  225. align 4
  226. release_pages:
  227.  
  228.            pushad
  229.            mov ebx, pg_data.pg_mutex
  230.            call wait_mutex      ;ebx
  231.  
  232.            mov esi, eax
  233.            mov edi, eax
  234.  
  235.            shr esi, 10
  236.            add esi, page_tabs
  237.  
  238.            mov ebp, [pg_data.pages_free]
  239.            mov ebx, [page_start]
  240.            mov edx, sys_pgmap
  241. @@:
  242.            xor eax, eax
  243.            xchg eax, [esi]
  244.            push eax
  245.            invlpg [edi]
  246.            pop eax
  247.  
  248.            test eax, 1
  249.            jz .next
  250.  
  251.            shr eax, 12
  252.            bts [edx], eax
  253.            cmc
  254.            adc ebp, 0
  255.            shr eax, 3
  256.            and eax, -4
  257.            add eax, edx
  258.            cmp eax, ebx
  259.            jae .next
  260.  
  261.            mov ebx, eax
  262. .next:
  263.            add edi, 0x1000
  264.            add esi, 4
  265.            dec ecx
  266.            jnz @B
  267.            mov [pg_data.pages_free], ebp
  268.            and [pg_data.pg_mutex],0
  269.            popad
  270.            ret
  271.  
  272. ; param
  273. ;  eax= base
  274. ;  ecx= count
  275.  
  276. align 4
  277. unmap_pages:
  278.  
  279.            push edi
  280.  
  281.            mov edi, eax
  282.            mov edx, eax
  283.  
  284.            shr edi, 10
  285.            add edi, page_tabs
  286.  
  287.            xor eax, eax
  288. @@:
  289.            stosd
  290.            invlpg [edx]
  291.            add edx, 0x1000
  292.            loop @b
  293.  
  294.            pop edi
  295.            ret
  296.  
  297.  
  298. align 4
  299. proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
  300.            push ebx
  301.            mov ebx, [lin_addr]
  302.            shr ebx, 22
  303.            mov eax, [phis_addr]
  304.            and eax, not 0xFFF
  305.            or eax, PG_UW          ;+PG_NOCACHE
  306.            mov dword [master_tab+ebx*4], eax
  307.            mov eax, [lin_addr]
  308.            shr eax, 10
  309.            add eax, page_tabs
  310.            invlpg [eax]
  311.            pop ebx
  312.            ret
  313. endp
  314.  
  315. align 4
  316. proc init_LFB
  317.            locals
  318.              pg_count dd ?
  319.            endl
  320.  
  321.            cmp dword [LFBAddress], -1
  322.            jne @f
  323.            mov [BOOT_VAR+0x901c],byte 2
  324.            stdcall kernel_alloc, 0x280000
  325.            mov [LFBAddress], eax
  326.            ret
  327. @@:
  328.            test [SCR_MODE],word 0100000000000000b
  329.            jnz @f
  330.            mov [BOOT_VAR+0x901c],byte 2
  331.            ret
  332. @@:
  333.            call init_mtrr
  334.  
  335.            mov edx, LFB_BASE
  336.            mov esi, [LFBAddress]
  337.            mov edi, 0x00800000
  338.            mov dword [exp_lfb+4], edx
  339.  
  340.            shr edi, 12
  341.            mov [pg_count], edi
  342.            shr edi, 10
  343.  
  344.            bt [cpu_caps], CAPS_PSE
  345.            jnc .map_page_tables
  346.            or esi, PG_LARGE+PG_UW
  347.            mov edx, sys_pgdir+(LFB_BASE shr 20)
  348. @@:
  349.            mov [edx], esi
  350.            add edx, 4
  351.            add esi, 0x00400000
  352.            dec edi
  353.            jnz @B
  354.  
  355.            bt [cpu_caps], CAPS_PGE
  356.            jnc @F
  357.            or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
  358. @@:
  359.            mov dword [LFBAddress], LFB_BASE
  360.            mov eax, cr3       ;flush TLB
  361.            mov cr3, eax
  362.            ret
  363.  
  364. .map_page_tables:
  365.  
  366. @@:
  367.            call alloc_page
  368.            stdcall map_page_table, edx, eax
  369.            add edx, 0x00400000
  370.            dec edi
  371.            jnz @B
  372.  
  373.            mov eax, [LFBAddress]
  374.            mov edi, page_tabs + (LFB_BASE shr 10)
  375.            or eax, PG_UW
  376.            mov ecx, [pg_count]
  377.            cld
  378. @@:
  379.            stosd
  380.            add eax, 0x1000
  381.            dec ecx
  382.            jnz @B
  383.  
  384.            mov dword [LFBAddress], LFB_BASE
  385.            mov eax, cr3       ;flush TLB
  386.            mov cr3, eax
  387.  
  388.            ret
  389. endp
  390.  
  391. align 4
  392. proc new_mem_resize stdcall, new_size:dword
  393.  
  394.            mov ebx, pg_data.pg_mutex
  395.            call wait_mutex    ;ebx
  396.  
  397.            mov edi, [new_size]
  398.            add edi,4095
  399.            and edi,not 4095
  400.            mov [new_size], edi
  401.  
  402.            mov edx,[current_slot]
  403.            cmp [edx+APPDATA.heap_base],0
  404.            jne .exit
  405.  
  406.            mov esi, [edx+APPDATA.mem_size]
  407.            add esi, 4095
  408.            and esi, not 4095
  409.  
  410.            cmp edi, esi
  411.            jae .expand
  412.  
  413.            shr edi, 12
  414.            shr esi, 12
  415. @@:
  416.            mov eax, [app_page_tabs+edi*4]
  417.            test eax, 1
  418.            jz .next
  419.            mov dword [app_page_tabs+edi*4], 2
  420.            mov ebx, edi
  421.            shl ebx, 12
  422.            push eax
  423.            invlpg [ebx]
  424.            pop eax
  425.            call free_page
  426.  
  427. .next:     add edi, 1
  428.            cmp edi, esi
  429.            jb @B
  430.  
  431. .update_size:
  432.            mov     ebx, [new_size]
  433.            call    update_mem_size
  434.  
  435.            xor eax, eax
  436.            dec [pg_data.pg_mutex]
  437.            ret
  438. .expand:
  439.  
  440.            push esi
  441.            push edi
  442.  
  443.            add edi, 0x3FFFFF
  444.            and edi, not(0x3FFFFF)
  445.            add esi, 0x3FFFFF
  446.            and esi, not(0x3FFFFF)
  447.  
  448.            cmp esi, edi
  449.            jae .grow
  450.  
  451.            xchg esi, edi
  452.  
  453. @@:
  454.            call alloc_page
  455.            test eax, eax
  456.            jz .exit
  457.  
  458.            stdcall map_page_table, edi, eax
  459.  
  460.            push edi
  461.            shr edi, 10
  462.            add edi, page_tabs
  463.            mov ecx, 1024
  464.            xor eax, eax
  465.            cld
  466.            rep stosd
  467.            pop edi
  468.  
  469.            add edi, 0x00400000
  470.            cmp edi, esi
  471.            jb @B
  472. .grow:
  473.            pop edi
  474.            pop esi
  475. @@:
  476.            call alloc_page
  477.            test eax, eax
  478.            jz .exit
  479.            stdcall map_page,esi,eax,dword PG_UW
  480.  
  481.            push edi
  482.            mov edi, esi
  483.            xor eax, eax
  484.            mov ecx, 1024
  485.            cld
  486.            rep stosd
  487.            pop edi
  488.  
  489.            add esi, 0x1000
  490.            cmp esi, edi
  491.            jb  @B
  492.  
  493.            jmp .update_size
  494. .exit:
  495.            xor eax, eax
  496.            inc eax
  497.            dec [pg_data.pg_mutex]
  498.            ret
  499. endp
  500.  
  501. update_mem_size:
  502. ; in: edx = slot base
  503. ;     ebx = new memory size
  504. ; destroys eax,ecx,edx
  505.  
  506.            mov    [APPDATA.mem_size+edx],ebx
  507. ;search threads and update
  508. ;application memory size infomation
  509.            mov    ecx,[APPDATA.dir_table+edx]
  510.            mov    eax,2
  511.  
  512. .search_threads:
  513. ;eax = current slot
  514. ;ebx = new memory size
  515. ;ecx = page directory
  516.            cmp    eax,[TASK_COUNT]
  517.            jg     .search_threads_end
  518.            mov    edx,eax
  519.            shl    edx,5
  520.            cmp    word [CURRENT_TASK+edx+TASKDATA.state],9 ;if slot empty?
  521.            jz     .search_threads_next
  522.            shl    edx,3
  523.            cmp    [SLOT_BASE+edx+APPDATA.dir_table],ecx     ;if it is our thread?
  524.            jnz    .search_threads_next
  525.            mov    [SLOT_BASE+edx+APPDATA.mem_size],ebx     ;update memory size
  526. .search_threads_next:
  527.            inc    eax
  528.            jmp    .search_threads
  529. .search_threads_end:
  530.            ret
  531.  
  532. ; param
  533. ;  eax= linear address
  534. ;
  535. ; retval
  536. ;  eax= phisical page address
  537.  
  538. align 4
  539. get_pg_addr:
  540.            shr eax, 12
  541.            mov eax, [page_tabs+eax*4]
  542.            and eax, 0xFFFFF000
  543.            ret
  544.  
  545.  
  546. align 4
  547. proc page_fault_handler
  548.  
  549.         test    byte [esp+12+2], 2
  550.         jnz     v86_page_fault
  551.  
  552.         .err_code equ ebp+32
  553.         .err_addr equ ebp-4
  554.  
  555.            pushad
  556.            mov ebp, esp
  557.            mov eax, cr2
  558.            push eax
  559.  
  560.            mov ax, app_data
  561.            mov ds, ax
  562.            mov es, ax
  563.  
  564.            inc [pg_data.pages_faults]
  565.  
  566. ;     push eax
  567. ;     push edx
  568. ;     mov edx, 0x400   ;bochs
  569. ;     mov al,0xff      ;bochs
  570. ;     out dx, al       ;bochs
  571. ;     pop edx
  572. ;     pop eax
  573.  
  574.            mov ebx, [.err_addr]
  575.            mov eax, [.err_code]
  576.  
  577.            cmp ebx, OS_BASE
  578.            jb .user_space      ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
  579.  
  580.            cmp ebx, page_tabs
  581.            jb .kernel_space    ;ñòðàíèöà â ïàìÿòè ÿäðà
  582.  
  583.            cmp ebx, kernel_tabs
  584.            jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
  585.                                ;ïðîñòî ñîçäàäèì îäíó
  586.  
  587.            cmp ebx, LFB_BASE
  588.            jb .core_tabs       ;òàáëèöû ñòðàíèö ÿäðà
  589.                                ;Îøèáêà
  590. .lfb:
  591.                                ;îáëàñòü LFB
  592.                                ;Îøèáêà
  593.            jmp .fail
  594.  
  595. align 4
  596. .user_space:
  597.            test eax, PG_MAP
  598.            jnz .err_access     ;Ñòðàíèöà ïðèñóòñòâóåò
  599.                                ;Îøèáêà äîñòóïà ?
  600.  
  601.            shr ebx, 12
  602.            mov ecx, ebx
  603.            shr ecx, 10
  604.            mov edx, [master_tab+ecx*4]
  605.            test edx, PG_MAP
  606.            jz .fail            ;òàáëèöà ñòðàíèö íå ñîçäàíà
  607.                                ;íåâåðíûé àäðåñ â ïðîãðàììå
  608.  
  609.            mov eax, [page_tabs+ebx*4]
  610.            test eax, 2
  611.            jz .fail            ;àäðåñ íå çàðåçåðâèðîâàí äëÿ ;
  612.                                ;èñïîëüçîâàíèÿ. Îøèáêà
  613. .alloc:
  614.            call alloc_page
  615.            test eax, eax
  616.            jz .fail
  617.  
  618.            stdcall map_page,[ebp-4],eax,dword PG_UW
  619.  
  620.            mov edi, [ebp-4]
  621.            and edi, 0xFFFFF000
  622.            mov ecx, 1024
  623.            xor eax, eax
  624.            cld
  625.            rep stosd
  626. .exit:
  627.            mov esp, ebp
  628.            popad
  629.            add esp, 4
  630.            iretd
  631.  
  632. .err_access:
  633. ;íèêîãäà íå ïðîèñõîäèò
  634.            jmp .fail
  635.  
  636. .kernel_space:
  637.            test eax, PG_MAP
  638.            jz .fail        ;ñòðàíèöà íå ïðèñóòñòâóåò
  639.  
  640.            test eax, 4     ;U/S
  641.            jnz .fail       ;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè
  642.                            ;ÿäðà
  643.            test eax, 8
  644.            jnz .fail       ;óñòàíîâëåí çàðåçåðâèðîâàííûé áèò
  645.                            ;â òàáëèöàõ ñòðàíèö. äîáàâëåíî â P4/Xeon
  646.  
  647. ;ïîïûòêà çàïèñè â çàùèù¸ííóþ ñòðàíèöó ÿäðà
  648.  
  649.            cmp ebx, tss._io_map_0
  650.            jb .fail
  651.  
  652.            cmp ebx, tss._io_map_0+8192
  653.            jae .fail
  654.  
  655. ; io permission map
  656. ; copy-on-write protection
  657.  
  658.            call alloc_page
  659.            test eax, eax
  660.            jz .fail
  661.  
  662.            push eax
  663.            stdcall map_page,[ebp-4],eax,dword PG_SW
  664.            pop eax
  665.            mov edi, [.err_addr]
  666.            and edi, -4096
  667.            lea esi, [edi+(not tss._io_map_0)+1]; -tss._io_map_0
  668.  
  669.            mov ebx, esi
  670.            shr ebx, 12
  671.            mov edx, [current_slot]
  672.            or eax, PG_SW
  673.            mov [edx+APPDATA.io_map+ebx*4], eax
  674.  
  675.            add esi, [default_io_map]
  676.            mov ecx, 4096/4
  677.            cld
  678.            rep movsd
  679.            jmp .exit
  680.  
  681.  
  682. ;íå îáðàáàòûâàåì. Îøèáêà
  683.  
  684. .core_tabs:
  685. .fail:
  686.            mov esp, ebp
  687.            popad
  688.            add esp, 4
  689.  
  690. ;           iretd
  691.  
  692.            save_ring3_context     ;debugger support
  693.  
  694.            mov bl, 14
  695.            jmp exc_c
  696.            iretd
  697. endp
  698.  
  699. align 4
  700. proc map_mem stdcall, lin_addr:dword,pdir:dword,\
  701.                       ofs:dword,buf_size:dword
  702.            mov eax, [buf_size]
  703.            test eax, eax
  704.            jz .exit
  705.  
  706.            mov eax, [pdir]
  707.            and eax, 0xFFFFF000
  708.  
  709.            stdcall map_page,[ipc_pdir],eax,PG_UW
  710.            mov ebx, [ofs]
  711.            shr ebx, 22
  712.            mov esi, [ipc_pdir]
  713.            mov edi, [ipc_ptab]
  714.            mov eax, [esi+ebx*4]
  715.            and eax, 0xFFFFF000
  716.            jz .exit
  717.            stdcall map_page,edi,eax,PG_UW
  718. ;           inc ebx
  719. ;           add edi, 0x1000
  720. ;           mov eax, [esi+ebx*4]
  721. ;           test eax, eax
  722. ;           jz @f
  723. ;          and eax, 0xFFFFF000
  724. ;           stdcall map_page, edi, eax
  725.  
  726. @@:        mov edi, [lin_addr]
  727.            and edi, 0xFFFFF000
  728.            mov ecx, [buf_size]
  729.            add ecx, 4095
  730.            shr ecx, 12
  731.            inc ecx
  732.  
  733.            mov edx, [ofs]
  734.            shr edx, 12
  735.            and edx, 0x3FF
  736.            mov esi, [ipc_ptab]
  737.  
  738. .map:      mov eax, [esi+edx*4]
  739.            and eax, 0xFFFFF000
  740.            jz  .exit
  741.            stdcall map_page,edi,eax,PG_UW
  742.            dec ecx
  743.            jz  .exit
  744.            add edi, 0x1000
  745.            inc edx
  746.            cmp edx, 0x400
  747.            jnz .map
  748.            inc ebx
  749.            mov eax, [ipc_pdir]
  750.            mov eax, [eax+ebx*4]
  751.            and eax, 0xFFFFF000
  752.            jz  .exit
  753.            stdcall map_page,esi,eax,PG_UW
  754.            xor edx, edx
  755.            jmp .map
  756.  
  757. .exit:
  758.            ret
  759. endp
  760.  
  761. align 4
  762. proc map_memEx stdcall, lin_addr:dword,pdir:dword,\
  763.                         ofs:dword,buf_size:dword
  764.            mov eax, [buf_size]
  765.            test eax, eax
  766.            jz .exit
  767.  
  768.            mov eax, [pdir]
  769.            and eax, 0xFFFFF000
  770.  
  771.            stdcall map_page,[proc_mem_pdir],eax,dword PG_UW
  772.            mov ebx, [ofs]
  773.            shr ebx, 22
  774.            mov esi, [proc_mem_pdir]
  775.            mov edi, [proc_mem_tab]
  776.            mov eax, [esi+ebx*4]
  777.            and eax, 0xFFFFF000
  778.            test eax, eax
  779.            jz .exit
  780.            stdcall map_page,edi,eax,dword PG_UW
  781.  
  782. @@:        mov edi, [lin_addr]
  783.            and edi, 0xFFFFF000
  784.            mov ecx, [buf_size]
  785.            add ecx, 4095
  786.            shr ecx, 12
  787.            inc ecx
  788.  
  789.            mov edx, [ofs]
  790.            shr edx, 12
  791.            and edx, 0x3FF
  792.            mov esi, [proc_mem_tab]
  793.  
  794. .map:      mov eax, [esi+edx*4]
  795. ;           and eax, 0xFFFFF000
  796. ;           test eax, eax
  797. ;           jz .exit
  798.            stdcall map_page,edi,eax,dword PG_UW
  799.            add edi, 0x1000
  800.            inc edx
  801.            dec ecx
  802.            jnz .map
  803. .exit:
  804.            ret
  805. endp
  806.  
  807.  
  808.  
  809.  
  810. sys_IPC:
  811. ;input:
  812. ;  eax=1 - set ipc buffer area
  813. ;    ebx=address of buffer
  814. ;    ecx=size of buffer
  815. ;  eax=2 - send message
  816. ;    ebx=PID
  817. ;    ecx=address of message
  818. ;    edx=size of message
  819.  
  820.            cmp  eax,1
  821.            jne @f
  822.            call set_ipc_buff
  823.            mov [esp+36], eax
  824.            ret
  825. @@:
  826.            cmp eax, 2
  827.            jne @f
  828.            stdcall sys_ipc_send, ebx, ecx, edx
  829.            mov [esp+36], eax
  830.            ret
  831. @@:
  832.            xor eax, eax
  833.            not eax
  834.            mov [esp+36], eax
  835.            ret
  836.  
  837. align 4
  838. proc set_ipc_buff
  839.  
  840.            mov  eax,[current_slot]
  841.            pushf
  842.            cli
  843.            mov  [eax+APPDATA.ipc_start],ebx     ;set fields in extended information area
  844.            mov  [eax+APPDATA.ipc_size],ecx
  845.  
  846.            add ecx, ebx
  847.            add ecx, 4095
  848.            and ecx, not 4095
  849.  
  850. .touch:    mov eax, [ebx]
  851.            add ebx, 0x1000
  852.            cmp ebx, ecx
  853.            jb  .touch
  854.  
  855.            popf
  856.            xor eax, eax
  857.            ret
  858. endp
  859.  
  860. proc sys_ipc_send stdcall, PID:dword, msg_addr:dword, msg_size:dword
  861.            locals
  862.              dst_slot   dd ?
  863.              dst_offset dd ?
  864.              buf_size   dd ?
  865.              used_buf   dd ?
  866.            endl
  867.  
  868.            pushf
  869.            cli
  870.  
  871.            mov  eax, [PID]
  872.            call pid_to_slot
  873.            test eax,eax
  874.            jz   .no_pid
  875.  
  876.            mov [dst_slot], eax
  877.            shl  eax,8
  878.            mov  edi,[eax+SLOT_BASE+0xa0]  ;is ipc area defined?
  879.            test edi,edi
  880.            jz   .no_ipc_area
  881.  
  882.            mov ebx, edi
  883.            and ebx, 0xFFF
  884.            mov [dst_offset], ebx
  885.  
  886.            mov esi, [eax+SLOT_BASE+0xa4]
  887.            mov [buf_size], esi
  888.  
  889.            mov ecx, [ipc_tmp]
  890.            cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page
  891.            jbe @f
  892.            push eax esi edi
  893.            add esi,0x1000
  894.            stdcall alloc_kernel_space,esi
  895.            mov ecx, eax
  896.            pop edi esi eax
  897. @@:
  898.            mov [used_buf], ecx
  899.            stdcall map_mem, ecx, [SLOT_BASE+eax+0xB8],\
  900.                              edi, esi
  901.  
  902.            mov edi, [dst_offset]
  903.            add edi, [used_buf]
  904.            cmp dword [edi], 0
  905.            jnz  .ipc_blocked          ;if dword [buffer]<>0 - ipc blocked now
  906.  
  907.            mov edx, dword [edi+4]
  908.            lea ebx, [edx+8]
  909.            add ebx, [msg_size]
  910.            cmp ebx, [buf_size]
  911.            ja .buffer_overflow         ;esi<0 - not enough memory in buffer
  912.  
  913.            mov dword [edi+4], ebx
  914.            mov eax,[TASK_BASE]
  915.            mov eax, [eax+0x04]         ;eax - our PID
  916.            add edi, edx
  917.            mov [edi], eax
  918.            mov ecx, [msg_size]
  919.  
  920.            mov [edi+4], ecx
  921.            add edi, 8
  922.            mov esi, [msg_addr]
  923.        ;    add esi, new_app_base
  924.            cld
  925.            rep movsb
  926.  
  927.            mov ebx, [ipc_tmp]
  928.            mov edx, ebx
  929.            shr ebx, 12
  930.            xor eax, eax
  931.            mov [page_tabs+ebx*4], eax
  932.            invlpg [edx]
  933.  
  934.            mov ebx, [ipc_pdir]
  935.            mov edx, ebx
  936.            shr ebx, 12
  937.            xor eax, eax
  938.            mov [page_tabs+ebx*4], eax
  939.            invlpg [edx]
  940.  
  941.            mov ebx, [ipc_ptab]
  942.            mov edx, ebx
  943.            shr ebx, 12
  944.            xor eax, eax
  945.            mov [page_tabs+ebx*4], eax
  946.            invlpg [edx]
  947.  
  948.            mov  eax, [dst_slot]
  949.            shl eax, 8
  950.            or   [eax+SLOT_BASE+0xA8],dword 0x40
  951.            cmp  dword [check_idle_semaphore],20
  952.            jge  .ipc_no_cis
  953.  
  954.            mov  dword [check_idle_semaphore],5
  955. .ipc_no_cis:
  956.            push 0
  957.            jmp .ret
  958. .no_pid:
  959.            popf
  960.            mov eax, 4
  961.            ret
  962. .no_ipc_area:
  963.            popf
  964.            xor eax, eax
  965.            inc eax
  966.            ret
  967. .ipc_blocked:
  968.            push 2
  969.            jmp .ret
  970. .buffer_overflow:
  971.            push 3
  972. .ret:
  973.            mov eax, [used_buf]
  974.            cmp eax, [ipc_tmp]
  975.            jz @f
  976.            stdcall free_kernel_space,eax
  977. @@:
  978.            pop eax
  979.            popf
  980.            ret
  981. endp
  982.  
  983. align 4
  984. sysfn_meminfo:
  985.  
  986.         ;   add ebx, new_app_base
  987.            cmp ebx, OS_BASE
  988.            jae .fail
  989.  
  990.            mov eax, [pg_data.pages_count]
  991.            mov [ebx], eax
  992.            shl eax, 12
  993.            mov [esp+36], eax
  994.            mov ecx, [pg_data.pages_free]
  995.            mov [ebx+4], ecx
  996.            mov edx, [pg_data.pages_faults]
  997.            mov [ebx+8], edx
  998.            mov esi, [heap_size]
  999.            mov [ebx+12], esi
  1000.            mov edi, [heap_free]
  1001.            mov [ebx+16], edi
  1002.            mov eax, [heap_blocks]
  1003.            mov [ebx+20], eax
  1004.            mov ecx, [free_blocks]
  1005.            mov [ebx+24], ecx
  1006.            ret
  1007. .fail:
  1008.            mov dword [esp+36], -1
  1009.            ret
  1010.  
  1011. align 4
  1012. f68call:
  1013.            dd f68.11
  1014.            dd f68.12
  1015.            dd f68.13
  1016.            dd f68.14
  1017.            dd f68.15
  1018.            dd f68.16
  1019.            dd f68.17
  1020.            dd f68.18
  1021.            dd f68.19
  1022.            dd f68.20
  1023.            dd f68.21
  1024.            dd f68.22
  1025.            dd f68.23
  1026.  
  1027. align 4
  1028. f68:
  1029.            cmp  eax,4
  1030.            jle  sys_sheduler
  1031.  
  1032.            cmp eax, 11
  1033.            jb .fail
  1034.  
  1035.            cmp eax, 23
  1036.            ja .fail
  1037.  
  1038.            jmp dword [f68call+eax*4-11*4]
  1039. .11:
  1040.            call init_heap
  1041.            mov [esp+36], eax
  1042.            ret
  1043. .12:
  1044.            stdcall user_alloc, ebx
  1045.            mov [esp+36], eax
  1046.            ret
  1047. .13:
  1048.            stdcall user_free, ebx
  1049.            mov [esp+36], eax
  1050.            ret
  1051. .14:
  1052.            cmp ebx, OS_BASE
  1053.            jae .fail
  1054.            stdcall get_event_ex, ebx, ecx
  1055.            mov [esp+36], eax
  1056.            ret
  1057. .15:
  1058.            mov ecx, [current_slot]
  1059.            mov eax, [ecx+APPDATA.fpu_handler]
  1060.            mov [ecx+APPDATA.fpu_handler], ebx
  1061.            mov [esp+36], eax
  1062.            ret
  1063. .16:
  1064.            test ebx, ebx
  1065.            jz .fail
  1066.            cmp ebx, OS_BASE
  1067.            jae .fail
  1068.            stdcall get_service, ebx
  1069.            mov [esp+36], eax
  1070.            ret
  1071. .17:
  1072.            call srv_handlerEx   ;ebx
  1073.            mov [esp+36], eax
  1074.            ret
  1075. .18:
  1076.            mov ecx, [current_slot]
  1077.            mov eax, [ecx+APPDATA.sse_handler]
  1078.            mov [ecx+APPDATA.sse_handler], ebx
  1079.            mov [esp+36], eax
  1080.            ret
  1081. .19:
  1082.            cmp ebx, OS_BASE
  1083.            jae .fail
  1084.            stdcall load_library, ebx
  1085.            mov [esp+36], eax
  1086.            ret
  1087. .20:
  1088.            mov     eax, ecx
  1089.            call    user_realloc
  1090.            mov     [esp+36], eax
  1091.            ret
  1092. .21:
  1093.            cmp ebx, OS_BASE
  1094.            jae .fail
  1095.  
  1096.            stdcall load_PE, ebx
  1097.  
  1098.            test eax, eax
  1099.            jz @F
  1100.  
  1101.            mov esi, eax
  1102.            stdcall eax, DRV_ENTRY
  1103.  
  1104.            test eax, eax
  1105.            jz @F
  1106.  
  1107.            mov [eax+SRV.entry], esi
  1108.  
  1109. @@:
  1110.            mov [esp+36], eax
  1111.            ret
  1112. .22:
  1113.            cmp ebx, OS_BASE
  1114.            jae .fail
  1115.  
  1116.            stdcall shmem_open, ebx, ecx, edx
  1117.            mov [esp+28], edx
  1118.            mov [esp+36], eax
  1119.            ret
  1120.  
  1121. .23:
  1122.            cmp ebx, OS_BASE
  1123.            jae .fail
  1124.  
  1125.            stdcall shmem_close, ebx
  1126.            mov [esp+36], eax
  1127.            ret
  1128.  
  1129. .fail:
  1130.            xor eax, eax
  1131.            mov [esp+36], eax
  1132.            ret
  1133.  
  1134. align 4
  1135. proc load_pe_driver stdcall, file:dword
  1136.  
  1137.            stdcall load_PE, [file]
  1138.            test eax, eax
  1139.            jz .fail
  1140.  
  1141.            mov esi, eax
  1142.            stdcall eax, DRV_ENTRY
  1143.            test eax, eax
  1144.            jz .fail
  1145.  
  1146.            mov [eax+SRV.entry], esi
  1147.            ret
  1148.  
  1149. .fail:
  1150.            xor eax, eax
  1151.            ret
  1152. endp
  1153.  
  1154.  
  1155. align 4
  1156. proc init_mtrr
  1157.  
  1158.            cmp [BOOT_VAR+0x901c],byte 2
  1159.            je  .exit
  1160.  
  1161.            bt [cpu_caps], CAPS_MTRR
  1162.            jnc .exit
  1163.  
  1164.            mov eax, cr0
  1165.            or eax, 0x60000000   ;disable caching
  1166.            mov cr0, eax
  1167.            wbinvd               ;invalidate cache
  1168.  
  1169.            mov ecx, 0x2FF
  1170.            rdmsr                ;
  1171.            push eax
  1172.  
  1173.            xor edx, edx
  1174.            xor eax, eax
  1175.            mov ecx, 0x2FF
  1176.            wrmsr                ;disable all MTRR
  1177.  
  1178.            mov eax, [MEM_AMOUNT]
  1179. ; round eax up to next power of 2
  1180.            dec eax
  1181.            bsr ecx, eax
  1182.            mov eax, 2
  1183.            shl eax, cl
  1184.            stdcall set_mtrr, edx,edx,eax,MEM_WB
  1185.            stdcall set_mtrr, 1,[LFBAddress],[LFBSize],MEM_WC
  1186.            xor edx, edx
  1187.            xor eax, eax
  1188.            mov ecx, 0x204
  1189.            mov ebx, 6
  1190. @@:
  1191.            wrmsr                ;disable unused MTRR
  1192.            inc ecx
  1193.            wrmsr
  1194.            inc ecx
  1195.            dec ebx
  1196.            jnz @b
  1197.  
  1198.            wbinvd               ;again invalidate
  1199.  
  1200.            pop eax
  1201.            or eax, 0x800        ;set default memtype to UC
  1202.            and al, 0xF0
  1203.            mov ecx, 0x2FF
  1204.            wrmsr                ;and enable MTRR
  1205.  
  1206.            mov eax, cr0
  1207.            and eax, not 0x60000000
  1208.            mov cr0, eax         ; enable caching
  1209. .exit:
  1210.            ret
  1211. endp
  1212.  
  1213. align 4
  1214. proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword
  1215.  
  1216.            xor edx, edx
  1217.            mov eax, [base]
  1218.            or eax, [mem_type]
  1219.            mov ecx, [reg]
  1220.            lea ecx, [0x200+ecx*2]
  1221.            wrmsr
  1222.  
  1223.            mov ebx, [size]
  1224.            dec ebx
  1225.            mov eax, 0xFFFFFFFF
  1226.            mov edx, 0x0000000F
  1227.            sub eax, ebx
  1228.            sbb edx, 0
  1229.            or eax, 0x800
  1230.            inc ecx
  1231.            wrmsr
  1232.            ret
  1233. endp
  1234.  
  1235. align 4
  1236. proc stall stdcall, delay:dword
  1237.            push ecx
  1238.            push edx
  1239.            push ebx
  1240.            push eax
  1241.  
  1242.            mov eax, [delay]
  1243.            mul [stall_mcs]
  1244.            mov ebx, eax       ;low
  1245.            mov ecx, edx       ;high
  1246.            rdtsc
  1247.            add ebx, eax
  1248.            adc ecx,edx
  1249. @@:
  1250.            rdtsc
  1251.            sub eax, ebx
  1252.            sbb edx, ecx
  1253.            jb @B
  1254.  
  1255.            pop eax
  1256.            pop ebx
  1257.            pop edx
  1258.            pop ecx
  1259.            ret
  1260. endp
  1261.  
  1262. align 4
  1263. proc create_ring_buffer stdcall, size:dword, flags:dword
  1264.            locals
  1265.              buf_ptr  dd ?
  1266.            endl
  1267.  
  1268.            mov eax, [size]
  1269.            test eax, eax
  1270.            jz .fail
  1271.  
  1272.            add eax, eax
  1273.            stdcall alloc_kernel_space, eax
  1274.            test eax, eax
  1275.            jz .fail
  1276.  
  1277.            push ebx
  1278.  
  1279.            mov [buf_ptr], eax
  1280.  
  1281.            mov ebx, [size]
  1282.            shr ebx, 12
  1283.            push ebx
  1284.  
  1285.            stdcall alloc_pages, ebx
  1286.            pop ecx
  1287.  
  1288.            test eax, eax
  1289.            jz .mm_fail
  1290.  
  1291.            push edi
  1292.  
  1293.            or eax, [flags]
  1294.            mov edi, [buf_ptr]
  1295.            mov ebx, [buf_ptr]
  1296.            mov edx, ecx
  1297.            shl edx, 2
  1298.            shr edi, 10
  1299. @@:
  1300.            mov [page_tabs+edi], eax
  1301.            mov [page_tabs+edi+edx], eax
  1302.            invlpg [ebx]
  1303.            invlpg [ebx+0x10000]
  1304.            add eax, 0x1000
  1305.            add ebx, 0x1000
  1306.            add edi, 4
  1307.            dec ecx
  1308.            jnz @B
  1309.  
  1310.            mov eax, [buf_ptr]
  1311.            pop edi
  1312.            pop ebx
  1313.            ret
  1314. .mm_fail:
  1315.            stdcall free_kernel_space, [buf_ptr]
  1316.            xor eax, eax
  1317.            pop ebx
  1318. .fail:
  1319.            ret
  1320. endp
  1321.  
  1322.  
  1323.  
  1324.