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