blob: 14a47feda92b754d8ede85072620066388ac99d0 [file] [log] [blame]
// Copyright 2016 The Fuchsia Authors
// Copyright (c) 2013-2015 Travis Geiselbrecht
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT
/*
* Main entry point to the OS. Initializes modules in order and creates
* the default thread.
*/
#include "lk/main.h"
#include <arch.h>
#include <debug.h>
#include <lib/counters.h>
#include <lib/cxxabi-dynamic-init/cxxabi-dynamic-init.h>
#include <lib/debuglog.h>
#include <lib/heap.h>
#include <lib/jtrace/jtrace.h>
#include <lib/lockup_detector.h>
#include <platform.h>
#include <string.h>
#include <zircon/compiler.h>
#include <dev/init.h>
#include <kernel/cpu.h>
#include <kernel/init.h>
#include <kernel/mutex.h>
#include <kernel/thread.h>
#include <kernel/topology.h>
#include <lk/init.h>
#include <phys/handoff.h>
#include <vm/init.h>
#include <vm/vm.h>
static uint secondary_idle_thread_count;
static int bootstrap2(void* arg);
KCOUNTER(timeline_threading, "boot.timeline.threading")
KCOUNTER(timeline_init, "boot.timeline.init")
static bool lk_global_constructors_called_flag = false;
extern void (*const __init_array_start[])();
extern void (*const __init_array_end[])();
bool lk_global_constructors_called() { return lk_global_constructors_called_flag; }
static void call_constructors() {
for (void (*const* a)() = __init_array_start; a != __init_array_end; a++) {
(*a)();
}
lk_global_constructors_called_flag = true;
}
namespace cxxabi_dynamic_init::internal {
bool ConstructorsCalled() { return lk_global_constructors_called(); }
} // namespace cxxabi_dynamic_init::internal
// called from arch code
void lk_main(paddr_t handoff_paddr) {
// get us into some sort of thread context so Thread::Current works.
thread_init_early();
// Initialize debug tracing (if enabled) as early as possible. This allows
// debug tracing to be used before the debug log comes up, and before global
// constructors are executed. Note that if debug tracing is configured to be
// persistent, then trace records will be dropped until we get to the point
// that the ZBI is processed and our NVRAM location is discovered.
//
// Note: it is actually possible to use jtrace before thread_init_early is
// called, but only if it has been configured to use small entries. Large
// entries currently attempt to record the TID of the thread performing the
// init as part of creating a trace entry. On x64, the current thread pointer
// before thread_init_early should be `nullptr` which would be easy to check
// for, but on ARM64, the current thread pointer (stored in TPIDR_EL1) is
// actually set (in start.S) to be a pointer to a dummy structure which is not
// actually a struct Thread, and cannot have it's TID queried.
//
// For now, we simply wait until after thread_init_early to initialize debug
// tracing. In the future, if there is a need to trace during
// thread_init_early, please know that it can be done provided that the
// hazards listed above have been dealt with.
jtrace_init();
// bring the debuglog up early so we can safely printf
dlog_init_early();
// deal with any static constructors
call_constructors();
// we can safely printf now since we have the debuglog, the current thread set
// which holds (a per-line buffer), and global ctors finished (some of the
// printf machinery depends on ctors right now).
// NOTE: botanist depends on this string being printed to serial. If this changes,
// that code must be changed as well. See fxbug.dev/59963#c20.
dprintf(ALWAYS, "printing enabled\n");
lk_primary_cpu_init_level(LK_INIT_LEVEL_EARLIEST, LK_INIT_LEVEL_ARCH_EARLY - 1);
// Carry out any early architecture-specific and platform-specific init
// required to get the boot CPU and platform into a known state.
arch_early_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_ARCH_EARLY, LK_INIT_LEVEL_PLATFORM_EARLY - 1);
// At this point the physmap is available.
HandoffFromPhys(handoff_paddr);
ZX_DEBUG_ASSERT(gPhysHandoff != nullptr);
platform_early_init();
DriverHandoffEarly(*gPhysHandoff);
lk_primary_cpu_init_level(LK_INIT_LEVEL_PLATFORM_EARLY, LK_INIT_LEVEL_ARCH_PREVM - 1);
// At this point, the kernel command line and serial are set up.
dprintf(INFO, "\nwelcome to Zircon\n\n");
dprintf(SPEW, "KASLR: .text section at %p\n", __code_start);
// Perform any additional arch and platform-specific set up that needs to be done
// before virtual memory or the heap are set up.
dprintf(SPEW, "initializing arch pre-vm\n");
arch_prevm_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_ARCH_PREVM, LK_INIT_LEVEL_PLATFORM_PREVM - 1);
dprintf(SPEW, "initializing platform pre-vm\n");
platform_prevm_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_PLATFORM_PREVM, LK_INIT_LEVEL_VM_PREHEAP - 1);
// perform basic virtual memory setup
dprintf(SPEW, "initializing vm pre-heap\n");
vm_init_preheap();
lk_primary_cpu_init_level(LK_INIT_LEVEL_VM_PREHEAP, LK_INIT_LEVEL_HEAP - 1);
// bring up the kernel heap
dprintf(SPEW, "initializing heap\n");
heap_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_HEAP, LK_INIT_LEVEL_VM - 1);
// enable virtual memory
dprintf(SPEW, "initializing vm\n");
vm_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_VM, LK_INIT_LEVEL_TOPOLOGY - 1);
// Initialize the lockup detector, after the platform timer has been
// configured, but before the topology subsystem has brought up other CPUs.
dprintf(SPEW, "initializing lockup detector on boot cpu\n");
lockup_primary_init();
// initialize the system topology
dprintf(SPEW, "initializing system topology\n");
topology_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_TOPOLOGY, LK_INIT_LEVEL_KERNEL - 1);
// initialize other parts of the kernel
dprintf(SPEW, "initializing kernel\n");
kernel_init();
lk_primary_cpu_init_level(LK_INIT_LEVEL_KERNEL, LK_INIT_LEVEL_THREADING - 1);
// create a thread to complete system initialization
dprintf(SPEW, "creating bootstrap completion thread\n");
Thread* t = Thread::Create("bootstrap2", &bootstrap2, NULL, DEFAULT_PRIORITY);
t->Detach();
t->Resume();
// become the idle thread and enable interrupts to start the scheduler
Thread::Current::BecomeIdle();
}
static int bootstrap2(void*) {
timeline_threading.Set(current_ticks());
// As this thread will initialize per-CPU state, ensure that it runs on the boot CPU.
Thread::Current::Get()->SetCpuAffinity(cpu_num_to_mask(BOOT_CPU_ID));
dprintf(SPEW, "top of bootstrap2()\n");
// Initialize the rest of the architecture and platform.
lk_primary_cpu_init_level(LK_INIT_LEVEL_THREADING, LK_INIT_LEVEL_ARCH - 1);
arch_init();
dprintf(SPEW, "initializing platform\n");
lk_primary_cpu_init_level(LK_INIT_LEVEL_ARCH, LK_INIT_LEVEL_PLATFORM - 1);
platform_init();
DriverHandoffLate(*gPhysHandoff);
// At this point, other cores in the system have been started (though may
// not yet be online).
// Perform per-CPU set up on the boot CPU.
DEBUG_ASSERT(arch_curr_cpu_num() == BOOT_CPU_ID);
dprintf(SPEW, "initializing late arch\n");
lk_primary_cpu_init_level(LK_INIT_LEVEL_PLATFORM, LK_INIT_LEVEL_ARCH_LATE - 1);
arch_late_init_percpu();
dprintf(SPEW, "moving to last init level\n");
lk_primary_cpu_init_level(LK_INIT_LEVEL_ARCH_LATE, LK_INIT_LEVEL_LAST);
timeline_init.Set(current_ticks());
return 0;
}
void lk_secondary_cpu_entry() {
cpu_num_t cpu = arch_curr_cpu_num();
DEBUG_ASSERT(cpu != 0);
if (cpu > secondary_idle_thread_count) {
dprintf(CRITICAL,
"Invalid secondary cpu num %u, SMP_MAX_CPUS %d, secondary_idle_thread_count %u\n", cpu,
SMP_MAX_CPUS, secondary_idle_thread_count);
return;
}
// late CPU initialization for secondary CPUs
arch_late_init_percpu();
// secondary cpu initialize from threading level up. 0 to threading was handled in arch
lk_init_level(LK_INIT_FLAG_SECONDARY_CPUS, LK_INIT_LEVEL_THREADING, LK_INIT_LEVEL_LAST);
lockup_secondary_init();
dprintf(SPEW, "entering scheduler on cpu %u\n", cpu);
thread_secondary_cpu_entry();
}
void lk_init_secondary_cpus(uint secondary_cpu_count) {
if (secondary_cpu_count >= SMP_MAX_CPUS) {
dprintf(CRITICAL, "Invalid secondary_cpu_count %u, SMP_MAX_CPUS %d\n", secondary_cpu_count,
SMP_MAX_CPUS);
secondary_cpu_count = SMP_MAX_CPUS - 1;
}
for (uint i = 0; i < secondary_cpu_count; i++) {
Thread* t = Thread::CreateIdleThread(i + 1);
if (!t) {
dprintf(CRITICAL, "could not allocate idle thread %u\n", i + 1);
secondary_idle_thread_count = i;
break;
}
}
secondary_idle_thread_count = secondary_cpu_count;
}