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


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

Subversion Repositories Kolibri OS

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