void kernel_start(uint32_t magic, uint32_t addr)
{
PRATTLE("\n////////////////// IncludeOS kernel start ////////////////// \n");
PRATTLE("* Booted with magic 0x%x, grub @ 0x%x \n",
magic, addr);
// generate checksums of read-only areas etc.
__init_sanity_checks();
PRATTLE("* Grub magic: 0x%x, grub info @ 0x%x\n", magic, addr);
// Determine where free memory starts
extern char _end;
uintptr_t free_mem_begin = reinterpret_cast<uintptr_t>(&_end);
uintptr_t memory_end = kernel::memory_end();
if (magic == MULTIBOOT_BOOTLOADER_MAGIC) {
free_mem_begin = _multiboot_free_begin(addr);
memory_end = _multiboot_memory_end(addr);
}
else if (kernel::is_softreset_magic(magic))
{
memory_end = kernel::softreset_memory_end(addr);
}
PRATTLE("* Free mem begin: 0x%zx, memory end: 0x%zx \n",
free_mem_begin, memory_end);
PRATTLE("* Moving symbols. \n");
// Preserve symbols from the ELF binary
free_mem_begin += _move_symbols(free_mem_begin);
PRATTLE("* Free mem moved to: %p \n", (void*) free_mem_begin);
PRATTLE("* Init .bss\n");
_init_bss();
// Instantiate machine
size_t memsize = memory_end - free_mem_begin;
__machine = os::Machine::create((void*)free_mem_begin, memsize);
PRATTLE("* Init ELF parser\n");
_init_elf_parser();
// Begin portable HAL initialization
__machine->init();
// TODO: Move more stuff into Machine::init
RNG::init();
PRATTLE("* Init syscalls\n");
_init_syscalls();
PRATTLE("* Init CPU exceptions\n");
x86::idt_initialize_for_cpu(0);
x86::init_libc(magic, addr);
}
void kernel_start(uintptr_t magic, uintptr_t addr)
{
// Initialize default serial port
__init_serial1();
// generate checksums of read-only areas etc.
__init_sanity_checks();
// Determine where free memory starts
extern char _end;
uintptr_t free_mem_begin = reinterpret_cast<uintptr_t>(&_end);
if (magic == MULTIBOOT_BOOTLOADER_MAGIC) {
free_mem_begin = _multiboot_free_begin(addr);
}
// Preserve symbols from the ELF binary
free_mem_begin += _move_symbols(free_mem_begin);
// Initialize zero-initialized vars
_init_bss();
// Initialize heap
_init_heap(free_mem_begin);
// Initialize stack-unwinder, call global constructors etc.
_init_c_runtime();
// Initialize system calls
_init_syscalls();
// Initialize early OS, platform and devices
OS::start(magic, addr);
// Initialize common subsystems and call Service::start
OS::post_start();
// verify certain read-only sections in memory
kernel_sanity_checks();
// Starting event loop from here allows us to profile OS::start
OS::event_loop();
}
//__attribute__((no_sanitize("all")))
void kernel_start(uintptr_t magic, uintptr_t addrin)
{
kprintf("Magic %zx addrin %zx\n",magic,addrin);
__init_sanity_checks();
cpu_print_current_el();
//its a "RAM address 0"
const struct fdt_property *prop;
int addr_cells = 0, size_cells = 0;
int proplen;
//TODO find this somewhere ?.. although it is at memory 0x00
uint64_t fdt_addr=0x40000000;
char *fdt=(char*)fdt_addr;
//OK so these get overidden in the for loop which should return a map of memory and not just a single one
uint64_t addr = 0;
uint64_t size = 0;
//checks both magic and version
if ( fdt_check_header(fdt) != 0 )
{
kprint("FDT Header check failed\r\n");
return;
}
size_cells = fdt_size_cells(fdt,0);
print_le_named32("size_cells :",(char *)&size_cells);
addr_cells = fdt_address_cells(fdt, 0);//fdt32_ld((const fdt32_t *)prop->data);
print_le_named32("addr_cells :",(char *)&addr_cells);
const int mem_offset = fdt_path_offset(fdt, "/memory");
if (mem_offset < 0)
return;
print_le_named32("mem_offset :",(char *)&mem_offset);
prop = fdt_get_property(fdt, mem_offset, "reg", &proplen);
int cellslen = (int)sizeof(uint32_t) * (addr_cells + size_cells);
for (int i = 0; i < proplen / cellslen; ++i) {
for (int j = 0; j < addr_cells; ++j) {
int offset = (cellslen * i) + (sizeof(uint32_t) * j);
addr |= (uint64_t)fdt32_ld((const fdt32_t *)((char *)prop->data + offset)) <<
((addr_cells - j - 1) * 32);
}
for (int j = 0; j < size_cells; ++j) {
int offset = (cellslen * i) +
(sizeof(uint32_t) * (j + addr_cells));
size |= (uint64_t)fdt32_ld((const fdt32_t *)((char *)prop->data + offset)) <<
((size_cells - j - 1) * 32);
}
}
print_le_named64("RAM BASE :",(char *)&addr);
print_le_named64("RAM SIZE :",(char *)&size);
uint64_t mem_end=addr+size;
extern char _end;
uintptr_t free_mem_begin = reinterpret_cast<uintptr_t>(&_end);
//ok now its sane
free_mem_begin += _move_symbols(free_mem_begin);
// Initialize .bss
_init_bss();
// Instantiate machine
size_t memsize = mem_end - free_mem_begin;
__machine = os::Machine::create((void*)free_mem_begin, memsize);
_init_elf_parser();
// Begin portable HAL initialization
__machine->init();
// Initialize system calls
_init_syscalls();
//probably not very sane!
cpu_debug_enable();
cpu_fiq_enable();
cpu_irq_enable();
cpu_serror_enable();
aarch64::init_libc((uintptr_t)fdt_addr);
}