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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 1501 → 1615