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