/kernel/branches/kolibri_pe/core/dll.inc |
---|
562,6 → 562,7 |
; loaded by the load_file() function |
align 4 |
_load_file@4: |
proc load_file stdcall, file_name:dword |
locals |
attr dd ? |
/kernel/branches/kolibri_pe/core/exports.inc |
---|
132,13 → 132,13 |
dd szSelectHwCursor , select_hw_cursor ;import stdcall |
dd szSetHwCursor , set_hw_cursor ;import stdcall |
dd szHwCursorRestore , hw_restore ;import |
dd szHwCursorRestore , hw_restore ;import |
dd szHwCursorCreate , create_cursor ;import |
dd szSysMsgBoardStr , sys_msg_board_str |
dd szSysMsgBoardChar , sys_msg_board |
dd szGetCurrentTask , get_curr_task |
dd szLoadFile , load_file ;retval eax, ebx |
dd szLoadFile , load_file ;retval eax, ebx |
dd szSendEvent , send_event |
dd szSetMouseData , set_mouse_data ;stdcall |
dd szSleep , delay_ms |
/kernel/branches/kolibri_pe/core/heap.c |
---|
8,18 → 8,9 |
#define page_tabs 0xDF800000 |
typedef struct |
{ |
link_t link; |
link_t adj; |
addr_t base; |
size_t size; |
void *parent; |
u32_t state; |
}md_t; |
#define MD_FREE 1 |
#define MD_USED 2 |
#define MD_FREE 1 |
#define MD_USED 2 |
typedef struct { |
u32_t av_mapped; |
63,37 → 54,36 |
int __fastcall init_heap(addr_t base, size_t size) |
{ |
md_t *md; |
u32_t i; |
md_t *md; |
u32_t i; |
ASSERT(base != 0); |
ASSERT(size != 0) |
ASSERT((base & 0x3FFFFF) == 0); |
ASSERT((size & 0x3FFFFF) == 0); |
ASSERT(base != 0); |
ASSERT(size != 0) |
ASSERT((base & 0x3FFFFF) == 0); |
ASSERT((size & 0x3FFFFF) == 0); |
for (i = 0; i < 32; i++) |
{ |
for (i = 0; i < 32; i++) |
{ |
list_initialize(&lheap.mapped[i]); |
list_initialize(&lheap.unmapped[i]); |
list_initialize(&sheap.mapped[i]); |
list_initialize(&sheap.unmapped[i]); |
}; |
}; |
list_initialize(&lheap.used); |
list_initialize(&sheap.used); |
list_initialize(&lheap.used); |
list_initialize(&sheap.used); |
md_slab = slab_cache_create(sizeof(md_t), 32,NULL,NULL,SLAB_CACHE_MAGDEFERRED); |
md_slab = slab_cache_create(sizeof(md_t), 32,NULL,NULL,SLAB_CACHE_MAGDEFERRED); |
md = (md_t*)slab_alloc(md_slab,0); |
md = (md_t*)slab_alloc(md_slab,0); |
list_initialize(&md->adj); |
md->base = base; |
md->size = size; |
md->parent = NULL; |
md->state = MD_FREE; |
list_initialize(&md->adj); |
md->base = base; |
md->size = size; |
md->parent = NULL; |
md->state = MD_FREE; |
list_prepend(&md->link, &lheap.unmapped[31]); |
lheap.av_mapped = 0x00000000; |
lheap.av_unmapped = 0x80000000; |
100,82 → 90,82 |
sheap.av_mapped = 0x00000000; |
sheap.av_unmapped = 0x00000000; |
return 1; |
return 1; |
}; |
md_t* __fastcall find_large_md(size_t size) |
{ |
md_t *md = NULL; |
md_t *md = NULL; |
count_t idx0; |
u32_t mask; |
count_t idx0; |
u32_t mask; |
ASSERT((size & 0x3FFFFF) == 0); |
ASSERT((size & 0x3FFFFF) == 0); |
idx0 = (size>>22) - 1 < 32 ? (size>>22) - 1 : 31; |
idx0 = (size>>22) - 1 < 32 ? (size>>22) - 1 : 31; |
mask = lheap.av_unmapped & ( -1<<idx0 ); |
if(mask) |
{ |
if(idx0 == 31) |
{ |
if(mask) |
{ |
if(idx0 == 31) |
{ |
md_t *tmp = (md_t*)lheap.unmapped[31].next; |
while((link_t*)tmp != &lheap.unmapped[31]) |
{ |
if(tmp->size >= size) |
{ |
DBG("remove large tmp %x\n", tmp); |
md = tmp; |
break; |
}; |
}; |
tmp = (md_t*)tmp->link.next; |
} |
else |
{ |
if(tmp->size >= size) |
{ |
DBG("remove large tmp %x\n", tmp); |
idx0 = _bsf(mask); |
md = tmp; |
break; |
}; |
}; |
tmp = (md_t*)tmp->link.next; |
} |
else |
{ |
idx0 = _bsf(mask); |
ASSERT( !list_empty(&lheap.unmapped[idx0])) |
md = (md_t*)lheap.unmapped[idx0].next; |
}; |
} |
else |
return NULL; |
}; |
} |
else |
return NULL; |
ASSERT(md->state == MD_FREE); |
ASSERT(md->state == MD_FREE); |
list_remove((link_t*)md); |
list_remove((link_t*)md); |
if(list_empty(&lheap.unmapped[idx0])) |
_reset_lavu(idx0); |
if(md->size > size) |
{ |
count_t idx1; |
md_t *new_md = (md_t*)slab_alloc(md_slab,0); /* FIXME check */ |
if(md->size > size) |
{ |
count_t idx1; |
md_t *new_md = (md_t*)slab_alloc(md_slab,0); /* FIXME check */ |
link_initialize(&new_md->link); |
list_insert(&new_md->adj, &md->adj); |
link_initialize(&new_md->link); |
list_insert(&new_md->adj, &md->adj); |
new_md->base = md->base; |
new_md->size = size; |
new_md->base = md->base; |
new_md->size = size; |
new_md->parent = NULL; |
new_md->state = MD_USED; |
new_md->state = MD_USED; |
md->base+= size; |
md->size-= size; |
md->base+= size; |
md->size-= size; |
idx1 = (md->size>>22) - 1 < 32 ? (md->size>>22) - 1 : 31; |
idx1 = (md->size>>22) - 1 < 32 ? (md->size>>22) - 1 : 31; |
list_prepend(&md->link, &lheap.unmapped[idx1]); |
_set_lavu(idx1); |
return new_md; |
}; |
md->state = MD_USED; |
return new_md; |
}; |
md->state = MD_USED; |
return md; |
return md; |
} |
md_t* __fastcall find_unmapped_md(size_t size) |
564,7 → 554,7 |
fd = (md_t*)md->adj.next; |
if(fd->state == MD_FREE) |
{ |
{ |
idx = (fd->size>>12) - 1 < 32 ? (fd->size>>12) - 1 : 31; |
list_remove((link_t*)fd); |
590,7 → 580,7 |
slab_free(md_slab, md); |
md = fd; |
}; |
}; |
}; |
md->state = MD_FREE; |
605,15 → 595,15 |
if( list_empty(&sheap.mapped[31])) |
list_prepend(&md->link, &sheap.mapped[31]); |
else |
{ |
{ |
md_t *tmp = (md_t*)sheap.mapped[31].next; |
while((link_t*)tmp != &sheap.mapped[31]) |
{ |
{ |
if(md->base < tmp->base) |
break; |
tmp = (md_t*)tmp->link.next; |
} |
} |
list_insert(&md->link, &tmp->link); |
}; |
}; |
622,16 → 612,12 |
}; |
void * __fastcall mem_alloc(size_t size, u32_t flags) |
md_t* __fastcall md_alloc(size_t size, u32_t flags) |
{ |
eflags_t efl; |
md_t *md; |
DBG("\nmem_alloc: %x bytes\n", size); |
ASSERT(size != 0); |
size = (size+4095)&~4095; |
if( flags & PG_MAP ) |
641,6 → 627,9 |
if( !md ) |
return NULL; |
ASSERT(md->state == MD_USED); |
ASSERT(md->parent != NULL); |
md_t *lmd = (md_t*)md->parent; |
ASSERT( lmd != NULL); |
655,44 → 644,63 |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
while(tmp--) |
{ |
*pte++ = frame; |
frame+= 4096; |
}; |
{ |
*pte++ = frame; |
frame+= 4096; |
}; |
} |
else |
{ |
md = find_unmapped_md(size); |
if( !md ) |
return NULL; |
ASSERT(md->parent != NULL); |
ASSERT(md->state == MD_USED); |
} |
return md; |
}; |
void * __fastcall mem_alloc(size_t size, u32_t flags) |
{ |
eflags_t efl; |
md_t *md; |
DBG("\nmem_alloc: %x bytes\n", size); |
ASSERT(size != 0); |
md = md_alloc(size, flags); |
if( !md ) |
return NULL; |
ASSERT(md->parent != NULL); |
ASSERT(md->state == MD_USED); |
efl = safe_cli(); |
spinlock_lock(&sheap.lock); |
if( list_empty(&sheap.used) ) |
list_prepend(&md->link, &sheap.used); |
else |
{ |
md_t *tmp = (md_t*)sheap.used.next; |
efl = safe_cli(); |
spinlock_lock(&sheap.lock); |
if( list_empty(&sheap.used) ) |
list_prepend(&md->link, &sheap.used); |
else |
while((link_t*)tmp != &sheap.used) |
{ |
md_t *tmp = (md_t*)sheap.used.next; |
if(md->base < tmp->base) |
break; |
tmp = (md_t*)tmp->link.next; |
} |
list_insert(&md->link, &tmp->link); |
}; |
while((link_t*)tmp != &sheap.used) |
{ |
if(md->base < tmp->base) |
break; |
tmp = (md_t*)tmp->link.next; |
} |
list_insert(&md->link, &tmp->link); |
}; |
spinlock_unlock(&sheap.lock); |
safe_sti(efl); |
spinlock_unlock(&sheap.lock); |
safe_sti(efl); |
DBG("allocate: %x size %x\n\n",md->base, size); |
return (void*)md->base; |
DBG("allocate: %x size %x\n\n",md->base, size); |
return (void*)md->base; |
}; |
void __fastcall mem_free(void *mem) |
738,17 → 746,17 |
if(lmd->parent != 0) |
{ |
count_t tmp = md->size >> 12; |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
count_t tmp = md->size >> 12; |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
while(tmp--) |
{ |
*pte++ = 0; |
asm volatile ( |
"invlpg (%0)" |
while(tmp--) |
{ |
*pte++ = 0; |
asm volatile ( |
"invlpg (%0)" |
::"r" (mem) ); |
mem+= 4096; |
}; |
mem+= 4096; |
}; |
free_mapped_md( md ); |
} |
/kernel/branches/kolibri_pe/core/heap.inc |
---|
146,6 → 146,7 |
mov eax, [page_tabs+(esi-1)*4] |
test al, USED_BLOCK |
jz .cantfree |
test al, DONT_FREE_BLOCK |
jnz .cantfree |
159,6 → 160,7 |
mov ebx, edi |
shr edi, 12 |
jz .released |
.release: |
xor ecx, ecx |
xchg ecx, [page_tabs+esi*4] |
/kernel/branches/kolibri_pe/core/memory.inc |
---|
243,6 → 243,7 |
mov ecx, [app_page_tabs+edi*4] |
test ecx, 1 |
jz .next |
mov dword [app_page_tabs+edi*4], 2 |
mov ebx, edi |
shl ebx, 12 |
986,24 → 987,11 |
cmp ebx, OS_BASE |
jae .fail |
stdcall load_PE, ebx |
test eax, eax |
jz @F |
mov esi, eax |
stdcall eax, DRV_ENTRY |
test eax, eax |
jz @F |
mov [eax+SRV.entry], esi |
@@: |
mov ecx, ebx |
call @load_pe_driver@4 |
mov [esp+36], eax |
ret |
.fail: |
xor eax, eax |
mov [esp+36], eax |
1010,27 → 998,6 |
ret |
align 4 |
proc load_pe_driver stdcall, file:dword |
stdcall load_PE, [file] |
test eax, eax |
jz .fail |
mov esi, eax |
stdcall eax, DRV_ENTRY |
test eax, eax |
jz .fail |
mov [eax+SRV.entry], esi |
ret |
.fail: |
xor eax, eax |
ret |
endp |
align 4 |
proc init_mtrr |
cmp [BOOT_VAR+0x901c],byte 2 |
/kernel/branches/kolibri_pe/core/mm.c |
---|
162,23 → 162,23 |
static void zone_release(zone_t *z, pfn_t base, count_t count) |
{ |
int i; |
pfn_t top = base+count; |
int i; |
pfn_t top = base+count; |
if( (base+count < z->base)||(base > z->base+z->count)) |
return; |
if( (base+count < z->base)||(base > z->base+z->count)) |
return; |
if(base < z->base) |
base = z->base; |
if(base < z->base) |
base = z->base; |
if(top > z->base+z->count) |
top = z->base+z->count; |
if(top > z->base+z->count) |
top = z->base+z->count; |
DBG("zone release base %x top %x\n", base, top); |
DBG("zone release base %x top %x\n", base, top); |
for (i = base; i < top; i++) { |
z->frames[i-z->base].refcount = 0; |
buddy_system_free(z, &z->frames[i-z->base].buddy_link); |
for (i = base; i < top; i++) { |
z->frames[i-z->base].refcount = 0; |
buddy_system_free(z, &z->frames[i-z->base].buddy_link); |
} |
}; |
260,12 → 260,12 |
} |
static inline void buddy_mark_busy(zone_t *z, link_t * block) { |
frame_t * frame = (frame_t*)block; |
frame_t * frame = (frame_t*)block; |
frame->refcount = 1; |
} |
static inline void buddy_mark_available(zone_t *z, link_t *block) { |
frame_t *frame = (frame_t*)block; |
frame_t *frame = (frame_t*)block; |
frame->refcount = 0; |
} |
281,15 → 281,15 |
{ |
frame_t *frame; |
index_t index; |
u32_t is_left, is_right; |
u32_t is_left, is_right; |
frame = (frame_t*)block; |
ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),frame->buddy_order)); |
frame = (frame_t*)block; |
ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),frame->buddy_order)); |
is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame); |
is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame); |
ASSERT(is_left ^ is_right); |
ASSERT(is_left ^ is_right); |
if (is_left) { |
index = (frame_index(zone, frame)) + (1 << frame->buddy_order); |
} else { /* if (is_right) */ |
309,56 → 309,56 |
static link_t* __fastcall buddy_system_alloc_block(zone_t *z, link_t *block) |
{ |
link_t *left,*right, *tmp; |
u32_t order; |
u32_t order; |
left = buddy_find_block(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
ASSERT(left); |
left = buddy_find_block(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
ASSERT(left); |
list_remove(left); |
while (1) { |
if (! buddy_get_order(z,left)) { |
buddy_mark_busy(z, left); |
if (! buddy_get_order(z,left)) { |
buddy_mark_busy(z, left); |
return left; |
} |
order = buddy_get_order(z, left); |
order = buddy_get_order(z, left); |
right = buddy_bisect(z, left); |
buddy_set_order(z, left, order-1); |
buddy_set_order(z, right, order-1); |
right = buddy_bisect(z, left); |
buddy_set_order(z, left, order-1); |
buddy_set_order(z, right, order-1); |
tmp = buddy_find_block(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
tmp = buddy_find_block(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
if (tmp == right) { |
right = left; |
left = tmp; |
} |
ASSERT(tmp == left); |
buddy_mark_busy(z, left); |
buddy_system_free(z, right); |
buddy_mark_available(z, left); |
if (tmp == right) { |
right = left; |
left = tmp; |
} |
ASSERT(tmp == left); |
buddy_mark_busy(z, left); |
buddy_system_free(z, right); |
buddy_mark_available(z, left); |
} |
} |
static void __fastcall buddy_system_free(zone_t *z, link_t *block) |
{ |
link_t *buddy, *hlp; |
u8_t i; |
link_t *buddy, *hlp; |
u8_t i; |
/* |
/* |
* Determine block's order. |
*/ |
i = buddy_get_order(z, block); |
i = buddy_get_order(z, block); |
ASSERT(i <= z->max_order); |
ASSERT(i <= z->max_order); |
if (i != z->max_order) { |
if (i != z->max_order) { |
/* |
* See if there is any buddy in the list of order i. |
*/ |
buddy = find_buddy(z, block); |
buddy = find_buddy(z, block); |
if (buddy) { |
ASSERT(buddy_get_order(z, buddy) == i); |
ASSERT(buddy_get_order(z, buddy) == i); |
/* |
* Remove buddy from the list of order i. |
*/ |
367,37 → 367,35 |
/* |
* Invalidate order of both block and buddy. |
*/ |
buddy_set_order(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
buddy_set_order(z, buddy, BUDDY_SYSTEM_INNER_BLOCK); |
buddy_set_order(z, block, BUDDY_SYSTEM_INNER_BLOCK); |
buddy_set_order(z, buddy, BUDDY_SYSTEM_INNER_BLOCK); |
/* |
* Coalesce block and buddy into one block. |
*/ |
hlp = buddy_coalesce(z, block, buddy); |
hlp = buddy_coalesce(z, block, buddy); |
/* |
* Set order of the coalesced block to i + 1. |
*/ |
buddy_set_order(z, hlp, i + 1); |
buddy_set_order(z, hlp, i + 1); |
/* |
* Recursively add the coalesced block to the list of order i + 1. |
*/ |
buddy_system_free(z, hlp); |
buddy_system_free(z, hlp); |
return; |
} |
} |
/* |
* Insert block into the list of order i. |
*/ |
list_append(block, &z->order[i]); |
list_append(block, &z->order[i]); |
} |
static inline frame_t * zone_get_frame(zone_t *zone, index_t frame_idx) |
{ |
ASSERT(frame_idx < zone->count); |
ASSERT(frame_idx < zone->count); |
return &zone->frames[frame_idx]; |
} |
409,8 → 407,8 |
frame = zone_get_frame(zone, frame_idx); |
if (frame->refcount) |
return; |
link = buddy_system_alloc_block(zone, &frame->buddy_link); |
ASSERT(link); |
link = buddy_system_alloc_block(zone, &frame->buddy_link); |
ASSERT(link); |
zone->free_count--; |
} |
418,7 → 416,7 |
{ |
link_t *res, *hlp; |
ASSERT(i <= z->max_order); |
ASSERT(i <= z->max_order); |
/* |
* If the list of order i is not empty, |
480,7 → 478,7 |
/* Allocate frames from zone buddy system */ |
tmp = buddy_system_alloc(zone, order); |
ASSERT(tmp); |
ASSERT(tmp); |
/* Update zone information. */ |
zone->free_count -= (1 << order); |
602,7 → 600,7 |
void __fastcall zone_free(zone_t *zone, pfn_t frame_idx) |
{ |
frame_t *frame; |
u32_t order; |
u32_t order; |
frame = &zone->frames[frame_idx]; |
609,7 → 607,7 |
/* remember frame order */ |
order = frame->buddy_order; |
ASSERT(frame->refcount); |
ASSERT(frame->refcount); |
if (!--frame->refcount) |
{ |
/kernel/branches/kolibri_pe/core/peload.inc |
---|
11,279 → 11,11 |
align 4 |
proc load_PE stdcall, file_name:dword |
locals |
image dd ? |
entry dd ? |
base dd ? |
endl |
stdcall load_file, [file_name] |
test eax, eax |
jz .fail |
mov [image], eax |
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 |
stdcall map_PE, eax, [image] |
mov [entry], eax |
test eax, eax |
jnz .cleanup |
mov ecx, [base] |
call @mem_free@4 |
.cleanup: |
mov ecx, [image] |
call @mem_free@4 |
mov eax, [entry] |
ret |
.fail: |
xor eax, eax |
ret |
endp |
DWORD equ dword |
PTR equ |
align 4 |
map_PE: ;stdcall base:dword, image:dword |
cld |
push ebp |
push edi |
push esi |
push ebx |
sub esp, 60 |
mov ebx, DWORD PTR [esp+84] |
mov ebp, DWORD PTR [esp+80] |
mov edx, ebx |
mov esi, ebx |
add edx, DWORD PTR [ebx+60] |
mov edi, ebp |
mov DWORD PTR [esp+32], edx |
mov ecx, DWORD PTR [edx+84] |
shr ecx, 2 |
rep movsd |
movzx eax, WORD PTR [edx+6] |
mov DWORD PTR [esp+36], 0 |
mov DWORD PTR [esp+16], eax |
jmp L2 |
L3: |
mov eax, DWORD PTR [edx+264] |
test eax, eax |
je L4 |
mov esi, ebx |
mov edi, ebp |
add esi, DWORD PTR [edx+268] |
mov ecx, eax |
add edi, DWORD PTR [edx+260] |
shr ecx, 2 |
rep movsd |
L4: |
mov ecx, DWORD PTR [edx+256] |
add ecx, 4095 |
and ecx, -4096 |
cmp ecx, eax |
jbe L6 |
sub ecx, eax |
add eax, DWORD PTR [edx+260] |
lea edi, [eax+ebp] |
xor eax, eax |
rep stosb |
L6: |
inc DWORD PTR [esp+36] |
add edx, 40 |
L2: |
mov esi, DWORD PTR [esp+16] |
cmp DWORD PTR [esp+36], esi |
jne L3 |
mov edi, DWORD PTR [esp+32] |
cmp DWORD PTR [edi+164], 0 |
je L9 |
mov esi, ebp |
mov ecx, ebp |
sub esi, DWORD PTR [edi+52] |
add ecx, DWORD PTR [edi+160] |
mov eax, esi |
shr eax, 16 |
mov DWORD PTR [esp+12], eax |
jmp L11 |
L12: |
lea ebx, [eax-8] |
xor edi, edi |
shr ebx,1 |
jmp L13 |
L14: |
movzx eax, WORD PTR [ecx+8+edi*2] |
mov edx, eax |
shr eax, 12 |
and edx, 4095 |
add edx, DWORD PTR [ecx] |
cmp ax, 2 |
je L17 |
cmp ax, 3 |
je L18 |
dec ax |
jne L15 |
mov eax, DWORD PTR [esp+12] |
add WORD PTR [edx+ebp], ax |
L17: |
add WORD PTR [edx+ebp], si |
L18: |
add DWORD PTR [edx+ebp], esi |
L15: |
inc edi |
L13: |
cmp edi, ebx |
jne L14 |
add ecx, DWORD PTR [ecx+4] |
L11: |
mov eax, DWORD PTR [ecx+4] |
test eax, eax |
jne L12 |
L9: |
mov edx, DWORD PTR [esp+32] |
cmp DWORD PTR [edx+132], 0 |
je L20 |
mov eax, ebp |
add eax, DWORD PTR [edx+128] |
mov DWORD PTR [esp+40], 0 |
add eax, 20 |
mov DWORD PTR [esp+56], eax |
L22: |
mov ecx, DWORD PTR [esp+56] |
cmp DWORD PTR [ecx-16], 0 |
jne L23 |
cmp DWORD PTR [ecx-8], 0 |
je L25 |
L23: |
mov edi, DWORD PTR [__exports+32] |
mov esi, DWORD PTR [__exports+28] |
mov eax, DWORD PTR [esp+56] |
mov DWORD PTR [esp+20], edi |
add edi, OS_BASE |
add esi, OS_BASE |
mov DWORD PTR [esp+44], esi |
mov ecx, DWORD PTR [eax-4] |
mov DWORD PTR [esp+48], edi |
mov edx, DWORD PTR [eax-20] |
mov DWORD PTR [esp+52], 0 |
add ecx, ebp |
add edx, ebp |
mov DWORD PTR [esp+24], edx |
mov DWORD PTR [esp+28], ecx |
L26: |
mov esi, DWORD PTR [esp+52] |
mov edi, DWORD PTR [esp+24] |
mov eax, DWORD PTR [edi+esi*4] |
test eax, eax |
je L27 |
test eax, eax |
js L27 |
lea edi, [ebp+eax] |
mov eax, DWORD PTR [esp+28] |
mov DWORD PTR [eax+esi*4], 0 |
lea esi, [edi+2] |
push eax |
push 32 |
movzx eax, WORD PTR [edi] |
mov edx, DWORD PTR [esp+56] |
mov eax, DWORD PTR [edx+eax*4] |
add eax, OS_BASE |
push eax |
push esi |
call strncmp |
pop ebx |
xor ebx, ebx |
test eax, eax |
jne L32 |
jmp L30 |
L33: |
push ecx |
push 32 |
mov ecx, DWORD PTR [esp+28] |
mov eax, DWORD PTR [ecx+OS_BASE+ebx*4] |
add eax, OS_BASE |
push eax |
push esi |
call strncmp |
pop edx |
test eax, eax |
jne L34 |
mov esi, DWORD PTR [esp+44] |
mov edx, DWORD PTR [esp+52] |
mov ecx, DWORD PTR [esp+28] |
mov eax, DWORD PTR [esi+ebx*4] |
add eax, OS_BASE |
mov DWORD PTR [ecx+edx*4], eax |
jmp L36 |
L34: |
inc ebx |
L32: |
cmp ebx, DWORD PTR [__exports+24] |
jb L33 |
L36: |
cmp ebx, DWORD PTR [__exports+24] |
jne L37 |
mov esi, msg_unresolved |
call sys_msg_board_str |
lea esi, [edi+2] |
call sys_msg_board_str |
mov esi, msg_CR |
call sys_msg_board_str |
mov DWORD PTR [esp+40], 1 |
jmp L37 |
L30: |
movzx eax, WORD PTR [edi] |
mov esi, DWORD PTR [esp+44] |
mov edi, DWORD PTR [esp+52] |
mov edx, DWORD PTR [esp+28] |
mov eax, DWORD PTR [esi+eax*4] |
add eax, OS_BASE |
mov DWORD PTR [edx+edi*4], eax |
L37: |
inc DWORD PTR [esp+52] |
jmp L26 |
L27: |
add DWORD PTR [esp+56], 20 |
jmp L22 |
L25: |
xor eax, eax |
cmp DWORD PTR [esp+40], 0 |
jne L40 |
L20: |
mov ecx, DWORD PTR [esp+32] |
mov eax, ebp |
add eax, DWORD PTR [ecx+40] |
L40: |
add esp, 60 |
pop ebx |
pop esi |
pop edi |
pop ebp |
ret 8 |
align 16 |
__exports: |
export 'KERNEL', \ |
commit_pages, 'CommitPages', \ ; eax, ebx, ecx |
align 16 |
_kernel_exports: |
export 'KERNEL', \ |
commit_pages, 'CommitPages', \ ; eax, ebx, ecx |
create_kernel_object, 'CreateObject', \ |
create_ring_buffer, 'CreateRingBuffer', \ ; stdcall |
destroy_kernel_object, 'DestroyObject', \ |
292,6 → 24,8 |
free, 'Kfree', \ |
map_io_mem, 'MapIoMem', \ ; stdcall |
get_pg_addr, 'GetPgAddr', \ ; eax |
@mem_alloc@8, 'mem_alloc', \ ; fastcall |
@mem_free@4, 'mem_free', \ ; fastcall |
\ |
select_hw_cursor, 'SelectHwCursor', \ ; stdcall |
set_hw_cursor, 'SetHwCursor', \ ; stdcall |
/kernel/branches/kolibri_pe/core/string.inc |
---|
57,6 → 57,7 |
endp |
align 4 |
_strncmp@12: |
proc strncmp stdcall, s1:dword, s2:dword, n:dword |
push esi |
/kernel/branches/kolibri_pe/core/sys32.inc |
---|
623,11 → 623,11 |
pop ecx |
pop ecx |
.nodebug: |
popad |
popad |
mov edi, [.slot] |
shl edi, 8 |
add edi,SLOT_BASE |
add edi,SLOT_BASE |
mov ecx,[edi+APPDATA.pl0_stack] |
sub ecx, OS_BASE |
639,12 → 639,14 |
mov ecx, [edi+APPDATA.io_map] |
cmp ecx, (tss._io_map_0-OS_BASE+PG_MAP) |
je @F |
je @F |
call @core_free@4 |
@@: |
mov ecx, [edi+APPDATA.io_map+4] |
cmp ecx, (tss._io_map_1-OS_BASE+PG_MAP) |
je @F |
je @F |
call @core_free@4 |
@@: |
mov eax, 0x20202020 |
/kernel/branches/kolibri_pe/core/taskman.inc |
---|
208,7 → 208,7 |
jna @F |
xor eax, eax |
cld |
cld |
rep stosb |
@@: |
mov ecx, [file_base] |
416,7 → 416,6 |
jnz @B |
mov edi, page_tabs |
mov ecx, [app_tabs] |
shl ecx, 10 |
xor eax, eax |
624,7 → 623,6 |
mov eax,1 |
ret |
; call MEM_Get_Linear_Address |
; push ebx |
; push ecx |
/kernel/branches/kolibri_pe/include/core.h |
---|
92,7 → 92,7 |
); |
} |
static inline void _btr(u32_t *data, count_t val) |
extern inline void _btr(u32_t *data, count_t val) |
{ |
asm volatile ("btr %0, %1 \n\t" |
: |
100,3 → 100,22 |
:"cc" |
); |
} |
extern inline void* load_file(const char *path, size_t *size) |
{ |
void* retval; |
size_t tmp; |
__asm__ __volatile__ ( |
"pushl %%eax \n\t" |
"call _load_file@4 \n\t" |
:"=eax" (retval), "=ebx"(tmp) |
:"a" (path) ); |
if(size) |
*size = tmp; |
return retval; |
}; |
//extern __fastcall void* load_file(const char *path, size_t *size); |
/kernel/branches/kolibri_pe/include/mm.h |
---|
22,16 → 22,27 |
int flags; |
} zone_t; |
typedef struct |
{ |
count_t count; |
addr_t frames[18]; |
}phismem_t; |
link_t link; |
link_t adj; |
addr_t base; |
size_t size; |
void *parent; |
u32_t state; |
}md_t; |
#define PG_MAP 1 |
#define PG_WRITE 2 |
#define PG_USER 4 |
#define PG_SW 3 |
#define PG_UW 7 |
#define PAGE_SIZE 4096 |
#define FRAME_WIDTH 12 |
60,15 → 71,19 |
void init_mm(); |
void* __fastcall frame_get_parent(pfn_t pfn); |
void __fastcall frame_set_parent(pfn_t pfn, void *data); |
void frame_free(pfn_t frame); |
addr_t __fastcall core_alloc(u32_t order); |
void __fastcall core_free(addr_t frame); |
void __fastcall core_free(addr_t frame); |
pfn_t alloc_page() __attribute__ ((deprecated)); |
pfn_t __stdcall alloc_pages(count_t count) __asm__ ("_alloc_pages") __attribute__ ((deprecated)); |
void frame_free(pfn_t frame); |
void __fastcall frame_set_parent(pfn_t pfn, void *data); |
void* __fastcall frame_get_parent(pfn_t pfn); |
md_t* __fastcall md_alloc(size_t size, u32_t flags); |
void* __fastcall mem_alloc(size_t size, u32_t flags); |
void __fastcall mem_free(void *mem); |
void* __fastcall mem_alloc(size_t size, u32_t flags) ; |
/kernel/branches/kolibri_pe/kernel.asm |
---|
129,7 → 129,12 |
public _rd_root |
public _rd_root_end |
public _load_file@4 |
public _kernel_exports |
public _strncmp@12 |
extrn __edata |
extrn _16bit_start |
146,11 → 151,13 |
extrn @init_heap@8 |
extrn @find_large_md@4 |
extrn @phis_alloc@4 |
extrn @mem_alloc@8 |
extrn @mem_free@4 |
extrn @load_pe@4 |
extrn @load_pe_driver@4 |
extrn _slab_cache_init |
extrn _alloc_page |
779,7 → 786,8 |
mov [SLOT_BASE+APPDATA.cursor],eax |
mov [SLOT_BASE+APPDATA.cursor+256],eax |
; stdcall load_pe_driver, szAtiHW |
;mov ecx, szAtiHW |
;call @load_pe_driver@4 |
; READ TSC / SECOND |
/kernel/branches/kolibri_pe/makefile |
---|
6,7 → 6,7 |
DEFS = -DUSE_SMP -DCONFIG_DEBUG |
CFLAGS = -c -O2 -I $(INCLUDE) -fomit-frame-pointer -fno-builtin-printf |
CFLAGS = -c -O2 -I $(INCLUDE) -fomit-frame-pointer -fno-builtin |
LDFLAGS = -shared -s -Map kernel.map --image-base 0x100000 --file-alignment 32 |
KERNEL_SRC:= \ |
30,6 → 30,7 |
mm.c \ |
slab.c \ |
heap.c \ |
dll.c \ |
spinlock.c \ |
boot/boot.asm \ |
boot/start.asm |