WebSVN – Kolibri OS – Diff – /kernel/trunk/core/memory.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5357 $
 
 
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
map_page:
        push    ebx
        mov     eax, [esp+12]              ; phis_addr
 
        or      eax, [esp+16]              ; flags
        and     eax, [pte_valid_mask]
        mov     ebx, [esp+8]               ; lin_addr
        shr     ebx, 12
        mov     [page_tabs+ebx*4], eax
        mov     eax, [esp+8]               ; lin_addr
        pop     ebx
        invlpg  [eax]
        ret     12
 
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
 
        or      edx, [flags]
        and     edx, [pte_valid_mask]
@@:
        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
 
        and     eax, [pte_valid_mask ]
        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_READ
        mov     dword [master_tab+ebx*4], eax
        mov     eax, [lin_addr]
        shr     eax, 10
        add     eax, page_tabs
        invlpg  [eax]
        pop     ebx
        ret
endp
 
uglobal
sb16_buffer_allocated db 0
endg
 
; Allocates [.size] bytes so that the target memory block
; is inside one 64K page for 24-bit DMA controller,
; that is, somewhere between 00xx0000h and 00xxFFFFh.
proc alloc_dma24
; Implementation note.
; The only user of that function is SB16 driver,
; so just return a statically allocated buffer.
virtual at esp
                dd      ? ; return address
.size           dd      ?
end virtual
        cmp     [sb16_buffer_allocated], 0
        jnz     .fail
        inc     [sb16_buffer_allocated]
        mov     eax, SB16Buffer
        ret     4
.fail:
        xor     eax, eax
        ret     4
endp
 
; Allocates a physical page for master page table
; that duplicates first Mb of OS_BASE at address 0;
; used for starting APs and for shutting down,
; where it is important to execute code in trivial-mapped pages.
; Returns eax = allocated physical page.
proc create_trampoline_pgmap
; The only non-trivial moment:
; we need a linear address to fill information,
; but we don't need it outside of this function,
; so we're returning physical address.
; Therefore, allocate memory with kernel_alloc,
; this will allocate physical page and a linear address somewhere,
; and deallocate only linear address with free_kernel_space.
        stdcall kernel_alloc, 0x1000
        mov     edi, eax
        mov     esi, master_tab
        mov     ecx, 1024
        rep movsd
        mov     ecx, [master_tab+(OS_BASE shr 20)]
        mov     [eax], ecx
        mov     edi, eax
        call    get_pg_addr
        push    eax
        stdcall free_kernel_space, edi
        pop     eax
        ret
endp
 
align 4
proc init_LFB
           locals
             pg_count dd ?
           endl
 
        cmp     dword [LFBAddress], -1
        jne     @f
        mov     [BOOT_VARS+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_UWR
        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_VARS+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, PDE_LARGE+PG_UWR
        mov     edx, sys_proc+PROC.pdt_0+(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_proc+PROC.pdt_0+(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_UWR
        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]
        mov     ebx, [edx+APPDATA.process]
 
        cmp     [ebx+PROC.heap_base], 0
        jne     .exit
 
        mov     edi, [new_size]
        add     edi, 4095
        and     edi, not 4095
        mov     [new_size], edi
 
        mov     esi, [ebx+PROC.mem_used]
        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]
        mov     edx, [edx+APPDATA.process]
        mov     [edx+PROC.mem_used], ebx
.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
 
 
; param
;  eax= linear address
;
; retval
;  eax= phisical page address
 
align 4
get_pg_addr:
        sub     eax, OS_BASE
        cmp     eax, 0x400000
        jb      @f
        shr     eax, 12
        mov     eax, [page_tabs+(eax+(OS_BASE shr 12))*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
 
.user_space:
        test    eax, PG_READ
        jnz     .err_access       ;Страница присутствует
                                  ;Ошибка доступа ?
 
        shr     ebx, 12
        mov     ecx, ebx
        shr     ecx, 10
        mov     edx, [master_tab+ecx*4]
        test    edx, PG_READ
        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_UWR
 
        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_process]
        mov     eax, [eax+PROC.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_UWR
        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_READ
        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_SWR
        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_SWR
        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_ipc stdcall, lin_addr:dword,slot:dword,\
                      ofs:dword,buf_size:dword,req_access:dword
        locals
             count   dd ?
             process dd ?
        endl
 
        mov     [count], 0
        cmp     [buf_size], 0
        jz      .exit
 
        mov     eax, [slot]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.process]
        test    eax, eax
        jz      .exit
 
        mov     [process], eax
        mov     ebx, [ofs]
        shr     ebx, 22
        mov     eax, [eax+PROC.pdt_0+ebx*4]                 ;get page table
        mov     esi, [ipc_ptab]
        and     eax, 0xFFFFF000
        jz      .exit
        stdcall map_page, esi, eax, PG_SWR
@@:
        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
.map:
        stdcall safe_map_page, [slot], [req_access], [ofs]
        jnc     .exit
        add     [count], PAGE_SIZE
        add     [ofs], PAGE_SIZE
        dec     ecx
        jz      .exit
 
        add     edi, PAGE_SIZE
        inc     edx
        cmp     edx, 1024
        jnz     .map
 
        inc     ebx
        mov     eax, [process]
        mov     eax, [eax+PROC.pdt_0+ebx*4]
        and     eax, 0xFFFFF000
        jz      .exit
 
        stdcall map_page, esi, eax, PG_SWR
        xor     edx, edx
        jmp     .map
.exit:
        mov     eax, [count]
        ret
endp
 
proc map_memEx stdcall, lin_addr:dword,slot:dword,\
                        ofs:dword,buf_size:dword,req_access:dword
        locals
             count   dd ?
             process dd ?
        endl
 
        mov     [count], 0
        cmp     [buf_size], 0
        jz      .exit
 
        mov     eax, [slot]
        shl     eax, 8
        mov     eax, [SLOT_BASE+eax+APPDATA.process]
        test    eax, eax
        jz      .exit
 
        mov     [process], eax
        mov     ebx, [ofs]
        shr     ebx, 22
        mov     eax, [eax+PROC.pdt_0+ebx*4]                 ;get page table
        mov     esi, [proc_mem_tab]
        and     eax, 0xFFFFF000
        jz      .exit
        stdcall map_page, esi, eax, PG_SWR
@@:
        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
.map:
        stdcall safe_map_page, [slot], [req_access], [ofs]
        jnc     .exit
        add     [count], PAGE_SIZE
        add     [ofs], PAGE_SIZE
        dec     ecx
        jz      .exit
 
        add     edi, PAGE_SIZE
        inc     edx
        cmp     edx, 1024
        jnz     .map
 
        inc     ebx
        mov     eax, [process]
        mov     eax, [eax+PROC.pdt_0+ebx*4]
        and     eax, 0xFFFFF000
        jz      .exit
 
        stdcall map_page, esi, eax, PG_SWR
        xor     edx, edx
        jmp     .map
.exit:
        mov     eax, [count]
        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_READ
        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_UWR
        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.process]
        mov     eax, [eax+PROC.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_UWR
        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
 
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+APPDATA.ipc_start] ;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+APPDATA.ipc_size]
        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_ipc, ecx, [dst_slot], \
                edi, esi, PG_SWR
 
        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
        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]
        je      @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, 27
        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
 
        stdcall load_pe_driver, ecx, edx
        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
 
.27:
        cmp     ecx, OS_BASE
        jae     .fail
 
        stdcall load_file_umode, ecx
        mov     [esp+24], edx
        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
           dd f68.27   ; load_file_umode
 
 
align 4
proc load_pe_driver stdcall, file:dword, cmdline:dword
        push    esi
 
        stdcall load_PE, [file]
        test    eax, eax
        jz      .fail
 
        mov     esi, eax
        push    [cmdline]
        push    DRV_ENTRY
        call    eax
        pop     ecx
        pop     ecx
        test    eax, eax
        jz      .fail
 
        mov     [eax+SRV.entry], esi
        pop     esi
        ret
 
.fail:
        xor     eax, eax
        pop     esi
        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 5356	Rev 5357
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: 5356 $	8	$Revision: 5357 $
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	map_page:	127	map_page:
128	push ebx	128	push ebx
129	mov eax, [esp+12] ; phis_addr	129	mov eax, [esp+12] ; phis_addr
130	and eax, not 0xFFF	-
131	or eax, [esp+16] ; flags	130	or eax, [esp+16] ; flags
-		131	and eax, [pte_valid_mask]
132	mov ebx, [esp+8] ; lin_addr	132	mov ebx, [esp+8] ; lin_addr
133	shr ebx, 12	133	shr ebx, 12
134	mov [page_tabs+ebx*4], eax	134	mov [page_tabs+ebx*4], eax
135	mov eax, [esp+8] ; lin_addr	135	mov eax, [esp+8] ; lin_addr
136	pop ebx	136	pop ebx
137	invlpg [eax]	137	invlpg [eax]
138	ret 12	138	ret 12
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	-
195	or edx, [flags]	194	or edx, [flags]
-		195	and edx, [pte_valid_mask]
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	and eax, [pte_valid_mask ]
232	mov edi, ebx	233	mov edi, ebx
233	shr edi, 12	234	shr edi, 12
234	lea edi, [page_tabs+edi*4]	235	lea edi, [page_tabs+edi*4]
235	@@:	236	@@:
236	stosd	237	stosd
237	invlpg [ebx]	238	invlpg [ebx]
238	add eax, 0x1000	239	add eax, 0x1000
239	add ebx, 0x1000	240	add ebx, 0x1000
240	loop @B	241	loop @B
241		242
242	pop edi	243	pop edi
243		244
244	mov ecx, pg_data.mutex	245	mov ecx, pg_data.mutex
245	call mutex_unlock	246	call mutex_unlock
246	.fail:	247	.fail:
247	ret	248	ret
248		249
249		250
250	; param	251	; param
251	; eax= base	252	; eax= base
252	; ecx= count	253	; ecx= count
253		254
254	align 4	255	align 4
255	release_pages:	256	release_pages:
256		257
257	push ebp	258	push ebp
258	push esi	259	push esi
259	push edi	260	push edi
260	push ebx	261	push ebx
261		262
262	mov esi, eax	263	mov esi, eax
263	mov edi, eax	264	mov edi, eax
264		265
265	shr esi, 12	266	shr esi, 12
266	lea esi, [page_tabs+esi*4]	267	lea esi, [page_tabs+esi*4]
267		268
268	push ecx	269	push ecx
269	mov ecx, pg_data.mutex	270	mov ecx, pg_data.mutex
270	call mutex_lock	271	call mutex_lock
271	pop ecx	272	pop ecx
272		273
273	mov ebp, [pg_data.pages_free]	274	mov ebp, [pg_data.pages_free]
274	mov ebx, [page_start]	275	mov ebx, [page_start]
275	mov edx, sys_pgmap	276	mov edx, sys_pgmap
276	@@:	277	@@:
277	xor eax, eax	278	xor eax, eax
278	xchg eax, [esi]	279	xchg eax, [esi]
279	invlpg [edi]	280	invlpg [edi]
280		281
281	test eax, 1	282	test eax, 1
282	jz .next	283	jz .next
283		284
284	shr eax, 12	285	shr eax, 12
285	bts [edx], eax	286	bts [edx], eax
286	cmc	287	cmc
287	adc ebp, 0	288	adc ebp, 0
288	shr eax, 3	289	shr eax, 3
289	and eax, -4	290	and eax, -4
290	add eax, edx	291	add eax, edx
291	cmp eax, ebx	292	cmp eax, ebx
292	jae .next	293	jae .next
293		294
294	mov ebx, eax	295	mov ebx, eax
295	.next:	296	.next:
296	add edi, 0x1000	297	add edi, 0x1000
297	add esi, 4	298	add esi, 4
298	loop @B	299	loop @B
299		300
300	mov [pg_data.pages_free], ebp	301	mov [pg_data.pages_free], ebp
301	mov ecx, pg_data.mutex	302	mov ecx, pg_data.mutex
302	call mutex_unlock	303	call mutex_unlock
303		304
304	pop ebx	305	pop ebx
305	pop edi	306	pop edi
306	pop esi	307	pop esi
307	pop ebp	308	pop ebp
308	ret	309	ret
309		310
310	; param	311	; param
311	; eax= base	312	; eax= base
312	; ecx= count	313	; ecx= count
313		314
314	align 4	315	align 4
315	unmap_pages:	316	unmap_pages:
316		317
317	push edi	318	push edi
318		319
319	mov edi, eax	320	mov edi, eax
320	mov edx, eax	321	mov edx, eax
321		322
322	shr edi, 10	323	shr edi, 10
323	add edi, page_tabs	324	add edi, page_tabs
324		325
325	xor eax, eax	326	xor eax, eax
326	@@:	327	@@:
327	stosd	328	stosd
328	invlpg [edx]	329	invlpg [edx]
329	add edx, 0x1000	330	add edx, 0x1000
330	loop @b	331	loop @b
331		332
332	pop edi	333	pop edi
333	ret	334	ret
334		335
335		336
336	align 4	337	align 4
337	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword	338	proc map_page_table stdcall, lin_addr:dword, phis_addr:dword
338	push ebx	339	push ebx
339	mov ebx, [lin_addr]	340	mov ebx, [lin_addr]
340	shr ebx, 22	341	shr ebx, 22
341	mov eax, [phis_addr]	342	mov eax, [phis_addr]
342	and eax, not 0xFFF	343	and eax, not 0xFFF
343	or eax, PG_READ	344	or eax, PG_READ
344	mov dword [master_tab+ebx*4], eax	345	mov dword [master_tab+ebx*4], eax
345	mov eax, [lin_addr]	346	mov eax, [lin_addr]
346	shr eax, 10	347	shr eax, 10
347	add eax, page_tabs	348	add eax, page_tabs
348	invlpg [eax]	349	invlpg [eax]
349	pop ebx	350	pop ebx
350	ret	351	ret
351	endp	352	endp
352		353
353	uglobal	354	uglobal
354	sb16_buffer_allocated db 0	355	sb16_buffer_allocated db 0
355	endg	356	endg
356		357
357	; Allocates [.size] bytes so that the target memory block	358	; Allocates [.size] bytes so that the target memory block
358	; is inside one 64K page for 24-bit DMA controller,	359	; is inside one 64K page for 24-bit DMA controller,
359	; that is, somewhere between 00xx0000h and 00xxFFFFh.	360	; that is, somewhere between 00xx0000h and 00xxFFFFh.
360	proc alloc_dma24	361	proc alloc_dma24
361	; Implementation note.	362	; Implementation note.
362	; The only user of that function is SB16 driver,	363	; The only user of that function is SB16 driver,
363	; so just return a statically allocated buffer.	364	; so just return a statically allocated buffer.
364	virtual at esp	365	virtual at esp
365	dd ? ; return address	366	dd ? ; return address
366	.size dd ?	367	.size dd ?
367	end virtual	368	end virtual
368	cmp [sb16_buffer_allocated], 0	369	cmp [sb16_buffer_allocated], 0
369	jnz .fail	370	jnz .fail
370	inc [sb16_buffer_allocated]	371	inc [sb16_buffer_allocated]
371	mov eax, SB16Buffer	372	mov eax, SB16Buffer
372	ret 4	373	ret 4
373	.fail:	374	.fail:
374	xor eax, eax	375	xor eax, eax
375	ret 4	376	ret 4
376	endp	377	endp
377		378
378	; Allocates a physical page for master page table	379	; Allocates a physical page for master page table
379	; that duplicates first Mb of OS_BASE at address 0;	380	; that duplicates first Mb of OS_BASE at address 0;
380	; used for starting APs and for shutting down,	381	; used for starting APs and for shutting down,
381	; where it is important to execute code in trivial-mapped pages.	382	; where it is important to execute code in trivial-mapped pages.
382	; Returns eax = allocated physical page.	383	; Returns eax = allocated physical page.
383	proc create_trampoline_pgmap	384	proc create_trampoline_pgmap
384	; The only non-trivial moment:	385	; The only non-trivial moment:
385	; we need a linear address to fill information,	386	; we need a linear address to fill information,
386	; but we don't need it outside of this function,	387	; but we don't need it outside of this function,
387	; so we're returning physical address.	388	; so we're returning physical address.
388	; Therefore, allocate memory with kernel_alloc,	389	; Therefore, allocate memory with kernel_alloc,
389	; this will allocate physical page and a linear address somewhere,	390	; this will allocate physical page and a linear address somewhere,
390	; and deallocate only linear address with free_kernel_space.	391	; and deallocate only linear address with free_kernel_space.
391	stdcall kernel_alloc, 0x1000	392	stdcall kernel_alloc, 0x1000
392	mov edi, eax	393	mov edi, eax
393	mov esi, master_tab	394	mov esi, master_tab
394	mov ecx, 1024	395	mov ecx, 1024
395	rep movsd	396	rep movsd
396	mov ecx, [master_tab+(OS_BASE shr 20)]	397	mov ecx, [master_tab+(OS_BASE shr 20)]
397	mov [eax], ecx	398	mov [eax], ecx
398	mov edi, eax	399	mov edi, eax
399	call get_pg_addr	400	call get_pg_addr
400	push eax	401	push eax
401	stdcall free_kernel_space, edi	402	stdcall free_kernel_space, edi
402	pop eax	403	pop eax
403	ret	404	ret
404	endp	405	endp
405		406
406	align 4	407	align 4
407	proc init_LFB	408	proc init_LFB
408	locals	409	locals
409	pg_count dd ?	410	pg_count dd ?
410	endl	411	endl
411		412
412	cmp dword [LFBAddress], -1	413	cmp dword [LFBAddress], -1
413	jne @f	414	jne @f
414	mov [BOOT_VARS+BOOT_MTRR], byte 2	415	mov [BOOT_VARS+BOOT_MTRR], byte 2
415	; max VGA=6404804=1228800 bytes	416	; max VGA=6404804=1228800 bytes
416	; + 326404=81920 bytes for mouse pointer	417	; + 326404=81920 bytes for mouse pointer
417	stdcall alloc_pages, ((1228800+81920)/4096)	418	stdcall alloc_pages, ((1228800+81920)/4096)
418		419
419	push eax	420	push eax
420	call alloc_page	421	call alloc_page
421	stdcall map_page_table, LFB_BASE, eax	422	stdcall map_page_table, LFB_BASE, eax
422	pop eax	423	pop eax
423	or eax, PG_UWR	424	or eax, PG_UWR
424	mov ebx, LFB_BASE	425	mov ebx, LFB_BASE
425	; max VGA=6404804=1228800 bytes	426	; max VGA=6404804=1228800 bytes
426	; + 326404=81920 bytes for mouse pointer	427	; + 326404=81920 bytes for mouse pointer
427	mov ecx, (1228800+81920)/4096	428	mov ecx, (1228800+81920)/4096
428	call commit_pages	429	call commit_pages
429	mov [LFBAddress], dword LFB_BASE	430	mov [LFBAddress], dword LFB_BASE
430	ret	431	ret
431	@@:	432	@@:
432	test [SCR_MODE], word 0100000000000000b	433	test [SCR_MODE], word 0100000000000000b
433	jnz @f	434	jnz @f
434	mov [BOOT_VARS+BOOT_MTRR], byte 2	435	mov [BOOT_VARS+BOOT_MTRR], byte 2
435	ret	436	ret
436	@@:	437	@@:
437	call init_mtrr	438	call init_mtrr
438		439
439	mov edx, LFB_BASE	440	mov edx, LFB_BASE
440	mov esi, [LFBAddress]	441	mov esi, [LFBAddress]
441	mov edi, 0x00C00000	442	mov edi, 0x00C00000
442	mov dword [exp_lfb+4], edx	443	mov dword [exp_lfb+4], edx
443		444
444	shr edi, 12	445	shr edi, 12
445	mov [pg_count], edi	446	mov [pg_count], edi
446	shr edi, 10	447	shr edi, 10
447		448
448	bt [cpu_caps], CAPS_PSE	449	bt [cpu_caps], CAPS_PSE
449	jnc .map_page_tables	450	jnc .map_page_tables
450	or esi, PDE_LARGE+PG_UWR	451	or esi, PDE_LARGE+PG_UWR
451	mov edx, sys_proc+PROC.pdt_0+(LFB_BASE shr 20)	452	mov edx, sys_proc+PROC.pdt_0+(LFB_BASE shr 20)
452	@@:	453	@@:
453	mov [edx], esi	454	mov [edx], esi
454	add edx, 4	455	add edx, 4
455	add esi, 0x00400000	456	add esi, 0x00400000
456	dec edi	457	dec edi
457	jnz @B	458	jnz @B
458		459
459	bt [cpu_caps], CAPS_PGE	460	bt [cpu_caps], CAPS_PGE
460	jnc @F	461	jnc @F
461	or dword [sys_proc+PROC.pdt_0+(LFB_BASE shr 20)], PG_GLOBAL	462	or dword [sys_proc+PROC.pdt_0+(LFB_BASE shr 20)], PG_GLOBAL
462	@@:	463	@@:
463	mov dword [LFBAddress], LFB_BASE	464	mov dword [LFBAddress], LFB_BASE
464	mov eax, cr3 ;flush TLB	465	mov eax, cr3 ;flush TLB
465	mov cr3, eax	466	mov cr3, eax
466	ret	467	ret
467		468
468	.map_page_tables:	469	.map_page_tables:
469		470
470	@@:	471	@@:
471	call alloc_page	472	call alloc_page
472	stdcall map_page_table, edx, eax	473	stdcall map_page_table, edx, eax
473	add edx, 0x00400000	474	add edx, 0x00400000
474	dec edi	475	dec edi
475	jnz @B	476	jnz @B
476		477
477	mov eax, [LFBAddress]	478	mov eax, [LFBAddress]
478	mov edi, page_tabs + (LFB_BASE shr 10)	479	mov edi, page_tabs + (LFB_BASE shr 10)
479	or eax, PG_UWR	480	or eax, PG_UWR
480	mov ecx, [pg_count]	481	mov ecx, [pg_count]
481	cld	482	cld
482	@@:	483	@@:
483	stosd	484	stosd
484	add eax, 0x1000	485	add eax, 0x1000
485	dec ecx	486	dec ecx
486	jnz @B	487	jnz @B
487		488
488	mov dword [LFBAddress], LFB_BASE	489	mov dword [LFBAddress], LFB_BASE
489	mov eax, cr3 ;flush TLB	490	mov eax, cr3 ;flush TLB
490	mov cr3, eax	491	mov cr3, eax
491		492
492	ret	493	ret
493	endp	494	endp
494		495
495	align 4	496	align 4
496	proc new_mem_resize stdcall, new_size:dword	497	proc new_mem_resize stdcall, new_size:dword
497		498

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/memory.inc – Rev 5356 → 5357