Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 863 → Rev 864

/kernel/branches/kolibri_pe/core/dll.inc
585,12 → 585,15
test eax, eax
jnz .fail
 
mov eax, [file_size]
cmp eax, 1024*1024*16
mov ecx, [file_size]
cmp ecx, 1024*1024*16
ja .fail
 
stdcall kernel_alloc, [file_size]
mov edx, PG_SW
call @mem_alloc@8
mov [file], eax
test eax, eax
jz .fail
 
stdcall read_file, [file_name], eax, dword 0, [file_size]
cmp ebx, [file_size]
599,10 → 602,11
mov eax, [file]
cmp dword [eax], 0x4B43504B
jne .exit
mov ebx, [eax+4]
mov [file_size], ebx
stdcall kernel_alloc, ebx
 
mov ecx, [eax+4]
mov [file_size], ecx
mov edx, PG_SW
call @mem_alloc@8
test eax, eax
jz .cleanup
 
824,20 → 828,20
 
mov [coff], eax
 
movzx ecx, [eax+CFH.nSections]
xor ebx, ebx
 
movzx ebx, [eax+CFH.nSections]
lea edx, [eax+20]
xor ecx, ecx
@@:
add ebx, [edx+CFS.SizeOfRawData]
add ebx, 15
and ebx, not 15
add ecx, [edx+CFS.SizeOfRawData]
add ecx, 15
and ecx, not 15
add edx, COFF_SECTION_SIZE
dec ecx
dec ebx
jnz @B
mov [img_size], ebx
 
stdcall kernel_alloc, ebx
mov [img_size], ecx
mov edx, PG_SW
call @mem_alloc@8
test eax, eax
jz .fail
mov [img_base], eax
/kernel/branches/kolibri_pe/core/exports.inc
31,7 → 31,6
szPciWrite32 db 'PciWrite32',0
 
szAllocPage db 'AllocPage',0
szAllocPages db 'AllocPages',0
szFreePage db 'FreePage',0
szGetPgAddr db 'GetPgAddr',0
szMapPage db 'MapPage',0
42,7 → 41,7
 
szAllocKernelSpace db 'AllocKernelSpace',0
szFreeKernelSpace db 'FreeKernelSpace',0
szKernelAlloc db 'KernelAlloc',0
szHeapAlloc db 'HeapAlloc',0
szKernelFree db 'KernelFree',0
szUserAlloc db 'UserAlloc',0
szUserFree db 'UserFree',0
104,7 → 103,6
dd szPciWrite32 , pci_write32
 
dd szAllocPage , _alloc_page ;stdcall
dd szAllocPages , _alloc_pages ;stdcall
dd szFreePage , free_page
dd szMapPage , map_page ;stdcall
dd szMapSpace , map_space
113,9 → 111,8
dd szCommitPages , commit_pages ;not implemented
dd szReleasePages , release_pages
 
dd szAllocKernelSpace, alloc_kernel_space ;stdcall
dd szFreeKernelSpace , free_kernel_space ;stdcall
dd szKernelAlloc , kernel_alloc ;stdcall
dd szHeapAlloc , @heap_alloc@8 ;fastcall
dd szKernelFree , kernel_free ;stdcall
dd szUserAlloc , user_alloc ;stdcall
dd szUserFree , user_free ;stdcall
/kernel/branches/kolibri_pe/core/heap.c
335,10 → 335,7
return NULL;
};
 
void* __stdcall alloc_kernel_space(size_t size); //__asm__("alloc_kernel_space");
 
 
void* __stdcall alloc_kernel_space(size_t size)
void * __fastcall heap_alloc(size_t size, u32_t flags)
{
md_t *md;
 
346,16 → 343,36
 
md = find_small_md(size);
 
DBG("alloc_kernel_space: %x size %x\n\n",md->base, size);
if( md )
{
if( flags & PG_MAP )
{
count_t tmp = size >> 12;
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12];
 
if( md )
while(tmp)
{
u32_t order;
addr_t frame;
size_t size;
 
asm volatile ("bsr %0, %1":"=&r"(order):"r"(tmp):"cc");
asm volatile ("btr %0, %1" :"=r"(tmp):"r"(order):"cc");
 
frame = core_alloc(order) | flags;
 
size = (1 << order);
while(size--)
{
*pte++ = frame;
frame+= 4096;
};
};
};
DBG("alloc_heap: %x size %x\n\n",md->base, size);
return (void*)md->base;
};
return NULL;
}
};
 
//void* __stdcall kernel_alloc(size_t size)
//{
//
// return NULL;
//}
//*/
 
/kernel/branches/kolibri_pe/core/heap.inc
45,81 → 45,7
ret
endp
 
align 4
proc kernel_alloc stdcall, size:dword
locals
lin_addr dd ?
pages_count dd ?
endl
 
push ebx
push edi
 
mov eax, [size]
add eax, 4095
and eax, not 4095;
mov [size], eax
test eax, eax
jz .err
 
mov ebx, eax
shr ebx, 12
mov [pages_count], ebx
 
stdcall alloc_kernel_space, eax
test eax, eax
jz .err
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!!!
test eax, eax
jz .err
 
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 .err
 
stdcall map_page,edx,eax,dword PG_SW
add edx, 0x1000
dec ecx
jnz @B
.end:
mov eax, [lin_addr]
pop edi
pop ebx
ret
.err:
xor eax, eax
pop edi
pop ebx
ret
endp
 
align 4
proc kernel_free stdcall, base:dword
 
/kernel/branches/kolibri_pe/core/malloc.inc
983,7 → 983,9
align 4
init_malloc:
 
stdcall kernel_alloc, 0x40000
mov ecx, 6
call @core_alloc@4
add eax, OS_BASE
 
mov [mst.top], eax
mov [mst.topsize], 256*1024
/kernel/branches/kolibri_pe/core/memory.inc
37,42 → 37,37
 
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
push ebx
push edi
mov eax, [size]
add eax, 4095
and eax, -4096
mov [size], eax
stdcall alloc_kernel_space, eax
 
mov ecx, [size]
add ecx, 4095
and ecx, -4096
mov [size], ecx
xor edx, edx
call @mem_alloc@8
test eax, eax
jz .fail
push eax
 
mov edi, 0x1000
mov ebx, eax
mov edx, eax
mov edi, eax
shr edi, 10
add edi, page_tabs
 
mov ecx,[size]
mov edx, [base]
shr eax, 12
shr ecx, 12
and edx, -4096
or edx, [flags]
mov eax, [base]
and eax, -4096
or eax, [flags]
@@:
mov [page_tabs+eax*4], edx
; push eax
; invlpg [ebx]
; pop eax
inc eax
add ebx, edi
add edx, edi
stosd
add eax, 0x1000
loop @B
 
pop eax
mov edx, [base]
and edx, 4095
mov eax, [base]
and eax, 4095
add eax, edx
.fail:
pop edi
pop ebx
ret
endp
 
194,8 → 189,9
cmp dword [LFBAddress], -1
jne @f
mov [BOOT_VAR+0x901c],byte 2
stdcall _alloc_pages, 0x280000 shr 12
add eax, OS_BASE
mov ecx, 0x280000
mov edx, PG_SW
call @mem_alloc@8
mov [LFBAddress], eax
ret
@@:
477,7 → 473,8
test edx, PG_MAP
jnz @F
 
call _alloc_page
xor ecx, ecx
call @core_alloc@4
test eax, eax
jz .fail
 
789,11 → 786,12
mov ecx, [ipc_tmp]
cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page
jbe @f
push eax esi edi
add esi,0x1000
stdcall alloc_kernel_space,esi
push eax
lea ecx, [esi+0x1000]
xor edx, edx
call @mem_alloc@8
mov ecx, eax
pop edi esi eax
pop eax
@@:
mov [used_buf], ecx
stdcall map_mem, ecx, [SLOT_BASE+eax+0xB8],\
820,7 → 818,6
mov [edi+4], ecx
add edi, 8
mov esi, [msg_addr]
; add esi, new_app_base
cld
rep movsb
 
1154,54 → 1151,50
buf_ptr dd ?
endl
 
mov eax, [size]
test eax, eax
jz .fail
mov ecx, [size]
test ecx, 4095
jnz .fail
 
add eax, eax
stdcall alloc_kernel_space, eax
add ecx, ecx
xor edx, edx
call @mem_alloc@8
test eax, eax
mov [buf_ptr], eax
jz .fail
 
push ebx
 
mov [buf_ptr], eax
xor ecx, ecx
mov edx, [size]
shr edx, 12
mov ebx, edx
dec edx
bsr ecx, edx
inc ecx
 
mov ebx, [size]
shr ebx, 12
push ebx
 
stdcall _alloc_pages, ebx
pop ecx
 
call @core_alloc@4
test eax, eax
jz .mm_fail
 
push edi
 
or eax, [flags]
mov edi, [buf_ptr]
mov ebx, [buf_ptr]
mov edx, ecx
shl edx, 2
shr edi, 10
mov edx, [buf_ptr]
lea ecx, [ebx*4]
shr edx, 10
@@:
mov [page_tabs+edi], eax
mov [page_tabs+edi+edx], eax
mov [page_tabs+edx], eax
mov [page_tabs+edx+ecx], eax
add eax, 0x1000
add ebx, 0x1000
add edi, 4
dec ecx
add edx, 4
dec ebx
jnz @B
 
mov eax, [buf_ptr]
pop edi
pop ebx
ret
.mm_fail:
stdcall free_kernel_space, [buf_ptr]
;stdcall free_kernel_space, [buf_ptr]
pop ebx
xor eax, eax
pop ebx
.fail:
ret
endp
/kernel/branches/kolibri_pe/core/mm.c
559,7 → 559,7
v = zone_frame_alloc(&z_core, order);
spinlock_unlock(&z_core.lock);
safe_sti(efl);
 
DBG("core alloc: %x, size %x\n", v << FRAME_WIDTH, (1<<order)<<12);
return (v << FRAME_WIDTH);
};
 
593,29 → 593,6
return (v << FRAME_WIDTH);
};
 
addr_t __stdcall alloc_pages(count_t count) //obsolete
{
eflags_t efl;
u32_t edx;
pfn_t v;
 
count = (count+7)&~7;
 
edx = save_edx();
efl = safe_cli();
spinlock_lock(&z_core.lock);
v = zone_frame_alloc(&z_core, to_order(count));
spinlock_unlock(&z_core.lock);
safe_sti(efl);
 
DBG("alloc_pages: %x count %x\n", v << FRAME_WIDTH, count);
 
restore_edx(edx);
 
return (v << FRAME_WIDTH);
};
 
 
void __fastcall zone_free(zone_t *zone, pfn_t frame_idx)
{
frame_t *frame;
/kernel/branches/kolibri_pe/core/peload.inc
24,14 → 24,14
 
mov [image], eax
 
mov edx, [eax+60]
 
stdcall kernel_alloc, [eax+80+edx]
mov ebx, [eax+60]
mov ecx, [eax+80+edx]
mov edx, PG_SW
call @mem_alloc@8
test eax, eax
mov [base], eax
jz .cleanup
 
mov [base], eax
 
stdcall map_PE, eax, [image]
 
mov [entry], eax
279,13 → 279,11
align 16
__exports:
export 'KERNEL', \
alloc_kernel_space, 'AllocKernelSpace', \ ; stdcall
commit_pages, 'CommitPages', \ ; eax, ebx, ecx
create_kernel_object, 'CreateObject', \
create_ring_buffer, 'CreateRingBuffer', \ ; stdcall
destroy_kernel_object, 'DestroyObject', \
free_kernel_space, 'FreeKernelSpace', \ ; stdcall
kernel_alloc, 'KernelAlloc', \ ; stdcall
kernel_free, 'KernelFree', \ ; stdcall
malloc, 'Kmalloc', \
free, 'Kfree', \
/kernel/branches/kolibri_pe/core/taskman.inc
955,7 → 955,8
pl0_stack dd ?
endl
 
stdcall _alloc_pages, (RING0_STACK_SIZE+512) shr 12
mov ecx, 1 ;(RING0_STACK_SIZE+512) shr 12
call @core_alloc@4
add eax, OS_BASE
mov [pl0_stack], eax
 
/kernel/branches/kolibri_pe/core/v86.inc
49,10 → 49,11
; first half (0x800 bytes) is page table for addresses 0 - 0x100000,
; second half is for V86-to-linear translation.
; Third and fourth are for I/O permission map.
push 8000h ; blocks less than 8 pages are discontinuous
call kernel_alloc
mov ecx, 2
call @core_alloc@4
test eax, eax
jz .fail2
add eax, OS_BASE
mov [ebx+V86_machine.pagedir], eax
push edi eax
mov edi, eax