int __noreturn
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
cprintf("%s\n\n", message);
print_kerninfo();
pmm_init(); // init physical memory management
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
cpu_idle(); // run idle process
}
int
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
cprintf("%s\n\n", message);
print_kerninfo();
grade_backtrace();
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
pmm_init(); // init physical memory management
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
//LAB1: CAHLLENGE 1 If you try to do it, uncomment lab1_switch_test()
// user/kernel mode switch test
//lab1_switch_test();
cpu_idle(); // run idle process
}
/**
* The entry.
*/
int main(int argc, char *argv[], char *envp[])
{
if (ginfo->status == STATUS_DEBUG)
raise(SIGTRAP);
cons_init();
const char *message = "(THU.CST) os is loading ...";
kprintf("%s\n\n", message);
intr_init();
ide_init();
host_signal_init();
/* Only to initialize lcpu_count. */
mp_init();
pmm_init();
pmm_init_ap();
vmm_init();
sched_init();
proc_init();
swap_init();
fs_init();
sync_init();
umclock_init();
cpu_idle();
host_exit(SIGINT);
return 0;
}
int
kern_init(void) {
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
kprintf ("%s\n\n", message);
/* Only to initialize lcpu_count. */
mp_init ();
pmm_init(); // init physical memory management
pmm_init_ap ();
pic_init(); // init interrupt controller
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
swap_init(); // init swap
fs_init(); // init fs
clock_init(); // init clock interrupt
intr_enable(); // enable irq interrupt
cpu_idle(); // run idle process
}
void __init cpu_init(void)
{
/* Initialize VMM (APIs only available after this) */
vmm_init();
/* We will never come back here. */
vmm_hang();
}
void __init cpu_init(void)
{
#if defined(CONFIG_SMP)
u32 cpu = vmm_smp_processor_id();
if (!cpu) { /* Primary CPU */
vmm_init();
} else { /* Secondary CPUs */
vmm_init_secondary();
}
#else
/* Initialize VMM (APIs only available after this) */
vmm_init();
#endif
/* We will never come back here. */
vmm_hang();
}
void __init cpu_init(struct multiboot_info *binfo)
{
while (1);
/* Initialize VMM (APIs only available after this) */
vmm_init();
/* We should never come back here. */
while (1);
}
int main(int argc, char* argv[argc+1])
{
FILE* pm_log = NULL;
FILE* tlb_log = NULL;
FILE* vmm_log = NULL;
FILE* backstore;
size_t opt;
for (opt = 1; opt < argc && argv[opt][0] == '-'; opt++)
{
switch (argv[opt][1])
{ case '-':
if (strcmp(argv[opt], "--log-physical-memory") == 0) case 'p': {
error(opt == argc - 2, "Option `%s` expected file name\n", argv[opt]);
pm_log = fopen(argv[++opt], "w+");
error(!pm_log, "Could not open file `%s`\n", argv[opt]);
} else if (strcmp(argv[opt], "--log-tlb") == 0) case 't': {
error(opt == argc - 2, "Option `%s` expected file name\n", argv[opt]);
tlb_log = fopen(argv[++opt], "w+");
error(!tlb_log, "Could not open file `%s`", argv[opt]);
}
else if (strcmp(argv[opt], "--log-command") == 0) case 'c': {
error(opt == argc - 2, "Option `%s` expected file name\n", argv[opt]);
vmm_log = fopen(argv[++opt], "w+");
error(!vmm_log, "Could not open file `%s`\n", argv[opt]);
}
else default: {
error(true, usage, argv[0]);
}}
}
error(opt == argc, usage, argv[0]);
backstore = fopen(argv[opt], "r+");
error(!backstore, "Could not open file `%s`\n", argv[opt]);
/* Initialisation*/
vmm_init(&vmm, backstore, vmm_log, tlb_log, pm_log);
/* Exécution */
yyparse();
/* Cleanup */
vmm_clean(&vmm);
if (pm_log) fclose(pm_log);
if (tlb_log) fclose(tlb_log);
if (vmm_log) fclose(vmm_log);
fclose(backstore);
return EXIT_SUCCESS;
}
void __init cpu_init(void)
{
#if defined(CONFIG_SMP)
u32 cpu = vmm_smp_processor_id();
#if defined(ARCH_HAS_DEFTERM_EARLY_PRINT)
arch_defterm_early_putc('0'+cpu);
#endif
if (!cpu) { /* Primary CPU */
vmm_init();
} else { /* Secondary CPUs */
vmm_init_secondary();
}
#else
/* Initialize VMM (APIs only available after this) */
vmm_init();
#endif
/* We will never come back here. */
vmm_hang();
}
void kernel_main(struct multiboot_info* mb_info) {
uint32_t kernel_init_pdir = vmm_init();
kprintf("Setting PIT interval...\n");
outb(0x43, 0x36);
outw(0x40, 1000);
kprintf("Initializing vfs...\n");
vfs_init_root();
ramfs_fifo_init();
ramfs_block_init();
driver_keyboard_init();
map_address_active((uint32_t) mb_info,
(uint32_t) mb_info, 0);
map_address_active((uint32_t) mb_info->mi_mods_addr,
(uint32_t) mb_info->mi_mods_addr, 0);
if (mb_info->mi_flags & MULTIBOOT_INFO_HAS_MODS) {
vmm_map_range(mb_info->mi_mods_addr[0].start,
mb_info->mi_mods_addr[0].start,
mb_info->mi_mods_addr[0].end - mb_info->mi_mods_addr[0].start,
0);
kprintf("Assuming mbmod[0] is a tarball (%d bytes) and unpacking it... \n", mb_info->mi_mods_addr[0].end - mb_info->mi_mods_addr[0].start);
kprintf("Mapped mod from %x to %x\n", mb_info->mi_mods_addr[0].start, mb_info->mi_mods_addr[0].end);
tar_load_ramfs(mb_info->mi_mods_addr[0].start);
} else {
kprintf("[PANIC] No multiboot module (initrfs) available.\n");
}
kprintf("[kernel_res] Creating /dev/vga\n");
vfs_create_kfile("/dev/vga", ramfs_vga_driver_struct(), 0);
if(vfs_exists("/ibin/init")) {
kprintf("[init] /ibin/init found. Executing...\n");
vfs_exec("/ibin/init", 0);
enableScheduling();
}
while(1);
//*********************************************************************** KERNEL END
}
void __noreturn
kern_init(void) {
//setup_exception_vector();
tlb_invalidate_all();
/*
unsigned base = 0xBE000000;
int i, j;
for (j = 10; j < 24; ++j) {
kprintf("\nj=%d\n\n\n", j);
for (i = 0; i < 10; ++i) {
int *addr = (int*)(base + i * 4 + (1 << j));
kprintf("0x%08x=0x%04x\n", addr, (*addr)&0xFFFF);
}
}
*/
pic_init(); // init interrupt controller
cons_init(); // init the console
clock_init(); // init clock interrupt
// panic("init");
check_initrd();
const char *message = "(THU.CST) os is loading ...\n\n";
kprintf(message);
print_kerninfo();
#if 0
kprintf("EX\n");
__asm__ volatile("syscall");
kprintf("EX RET\n");
#endif
pmm_init(); // init physical memory management
vmm_init(); // init virtual memory management
sched_init();
proc_init(); // init process table
ide_init();
fs_init();
intr_enable(); // enable irq interrupt
//*(int*)(0x00124) = 0x432;
//asm volatile("divu $1, $1, $1");
cpu_idle();
}
int kmain() {
low_printname();
init_early_malloc(&_kernel_end);
pmm_pfaInit();
vmm_init();
heap_init();
timing_system_engine_reportstatustoconsole();
//Tests
kernel_doperiodic(1,0); // Force stuff to happen once at the end of initialisation
kernel_idle_process();
return 0;
}
void __init cpu_init(struct multiboot_info *binfo, char *cmdline)
{
memcpy(&boot_info, binfo, sizeof(struct multiboot_info));
memcpy(boot_cmd_line, cmdline, sizeof(boot_cmd_line));
BUG_ON(!(binfo->flags & MULTIBOOT_INFO_MEMORY));
vmm_parse_early_options((char *)boot_cmd_line);
indentify_cpu();
/* Initialize VMM (APIs only available after this) */
vmm_init();
/* We should never come back here. */
vmm_hang();
}
void kmain()
{
if(!pmm_init())
error("Failed initializing PMM.",1);
if(!vmm_init(0))
error("Failed initializing VMM.",1);
initmemory(0);
if(!initinterrupt())
error("Failed initializing interrupt.",1);
if(!initapic())
error("Failed initializing APIC.",1);
if(!initacpi())
error("Failed initializing ACPI.",1);
initmp();
printf("Initialized %d processor(s).\n",getprocessorcount());
haltcpu();
}
static void vm_init_postheap(uint level)
{
#if WITH_KERNEL_VMM
LTRACE_ENTRY;
vmm_init();
/* create vmm regions to cover what is already there from the initial mapping table */
struct mmu_initial_mapping *map = mmu_initial_mappings;
while (map->size > 0) {
if (!(map->flags & MMU_INITIAL_MAPPING_TEMPORARY)) {
vmm_reserve_space(vmm_get_kernel_aspace(), map->name, map->size, map->virt);
}
map++;
}
#endif
}
int
xh_vm_create(void)
{
int error;
if (vm != NULL) {
return (EEXIST);
}
error = vmm_init();
if (error != 0) {
return (error);
}
memflags = 0;
lowmem_limit = (3ull << 30);
return (vm_create(&vm));
}
int kern_init(void)
{
extern char edata[], end[];
memset(edata, 0, end - edata);
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
kprintf("%s\n\n", message);
print_kerninfo();
/* Only to initialize lcpu_count. */
mp_init();
debug_init(); // init debug registers
pmm_init(); // init physical memory management
pmm_init_ap();
pic_init(); // init interrupt controller
idt_init(); // init interrupt descriptor table
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
ide_init(); // init ide devices
#ifdef UCONFIG_SWAP
swap_init(); // init swap
#endif
fs_init(); // init fs
clock_init(); // init clock interrupt
mod_init();
intr_enable(); // enable irq interrupt
/* do nothing */
cpu_idle(); // run idle process
}
extern void swap_init_nios2(void);
int alt_main(void)
{
const char *message = "(THU.CST) os is loading ...";
kprintf("%s\n\n", message);
mp_init();
pmm_init(); // init physical memory management
pmm_init_ap();
vmm_init(); // init virtual memory management
void __noreturn
kern_init(void) {
//setup_exception_vector();
tlb_invalidate_all();
pic_init(); // init interrupt controller
vga_init();
cons_init(); // init the console
clock_init(); // init clock interrupt
check_initrd();
const char *message = "(THU.CST) os is loading ...\n\n";
kprintf(message);
print_kerninfo();
#if 0
kprintf("EX\n");
__asm__ volatile("syscall");
kprintf("EX RET\n");
#endif
pmm_init(); // init physical memory management
vmm_init(); // init virtual memory management
sched_init();
proc_init(); // init process table
ide_init();
fs_init();
intr_enable(); // enable irq interrupt
//*(int*)(0x00124) = 0x432;
//asm volatile("divu $1, $1, $1");
cpu_idle();
}
static int
vmm_handler(module_t mod, int what, void *arg)
{
int error;
switch (what) {
case MOD_LOAD:
vmmdev_init();
if (ppt_avail_devices() > 0)
iommu_init();
error = vmm_init();
if (error == 0)
vmm_initialized = 1;
break;
case MOD_UNLOAD:
error = vmmdev_cleanup();
if (error == 0) {
vmm_resume_p = NULL;
iommu_cleanup();
if (vmm_ipinum != IPI_AST)
vmm_ipi_free(vmm_ipinum);
error = VMM_CLEANUP();
/*
* Something bad happened - prevent new
* VMs from being created
*/
if (error)
vmm_initialized = 0;
}
break;
default:
error = 0;
break;
}
return (error);
}
int main(int argc, char **argv)
{
int vmmflags = VMM_VMCALL_PRINTF;
uint64_t entry = 0;
int ret;
struct vm_trapframe *vm_tf;
int c;
int option_index;
static struct option long_options[] = {
{"debug", no_argument, 0, 'd'},
{"vmmflags", required_argument, 0, 'v'},
{"memsize", required_argument, 0, 'm'},
{"memstart", required_argument, 0, 'M'},
{"stack", required_argument, 0, 'S'},
{"cmdline_extra", required_argument, 0, 'c'},
{"greedy", no_argument, 0, 'g'},
{"scp", no_argument, 0, 's'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
fprintf(stderr, "%p %p %p %p\n", PGSIZE, PGSHIFT, PML1_SHIFT,
PML1_PTE_REACH);
if ((uintptr_t)__procinfo.program_end >= MinMemory) {
fprintf(stderr,
"Panic: vmrunkernel binary extends into guest memory\n");
exit(1);
}
while ((c = getopt_long(argc, argv, "dv:m:M:S:gsh", long_options,
&option_index)) != -1) {
switch (c) {
case 'd':
debug++;
break;
case 'v':
vmmflags = strtoull(optarg, 0, 0);
break;
case 'm':
memsize = strtoull(optarg, 0, 0);
break;
case 'M':
memstart = strtoull(optarg, 0, 0);
break;
case 'S':
stack = strtoull(optarg, 0, 0);
break;
case 'g': /* greedy */
parlib_never_yield = TRUE;
break;
case 's': /* scp */
parlib_wants_to_be_mcp = FALSE;
break;
case 'h':
default:
// Sadly, the getopt_long struct does
// not have a pointer to help text.
for (int i = 0;
i < sizeof(long_options)/sizeof(long_options[0]) - 1;
i++) {
struct option *l = &long_options[i];
fprintf(stderr, "%s or %c%s\n", l->name, l->val,
l->has_arg ? " <arg>" : "");
}
exit(0);
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)]\n", argv[0]);
exit(1);
}
if ((uintptr_t)(memstart + memsize) >= (uintptr_t)BRK_START) {
fprintf(stderr,
"memstart 0x%lx memsize 0x%lx -> 0x%lx is too large; overlaps BRK_START at %p\n",
memstart, memsize, memstart + memsize, BRK_START);
exit(1);
}
ram = mmap((void *)memstart, memsize,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
if (ram != (void *)memstart) {
fprintf(stderr, "Could not mmap 0x%lx bytes at 0x%lx\n",
memsize, memstart);
exit(1);
}
entry = load_kernel(argv[0]);
if (entry == 0) {
fprintf(stderr, "Unable to load kernel %s\n", argv[0]);
exit(1);
}
vm->nr_gpcs = 1;
vm->gpcis = &gpci;
ret = vmm_init(vm, vmmflags);
if (ret) {
fprintf(stderr, "vmm_init failed: %r\n");
exit(1);
}
/* Allocate 3 pages for page table pages: a page of 512 GiB
* PTEs with only one entry filled to point to a page of 1 GiB
* PTEs; a page of 1 GiB PTEs with only one entry filled to
* point to a page of 2 MiB PTEs; and a page of 2 MiB PTEs,
* all of which may be filled. For now, we don't handle
* starting addresses not aligned on 512 GiB boundaries or
* sizes > GiB */
ret = posix_memalign((void **)&p512, PGSIZE, 3 * PGSIZE);
if (ret) {
perror("ptp alloc");
exit(1);
}
/* Set up a 1:1 ("identity") page mapping from guest virtual
* to guest physical using the (host virtual)
* `kerneladdress`. This mapping may be used for only a short
* time, until the guest sets up its own page tables. Be aware
* that the values stored in the table are physical addresses.
* This is subtle and mistakes are easily disguised due to the
* identity mapping, so take care when manipulating these
* mappings. */
p1 = &p512[NPTENTRIES];
p2m = &p512[2 * NPTENTRIES];
fprintf(stderr, "Map %p for %zu bytes\n", memstart, memsize);
/* TODO: fix this nested loop so it's correct for more than
* one GiB. */
for(uintptr_t p4 = memstart; p4 < memstart + memsize;
p4 += PML4_PTE_REACH) {
p512[PML4(p4)] = (uint64_t)p1 | PTE_KERN_RW;
for (uintptr_t p3 = p4; p3 < memstart + memsize;
p3 += PML3_PTE_REACH) {
p1[PML3(p3)] = (uint64_t)p2m | PTE_KERN_RW;
for (uintptr_t p2 = p3; p2 < memstart + memsize; p2 += PML2_PTE_REACH) {
p2m[PML2(p2)] =
(uint64_t)(p2) | PTE_KERN_RW | PTE_PS;
}
}
}
fprintf(stderr, "p512 %p p512[0] is 0x%lx p1 %p p1[0] is 0x%x\n", p512, p512[0], p1, p1[0]);
vm_tf = gth_to_vmtf(vm->gths[0]);
vm_tf->tf_cr3 = (uint64_t) p512;
vm_tf->tf_rip = entry;
vm_tf->tf_rsp = stack;
vm_tf->tf_rsi = (uint64_t) 0;
start_guest_thread(vm->gths[0]);
uthread_sleep_forever();
return 0;
}
int kern_init(uint64_t mbmagic, uint64_t mbmem)
{
extern char edata[], end[];
memset(edata, 0, end - edata);
/* percpu variable for CPU0 is preallocated */
percpu_offsets[0] = __percpu_start;
cons_init(); // init the console
const char *message = "(THU.CST) os is loading ...";
kprintf("%s\n\n", message);
if(mbmagic == MULTIBOOT_BOOTLOADER_MAGIC){
kprintf("Multiboot dectected: param %p\n", (void*)mbmem);
mbmem2e820((Mbdata*)VADDR_DIRECT(mbmem));
parse_initrd((Mbdata*)VADDR_DIRECT(mbmem));
}
print_kerninfo();
/* get_cpu_var not available before tls_init() */
hz_init();
gdt_init(per_cpu_ptr(cpus, 0));
tls_init(per_cpu_ptr(cpus, 0));
acpitables_init();
lapic_init();
numa_init();
pmm_init_numa(); // init physical memory management, numa awared
/* map the lapic */
lapic_init_late();
//init the acpi stuff
idt_init(); // init interrupt descriptor table
pic_init(); // init interrupt controller
// acpi_conf_init();
percpu_init();
cpus_init();
#ifdef UCONFIG_ENABLE_IPI
ipi_init();
#endif
refcache_init();
vmm_init(); // init virtual memory management
sched_init(); // init scheduler
proc_init(); // init process table
sync_init(); // init sync struct
/* ext int */
ioapic_init();
acpi_init();
ide_init(); // init ide devices
#ifdef UCONFIG_SWAP
swap_init(); // init swap
#endif
fs_init(); // init fs
clock_init(); // init clock interrupt
mod_init();
trap_init();
//XXX put here?
bootaps();
intr_enable(); // enable irq interrupt
#ifdef UCONFIG_HAVE_LINUX_DDE36_BASE
dde_kit_init();
#endif
/* do nothing */
cpu_idle(); // run idle process
}
registers_t *kinit(mboot_info_t *mboot, uint32_t mboot_magic)
{
kdbg_init();
assert(mboot_magic == MBOOT_MAGIC2);
mboot_mod_t *mods = (mboot_mod_t *)(assert_higher(mboot->mods_addr));
kernel_elf_init(mboot);
pmm_init(mboot);
vmm_init(mods[0].mod_end);
idt_init();
tss_init();
register_int_handler(INT_PF, page_fault_handler);
register_int_handler(INT_SCHEDULE, switch_kernel_thread);
scheduler_init();
timer_init(500);
/* vfs_init(); */
syscall_init();
process_init((void(*)(void))&_idle);
tar_header_t *tarfs_location = assert_higher((tar_header_t *)mods[0].mod_start);
debug_enabled = 1;
debug("[info] Mboot flags %x\n", mboot->mods_addr);
debug("[info] Mounting tarfs as root\n");
vfs_init();
vfs_mount("/", tarfs_init(tarfs_location));
vfs_mount("/mnt/tarfs", tarfs_init(tarfs_location));
vfs_mount("/dev/debug", debug_dev_init());
keyboard_init();
fopen("/dev/debug", "w");
fopen("/dev/debug", "w");
/* for(;;); */
/* vfs_mount("/", tarfs_init(tarfs_location)); */
/* keyboard_init(); */
/* vfs_mount("/dev/debug", debug_dev_init()); */
/* fopen("/dev/kbd", "r"); */
/* fopen("/dev/debug", "w"); */
/* fopen("/dev/debug", "w"); */
execve("/bin/init",0,0);
debug("[status]========================\n");
debug("[status] Os5 by Thomas Lovén\n");
debug("[status] Kernel git data: [%s (%s)] %s\n", __kernel_git_hash, (__kernel_git_dirty)?"dirty":"clean", __kernel_git_date);
debug("[status] %s: %s\n", __kernel_git_branch, __kernel_git_message);
debug("[status] Kernel compilation: %s %s\n", __kernel_build_date, __kernel_build_time);
debug("[status]========================\n");
thread_t *init = new_thread((void(*)(void))current->proc->mm.code_entry,1);
init->proc = current->proc;
debug("[status] Kernel booted\n");
return switch_kernel_thread(0);
}
/*
ok, this is pman init stage two. we will execute this code, and then jump to the process
manager main processing loop.
What we will do here, is setup the page pool. And initialize System services, along with structures.
Notice, we are now task 0 on the system.
*/
void pman_init_stage2()
{
UINT32 linear, physical;
struct pm_thread *pmthr = NULL;
struct pm_task *pmtsk = NULL;
int i = 0;
int init_size = 0;
/* get rid of the init stuff */
destroy_thread(INIT_THREAD_NUM);
destroy_task(INIT_TASK_NUM);
/*
Open used ports
*/
for(i = 0; i <= 12; i++)
{
open_port(i, 3, PRIV_LEVEL_ONLY);
}
/*
Init stage 1 has placed bootinfo at PMAN_MULTIBOOTINFO_PHYS
before initializing the pool we need to know memory size
and that information is there. So lets map it on our page table.
*/
linear = PMAN_MULTIBOOT_LINEAR + SARTORIS_PROCBASE_LINEAR;
physical = PMAN_MULTIBOOT_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MULTIBOOT_PAGES, PGATT_WRITE_ENA, 2);
/* Reallocate init image */
init_size = init_reloc();
pman_print_set_color(0x7);
pman_print("Mapping Malloc %i pages", PMAN_MALLOC_PAGES);
/* Pagein remaining pages for kmalloc */
linear = PMAN_MALLOC_LINEAR + SARTORIS_PROCBASE_LINEAR; // place after multiboot (this will invalidate the map src/dest linear address,
// we cannot use that area anymore, but it's ok, we used it for init copy only.)
physical = PMAN_MALLOC_PHYS;
map_pages(PMAN_TASK, linear, physical, PMAN_MALLOC_PAGES, PGATT_WRITE_ENA, 2);
pman_print("Initializing tasks/threads.");
/* Show MMAP information */
if(((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->flags & MB_INFO_MMAP && ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length > 0)
{
//Calculate multiboot mmap linear address.
//Sartoris loader left MMAP just after multiboot info structure.
((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr = PMAN_MULTIBOOT_LINEAR + sizeof(struct multiboot_info);
pman_print("Multiboot MMAP Size: %i ", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length);
pman_print("Multiboot mmap linear address: %x", ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr);
struct mmap_entry *entry = NULL;
entry = (struct mmap_entry *)((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_addr;
int kk = 0, mmlen = ((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR)->mmap_length / entry->size;
for(kk = 0; kk < mmlen; kk++)
{
pman_print("Multiboot entry size: %i start: %x end: %x type: %i", entry->size, (UINT32)entry->start, (UINT32)entry->end, entry->type);
entry = (struct mmap_entry *)((UINT32)entry + entry->size);
}
}
else
{
pman_print("No MMAP present.");
}
/* Initialize vmm subsystem */
vmm_init((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR, PMAN_INIT_RELOC_PHYS, PMAN_INIT_RELOC_PHYS + init_size);
tsk_init();
thr_init();
/* Mark SCHED_THR as taken! */
pmtsk = tsk_create(PMAN_TASK);
pmtsk->state = TSK_NORMAL;
pmthr = thr_create(SCHED_THR, pmtsk);
pmthr->state = THR_INTHNDL; // ehm... well... it IS an interrupt handler :D
pmthr->task_id = PMAN_TASK;
pmthr->state = THR_INTHNDL;
pman_print("Initializing allocator and interrupts.");
/* Initialize kernel memory allocator */
kmem_init(PMAN_MALLOC_LINEAR, PMAN_MALLOC_PAGES);
/* get our own interrupt handlers, override microkernel defaults */
int_init();
/* Initialize Scheduler subsystem */
sch_init();
pman_print("InitFS2 Service loading...");
/* Load System Services and init Loader */
loader_init((ADDR)PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS));
//pman_print_clr(7);
pman_print("Loading finished, return INIT image memory to POOL...");
/* Put now unused Init-Fs pages onto vmm managed address space again. */
vmm_add_mem((struct multiboot_info*)PMAN_MULTIBOOT_LINEAR
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS)
,PHYSICAL2LINEAR(PMAN_INIT_RELOC_PHYS + init_size));
pman_print("Signals Initialization...");
/* Initialize global signals container */
init_signals();
pman_print("Commands Initialization...");
/* Initialize Commands subsystem. */
cmd_init();
pman_print_set_color(12);
pman_print("PMAN: Initialization step 2 completed.");
/* Create Scheduler int handler */
if(create_int_handler(32, SCHED_THR, FALSE, 0) < 0)
pman_print_and_stop("Could not create Scheduler thread.");
/* This is it, we are finished! */
process_manager();
}
int
main_continued(void)
{
vm_t vm;
int err;
/* setup for restart with a setjmp */
while (setjmp(restart_jmp_buf) != 0) {
reset_resources();
}
restart_tcb = camkes_get_tls()->tcb_cap;
restart_event_reg_callback(restart_event, NULL);
err = vmm_init();
assert(!err);
print_cpio_info();
/* Create the VM */
err = vm_create(VM_NAME, VM_PRIO, _fault_endpoint, VM_BADGE,
&_vka, &_simple, &_vspace, &_io_ops, &vm);
if (err) {
printf("Failed to create VM\n");
seL4_DebugHalt();
return -1;
}
/* HACK: See if we have a "RAM device" for 1-1 mappings */
map_unity_ram(&vm);
/* Load system images */
printf("Loading Linux: \'%s\' dtb: \'%s\'\n", VM_LINUX_NAME, VM_LINUX_DTB_NAME);
err = load_linux(&vm, VM_LINUX_NAME, VM_LINUX_DTB_NAME);
if (err) {
printf("Failed to load VM image\n");
seL4_DebugHalt();
return -1;
}
vm_vchan_setup(&vm);
/* Power on */
printf("Starting VM\n\n");
err = vm_start(&vm);
if (err) {
printf("Failed to start VM\n");
seL4_DebugHalt();
return -1;
}
/* Loop forever, handling events */
while (1) {
seL4_MessageInfo_t tag;
seL4_Word sender_badge;
tag = seL4_Wait(_fault_endpoint, &sender_badge);
if (sender_badge == 0) {
seL4_Word label;
label = seL4_MessageInfo_get_label(tag);
if (label == IRQ_MESSAGE_LABEL) {
irq_server_handle_irq_ipc(_irq_server);
} else {
printf("Unknown label (%d) for IPC badge %d\n", label, sender_badge);
}
} else if (sender_badge == VUSB_NBADGE) {
vusb_notify();
} else {
assert(sender_badge == VM_BADGE);
err = vm_event(&vm, tag);
if (err) {
/* Shutdown */
vm_stop(&vm);
seL4_DebugHalt();
while (1);
}
}
}
return 0;
}
