Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 1036 → Rev 1037

/kernel/trunk/generic/include/config.h
35,22 → 35,30
 
#define STACK_SIZE PAGE_SIZE
 
#define CONFIG_MEMORY_SIZE (8*1024*1024)
#define CONFIG_MEMORY_SIZE (8 * 1024 * 1024)
#define CONFIG_STACK_SIZE STACK_SIZE
#define CONFIG_INIT_TASKS 32
 
struct config {
typedef struct {
__address addr;
size_t size;
} init_task_t;
 
typedef struct {
count_t cnt;
init_task_t tasks[CONFIG_INIT_TASKS];
} init_t;
 
typedef struct {
count_t cpu_count;
volatile count_t cpu_active;
 
__address base;
size_t memory_size;
__address init_addr;
size_t init_size;
size_t kernel_size; /**< Size of memory in bytes taken by kernel and stack */
};
} config_t;
 
extern config_t config;
extern init_t init;
 
#endif
/kernel/trunk/generic/include/typedefs.h
40,7 → 40,6
 
typedef unsigned long long task_id_t;
 
typedef struct config config_t;
typedef struct cpu_info cpu_info_t;
 
typedef struct cpu cpu_t;
/kernel/trunk/generic/src/main/kinit.c
132,16 → 132,17
panic("thread_create/kconsole\n");
 
interrupts_enable();
 
if (config.init_size > 0) {
count_t i;
for (i = 0; i < init.cnt; i++) {
/*
* Create the first user task.
* Run user tasks.
*/
if (config.init_addr % FRAME_SIZE)
panic("config.init_addr is not frame aligned");
if (init.tasks[i].addr % FRAME_SIZE)
panic("init[%d].addr is not frame aligned", i);
 
utask = task_run_program((void *)config.init_addr);
utask = task_run_program((void *) init.tasks[i].addr);
if (utask)
ipc_phone_0 = &utask->answerbox;
else
/kernel/trunk/generic/src/main/main.c
63,6 → 63,7
#include <smp/smp.h>
 
config_t config; /**< Global configuration structure. */
init_t init = {0}; /**< Initial user-space tasks */
 
context_t ctx;
 
75,9 → 76,6
size_t hardcoded_ktext_size = 0;
size_t hardcoded_kdata_size = 0;
 
__address init_addr = 0;
size_t init_size = 0;
 
void main_bsp(void);
void main_ap(void);
 
110,21 → 108,22
config.base = hardcoded_load_address;
config.memory_size = get_memory_size();
config.init_addr = init_addr;
config.init_size = init_size;
config.kernel_size = ALIGN_UP(hardcoded_ktext_size + hardcoded_kdata_size, PAGE_SIZE);
stackaddr = config.base + config.kernel_size;
/* Avoid placing kernel on top of init */
if (overlaps(stackaddr,CONFIG_STACK_SIZE,
config.init_addr, config.init_size)) {
stackaddr = ALIGN_UP(config.init_addr+config.init_size,
CONFIG_STACK_SIZE);
config.init_size = ALIGN_UP(config.init_size,CONFIG_STACK_SIZE) + CONFIG_STACK_SIZE;
} else {
count_t i;
bool overlap = false;
for (i = 0; i < init.cnt; i++)
if (overlaps(stackaddr, CONFIG_STACK_SIZE, init.tasks[i].addr, init.tasks[i].size)) {
stackaddr = ALIGN_UP(init.tasks[i].addr + init.tasks[i].size, CONFIG_STACK_SIZE);
init.tasks[i].size = ALIGN_UP(init.tasks[i].size, CONFIG_STACK_SIZE) + CONFIG_STACK_SIZE;
overlap = true;
}
if (!overlap)
config.kernel_size += CONFIG_STACK_SIZE;
}
context_save(&ctx);
context_set(&ctx, FADDR(main_bsp_separated_stack),
151,7 → 150,7
* commands.
*/
kconsole_init();
 
/*
* Exception handler initialization, before architecture
* starts adding its own handlers
189,8 → 188,9
task_init();
thread_init();
if (config.init_size > 0)
printf("config.init_addr=%P, config.init_size=%d\n", config.init_addr, config.init_size);
count_t i;
for (i = 0; i < init.cnt; i++)
printf("init[%d].addr=%P, init[%d].size=%d\n", i, init.tasks[i].addr, i, init.tasks[i].size);
ipc_init();
/*
/kernel/trunk/generic/src/mm/frame.c
134,9 → 134,9
ipl = interrupts_disable();
spinlock_lock(&zones.lock);
/* Try to merge */
if (zones.count+1 == ZONES_MAX)
if (zones.count + 1 == ZONES_MAX)
panic("Maximum zone(%d) count exceeded.", ZONES_MAX);
for (i=0; i < zones.count; i++) {
for (i = 0; i < zones.count; i++) {
/* Check for overflow */
z = zones.info[i];
if (overlaps(newzone->base,newzone->count,
148,8 → 148,8
break;
}
/* Move other zones up */
for (j=i;j < zones.count;j++)
zones.info[j+1] = zones.info[j];
for (j = i;j < zones.count; j++)
zones.info[j + 1] = zones.info[j];
zones.info[i] = newzone;
zones.count++;
spinlock_unlock(&zones.lock);
689,8 → 689,8
 
/* Replace existing zones in zoneinfo list */
zones.info[z1] = newzone;
for (i=z2+1;i < zones.count;i++)
zones.info[i-1] = zones.info[i];
for (i = z2 + 1; i < zones.count; i++)
zones.info[i - 1] = zones.info[i];
zones.count--;
 
/* Free old zone information */
808,19 → 808,24
*/
confcount = SIZE2FRAMES(zone_conf_size(count));
if (confframe >= start && confframe < start+count) {
for (;confframe < start+count;confframe++) {
for (;confframe < start + count; confframe++) {
addr = PFN2ADDR(confframe);
if (overlaps(addr, PFN2ADDR(confcount),
KA2PA(config.base),config.kernel_size))
if (overlaps(addr, PFN2ADDR(confcount), KA2PA(config.base), config.kernel_size))
continue;
if (config.init_addr)
if (overlaps(addr,PFN2ADDR(confcount),
KA2PA(config.init_addr),
config.init_size))
continue;
bool overlap = false;
count_t i;
for (i = 0; i < init.cnt; i++)
if (overlaps(addr, PFN2ADDR(confcount), KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
overlap = true;
break;
}
if (overlap)
continue;
break;
}
if (confframe >= start+count)
if (confframe >= start + count)
panic("Cannot find configuration data for zone.");
}
 
989,9 → 994,10
pfn_t firstframe = ADDR2PFN(KA2PA(config.base));
pfn_t lastframe = ADDR2PFN(KA2PA(config.base+config.kernel_size));
frame_mark_unavailable(firstframe,lastframe-firstframe+1);
if (config.init_size > 0)
frame_mark_unavailable(ADDR2PFN(KA2PA(config.init_addr)),
SIZE2FRAMES(config.init_size));
count_t i;
for (i = 0; i < init.cnt; i++)
frame_mark_unavailable(ADDR2PFN(KA2PA(init.tasks[i].addr)), SIZE2FRAMES(init.tasks[i].size));
}
}
 
1009,7 → 1015,7
spinlock_lock(&zones.lock);
printf("# Base address\tFree Frames\tBusy Frames\n");
printf(" ------------\t-----------\t-----------\n");
for (i=0;i<zones.count;i++) {
for (i = 0; i < zones.count; i++) {
zone = zones.info[i];
spinlock_lock(&zone->lock);
printf("%d: %L\t%d\t\t%d\n",i,PFN2ADDR(zone->base),
1032,7 → 1038,7
ipl = interrupts_disable();
spinlock_lock(&zones.lock);
 
for (i=0;i < zones.count; i++) {
for (i = 0; i < zones.count; i++) {
if (i == num || PFN2ADDR(zones.info[i]->base) == num) {
zone = zones.info[i];
break;
/kernel/trunk/arch/amd64/src/boot/boot.S
172,8 → 172,8
addq $0xffffffff80000000, %rdx
mods_invalid:
movq %rcx, init_size
movq %rdx, init_addr
# movq %rcx, init_size
# movq %rdx, init_addr
bt $6, %eax # mbi->flags[6] (mmap_length, mmap_addr valid)
jc mmap_valid
/kernel/trunk/arch/mips32/src/mips32.c
93,9 → 93,11
 
console_init();
debugger_init();
/* Setup usermode...*/
config.init_addr = INIT_ADDRESS;
config.init_size = INIT_SIZE;
/* Setup usermode */
init.cnt = 1;
init.tasks[0].addr = INIT_ADDRESS;
init.tasks[0].size = INIT_SIZE;
}
 
void arch_post_mm_init(void)
/kernel/trunk/arch/ia32/src/boot/boot.S
99,28 → 99,41
mem_invalid:
movl %ecx, e801memorysize
bt $3, %eax # mbi->flags[3] (mods_count, mods_addr valid)
bt $3, %eax # mbi->flags[3] (mods_count, mods_addr valid)
jc mods_valid
xorl %ecx, %ecx
xorl %edx, %edx
jmp mods_invalid
movl %ecx, init
jmp mods_end
mods_valid:
movl 20(%ebx), %ecx # mbi->mods_count
movl %ecx, init
cmpl $0, %ecx
je mods_invalid
je mods_end
movl 24(%ebx), %esi # mbi->mods_addr
movl 0(%esi), %edx # mods->mod_start
movl 4(%esi), %ecx # mods->mod_end
subl %edx, %ecx
addl $0x80000000, %edx
movl $init, %edi
mods_invalid:
movl %ecx, init_size
movl %edx, init_addr
mods_loop:
movl 0(%esi), %edx # mods->mod_start
addl $0x80000000, %edx
movl %edx, 4(%edi)
movl 4(%esi), %edx
subl 0(%esi), %edx # mods->mod_end - mods->mod_start
movl %edx, 8(%edi)
addl $16, %esi
addl $8 , %edi
loop mods_loop
mods_end:
bt $6, %eax # mbi->flags[6] (mmap_length, mmap_addr valid)
jc mmap_valid