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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2020. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 7965 $
 
 
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], 4096*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 + 4096*sizeof.MEM_BLOCK
 
        mov     ecx, [pg_data.kernel_pages]
        shl     ecx, 12
        sub     ecx, HEAP_BASE-OS_BASE + 4096*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, 4096-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, 4095
        and     eax, not 4095
        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, 4095
        and     eax, not 4095;
        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, 0x1000
        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, 4095
        and     esi, not 4095
        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, not 4095
        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, 0xFFFFF000
        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, 0xFFF
        and     ebx, not 0xFFF
        add     [edx + PROC.mem_used], ebx
 
        lea     ecx, [edx + PROC.heap_lock]
        call    mutex_unlock
 
        lea     eax, [esi + 4096]
 
        pop     edi
        pop     esi
        pop     ebx
        ret
.test_used:
        test    al, MEM_BLOCK_USED
        jz      .m_exit
 
        and     eax, 0xFFFFF000 ; not PAGESIZE
.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, not 0xFFF
        mov     [address], edx
        sub     edx, 0x1000
        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, 0xFFFFF000
        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, 0x1000
        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, not 0xFFF
        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, 0xFFF
        and     ebx, not 0xFFF
        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, not 4095
        mov     ecx, eax
        or      al, MEM_BLOCK_FREE
        mov     [page_tabs + (esi-1)*4], eax
        sub     ecx, 4096
        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, 4095
        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, not 4095           ; 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, 4096       ; PAGESIZE?
        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, not 4095           ; not (PAGESIZE - 1)    ?
        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 - 0x1000]
        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, not 0xFFF
        mov     edx, [current_process]
        mov     ebx, [edx + PROC.mem_used]
        sub     ebx, eax
        add     ebx, 0x1000
        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, not 0xFFF
        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, 4095
        and     ecx, -4096
        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_TASK]
        shl     ebx, 5
        mov     ebx, [CURRENT_TASK + ebx + 4]
        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, 0xFFFFF000
        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    esi
        push    edi
        pushfd
        cli
 
        mov     esi, [current_slot]
        add     esi, APP_OBJ_OFFSET
.next:
        mov     eax, [esi + APPOBJ.fd]
        test    eax, eax
        jz      @F
 
        cmp     eax, esi
        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
.fail:
        ret
endp


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 7136 → 7965