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

           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, 0x01000000 + 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

           shl ebx, 3

           add eax,ebx

           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, 0xFFF

           and eax, 0xFFFFF000;

           mov [size], eax

           cmp eax, [heap_free]

           ja .error

           sub eax, 1

           and 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

           test ebx, ebx

           jz @f

@@:

           mov ecx, [block_ind]

           mov [mem_block_list+ecx*4], ebx

           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

           popfd

           ret

           remove_from_list edi

           mov [mem_block_list+ecx*4], edx

           and edx, edx

           jnz @f

           mov ecx, [block_ind]

           btr [mem_block_mask], ecx

@@:

           mov ebx, [mem_used_list]

           mov [edi+list_next], ebx

           test ebx, ebx

           jnz @f

           mov [ebx+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

           popfd

           ret

.error:

           xor eax, eax

           popfd

           ret

endp

proc free_kernel_space stdcall, base:dword

           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

           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

           not eax

           ret

.fail:

           xor eax, eax

           ret

endp

proc kernel_alloc stdcall, size:dword

           locals

             lin_addr    dd ?

             pages_count dd ?

           endl

           add eax, 0xFFF

           and eax, 0xFFFFF000;

           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

           xor eax, eax

           ret

endp

proc kernel_free stdcall, base:dword

           locals

             size  dd ?

           endl

           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

           mov [size], ecx

           test eax, eax

           jz .fail

           mov edi, [base]

           mov esi, edi

           shr edi, 10

           add edi, pages_tab

           xor edx, edx

.release:

           mov eax, [edi]

           test eax, 1

           jz .next

           mov [edi],edx

.next:

           invlpg [esi]

           add esi, 0x1000

           add edi, 4

           dec ecx

           jnz .release

.fail:

           ret

endp

restore block_prev

restore block_list

restore block_base

restore block_size

restore block_flags

proc init_heap stdcall, heap_size:dword

           locals

             tab_count dd ?

           endl

           and edx, edx

           jz .exit

           add edx, 4095

           and edx, not 4095

           mov [heap_size], edx

           add edx, 0x003FFFFF

           and edx, not 0x003FFFFF

           shr edx, 22

           mov [tab_count], edx

           shl ebx,8

           mov esi, [PROC_BASE+0x8c+ebx]

           add esi, 0x003FFFFF

           and esi, not 0x003FFFFF

           mov edi, esi

           mov [PROC_BASE+0x18+ebx], esi

           add esi, [heap_size]

           mov [PROC_BASE+0x1C+ebx], esi

           and eax, not 0xFFF

           stdcall map_page,[current_pdir],eax,dword PG_SW

@@:

           call alloc_page

           test eax, eax

           jz .exit

           add edi, 0x00400000

           dec edx

           jnz @B

           shl ecx, 12-2

           mov ebx,[CURRENT_TASK]

           shl ebx,8

           mov edi, [PROC_BASE+0x18+ebx]

           add edi, new_app_base

           shr edi, 10

           mov esi, edi

           add edi, pages_tab

           xor eax, eax

           cld

           rep stosd

           mov eax, ebx

           sub eax, 4096

           or ebx, FREE_BLOCK

           mov [pages_tab+esi], ebx

.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+0x18]; heap_base

           mov edi, dword [ebx+PROC_BASE+0x1C]; 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

           add edx, ecx

           sub eax, ecx;

           or eax, FREE_BLOCK

           shr edx, 12

           mov [pages_tab+edx*4], eax

           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 @f

           mov ecx, eax

           or eax, FREE_BLOCK

           mov [pages_tab+esi*4], eax

           inc esi

           sub ecx, 4096

           shr ecx, 12

.release:

           mov eax, [pages_tab+esi*4]

           call free_page

           inc esi

           dec ecx

           jnz .release

@@:

           mov ebx, [CURRENT_TASK]

           shl ebx, 8

           mov esi, dword [ebx+PROC_BASE+0x18]; heap_base

           mov edi, dword [ebx+PROC_BASE+0x1C]; heap_top

           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

;

;           stdcall wait_mutex, pg_data.pg_mutex

;

;           mov edi, [new_size]

;           add edi,4095

;           and edi,not 4095

;           mov [new_size], edi

;           shl    edx,8

;           mov    esi, [PROC_BASE+0x8c+edx]

;           add esi, 4095

;           and esi, not 4095

;           jae .expand

;           shr esi, 12

;

;@@:        mov eax, [pages_tab+0x4000+edi*4]

;           test eax, 1

;           jz .next

;           mov dword [pages_tab+0x4000+edi*4], 2

;           mov ebx, edi

;           shl ebx, 12

;           invlpg [ebx+std_application_base_address]

;           call free_page

;

;.next:     add edi, 1

;           cmp edi, esi

;           jb @B

;

;.update_size:

;           mov    [PROC_BASE+0x8c+edx],ebx

;

;;search threads and update

;;application memory size infomation

;           mov    ecx,[PROC_BASE+0xb8+edx]

;           mov    eax,2

;;eax = current slot

;;ebx = new memory size

;;ecx = page directory

;           cmp    eax,[TASK_COUNT]

;           jg     .search_threads_end

;           mov    edx,eax

;           shl    edx,5

;           cmp    word [CURRENT_TASK+edx+0xa],9 ;if slot empty?

;           jz     .search_threads_next

;           shl    edx,3

;           cmp    [PROC_BASE+edx+0xb8],ecx     ;if it is our thread?

;           jnz    .search_threads_next

;           mov    [PROC_BASE+edx+0x8c],ebx     ;update memory size

;.search_threads_next:

;           inc    eax

;           jmp    .search_threads

;.search_threads_end:

;           xor eax, eax

;           dec [pg_data.pg_mutex]

;           ret

;

;

;.expand:

;           add edi, new_app_base

;           add esi, new_app_base

;

;.grow:     call alloc_page

;           test eax, eax

;           jz .exit

;           stdcall map_page,esi,eax,dword PG_UW

;           mov edi, esi

;           xor eax, eax

;           mov ecx, 1024

;           cld

;           rep stosd

;           pop edi

;           cmp esi, edi

;           jna .grow

;           jmp .update_size

;.exit:

;           xor eax, eax

;           inc eax

;           dec [pg_data.pg_mutex]

;           ret

;endp

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

           popf

           shl eax,5

           add eax, srv_tab

           ret

endp

new_services:

         cmp eax, 10

         jb .fail

         ja @f

         call get_mem_info

         mov [esp+36], eax

         ret

@@:

         cmp eax, 11

         ja @f

         call init_heap

         mov [esp+36], eax

         ret

@@:

         cmp eax, 12

         ja @f

         call user_alloc

         mov [esp+36], eax

         ret

@@:

         cmp eax, 13

         ja @f

         call user_free

         mov [esp+36], eax

         ret

         cmp eax, 14

         ja @f

         mov eax, [ebp+8+new_app_base]

         add eax,new_app_base

         stdcall get_notify, eax

         ret

;@@:

;         cmp eax, 15

;         ja @f

;         call set_notify

;         ret

@@:

         cmp eax, 16

         ja @f

         add eax, new_app_base

         stdcall get_service, eax

         mov [esp+36], eax

         ret

@@:

         cmp eax, 17

         ja @f

         stdcall srv_handler,[ebp+8+new_app_base],\

                          [ebp+12+new_app_base],\

                          [ebp+16+new_app_base]

         mov [esp+36], eax

         ret

;@@:

;         cmp eax, 20

;         ja @f

;         call CreateSound

;         mov [esp+36], eax

;         ret

.fail:

         xor eax, eax

         mov [esp+36], eax

         ret

        jecxz .end

        mov esi,edi

        xor eax,eax

        repne scasb

        neg ecx             ; cx = count - strlen

        add ecx,ebx         ; strlen + count - strlen

        mov edi,esi

        mov esi,[str2]

        repe cmpsb

        mov al,[esi-1]

        xor ecx,ecx

        ja .str2_big

        je .end

        sub ecx,2

        not ecx

.end:

        mov eax,ecx

        ret

endp

.next:

           mov eax, [edx]

           test eax, eax

           jz .end

           stdcall strncmp, eax, [sz_name], 16

           pop edx

           test eax, eax

           jz .ok

           jmp .next

.ok:

           mov eax, [edx+4]

.end:

           ret

endp

         mov esi, [imp]

         mov eax, [esi]

         test eax, eax

         jz .end

         stdcall get_proc, [exp], eax

         pop esi

         jz @F

@@:

         add esi, 4

         jmp .next

.end:

         ret

endp