WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/memory.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2987 $
 
 
align 4
proc alloc_page
 
        pushfd
        cli
        push    ebx
;//-
        cmp     [pg_data.pages_free], 1
        jle     .out_of_memory
;//-
 
        mov     ebx, [page_start]
        mov     ecx, [page_end]
.l1:
        bsf     eax, [ebx];
        jnz     .found
        add     ebx, 4
        cmp     ebx, ecx
        jb      .l1
        pop     ebx
        popfd
        xor     eax, eax
        ret
.found:
;//-
        dec     [pg_data.pages_free]
        jz      .out_of_memory
;//-
        btr     [ebx], eax
        mov     [page_start], ebx
        sub     ebx, sys_pgmap
        lea     eax, [eax+ebx*8]
        shl     eax, 12
;//-       dec [pg_data.pages_free]
        pop     ebx
        popfd
        ret
;//-
.out_of_memory:
        mov     [pg_data.pages_free], 1
        xor     eax, eax
        pop     ebx
        popfd
        ret
;//-
endp
 
align 4
proc alloc_pages stdcall, count:dword
        pushfd
        push    ebx
        push    edi
        cli
        mov     eax, [count]
        add     eax, 7
        shr     eax, 3
        mov     [count], eax
;//-
        mov     ebx, [pg_data.pages_free]
        sub     ebx, 9
        js      .out_of_memory
        shr     ebx, 3
        cmp     eax, ebx
        jg      .out_of_memory
;//-
        mov     ecx, [page_start]
        mov     ebx, [page_end]
.find:
        mov     edx, [count]
        mov     edi, ecx
.match:
        cmp     byte [ecx], 0xFF
        jne     .next
        dec     edx
        jz      .ok
        inc     ecx
        cmp     ecx, ebx
        jb      .match
.out_of_memory:
.fail:
        xor     eax, eax
        pop     edi
        pop     ebx
        popfd
        ret
.next:
        inc     ecx
        cmp     ecx, ebx
        jb      .find
        pop     edi
        pop     ebx
        popfd
        xor     eax, eax
        ret
.ok:
        sub     ecx, edi
        inc     ecx
        push    esi
        mov     esi, edi
        xor     eax, eax
        rep stosb
        sub     esi, sys_pgmap
        shl     esi, 3+12
        mov     eax, esi
        mov     ebx, [count]
        shl     ebx, 3
        sub     [pg_data.pages_free], ebx
        pop     esi
        pop     edi
        pop     ebx
        popfd
        ret
endp
 
align 4
proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
        push    ebx
        mov     eax, [phis_addr]
        and     eax, not 0xFFF
        or      eax, [flags]
        mov     ebx, [lin_addr]
        shr     ebx, 12
        mov     [page_tabs+ebx*4], eax
        mov     eax, [lin_addr]
        invlpg  [eax]
        pop     ebx
        ret
endp
 
align 4
map_space:    ;not implemented
 
 
        ret
 
 
align 4
proc free_page
;arg:  eax  page address
        pushfd
        cli
        shr     eax, 12                       ;page index
        bts     dword [sys_pgmap], eax        ;that's all!
        cmc
        adc     [pg_data.pages_free], 0
        shr     eax, 3
        and     eax, not 3                    ;dword offset from page_map
        add     eax, sys_pgmap
        cmp     [page_start], eax
        ja      @f
        popfd
        ret
@@:
        mov     [page_start], eax
        popfd
        ret
endp
 
align 4
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
        push    ebx
        push    edi
        mov     eax, [size]
        add     eax, [base]
        add     eax, 4095
        and     eax, -4096
        mov     ecx, [base]
        and     ecx, -4096
        sub     eax, ecx
        mov     [size], eax
 
        stdcall alloc_kernel_space, eax
        test    eax, eax
        jz      .fail
        push    eax
 
        mov     edi, 0x1000
        mov     ebx, eax
        mov     ecx, [size]
        mov     edx, [base]
        shr     eax, 12
        shr     ecx, 12
        and     edx, -4096
        or      edx, [flags]
@@:
        mov     [page_tabs+eax*4], edx
        invlpg  [ebx]
        inc     eax
        add     ebx, edi
        add     edx, edi
        loop    @B
 
        pop     eax
        mov     edx, [base]
        and     edx, 4095
        add     eax, edx
.fail:
        pop     edi
        pop     ebx
        ret
endp
 
; param
;  eax= page base + page flags
;  ebx= linear address
;  ecx= count
 
align 4
commit_pages:
        test    ecx, ecx
        jz      .fail
 
        push    edi
        push    eax
        push    ecx
        mov     ecx, pg_data.mutex
        call    mutex_lock
        pop     ecx
        pop     eax
 
        mov     edi, ebx
        shr     edi, 12
        lea     edi, [page_tabs+edi*4]
@@:
        stosd
        invlpg  [ebx]
        add     eax, 0x1000
        add     ebx, 0x1000
        loop    @B
 
        pop     edi
 
        mov     ecx, pg_data.mutex
        call    mutex_unlock
.fail:
        ret
 
 
; param
;  eax= base
;  ecx= count
 
align 4
release_pages:
 
        push    ebp
        push    esi
        push    edi
        push    ebx
 
        mov     esi, eax
        mov     edi, eax
 
        shr     esi, 12
        lea     esi, [page_tabs+esi*4]
 
        push    ecx
        mov     ecx, pg_data.mutex
        call    mutex_lock
        pop     ecx
 
        mov     ebp, [pg_data.pages_free]
        mov     ebx, [page_start]
        mov     edx, sys_pgmap
@@:
        xor     eax, eax
        xchg    eax, [esi]
        invlpg  [edi]
 
        test    eax, 1
        jz      .next
 
        shr     eax, 12
        bts     [edx], eax
        cmc
        adc     ebp, 0
        shr     eax, 3
        and     eax, -4
        add     eax, edx
        cmp     eax, ebx
        jae     .next
 
        mov     ebx, eax
.next:
        add     edi, 0x1000
        add     esi, 4
        loop    @B
 
        mov     [pg_data.pages_free], ebp
        mov     ecx, pg_data.mutex
        call    mutex_unlock
 
        pop     ebx
        pop     edi
        pop     esi
        pop     ebp
        ret
 
; param
;  eax= base
;  ecx= count
 
align 4
unmap_pages:
 
        push    edi
 
        mov     edi, eax
        mov     edx, eax
 
        shr     edi, 10
        add     edi, page_tabs
 
        xor     eax, eax
@@:
        stosd
        invlpg  [edx]
        add     edx, 0x1000
        loop    @b
 
        pop     edi
        ret
 
 
align 4
proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
        push    ebx
        mov     ebx, [lin_addr]
        shr     ebx, 22
        mov     eax, [phis_addr]
        and     eax, not 0xFFF
        or      eax, PG_UW        ;+PG_NOCACHE
        mov     dword [master_tab+ebx*4], eax
        mov     eax, [lin_addr]
        shr     eax, 10
        add     eax, page_tabs
        invlpg  [eax]
        pop     ebx
        ret
endp
 
align 4
proc init_LFB
           locals
             pg_count dd ?
           endl
 
        cmp     dword [LFBAddress], -1
        jne     @f
        mov     [BOOT_VAR+BOOT_MTRR], byte 2
; max VGA=640*480*4=1228800 bytes
; + 32*640*4=81920 bytes for mouse pointer
        stdcall alloc_pages, ((1228800+81920)/4096)
 
        push    eax
        call    alloc_page
        stdcall map_page_table, LFB_BASE, eax
        pop     eax
        or      eax, PG_UW
        mov     ebx, LFB_BASE
; max VGA=640*480*4=1228800 bytes
; + 32*640*4=81920 bytes for mouse pointer
        mov     ecx, (1228800+81920)/4096
        call    commit_pages
        mov     [LFBAddress], dword LFB_BASE
        ret
@@:
        test    [SCR_MODE], word 0100000000000000b
        jnz     @f
        mov     [BOOT_VAR+BOOT_MTRR], byte 2
        ret
@@:
        call    init_mtrr
 
        mov     edx, LFB_BASE
        mov     esi, [LFBAddress]
        mov     edi, 0x00C00000
        mov     dword [exp_lfb+4], edx
 
        shr     edi, 12
        mov     [pg_count], edi
        shr     edi, 10
 
        bt      [cpu_caps], CAPS_PSE
        jnc     .map_page_tables
        or      esi, PG_LARGE+PG_UW
        mov     edx, sys_pgdir+(LFB_BASE shr 20)
@@:
        mov     [edx], esi
        add     edx, 4
        add     esi, 0x00400000
        dec     edi
        jnz     @B
 
        bt      [cpu_caps], CAPS_PGE
        jnc     @F
        or      dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
@@:
        mov     dword [LFBAddress], LFB_BASE
        mov     eax, cr3      ;flush TLB
        mov     cr3, eax
        ret
 
.map_page_tables:
 
@@:
        call    alloc_page
        stdcall map_page_table, edx, eax
        add     edx, 0x00400000
        dec     edi
        jnz     @B
 
        mov     eax, [LFBAddress]
        mov     edi, page_tabs + (LFB_BASE shr 10)
        or      eax, PG_UW
        mov     ecx, [pg_count]
        cld
@@:
        stosd
        add     eax, 0x1000
        dec     ecx
        jnz     @B
 
        mov     dword [LFBAddress], LFB_BASE
        mov     eax, cr3      ;flush TLB
        mov     cr3, eax
 
        ret
endp
 
align 4
proc new_mem_resize stdcall, new_size:dword
 
        push    ebx
        push    esi
        push    edi
 
        mov     edx, [current_slot]
        cmp     [edx+APPDATA.heap_base], 0
        jne     .exit
 
        mov     edi, [new_size]
        add     edi, 4095
        and     edi, not 4095
        mov     [new_size], edi
 
 
 
 
 
        mov     esi, [edx+APPDATA.mem_size]
        add     esi, 4095
        and     esi, not 4095
 
        cmp     edi, esi
        ja      .expand
        je      .exit
 
        mov     ebx, edi
        shr     edi, 12
        shr     esi, 12
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
@@:
        mov     eax, [app_page_tabs+edi*4]
        test    eax, 1
        jz      .next
 
        mov     dword [app_page_tabs+edi*4], 0
 
 
 
        invlpg  [ebx]
 
        call    free_page
 
.next:
        inc     edi
        add     ebx, 0x1000
        cmp     edi, esi
        jb      @B
 
 
 
 
 
        mov     ecx, pg_data.mutex
        call    mutex_unlock
 
.update_size:
        mov     edx, [current_slot]
        mov     ebx, [new_size]
        call    update_mem_size
.exit:
        pop     edi
        pop     esi
        pop     ebx
        xor     eax, eax
        ret
 
.expand:
 
        mov     ecx, pg_data.mutex
        call    mutex_lock
 
        xchg    esi, edi
 
        push    esi                   ;new size
        push    edi                   ;old size
 
        add     edi, 0x3FFFFF
        and     edi, not(0x3FFFFF)
        add     esi, 0x3FFFFF
        and     esi, not(0x3FFFFF)
 
        cmp     edi, esi
 
 
 
        jae     .grow
 @@:
        call    alloc_page
        test    eax, eax
        jz      .exit_fail
 
        stdcall map_page_table, edi, eax
 
        push    edi
        shr     edi, 10
        add     edi, page_tabs
        mov     ecx, 1024
        xor     eax, eax
        cld
        rep stosd
        pop     edi
 
        add     edi, 0x00400000
        cmp     edi, esi
        jb      @B
.grow:
 
 
 
        pop     edi                   ;old size
 
 
 
 
 
 
 
 
 
 
 
        pop     ecx                   ;new size
 
        shr     edi, 10
        shr     ecx, 10
        sub     ecx, edi
        shr     ecx, 2                ;pages count
        mov     eax, 2
 
        add     edi, app_page_tabs
 
        rep stosd
 
 
        mov     ecx, pg_data.mutex
        call    mutex_unlock
 
 
 
 
 
 
        jmp     .update_size
 
.exit_fail:
        mov     ecx, pg_data.mutex
        call    mutex_unlock
 
        add     esp, 8
        pop     edi
        pop     esi
        pop     ebx
        xor     eax, eax
        inc     eax
        ret
endp
 
 
align 4
update_mem_size:
; in: edx = slot base
;     ebx = new memory size
; destroys eax,ecx,edx
 
        mov     [APPDATA.mem_size+edx], ebx
;search threads and update
;application memory size infomation
        mov     ecx, [APPDATA.dir_table+edx]
        mov     eax, 2
 
.search_threads:
;eax = current slot
;ebx = new memory size
;ecx = page directory
        cmp     eax, [TASK_COUNT]
        jg      .search_threads_end
        mov     edx, eax
        shl     edx, 5
        cmp     word [CURRENT_TASK+edx+TASKDATA.state], 9  ;if slot empty?
        jz      .search_threads_next
        shl     edx, 3
        cmp     [SLOT_BASE+edx+APPDATA.dir_table], ecx      ;if it is our thread?
        jnz     .search_threads_next
        mov     [SLOT_BASE+edx+APPDATA.mem_size], ebx      ;update memory size
.search_threads_next:
        inc     eax
        jmp     .search_threads
.search_threads_end:
        ret
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
        shr     eax, 12
        mov     eax, [page_tabs+eax*4]
        and     eax, 0xFFFFF000
        ret
 
 
align 4
; Now it is called from core/sys32::exc_c (see stack frame there)
proc page_fault_handler
 
    .err_addr   equ ebp-4
 
        push    ebx               ;save exception number (#PF)
        mov     ebp, esp
        mov     ebx, cr2
        push    ebx               ;that is locals: .err_addr = cr2
        inc     [pg_data.pages_faults]
 
        mov     eax, [pf_err_code]
 
        cmp     ebx, OS_BASE      ;ebx == .err_addr
        jb      .user_space       ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
 
        cmp     ebx, page_tabs
        jb      .kernel_space     ;ñòðàíèöà â ïàìÿòè ÿäðà
 
        cmp     ebx, kernel_tabs
        jb      .alloc;.app_tabs  ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
                                  ;ïðîñòî ñîçäàäèì îäíó
if 0 ;ïîêà ýòî ïðîñòî ëèøíåå
        cmp     ebx, LFB_BASE
        jb      .core_tabs        ;òàáëèöû ñòðàíèö ÿäðà
                                  ;Îøèáêà
  .lfb:
                                  ;îáëàñòü LFB
                                  ;Îøèáêà
        jmp     .fail
end if
.core_tabs:
.fail:  ;simply return to caller
        mov     esp, ebp
        pop     ebx               ;restore exception number (#PF)
        ret
 
;        xchg bx, bx
;        add     esp,12 ;clear in stack: locals(.err_addr) + #PF + ret_to_caller
;        restore_ring3_context
;        iretd
 
.user_space:
        test    eax, PG_MAP
        jnz     .err_access       ;Ñòðàíèöà ïðèñóòñòâóåò
                                  ;Îøèáêà äîñòóïà ?
 
        shr     ebx, 12
        mov     ecx, ebx
        shr     ecx, 10
        mov     edx, [master_tab+ecx*4]
        test    edx, PG_MAP
        jz      .fail             ;òàáëèöà ñòðàíèö íå ñîçäàíà
                                  ;íåâåðíûé àäðåñ â ïðîãðàììå
 
        mov     eax, [page_tabs+ebx*4]
        test    eax, 2
        jz      .fail             ;àäðåñ íå çàðåçåðâèðîâàí äëÿ ;
                                  ;èñïîëüçîâàíèÿ. Îøèáêà
.alloc:
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        stdcall map_page, [.err_addr], eax, PG_UW
 
        mov     edi, [.err_addr]
        and     edi, 0xFFFFF000
        mov     ecx, 1024
        xor     eax, eax
       ;cld     ;caller is duty for this
        rep stosd
.exit:  ;iret with repeat fault instruction
        add     esp, 12;clear in stack: locals(.err_addr) + #PF + ret_to_caller
        restore_ring3_context
        iretd
 
.err_access:
; access denied? this may be a result of copy-on-write protection for DLL
; check list of HDLLs
        and     ebx, not 0xFFF
        mov     eax, [CURRENT_TASK]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
        test    eax, eax
        jz      .fail
        mov     esi, [eax+HDLL.fd]
.scan_hdll:
        cmp     esi, eax
        jz      .fail
        mov     edx, ebx
        sub     edx, [esi+HDLL.base]
        cmp     edx, [esi+HDLL.size]
        jb      .fault_in_hdll
.scan_hdll.next:
        mov     esi, [esi+HDLL.fd]
        jmp     .scan_hdll
.fault_in_hdll:
; allocate new page, map it as rw and copy data
        call    alloc_page
        test    eax, eax
        jz      .fail
        stdcall map_page, ebx, eax, PG_UW
        mov     edi, ebx
        mov     ecx, 1024
        sub     ebx, [esi+HDLL.base]
        mov     esi, [esi+HDLL.parent]
        mov     esi, [esi+DLLDESCR.data]
        add     esi, ebx
        rep movsd
        jmp     .exit
 
.kernel_space:
        test    eax, PG_MAP
        jz      .fail   ;ñòðàíèöà íå ïðèñóòñòâóåò
 
        test    eax, 12 ;U/S (+below)
        jnz     .fail   ;ïðèëîæåíèå îáðàòèëîñü ê ïàìÿòè
                        ;ÿäðà
       ;test    eax, 8
       ;jnz     .fail   ;óñòàíîâëåí çàðåçåðâèðîâàííûé áèò
                        ;â òàáëèöàõ ñòðàíèö. äîáàâëåíî â P4/Xeon
 
;ïîïûòêà çàïèñè â çàùèù¸ííóþ ñòðàíèöó ÿäðà
 
        cmp     ebx, tss._io_map_0
        jb      .fail
 
        cmp     ebx, tss._io_map_0+8192
        jae     .fail
 
; io permission map
; copy-on-write protection
 
        call    alloc_page
        test    eax, eax
        jz      .fail
 
        push    eax
        stdcall map_page, [.err_addr], eax, dword PG_SW
        pop     eax
        mov     edi, [.err_addr]
        and     edi, -4096
        lea     esi, [edi+(not tss._io_map_0)+1]; -tss._io_map_0
 
        mov     ebx, esi
        shr     ebx, 12
        mov     edx, [current_slot]
        or      eax, PG_SW
        mov     [edx+APPDATA.io_map+ebx*4], eax
 
        add     esi, [default_io_map]
        mov     ecx, 4096/4
       ;cld     ;caller is duty for this
        rep movsd
        jmp     .exit
endp
 
; returns number of mapped bytes
proc map_mem stdcall, lin_addr:dword,slot:dword,\
                      ofs:dword,buf_size:dword,req_access:dword
        push    0 ; initialize number of mapped bytes
 
        cmp     [buf_size], 0
        jz      .exit
 
        mov     eax, [slot]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.dir_table]
        and     eax, 0xFFFFF000
 
        stdcall map_page, [ipc_pdir], eax, PG_UW
        mov     ebx, [ofs]
        shr     ebx, 22
        mov     esi, [ipc_pdir]
        mov     edi, [ipc_ptab]
        mov     eax, [esi+ebx*4]
        and     eax, 0xFFFFF000
        jz      .exit
        stdcall map_page, edi, eax, PG_UW
;           inc ebx
;           add edi, 0x1000
;           mov eax, [esi+ebx*4]
;           test eax, eax
;           jz @f
;          and eax, 0xFFFFF000
;           stdcall map_page, edi, eax
 
@@:
        mov     edi, [lin_addr]
        and     edi, 0xFFFFF000
        mov     ecx, [buf_size]
        add     ecx, 4095
        shr     ecx, 12
        inc     ecx
 
        mov     edx, [ofs]
        shr     edx, 12
        and     edx, 0x3FF
        mov     esi, [ipc_ptab]
 
.map:
        stdcall safe_map_page, [slot], [req_access], [ofs]
        jnc     .exit
        add     dword [ebp-4], 4096
        add     [ofs], 4096
        dec     ecx
        jz      .exit
        add     edi, 0x1000
        inc     edx
        cmp     edx, 0x400
        jnz     .map
        inc     ebx
        mov     eax, [ipc_pdir]
        mov     eax, [eax+ebx*4]
        and     eax, 0xFFFFF000
        jz      .exit
        stdcall map_page, esi, eax, PG_UW
        xor     edx, edx
        jmp     .map
 
.exit:
        pop     eax
        ret
endp
 
proc map_memEx stdcall, lin_addr:dword,slot:dword,\
                        ofs:dword,buf_size:dword,req_access:dword
        push    0 ; initialize number of mapped bytes
 
        cmp     [buf_size], 0
        jz      .exit
 
        mov     eax, [slot]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.dir_table]
        and     eax, 0xFFFFF000
 
        stdcall map_page, [proc_mem_pdir], eax, PG_UW
        mov     ebx, [ofs]
        shr     ebx, 22
        mov     esi, [proc_mem_pdir]
        mov     edi, [proc_mem_tab]
        mov     eax, [esi+ebx*4]
        and     eax, 0xFFFFF000
        test    eax, eax
        jz      .exit
        stdcall map_page, edi, eax, PG_UW
 
@@:
        mov     edi, [lin_addr]
        and     edi, 0xFFFFF000
        mov     ecx, [buf_size]
        add     ecx, 4095
        shr     ecx, 12
        inc     ecx
 
        mov     edx, [ofs]
        shr     edx, 12
        and     edx, 0x3FF
        mov     esi, [proc_mem_tab]
 
.map:
        stdcall safe_map_page, [slot], [req_access], [ofs]
        jnc     .exit
        add     dword [ebp-4], 0x1000
        add     edi, 0x1000
        add     [ofs], 0x1000
        inc     edx
        dec     ecx
        jnz     .map
.exit:
        pop     eax
        ret
endp
 
; in: esi+edx*4 = pointer to page table entry
; in: [slot], [req_access], [ofs] on the stack
; in: edi = linear address to map
; out: CF cleared <=> failed
; destroys: only eax
proc safe_map_page stdcall, slot:dword, req_access:dword, ofs:dword
        mov     eax, [esi+edx*4]
        test    al, PG_MAP
        jz      .not_present
        test    al, PG_WRITE
        jz      .resolve_readonly
; normal case: writable page, just map with requested access
.map:
        stdcall map_page, edi, eax, [req_access]
        stc
.fail:
        ret
.not_present:
; check for alloc-on-demand page
        test    al, 2
        jz      .fail
; allocate new page, save it to source page table
        push    ecx
        call    alloc_page
        pop     ecx
        test    eax, eax
        jz      .fail
        or      al, PG_UW
        mov     [esi+edx*4], eax
        jmp     .map
.resolve_readonly:
; readonly page, probably copy-on-write
; check: readonly request of readonly page is ok
        test    [req_access], PG_WRITE
        jz      .map
; find control structure for this page
        pushf
        cli
        cld
        push    ebx ecx
        mov     eax, [slot]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
        test    eax, eax
        jz      .no_hdll
        mov     ecx, [eax+HDLL.fd]
.scan_hdll:
        cmp     ecx, eax
        jz      .no_hdll
        mov     ebx, [ofs]
        and     ebx, not 0xFFF
        sub     ebx, [ecx+HDLL.base]
        cmp     ebx, [ecx+HDLL.size]
        jb      .hdll_found
        mov     ecx, [ecx+HDLL.fd]
        jmp     .scan_hdll
.no_hdll:
        pop     ecx ebx
        popf
        clc
        ret
.hdll_found:
; allocate page, save it in page table, map it, copy contents from base
        mov     eax, [ecx+HDLL.parent]
        add     ebx, [eax+DLLDESCR.data]
        call    alloc_page
        test    eax, eax
        jz      .no_hdll
        or      al, PG_UW
        mov     [esi+edx*4], eax
        stdcall map_page, edi, eax, [req_access]
        push    esi edi
        mov     esi, ebx
        mov     ecx, 4096/4
        rep movsd
        pop     edi esi
        pop     ecx ebx
        popf
        stc
        ret
endp
 
sys_IPC:
;input:
;  ebx=1 - set ipc buffer area
;    ecx=address of buffer
;    edx=size of buffer
;  eax=2 - send message
;    ebx=PID
;    ecx=address of message
;    edx=size of message
 
        dec     ebx
        jnz     @f
 
        mov     eax, [current_slot]
        pushf
        cli
        mov     [eax+APPDATA.ipc_start], ecx    ;set fields in extended information area
        mov     [eax+APPDATA.ipc_size], edx
 
        add     edx, ecx
        add     edx, 4095
        and     edx, not 4095
 
.touch:
        mov     eax, [ecx]
        add     ecx, 0x1000
        cmp     ecx, edx
        jb      .touch
 
        popf
        mov     [esp+32], ebx   ;ebx=0
        ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;2
@@:
        dec     ebx
        jnz     @f
 
        stdcall sys_ipc_send, ecx, edx, esi
        mov     [esp+32], eax
        ret
@@:
        or      eax, -1
        mov     [esp+32], eax
        ret
 
;align 4
;proc set_ipc_buff
 
;           mov  eax,[current_slot]
;           pushf
;           cli
;           mov  [eax+APPDATA.ipc_start],ebx     ;set fields in extended information area
;           mov  [eax+APPDATA.ipc_size],ecx
;
;           add ecx, ebx
;           add ecx, 4095
;           and ecx, not 4095
;
;.touch:    mov eax, [ebx]
;           add ebx, 0x1000
;           cmp ebx, ecx
;           jb  .touch
;
;           popf
;           xor eax, eax
;           ret
;endp
 
proc sys_ipc_send stdcall, PID:dword, msg_addr:dword, msg_size:dword
           locals
             dst_slot   dd ?
             dst_offset dd ?
             buf_size   dd ?
             used_buf   dd ?
           endl
 
        pushf
        cli
 
        mov     eax, [PID]
        call    pid_to_slot
        test    eax, eax
        jz      .no_pid
 
        mov     [dst_slot], eax
        shl     eax, 8
        mov     edi, [eax+SLOT_BASE+0xa0] ;is ipc area defined?
        test    edi, edi
        jz      .no_ipc_area
 
        mov     ebx, edi
        and     ebx, 0xFFF
        mov     [dst_offset], ebx
 
        mov     esi, [eax+SLOT_BASE+0xa4]
        mov     [buf_size], esi
 
        mov     ecx, [ipc_tmp]
        cmp     esi, 0x40000-0x1000; size of [ipc_tmp] minus one page
        jbe     @f
        push    esi edi
        add     esi, 0x1000
        stdcall alloc_kernel_space, esi
        mov     ecx, eax
        pop     edi esi
@@:
        mov     [used_buf], ecx
        stdcall map_mem, ecx, [dst_slot], \
                edi, esi, PG_SW
 
        mov     edi, [dst_offset]
        add     edi, [used_buf]
        cmp     dword [edi], 0
        jnz     .ipc_blocked          ;if dword [buffer]<>0 - ipc blocked now
 
        mov     edx, dword [edi+4]
        lea     ebx, [edx+8]
        add     ebx, [msg_size]
        cmp     ebx, [buf_size]
        ja      .buffer_overflow       ;esi<0 - not enough memory in buffer
 
        mov     dword [edi+4], ebx
        mov     eax, [TASK_BASE]
        mov     eax, [eax+0x04]        ;eax - our PID
        add     edi, edx
        mov     [edi], eax
        mov     ecx, [msg_size]
 
        mov     [edi+4], ecx
        add     edi, 8
        mov     esi, [msg_addr]
       ;    add esi, new_app_base
        cld
        rep movsb
 
        mov     ebx, [ipc_tmp]
        mov     edx, ebx
        shr     ebx, 12
        xor     eax, eax
        mov     [page_tabs+ebx*4], eax
        invlpg  [edx]
 
        mov     ebx, [ipc_pdir]
        mov     edx, ebx
        shr     ebx, 12
        xor     eax, eax
        mov     [page_tabs+ebx*4], eax
        invlpg  [edx]
 
        mov     ebx, [ipc_ptab]
        mov     edx, ebx
        shr     ebx, 12
        xor     eax, eax
        mov     [page_tabs+ebx*4], eax
        invlpg  [edx]
 
        mov     eax, [dst_slot]
        shl     eax, 8
        or      [eax+SLOT_BASE+0xA8], dword 0x40
        cmp     dword [check_idle_semaphore], 20
        jge     .ipc_no_cis
 
        mov     dword [check_idle_semaphore], 5
.ipc_no_cis:
        push    0
        jmp     .ret
.no_pid:
        popf
        mov     eax, 4
        ret
.no_ipc_area:
        popf
        xor     eax, eax
        inc     eax
        ret
.ipc_blocked:
        push    2
        jmp     .ret
.buffer_overflow:
        push    3
.ret:
        mov     eax, [used_buf]
        cmp     eax, [ipc_tmp]
        jz      @f
        stdcall free_kernel_space, eax
@@:
        pop     eax
        popf
        ret
endp
 
align 4
sysfn_meminfo:
 
        ;   add ecx, new_app_base
        cmp     ecx, OS_BASE
        jae     .fail
 
        mov     eax, [pg_data.pages_count]
        mov     [ecx], eax
        shl     eax, 12
        mov     [esp+32], eax
        mov     eax, [pg_data.pages_free]
        mov     [ecx+4], eax
        mov     eax, [pg_data.pages_faults]
        mov     [ecx+8], eax
        mov     eax, [heap_size]
        mov     [ecx+12], eax
        mov     eax, [heap_free]
        mov     [ecx+16], eax
        mov     eax, [heap_blocks]
        mov     [ecx+20], eax
        mov     eax, [free_blocks]
        mov     [ecx+24], eax
        ret
.fail:
        or      dword [esp+32], -1
        ret
 
align 4
f68:
        cmp     ebx, 4
        jbe     sys_sheduler
 
        cmp     ebx, 11
        jb      .fail
 
        cmp     ebx, 25
        ja      .fail
 
        jmp     dword [f68call+ebx*4-11*4]
.11:
        call    init_heap
        mov     [esp+32], eax
        ret
.12:
        stdcall user_alloc, ecx
        mov     [esp+32], eax
        ret
.13:
        stdcall user_free, ecx
        mov     [esp+32], eax
        ret
.14:
        cmp     ecx, OS_BASE
        jae     .fail
        mov     edi, ecx
        call    get_event_ex
        mov     [esp+32], eax
        ret
.16:
        test    ecx, ecx
        jz      .fail
        cmp     ecx, OS_BASE
        jae     .fail
        stdcall get_service, ecx
        mov     [esp+32], eax
        ret
.17:
        call    srv_handlerEx   ;ecx
        mov     [esp+32], eax
        ret
.19:
        cmp     ecx, OS_BASE
        jae     .fail
        stdcall load_library, ecx
        mov     [esp+32], eax
        ret
.20:
        mov     eax, edx
        mov     ebx, ecx
        call    user_realloc            ;in: eax = pointer, ebx = new size
        mov     [esp+32], eax
        ret
.21:
        cmp     ecx, OS_BASE
        jae     .fail
 
        cmp     edx, OS_BASE
        jae     .fail
 
        mov     edi, edx
        stdcall load_PE, ecx
        mov     esi, eax
        test    eax, eax
        jz      @F
 
        push    edi
        push    DRV_ENTRY
        call    eax
        add     esp, 8
        test    eax, eax
        jz      @F
 
        mov     [eax+SRV.entry], esi
 
@@:
        mov     [esp+32], eax
        ret
.22:
        cmp     ecx, OS_BASE
        jae     .fail
 
        stdcall shmem_open, ecx, edx, esi
        mov     [esp+24], edx
        mov     [esp+32], eax
        ret
 
.23:
        cmp     ecx, OS_BASE
        jae     .fail
 
        stdcall shmem_close, ecx
        mov     [esp+32], eax
        ret
.24:
        mov     eax, [current_slot]
        xchg    ecx, [eax+APPDATA.exc_handler]
        xchg    edx, [eax+APPDATA.except_mask]
        mov     [esp+32], ecx ; reg_eax+8
        mov     [esp+20], edx ; reg_ebx+8
        ret
.25:
        cmp     ecx, 32
        jae     .fail
        mov     eax, [current_slot]
        btr     [eax+APPDATA.except_mask], ecx
        setc    byte[esp+32]
        jecxz   @f
        bts     [eax+APPDATA.except_mask], ecx
@@:
        ret
 
.26:
        stdcall user_unmap, ecx, edx, esi
        mov     [esp+32], eax
        ret
 
.fail:
        xor     eax, eax
        mov     [esp+32], eax
        ret
 
 
align 4
f68call:   ; keep this table closer to main code
 
           dd f68.11   ; init_heap
           dd f68.12   ; user_alloc
           dd f68.13   ; user_free
           dd f68.14   ; get_event_ex
           dd f68.fail ; moved to f68.24
           dd f68.16   ; get_service
           dd f68.17   ; call_service
           dd f68.fail ; moved to f68.25
           dd f68.19   ; load_dll
           dd f68.20   ; user_realloc
           dd f68.21   ; load_driver
           dd f68.22   ; shmem_open
           dd f68.23   ; shmem_close
           dd f68.24   ; set exception handler
           dd f68.25   ; unmask exception
           dd f68.26   ; user_unmap
 
 
align 4
proc load_pe_driver stdcall, file:dword
 
        stdcall load_PE, [file]
        test    eax, eax
        jz      .fail
 
        mov     esi, eax
        stdcall eax, DRV_ENTRY
        test    eax, eax
        jz      .fail
 
        mov     [eax+SRV.entry], esi
        ret
 
.fail:
        xor     eax, eax
        ret
endp
 
 
align 4
proc init_mtrr
 
        cmp     [BOOT_VAR+BOOT_MTRR], byte 2
        je      .exit
 
        bt      [cpu_caps], CAPS_MTRR
        jnc     .exit
 
        mov     eax, cr0
        or      eax, 0x60000000 ;disable caching
        mov     cr0, eax
        wbinvd                  ;invalidate cache
 
        mov     ecx, 0x2FF
        rdmsr                   ;
; has BIOS already initialized MTRRs?
        test    ah, 8
        jnz     .skip_init
; rarely needed, so mainly placeholder
; main memory - cached
        push    eax
 
        mov     eax, [MEM_AMOUNT]
; round eax up to next power of 2
        dec     eax
        bsr     ecx, eax
        mov     ebx, 2
        shl     ebx, cl
        dec     ebx
; base of memory range = 0, type of memory range = MEM_WB
        xor     edx, edx
        mov     eax, MEM_WB
        mov     ecx, 0x200
        wrmsr
; mask of memory range = 0xFFFFFFFFF - (size - 1), ebx = size - 1
        mov     eax, 0xFFFFFFFF
        mov     edx, 0x0000000F
        sub     eax, ebx
        sbb     edx, 0
        or      eax, 0x800
        inc     ecx
        wrmsr
; clear unused MTRRs
        xor     eax, eax
        xor     edx, edx
@@:
        wrmsr
        inc     ecx
        cmp     ecx, 0x210
        jb      @b
; enable MTRRs
        pop     eax
        or      ah, 8
        and     al, 0xF0; default memtype = UC
        mov     ecx, 0x2FF
        wrmsr
.skip_init:
        stdcall set_mtrr, [LFBAddress], [LFBSize], MEM_WC
 
        wbinvd                  ;again invalidate
 
        mov     eax, cr0
        and     eax, not 0x60000000
        mov     cr0, eax        ; enable caching
.exit:
        ret
endp
 
align 4
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword
; find unused register
        mov     ecx, 0x201
@@:
        rdmsr
        dec     ecx
        test    ah, 8
        jz      .found
        rdmsr
        mov     al, 0; clear memory type field
        cmp     eax, [base]
        jz      .ret
        add     ecx, 3
        cmp     ecx, 0x210
        jb      @b
; no free registers, ignore the call
.ret:
        ret
.found:
; found, write values
        xor     edx, edx
        mov     eax, [base]
        or      eax, [mem_type]
        wrmsr
 
        mov     ebx, [size]
        dec     ebx
        mov     eax, 0xFFFFFFFF
        mov     edx, 0x0000000F
        sub     eax, ebx
        sbb     edx, 0
        or      eax, 0x800
        inc     ecx
        wrmsr
        ret
endp
 
align 4
proc stall stdcall, delay:dword
        push    ecx
        push    edx
        push    ebx
        push    eax
 
        mov     eax, [delay]
        mul     [stall_mcs]
        mov     ebx, eax      ;low
        mov     ecx, edx      ;high
        rdtsc
        add     ebx, eax
        adc     ecx, edx
@@:
        rdtsc
        sub     eax, ebx
        sbb     edx, ecx
        jb      @B
 
        pop     eax
        pop     ebx
        pop     edx
        pop     ecx
        ret
endp
 
align 4
proc create_ring_buffer stdcall, size:dword, flags:dword
           locals
             buf_ptr  dd ?
           endl
 
        mov     eax, [size]
        test    eax, eax
        jz      .fail
 
        add     eax, eax
        stdcall alloc_kernel_space, eax
        test    eax, eax
        jz      .fail
 
        push    ebx
 
        mov     [buf_ptr], eax
 
        mov     ebx, [size]
        shr     ebx, 12
        push    ebx
 
        stdcall alloc_pages, ebx
        pop     ecx
 
        test    eax, eax
        jz      .mm_fail
 
        push    edi
 
        or      eax, [flags]
        mov     edi, [buf_ptr]
        mov     ebx, [buf_ptr]
        mov     edx, ecx
        shl     edx, 2
        shr     edi, 10
@@:
        mov     [page_tabs+edi], eax
        mov     [page_tabs+edi+edx], eax
        invlpg  [ebx]
        invlpg  [ebx+0x10000]
        add     eax, 0x1000
        add     ebx, 0x1000
        add     edi, 4
        dec     ecx
        jnz     @B
 
        mov     eax, [buf_ptr]
        pop     edi
        pop     ebx
        ret
.mm_fail:
        stdcall free_kernel_space, [buf_ptr]
        xor     eax, eax
        pop     ebx
.fail:
        ret
endp
 
 
align 4
proc print_mem
        mov     edi, BOOT_VAR + 0x9104
        mov     ecx, [edi-4]
        test    ecx, ecx
        jz     .done
 
@@:
        mov eax, [edi]
        mov edx, [edi+4]
        add eax, [edi+8]
        adc edx, [edi+12]
 
        DEBUGF  1, "K : E820 %x%x - %x%x type %d\n", \
                    [edi+4], [edi],\
                    edx, eax, [edi+16]
        add     edi, 20
        dec     ecx
        jnz     @b
.done:
        ret
endp

Rev 2467	Rev 2987
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 2467 $	8	$Revision: 2987 $
9		9
10		10
11	align 4	11	align 4
12	proc alloc_page	12	proc alloc_page
13		13
14	pushfd	14	pushfd
15	cli	15	cli
16	push ebx	16	push ebx
17	;//-	17	;//-
18	cmp [pg_data.pages_free], 1	18	cmp [pg_data.pages_free], 1
19	jle .out_of_memory	19	jle .out_of_memory
20	;//-	20	;//-
21		21
22	mov ebx, [page_start]	22	mov ebx, [page_start]
23	mov ecx, [page_end]	23	mov ecx, [page_end]
24	.l1:	24	.l1:
25	bsf eax, [ebx];	25	bsf eax, [ebx];
26	jnz .found	26	jnz .found
27	add ebx, 4	27	add ebx, 4
28	cmp ebx, ecx	28	cmp ebx, ecx
29	jb .l1	29	jb .l1
30	pop ebx	30	pop ebx
31	popfd	31	popfd
32	xor eax, eax	32	xor eax, eax
33	ret	33	ret
34	.found:	34	.found:
35	;//-	35	;//-
36	dec [pg_data.pages_free]	36	dec [pg_data.pages_free]
37	jz .out_of_memory	37	jz .out_of_memory
38	;//-	38	;//-
39	btr [ebx], eax	39	btr [ebx], eax
40	mov [page_start], ebx	40	mov [page_start], ebx
41	sub ebx, sys_pgmap	41	sub ebx, sys_pgmap
42	lea eax, [eax+ebx*8]	42	lea eax, [eax+ebx*8]
43	shl eax, 12	43	shl eax, 12
44	;//- dec [pg_data.pages_free]	44	;//- dec [pg_data.pages_free]
45	pop ebx	45	pop ebx
46	popfd	46	popfd
47	ret	47	ret
48	;//-	48	;//-
49	.out_of_memory:	49	.out_of_memory:
50	mov [pg_data.pages_free], 1	50	mov [pg_data.pages_free], 1
51	xor eax, eax	51	xor eax, eax
52	pop ebx	52	pop ebx
53	popfd	53	popfd
54	ret	54	ret
55	;//-	55	;//-
56	endp	56	endp
57		57
58	align 4	58	align 4
59	proc alloc_pages stdcall, count:dword	59	proc alloc_pages stdcall, count:dword
60	pushfd	60	pushfd
61	push ebx	61	push ebx
62	push edi	62	push edi
63	cli	63	cli
64	mov eax, [count]	64	mov eax, [count]
65	add eax, 7	65	add eax, 7
66	shr eax, 3	66	shr eax, 3
67	mov [count], eax	67	mov [count], eax
68	;//-	68	;//-
69	mov ebx, [pg_data.pages_free]	69	mov ebx, [pg_data.pages_free]
70	sub ebx, 9	70	sub ebx, 9
71	js .out_of_memory	71	js .out_of_memory
72	shr ebx, 3	72	shr ebx, 3
73	cmp eax, ebx	73	cmp eax, ebx
74	jg .out_of_memory	74	jg .out_of_memory
75	;//-	75	;//-
76	mov ecx, [page_start]	76	mov ecx, [page_start]
77	mov ebx, [page_end]	77	mov ebx, [page_end]
78	.find:	78	.find:
79	mov edx, [count]	79	mov edx, [count]
80	mov edi, ecx	80	mov edi, ecx
81	.match:	81	.match:
82	cmp byte [ecx], 0xFF	82	cmp byte [ecx], 0xFF
83	jne .next	83	jne .next
84	dec edx	84	dec edx
85	jz .ok	85	jz .ok
86	inc ecx	86	inc ecx
87	cmp ecx, ebx	87	cmp ecx, ebx
88	jb .match	88	jb .match
89	.out_of_memory:	89	.out_of_memory:
90	.fail:	90	.fail:
91	xor eax, eax	91	xor eax, eax
92	pop edi	92	pop edi
93	pop ebx	93	pop ebx
94	popfd	94	popfd
95	ret	95	ret
96	.next:	96	.next:
97	inc ecx	97	inc ecx
98	cmp ecx, ebx	98	cmp ecx, ebx
99	jb .find	99	jb .find
100	pop edi	100	pop edi
101	pop ebx	101	pop ebx
102	popfd	102	popfd
103	xor eax, eax	103	xor eax, eax
104	ret	104	ret
105	.ok:	105	.ok:
106	sub ecx, edi	106	sub ecx, edi
107	inc ecx	107	inc ecx
108	push esi	108	push esi
109	mov esi, edi	109	mov esi, edi
110	xor eax, eax	110	xor eax, eax
111	rep stosb	111	rep stosb
112	sub esi, sys_pgmap	112	sub esi, sys_pgmap
113	shl esi, 3+12	113	shl esi, 3+12
114	mov eax, esi	114	mov eax, esi
115	mov ebx, [count]	115	mov ebx, [count]
116	shl ebx, 3	116	shl ebx, 3
117	sub [pg_data.pages_free], ebx	117	sub [pg_data.pages_free], ebx
118	pop esi	118	pop esi
119	pop edi	119	pop edi
120	pop ebx	120	pop ebx
121	popfd	121	popfd
122	ret	122	ret
123	endp	123	endp
124		124
125	align 4	125	align 4
126	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword	126	proc map_page stdcall,lin_addr:dword,phis_addr:dword,flags:dword
127	push ebx	127	push ebx
128	mov eax, [phis_addr]	128	mov eax, [phis_addr]
129	and eax, not 0xFFF	129	and eax, not 0xFFF
130	or eax, [flags]	130	or eax, [flags]
131	mov ebx, [lin_addr]	131	mov ebx, [lin_addr]
132	shr ebx, 12	132	shr ebx, 12
133	mov [page_tabs+ebx*4], eax	133	mov [page_tabs+ebx*4], eax
134	mov eax, [lin_addr]	134	mov eax, [lin_addr]
135	invlpg [eax]	135	invlpg [eax]
136	pop ebx	136	pop ebx
137	ret	137	ret
138	endp	138	endp
139		139
140	align 4	140	align 4
141	map_space: ;not implemented	141	map_space: ;not implemented
142		142
143		143
144	ret	144	ret
145		145
146		146
147	align 4	147	align 4
148	proc free_page	148	proc free_page
149	;arg: eax page address	149	;arg: eax page address
150	pushfd	150	pushfd
151	cli	151	cli
152	shr eax, 12 ;page index	152	shr eax, 12 ;page index
153	bts dword [sys_pgmap], eax ;that's all!	153	bts dword [sys_pgmap], eax ;that's all!
154	cmc	154	cmc
155	adc [pg_data.pages_free], 0	155	adc [pg_data.pages_free], 0
156	shr eax, 3	156	shr eax, 3
157	and eax, not 3 ;dword offset from page_map	157	and eax, not 3 ;dword offset from page_map
158	add eax, sys_pgmap	158	add eax, sys_pgmap
159	cmp [page_start], eax	159	cmp [page_start], eax
160	ja @f	160	ja @f
161	popfd	161	popfd
162	ret	162	ret
163	@@:	163	@@:
164	mov [page_start], eax	164	mov [page_start], eax
165	popfd	165	popfd
166	ret	166	ret
167	endp	167	endp
168		168
169	align 4	169	align 4
170	proc map_io_mem stdcall, base:dword, size:dword, flags:dword	170	proc map_io_mem stdcall, base:dword, size:dword, flags:dword
171		171
172	push ebx	172	push ebx
173	push edi	173	push edi
174	mov eax, [size]	174	mov eax, [size]
175	add eax, [base]	175	add eax, [base]
176	add eax, 4095	176	add eax, 4095
177	and eax, -4096	177	and eax, -4096
178	mov ecx, [base]	178	mov ecx, [base]
179	and ecx, -4096	179	and ecx, -4096
180	sub eax, ecx	180	sub eax, ecx
181	mov [size], eax	181	mov [size], eax
182		182
183	stdcall alloc_kernel_space, eax	183	stdcall alloc_kernel_space, eax
184	test eax, eax	184	test eax, eax
185	jz .fail	185	jz .fail
186	push eax	186	push eax
187		187
188	mov edi, 0x1000	188	mov edi, 0x1000
189	mov ebx, eax	189	mov ebx, eax
190	mov ecx, [size]	190	mov ecx, [size]
191	mov edx, [base]	191	mov edx, [base]
192	shr eax, 12	192	shr eax, 12
193	shr ecx, 12	193	shr ecx, 12
194	and edx, -4096	194	and edx, -4096
195	or edx, [flags]	195	or edx, [flags]
196	@@:	196	@@:
197	mov [page_tabs+eax*4], edx	197	mov [page_tabs+eax*4], edx
198	invlpg [ebx]	198	invlpg [ebx]
199	inc eax	199	inc eax
200	add ebx, edi	200	add ebx, edi
201	add edx, edi	201	add edx, edi
202	loop @B	202	loop @B
203		203
204	pop eax	204	pop eax
205	mov edx, [base]	205	mov edx, [base]
206	and edx, 4095	206	and edx, 4095
207	add eax, edx	207	add eax, edx
208	.fail:	208	.fail:
209	pop edi	209	pop edi
210	pop ebx	210	pop ebx
211	ret	211	ret
212	endp	212	endp
213		213
214	; param	214	; param
215	; eax= page base + page flags	215	; eax= page base + page flags
216	; ebx= linear address	216	; ebx= linear address
217	; ecx= count	217	; ecx= count
218		218
219	align 4	219	align 4
220	commit_pages:	220	commit_pages:
221	test ecx, ecx	221	test ecx, ecx
222	jz .fail	222	jz .fail
223		223
224	push edi	224	push edi
225	push eax	225	push eax
226	push ecx	226	push ecx
227	mov ecx, pg_data.mutex	227	mov ecx, pg_data.mutex
228	call mutex_lock	228	call mutex_lock
229	pop ecx	229	pop ecx
230	pop eax	230	pop eax
231		231
232	mov edi, ebx	232	mov edi, ebx
233	shr edi, 12	233	shr edi, 12
234	lea edi, [page_tabs+edi*4]	234	lea edi, [page_tabs+edi*4]
235	@@:	235	@@:
236	stosd	236	stosd
237	invlpg [ebx]	237	invlpg [ebx]
238	add eax, 0x1000	238	add eax, 0x1000
239	add ebx, 0x1000	239	add ebx, 0x1000
240	loop @B	240	loop @B
241		241
242	pop edi	242	pop edi
243		243
244	mov ecx, pg_data.mutex	244	mov ecx, pg_data.mutex
245	call mutex_unlock	245	call mutex_unlock
246	.fail:	246	.fail:
247	ret	247	ret
248		248
249		249
250	; param	250	; param
251	; eax= base	251	; eax= base
252	; ecx= count	252	; ecx= count
253		253
254	align 4	254	align 4
255	release_pages:	255	release_pages:
256		256
257	push ebp	257	push ebp
258	push esi	258	push esi
259	push edi	259	push edi
260	push ebx	260	push ebx
261		261
262	mov esi, eax	262	mov esi, eax
263	mov edi, eax	263	mov edi, eax
264		264
265	shr esi, 12	265	shr esi, 12
266	lea esi, [page_tabs+esi*4]	266	lea esi, [page_tabs+esi*4]
267		267
268	push ecx	268	push ecx
269	mov ecx, pg_data.mutex	269	mov ecx, pg_data.mutex
270	call mutex_lock	270	call mutex_lock
271	pop ecx	271	pop ecx
272		272
273	mov ebp, [pg_data.pages_free]	273	mov ebp, [pg_data.pages_free]
274	mov ebx, [page_start]	274	mov ebx, [page_start]
275	mov edx, sys_pgmap	275	mov edx, sys_pgmap
276	@@:	276	@@:
277	xor eax, eax	277	xor eax, eax
278	xchg eax, [esi]	278	xchg eax, [esi]
279	invlpg [edi]	279	invlpg [edi]
280		280
281	test eax, 1	281	test eax, 1
282	jz .next	282	jz .next
283		283
284	shr eax, 12	284	shr eax, 12
285	bts [edx], eax	285	bts [edx], eax
286	cmc	286	cmc
287	adc ebp, 0	287	adc ebp, 0
288	shr eax, 3	288	shr eax, 3
289	and eax, -4	289	and eax, -4
290	add eax, edx	290	add eax, edx
291	cmp eax, ebx	291	cmp eax, ebx
292	jae .next	292	jae .next
293		293
294	mov ebx, eax	294	mov ebx, eax
295	.next:	295	.next:
296	add edi, 0x1000	296	add edi, 0x1000
297	add esi, 4	297	add esi, 4
298	loop @B	298	loop @B
299		299
300	mov [pg_data.pages_free], ebp	300	mov [pg_data.pages_free], ebp
301	mov ecx, pg_data.mutex	301	mov ecx, pg_data.mutex
302	call mutex_unlock	302	call mutex_unlock
303		303
304	pop ebx	304	pop ebx
305	pop edi	305	pop edi
306	pop esi	306	pop esi
307	pop ebp	307	pop ebp
308	ret	308	ret
309		309
310	; param	310	; param
311	; eax= base	311	; eax= base
312	; ecx= count	312	; ecx= count
313		313
314	align 4	314	align 4
315	unmap_pages:	315	unmap_pages:
316		316
317	push edi	317	push edi
318		318
319	mov edi, eax	319	mov edi, eax
320	mov edx, eax	320	mov edx, eax
321		321
322	shr edi, 10	322	shr edi, 10
323	add edi, page_tabs	323	add edi, page_tabs
324		324
325	xor eax, eax	325	xor eax, eax
326	@@:	326	@@:
327	stosd	327	stosd
328	invlpg [edx]	328	invlpg [edx]
329	add edx, 0x1000	329	add edx, 0x1000
330	loop @b	330	loop @b
331		331
332	pop edi	332	pop edi
333	ret	333	ret
334		334
335		335
336	align 4	336	align 4
337	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword	337	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
338	push ebx	338	push ebx
339	mov ebx, [lin_addr]	339	mov ebx, [lin_addr]
340	shr ebx, 22	340	shr ebx, 22
341	mov eax, [phis_addr]	341	mov eax, [phis_addr]
342	and eax, not 0xFFF	342	and eax, not 0xFFF
343	or eax, PG_UW ;+PG_NOCACHE	343	or eax, PG_UW ;+PG_NOCACHE
344	mov dword [master_tab+ebx*4], eax	344	mov dword [master_tab+ebx*4], eax
345	mov eax, [lin_addr]	345	mov eax, [lin_addr]
346	shr eax, 10	346	shr eax, 10
347	add eax, page_tabs	347	add eax, page_tabs
348	invlpg [eax]	348	invlpg [eax]
349	pop ebx	349	pop ebx
350	ret	350	ret
351	endp	351	endp
352		352
353	align 4	353	align 4
354	proc init_LFB	354	proc init_LFB
355	locals	355	locals
356	pg_count dd ?	356	pg_count dd ?
357	endl	357	endl
358		358
359	cmp dword [LFBAddress], -1	359	cmp dword [LFBAddress], -1
360	jne @f	360	jne @f
361	mov [BOOT_VAR+BOOT_MTRR], byte 2	361	mov [BOOT_VAR+BOOT_MTRR], byte 2
362	; max VGA=6404804=1228800 bytes	362	; max VGA=6404804=1228800 bytes
363	; + 326404=81920 bytes for mouse pointer	363	; + 326404=81920 bytes for mouse pointer
364	stdcall alloc_pages, ((1228800+81920)/4096)	364	stdcall alloc_pages, ((1228800+81920)/4096)
365		365
366	push eax	366	push eax
367	call alloc_page	367	call alloc_page
368	stdcall map_page_table, LFB_BASE, eax	368	stdcall map_page_table, LFB_BASE, eax
369	pop eax	369	pop eax
370	or eax, PG_UW	370	or eax, PG_UW
371	mov ebx, LFB_BASE	371	mov ebx, LFB_BASE
372	; max VGA=6404804=1228800 bytes	372	; max VGA=6404804=1228800 bytes
373	; + 326404=81920 bytes for mouse pointer	373	; + 326404=81920 bytes for mouse pointer
374	mov ecx, (1228800+81920)/4096	374	mov ecx, (1228800+81920)/4096
375	call commit_pages	375	call commit_pages
376	mov [LFBAddress], dword LFB_BASE	376	mov [LFBAddress], dword LFB_BASE
377	ret	377	ret
378	@@:	378	@@:
379	test [SCR_MODE], word 0100000000000000b	379	test [SCR_MODE], word 0100000000000000b
380	jnz @f	380	jnz @f
381	mov [BOOT_VAR+BOOT_MTRR], byte 2	381	mov [BOOT_VAR+BOOT_MTRR], byte 2
382	ret	382	ret
383	@@:	383	@@:
384	call init_mtrr	384	call init_mtrr
385		385
386	mov edx, LFB_BASE	386	mov edx, LFB_BASE
387	mov esi, [LFBAddress]	387	mov esi, [LFBAddress]
388	mov edi, 0x00C00000	388	mov edi, 0x00C00000
389	mov dword [exp_lfb+4], edx	389	mov dword [exp_lfb+4], edx
390		390
391	shr edi, 12	391	shr edi, 12
392	mov [pg_count], edi	392	mov [pg_count], edi
393	shr edi, 10	393	shr edi, 10
394		394
395	bt [cpu_caps], CAPS_PSE	395	bt [cpu_caps], CAPS_PSE
396	jnc .map_page_tables	396	jnc .map_page_tables
397	or esi, PG_LARGE+PG_UW	397	or esi, PG_LARGE+PG_UW
398	mov edx, sys_pgdir+(LFB_BASE shr 20)	398	mov edx, sys_pgdir+(LFB_BASE shr 20)
399	@@:	399	@@:
400	mov [edx], esi	400	mov [edx], esi
401	add edx, 4	401	add edx, 4
402	add esi, 0x00400000	402	add esi, 0x00400000
403	dec edi	403	dec edi
404	jnz @B	404	jnz @B
405		405
406	bt [cpu_caps], CAPS_PGE	406	bt [cpu_caps], CAPS_PGE
407	jnc @F	407	jnc @F
408	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL	408	or dword [sys_pgdir+(LFB_BASE shr 20)], PG_GLOBAL
409	@@:	409	@@:
410	mov dword [LFBAddress], LFB_BASE	410	mov dword [LFBAddress], LFB_BASE
411	mov eax, cr3 ;flush TLB	411	mov eax, cr3 ;flush TLB
412	mov cr3, eax	412	mov cr3, eax
413	ret	413	ret
414		414
415	.map_page_tables:	415	.map_page_tables:
416		416
417	@@:	417	@@:
418	call alloc_page	418	call alloc_page
419	stdcall map_page_table, edx, eax	419	stdcall map_page_table, edx, eax
420	add edx, 0x00400000	420	add edx, 0x00400000
421	dec edi	421	dec edi
422	jnz @B	422	jnz @B
423		423
424	mov eax, [LFBAddress]	424	mov eax, [LFBAddress]
425	mov edi, page_tabs + (LFB_BASE shr 10)	425	mov edi, page_tabs + (LFB_BASE shr 10)
426	or eax, PG_UW	426	or eax, PG_UW
427	mov ecx, [pg_count]	427	mov ecx, [pg_count]
428	cld	428	cld
429	@@:	429	@@:
430	stosd	430	stosd
431	add eax, 0x1000	431	add eax, 0x1000
432	dec ecx	432	dec ecx
433	jnz @B	433	jnz @B
434		434
435	mov dword [LFBAddress], LFB_BASE	435	mov dword [LFBAddress], LFB_BASE
436	mov eax, cr3 ;flush TLB	436	mov eax, cr3 ;flush TLB
437	mov cr3, eax	437	mov cr3, eax
438		438
439	ret	439	ret
440	endp	440	endp
441		441
442	align 4	442	align 4
443	proc new_mem_resize stdcall, new_size:dword	443	proc new_mem_resize stdcall, new_size:dword
-		444
-		445	push ebx
-		446	push esi
-		447	push edi
444		448
-		449	mov edx, [current_slot]
445	mov ecx, pg_data.mutex	450	cmp [edx+APPDATA.heap_base], 0
446	call mutex_lock	451	jne .exit
447		452
448	mov edi, [new_size]	453	mov edi, [new_size]
449	add edi, 4095	454	add edi, 4095
450	and edi, not 4095	455	and edi, not 4095
451	mov [new_size], edi	456	mov [new_size], edi
452		-
453	mov edx, [current_slot]	-
454	cmp [edx+APPDATA.heap_base], 0	-
455	jne .exit	-
456		457
457	mov esi, [edx+APPDATA.mem_size]	458	mov esi, [edx+APPDATA.mem_size]
458	add esi, 4095	459	add esi, 4095
459	and esi, not 4095	460	and esi, not 4095
460		461
461	cmp edi, esi	462	cmp edi, esi
462	jae .expand	463	ja .expand
-		464	je .exit
-		465
463		466	mov ebx, edi
464	shr edi, 12	467	shr edi, 12
-		468	shr esi, 12
-		469
-		470	mov ecx, pg_data.mutex
465	shr esi, 12	471	call mutex_lock
466	@@:	472	@@:
467	mov eax, [app_page_tabs+edi*4]	473	mov eax, [app_page_tabs+edi*4]
468	test eax, 1	474	test eax, 1
469	jz .next	475	jz .next
-		476
470	mov dword [app_page_tabs+edi*4], 2	477	mov dword [app_page_tabs+edi*4], 0
471	mov ebx, edi	-
472	shl ebx, 12	-
473	push eax	-
474	invlpg [ebx]	478	invlpg [ebx]
475	pop eax	-
476	call free_page	479	call free_page
477		480
478	.next:	481	.next:
-		482	inc edi
479	add edi, 1	483	add ebx, 0x1000
480	cmp edi, esi	484	cmp edi, esi
481	jb @B	485	jb @B
482		-
483	.update_size:	-
484	mov ebx, [new_size]	-
485	call update_mem_size	-
486		486
487	mov ecx, pg_data.mutex	487	mov ecx, pg_data.mutex
488	call mutex_unlock	488	call mutex_unlock

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/memory.inc – Rev 2467 → 2987