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