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


$Revision: 425 $
 
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
 
virtual at 0
  MEM_BLOCK MEM_BLOCK
end virtual
 
MEM_BLOCK_SIZE equ 8*4
 
block_next   equ MEM_BLOCK.next_block
block_prev   equ MEM_BLOCK.prev_block
list_fd      equ MEM_BLOCK.list_fd
list_bk      equ MEM_BLOCK.list_bk
block_base   equ MEM_BLOCK.base
block_size   equ MEM_BLOCK.size
block_flags  equ MEM_BLOCK.flags
 
macro calc_index op
{          shr op, 12
           dec op
           cmp op, 63
           jna @f
           mov op, 63
@@:
}
 
macro remove_from_list op
{          mov edx, [op+list_fd]
           mov ecx, [op+list_bk]
           test edx, edx
           jz @f
           mov [edx+list_bk], ecx
@@:
           test ecx, ecx
           jz @f
           mov [ecx+list_fd], edx
@@:
           mov [op+list_fd],0
           mov [op+list_bk],0
}
 
macro remove_from_free op
{
           remove_from_list op
 
           mov eax, [op+block_size]
           calc_index eax
           cmp [mem_block_list+eax*4], op
           jne @f
           mov [mem_block_list+eax*4], edx
@@:
           cmp [mem_block_list+eax*4], 0
           jne @f
           btr [mem_block_mask], eax
@@:
}
 
macro remove_from_used op
{
           mov edx, [op+list_fd]
           mov ecx, [op+list_bk]
           mov [edx+list_bk], ecx
           mov [ecx+list_fd], edx
           mov [op+list_fd], 0
           mov [op+list_bk], 0
}
 
align 4
proc init_kernel_heap
 
           mov ecx, 64/4
           mov edi, mem_block_list
           xor eax, eax
           cld
           rep stosd
 
           mov ecx, 512/4
           mov edi, mem_block_map
           not eax
           rep stosd
 
           mov [mem_block_start], mem_block_map
           mov [mem_block_end], mem_block_map+512
           mov [mem_block_arr], HEAP_BASE
 
           mov eax, mem_used.fd-MEM_LIST_OFFSET
           mov [mem_used.fd], eax
           mov [mem_used.bk], eax
 
           stdcall alloc_pages, dword 32
           mov ecx, 32
           mov edx, eax
           mov edi, HEAP_BASE
.l1:
           stdcall map_page,edi,edx,PG_SW
           add edi, 0x1000
           add edx, 0x1000
           dec ecx
           jnz .l1
 
           mov edi, HEAP_BASE
           mov ebx, HEAP_BASE+MEM_BLOCK_SIZE
           xor eax, eax
           mov [edi+block_next], ebx
           mov [edi+block_prev], eax
           mov [edi+list_fd], eax
           mov [edi+list_bk], eax
           mov [edi+block_base], HEAP_BASE
           mov [edi+block_size], 4096*MEM_BLOCK_SIZE
           mov [edi+block_flags], USED_BLOCK
 
           mov [ebx+block_next], eax
           mov [ebx+block_prev], eax
           mov [ebx+list_fd], eax
           mov [ebx+list_bk], eax
           mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK_SIZE
 
           mov ecx, [MEM_AMOUNT]
           sub ecx, HEAP_BASE + 4096*MEM_BLOCK_SIZE
           mov [heap_size], ecx
           mov [heap_free], ecx
           mov [ebx+block_size], ecx
           mov [ebx+block_flags], FREE_BLOCK
 
           mov [mem_block_mask], eax
           mov [mem_block_mask+4],0x80000000
 
           mov [mem_block_list+63*4], ebx
           mov byte [mem_block_map], 0xFC
           and [heap_mutex], 0
           mov [heap_blocks], 4095
           mov [free_blocks], 4095
           ret
endp
 
; param
;  eax= required size
;
; retval
;  edi= memory block descriptor
;  ebx= descriptor index
 
align 4
get_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
proc 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
endp
 
proc 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
endp
 
align 4
proc alloc_kernel_space stdcall, size:dword
           local block_ind:DWORD
 
           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_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
           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
           ret
.error:
           xor eax, eax
           mov [heap_mutex], eax
           ret
endp
 
align 4
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
 
           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
           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
           ret
.fail:
           xor eax, eax
           mov [heap_mutex], eax
           ret
endp
 
align 4
proc kernel_alloc stdcall, size:dword
           locals
             lin_addr    dd ?
             pages_count dd ?
           endl
 
           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]
           ret
.err:
           xor eax, eax
           ret
endp
 
align 4
proc kernel_free stdcall, base:dword
           push ebx esi
 
           mov ebx, heap_mutex
           call wait_mutex    ;ebx
 
           mov eax, [base]
           mov esi, [mem_used.fd]
@@:
           cmp esi, mem_used.fd-MEM_LIST_OFFSET
           je .fail
 
           cmp [esi+block_base], eax
           je .found
           mov esi, [esi+list_fd]
           jmp @b
.found:
           cmp [esi+block_flags], USED_BLOCK
           jne .fail
 
           and [heap_mutex], 0
 
           push ecx
           mov ecx, [esi+block_size];
           shr ecx, 12
           call release_pages   ;eax, ecx
           pop ecx
           stdcall free_kernel_space, [base]
           pop esi ebx
           ret
.fail:
           and [heap_mutex], 0
           pop esi ebx
           ret
endp
 
restore block_next
restore block_prev
restore block_list
restore block_base
restore block_size
restore block_flags
 
;;;;;;;;;;;;;;      USER     ;;;;;;;;;;;;;;;;;
 
HEAP_TOP  equ 0x5FC00000
 
align 4
proc init_heap
 
           mov ebx,[CURRENT_TASK]
           shl ebx,8
           mov eax, [SLOT_BASE+APPDATA.heap_top+ebx]
           test eax, eax
           jz @F
           sub eax,[SLOT_BASE+APPDATA.heap_base+ebx]
           sub eax, 4096
           ret
@@:
           mov esi, [SLOT_BASE+APPDATA.mem_size+ebx]
           add esi, 4095
           and esi, not 4095
           mov [SLOT_BASE+APPDATA.mem_size+ebx], esi
           mov eax, HEAP_TOP
           mov [SLOT_BASE+APPDATA.heap_base+ebx], esi
           mov [SLOT_BASE+APPDATA.heap_top+ebx], eax
 
           sub eax, esi
           add esi, new_app_base
           shr esi, 10
           mov ecx, eax
           sub eax, 4096
           or ecx, FREE_BLOCK
           mov [page_tabs+esi], ecx
           ret
.exit:
           xor eax, eax
           ret
endp
 
align 4
proc user_alloc stdcall, alloc_size:dword
 
           mov ecx, [alloc_size]
           add ecx, (4095+4096)
           and ecx, not 4095
 
           mov ebx, [CURRENT_TASK]
           shl ebx, 8
           mov esi, dword [ebx+SLOT_BASE+APPDATA.heap_base]; heap_base
           mov edi, dword [ebx+SLOT_BASE+APPDATA.heap_top]; heap_top
           add esi, new_app_base
           add edi, new_app_base
l_0:
           cmp esi, edi
           jae m_exit
 
           mov ebx, esi
           shr ebx, 12
           mov eax, [page_tabs+ebx*4]
           test eax, FREE_BLOCK
           jz test_used
           and eax, 0xFFFFF000
           cmp eax, ecx    ;alloc_size
           jb  m_next
	   jz  @f
 
           mov edx, esi
           add edx, ecx
           sub eax, ecx;
           or eax, FREE_BLOCK
           shr edx, 12
           mov [page_tabs+edx*4], eax
 
@@:
           or ecx, USED_BLOCK
           mov [page_tabs+ebx*4], ecx
           shr ecx, 12
           dec ecx
           inc ebx
@@:
           mov dword [page_tabs+ebx*4], 2
           inc ebx
           dec ecx
           jnz @B
 
        mov     edx, [CURRENT_TASK]
        shl     edx, 8
        mov     ebx, [alloc_size]
        add     ebx, 0xFFF
        and     ebx, not 0xFFF
        add     ebx, [SLOT_BASE+APPDATA.mem_size+edx]
        call    update_mem_size
 
           mov eax, esi
           add eax, 4096
           sub eax, new_app_base
           ret
m_next:
           add esi, eax
           jmp l_0
test_used:
           test eax, USED_BLOCK
           jz m_exit
 
           and eax, 0xFFFFF000
           add esi, eax
           jmp l_0
m_exit:
           xor eax, eax
           ret
endp
 
align 4
proc user_free stdcall, base:dword
 
           mov esi, [base]
           test esi, esi
           jz .exit
 
           xor ebx, ebx
           sub esi, 4096
           shr esi, 12
           mov eax, [page_tabs+esi*4]
           test eax, USED_BLOCK
           jz .not_used
 
           and eax, not 4095
           mov ecx, eax
           or eax, FREE_BLOCK
           mov [page_tabs+esi*4], eax
           inc esi
           sub ecx, 4096
           shr ecx, 12
           mov ebx, ecx
.release:
           xor eax, eax
           xchg eax, [page_tabs+esi*4]
           test eax, 1
           jz @F
           call free_page
@@:
           inc esi
           dec ecx
           jnz .release
.not_used:
           mov edx, [CURRENT_TASK]
           shl edx, 8
           mov esi, dword [edx+SLOT_BASE+APPDATA.heap_base]; heap_base
           mov edi, dword [edx+SLOT_BASE+APPDATA.heap_top]; heap_top
           sub ebx, [edx+SLOT_BASE+APPDATA.mem_size]
           neg ebx
           call update_mem_size
           add esi, new_app_base
           add edi, new_app_base
           shr esi, 12
           shr edi, 12
@@:
           mov eax, [page_tabs+esi*4]
           test eax, USED_BLOCK
           jz .test_free
           shr eax, 12
           add esi, eax
           jmp @B
.test_free:
           test eax, 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 ebx, USED_BLOCK
           jz .next_free
 
           shr ebx, 12
           add edx, ebx
           mov esi, edx
           jmp @B
.next_free:
           test ebx, 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
endp
 
if 0
align 4
proc alloc_dll
           pushf
           cli
           bsf eax, [dll_map]
           jnz .find
           popf
           xor eax, eax
           ret
.find:
           btr [dll_map], eax
           popf
           shl eax, 5
           add eax, dll_tab
           ret
endp
 
align 4
proc alloc_service
           pushf
           cli
           bsf eax, [srv_map]
           jnz .find
           popf
           xor eax, eax
           ret
.find:
           btr [srv_map], eax
           popf
           shl eax,0x02
           lea eax,[srv_tab+eax+eax*8]   ;srv_tab+eax*36
           ret
endp
 
end if

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 380 → 425