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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 823 $
 
 
struc MEM_BLOCK
{  .next_block  dd ?
   .prev_block  dd ? ;+4
   .list_fd     dd ? ;+8
   .list_bk     dd ? ;+12
   .base        dd ? ;+16
   .size        dd ? ;+20
   .flags       dd ? ;+24
   .handle      dd ? ;+28
}
 
MEM_LIST_OFFSET equ  8
FREE_BLOCK      equ  4
USED_BLOCK      equ  8
DONT_FREE_BLOCK equ  10h
 
virtual at 0
  MEM_BLOCK MEM_BLOCK
end virtual
 
MEM_BLOCK_SIZE equ 8*4
 
block_next   equ MEM_BLOCK.next_block
block_prev   equ MEM_BLOCK.prev_block
list_fd      equ MEM_BLOCK.list_fd
list_bk      equ MEM_BLOCK.list_bk
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
@@:
}
 
macro remove_from_list op
{          mov edx, [op+list_fd]
           mov ecx, [op+list_bk]
           test edx, edx
           jz @f
           mov [edx+list_bk], ecx
@@:
           test ecx, ecx
           jz @f
           mov [ecx+list_fd], edx
@@:
           mov [op+list_fd],0
           mov [op+list_bk],0
}
 
macro remove_from_free op
{
           remove_from_list op
 
           mov eax, [op+block_size]
           calc_index eax
           cmp [mem_block_list+eax*4], op
           jne @f
           mov [mem_block_list+eax*4], edx
@@:
           cmp [mem_block_list+eax*4], 0
           jne @f
           btr [mem_block_mask], eax
@@:
}
 
macro remove_from_used op
{
           mov edx, [op+list_fd]
           mov ecx, [op+list_bk]
           mov [edx+list_bk], ecx
           mov [ecx+list_fd], edx
           mov [op+list_fd], 0
           mov [op+list_bk], 0
}
 
align 4
proc init_kernel_heap
 
           mov ecx, 64/4
           mov edi, mem_block_list
           xor eax, eax
           cld
           rep stosd
 
           mov ecx, 512/4
           mov edi, mem_block_map
           not eax
           rep stosd
 
           mov [mem_block_start], mem_block_map
           mov [mem_block_end], mem_block_map+512
           mov [mem_block_arr], HEAP_BASE
 
           mov eax, mem_used.fd-MEM_LIST_OFFSET
           mov [mem_used.fd], eax
           mov [mem_used.bk], eax
 
           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
           mov ebx, HEAP_BASE+MEM_BLOCK_SIZE
           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*MEM_BLOCK_SIZE
           mov [edi+block_flags], USED_BLOCK
 
           mov [ebx+block_next], eax
           mov [ebx+block_prev], eax
           mov [ebx+list_fd], eax
           mov [ebx+list_bk], eax
           mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK_SIZE
 
           mov ecx, [MEM_AMOUNT]
           sub ecx, (HEAP_BASE - OS_BASE + 4096*MEM_BLOCK_SIZE)
           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 [mem_block_list+63*4], ebx
           mov byte [mem_block_map], 0xFC
           and [heap_mutex], 0
           mov [heap_blocks], 4095
           mov [free_blocks], 4095
           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
           mov edi, [mem_block_list+ebx*4]
.check_size:
           cmp eax, [edi+block_size]
           ja .next
           ret
 
.high_mask:
           add esi, 4
           cmp esi, mem_block_mask+8
           jae .err
           add ebx, 32
           mov edx, [esi]
           jmp .find
.next:
           mov edi, [edi+list_fd]
           test edi, edi
           jnz .check_size
.err:
           xor edi, edi
           ret
 
align 4
alloc_mem_block:
 
           mov ebx, [mem_block_start]
           mov ecx, [mem_block_end]
.l1:
           bsf eax,[ebx];
           jnz found
           add ebx,4
           cmp ebx, ecx
           jb .l1
           xor eax,eax
           ret
 
found:
           btr [ebx], eax
           mov [mem_block_start],ebx
           sub ebx, mem_block_map
           lea eax,[eax+ebx*8]
           shl eax, 5
           add eax, [mem_block_arr]
           dec [free_blocks]
           ret
align 4
free_mem_block:
           mov dword [eax], 0
           mov dword [eax+4], 0
           mov dword [eax+8], 0
           mov dword [eax+12], 0
           mov dword [eax+16], 0
;           mov dword [eax+20], 0
           mov dword [eax+24], 0
           mov dword [eax+28], 0
 
           sub eax, [mem_block_arr]
           shr eax, 5
 
           mov ebx, mem_block_map
           bts [ebx], eax
           inc [free_blocks]
           shr eax, 3
           and eax, not 3
           add eax, ebx
           cmp [mem_block_start], eax
           ja @f
           ret
@@:
           mov [mem_block_start], eax
	   ret
.err:
           xor eax, eax
	   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
 
           mov ebx, heap_mutex
           call wait_mutex    ;ebx
 
           cmp eax, [heap_free]
           ja .error
 
           call get_small_block ; eax
           test edi, edi
           jz .error
 
           cmp [edi+block_flags], FREE_BLOCK
           jne .error
 
           mov [block_ind], ebx   ;index of allocated block
 
           mov eax, [edi+block_size]
           cmp eax, [size]
           je .m_eq_size
 
           call alloc_mem_block
           and eax, eax
           jz .error
 
           mov esi, eax           ;esi - splitted block
 
           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
           and eax, eax
           jz @f
           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]
           shr eax, 12
           sub eax, 1
           cmp eax, 63
           jna @f
           mov eax, 63
@@:
           cmp eax, [block_ind]
           je .m_eq_ind
 
           remove_from_list edi
 
           mov ecx, [block_ind]
           mov [mem_block_list+ecx*4], edx
 
           test edx, edx
           jnz @f
           btr [mem_block_mask], ecx
@@:
           mov edx, [mem_block_list+eax*4]
           mov [edi+list_fd], edx
           test edx, edx
           jz @f
           mov [edx+list_bk], edi
@@:
           mov [mem_block_list+eax*4], edi
           bts [mem_block_mask], eax
.m_eq_ind:
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
           mov edx, [ecx+list_fd]
           mov [esi+list_fd], edx
           mov [esi+list_bk], ecx
           mov [ecx+list_fd], esi
           mov [edx+list_bk], esi
 
           mov [esi+block_flags], USED_BLOCK
           mov eax, [esi+block_base]
           mov ebx, [size]
           sub [heap_free], ebx
           and [heap_mutex], 0
           pop edi
           pop esi
           pop ebx
           ret
.m_eq_size:
           remove_from_list edi
           mov [mem_block_list+ebx*4], edx
           and edx, edx
           jnz @f
           btr [mem_block_mask], ebx
@@:
           mov ecx, mem_used.fd-MEM_LIST_OFFSET
           mov edx, [ecx+list_fd]
           mov [edi+list_fd], edx
           mov [edi+list_bk], ecx
           mov [ecx+list_fd], edi
           mov [edx+list_bk], edi
 
           mov [edi+block_flags], USED_BLOCK
           mov eax, [edi+block_base]
           mov ebx, [size]
           sub [heap_free], ebx
           and [heap_mutex], 0
           pop edi
           pop esi
           pop ebx
           ret
.error:
           xor eax, eax
           mov [heap_mutex], eax
           pop edi
           pop esi
           pop ebx
           ret
endp
 
align 4
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
           push ebx
           push esi
           push edi
           mov ebx, heap_mutex
           call wait_mutex    ;ebx
 
           mov eax, [base]
           mov esi, [mem_used.fd]
@@:
           cmp esi, mem_used.fd-MEM_LIST_OFFSET
           je .fail
 
           cmp [esi+block_base], eax
           je .found
           mov esi, [esi+list_fd]
           jmp @b
.found:
           cmp [esi+block_flags], USED_BLOCK
           jne .fail
 
           mov eax, [esi+block_size]
           add [heap_free], eax
 
           mov edi, [esi+block_next]
           test edi, edi
           jz .prev
 
           cmp [edi+block_flags], FREE_BLOCK
           jne .prev
 
           remove_from_free edi
 
           mov edx, [edi+block_next]
           mov [esi+block_next], edx
           test edx, edx
           jz @f
 
           mov [edx+block_prev], esi
@@:
           mov ecx, [edi+block_size]
           add [esi+block_size], ecx
 
           mov eax, edi
           call free_mem_block
.prev:
           mov edi, [esi+block_prev]
           test edi, edi
           jz .insert
 
           cmp [edi+block_flags], FREE_BLOCK
           jne .insert
 
           remove_from_used esi
 
           mov edx, [esi+block_next]
           mov [edi+block_next], edx
           test edx, edx
           jz @f
           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
           calc_index ecx
           cmp eax, ecx
           je .m_eq
 
           push ecx
           remove_from_list edi
           pop ecx
 
           cmp [mem_block_list+ecx*4], edi
           jne @f
           mov [mem_block_list+ecx*4], edx
@@:
           cmp [mem_block_list+ecx*4], 0
           jne @f
           btr [mem_block_mask], ecx
@@:
           mov esi, [mem_block_list+eax*4]
           mov [mem_block_list+eax*4], edi
           mov [edi+list_fd], esi
           test esi, esi
           jz @f
           mov [esi+list_bk], edi
@@:
           bts [mem_block_mask], eax
.m_eq:
           xor eax, eax
           mov [heap_mutex], eax
           dec eax
           pop edi
           pop esi
           pop ebx
           ret
.insert:
           remove_from_used esi
 
           mov eax, [esi+block_size]
           calc_index eax
 
           mov edi, [mem_block_list+eax*4]
           mov [mem_block_list+eax*4], esi
           mov [esi+list_fd], edi
           test edi, edi
           jz @f
           mov [edi+list_bk], esi
@@:
           bts [mem_block_mask], eax
           mov [esi+block_flags],FREE_BLOCK
           xor eax, eax
           mov [heap_mutex], eax
           dec eax
           pop edi
           pop esi
           pop ebx
           ret
.fail:
           xor eax, eax
           mov [heap_mutex], eax
           pop edi
           pop esi
           pop ebx
           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 ebx, heap_mutex
           call wait_mutex    ;ebx
 
           mov eax, [base]
           mov esi, [mem_used.fd]
@@:
           cmp esi, mem_used.fd-MEM_LIST_OFFSET
           je .fail
 
           cmp [esi+block_base], eax
           je .found
           mov esi, [esi+list_fd]
           jmp @b
.found:
           cmp [esi+block_flags], USED_BLOCK
           jne .fail
 
           and [heap_mutex], 0
 
           push ecx
           mov ecx, [esi+block_size];
           shr ecx, 12
           call release_pages   ;eax, ecx
           pop ecx
           stdcall free_kernel_space, [base]
           pop esi ebx
           ret
.fail:
           and [heap_mutex], 0
           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 0x5FC00000
 
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_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
           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
 
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

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 819 → 823