1 /* 2 * Copyright 2002-2015, Axel Dörfler, axeld@pinc-software.de. 3 * Distributed under the terms of the MIT License. 4 * 5 * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved. 6 * Distributed under the terms of the NewOS License. 7 */ 8 9 10 /*! This is main - initializes the kernel and launches the Bootscript */ 11 12 13 #include <string.h> 14 15 #include <FindDirectory.h> 16 #include <OS.h> 17 18 #include <arch/platform.h> 19 #include <boot_device.h> 20 #include <boot_item.h> 21 #include <boot_splash.h> 22 #include <commpage.h> 23 #include <condition_variable.h> 24 #include <cpu.h> 25 #include <debug.h> 26 #include <DPC.h> 27 #include <elf.h> 28 #include <find_directory_private.h> 29 #include <fs/devfs.h> 30 #include <fs/KPath.h> 31 #include <int.h> 32 #include <kdevice_manager.h> 33 #include <kdriver_settings.h> 34 #include <kernel_daemon.h> 35 #include <kmodule.h> 36 #include <kscheduler.h> 37 #include <ksyscalls.h> 38 #include <ksystem_info.h> 39 #include <lock.h> 40 #include <low_resource_manager.h> 41 #include <messaging.h> 42 #include <Notifications.h> 43 #include <port.h> 44 #include <posix/realtime_sem.h> 45 #include <posix/xsi_message_queue.h> 46 #include <posix/xsi_semaphore.h> 47 #include <real_time_clock.h> 48 #include <sem.h> 49 #include <smp.h> 50 #include <system_profiler.h> 51 #include <team.h> 52 #include <timer.h> 53 #include <user_debugger.h> 54 #include <user_mutex.h> 55 #include <vfs.h> 56 #include <vm/vm.h> 57 #include <boot/kernel_args.h> 58 59 #include "vm/VMAnonymousCache.h" 60 61 62 //#define TRACE_BOOT 63 #ifdef TRACE_BOOT 64 # define TRACE(x...) dprintf("INIT: " x) 65 #else 66 # define TRACE(x...) ; 67 #endif 68 69 70 void *__dso_handle; 71 72 bool gKernelStartup = true; 73 bool gKernelShutdown = false; 74 75 static kernel_args sKernelArgs; 76 static uint32 sCpuRendezvous; 77 static uint32 sCpuRendezvous2; 78 static uint32 sCpuRendezvous3; 79 80 static int32 main2(void *); 81 82 83 static void 84 non_boot_cpu_init(void* args, int currentCPU) 85 { 86 kernel_args* kernelArgs = (kernel_args*)args; 87 if (currentCPU != 0) 88 cpu_init_percpu(kernelArgs, currentCPU); 89 } 90 91 92 extern "C" int 93 _start(kernel_args *bootKernelArgs, int currentCPU) 94 { 95 if (bootKernelArgs->kernel_args_size != sizeof(kernel_args) 96 || bootKernelArgs->version != CURRENT_KERNEL_ARGS_VERSION) { 97 // This is something we cannot handle right now - release kernels 98 // should always be able to handle the kernel_args of earlier 99 // released kernels. 100 debug_early_boot_message("Version mismatch between boot loader and " 101 "kernel!\n"); 102 return -1; 103 } 104 105 smp_set_num_cpus(bootKernelArgs->num_cpus); 106 107 // wait for all the cpus to get here 108 smp_cpu_rendezvous(&sCpuRendezvous); 109 110 // the passed in kernel args are in a non-allocated range of memory 111 if (currentCPU == 0) 112 memcpy(&sKernelArgs, bootKernelArgs, sizeof(kernel_args)); 113 114 smp_cpu_rendezvous(&sCpuRendezvous2); 115 116 // do any pre-booting cpu config 117 cpu_preboot_init_percpu(&sKernelArgs, currentCPU); 118 thread_preboot_init_percpu(&sKernelArgs, currentCPU); 119 120 // if we're not a boot cpu, spin here until someone wakes us up 121 if (smp_trap_non_boot_cpus(currentCPU, &sCpuRendezvous3)) { 122 // init platform 123 arch_platform_init(&sKernelArgs); 124 125 // setup debug output 126 debug_init(&sKernelArgs); 127 set_dprintf_enabled(true); 128 dprintf("Welcome to kernel debugger output!\n"); 129 dprintf("Haiku revision: %s\n", get_haiku_revision()); 130 131 // init modules 132 TRACE("init CPU\n"); 133 cpu_init(&sKernelArgs); 134 cpu_init_percpu(&sKernelArgs, currentCPU); 135 TRACE("init interrupts\n"); 136 int_init(&sKernelArgs); 137 138 TRACE("init VM\n"); 139 vm_init(&sKernelArgs); 140 // Before vm_init_post_sem() is called, we have to make sure that 141 // the boot loader allocated region is not used anymore 142 boot_item_init(); 143 debug_init_post_vm(&sKernelArgs); 144 low_resource_manager_init(); 145 146 // now we can use the heap and create areas 147 arch_platform_init_post_vm(&sKernelArgs); 148 lock_debug_init(); 149 TRACE("init driver_settings\n"); 150 driver_settings_init(&sKernelArgs); 151 debug_init_post_settings(&sKernelArgs); 152 TRACE("init notification services\n"); 153 notifications_init(); 154 TRACE("init teams\n"); 155 team_init(&sKernelArgs); 156 TRACE("init ELF loader\n"); 157 elf_init(&sKernelArgs); 158 TRACE("init modules\n"); 159 module_init(&sKernelArgs); 160 TRACE("init semaphores\n"); 161 haiku_sem_init(&sKernelArgs); 162 TRACE("init interrupts post vm\n"); 163 int_init_post_vm(&sKernelArgs); 164 cpu_init_post_vm(&sKernelArgs); 165 commpage_init(); 166 call_all_cpus_sync(non_boot_cpu_init, &sKernelArgs); 167 168 TRACE("init system info\n"); 169 system_info_init(&sKernelArgs); 170 171 TRACE("init SMP\n"); 172 smp_init(&sKernelArgs); 173 cpu_build_topology_tree(); 174 TRACE("init timer\n"); 175 timer_init(&sKernelArgs); 176 TRACE("init real time clock\n"); 177 rtc_init(&sKernelArgs); 178 timer_init_post_rtc(); 179 180 TRACE("init condition variables\n"); 181 condition_variable_init(); 182 183 // now we can create and use semaphores 184 TRACE("init VM semaphores\n"); 185 vm_init_post_sem(&sKernelArgs); 186 TRACE("init generic syscall\n"); 187 generic_syscall_init(); 188 smp_init_post_generic_syscalls(); 189 TRACE("init scheduler\n"); 190 scheduler_init(); 191 TRACE("init threads\n"); 192 thread_init(&sKernelArgs); 193 TRACE("init kernel daemons\n"); 194 kernel_daemon_init(); 195 arch_platform_init_post_thread(&sKernelArgs); 196 197 TRACE("init I/O interrupts\n"); 198 int_init_io(&sKernelArgs); 199 TRACE("init VM threads\n"); 200 vm_init_post_thread(&sKernelArgs); 201 low_resource_manager_init_post_thread(); 202 TRACE("init DPC\n"); 203 dpc_init(); 204 TRACE("init VFS\n"); 205 vfs_init(&sKernelArgs); 206 #if ENABLE_SWAP_SUPPORT 207 TRACE("init swap support\n"); 208 swap_init(); 209 #endif 210 TRACE("init POSIX semaphores\n"); 211 realtime_sem_init(); 212 xsi_sem_init(); 213 xsi_msg_init(); 214 215 // Start a thread to finish initializing the rest of the system. Note, 216 // it won't be scheduled before calling scheduler_start() (on any CPU). 217 TRACE("spawning main2 thread\n"); 218 thread_id thread = spawn_kernel_thread(&main2, "main2", 219 B_NORMAL_PRIORITY, NULL); 220 resume_thread(thread); 221 222 // We're ready to start the scheduler and enable interrupts on all CPUs. 223 scheduler_enable_scheduling(); 224 225 // bring up the AP cpus in a lock step fashion 226 TRACE("waking up AP cpus\n"); 227 sCpuRendezvous = sCpuRendezvous2 = 0; 228 smp_wake_up_non_boot_cpus(); 229 smp_cpu_rendezvous(&sCpuRendezvous); // wait until they're booted 230 231 // exit the kernel startup phase (mutexes, etc work from now on out) 232 TRACE("exiting kernel startup\n"); 233 gKernelStartup = false; 234 235 smp_cpu_rendezvous(&sCpuRendezvous2); 236 // release the AP cpus to go enter the scheduler 237 238 TRACE("starting scheduler on cpu 0 and enabling interrupts\n"); 239 scheduler_start(); 240 enable_interrupts(); 241 } else { 242 // lets make sure we're in sync with the main cpu 243 // the boot processor has probably been sending us 244 // tlb sync messages all along the way, but we've 245 // been ignoring them 246 arch_cpu_global_TLB_invalidate(); 247 248 // this is run for each non boot processor after they've been set loose 249 smp_per_cpu_init(&sKernelArgs, currentCPU); 250 251 // wait for all other AP cpus to get to this point 252 smp_cpu_rendezvous(&sCpuRendezvous); 253 smp_cpu_rendezvous(&sCpuRendezvous2); 254 255 // welcome to the machine 256 scheduler_start(); 257 enable_interrupts(); 258 } 259 260 #ifdef TRACE_BOOT 261 // We disable interrupts for this dprintf(), since otherwise dprintf() 262 // would acquires a mutex, which is something we must not do in an idle 263 // thread, or otherwise the scheduler would be seriously unhappy. 264 disable_interrupts(); 265 TRACE("main: done... begin idle loop on cpu %d\n", currentCPU); 266 enable_interrupts(); 267 #endif 268 269 for (;;) 270 cpu_idle(); 271 272 return 0; 273 } 274 275 276 static int32 277 main2(void* /*unused*/) 278 { 279 TRACE("start of main2: initializing devices\n"); 280 281 #if SYSTEM_PROFILER 282 start_system_profiler(SYSTEM_PROFILE_SIZE, SYSTEM_PROFILE_STACK_DEPTH, 283 SYSTEM_PROFILE_INTERVAL); 284 #endif 285 boot_splash_init(sKernelArgs.boot_splash); 286 287 commpage_init_post_cpus(); 288 289 TRACE("init ports\n"); 290 port_init(&sKernelArgs); 291 292 TRACE("init user mutex\n"); 293 user_mutex_init(); 294 295 TRACE("init system notifications\n"); 296 system_notifications_init(); 297 298 TRACE("Init modules\n"); 299 boot_splash_set_stage(BOOT_SPLASH_STAGE_1_INIT_MODULES); 300 module_init_post_threads(); 301 302 // init userland debugging 303 TRACE("Init Userland debugging\n"); 304 init_user_debug(); 305 306 // init the messaging service 307 TRACE("Init Messaging Service\n"); 308 init_messaging_service(); 309 310 /* bootstrap all the filesystems */ 311 TRACE("Bootstrap file systems\n"); 312 boot_splash_set_stage(BOOT_SPLASH_STAGE_2_BOOTSTRAP_FS); 313 vfs_bootstrap_file_systems(); 314 315 TRACE("Init Device Manager\n"); 316 boot_splash_set_stage(BOOT_SPLASH_STAGE_3_INIT_DEVICES); 317 device_manager_init(&sKernelArgs); 318 319 TRACE("Add preloaded old-style drivers\n"); 320 legacy_driver_add_preloaded(&sKernelArgs); 321 322 int_init_post_device_manager(&sKernelArgs); 323 324 TRACE("Mount boot file system\n"); 325 boot_splash_set_stage(BOOT_SPLASH_STAGE_4_MOUNT_BOOT_FS); 326 vfs_mount_boot_file_system(&sKernelArgs); 327 328 #if ENABLE_SWAP_SUPPORT 329 TRACE("swap_init_post_modules\n"); 330 swap_init_post_modules(); 331 #endif 332 333 // CPU specific modules may now be available 334 boot_splash_set_stage(BOOT_SPLASH_STAGE_5_INIT_CPU_MODULES); 335 cpu_init_post_modules(&sKernelArgs); 336 337 TRACE("vm_init_post_modules\n"); 338 boot_splash_set_stage(BOOT_SPLASH_STAGE_6_INIT_VM_MODULES); 339 vm_init_post_modules(&sKernelArgs); 340 341 TRACE("debug_init_post_modules\n"); 342 debug_init_post_modules(&sKernelArgs); 343 344 TRACE("device_manager_init_post_modules\n"); 345 device_manager_init_post_modules(&sKernelArgs); 346 347 boot_splash_set_stage(BOOT_SPLASH_STAGE_7_RUN_BOOT_SCRIPT); 348 boot_splash_uninit(); 349 // NOTE: We could introduce a syscall to draw more icons indicating 350 // stages in the boot script itself. Then we should not free the image. 351 // In that case we should copy it over to the kernel heap, so that we 352 // can still free the kernel args. 353 354 // The boot splash screen is the last user of the kernel args. 355 // Note: don't confuse the kernel_args structure (which is never freed) 356 // with the kernel args ranges it contains (and which are freed here). 357 vm_free_kernel_args(&sKernelArgs); 358 359 // start the init process 360 { 361 KPath serverPath; 362 status_t status = __find_directory(B_SYSTEM_SERVERS_DIRECTORY, 363 gBootDevice, false, serverPath.LockBuffer(), 364 serverPath.BufferSize()); 365 if (status != B_OK) 366 dprintf("main2: find_directory() failed: %s\n", strerror(status)); 367 serverPath.UnlockBuffer(); 368 status = serverPath.Append("/launch_daemon"); 369 if (status != B_OK) { 370 dprintf("main2: constructing path to launch_daemon failed: %s\n", 371 strerror(status)); 372 } 373 374 const char* args[] = { serverPath.Path(), NULL }; 375 int32 argc = 1; 376 thread_id thread; 377 378 thread = load_image(argc, args, NULL); 379 if (thread >= B_OK) { 380 resume_thread(thread); 381 TRACE("launch_daemon started\n"); 382 } else { 383 dprintf("error starting \"%s\" error = %" B_PRId32 " \n", 384 args[0], thread); 385 } 386 } 387 388 return 0; 389 } 390 391