mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-04 14:21:55 +03:00
1118 lines
24 KiB
PHP
1118 lines
24 KiB
PHP
|
|
HEAP_BASE equ 0x01000000
|
|
;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, 0x00C00000 + 4096*MEM_BLOCK_SIZE
|
|
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
|
|
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
|
|
|
|
pushfd
|
|
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
|
|
|
|
found:
|
|
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]
|
|
popfd
|
|
ret
|
|
endp
|
|
|
|
proc free_mem_block
|
|
pushfd
|
|
cli
|
|
sub eax, [mem_block_arr]
|
|
shr eax, 5
|
|
|
|
mov ebx, mem_block_map
|
|
bts [ebx], eax
|
|
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
|
|
|
|
align 4
|
|
proc alloc_kernel_space stdcall, size:dword
|
|
local block_ind:DWORD
|
|
|
|
pushfd
|
|
cli
|
|
|
|
mov eax, [size]
|
|
add eax, 0xFFF
|
|
and eax, 0xFFFFF000;
|
|
mov [size], eax
|
|
|
|
shr eax, 12
|
|
sub eax, 1
|
|
|
|
mov [block_ind], eax
|
|
|
|
stdcall get_block, eax
|
|
and 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
|
|
|
|
mov ebx, [edi+list_next]
|
|
test ebx, ebx
|
|
jz @f
|
|
|
|
mov [ebx+list_prev], edi
|
|
@@:
|
|
mov ecx, [block_ind]
|
|
mov [mem_block_list+ecx*4], ebx
|
|
|
|
and ebx, 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]
|
|
popfd
|
|
ret
|
|
|
|
.m_eq_size:
|
|
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]
|
|
popfd
|
|
ret
|
|
.error:
|
|
xor eax, eax
|
|
popfd
|
|
ret
|
|
endp
|
|
|
|
align 4
|
|
proc free_kernel_space stdcall, base:dword
|
|
|
|
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 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
|
|
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
|
|
not eax
|
|
ret
|
|
.fail:
|
|
xor eax, eax
|
|
ret
|
|
endp
|
|
|
|
align 4
|
|
proc kernel_alloc stdcall, size:dword
|
|
locals
|
|
lin_addr dd ?
|
|
pages_count dd ?
|
|
endl
|
|
|
|
mov eax, [size]
|
|
add eax, 0xFFF
|
|
and eax, 0xFFFFF000;
|
|
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
|
|
locals
|
|
size dd ?
|
|
endl
|
|
|
|
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 ecx, [esi+block_size];
|
|
mov [size], ecx
|
|
|
|
stdcall free_kernel_space, [base]
|
|
test eax, eax
|
|
jz .fail
|
|
|
|
mov ecx, [size]
|
|
mov edi, [base]
|
|
|
|
shr ecx, 12
|
|
mov esi, edi
|
|
shr edi, 10
|
|
add edi, pages_tab
|
|
xor edx, edx
|
|
.release:
|
|
mov eax, [edi]
|
|
test eax, 1
|
|
jz .next
|
|
|
|
call free_page
|
|
mov [edi],edx
|
|
.next:
|
|
invlpg [esi]
|
|
add esi, 0x1000
|
|
add edi, 4
|
|
dec ecx
|
|
jnz .release
|
|
.fail:
|
|
ret
|
|
endp
|
|
|
|
restore block_next
|
|
restore block_prev
|
|
restore block_list
|
|
restore block_base
|
|
restore block_size
|
|
restore block_flags
|
|
|
|
;;;;;;;;;;;;;; USER ;;;;;;;;;;;;;;;;;
|
|
|
|
align 4
|
|
proc init_heap stdcall, heap_size:dword
|
|
locals
|
|
tab_count dd ?
|
|
endl
|
|
|
|
mov edx, [heap_size]
|
|
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
|
|
|
|
mov ebx,[CURRENT_TASK]
|
|
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
|
|
|
|
mov eax, cr3
|
|
and eax, not 0xFFF
|
|
stdcall map_page,[current_pdir],eax,dword PG_SW
|
|
|
|
add edi, new_app_base
|
|
@@:
|
|
call alloc_page
|
|
test eax, eax
|
|
jz .exit
|
|
|
|
stdcall map_page_table, [current_pdir], edi, eax
|
|
add edi, 0x00400000
|
|
dec edx
|
|
jnz @B
|
|
|
|
mov ecx, [tab_count]
|
|
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
|
|
|
|
stdcall map_page,[current_pdir],dword PG_UNMAP
|
|
|
|
mov ebx, [heap_size]
|
|
mov eax, ebx
|
|
sub eax, 4096
|
|
or ebx, FREE_BLOCK
|
|
mov [pages_tab+esi], ebx
|
|
|
|
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+0x18]; heap_base
|
|
mov edi, dword [ebx+PROC_BASE+0x1C]; 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
|
|
|
|
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 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
|
|
|
|
sub esi, 4096
|
|
shr esi, 12
|
|
mov eax, [pages_tab+esi*4]
|
|
test eax, USED_BLOCK
|
|
jz @f
|
|
|
|
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
|
|
.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
|
|
|
|
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
|
|
|
|
|
|
;proc new_mem_resize stdcall, new_size:dword
|
|
;
|
|
; stdcall wait_mutex, pg_data.pg_mutex
|
|
;
|
|
; mov edi, [new_size]
|
|
; add edi,4095
|
|
; and edi,not 4095
|
|
; mov [new_size], edi
|
|
|
|
; mov edx,[CURRENT_TASK]
|
|
; shl edx,8
|
|
; mov esi, [PROC_BASE+0x8c+edx]
|
|
; add esi, 4095
|
|
; and esi, not 4095
|
|
|
|
; cmp edi, esi
|
|
; jae .expand
|
|
|
|
; shr edi, 12
|
|
; 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 ebx, [new_size]
|
|
; mov [PROC_BASE+0x8c+edx],ebx
|
|
;
|
|
;;search threads and update
|
|
;;application memory size infomation
|
|
; mov ecx,[PROC_BASE+0xb8+edx]
|
|
; mov eax,2
|
|
|
|
;.search_threads:
|
|
;;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
|
|
|
|
; push edi
|
|
; mov edi, esi
|
|
; xor eax, eax
|
|
; mov ecx, 1024
|
|
; cld
|
|
; rep stosd
|
|
; pop edi
|
|
|
|
; add esi, 0x1000
|
|
; cmp esi, edi
|
|
; jna .grow
|
|
; jmp .update_size
|
|
;.exit:
|
|
; xor eax, eax
|
|
; inc eax
|
|
; dec [pg_data.pg_mutex]
|
|
; 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
|
|
|
|
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,5
|
|
add eax, srv_tab
|
|
ret
|
|
endp
|
|
|
|
if NEW
|
|
|
|
align 16
|
|
new_services:
|
|
cmp eax, 10
|
|
jb .fail
|
|
ja @f
|
|
|
|
push dword [ebp+8+new_app_base]
|
|
call get_mem_info
|
|
mov [esp+36], eax
|
|
ret
|
|
@@:
|
|
cmp eax, 11
|
|
ja @f
|
|
|
|
push dword [ebp+8+new_app_base]
|
|
call init_heap
|
|
mov [esp+36], eax
|
|
ret
|
|
@@:
|
|
cmp eax, 12
|
|
ja @f
|
|
|
|
push dword [ebp+8+new_app_base]
|
|
call user_alloc
|
|
mov [esp+36], eax
|
|
ret
|
|
@@:
|
|
cmp eax, 13
|
|
ja @f
|
|
|
|
push dword [ebp+8+new_app_base]
|
|
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
|
|
|
|
mov eax, [ebp+8+new_app_base]
|
|
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
|
|
|
|
proc strncmp stdcall, str1:dword, str2:dword, count:dword
|
|
|
|
mov ecx,[count]
|
|
jecxz .end
|
|
|
|
mov ebx,ecx
|
|
|
|
mov edi,[str1]
|
|
mov esi,edi
|
|
xor eax,eax
|
|
repne scasb
|
|
neg ecx ; cx = count - strlen
|
|
add ecx,ebx ; strlen + count - strlen
|
|
|
|
.okay:
|
|
mov edi,esi
|
|
mov esi,[str2]
|
|
repe cmpsb
|
|
mov al,[esi-1]
|
|
xor ecx,ecx
|
|
|
|
cmp al,[edi-1]
|
|
ja .str2_big
|
|
je .end
|
|
|
|
.str1_big:
|
|
sub ecx,2
|
|
|
|
.str2_big:
|
|
not ecx
|
|
.end:
|
|
mov eax,ecx
|
|
ret
|
|
endp
|
|
|
|
|
|
proc get_proc stdcall, exp:dword, sz_name:dword
|
|
|
|
mov edx, [exp]
|
|
.next:
|
|
mov eax, [edx]
|
|
test eax, eax
|
|
jz .end
|
|
|
|
push edx
|
|
stdcall strncmp, eax, [sz_name], 16
|
|
pop edx
|
|
test eax, eax
|
|
jz .ok
|
|
|
|
add edx,8
|
|
jmp .next
|
|
.ok:
|
|
mov eax, [edx+4]
|
|
.end:
|
|
ret
|
|
endp
|
|
|
|
proc link_dll stdcall, exp:dword, imp:dword
|
|
mov esi, [imp]
|
|
|
|
.next:
|
|
mov eax, [esi]
|
|
test eax, eax
|
|
jz .end
|
|
|
|
push esi
|
|
stdcall get_proc, [exp], eax
|
|
pop esi
|
|
|
|
test eax, eax
|
|
jz @F
|
|
|
|
mov [esi], eax
|
|
@@:
|
|
add esi, 4
|
|
jmp .next
|
|
.end:
|
|
ret
|
|
endp
|
|
|
|
end if
|
|
|
|
|
|
|