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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3500 $
 
 
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
 
           mov ecx, heap_mutex
           call mutex_lock
 
           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
 
           mov ecx, heap_mutex
           call mutex_unlock
           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:
           mov ecx, heap_mutex
           call mutex_unlock
.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
 
           mov ecx, heap_mutex
           call mutex_lock
 
           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:
           mov ecx, heap_mutex
           call mutex_unlock
           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:
           mov ecx, heap_mutex
           call mutex_unlock
           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
 
           mov ecx, heap_mutex
           call mutex_lock
 
           mov eax, [base]
           call md.find_used
 
           mov ecx, heap_mutex
           cmp [esi+block_flags], USED_BLOCK
           jne .fail
 
           call mutex_unlock
 
           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:
           call mutex_unlock
           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 ?
 
.unmap:
        mov     eax, [edx]              ; get page addres
        test    al, 1                   ; page mapped ?
        jz      @F
        test    eax, PG_SHARED          ; page shared ?
        jnz     @F
        mov     [page_tabs+edx*4], 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 2465	Rev 3500
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: 2465 $	8	$Revision: 3500 $
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 [edi+list_fd], eax	157	mov [ecx+list_fd], eax
158	mov [edi+list_bk], eax	158	mov [ecx+list_bk], eax
159	mov [edi+block_base], eax	159	mov [ecx+block_base], eax
160	mov [edi+block_size], eax	160	mov [ecx+block_size], eax
161	mov [edi+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	287	mov ecx, heap_mutex
288	call mutex_lock	288	call mutex_lock
289		289
290	mov eax, [size]	290	mov eax, [size]
291		291
292	call get_small_block ; eax	292	call get_small_block ; eax
293	test edi, edi	293	test edi, edi
294	jz .error_unlock	294	jz .error_unlock
295		295
296	cmp [edi+block_flags], FREE_BLOCK	296	cmp [edi+block_flags], FREE_BLOCK
297	jne .error_unlock	297	jne .error_unlock
298		298
299	mov [block_ind], ebx ;index of allocated block	299	mov [block_ind], ebx ;index of allocated block
300		300
301	mov eax, [edi+block_size]	301	mov eax, [edi+block_size]
302	cmp eax, [size]	302	cmp eax, [size]
303	je .m_eq_size	303	je .m_eq_size
304		304
305	mov esi, [next_memblock] ;new memory block	305	mov esi, [next_memblock] ;new memory block
306	test esi, esi	306	test esi, esi
307	jz .error_unlock	307	jz .error_unlock
308		308
309	dec [free_blocks]	309	dec [free_blocks]
310	mov eax, [esi]	310	mov eax, [esi]
311	mov [next_memblock], eax	311	mov [next_memblock], eax
312		312
313	mov [esi+block_next], edi	313	mov [esi+block_next], edi
314	mov eax, [edi+block_prev]	314	mov eax, [edi+block_prev]
315	mov [esi+block_prev], eax	315	mov [esi+block_prev], eax
316	mov [edi+block_prev], esi	316	mov [edi+block_prev], esi
317	mov [esi+list_fd], 0	317	mov [esi+list_fd], 0
318	mov [esi+list_bk], 0	318	mov [esi+list_bk], 0
319	mov [eax+block_next], esi	319	mov [eax+block_next], esi
320		320
321	mov ebx, [edi+block_base]	321	mov ebx, [edi+block_base]
322	mov [esi+block_base], ebx	322	mov [esi+block_base], ebx
323	mov edx, [size]	323	mov edx, [size]
324	mov [esi+block_size], edx	324	mov [esi+block_size], edx
325	add [edi+block_base], edx	325	add [edi+block_base], edx
326	sub [edi+block_size], edx	326	sub [edi+block_size], edx
327		327
328	mov eax, [edi+block_size]	328	mov eax, [edi+block_size]
329	calc_index eax	329	calc_index eax
330	cmp eax, [block_ind]	330	cmp eax, [block_ind]
331	je .add_used	331	je .add_used
332		332
333	list_del edi	333	list_del edi
334		334
335	mov ecx, [block_ind]	335	mov ecx, [block_ind]
336	lea edx, [mem_block_list+ecx*8]	336	lea edx, [mem_block_list+ecx*8]
337	cmp edx, [edx]	337	cmp edx, [edx]
338	jnz @f	338	jnz @f
339	btr [mem_block_mask], ecx	339	btr [mem_block_mask], ecx
340	@@:	340	@@:
341	bts [mem_block_mask], eax	341	bts [mem_block_mask], eax
342	lea edx, [mem_block_list+eax*8] ;edx= list head	342	lea edx, [mem_block_list+eax*8] ;edx= list head
343	list_add edi, edx	343	list_add edi, edx
344	.add_used:	344	.add_used:
345		345
346	call md.add_to_used	346	call md.add_to_used
347		347
348	mov ecx, heap_mutex	348	mov ecx, heap_mutex
349	call mutex_unlock	349	call mutex_unlock
350	mov eax, [esi+block_base]	350	mov eax, [esi+block_base]
351	pop edi	351	pop edi
352	pop esi	352	pop esi
353	pop ebx	353	pop ebx
354	ret	354	ret
355		355
356	.m_eq_size:	356	.m_eq_size:
357	list_del edi	357	list_del edi
358	lea edx, [mem_block_list+ebx*8]	358	lea edx, [mem_block_list+ebx*8]
359	cmp edx, [edx]	359	cmp edx, [edx]
360	jnz @f	360	jnz @f
361	btr [mem_block_mask], ebx	361	btr [mem_block_mask], ebx
362	@@:	362	@@:
363	mov esi, edi	363	mov esi, edi
364	jmp .add_used	364	jmp .add_used
365		365
366	.error_unlock:	366	.error_unlock:
367	mov ecx, heap_mutex	367	mov ecx, heap_mutex
368	call mutex_unlock	368	call mutex_unlock
369	.error:	369	.error:
370	xor eax, eax	370	xor eax, eax
371	pop edi	371	pop edi
372	pop esi	372	pop esi
373	pop ebx	373	pop ebx
374	ret	374	ret
375	endp	375	endp
376		376
377	align 4	377	align 4
378	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword	378	proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
379		379
380	mov ecx, heap_mutex	380	mov ecx, heap_mutex
381	call mutex_lock	381	call mutex_lock
382		382
383	mov eax, [base]	383	mov eax, [base]
384		384
385	call md.del_from_used	385	call md.del_from_used
386	test esi, esi	386	test esi, esi
387	jz .fail	387	jz .fail
388		388
389	mov eax, [esi+block_size]	389	mov eax, [esi+block_size]
390	add [heap_free], eax	390	add [heap_free], eax
391		391
392	mov edi, [esi+block_next]	392	mov edi, [esi+block_next]
393	cmp [edi+block_flags], FREE_BLOCK	393	cmp [edi+block_flags], FREE_BLOCK
394	jne .prev	394	jne .prev
395		395
396	list_del edi	396	list_del edi
397		397
398	mov edx, [edi+block_next]	398	mov edx, [edi+block_next]
399	mov [esi+block_next], edx	399	mov [esi+block_next], edx
400	mov [edx+block_prev], esi	400	mov [edx+block_prev], esi
401	mov ecx, [edi+block_size]	401	mov ecx, [edi+block_size]
402	add [esi+block_size], ecx	402	add [esi+block_size], ecx
403		403
404	calc_index ecx	404	calc_index ecx
405		405
406	lea edx, [mem_block_list+ecx*8]	406	lea edx, [mem_block_list+ecx*8]
407	cmp edx, [edx]	407	cmp edx, [edx]
408	jne @F	408	jne @F
409	btr [mem_block_mask], ecx	409	btr [mem_block_mask], ecx
410	@@:	410	@@:
411	mov eax, edi	411	mov eax, edi
412	call free_mem_block	412	call free_mem_block
413	.prev:	413	.prev:
414	mov edi, [esi+block_prev]	414	mov edi, [esi+block_prev]
415	cmp [edi+block_flags], FREE_BLOCK	415	cmp [edi+block_flags], FREE_BLOCK
416	jne .insert	416	jne .insert
417		417
418	mov edx, [esi+block_next]	418	mov edx, [esi+block_next]
419	mov [edi+block_next], edx	419	mov [edi+block_next], edx
420	mov [edx+block_prev], edi	420	mov [edx+block_prev], edi
421		421
422	mov eax, esi	422	mov eax, esi
423	call free_mem_block	423	call free_mem_block
424		424
425	mov ecx, [edi+block_size]	425	mov ecx, [edi+block_size]
426	mov eax, [esi+block_size]	426	mov eax, [esi+block_size]
427	add eax, ecx	427	add eax, ecx
428	mov [edi+block_size], eax	428	mov [edi+block_size], eax
429		429
430	calc_index eax ;new index	430	calc_index eax ;new index
431	calc_index ecx ;old index	431	calc_index ecx ;old index
432	cmp eax, ecx	432	cmp eax, ecx
433	je .m_eq	433	je .m_eq
434		434
435	push ecx	435	push ecx
436	list_del edi	436	list_del edi
437	pop ecx	437	pop ecx
438		438
439	lea edx, [mem_block_list+ecx*8]	439	lea edx, [mem_block_list+ecx*8]
440	cmp edx, [edx]	440	cmp edx, [edx]
441	jne .add_block	441	jne .add_block
442	btr [mem_block_mask], ecx	442	btr [mem_block_mask], ecx
-		443
443	.add_block:	444	.add_block:
444	bts [mem_block_mask], eax	445	bts [mem_block_mask], eax
445	lea edx, [mem_block_list+eax*8]	446	lea edx, [mem_block_list+eax*8]
446	list_add edi, edx	447	list_add edi, edx
447	.m_eq:	448	.m_eq:
448	mov ecx, heap_mutex	449	mov ecx, heap_mutex
449	call mutex_unlock	450	call mutex_unlock
450	xor eax, eax	451	xor eax, eax
451	not eax	452	not eax
452	ret	453	ret
453	.insert:	454	.insert:
454	mov [esi+block_flags], FREE_BLOCK	455	mov [esi+block_flags], FREE_BLOCK
455	mov eax, [esi+block_size]	456	mov eax, [esi+block_size]
456	calc_index eax	457	calc_index eax
457	mov edi, esi	458	mov edi, esi
458	jmp .add_block	459	jmp .add_block
459		460
460	.fail:	461	.fail:
461	mov ecx, heap_mutex	462	mov ecx, heap_mutex
462	call mutex_unlock	463	call mutex_unlock
463	xor eax, eax	464	xor eax, eax
464	ret	465	ret
465	endp	466	endp
466		467
467	align 4	468	align 4
468	proc kernel_alloc stdcall, size:dword	469	proc kernel_alloc stdcall, size:dword
469	locals	470	locals
470	lin_addr dd ?	471	lin_addr dd ?
471	pages_count dd ?	472	pages_count dd ?
472	endl	473	endl
473		474
474	push ebx	475	push ebx
475	push edi	476	push edi
476		477
477	mov eax, [size]	478	mov eax, [size]
478	add eax, 4095	479	add eax, 4095
479	and eax, not 4095;	480	and eax, not 4095;
480	mov [size], eax	481	mov [size], eax
481	and eax, eax	482	and eax, eax
482	jz .err	483	jz .err
483	mov ebx, eax	484	mov ebx, eax
484	shr ebx, 12	485	shr ebx, 12
485	mov [pages_count], ebx	486	mov [pages_count], ebx
486		487
487	stdcall alloc_kernel_space, eax	488	stdcall alloc_kernel_space, eax
488	test eax, eax	489	test eax, eax
489	jz .err	490	jz .err
490	mov [lin_addr], eax	491	mov [lin_addr], eax
491		492
492	mov ecx, [pages_count]	493	mov ecx, [pages_count]
493	mov edx, eax	494	mov edx, eax
494	mov ebx, ecx	495	mov ebx, ecx
495		496
496	shr ecx, 3	497	shr ecx, 3
497	jz .next	498	jz .next
498		499
499	and ebx, not 7	500	and ebx, not 7

Subversion Repositories Kolibri OS

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