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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6339 $
 
 
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
 
        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+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
        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+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     ;;;;;;;;;;;;;;;;;
 
HEAP_TOP  equ 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, 9
        mov     ecx, eax
        sub     eax, PAGE_SIZE
        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     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, dword [ebx+PROC.heap_base] ; heap_base
        mov     edi, dword [ebx+PROC.heap_top]  ; heap_top
.scan:
        cmp     esi, edi
        jae     .m_exit
 
        mov     ebx, esi
        shr     ebx, 12
        mov     eax, [page_tabs+ebx*8]
        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*8], eax
@@:
        or      ecx, USED_BLOCK
        mov     [page_tabs+ebx*8], ecx
        shr     ecx, 12
        inc     ebx
        dec     ecx
        jz      .no
@@:
        mov     dword [page_tabs+ebx*8], 2
        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, USED_BLOCK
        jz      .m_exit
 
        and     eax, 0xFFFFF000
.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*8]
        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, 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*8], 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*8], eax
        shr     eax, 12
        dec     eax
        jz      .second_nofill
        inc     ebx
.fill:
        mov     dword [page_tabs+ebx*8], 2
        inc     ebx
        dec     eax
        jnz     .fill
 
.second_nofill:
        sub     ecx, edx
        jz      .nothird
        or      cl, FREE_BLOCK
        mov     [page_tabs+ebx*8], 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)*8]
        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)*8], eax
        sub     ecx, 4096
        mov     ebx, ecx
        shr     ecx, 12
        jz      .released
.release:
        xor     eax, eax
        xchg    eax, [page_tabs+esi*8]
        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*8]
        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*8]  ; 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*8-8]      ; block end ptr
        lea     eax, [edx+ecx*8]        ; 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, 8
        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*8]
        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*8]
        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*8], 0
        add     eax, ebx
        and     eax, not 4095
        or      eax, FREE_BLOCK
        mov     [page_tabs+esi*8], 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*8]
        test    dl, USED_BLOCK
        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, 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*8]
        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*8]
        and     eax, not 0xFFF
        mov     edx, [current_process]
        mov     ebx, [edx+PROC.mem_used]
        sub     ebx, eax
        add     ebx, 0x1000
        or      al, FREE_BLOCK
        mov     [page_tabs+ecx*8], 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, USED_BLOCK
        xchg    [page_tabs+ecx*8], 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*8]
        test    al, USED_BLOCK
        jnz     .merge_done
        and     dword [page_tabs+edx*8], 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*8], 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*8]
        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*8], eax
@@:
        mov     eax, ebx
        sub     eax, ecx
        shl     eax, 12
        or      al, USED_BLOCK
        mov     [page_tabs+ecx*8], eax
        lea     eax, [ecx+1]
        shl     eax, 12
        push    eax
        push    edi
        lea     edi, [page_tabs+edx*8]
        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*8]
        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*8], eax
        pop     esi
@@:
        mov     eax, ebx
        shl     eax, 12
        or      al, USED_BLOCK
        mov     [page_tabs+esi*8], eax
        inc     esi
        mov     eax, esi
        shl     eax, 12
        push    eax
        mov     eax, [page_tabs+ecx*8]
        and     eax, not 0xFFF
        or      al, FREE_BLOCK
        sub     edx, ecx
        mov     [page_tabs+ecx*8], eax
        inc     ecx
        dec     ebx
        dec     edx
        jz      .no
@@:
        xor     eax, eax
        xchg    eax, [page_tabs+ecx*8]
        mov     [page_tabs+esi*8], 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*8], 2
        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      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, 9
 
        mov     esi, [esi+SMEM.base]
        shr     esi, 9
        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
        movsd
        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 5596	Rev 6339
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 5596 $	8	$Revision: 6339 $
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		132
133	or eax, PG_SWR	133	or eax, PG_SWR
134	mov ebx, HEAP_BASE	134	mov ebx, HEAP_BASE
135	mov ecx, 32	135	mov ecx, 32
136	call commit_pages	136	call commit_pages
137		137
138	mov edi, HEAP_BASE ;descriptors	138	mov edi, HEAP_BASE ;descriptors
139	mov ebx, HEAP_BASE+sizeof.MEM_BLOCK ;free space	139	mov ebx, HEAP_BASE+sizeof.MEM_BLOCK ;free space
140	mov ecx, HEAP_BASE+sizeof.MEM_BLOCK*2 ;terminator	140	mov ecx, HEAP_BASE+sizeof.MEM_BLOCK*2 ;terminator
141		141
142	xor eax, eax	142	xor eax, eax
143	mov [edi+block_next], ebx	143	mov [edi+block_next], ebx
144	mov [edi+block_prev], eax	144	mov [edi+block_prev], eax
145	mov [edi+list_fd], eax	145	mov [edi+list_fd], eax
146	mov [edi+list_bk], eax	146	mov [edi+list_bk], eax
147	mov [edi+block_base], HEAP_BASE	147	mov [edi+block_base], HEAP_BASE
148	mov [edi+block_size], 4096*sizeof.MEM_BLOCK	148	mov [edi+block_size], 4096*sizeof.MEM_BLOCK
149	mov [edi+block_flags], USED_BLOCK	149	mov [edi+block_flags], USED_BLOCK
150		150
151	mov [ecx+block_next], eax	151	mov [ecx+block_next], eax
152	mov [ecx+block_prev], ebx	152	mov [ecx+block_prev], ebx
153	mov [ecx+list_fd], eax	153	mov [ecx+list_fd], eax
154	mov [ecx+list_bk], eax	154	mov [ecx+list_bk], eax
155	mov [ecx+block_base], eax	155	mov [ecx+block_base], eax
156	mov [ecx+block_size], eax	156	mov [ecx+block_size], eax
157	mov [ecx+block_flags], USED_BLOCK	157	mov [ecx+block_flags], USED_BLOCK
158		158
159	mov [ebx+block_next], ecx	159	mov [ebx+block_next], ecx
160	mov [ebx+block_prev], edi	160	mov [ebx+block_prev], edi
161	mov [ebx+block_base], HEAP_BASE+4096*sizeof.MEM_BLOCK	161	mov [ebx+block_base], HEAP_BASE+4096*sizeof.MEM_BLOCK
162		162
163	mov ecx, [pg_data.kernel_pages]	163	mov ecx, [pg_data.kernel_pages]
164	shl ecx, 12	164	shl ecx, 12
165	sub ecx, HEAP_BASE-OS_BASE+4096*sizeof.MEM_BLOCK	165	sub ecx, HEAP_BASE-OS_BASE+4096*sizeof.MEM_BLOCK
166	mov [heap_size], ecx	166	mov [heap_size], ecx
167	mov [heap_free], ecx	167	mov [heap_free], ecx
168	mov [ebx+block_size], ecx	168	mov [ebx+block_size], ecx
169	mov [ebx+block_flags], FREE_BLOCK	169	mov [ebx+block_flags], FREE_BLOCK
170		170
171	mov [mem_block_mask], eax	171	mov [mem_block_mask], eax
172	mov [mem_block_mask+4], 0x80000000	172	mov [mem_block_mask+4], 0x80000000
173		173
174	mov ecx, mem_block_list+63*8	174	mov ecx, mem_block_list+63*8
175	list_add ebx, ecx	175	list_add ebx, ecx
176		176
177	mov ecx, 4096-3-1	177	mov ecx, 4096-3-1
178	mov eax, HEAP_BASE+sizeof.MEM_BLOCK*4	178	mov eax, HEAP_BASE+sizeof.MEM_BLOCK*4
179		179
180	mov [next_memblock], HEAP_BASE+sizeof.MEM_BLOCK *3	180	mov [next_memblock], HEAP_BASE+sizeof.MEM_BLOCK *3
181	@@:	181	@@:
182	mov [eax-sizeof.MEM_BLOCK], eax	182	mov [eax-sizeof.MEM_BLOCK], eax
183	add eax, sizeof.MEM_BLOCK	183	add eax, sizeof.MEM_BLOCK
184	loop @B	184	loop @B
185		185
186	mov [eax-sizeof.MEM_BLOCK], dword 0	186	mov [eax-sizeof.MEM_BLOCK], dword 0
187		187
188	mov ecx, heap_mutex	188	mov ecx, heap_mutex
189	call mutex_init	189	call mutex_init
190	mov [heap_blocks], 4094	190	mov [heap_blocks], 4094
191	mov [free_blocks], 4093	191	mov [free_blocks], 4093
192	ret	192	ret
193	endp	193	endp
194		194
195	; param	195	; param
196	; eax= required size	196	; eax= required size
197	;	197	;
198	; retval	198	; retval
199	; edi= memory block descriptor	199	; edi= memory block descriptor
200	; ebx= descriptor index	200	; ebx= descriptor index
201		201
202	align 4	202	align 4
203	get_small_block:	203	get_small_block:
204	mov ecx, eax	204	mov ecx, eax
205	shr ecx, 12	205	shr ecx, 12
206	dec ecx	206	dec ecx
207	cmp ecx, 63	207	cmp ecx, 63
208	jle .get_index	208	jle .get_index
209	mov ecx, 63	209	mov ecx, 63
210	.get_index:	210	.get_index:
211	lea esi, [mem_block_mask]	211	lea esi, [mem_block_mask]
212	xor ebx, ebx	212	xor ebx, ebx
213	or edx, -1	213	or edx, -1
214		214
215	cmp ecx, 32	215	cmp ecx, 32
216	jb .bit_test	216	jb .bit_test
217		217
218	sub ecx, 32	218	sub ecx, 32
219	add ebx, 32	219	add ebx, 32
220	add esi, 4	220	add esi, 4
221	.bit_test:	221	.bit_test:
222	shl edx, cl	222	shl edx, cl
223	and edx, [esi]	223	and edx, [esi]
224	.find:	224	.find:
225	bsf edi, edx	225	bsf edi, edx
226	jz .high_mask	226	jz .high_mask
227	add ebx, edi	227	add ebx, edi
228	lea ecx, [mem_block_list+ebx*8]	228	lea ecx, [mem_block_list+ebx*8]
229	mov edi, ecx	229	mov edi, ecx
230	.next:	230	.next:
231	mov edi, [edi+list_fd]	231	mov edi, [edi+list_fd]
232	cmp edi, ecx	232	cmp edi, ecx
233	je .err	233	je .err
234	cmp eax, [edi+block_size]	234	cmp eax, [edi+block_size]
235	ja .next	235	ja .next
236	ret	236	ret
237	.err:	237	.err:
238	xor edi, edi	238	xor edi, edi
239	ret	239	ret
240		240
241	.high_mask:	241	.high_mask:
242	add esi, 4	242	add esi, 4
243	cmp esi, mem_block_mask+8	243	cmp esi, mem_block_mask+8
244	jae .err	244	jae .err
245	add ebx, 32	245	add ebx, 32
246	mov edx, [esi]	246	mov edx, [esi]
247	jmp .find	247	jmp .find
248		248
249		249
250	align 4	250	align 4
251	free_mem_block:	251	free_mem_block:
252	mov ebx, [next_memblock]	252	mov ebx, [next_memblock]
253	mov [eax], ebx	253	mov [eax], ebx
254	mov [next_memblock], eax	254	mov [next_memblock], eax
255	xor ebx, ebx	255	xor ebx, ebx
256		256
257	mov dword [eax+4], ebx	257	mov dword [eax+4], ebx
258	mov dword [eax+8], ebx	258	mov dword [eax+8], ebx
259	mov dword [eax+12], ebx	259	mov dword [eax+12], ebx
260	mov dword [eax+16], ebx	260	mov dword [eax+16], ebx
261	; mov dword [eax+20], 0 ;don't clear block size	261	; mov dword [eax+20], 0 ;don't clear block size
262	mov dword [eax+24], ebx	262	mov dword [eax+24], ebx
263	mov dword [eax+28], ebx	263	mov dword [eax+28], ebx
264	inc [free_blocks]	264	inc [free_blocks]
265	ret	265	ret
266		266
267	align 4	267	align 4
268	proc alloc_kernel_space stdcall, size:dword	268	proc alloc_kernel_space stdcall, size:dword
269	local block_ind:DWORD	269	local block_ind:DWORD
270		270
271	push ebx	271	push ebx
272	push esi	272	push esi
273	push edi	273	push edi
274		274
275	mov eax, [size]	275	mov eax, [size]
276	add eax, 4095	276	add eax, 4095
277	and eax, not 4095	277	and eax, not 4095
278	mov [size], eax	278	mov [size], eax
279		279
280	cmp eax, [heap_free]	280	cmp eax, [heap_free]
281	ja .error	281	ja .error
282		282
283	spin_lock_irqsave heap_mutex	283	spin_lock_irqsave heap_mutex
284		284
285	mov eax, [size]	285	mov eax, [size]
286		286
287	call get_small_block ; eax	287	call get_small_block ; eax
288	test edi, edi	288	test edi, edi
289	jz .error_unlock	289	jz .error_unlock
290		290
291	cmp [edi+block_flags], FREE_BLOCK	291	cmp [edi+block_flags], FREE_BLOCK
292	jne .error_unlock	292	jne .error_unlock
293		293
294	mov [block_ind], ebx ;index of allocated block	294	mov [block_ind], ebx ;index of allocated block
295		295
296	mov eax, [edi+block_size]	296	mov eax, [edi+block_size]
297	cmp eax, [size]	297	cmp eax, [size]
298	je .m_eq_size	298	je .m_eq_size
299		299
300	mov esi, [next_memblock] ;new memory block	300	mov esi, [next_memblock] ;new memory block
301	test esi, esi	301	test esi, esi
302	jz .error_unlock	302	jz .error_unlock
303		303
304	dec [free_blocks]	304	dec [free_blocks]
305	mov eax, [esi]	305	mov eax, [esi]
306	mov [next_memblock], eax	306	mov [next_memblock], eax
307		307
308	mov [esi+block_next], edi	308	mov [esi+block_next], edi
309	mov eax, [edi+block_prev]	309	mov eax, [edi+block_prev]
310	mov [esi+block_prev], eax	310	mov [esi+block_prev], eax
311	mov [edi+block_prev], esi	311	mov [edi+block_prev], esi
312	mov [esi+list_fd], 0	312	mov [esi+list_fd], 0
313	mov [esi+list_bk], 0	313	mov [esi+list_bk], 0
314	mov [eax+block_next], esi	314	mov [eax+block_next], esi
315		315
316	mov ebx, [edi+block_base]	316	mov ebx, [edi+block_base]
317	mov [esi+block_base], ebx	317	mov [esi+block_base], ebx
318	mov edx, [size]	318	mov edx, [size]
319	mov [esi+block_size], edx	319	mov [esi+block_size], edx
320	add [edi+block_base], edx	320	add [edi+block_base], edx
321	sub [edi+block_size], edx	321	sub [edi+block_size], edx
322		322
323	mov eax, [edi+block_size]	323	mov eax, [edi+block_size]
324	calc_index eax	324	calc_index eax
325	cmp eax, [block_ind]	325	cmp eax, [block_ind]
326	je .add_used	326	je .add_used
327		327
328	list_del edi	328	list_del edi
329		329
330	mov ecx, [block_ind]	330	mov ecx, [block_ind]
331	lea edx, [mem_block_list+ecx*8]	331	lea edx, [mem_block_list+ecx*8]
332	cmp edx, [edx]	332	cmp edx, [edx]
333	jnz @f	333	jnz @f
334	btr [mem_block_mask], ecx	334	btr [mem_block_mask], ecx
335	@@:	335	@@:
336	bts [mem_block_mask], eax	336	bts [mem_block_mask], eax
337	lea edx, [mem_block_list+eax*8] ;edx= list head	337	lea edx, [mem_block_list+eax*8] ;edx= list head
338	list_add edi, edx	338	list_add edi, edx
339	.add_used:	339	.add_used:
340		340
341	call md.add_to_used	341	call md.add_to_used
342		342
343	spin_unlock_irqrestore heap_mutex	343	spin_unlock_irqrestore heap_mutex
344	mov eax, [esi+block_base]	344	mov eax, [esi+block_base]
345	pop edi	345	pop edi
346	pop esi	346	pop esi
347	pop ebx	347	pop ebx
348	ret	348	ret
349		349
350	.m_eq_size:	350	.m_eq_size:
351	list_del edi	351	list_del edi
352	lea edx, [mem_block_list+ebx*8]	352	lea edx, [mem_block_list+ebx*8]
353	cmp edx, [edx]	353	cmp edx, [edx]
354	jnz @f	354	jnz @f
355	btr [mem_block_mask], ebx	355	btr [mem_block_mask], ebx
356	@@:	356	@@:
357	mov esi, edi	357	mov esi, edi
358	jmp .add_used	358	jmp .add_used
359		359
360	.error_unlock:	360	.error_unlock:
361	spin_unlock_irqrestore heap_mutex	361	spin_unlock_irqrestore heap_mutex
362	.error:	362	.error:
363	xor eax, eax	363	xor eax, eax
364	pop edi	364	pop edi
365	pop esi	365	pop esi
366	pop ebx	366	pop ebx
367	ret	367	ret
368	endp	368	endp
369		369
370	align 4	370	align 4
371	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword	371	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
372		372
373	spin_lock_irqsave heap_mutex	373	spin_lock_irqsave heap_mutex
374		374
375	mov eax, [base]	375	mov eax, [base]
376		376
377	call md.del_from_used	377	call md.del_from_used
378	test esi, esi	378	test esi, esi
379	jz .fail	379	jz .fail
380		380
381	mov eax, [esi+block_size]	381	mov eax, [esi+block_size]
382	add [heap_free], eax	382	add [heap_free], eax
383		383
384	mov edi, [esi+block_next]	384	mov edi, [esi+block_next]
385	cmp [edi+block_flags], FREE_BLOCK	385	cmp [edi+block_flags], FREE_BLOCK
386	jne .prev	386	jne .prev
387		387
388	list_del edi	388	list_del edi
389		389
390	mov edx, [edi+block_next]	390	mov edx, [edi+block_next]
391	mov [esi+block_next], edx	391	mov [esi+block_next], edx
392	mov [edx+block_prev], esi	392	mov [edx+block_prev], esi
393	mov ecx, [edi+block_size]	393	mov ecx, [edi+block_size]
394	add [esi+block_size], ecx	394	add [esi+block_size], ecx
395		395
396	calc_index ecx	396	calc_index ecx
397		397
398	lea edx, [mem_block_list+ecx*8]	398	lea edx, [mem_block_list+ecx*8]
399	cmp edx, [edx]	399	cmp edx, [edx]
400	jne @F	400	jne @F
401	btr [mem_block_mask], ecx	401	btr [mem_block_mask], ecx
402	@@:	402	@@:
403	mov eax, edi	403	mov eax, edi
404	call free_mem_block	404	call free_mem_block
405	.prev:	405	.prev:
406	mov edi, [esi+block_prev]	406	mov edi, [esi+block_prev]
407	cmp [edi+block_flags], FREE_BLOCK	407	cmp [edi+block_flags], FREE_BLOCK
408	jne .insert	408	jne .insert
409		409
410	mov edx, [esi+block_next]	410	mov edx, [esi+block_next]
411	mov [edi+block_next], edx	411	mov [edi+block_next], edx
412	mov [edx+block_prev], edi	412	mov [edx+block_prev], edi
413		413
414	mov eax, esi	414	mov eax, esi
415	call free_mem_block	415	call free_mem_block
416		416
417	mov ecx, [edi+block_size]	417	mov ecx, [edi+block_size]
418	mov eax, [esi+block_size]	418	mov eax, [esi+block_size]
419	add eax, ecx	419	add eax, ecx
420	mov [edi+block_size], eax	420	mov [edi+block_size], eax
421		421
422	calc_index eax ;new index	422	calc_index eax ;new index
423	calc_index ecx ;old index	423	calc_index ecx ;old index
424	cmp eax, ecx	424	cmp eax, ecx
425	je .m_eq	425	je .m_eq
426		426
427	push ecx	427	push ecx
428	list_del edi	428	list_del edi
429	pop ecx	429	pop ecx
430		430
431	lea edx, [mem_block_list+ecx*8]	431	lea edx, [mem_block_list+ecx*8]
432	cmp edx, [edx]	432	cmp edx, [edx]
433	jne .add_block	433	jne .add_block
434	btr [mem_block_mask], ecx	434	btr [mem_block_mask], ecx
435		435
436	.add_block:	436	.add_block:
437	bts [mem_block_mask], eax	437	bts [mem_block_mask], eax
438	lea edx, [mem_block_list+eax*8]	438	lea edx, [mem_block_list+eax*8]
439	list_add edi, edx	439	list_add edi, edx
440	.m_eq:	440	.m_eq:
441	spin_unlock_irqrestore heap_mutex	441	spin_unlock_irqrestore heap_mutex
442	xor eax, eax	442	xor eax, eax
443	not eax	443	not eax
444	ret	444	ret
445	.insert:	445	.insert:
446	mov [esi+block_flags], FREE_BLOCK	446	mov [esi+block_flags], FREE_BLOCK
447	mov eax, [esi+block_size]	447	mov eax, [esi+block_size]
448	calc_index eax	448	calc_index eax
449	mov edi, esi	449	mov edi, esi
450	jmp .add_block	450	jmp .add_block
451		451
452	.fail:	452	.fail:
453	spin_unlock_irqrestore heap_mutex	453	spin_unlock_irqrestore heap_mutex
454	xor eax, eax	454	xor eax, eax
455	ret	455	ret
456	endp	456	endp
457		457
458	align 4	458	align 4
459	proc kernel_alloc stdcall, size:dword	459	proc kernel_alloc stdcall, size:dword
460	locals	460	locals
461	lin_addr dd ?	461	lin_addr dd ?
462	pages_count dd ?	462	pages_count dd ?
463	endl	463	endl
464		464
465	push ebx	465	push ebx
466	push edi	466	push edi
467		467
468	mov eax, [size]	468	mov eax, [size]
469	add eax, 4095	469	add eax, 4095
470	and eax, not 4095;	470	and eax, not 4095;
471	mov [size], eax	471	mov [size], eax
472	and eax, eax	472	and eax, eax
473	jz .err	473	jz .err
474	mov ebx, eax	474	mov ebx, eax
475	shr ebx, 12	475	shr ebx, 12
476	mov [pages_count], ebx	476	mov [pages_count], ebx
477		477
478	stdcall alloc_kernel_space, eax	478	stdcall alloc_kernel_space, eax
479	mov [lin_addr], eax	479	mov [lin_addr], eax
480	mov ebx, [pages_count]	480	mov ebx, [pages_count]
481	test eax, eax	481	test eax, eax
482	jz .err	482	jz .err
483		483
484	mov edx, eax	484	mov edx, eax
485		485
486	shr ebx, 3	486	shr ebx, 3
487	jz .tail	487	jz .tail
488		488
489	shl ebx, 3	489	shl ebx, 3
490	stdcall alloc_pages, ebx	490	stdcall alloc_pages, ebx
491	test eax, eax	491	test eax, eax
492	jz .err	492	jz .err
493		493
494	mov ecx, ebx	494	mov ecx, ebx
495	or eax, PG_GLOBAL+PG_SWR	495	or eax, PG_GLOBAL+PG_SWR
496	mov ebx, [lin_addr]	496	mov ebx, [lin_addr]
497	call commit_pages	497	call commit_pages
498		498
499	mov edx, ebx ; this dirty hack	499	mov edx, ebx ; this dirty hack
500	.tail:	500	.tail:

Subversion Repositories Kolibri OS

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