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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9900 $
 
 
struct  MEM_BLOCK
        list            LHEAD
        next_block      dd ? ;+8
        prev_block      dd ? ;+4
        base            dd ? ;+16
        size            dd ? ;+20
        flags           dd ? ;+24
        handle          dd ? ;+28
ends
 
MEM_BLOCK_RESERVED  = 0x02      ; Will be allocated on first access (lazy allocation)
MEM_BLOCK_FREE      = 0x04
MEM_BLOCK_USED      = 0x08
MEM_BLOCK_DONT_FREE = 0x10
 
macro calc_index op
{          shr op, 12
        dec     op
        cmp     op, 63
        jna     @f
        mov     op, 63
@@:
}
 
align 4
md:
.add_to_used:
        mov     eax, [esi + MEM_BLOCK.base]
        mov     ebx, [esi + MEM_BLOCK.base]
        shr     ebx, 6
        add     eax, ebx
        shr     ebx, 6
        add     eax, ebx
        shr     eax, 12
        and     eax, 63
        inc     [mem_hash_cnt + eax*4]
 
        lea     ecx, [mem_used_list + eax*8]
        list_add esi, ecx
        mov     [esi + MEM_BLOCK.flags], MEM_BLOCK_USED
        mov     eax, [esi + MEM_BLOCK.size]
        sub     [heap_free], eax
        ret
align 4
.find_used:
        mov     ecx, eax
        mov     ebx, eax
        shr     ebx, 6
        add     ecx, ebx
        shr     ebx, 6
        add     ecx, ebx
        shr     ecx, 12
        and     ecx, 63
 
        lea     ebx, [mem_used_list + ecx*8]
        mov     esi, ebx
.next:
        mov     esi, [esi + MEM_BLOCK.list.next]
        cmp     esi, ebx
        je      .fail
 
        cmp     eax, [esi + MEM_BLOCK.base]
        jne     .next
 
        ret
.fail:
        xor     esi, esi
        ret
 
align 4
.del_from_used:
        call    .find_used
        test    esi, esi
        jz      .done
 
        cmp     [esi + MEM_BLOCK.flags], MEM_BLOCK_USED
        jne     .fatal
 
        dec     [mem_hash_cnt + ecx*4]
        list_del esi
.done:
        ret
.fatal:                            ;FIXME panic here
        xor     esi, esi
        ret
 
;Initial heap state
;
; + heap_size               terminator        MEM_BLOCK_USED
; + 4096*MEM_BLOCK.sizeof   free space        MEM_BLOCK_FREE
;HEAP_BASE                heap_descriptors  MEM_BLOCK_USED
;
 
align 4
proc init_kernel_heap
 
        mov     ecx, 64
        mov     edi, mem_block_list
  @@:
        mov     eax, edi
        stosd
        stosd
        loop    @B
 
        mov     ecx, 64
        mov     edi, mem_used_list
  @@:
        mov     eax, edi
        stosd
        stosd
        loop    @B
 
        stdcall alloc_pages, dword 32
 
        or      eax, PG_SWR
        mov     ebx, HEAP_BASE
        mov     ecx, 32
        call    commit_pages
 
        mov     edi, HEAP_BASE                     ;descriptors
        mov     ebx, HEAP_BASE + sizeof.MEM_BLOCK      ;free space
        mov     ecx, HEAP_BASE + sizeof.MEM_BLOCK*2    ;terminator
 
        xor     eax, eax
        mov     [edi + MEM_BLOCK.next_block], ebx
        mov     [edi + MEM_BLOCK.prev_block], eax
        mov     [edi + MEM_BLOCK.list.next], eax
        mov     [edi + MEM_BLOCK.list.prev], eax
        mov     [edi + MEM_BLOCK.base], HEAP_BASE
        mov     [edi + MEM_BLOCK.size], PAGE_SIZE * sizeof.MEM_BLOCK
        mov     [edi + MEM_BLOCK.flags], MEM_BLOCK_USED
 
        mov     [ecx + MEM_BLOCK.next_block], eax
        mov     [ecx + MEM_BLOCK.prev_block], ebx
        mov     [ecx + MEM_BLOCK.list.next], eax
        mov     [ecx + MEM_BLOCK.list.prev], eax
        mov     [ecx + MEM_BLOCK.base], eax
        mov     [ecx + MEM_BLOCK.size], eax
        mov     [ecx + MEM_BLOCK.flags], MEM_BLOCK_USED
 
        mov     [ebx + MEM_BLOCK.next_block], ecx
        mov     [ebx + MEM_BLOCK.prev_block], edi
        mov     [ebx + MEM_BLOCK.base], HEAP_BASE + PAGE_SIZE * sizeof.MEM_BLOCK
 
        mov     ecx, [pg_data.kernel_pages]
        shl     ecx, 12
        sub     ecx, HEAP_BASE-OS_BASE + PAGE_SIZE * sizeof.MEM_BLOCK
        mov     [heap_size], ecx
        mov     [heap_free], ecx
        mov     [ebx + MEM_BLOCK.size], ecx
        mov     [ebx + MEM_BLOCK.flags], MEM_BLOCK_FREE
 
        mov     [mem_block_mask], eax
        mov     [mem_block_mask + 4], 0x80000000
 
        mov     ecx, mem_block_list + 63*8
        list_add ebx, ecx
 
        mov     ecx, PAGE_SIZE -3-1
        mov     eax, HEAP_BASE + sizeof.MEM_BLOCK*4
 
        mov     [next_memblock], HEAP_BASE + sizeof.MEM_BLOCK *3
 @@:
        mov     [eax - sizeof.MEM_BLOCK], eax
        add     eax, sizeof.MEM_BLOCK
        loop    @B
 
        mov     dword[eax - sizeof.MEM_BLOCK], 0
 
        mov     ecx, heap_mutex
        call    mutex_init
        mov     [heap_blocks], 4094
        mov     [free_blocks], 4093
        ret
endp
 
; param
;  eax= required size
;
; retval
;  edi= memory block descriptor
;  ebx= descriptor index
 
align 4
get_small_block:
        mov     ecx, eax
        shr     ecx, 12
        dec     ecx
        cmp     ecx, 63
        jle     .get_index
        mov     ecx, 63
  .get_index:
        lea     esi, [mem_block_mask]
        xor     ebx, ebx
        or      edx, -1
 
        cmp     ecx, 32
        jb      .bit_test
 
        sub     ecx, 32
        add     ebx, 32
        add     esi, 4
  .bit_test:
        shl     edx, cl
        and     edx, [esi]
  .find:
        bsf     edi, edx
        jz      .high_mask
        add     ebx, edi
        lea     ecx, [mem_block_list + ebx*8]
        mov     edi, ecx
  .next:
        mov     edi, [edi + MEM_BLOCK.list.next]
        cmp     edi, ecx
        je      .err
        cmp     eax, [edi + MEM_BLOCK.size]
        ja      .next
        ret
  .err:
        xor     edi, edi
        ret
 
  .high_mask:
        add     esi, 4
        cmp     esi, mem_block_mask + 8
        jae     .err
        add     ebx, 32
        mov     edx, [esi]
        jmp     .find
 
 
align 4
free_mem_block:
 
        mov     ebx, [next_memblock]
        mov     [eax], ebx
        mov     [next_memblock], eax
 
        xor     ebx, ebx
        mov     dword[eax + 4], ebx
        mov     dword[eax + 8], ebx
        mov     dword[eax + 12], ebx
        mov     dword[eax + 16], ebx
;           mov dword[eax + 20], 0     ;don't clear block size
        mov     dword[eax + 24], ebx
        mov     dword[eax + 28], ebx
 
        inc     [free_blocks]
 
        ret
 
align 4
proc alloc_kernel_space stdcall, size:dword
           local block_ind:DWORD
 
        push    ebx
        push    esi
        push    edi
 
        mov     eax, [size]
        add     eax, PAGE_SIZE-1
        and     eax, -PAGE_SIZE
        mov     [size], eax
 
        cmp     eax, [heap_free]
        ja      .error
 
        spin_lock_irqsave heap_mutex
 
        mov     eax, [size]
 
        call    get_small_block ; eax
        test    edi, edi
        jz      .error_unlock
 
        cmp     [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
        jne     .error_unlock
 
        mov     [block_ind], ebx  ;index of allocated block
 
        mov     eax, [edi + MEM_BLOCK.size]
        cmp     eax, [size]
        je      .m_eq_size
 
        mov     esi, [next_memblock]    ;new memory block
        test    esi, esi
        jz      .error_unlock
 
        dec     [free_blocks]
        mov     eax, [esi]
        mov     [next_memblock], eax
 
        mov     [esi + MEM_BLOCK.next_block], edi
        mov     eax, [edi + MEM_BLOCK.prev_block]
        mov     [esi + MEM_BLOCK.prev_block], eax
        mov     [edi + MEM_BLOCK.prev_block], esi
        mov     [esi + MEM_BLOCK.list.next], 0
        mov     [esi + MEM_BLOCK.list.prev], 0
        mov     [eax + MEM_BLOCK.next_block], esi
 
        mov     ebx, [edi + MEM_BLOCK.base]
        mov     [esi + MEM_BLOCK.base], ebx
        mov     edx, [size]
        mov     [esi + MEM_BLOCK.size], edx
        add     [edi + MEM_BLOCK.base], edx
        sub     [edi + MEM_BLOCK.size], edx
 
        mov     eax, [edi + MEM_BLOCK.size]
        calc_index eax
        cmp     eax, [block_ind]
        je      .add_used
 
        list_del edi
 
        mov     ecx, [block_ind]
        lea     edx, [mem_block_list + ecx*8]
        cmp     edx, [edx]
        jnz     @f
        btr     [mem_block_mask], ecx
@@:
        bts     [mem_block_mask], eax
        lea     edx, [mem_block_list + eax*8]  ;edx= list head
        list_add edi, edx
.add_used:
 
        call    md.add_to_used
 
        spin_unlock_irqrestore heap_mutex
        mov     eax, [esi + MEM_BLOCK.base]
        pop     edi
        pop     esi
        pop     ebx
        ret
 
.m_eq_size:
        list_del edi
        lea     edx, [mem_block_list + ebx*8]
        cmp     edx, [edx]
        jnz     @f
        btr     [mem_block_mask], ebx
@@:
        mov     esi, edi
        jmp     .add_used
 
.error_unlock:
        spin_unlock_irqrestore heap_mutex
.error:
        xor     eax, eax
        pop     edi
        pop     esi
        pop     ebx
        ret
endp
 
align 4
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
 
        spin_lock_irqsave heap_mutex
 
        mov     eax, [base]
 
        call    md.del_from_used
        test    esi, esi
        jz      .fail
 
        mov     eax, [esi + MEM_BLOCK.size]
        add     [heap_free], eax
 
        mov     edi, [esi + MEM_BLOCK.next_block]
        cmp     [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
        jne     .prev
 
        list_del edi
 
        mov     edx, [edi + MEM_BLOCK.next_block]
        mov     [esi + MEM_BLOCK.next_block], edx
        mov     [edx + MEM_BLOCK.prev_block], esi
        mov     ecx, [edi + MEM_BLOCK.size]
        add     [esi + MEM_BLOCK.size], ecx
 
        calc_index ecx
 
        lea     edx, [mem_block_list + ecx*8]
        cmp     edx, [edx]
        jne     @F
        btr     [mem_block_mask], ecx
@@:
        mov     eax, edi
        call    free_mem_block
.prev:
        mov     edi, [esi + MEM_BLOCK.prev_block]
        cmp     [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
        jne     .insert
 
        mov     edx, [esi + MEM_BLOCK.next_block]
        mov     [edi + MEM_BLOCK.next_block], edx
        mov     [edx + MEM_BLOCK.prev_block], edi
 
        mov     eax, esi
        call    free_mem_block
 
        mov     ecx, [edi + MEM_BLOCK.size]
        mov     eax, [esi + MEM_BLOCK.size]
        add     eax, ecx
        mov     [edi + MEM_BLOCK.size], eax
 
        calc_index eax                     ;new index
        calc_index ecx                     ;old index
        cmp     eax, ecx
        je      .m_eq
 
        push    ecx
        list_del edi
        pop     ecx
 
        lea     edx, [mem_block_list + ecx*8]
        cmp     edx, [edx]
        jne     .add_block
        btr     [mem_block_mask], ecx
 
.add_block:
        bts     [mem_block_mask], eax
        lea     edx, [mem_block_list + eax*8]
        list_add edi, edx
.m_eq:
        spin_unlock_irqrestore heap_mutex
        xor     eax, eax
        not     eax
        ret
.insert:
        mov     [esi + MEM_BLOCK.flags], MEM_BLOCK_FREE
        mov     eax, [esi + MEM_BLOCK.size]
        calc_index eax
        mov     edi, esi
        jmp     .add_block
 
.fail:
        spin_unlock_irqrestore heap_mutex
        xor     eax, eax
        ret
endp
 
align 4
proc kernel_alloc stdcall, size:dword
        locals
          lin_addr    dd ?
          pages_count dd ?
        endl
 
        push    ebx
        push    edi
 
        mov     eax, [size]
        add     eax, PAGE_SIZE-1
        and     eax, -PAGE_SIZE;
        mov     [size], eax
        and     eax, eax
        jz      .err
        mov     ebx, eax
        shr     ebx, 12
        mov     [pages_count], ebx
 
        stdcall alloc_kernel_space, eax
        mov     [lin_addr], eax
        mov     ebx, [pages_count]
        test    eax, eax
        jz      .err
 
        mov     edx, eax
 
        shr     ebx, 3
        jz      .tail
 
        shl     ebx, 3
        stdcall alloc_pages, ebx
        test    eax, eax
        jz      .err
 
        mov     ecx, ebx
        or      eax, PG_GLOBAL + PG_SWR
        mov     ebx, [lin_addr]
        call    commit_pages
 
        mov     edx, ebx                    ; this dirty hack
.tail:
        mov     ebx, [pages_count]
        and     ebx, 7
        jz      .end
@@:
        call    alloc_page
        test    eax, eax
        jz      .err
 
        stdcall map_page, edx, eax, dword (PG_GLOBAL + PG_SWR)
        add     edx, PAGE_SIZE
        dec     ebx
        jnz     @B
.end:
        mov     eax, [lin_addr]
        pop     edi
        pop     ebx
        ret
.err:
        xor     eax, eax
        pop     edi
        pop     ebx
        ret
endp
 
align 4
proc kernel_free stdcall, base:dword
 
        push    ebx esi
 
        spin_lock_irqsave heap_mutex
 
        mov     eax, [base]
        call    md.find_used
 
        cmp     [esi + MEM_BLOCK.flags], MEM_BLOCK_USED
        jne     .fail
 
        spin_unlock_irqrestore heap_mutex
 
        mov     eax, [esi + MEM_BLOCK.base]
        mov     ecx, [esi + MEM_BLOCK.size]
        shr     ecx, 12
        call    release_pages   ;eax, ecx
        stdcall free_kernel_space, [base]
        pop     esi ebx
        ret
.fail:
        spin_unlock_irqrestore heap_mutex
        xor     eax, eax
        pop     esi ebx
        ret
endp
 
;;;;;;;;;;;;;;      USER HEAP     ;;;;;;;;;;;;;;;;;
 
HEAP_TOP  = 0x80000000
 
align 4
proc init_heap
 
        mov     ebx, [current_process]
        mov     eax, [ebx + PROC.heap_top]
        test    eax, eax
        jz      @F
        sub     eax, [ebx + PROC.heap_base]
        sub     eax, PAGE_SIZE
        ret
@@:
        lea     ecx, [ebx + PROC.heap_lock]
        call    mutex_init
 
        mov     esi, [ebx + PROC.mem_used]
        add     esi, PAGE_SIZE-1
        and     esi, -PAGE_SIZE
        mov     [ebx + PROC.mem_used], esi
        mov     eax, HEAP_TOP
        mov     [ebx + PROC.heap_base], esi
        mov     [ebx + PROC.heap_top], eax
 
        sub     eax, esi
        shr     esi, 10
        mov     ecx, eax
        sub     eax, PAGE_SIZE
        or      ecx, MEM_BLOCK_FREE
        mov     [page_tabs + esi], ecx
        ret
endp
 
align 4
proc user_alloc stdcall, alloc_size:dword
 
        push    ebx esi edi
 
        mov     ebx, [current_process]
        lea     ecx, [ebx + PROC.heap_lock]
        call    mutex_lock
 
        mov     ecx, [alloc_size]
        add     ecx, (4095 + PAGE_SIZE)
        and     ecx, -PAGE_SIZE
        mov     esi, [ebx + PROC.heap_base]
        mov     edi, [ebx + PROC.heap_top]
  .scan:
        cmp     esi, edi
        jae     .m_exit
 
        mov     ebx, esi
        shr     ebx, 12
        mov     eax, [page_tabs + ebx*4]
        test    al, MEM_BLOCK_FREE
        jz      .test_used
        and     eax, -PAGE_SIZE
        cmp     eax, ecx   ;alloc_size
        jb      .m_next
        jz      @f
 
        lea     edx, [esi + ecx]
        sub     eax, ecx
        or      al, MEM_BLOCK_FREE
        shr     edx, 12
        mov     [page_tabs + edx*4], eax
  @@:
        or      ecx, MEM_BLOCK_USED
        mov     [page_tabs + ebx*4], ecx
        shr     ecx, 12
        inc     ebx
        dec     ecx
        jz      .no
  @@:
        mov     dword [page_tabs + ebx*4], MEM_BLOCK_RESERVED
        inc     ebx
        dec     ecx
        jnz     @B
  .no:
 
        mov     edx, [current_process]
        mov     ebx, [alloc_size]
        add     ebx, PAGE_SIZE-1
        and     ebx, -PAGE_SIZE
        add     [edx + PROC.mem_used], ebx
 
        lea     ecx, [edx + PROC.heap_lock]
        call    mutex_unlock
 
        lea     eax, [esi + PAGE_SIZE]
 
        pop     edi
        pop     esi
        pop     ebx
        ret
.test_used:
        test    al, MEM_BLOCK_USED
        jz      .m_exit
 
        and     eax, -PAGE_SIZE
.m_next:
        add     esi, eax
        jmp     .scan
.m_exit:
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
 
        xor     eax, eax
        pop     edi
        pop     esi
        pop     ebx
        ret
endp
 
align 4
proc user_alloc_at stdcall, address:dword, alloc_size:dword
 
        push    ebx
        push    esi
        push    edi
 
        mov     ebx, [current_process]
        lea     ecx, [ebx + PROC.heap_lock]
        call    mutex_lock
 
        mov     edx, [address]
        and     edx, -PAGE_SIZE
        mov     [address], edx
        sub     edx, PAGE_SIZE
        jb      .error
        mov     esi, [ebx + PROC.heap_base]
        mov     edi, [ebx + PROC.heap_top]
        cmp     edx, esi
        jb      .error
.scan:
        cmp     esi, edi
        jae     .error
        mov     ebx, esi
        shr     ebx, 12
        mov     eax, [page_tabs + ebx*4]
        mov     ecx, eax
        and     ecx, -PAGE_SIZE
        add     ecx, esi
        cmp     edx, ecx
        jb      .found
        mov     esi, ecx
        jmp     .scan
.error:
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
 
        xor     eax, eax
        pop     edi
        pop     esi
        pop     ebx
        ret
.found:
        test    al, MEM_BLOCK_FREE
        jz      .error
        mov     eax, ecx
        sub     eax, edx
        sub     eax, PAGE_SIZE
        cmp     eax, [alloc_size]
        jb      .error
 
; Here we have 1 big free block which includes requested area.
; In general, 3 other blocks must be created instead:
; free at [esi, edx);
; busy at [edx, edx + 0x1000 + ALIGN_UP(alloc_size,0x1000));
; free at [edx + 0x1000 + ALIGN_UP(alloc_size,0x1000), ecx)
; First or third block (or both) may be absent.
        mov     eax, edx
        sub     eax, esi
        jz      .nofirst
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + ebx*4], eax
  .nofirst:
        mov     eax, [alloc_size]
        add     eax, 0x1FFF
        and     eax, -PAGE_SIZE
        mov     ebx, edx
        add     edx, eax
        shr     ebx, 12
        or      al, MEM_BLOCK_USED
        mov     [page_tabs + ebx*4], eax
        shr     eax, 12
        dec     eax
        jz      .second_nofill
        inc     ebx
  .fill:
        mov     dword [page_tabs + ebx*4], MEM_BLOCK_RESERVED
        inc     ebx
        dec     eax
        jnz     .fill
 
  .second_nofill:
        sub     ecx, edx
        jz      .nothird
        or      cl, MEM_BLOCK_FREE
        mov     [page_tabs + ebx*4], ecx
 
  .nothird:
        mov     edx, [current_process]
        mov     ebx, [alloc_size]
        add     ebx, PAGE_SIZE-1
        and     ebx, -PAGE_SIZE
        add     [edx + PROC.mem_used], ebx
 
        lea     ecx, [edx + PROC.heap_lock]
        call    mutex_unlock
 
        mov     eax, [address]
 
        pop     edi
        pop     esi
        pop     ebx
        ret
endp
 
align 4
proc user_free stdcall, base:dword
 
        push    esi
 
        mov     esi, [base]
        test    esi, esi
        jz      .fail
 
        push    ebx
 
        mov     ebx, [current_process]
        lea     ecx, [ebx + PROC.heap_lock]
        call    mutex_lock
 
        xor     ebx, ebx
        shr     esi, 12
        mov     eax, [page_tabs + (esi-1)*4]
        test    al, MEM_BLOCK_USED
        jz      .cantfree
        test    al, MEM_BLOCK_DONT_FREE
        jnz     .cantfree
 
        and     eax, -PAGE_SIZE
        mov     ecx, eax
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + (esi-1)*4], eax
        sub     ecx, PAGE_SIZE
        mov     ebx, ecx
        shr     ecx, 12
        jz      .released
  .release:
        xor     eax, eax
        xchg    eax, [page_tabs + esi*4]
        test    al, 1
        jz      @F
        test    eax, PG_SHARED
        jnz     @F
        call    free_page
        mov     eax, esi
        shl     eax, 12
        invlpg  [eax]
  @@:
        inc     esi
        dec     ecx
        jnz     .release
 
 .released:
        push    edi
 
        mov     edx, [current_process]
        lea     ecx, [edx + PROC.heap_lock]
        mov     esi, dword [edx + PROC.heap_base]
        mov     edi, dword [edx + PROC.heap_top]
        sub     ebx, [edx + PROC.mem_used]
        neg     ebx
        mov     [edx + PROC.mem_used], ebx
        call    user_normalize
        pop     edi
 .exit:
        call    mutex_unlock
 
        xor     eax, eax
        inc     eax
        pop     ebx
        pop     esi
        ret
 
  .cantfree:
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        jmp     .exit
  .fail:
        xor     eax, eax
        pop     esi
        ret
endp
 
 
align 4
proc user_unmap stdcall, base:dword, offset:dword, size:dword
 
        push    ebx
 
        mov     ebx, [base]             ; must be valid pointer
        test    ebx, ebx
        jz      .error
 
        mov     edx, [offset]           ; check offset
        add     edx, ebx                ; must be below 2Gb app limit
        js      .error
 
        shr     ebx, 12                 ; chek block attributes
        lea     ebx, [page_tabs + ebx*4]
        mov     eax, [ebx - 4]          ; block attributes
        test    al, MEM_BLOCK_USED
        jz      .error
        test    al, MEM_BLOCK_DONT_FREE
        jnz     .error
 
        shr     edx, 12
        lea     edx, [page_tabs + edx*4]  ; unmap offset
 
        mov     ecx, [size]
        add     ecx, PAGE_SIZE-1
        shr     ecx, 12                 ; unmap size in pages
 
        shr     eax, 12                 ; block size  +  1 page
        lea     ebx, [ebx + eax*4-4]      ; block end ptr
        lea     eax, [edx + ecx*4]        ; unmap end ptr
 
        cmp     eax, ebx                ; check for overflow
        ja      .error
 
        mov     ebx, [offset]
        and     ebx, -PAGE_SIZE         ; is it required ?
        add     ebx, [base]
 
  .unmap:
        mov     eax, [edx]              ; get page addres
        test    al, 1                   ; page mapped ?
        jz      @F
        test    eax, PG_SHARED          ; page shared ?
        jnz     @F
        mov     dword[edx], MEM_BLOCK_RESERVED
                                        ; mark page as reserved
        invlpg  [ebx]                   ; when we start using
        call    free_page               ; empty c-o-w page instead this ?
  @@:
        add     ebx, PAGE_SIZE
        add     edx, 4
        dec     ecx
        jnz     .unmap
 
        pop     ebx
        or      al, 1                   ; return non zero on success
        ret
.error:
        pop     ebx
        xor     eax, eax                ; something wrong
        ret
endp
 
align 4
user_normalize:
; in: esi=heap_base, edi=heap_top
; out: eax=0 <=> OK
; destroys: ebx,edx,esi,edi
        shr     esi, 12
        shr     edi, 12
@@:
        mov     eax, [page_tabs + esi*4]
        test    al, MEM_BLOCK_USED
        jz      .test_free
        shr     eax, 12
        add     esi, eax
        jmp     @B
.test_free:
        test    al, MEM_BLOCK_FREE
        jz      .err
        mov     edx, eax
        shr     edx, 12
        add     edx, esi
        cmp     edx, edi
        jae     .exit
 
        mov     ebx, [page_tabs + edx*4]
        test    bl, MEM_BLOCK_USED
        jz      .next_free
 
        shr     ebx, 12
        add     edx, ebx
        mov     esi, edx
        jmp     @B
.next_free:
        test    bl, MEM_BLOCK_FREE
        jz      .err
        and     dword[page_tabs + edx*4], 0
        add     eax, ebx
        and     eax, -PAGE_SIZE
        or      eax, MEM_BLOCK_FREE
        mov     [page_tabs + esi*4], eax
        jmp     @B
.exit:
        xor     eax, eax
        inc     eax
        ret
.err:
        xor     eax, eax
        ret
 
user_realloc:
; in: eax = pointer, ebx = new size
; out: eax = new pointer or NULL
        test    eax, eax
        jnz     @f
; realloc(NULL,sz) - same as malloc(sz)
        push    ebx
        call    user_alloc
        ret
@@:
        push    ecx edx
 
        push    eax
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_lock
        pop     eax
 
        lea     ecx, [eax - PAGE_SIZE]
        shr     ecx, 12
        mov     edx, [page_tabs + ecx*4]
        test    dl, MEM_BLOCK_USED
        jnz     @f
; attempt to realloc invalid pointer
.ret0:
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
 
        pop     edx ecx
        xor     eax, eax
        ret
@@:
        test    dl, MEM_BLOCK_DONT_FREE
        jnz     .ret0
        add     ebx, 0x1FFF
        shr     edx, 12
        shr     ebx, 12
; edx = allocated size, ebx = new size
        add     edx, ecx
        add     ebx, ecx
        cmp     edx, ebx
        jb      .realloc_add
; release part of allocated memory
.loop:
        cmp     edx, ebx
        jz      .release_done
        dec     edx
        xor     eax, eax
        xchg    eax, [page_tabs + edx*4]
        test    al, 1
        jz      .loop
        call    free_page
        mov     eax, edx
        shl     eax, 12
        invlpg  [eax]
        jmp     .loop
.release_done:
        sub     ebx, ecx
        cmp     ebx, 1
        jnz     .nofreeall
        mov     eax, [page_tabs + ecx*4]
        and     eax, -PAGE_SIZE
        mov     edx, [current_process]
        mov     ebx, [edx + PROC.mem_used]
        sub     ebx, eax
        add     ebx, PAGE_SIZE
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + ecx*4], eax
        push    esi edi
        mov     esi, [edx + PROC.heap_base]
        mov     edi, [edx + PROC.heap_top]
        mov     [edx + PROC.mem_used], ebx
        call    user_normalize
        pop     edi esi
        jmp     .ret0   ; all freed
.nofreeall:
        sub     edx, ecx
        shl     ebx, 12
        or      ebx, MEM_BLOCK_USED
        xchg    [page_tabs + ecx*4], ebx
        shr     ebx, 12
        sub     ebx, edx
        push    ebx ecx edx
        mov     edx, [current_process]
        shl     ebx, 12
        sub     ebx, [edx + PROC.mem_used]
        neg     ebx
        mov     [edx + PROC.mem_used], ebx
        pop     edx ecx ebx
        lea     eax, [ecx + 1]
        shl     eax, 12
        push    eax
        add     ecx, edx
        lea     edx, [ecx + ebx]
        shl     ebx, 12
        jz      .ret
        push    esi
        mov     esi, [current_process]
        mov     esi, [esi + PROC.heap_top]
        shr     esi, 12
@@:
        cmp     edx, esi
        jae     .merge_done
        mov     eax, [page_tabs + edx*4]
        test    al, MEM_BLOCK_USED
        jnz     .merge_done
        and     dword [page_tabs + edx*4], 0
        shr     eax, 12
        add     edx, eax
        shl     eax, 12
        add     ebx, eax
        jmp     @b
.merge_done:
        pop     esi
        or      ebx, MEM_BLOCK_FREE
        mov     [page_tabs + ecx*4], ebx
.ret:
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
        pop     eax edx ecx
        ret
 
.realloc_add:
; get some additional memory
        mov     eax, [current_process]
        mov     eax, [eax + PROC.heap_top]
        shr     eax, 12
        cmp     edx, eax
        jae     .cant_inplace
        mov     eax, [page_tabs + edx*4]
        test    al, MEM_BLOCK_FREE
        jz      .cant_inplace
        shr     eax, 12
        add     eax, edx
        sub     eax, ebx
        jb      .cant_inplace
        jz      @f
        shl     eax, 12
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + ebx*4], eax
@@:
        mov     eax, ebx
        sub     eax, ecx
        shl     eax, 12
        or      al, MEM_BLOCK_USED
        mov     [page_tabs + ecx*4], eax
        lea     eax, [ecx + 1]
        shl     eax, 12
        push    eax
        push    edi
        lea     edi, [page_tabs + edx*4]
        mov     eax, 2
        sub     ebx, edx
        mov     ecx, ebx
        cld
        rep stosd
        pop     edi
        mov     edx, [current_process]
        shl     ebx, 12
        add     [edx + PROC.mem_used], ebx
 
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
        pop     eax edx ecx
        ret
 
.cant_inplace:
        push    esi edi
        mov     eax, [current_process]
        mov     esi, [eax + PROC.heap_base]
        mov     edi, [eax + PROC.heap_top]
        shr     esi, 12
        shr     edi, 12
        sub     ebx, ecx
.find_place:
        cmp     esi, edi
        jae     .place_not_found
        mov     eax, [page_tabs + esi*4]
        test    al, MEM_BLOCK_FREE
        jz      .next_place
        shr     eax, 12
        cmp     eax, ebx
        jae     .place_found
        add     esi, eax
        jmp     .find_place
.next_place:
        shr     eax, 12
        add     esi, eax
        jmp     .find_place
.place_not_found:
        pop     edi esi
        jmp     .ret0
.place_found:
        sub     eax, ebx
        jz      @f
        push    esi
        add     esi, ebx
        shl     eax, 12
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + esi*4], eax
        pop     esi
@@:
        mov     eax, ebx
        shl     eax, 12
        or      al, MEM_BLOCK_USED
        mov     [page_tabs + esi*4], eax
        inc     esi
        mov     eax, esi
        shl     eax, 12
        push    eax
        mov     eax, [page_tabs + ecx*4]
        and     eax, -PAGE_SIZE
        or      al, MEM_BLOCK_FREE
        sub     edx, ecx
        mov     [page_tabs + ecx*4], eax
        inc     ecx
        dec     ebx
        dec     edx
        jz      .no
@@:
        xor     eax, eax
        xchg    eax, [page_tabs + ecx*4]
        mov     [page_tabs + esi*4], eax
        mov     eax, ecx
        shl     eax, 12
        invlpg  [eax]
        inc     esi
        inc     ecx
        dec     ebx
        dec     edx
        jnz     @b
.no:
        push    ebx
        mov     edx, [current_process]
        shl     ebx, 12
        add     [edx + PROC.mem_used], ebx
        pop     ebx
@@:
        mov     dword [page_tabs + esi*4], MEM_BLOCK_RESERVED
        inc     esi
        dec     ebx
        jnz     @b
 
        mov     ecx, [current_process]
        lea     ecx, [ecx + PROC.heap_lock]
        call    mutex_unlock
        pop     eax edi esi edx ecx
        ret
 
 
 
;;;;;;;;;;;;;;      SHARED MEMORY     ;;;;;;;;;;;;;;;;;
 
 
; param
;  eax= shm_map object
 
align 4
destroy_smap:
 
        pushfd
        cli
 
        push    esi
        push    edi
 
        mov     edi, eax
        mov     esi, [eax + SMAP.parent]
        test    esi, esi
        jz      .done
 
        lock dec [esi + SMEM.refcount]
        jnz     .done
 
        mov     ecx, [esi + SMEM.bk]
        mov     edx, [esi + SMEM.fd]
 
        mov     [ecx + SMEM.fd], edx
        mov     [edx + SMEM.bk], ecx
 
        stdcall kernel_free, [esi + SMEM.base]
        mov     eax, esi
        call    free
.done:
        mov     eax, edi
        call    destroy_kernel_object
 
        pop     edi
        pop     esi
        popfd
 
        ret
 
E_NOTFOUND      =  5
E_ACCESS        = 10
E_NOMEM         = 30
E_PARAM         = 33
 
SHM_READ        = 0
SHM_WRITE       = 1
 
SHM_ACCESS_MASK = 3
 
SHM_OPEN        = 0 shl 2
SHM_OPEN_ALWAYS = 1 shl 2
SHM_CREATE      = 2 shl 2
 
SHM_OPEN_MASK   = 3 shl 2
 
align 4
proc shmem_open stdcall name:dword, size:dword, access:dword
        locals
           action         dd ?
           owner_access   dd ?
           mapped         dd ?
        endl
 
        push    ebx
        push    esi
        push    edi
 
        mov     [mapped], 0
        mov     [owner_access], 0
 
        pushfd                         ;mutex required
        cli
 
        mov     eax, [access]
        and     eax, SHM_OPEN_MASK
        mov     [action], eax
 
        mov     ebx, [name]
        test    ebx, ebx
        mov     edx, E_PARAM
        jz      .fail
 
        mov     esi, [shmem_list.fd]
align 4
@@:
        cmp     esi, shmem_list
        je      .not_found
 
        lea     edx, [esi + SMEM.name]; link , base, size
        stdcall strncmp, edx, ebx, 32
        test    eax, eax
        je      .found
 
        mov     esi, [esi + SMEM.fd]
        jmp     @B
 
.not_found:
        mov     eax, [action]
 
        cmp     eax, SHM_OPEN
        mov     edx, E_NOTFOUND
        je      .fail
 
        cmp     eax, SHM_CREATE
        mov     edx, E_PARAM
        je      .create_shm
 
        cmp     eax, SHM_OPEN_ALWAYS
        jne     .fail
 
.create_shm:
 
        mov     ecx, [size]
        test    ecx, ecx
        jz      .fail
 
        add     ecx, PAGE_SIZE-1
        and     ecx, -PAGE_SIZE
        mov     [size], ecx
 
        mov     eax, sizeof.SMEM
        call    malloc
        test    eax, eax
        mov     esi, eax
        mov     edx, E_NOMEM
        jz      .fail
 
        stdcall kernel_alloc, [size]
        test    eax, eax
        mov     [mapped], eax
        mov     edx, E_NOMEM
        jz      .cleanup
 
        mov     ecx, [size]
        mov     edx, [access]
        and     edx, SHM_ACCESS_MASK
 
        mov     [esi + SMEM.base], eax
        mov     [esi + SMEM.size], ecx
        mov     [esi + SMEM.access], edx
        mov     [esi + SMEM.refcount], 0
        mov     [esi + SMEM.name + 28], 0
 
        lea     eax, [esi + SMEM.name]
        stdcall strncpy, eax, [name], 31
 
        mov     eax, [shmem_list.fd]
        mov     [esi + SMEM.bk], shmem_list
        mov     [esi + SMEM.fd], eax
 
        mov     [eax + SMEM.bk], esi
        mov     [shmem_list.fd], esi
 
        mov     [action], SHM_OPEN
        mov     [owner_access], SHM_WRITE
 
.found:
        mov     eax, [action]
 
        cmp     eax, SHM_CREATE
        mov     edx, E_ACCESS
        je      .exit
 
        cmp     eax, SHM_OPEN
        mov     edx, E_PARAM
        je      .create_map
 
        cmp     eax, SHM_OPEN_ALWAYS
        jne     .fail
 
.create_map:
 
        mov     eax, [access]
        and     eax, SHM_ACCESS_MASK
        cmp     eax, [esi + SMEM.access]
        mov     [access], eax
        mov     edx, E_ACCESS
        ja      .fail
 
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        mov     eax, sizeof.SMAP
 
        call    create_kernel_object
        test    eax, eax
        mov     edi, eax
        mov     edx, E_NOMEM
        jz      .fail
 
        inc     [esi + SMEM.refcount]
 
        mov     [edi + SMAP.magic], 'SMAP'
        mov     [edi + SMAP.destroy], destroy_smap
        mov     [edi + SMAP.parent], esi
        mov     [edi + SMAP.base], 0
 
        stdcall user_alloc, [esi + SMEM.size]
        test    eax, eax
        mov     [mapped], eax
        mov     edx, E_NOMEM
        jz      .cleanup2
 
        mov     [edi + SMAP.base], eax
 
        mov     ecx, [esi + SMEM.size]
        mov     [size], ecx
 
        shr     ecx, 12
        shr     eax, 10
 
        mov     esi, [esi + SMEM.base]
        shr     esi, 10
        lea     edi, [page_tabs + eax]
        add     esi, page_tabs
 
        mov     edx, [access]
        or      edx, [owner_access]
        shl     edx, 1
        or      edx, PG_SHARED + PG_UR
@@:
        lodsd
        and     eax, -PAGE_SIZE
        or      eax, edx
        stosd
        loop    @B
 
        xor     edx, edx
 
        cmp     [owner_access], 0
        jne     .fail
.exit:
        mov     edx, [size]
.fail:
        mov     eax, [mapped]
 
        popfd
        pop     edi
        pop     esi
        pop     ebx
        ret
.cleanup:
        mov     [size], edx
        mov     eax, esi
        call    free
        jmp     .exit
 
.cleanup2:
        mov     [size], edx
        mov     eax, edi
        call    destroy_smap
        jmp     .exit
endp
 
align 4
proc shmem_close stdcall, name:dword
 
        mov     eax, [name]
        test    eax, eax
        jz      .fail
 
        push    ebx ; Added
        push    esi
        push    edi
        pushfd
        cli
 
        mov     esi, [current_slot]
        add     esi, APP_OBJ_OFFSET
        mov     ebx, esi ; Fixed endless loop bug with not existing name (part 1)
.next:
        mov     eax, [esi + APPOBJ.fd]
        test    eax, eax
        jz      @F
 
        cmp     eax, ebx ;esi ; Fixed endless loop bug with not existing name (part 2)
        je      @F            ; Small optimization
        mov     esi, eax
        ;je      @F
 
        cmp     [eax + SMAP.magic], 'SMAP'
        jne     .next
 
        mov     edi, [eax + SMAP.parent]
        test    edi, edi
        jz      .next
 
        lea     edi, [edi + SMEM.name]
        stdcall strncmp, [name], edi, 32
        test    eax, eax
        jne     .next
 
        stdcall user_free, [esi + SMAP.base]
 
        mov     eax, esi
        call    [esi + APPOBJ.destroy]
@@:
        popfd
        pop     edi
        pop     esi
        pop     ebx ; Added
.fail:
        ret
endp
 
 
 
proc    user_ring stdcall, size:dword
 
locals
        virt_ptr        dd ?
        phys_ptr        dd ?
        num_pages       dd ?
endl
 
; Size must be an exact multiple of pagesize
        mov     eax, [size]
        test    eax, PAGE_SIZE-1
        jnz     .exit
 
; We must have at least one complete page
        shr     eax, 12
        jz      .exit
        mov     [num_pages], eax
 
; Allocate double the virtual memory
        mov     eax, [size]
        shl     eax, 1
        jz      .exit
        stdcall user_alloc, eax
        test    eax, eax
        jz      .exit
        mov     [virt_ptr], eax
 
; Now allocate physical memory
        stdcall alloc_pages, [num_pages]
        test    eax, eax
        jz      .exit_free_virt
        mov     [phys_ptr], eax
 
; Map first half of virtual memory to physical memory
        push    ecx esi edi
        mov     ecx, [num_pages]
        mov     esi, [virt_ptr]
        mov     edi, [phys_ptr]
  .loop1:
        stdcall map_page, esi, edi, PG_UWR
        add     esi, PAGE_SIZE
        add     edi, PAGE_SIZE
        dec     ecx
        jnz     .loop1
 
; Map second half of virtual memory to same physical memory
        mov     ecx, [num_pages]
        mov     edi, [phys_ptr]
  .loop2:
        stdcall map_page, esi, edi, PG_UWR
        add     esi, PAGE_SIZE
        add     edi, PAGE_SIZE
        dec     ecx
        jnz     .loop2
        pop     edi esi ecx
 
        mov     eax, [virt_ptr]
        ret
 
  .exit_free_virt:
        stdcall user_free, [virt_ptr]
 
  .exit:
        xor     eax, eax
        ret
 
endp

Rev 9828	Rev 9900
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2022. 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: 9828 $	8	$Revision: 9900 $
9		9
10		10
11	struct MEM_BLOCK	11	struct MEM_BLOCK
12	list LHEAD	12	list LHEAD
13	next_block dd ? ;+8	13	next_block dd ? ;+8
14	prev_block dd ? ;+4	14	prev_block dd ? ;+4
15	base dd ? ;+16	15	base dd ? ;+16
16	size dd ? ;+20	16	size dd ? ;+20
17	flags dd ? ;+24	17	flags dd ? ;+24
18	handle dd ? ;+28	18	handle dd ? ;+28
19	ends	19	ends
20		20
21	MEM_BLOCK_RESERVED = 0x02 ; Will be allocated on first access (lazy allocation)	21	MEM_BLOCK_RESERVED = 0x02 ; Will be allocated on first access (lazy allocation)
22	MEM_BLOCK_FREE = 0x04	22	MEM_BLOCK_FREE = 0x04
23	MEM_BLOCK_USED = 0x08	23	MEM_BLOCK_USED = 0x08
24	MEM_BLOCK_DONT_FREE = 0x10	24	MEM_BLOCK_DONT_FREE = 0x10
25		25
26	macro calc_index op	26	macro calc_index op
27	{ shr op, 12	27	{ shr op, 12
28	dec op	28	dec op
29	cmp op, 63	29	cmp op, 63
30	jna @f	30	jna @f
31	mov op, 63	31	mov op, 63
32	@@:	32	@@:
33	}	33	}
34		34
35	align 4	35	align 4
36	md:	36	md:
37	.add_to_used:	37	.add_to_used:
38	mov eax, [esi + MEM_BLOCK.base]	38	mov eax, [esi + MEM_BLOCK.base]
39	mov ebx, [esi + MEM_BLOCK.base]	39	mov ebx, [esi + MEM_BLOCK.base]
40	shr ebx, 6	40	shr ebx, 6
41	add eax, ebx	41	add eax, ebx
42	shr ebx, 6	42	shr ebx, 6
43	add eax, ebx	43	add eax, ebx
44	shr eax, 12	44	shr eax, 12
45	and eax, 63	45	and eax, 63
46	inc [mem_hash_cnt + eax*4]	46	inc [mem_hash_cnt + eax*4]
47		47
48	lea ecx, [mem_used_list + eax*8]	48	lea ecx, [mem_used_list + eax*8]
49	list_add esi, ecx	49	list_add esi, ecx
50	mov [esi + MEM_BLOCK.flags], MEM_BLOCK_USED	50	mov [esi + MEM_BLOCK.flags], MEM_BLOCK_USED
51	mov eax, [esi + MEM_BLOCK.size]	51	mov eax, [esi + MEM_BLOCK.size]
52	sub [heap_free], eax	52	sub [heap_free], eax
53	ret	53	ret
54	align 4	54	align 4
55	.find_used:	55	.find_used:
56	mov ecx, eax	56	mov ecx, eax
57	mov ebx, eax	57	mov ebx, eax
58	shr ebx, 6	58	shr ebx, 6
59	add ecx, ebx	59	add ecx, ebx
60	shr ebx, 6	60	shr ebx, 6
61	add ecx, ebx	61	add ecx, ebx
62	shr ecx, 12	62	shr ecx, 12
63	and ecx, 63	63	and ecx, 63
64		64
65	lea ebx, [mem_used_list + ecx*8]	65	lea ebx, [mem_used_list + ecx*8]
66	mov esi, ebx	66	mov esi, ebx
67	.next:	67	.next:
68	mov esi, [esi + MEM_BLOCK.list.next]	68	mov esi, [esi + MEM_BLOCK.list.next]
69	cmp esi, ebx	69	cmp esi, ebx
70	je .fail	70	je .fail
71		71
72	cmp eax, [esi + MEM_BLOCK.base]	72	cmp eax, [esi + MEM_BLOCK.base]
73	jne .next	73	jne .next
74		74
75	ret	75	ret
76	.fail:	76	.fail:
77	xor esi, esi	77	xor esi, esi
78	ret	78	ret
79		79
80	align 4	80	align 4
81	.del_from_used:	81	.del_from_used:
82	call .find_used	82	call .find_used
83	test esi, esi	83	test esi, esi
84	jz .done	84	jz .done
85		85
86	cmp [esi + MEM_BLOCK.flags], MEM_BLOCK_USED	86	cmp [esi + MEM_BLOCK.flags], MEM_BLOCK_USED
87	jne .fatal	87	jne .fatal
88		88
89	dec [mem_hash_cnt + ecx*4]	89	dec [mem_hash_cnt + ecx*4]
90	list_del esi	90	list_del esi
91	.done:	91	.done:
92	ret	92	ret
93	.fatal: ;FIXME panic here	93	.fatal: ;FIXME panic here
94	xor esi, esi	94	xor esi, esi
95	ret	95	ret
96		96
97	;Initial heap state	97	;Initial heap state
98	;	98	;
99	; + heap_size terminator MEM_BLOCK_USED	99	; + heap_size terminator MEM_BLOCK_USED
100	; + 4096*MEM_BLOCK.sizeof free space MEM_BLOCK_FREE	100	; + 4096*MEM_BLOCK.sizeof free space MEM_BLOCK_FREE
101	;HEAP_BASE heap_descriptors MEM_BLOCK_USED	101	;HEAP_BASE heap_descriptors MEM_BLOCK_USED
102	;	102	;
103		103
104	align 4	104	align 4
105	proc init_kernel_heap	105	proc init_kernel_heap
106		106
107	mov ecx, 64	107	mov ecx, 64
108	mov edi, mem_block_list	108	mov edi, mem_block_list
109	@@:	109	@@:
110	mov eax, edi	110	mov eax, edi
111	stosd	111	stosd
112	stosd	112	stosd
113	loop @B	113	loop @B
114		114
115	mov ecx, 64	115	mov ecx, 64
116	mov edi, mem_used_list	116	mov edi, mem_used_list
117	@@:	117	@@:
118	mov eax, edi	118	mov eax, edi
119	stosd	119	stosd
120	stosd	120	stosd
121	loop @B	121	loop @B
122		122
123	stdcall alloc_pages, dword 32	123	stdcall alloc_pages, dword 32
124		124
125	or eax, PG_SWR	125	or eax, PG_SWR
126	mov ebx, HEAP_BASE	126	mov ebx, HEAP_BASE
127	mov ecx, 32	127	mov ecx, 32
128	call commit_pages	128	call commit_pages
129		129
130	mov edi, HEAP_BASE ;descriptors	130	mov edi, HEAP_BASE ;descriptors
131	mov ebx, HEAP_BASE + sizeof.MEM_BLOCK ;free space	131	mov ebx, HEAP_BASE + sizeof.MEM_BLOCK ;free space
132	mov ecx, HEAP_BASE + sizeof.MEM_BLOCK*2 ;terminator	132	mov ecx, HEAP_BASE + sizeof.MEM_BLOCK*2 ;terminator
133		133
134	xor eax, eax	134	xor eax, eax
135	mov [edi + MEM_BLOCK.next_block], ebx	135	mov [edi + MEM_BLOCK.next_block], ebx
136	mov [edi + MEM_BLOCK.prev_block], eax	136	mov [edi + MEM_BLOCK.prev_block], eax
137	mov [edi + MEM_BLOCK.list.next], eax	137	mov [edi + MEM_BLOCK.list.next], eax
138	mov [edi + MEM_BLOCK.list.prev], eax	138	mov [edi + MEM_BLOCK.list.prev], eax
139	mov [edi + MEM_BLOCK.base], HEAP_BASE	139	mov [edi + MEM_BLOCK.base], HEAP_BASE
140	mov [edi + MEM_BLOCK.size], 4096*sizeof.MEM_BLOCK	140	mov [edi + MEM_BLOCK.size], PAGE_SIZE * sizeof.MEM_BLOCK
141	mov [edi + MEM_BLOCK.flags], MEM_BLOCK_USED	141	mov [edi + MEM_BLOCK.flags], MEM_BLOCK_USED
142		142
143	mov [ecx + MEM_BLOCK.next_block], eax	143	mov [ecx + MEM_BLOCK.next_block], eax
144	mov [ecx + MEM_BLOCK.prev_block], ebx	144	mov [ecx + MEM_BLOCK.prev_block], ebx
145	mov [ecx + MEM_BLOCK.list.next], eax	145	mov [ecx + MEM_BLOCK.list.next], eax
146	mov [ecx + MEM_BLOCK.list.prev], eax	146	mov [ecx + MEM_BLOCK.list.prev], eax
147	mov [ecx + MEM_BLOCK.base], eax	147	mov [ecx + MEM_BLOCK.base], eax
148	mov [ecx + MEM_BLOCK.size], eax	148	mov [ecx + MEM_BLOCK.size], eax
149	mov [ecx + MEM_BLOCK.flags], MEM_BLOCK_USED	149	mov [ecx + MEM_BLOCK.flags], MEM_BLOCK_USED
150		150
151	mov [ebx + MEM_BLOCK.next_block], ecx	151	mov [ebx + MEM_BLOCK.next_block], ecx
152	mov [ebx + MEM_BLOCK.prev_block], edi	152	mov [ebx + MEM_BLOCK.prev_block], edi
153	mov [ebx + MEM_BLOCK.base], HEAP_BASE + 4096*sizeof.MEM_BLOCK	153	mov [ebx + MEM_BLOCK.base], HEAP_BASE + PAGE_SIZE * sizeof.MEM_BLOCK
154		154
155	mov ecx, [pg_data.kernel_pages]	155	mov ecx, [pg_data.kernel_pages]
156	shl ecx, 12	156	shl ecx, 12
157	sub ecx, HEAP_BASE-OS_BASE + 4096*sizeof.MEM_BLOCK	157	sub ecx, HEAP_BASE-OS_BASE + PAGE_SIZE * sizeof.MEM_BLOCK
158	mov [heap_size], ecx	158	mov [heap_size], ecx
159	mov [heap_free], ecx	159	mov [heap_free], ecx
160	mov [ebx + MEM_BLOCK.size], ecx	160	mov [ebx + MEM_BLOCK.size], ecx
161	mov [ebx + MEM_BLOCK.flags], MEM_BLOCK_FREE	161	mov [ebx + MEM_BLOCK.flags], MEM_BLOCK_FREE
162		162
163	mov [mem_block_mask], eax	163	mov [mem_block_mask], eax
164	mov [mem_block_mask + 4], 0x80000000	164	mov [mem_block_mask + 4], 0x80000000
165		165
166	mov ecx, mem_block_list + 63*8	166	mov ecx, mem_block_list + 63*8
167	list_add ebx, ecx	167	list_add ebx, ecx
168		168
169	mov ecx, 4096-3-1	169	mov ecx, PAGE_SIZE -3-1
170	mov eax, HEAP_BASE + sizeof.MEM_BLOCK*4	170	mov eax, HEAP_BASE + sizeof.MEM_BLOCK*4
171		171
172	mov [next_memblock], HEAP_BASE + sizeof.MEM_BLOCK *3	172	mov [next_memblock], HEAP_BASE + sizeof.MEM_BLOCK *3
173	@@:	173	@@:
174	mov [eax - sizeof.MEM_BLOCK], eax	174	mov [eax - sizeof.MEM_BLOCK], eax
175	add eax, sizeof.MEM_BLOCK	175	add eax, sizeof.MEM_BLOCK
176	loop @B	176	loop @B
177		177
178	mov dword[eax - sizeof.MEM_BLOCK], 0	178	mov dword[eax - sizeof.MEM_BLOCK], 0
179		179
180	mov ecx, heap_mutex	180	mov ecx, heap_mutex
181	call mutex_init	181	call mutex_init
182	mov [heap_blocks], 4094	182	mov [heap_blocks], 4094
183	mov [free_blocks], 4093	183	mov [free_blocks], 4093
184	ret	184	ret
185	endp	185	endp
186		186
187	; param	187	; param
188	; eax= required size	188	; eax= required size
189	;	189	;
190	; retval	190	; retval
191	; edi= memory block descriptor	191	; edi= memory block descriptor
192	; ebx= descriptor index	192	; ebx= descriptor index
193		193
194	align 4	194	align 4
195	get_small_block:	195	get_small_block:
196	mov ecx, eax	196	mov ecx, eax
197	shr ecx, 12	197	shr ecx, 12
198	dec ecx	198	dec ecx
199	cmp ecx, 63	199	cmp ecx, 63
200	jle .get_index	200	jle .get_index
201	mov ecx, 63	201	mov ecx, 63
202	.get_index:	202	.get_index:
203	lea esi, [mem_block_mask]	203	lea esi, [mem_block_mask]
204	xor ebx, ebx	204	xor ebx, ebx
205	or edx, -1	205	or edx, -1
206		206
207	cmp ecx, 32	207	cmp ecx, 32
208	jb .bit_test	208	jb .bit_test
209		209
210	sub ecx, 32	210	sub ecx, 32
211	add ebx, 32	211	add ebx, 32
212	add esi, 4	212	add esi, 4
213	.bit_test:	213	.bit_test:
214	shl edx, cl	214	shl edx, cl
215	and edx, [esi]	215	and edx, [esi]
216	.find:	216	.find:
217	bsf edi, edx	217	bsf edi, edx
218	jz .high_mask	218	jz .high_mask
219	add ebx, edi	219	add ebx, edi
220	lea ecx, [mem_block_list + ebx*8]	220	lea ecx, [mem_block_list + ebx*8]
221	mov edi, ecx	221	mov edi, ecx
222	.next:	222	.next:
223	mov edi, [edi + MEM_BLOCK.list.next]	223	mov edi, [edi + MEM_BLOCK.list.next]
224	cmp edi, ecx	224	cmp edi, ecx
225	je .err	225	je .err
226	cmp eax, [edi + MEM_BLOCK.size]	226	cmp eax, [edi + MEM_BLOCK.size]
227	ja .next	227	ja .next
228	ret	228	ret
229	.err:	229	.err:
230	xor edi, edi	230	xor edi, edi
231	ret	231	ret
232		232
233	.high_mask:	233	.high_mask:
234	add esi, 4	234	add esi, 4
235	cmp esi, mem_block_mask + 8	235	cmp esi, mem_block_mask + 8
236	jae .err	236	jae .err
237	add ebx, 32	237	add ebx, 32
238	mov edx, [esi]	238	mov edx, [esi]
239	jmp .find	239	jmp .find
240		240
241		241
242	align 4	242	align 4
243	free_mem_block:	243	free_mem_block:
244		244
245	mov ebx, [next_memblock]	245	mov ebx, [next_memblock]
246	mov [eax], ebx	246	mov [eax], ebx
247	mov [next_memblock], eax	247	mov [next_memblock], eax
248		248
249	xor ebx, ebx	249	xor ebx, ebx
250	mov dword[eax + 4], ebx	250	mov dword[eax + 4], ebx
251	mov dword[eax + 8], ebx	251	mov dword[eax + 8], ebx
252	mov dword[eax + 12], ebx	252	mov dword[eax + 12], ebx
253	mov dword[eax + 16], ebx	253	mov dword[eax + 16], ebx
254	; mov dword[eax + 20], 0 ;don't clear block size	254	; mov dword[eax + 20], 0 ;don't clear block size
255	mov dword[eax + 24], ebx	255	mov dword[eax + 24], ebx
256	mov dword[eax + 28], ebx	256	mov dword[eax + 28], ebx
257		257
258	inc [free_blocks]	258	inc [free_blocks]
259		259
260	ret	260	ret
261		261
262	align 4	262	align 4
263	proc alloc_kernel_space stdcall, size:dword	263	proc alloc_kernel_space stdcall, size:dword
264	local block_ind:DWORD	264	local block_ind:DWORD
265		265
266	push ebx	266	push ebx
267	push esi	267	push esi
268	push edi	268	push edi
269		269
270	mov eax, [size]	270	mov eax, [size]
271	add eax, 4095	271	add eax, PAGE_SIZE-1
272	and eax, not 4095	272	and eax, -PAGE_SIZE
273	mov [size], eax	273	mov [size], eax
274		274
275	cmp eax, [heap_free]	275	cmp eax, [heap_free]
276	ja .error	276	ja .error
277		277
278	spin_lock_irqsave heap_mutex	278	spin_lock_irqsave heap_mutex
279		279
280	mov eax, [size]	280	mov eax, [size]
281		281
282	call get_small_block ; eax	282	call get_small_block ; eax
283	test edi, edi	283	test edi, edi
284	jz .error_unlock	284	jz .error_unlock
285		285
286	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE	286	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
287	jne .error_unlock	287	jne .error_unlock
288		288
289	mov [block_ind], ebx ;index of allocated block	289	mov [block_ind], ebx ;index of allocated block
290		290
291	mov eax, [edi + MEM_BLOCK.size]	291	mov eax, [edi + MEM_BLOCK.size]
292	cmp eax, [size]	292	cmp eax, [size]
293	je .m_eq_size	293	je .m_eq_size
294		294
295	mov esi, [next_memblock] ;new memory block	295	mov esi, [next_memblock] ;new memory block
296	test esi, esi	296	test esi, esi
297	jz .error_unlock	297	jz .error_unlock
298		298
299	dec [free_blocks]	299	dec [free_blocks]
300	mov eax, [esi]	300	mov eax, [esi]
301	mov [next_memblock], eax	301	mov [next_memblock], eax
302		302
303	mov [esi + MEM_BLOCK.next_block], edi	303	mov [esi + MEM_BLOCK.next_block], edi
304	mov eax, [edi + MEM_BLOCK.prev_block]	304	mov eax, [edi + MEM_BLOCK.prev_block]
305	mov [esi + MEM_BLOCK.prev_block], eax	305	mov [esi + MEM_BLOCK.prev_block], eax
306	mov [edi + MEM_BLOCK.prev_block], esi	306	mov [edi + MEM_BLOCK.prev_block], esi
307	mov [esi + MEM_BLOCK.list.next], 0	307	mov [esi + MEM_BLOCK.list.next], 0
308	mov [esi + MEM_BLOCK.list.prev], 0	308	mov [esi + MEM_BLOCK.list.prev], 0
309	mov [eax + MEM_BLOCK.next_block], esi	309	mov [eax + MEM_BLOCK.next_block], esi
310		310
311	mov ebx, [edi + MEM_BLOCK.base]	311	mov ebx, [edi + MEM_BLOCK.base]
312	mov [esi + MEM_BLOCK.base], ebx	312	mov [esi + MEM_BLOCK.base], ebx
313	mov edx, [size]	313	mov edx, [size]
314	mov [esi + MEM_BLOCK.size], edx	314	mov [esi + MEM_BLOCK.size], edx
315	add [edi + MEM_BLOCK.base], edx	315	add [edi + MEM_BLOCK.base], edx
316	sub [edi + MEM_BLOCK.size], edx	316	sub [edi + MEM_BLOCK.size], edx
317		317
318	mov eax, [edi + MEM_BLOCK.size]	318	mov eax, [edi + MEM_BLOCK.size]
319	calc_index eax	319	calc_index eax
320	cmp eax, [block_ind]	320	cmp eax, [block_ind]
321	je .add_used	321	je .add_used
322		322
323	list_del edi	323	list_del edi
324		324
325	mov ecx, [block_ind]	325	mov ecx, [block_ind]
326	lea edx, [mem_block_list + ecx*8]	326	lea edx, [mem_block_list + ecx*8]
327	cmp edx, [edx]	327	cmp edx, [edx]
328	jnz @f	328	jnz @f
329	btr [mem_block_mask], ecx	329	btr [mem_block_mask], ecx
330	@@:	330	@@:
331	bts [mem_block_mask], eax	331	bts [mem_block_mask], eax
332	lea edx, [mem_block_list + eax*8] ;edx= list head	332	lea edx, [mem_block_list + eax*8] ;edx= list head
333	list_add edi, edx	333	list_add edi, edx
334	.add_used:	334	.add_used:
335		335
336	call md.add_to_used	336	call md.add_to_used
337		337
338	spin_unlock_irqrestore heap_mutex	338	spin_unlock_irqrestore heap_mutex
339	mov eax, [esi + MEM_BLOCK.base]	339	mov eax, [esi + MEM_BLOCK.base]
340	pop edi	340	pop edi
341	pop esi	341	pop esi
342	pop ebx	342	pop ebx
343	ret	343	ret
344		344
345	.m_eq_size:	345	.m_eq_size:
346	list_del edi	346	list_del edi
347	lea edx, [mem_block_list + ebx*8]	347	lea edx, [mem_block_list + ebx*8]
348	cmp edx, [edx]	348	cmp edx, [edx]
349	jnz @f	349	jnz @f
350	btr [mem_block_mask], ebx	350	btr [mem_block_mask], ebx
351	@@:	351	@@:
352	mov esi, edi	352	mov esi, edi
353	jmp .add_used	353	jmp .add_used
354		354
355	.error_unlock:	355	.error_unlock:
356	spin_unlock_irqrestore heap_mutex	356	spin_unlock_irqrestore heap_mutex
357	.error:	357	.error:
358	xor eax, eax	358	xor eax, eax
359	pop edi	359	pop edi
360	pop esi	360	pop esi
361	pop ebx	361	pop ebx
362	ret	362	ret
363	endp	363	endp
364		364
365	align 4	365	align 4
366	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword	366	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
367		367
368	spin_lock_irqsave heap_mutex	368	spin_lock_irqsave heap_mutex
369		369
370	mov eax, [base]	370	mov eax, [base]
371		371
372	call md.del_from_used	372	call md.del_from_used
373	test esi, esi	373	test esi, esi
374	jz .fail	374	jz .fail
375		375
376	mov eax, [esi + MEM_BLOCK.size]	376	mov eax, [esi + MEM_BLOCK.size]
377	add [heap_free], eax	377	add [heap_free], eax
378		378
379	mov edi, [esi + MEM_BLOCK.next_block]	379	mov edi, [esi + MEM_BLOCK.next_block]
380	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE	380	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
381	jne .prev	381	jne .prev
382		382
383	list_del edi	383	list_del edi
384		384
385	mov edx, [edi + MEM_BLOCK.next_block]	385	mov edx, [edi + MEM_BLOCK.next_block]
386	mov [esi + MEM_BLOCK.next_block], edx	386	mov [esi + MEM_BLOCK.next_block], edx
387	mov [edx + MEM_BLOCK.prev_block], esi	387	mov [edx + MEM_BLOCK.prev_block], esi
388	mov ecx, [edi + MEM_BLOCK.size]	388	mov ecx, [edi + MEM_BLOCK.size]
389	add [esi + MEM_BLOCK.size], ecx	389	add [esi + MEM_BLOCK.size], ecx
390		390
391	calc_index ecx	391	calc_index ecx
392		392
393	lea edx, [mem_block_list + ecx*8]	393	lea edx, [mem_block_list + ecx*8]
394	cmp edx, [edx]	394	cmp edx, [edx]
395	jne @F	395	jne @F
396	btr [mem_block_mask], ecx	396	btr [mem_block_mask], ecx
397	@@:	397	@@:
398	mov eax, edi	398	mov eax, edi
399	call free_mem_block	399	call free_mem_block
400	.prev:	400	.prev:
401	mov edi, [esi + MEM_BLOCK.prev_block]	401	mov edi, [esi + MEM_BLOCK.prev_block]
402	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE	402	cmp [edi + MEM_BLOCK.flags], MEM_BLOCK_FREE
403	jne .insert	403	jne .insert
404		404
405	mov edx, [esi + MEM_BLOCK.next_block]	405	mov edx, [esi + MEM_BLOCK.next_block]
406	mov [edi + MEM_BLOCK.next_block], edx	406	mov [edi + MEM_BLOCK.next_block], edx
407	mov [edx + MEM_BLOCK.prev_block], edi	407	mov [edx + MEM_BLOCK.prev_block], edi
408		408
409	mov eax, esi	409	mov eax, esi
410	call free_mem_block	410	call free_mem_block
411		411
412	mov ecx, [edi + MEM_BLOCK.size]	412	mov ecx, [edi + MEM_BLOCK.size]
413	mov eax, [esi + MEM_BLOCK.size]	413	mov eax, [esi + MEM_BLOCK.size]
414	add eax, ecx	414	add eax, ecx
415	mov [edi + MEM_BLOCK.size], eax	415	mov [edi + MEM_BLOCK.size], eax
416		416
417	calc_index eax ;new index	417	calc_index eax ;new index
418	calc_index ecx ;old index	418	calc_index ecx ;old index
419	cmp eax, ecx	419	cmp eax, ecx
420	je .m_eq	420	je .m_eq
421		421
422	push ecx	422	push ecx
423	list_del edi	423	list_del edi
424	pop ecx	424	pop ecx
425		425
426	lea edx, [mem_block_list + ecx*8]	426	lea edx, [mem_block_list + ecx*8]
427	cmp edx, [edx]	427	cmp edx, [edx]
428	jne .add_block	428	jne .add_block
429	btr [mem_block_mask], ecx	429	btr [mem_block_mask], ecx
430		430
431	.add_block:	431	.add_block:
432	bts [mem_block_mask], eax	432	bts [mem_block_mask], eax
433	lea edx, [mem_block_list + eax*8]	433	lea edx, [mem_block_list + eax*8]
434	list_add edi, edx	434	list_add edi, edx
435	.m_eq:	435	.m_eq:
436	spin_unlock_irqrestore heap_mutex	436	spin_unlock_irqrestore heap_mutex
437	xor eax, eax	437	xor eax, eax
438	not eax	438	not eax
439	ret	439	ret
440	.insert:	440	.insert:
441	mov [esi + MEM_BLOCK.flags], MEM_BLOCK_FREE	441	mov [esi + MEM_BLOCK.flags], MEM_BLOCK_FREE
442	mov eax, [esi + MEM_BLOCK.size]	442	mov eax, [esi + MEM_BLOCK.size]
443	calc_index eax	443	calc_index eax
444	mov edi, esi	444	mov edi, esi
445	jmp .add_block	445	jmp .add_block
446		446
447	.fail:	447	.fail:
448	spin_unlock_irqrestore heap_mutex	448	spin_unlock_irqrestore heap_mutex
449	xor eax, eax	449	xor eax, eax
450	ret	450	ret
451	endp	451	endp
452		452
453	align 4	453	align 4
454	proc kernel_alloc stdcall, size:dword	454	proc kernel_alloc stdcall, size:dword
455	locals	455	locals
456	lin_addr dd ?	456	lin_addr dd ?
457	pages_count dd ?	457	pages_count dd ?
458	endl	458	endl
459		459
460	push ebx	460	push ebx
461	push edi	461	push edi
462		462
463	mov eax, [size]	463	mov eax, [size]
464	add eax, 4095	464	add eax, PAGE_SIZE-1
465	and eax, not 4095;	465	and eax, -PAGE_SIZE;
466	mov [size], eax	466	mov [size], eax
467	and eax, eax	467	and eax, eax
468	jz .err	468	jz .err
469	mov ebx, eax	469	mov ebx, eax
470	shr ebx, 12	470	shr ebx, 12
471	mov [pages_count], ebx	471	mov [pages_count], ebx
472		472
473	stdcall alloc_kernel_space, eax	473	stdcall alloc_kernel_space, eax
474	mov [lin_addr], eax	474	mov [lin_addr], eax
475	mov ebx, [pages_count]	475	mov ebx, [pages_count]
476	test eax, eax	476	test eax, eax
477	jz .err	477	jz .err
478		478
479	mov edx, eax	479	mov edx, eax
480		480
481	shr ebx, 3	481	shr ebx, 3
482	jz .tail	482	jz .tail
483		483
484	shl ebx, 3	484	shl ebx, 3
485	stdcall alloc_pages, ebx	485	stdcall alloc_pages, ebx
486	test eax, eax	486	test eax, eax
487	jz .err	487	jz .err
488		488
489	mov ecx, ebx	489	mov ecx, ebx
490	or eax, PG_GLOBAL + PG_SWR	490	or eax, PG_GLOBAL + PG_SWR
491	mov ebx, [lin_addr]	491	mov ebx, [lin_addr]
492	call commit_pages	492	call commit_pages
493		493
494	mov edx, ebx ; this dirty hack	494	mov edx, ebx ; this dirty hack
495	.tail:	495	.tail:
496	mov ebx, [pages_count]	496	mov ebx, [pages_count]
497	and ebx, 7	497	and ebx, 7
498	jz .end	498	jz .end
499	@@:	499	@@:
500	call alloc_page	500	call alloc_page

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc @ 425 – Rev 9828 → 9900