Subversion Repositories Kolibri OS

Rev

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

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