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

           and [heap_mutex], 0

           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

           mov ecx, [mem_block_end]

.l1:

           bsf eax,[ebx];

           jnz found

           add ebx,4

           cmp ebx, ecx

           jb .l1

           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]

           ret

endp

           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

           ret

@@:

           mov [mem_block_start], eax

	   ret

.err:

           xor eax, eax

	   ret

endp

proc alloc_kernel_space stdcall, size:dword

           local block_ind:DWORD

           add eax, 4095

           and eax, not 4095

           mov [size], eax

           call wait_mutex    ;ebx

           ja .error

           sub eax, 1

           test eax, eax

           jz .error

           jne .error

           cmp eax, [size]

           je .m_eq_size

           and eax, eax

           jz .error

           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

           shr eax, 12

           sub eax, 1

           cmp eax, 63

           jna @f

           mov eax, 63

@@:

           cmp eax, [block_ind]

           je .m_eq_ind

           mov [mem_block_list+ecx*4], 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

proc free_kernel_space stdcall, base:dword

           call wait_mutex    ;ebx

           mov esi, [mem_used_list]

@@:

           test esi, esi

           jz .fail

           je .found

           mov esi, [esi+list_next]

           jmp @b

.found:

           cmp [esi+block_flags], USED_BLOCK

           jne .fail

           add [heap_free], eax

           test edi, edi

           jz .prev

           jne .prev

           mov [esi+block_next], edx

           test edx, edx

           jz @f

@@:

           mov ecx, [edi+block_size]

           add [esi+block_size], ecx

           call free_mem_block

.prev:

           mov edi, [esi+block_prev]

           test edi, edi

           jz .insert

           jne .insert

           mov [edi+block_next], edx

           test edx, edx

           jz @f

           mov [edx+block_prev], edi

@@:

           mov eax, esi

           call free_mem_block

           mov eax, [esi+block_size]

           add eax, ecx

           mov [edi+block_size], eax

           calc_index ecx

           cmp eax, ecx

           je .m_eq

           remove_from_list edi

           pop ecx

           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

           calc_index eax

           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

proc kernel_alloc stdcall, size:dword

           locals

             lin_addr    dd ?

             pages_count dd ?

           endl

           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

           and eax, eax

           jz .error

           mov [lin_addr], eax

           mov edx, eax

           mov ebx, ecx

           jz .next

           push ebx

           stdcall alloc_pages, ebx

           pop ecx                   ; yes ecx!!!

           and eax, eax

           jz .error

           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

           call alloc_page

           pop ecx

           test eax, eax

           jz .error

           add edx, 0x1000

           dec ecx

           jnz @B

.end:

           mov eax, [lin_addr]

           ret

.error:

           xor eax, eax

           ret

endp

proc kernel_free stdcall, base:dword

           call wait_mutex    ;ebx

           mov esi, [mem_used_list]

@@:

           test esi, esi

           jz .fail

           je .found

           mov esi, [esi+list_next]

           jmp @b

.found:

           cmp [esi+block_flags], USED_BLOCK

           jne .fail

           stdcall free_kernel_space, [base]

           ret

.fail:

           and [heap_mutex], 0

           ret

endp

restore block_prev

restore block_list

restore block_base

restore block_size

restore block_flags

proc init_heap

           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 eax, HEAP_TOP

           mov [PROC_BASE+APPDATA.heap_base+ebx], esi

           mov [PROC_BASE+APPDATA.heap_top+ebx], eax

           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

proc user_alloc stdcall, alloc_size:dword

           add ecx, (4095+4096)

           and ecx, not 4095

           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

           cmp esi, edi

           jae m_exit

           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

           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

           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

           add esi, eax

           jmp l_0

m_exit:

           xor eax, eax

           ret

endp

proc user_free stdcall, base:dword

           test esi, esi

           jz .exit

           shr esi, 12

           mov eax, [pages_tab+esi*4]

           test eax, USED_BLOCK

           jz .not_used

           mov ecx, eax

           or eax, FREE_BLOCK

           mov [pages_tab+esi*4], eax

           inc esi

           sub ecx, 4096

           shr ecx, 12

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

           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

           test ebx, USED_BLOCK

           jz .next_free

           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

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

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