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


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

Subversion Repositories Kolibri OS

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