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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 281 → 294