Subversion Repositories Kolibri OS

;HEAP_SIZE equ 0x01000000

{  .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

}

USED_BLOCK      equ  8

  MEM_BLOCK MEM_BLOCK

end virtual

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

{          shr op, 12

           dec op

           cmp op, 63

           jna @f

           mov op, 63

@@:

}

{          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

}

{

           remove_from_list op

           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

@@:

}

{

           remove_from_list op

           cmp [mem_used_list], op

           jne @f

           mov [mem_used_list], edx

@@:

}

proc init_kernel_heap

           mov edi, mem_block_list

           xor eax, eax

           cld

           rep stosd

           mov edi, mem_block_map

           not eax

           rep stosd

           mov [mem_block_end], mem_block_map+512

           mov [mem_block_arr], HEAP_BASE

           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 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_prev], eax

           mov [ebx+list_next], eax

           mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK_SIZE

           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+4],0x80000000

           mov [mem_block_list+63*4], ebx

           mov byte [mem_block_map], 0xFC

           mov [heap_blocks], 4095

           mov [free_blocks], 4095

           ret

endp

proc get_block stdcall, index:dword

           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

           jb .bit_test

           add ebx, 32

           add esi, 4

           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

           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

           xor eax, eax

           ret

endp

proc alloc_mem_block

           cli

           mov ebx, [mem_block_start]

           mov ecx, [mem_block_end]

.l1:

           bsf eax,[ebx];

           jnz found

           add ebx,4

           cmp ebx, ecx

           jb .l1

           popfd

           xor eax,eax

           ret

           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]

           popfd

           ret

endp

           pushfd

           cli

           sub eax, [mem_block_arr]

           shr eax, 5

           bts [ebx], eax

           inc [free_blocks]

           shr eax, 3

           and eax, not 3

           add eax, ebx

           cmp [mem_block_start], eax

           ja @f

           popfd

           ret

@@:

           mov [mem_block_start], eax

           popfd

	   ret

.err:

           xor eax, eax

           popfd

	   ret

endp

proc alloc_kernel_space stdcall, size:dword

           local block_ind:DWORD

           cli

           add eax, 4095

           and eax, not 4095

           mov [size], eax

           cmp eax, [heap_free]

           ja .error