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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 3798 → 4391