Subversion Repositories Kolibri OS

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

}

FREE_BLOCK      equ  4

USED_BLOCK      equ  8

  MEM_BLOCK MEM_BLOCK

end virtual

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

{          shr op, 12

           dec op

           cmp op, 63

           jna @f

           mov op, 63

@@:

}

{          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

}

{

           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

@@:

}

{

           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

}

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 [mem_used.fd], eax

           mov [mem_used.bk], eax

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

           mov [ebx+list_fd], eax

           mov [ebx+list_bk], 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 byte [mem_block_map], 0xFC

           and [heap_mutex], 0

           mov [heap_blocks], 4095

           mov [free_blocks], 4095

           ret

endp

;  eax= required size

;

; retval

;  edi= memory block descriptor

;  ebx= descriptor index

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

           jb .bit_test

           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

           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

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

           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

           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

           test edi, edi

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

           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_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 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 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 uses ebx ecx edx esi edi, base:dword

           call wait_mutex    ;ebx

           mov esi, [mem_used.fd]

@@:

           cmp esi, mem_used.fd-MEM_LIST_OFFSET

           je .fail

           je .found

           mov esi, [esi+list_fd]

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

           calc_index eax

           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

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

           mov ebx, eax

           shr ebx, 12

           mov [pages_count], ebx

           test eax, eax

           jz .err

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

           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

           add edx, 0x1000

           dec ecx

           jnz @B

.end:

           mov eax, [lin_addr]

           ret

.err:

           xor eax, eax

           ret

endp

proc kernel_free stdcall, base:dword

           push ebx esi

           call wait_mutex    ;ebx

           mov esi, [mem_used.fd]

@@:

           cmp esi, mem_used.fd-MEM_LIST_OFFSET

           je .fail

           je .found

           mov esi, [esi+list_fd]

           jmp @b

.found:

           cmp [esi+block_flags], USED_BLOCK

           jne .fail

           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_prev

restore block_list

restore block_base

restore block_size

restore block_flags

proc init_heap

           mov eax, [ebx+APPDATA.heap_top]

           test eax, eax

           jz @F

           sub eax,[ebx+APPDATA.heap_base]

           sub eax, 4096

           ret

@@:

           mov esi, [ebx+APPDATA.mem_size]

           add esi, 4095

           and esi, not 4095

           mov [ebx+APPDATA.mem_size], esi

           mov eax, HEAP_TOP

           mov [ebx+APPDATA.heap_base], esi

           mov [ebx+APPDATA.heap_top], eax

       ;    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

proc user_alloc stdcall, alloc_size:dword

           add ecx, (4095+4096)

           and ecx, not 4095

           mov esi, dword [ebx+APPDATA.heap_base]  ; heap_base

           mov edi, dword [ebx+APPDATA.heap_top]   ; heap_top

l_0:

           cmp esi, edi

           jae m_exit

           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

           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     ebx, [alloc_size]

           add     ebx, 0xFFF

           and     ebx, not 0xFFF

           add     ebx, [edx+APPDATA.mem_size]

           call    update_mem_size

           add eax, 4096

           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

           sub esi, 4096

           shr esi, 12

           mov eax, [page_tabs+esi*4]

           test eax, USED_BLOCK

           jz .not_used

           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_slot]

           mov esi, dword [edx+APPDATA.heap_base]

           mov edi, dword [edx+APPDATA.heap_top]

           sub ebx, [edx+APPDATA.mem_size]

           neg ebx

           call update_mem_size

           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

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

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