Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2020. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 7733 $

align 4

proc mem_test

; if we have BIOS with fn E820, skip the test

        cmp     dword [BOOT_LO.memmap_block_cnt], 0

        jnz     .ret

        mov     eax, cr0

        and     eax, not (CR0_CD+CR0_NW)

        or      eax, CR0_CD       ;disable caching

        mov     cr0, eax

        wbinvd                    ;invalidate cache

        xor     edi, edi

        mov     ebx, 'TEST'

@@:

        add     edi, 0x100000

        xchg    ebx, dword [edi]

        cmp     dword [edi], 'TEST'

        xchg    ebx, dword [edi]

        je      @b

        and     eax, not (CR0_CD+CR0_NW) ;enable caching

        mov     cr0, eax

        inc     dword [BOOT_LO.memmap_block_cnt]

        xor     eax, eax

        mov     [BOOT_LO.memmap_blocks + e820entry.addr.lo], eax

        mov     [BOOT_LO.memmap_blocks + e820entry.addr.hi], eax

        mov     [BOOT_LO.memmap_blocks + e820entry.size.lo], edi

        mov     [BOOT_LO.memmap_blocks + e820entry.size.hi], eax

        inc     eax

        mov     [BOOT_LO.memmap_blocks + e820entry.type], eax

.ret:

        ret

endp

align 4

proc init_mem

; calculate maximum allocatable address and number of allocatable pages

        mov     edi, BOOT_LO.memmap_blocks

        mov     ecx, [edi-4]

        xor     esi, esi; esi will hold total amount of memory

        xor     edx, edx; edx will hold maximum allocatable address

.calcmax:

; round all to pages

        mov     eax, [edi]

        cmp     [edi+16], byte 1

        jne     .unusable

        test    eax, 0xFFF

        jz      @f

        neg     eax

        and     eax, 0xFFF

        add     [edi], eax

        adc     dword [edi+4], 0

        sub     [edi+8], eax

        sbb     dword [edi+12], 0

        jc      .unusable

@@:

        and     dword [edi+8], not 0xFFF

        jz      .unusable

; ignore memory after 4 Gb

        cmp     dword [edi+4], 0

        jnz     .unusable

        mov     eax, [edi]

        cmp     dword [edi+12], 0

        jnz     .overflow

        add     eax, [edi+8]

        jnc     @f

.overflow:

        mov     eax, 0xFFFFF000

@@:

        cmp     edx, eax

        jae     @f

        mov     edx, eax

@@:

        sub     eax, [edi]

        mov     [edi+8], eax

        add     esi, eax

        jmp     .usable

.unusable:

;        and     dword [edi+8], 0

.usable:

        add     edi, 20

        loop    .calcmax

.calculated:

        mov     [MEM_AMOUNT-OS_BASE], esi

        mov     [pg_data.mem_amount-OS_BASE], esi

        shr     esi, 12

        mov     [pg_data.pages_count-OS_BASE], esi

        shr     edx, 12

        add     edx, 31

        and     edx, not 31

        shr     edx, 3

        mov     [pg_data.pagemap_size-OS_BASE], edx

        add     edx, (sys_pgmap-OS_BASE)+4095

        and     edx, not 4095

        mov     [tmp_page_tabs], edx

        mov     edx, esi

        and     edx, -1024

        cmp     edx, (OS_BASE/4096)

        jbe     @F

        mov     edx, (OS_BASE/4096)

        jmp     .set

@@:

        cmp     edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096

        jae     .set

        mov     edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096

.set:

        mov     [pg_data.kernel_pages-OS_BASE], edx

        shr     edx, 10

        mov     [pg_data.kernel_tables-OS_BASE], edx

        xor     eax, eax

        mov     edi, sys_proc-OS_BASE

        mov     ecx, 8192/4

        cld

        rep stosd

        mov     edx, (sys_proc-OS_BASE+PROC.pdt_0)+ 0x800; (OS_BASE shr 20)

        bt      [cpu_caps-OS_BASE], CAPS_PSE

        jnc     .no_PSE

        mov     ebx, cr4

        or      ebx, CR4_PSE

        mov     eax, PDE_LARGE+PG_SWR

        mov     cr4, ebx

        dec     [pg_data.kernel_tables-OS_BASE]

        mov     [edx], eax

        add     edx, 4

        mov     edi, [tmp_page_tabs]

        jmp     .map_kernel_heap        ; new kernel fits to the first 4Mb - nothing to do with ".map_low"

.no_PSE:

        mov     eax, PG_SWR

        mov     ecx, [tmp_page_tabs]

        shr     ecx, 12

.map_low:

        mov     edi, [tmp_page_tabs]

@@:                                   ;

        stosd

        add     eax, 0x1000

        dec     ecx

        jnz     @B

.map_kernel_heap:

        mov     ecx, [pg_data.kernel_tables-OS_BASE]

        shl     ecx, 10

        xor     eax, eax

        rep stosd

        mov     ecx, [pg_data.kernel_tables-OS_BASE]

        mov     eax, [tmp_page_tabs]

        or      eax, PG_SWR

        mov     edi, edx

.map_kernel_tabs:

        stosd

        add     eax, 0x1000

        dec     ecx

        jnz     .map_kernel_tabs

        mov     dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)], sys_proc+PROC.pdt_0+PG_SWR-OS_BASE

        mov     edi, (sys_proc+PROC.pdt_0-OS_BASE)

        lea     esi, [edi+(OS_BASE shr 20)]

        movsd

        movsd

        ret

endp

align 4

proc init_page_map

; mark all memory as unavailable

        mov     edi, sys_pgmap-OS_BASE

        mov     ecx, [pg_data.pagemap_size-OS_BASE]

        shr     ecx, 2

        xor     eax, eax

        cld

        rep stosd

; scan through memory map and mark free areas as available

        mov     ebx, BOOT_LO.memmap_blocks

        mov     edx, [ebx-4]

.scanmap:

        cmp     [ebx+16], byte 1

        jne     .next

        mov     ecx, [ebx+8]

        shr     ecx, 12; ecx = number of pages

        jz      .next

        mov     edi, [ebx]

        shr     edi, 12; edi = first page

        mov     eax, edi

        shr     edi, 5

        shl     edi, 2

        add     edi, sys_pgmap-OS_BASE

        and     eax, 31

        jz      .startok

        add     ecx, eax

        sub     ecx, 32

        jbe     .onedword

        push    ecx

        mov     ecx, eax

        or      eax, -1

        shl     eax, cl

        or      [edi], eax

        add     edi, 4

        pop     ecx

.startok:

        push    ecx

        shr     ecx, 5

        or      eax, -1

        rep stosd

        pop     ecx

        and     ecx, 31

        neg     eax

        shl     eax, cl

        dec     eax

        or      [edi], eax

        jmp     .next

.onedword:

        add     ecx, 32

        sub     ecx, eax

@@:

        bts     [edi], eax

        inc     eax

        loop    @b

.next:

        add     ebx, 20

        dec     edx

        jnz     .scanmap

; mark kernel memory as allocated (unavaila