Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 861 → Rev 860

/kernel/branches/kolibri_pe/core/heap.c
110,7 → 110,7
md_t *new_md = (md_t*)slab_alloc(md_slab,0);
 
link_initialize(&new_md->link);
list_insert(&new_md->adj, &md->adj);
list_insert(&md->adj, &new_md->adj);
 
new_md->base = md->base;
new_md->size = size;
144,34 → 144,19
idx0 = (size>>12) - 1 < 32 ? (size>>12) - 1 : 31;
mask = sheap.availmask & ( -1<<idx0 );
 
//printf("smask %x size %x idx0 %x mask %x\n",sheap.availmask, size, idx0, mask);
 
if(mask)
{
md_t *tmp;
 
idx0 = _bsf(mask);
 
ASSERT( !list_empty(&sheap.list[idx0]))
 
tmp = (md_t*)sheap.list[idx0].next;
md = (md_t*)sheap.list[idx0].next;
 
while((link_t*)tmp != &sheap.list[idx0])
{
if(tmp->size >= size)
{
//printf("remove tmp %x\n", tmp);
list_remove((link_t*)tmp);
list_remove((link_t*)md);
if(list_empty(&sheap.list[idx0]))
_reset_smask(idx0);
md = tmp;
break;
};
tmp = (md_t*)tmp->link.next;
};
};
 
if( !md)
}
else
{
md_t *lmd;
lmd = find_large_md((size+0x3FFFFF)&~0x3FFFFF);
196,7 → 181,7
md_t *new_md = (md_t*)slab_alloc(md_slab,0);
 
link_initialize(&new_md->link);
list_insert(&new_md->adj, &md->adj);
list_insert(&md->adj, &new_md->adj);
 
new_md->base = md->base;
new_md->size = size;
206,30 → 191,9
md->base+= size;
md->size-= size;
 
idx1 = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31;
idx1 = (md->size>>22) - 1 < 32 ? (md->size>>22) - 1 : 31;
 
//printf("insert md %x, base %x size %x idx %x\n", md,md->base, md->size,idx1);
 
if( idx1 < 31)
list_prepend(&md->link, &sheap.list[idx1]);
else
{
if( list_empty(&sheap.list[31]))
list_prepend(&md->link, &sheap.list[31]);
else
{
md_t *tmp = (md_t*)sheap.list[31].next;
 
while((link_t*)tmp != &sheap.list[31])
{
if(md->base < tmp->base)
break;
tmp = (md_t*)tmp->link.next;
}
list_insert(&md->link, &tmp->link);
};
};
 
_set_smask(idx1);
 
safe_sti(efl);
318,8 → 282,6
size = (size+4095)&~4095;
 
md = find_small_md(size);
 
// printf("alloc_kernel_space: %x size %x\n\n",md->base, size);
if( md )
return (void*)md->base;
return NULL;
/kernel/branches/kolibri_pe/core/memory.inc
31,9 → 31,27
 
 
align 4
free_page:
proc free_page
 
;arg: eax page address
; pushfd
; cli
; shr eax, 12 ;page index
; bts dword [sys_pgmap], eax ;that's all!
; cmc
; adc [pg_data.pages_free], 0
; shr eax, 3
; and eax, not 3 ;dword offset from page_map
; add eax, sys_pgmap
; cmp [page_start], eax
; ja @f
; popfd
; ret
;@@:
; mov [page_start], eax
; popfd
ret
endp
 
proc map_io_mem stdcall, base:dword, size:dword, flags:dword
 
127,6 → 145,9
shr esi, 10
add esi, page_tabs
 
; mov ebp, [pg_data.pages_free]
; mov ebx, [page_start]
; mov edx, sys_pgmap
@@:
xor eax, eax
xchg eax, [esi]
133,11 → 154,27
push eax
invlpg [edi]
pop eax
 
; test eax, 1
; jz .next
 
; shr eax, 12
; bts [edx], eax
; cmc
; adc ebp, 0
; shr eax, 3
; and eax, -4
; add eax, edx
; cmp eax, ebx
; jae .next
 
; mov ebx, eax
.next:
add edi, 0x1000
add esi, 4
dec ecx
jnz @B
; mov [pg_data.pages_free], ebp
and [pg_data.pg_mutex],0
popad
ret
403,6 → 440,8
mov ebx, [.err_addr]
mov eax, [.err_code]
 
; xchg bx, bx
 
cmp ebx, HEAP_BASE
jb .user_space ;ñòðàíèöà â ïàìÿòè ïðèëîæåíèÿ ;
 
412,19 → 451,15
cmp ebx, page_tabs
jb .lfb
 
cmp ebx, heap_tabs
jb .user_tabs
 
cmp ebx, OS_BASE
jb .heap_tab
jb .core_tabs
 
jmp .core_tabs
 
; cmp ebx, kernel_tabs
; jb .alloc;.app_tabs ;òàáëèöû ñòðàíèö ïðèëîæåíèÿ ;
;ïðîñòî ñîçäàäèì îäíó
 
 
 
.lfb:
shr ebx, 22
mov edx, [_sys_pdbr + ebx*4]
431,28 → 466,8
mov [master_tab + ebx*4], edx
jmp .exit
 
.user_tabs:
shr ebx, 12
and ebx, 0x3FF
mov edx, [master_tab + ebx*4]
test edx, PG_MAP
jnz .fail
.core_tabs:
 
call _alloc_page
test eax, eax
jz .fail
 
lea edx, [eax + PG_UW]
lea edi, [eax + OS_BASE]
mov ecx, 1024
xor eax, eax
cld
rep stosd
 
mov [master_tab + ebx*4], edx
jmp .exit
 
.heap_tab:
shr ebx, 12
and ebx, 0x3FF
mov edx, [master_tab + ebx*4]
459,20 → 474,18
test edx, PG_MAP
jz .check_ptab ;òàáëèöà ñòðàíèö íå ñîçäàíà
 
jmp .fail
 
 
align 4
.kernel_heap:
 
mov ecx, ebx
shr ebx, 22
mov edx, [master_tab + ebx*4]
test edx, PG_MAP
jz .check_ptab ;òàáëèöà ñòðàíèö íå ñîçäàíà
 
shr ecx, 12
mov eax, [page_tabs+ecx*4]
 
jmp .fail
 
.check_ptab:
mov edx, [_sys_pdbr + ebx*4]
test edx, PG_MAP
/kernel/branches/kolibri_pe/core/mm.c
55,10 → 55,10
size_t core_size;
 
pages = mem_amount >> FRAME_WIDTH;
// printf("last page = %x total pages = %x\n",mem_amount, pages);
printf("last page = %x total pages = %x\n",mem_amount, pages);
 
conf_size = pages*sizeof(frame_t);
// printf("conf_size = %x free mem start =%x\n",conf_size, pg_balloc);
printf("conf_size = %x free mem start =%x\n",conf_size, pg_balloc);
 
zone_create(&z_core, 0, pages);
 
153,7 → 153,7
if(top > z->base+z->count)
top = z->base+z->count;
 
// printf("zone reserve base %x top %x\n", base, top);
printf("zone reserve base %x top %x\n", base, top);
 
for (i = base; i < top; i++)
zone_mark_unavailable(z, i - z->base);
174,7 → 174,7
if(top > z->base+z->count)
top = z->base+z->count;
 
// printf("zone release base %x top %x\n", base, top);
printf("zone release base %x top %x\n", base, top);
 
for (i = base; i < top; i++) {
z->frames[i-z->base].refcount = 0;
586,9 → 586,6
v = zone_frame_alloc(&z_core, 0);
spinlock_unlock(&z_core.lock);
safe_sti(efl);
 
//printf("alloc_page: %x\n", v << FRAME_WIDTH);
 
restore_edx(edx);
return (v << FRAME_WIDTH);
};
607,9 → 604,6
v = zone_frame_alloc(&z_core, to_order(count));
spinlock_unlock(&z_core.lock);
safe_sti(efl);
 
//printf("alloc_pages: %x count %x\n", v << FRAME_WIDTH, count);
 
restore_edx(edx);
 
return (v << FRAME_WIDTH);
/kernel/branches/kolibri_pe/core/taskman.inc
356,7 → 356,7
 
mov eax, [app_size]
add eax, 4095
and eax, not 4095
and eax, NOT(4095)
mov [app_size], eax
mov ebx, eax
shr eax, 12
363,49 → 363,39
mov [app_pages], eax
 
add ebx, 0x3FFFFF
and ebx, not 0x3FFFFF
and ebx, NOT(0x3FFFFF)
shr ebx, 22
mov [app_tabs], ebx
 
mov ecx, [img_size]
add ecx, 4095
and ecx, not 4095
and ecx, NOT(4095)
 
mov [img_size], ecx
shr ecx, 12
mov [img_pages], ecx
 
; if GREEDY_KERNEL
; lea eax, [ecx+ebx+2] ;only image size
; else
; lea eax, [eax+ebx+2] ;all requested memory
; end if
if GREEDY_KERNEL
lea eax, [ecx+ebx+2] ;only image size
else
lea eax, [eax+ebx+2] ;all requested memory
end if
; cmp eax, [pg_data.pages_free]
; ja .fail
 
call _alloc_page
test eax, eax
jz .fail
mov [dir_addr], eax
jz .fail
 
;lea edi, [eax + OS_BASE]
;mov ecx, (OS_BASE shr 20)/4
;xor eax, eax
;cld
;rep stosd
 
;mov ecx, 1024-(OS_BASE shr 20)/4
;mov esi, _sys_pdbr+(OS_BASE shr 20)
;rep movsd
 
lea edi, [eax+OS_BASE]
mov ecx, 512
mov ecx, (OS_BASE shr 20)/4
xor eax, eax
cld
rep stosd
 
mov ecx, 512
mov esi, _sys_pdbr+(HEAP_BASE shr 20)
mov ecx, 1024-(OS_BASE shr 20)/4
mov esi, _sys_pdbr+(OS_BASE shr 20)
rep movsd
 
mov edi, [dir_addr]
412,19 → 402,18
lea eax, [edi+PG_SW]
mov [edi+OS_BASE+(page_tabs shr 20)], eax
 
mov eax, edi
and eax, -4096
call set_cr3
 
 
mov edx, [app_tabs]
mov edi, master_tab
xor edi, edi
@@:
call _alloc_page
test eax, eax
jz .fail
 
or eax, PG_UW
stosd
stdcall map_page_table, edi, eax
add edi, 0x00400000
dec edx
jnz @B
 
/kernel/branches/kolibri_pe/core/init.c
36,14 → 36,14
module_t *mod;
int i;
 
// printf ("mods_count = %d, mods_addr = 0x%x\n",
// (u32_t) boot_mbi->mods_count, (u32_t) boot_mbi->mods_addr);
printf ("mods_count = %d, mods_addr = 0x%x\n",
(u32_t) boot_mbi->mods_count, (u32_t) boot_mbi->mods_addr);
for (i = 0, mod = (module_t *) boot_mbi->mods_addr;
i < boot_mbi->mods_count;i++, mod++)
{
pg_balloc = mod->mod_end;
// printf (" mod_start = 0x%x, mod_end = 0x%x, string = %s\n",
// (u32_t) mod->mod_start,(u32_t) mod->mod_end, (char *) mod->string);
printf (" mod_start = 0x%x, mod_end = 0x%x, string = %s\n",
(u32_t) mod->mod_start,(u32_t) mod->mod_end, (char *) mod->string);
};
mod--;
rd_base = mod->mod_start+OS_BASE;
51,7 → 51,7
rd_fat_end = rd_base + 512 + 4278;
rd_root = rd_base + 512*19;
rd_root_end = rd_base + 512*33;
// printf(" rd_base = %x\n", rd_base);
printf(" rd_base = %x\n", rd_base);
}
 
if (CHECK_FLAG (boot_mbi->flags, 6))
59,8 → 59,8
memory_map_t *mmap;
u32_t page;
 
// printf ("mmap_addr = 0x%x, mmap_length = 0x%x\n",
// (unsigned) boot_mbi->mmap_addr, (unsigned) boot_mbi->mmap_length);
printf ("mmap_addr = 0x%x, mmap_length = 0x%x\n",
(unsigned) boot_mbi->mmap_addr, (unsigned) boot_mbi->mmap_length);
 
for (mmap = (memory_map_t *) boot_mbi->mmap_addr;
(u32_t) mmap < boot_mbi->mmap_addr + boot_mbi->mmap_length;
68,7 → 68,7
+ mmap->size + sizeof (mmap->size)))
{
u32_t page;
/*
 
printf (" size = 0x%x, base_addr = 0x%x%x,"
" length = 0x%x%x, type = 0x%x\n",
(unsigned) mmap->size,
77,7 → 77,7
(unsigned) mmap->length_high,
(unsigned) mmap->length_low,
(unsigned) mmap->type);
*/
 
if( mmap->type != 1)
continue;
page = (mmap->base_addr_low+mmap->length_low)&(~4095);
/kernel/branches/kolibri_pe/core/malloc.inc
986,8 → 986,8
stdcall kernel_alloc, 0x40000
 
mov [mst.top], eax
mov [mst.topsize], 256*1024
mov dword [eax+4], (256*1024) or 1
mov [mst.topsize], 128*1024
mov dword [eax+4], (128*1024) or 1
mov eax, mst.smallbins
@@:
mov [eax+8], eax
/kernel/branches/kolibri_pe/kernel.asm
399,14 → 399,13
mov edi,BOOT_VAR
mov ecx,0x10000 / 4
rep movsd
 
xor edi, edi
xor eax, eax
mov ecx,0x10000 / 4
rep stosd
 
mov edi, 0x40000
mov ecx, (0x90000-0x40000)/4
mov edi, SLOT_BASE
mov ecx,0x10000 / 4
rep stosd
 
mov dword [_sys_pdbr], eax
850,9 → 849,9
;protect io permission map
 
mov esi, [default_io_map]
; stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP
; add esi, 0x1000
; stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP
stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP
add esi, 0x1000
stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP
 
; stdcall map_page,tss._io_map_0,\
; (tss._io_map_0-OS_BASE), PG_MAP
2321,13 → 2320,8
 
cmp ebx,2 ; SET PIXEL
jnz nosb2
mov ebx, [mem_BACKGROUND]
add ebx, 4095
and ebx, -4096
sub ebx, 4
cmp ecx, ebx
ja @F
 
cmp ecx,[mem_BACKGROUND]
jae nosb2
mov eax,[img_background]
mov ebx,[eax+ecx]
and ebx,0xFF000000 ;255*256*256*256
2334,9 → 2328,8
and edx,0x00FFFFFF ;255*256*256+255*256+255
add edx,ebx
mov [eax+ecx],edx
@@:
; mov [bgrchanged],1
ret
 
nosb2:
 
cmp ebx,3 ; DRAW BACKGROUND
2481,24 → 2474,19
mov ax,[BgrDataHeight]
mov [esp+36],eax
ret
 
nogb1:
 
cmp eax,2 ; PIXEL
jnz nogb2
mov ecx, [mem_BACKGROUND]
add ecx, 4095
and ecx, -4096
sub ecx, 4
cmp ebx, ecx
ja @F
 
; mov edx,0x160000-16
; cmp edx,ebx
; jbe nogb2
; mov eax, [ebx+IMG_BACKGROUND]
mov eax,[img_background]
mov eax,[ebx+eax]
 
and eax, 0xFFFFFF
mov [esp+36],eax
@@:
ret
nogb2:
 
/kernel/branches/kolibri_pe/const.inc
195,7 → 195,6
 
OS_TEMP equ 0xDFC00000
 
heap_tabs equ (page_tabs+ (HEAP_BASE shr 10))
kernel_tabs equ (page_tabs+ (OS_BASE shr 10)) ;0xFDE00000
master_tab equ (page_tabs+ (page_tabs shr 10)) ;0xFDFF70000
 
281,7 → 280,7
DONT_DRAW_MOUSE equ (OS_BASE+0x000FFF5)
DONT_SWITCH equ (OS_BASE+0x000FFFF)
 
;TMP_STACK_TOP equ 0x006CC00
TMP_STACK_TOP equ 0x006CC00
 
FONT_II equ (OS_BASE+0x006DC00)
FONT_I equ (OS_BASE+0x006E600)
297,6 → 296,8
 
VGABasePtr equ (OS_BASE+0x00A0000)
 
;RAMDISK equ (OS_BASE+0x0100000)
 
RAMDISK_FAT equ (OS_BASE+0x0180000)
FLOPPY_FAT equ (OS_BASE+0x0182000)
 
/kernel/branches/kolibri_pe/include/link.h
51,7 → 51,7
head->next = link;
}
 
static inline list_insert(link_t *new, link_t *old)
static inline list_insert(link_t *old, link_t *new)
{
new->prev = old->prev;
new->next = old;
/kernel/branches/kolibri_pe/makefile
15,8 → 15,7
core/heap.inc \
core/taskman.inc \
core/sys32.inc \
core/dll.inc \
data32.inc
core/dll.inc
 
PE_SRC:= \
init.c \