void kbd_init() { assert(!did_init); preemption_disable(); g_kbd_irq_thread = kernel_thread_create(THREAD_PRIORITY_MAX, kbd_irq_thread_proc, NULL, "kbd-irq"); kbd_queue = workqueue_create(g_kbd_irq_thread); g_kbd_test_thread = kernel_thread_create(THREAD_PRIORITY_MAX, test_thread, NULL, "kbd-test-thread"); if (!g_kbd_irq_thread || !kbd_queue || !g_kbd_test_thread) fatal("out of memory"); list_init(&g_kbd_waiters, offsetof(KbdKeyMessage, kbd_waiters)); spinlock_init(&buffer_lock, "Keyboard buffer lock."); buffer_vc = virtual_console_get_current(); thread_start(g_kbd_irq_thread); thread_start(g_kbd_test_thread); did_init = true; preemption_enable(); }
kern_return_t kernel_thread_start_priority( thread_continue_t continuation, void *parameter, integer_t priority, thread_t *new_thread) { kern_return_t result; thread_t thread; result = kernel_thread_create(continuation, parameter, priority, &thread); if (result != KERN_SUCCESS) return (result); *new_thread = thread; thread_mtx_lock(thread); thread_start_internal(thread); thread_mtx_unlock(thread); return (result); }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ #define kernel_bootstrap_kprintf(x...) /* kprintf("kernel_bootstrap: " x) */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); /* i386_vm_init already checks for this ; do it aagin anyway */ if (PE_parse_boot_argn("serverperfmode", &serverperfmode, sizeof (serverperfmode))) { serverperfmode = 1; } scale_setup(); kernel_bootstrap_kprintf("calling vm_mem_bootstrap\n"); vm_mem_bootstrap(); kernel_bootstrap_kprintf("calling vm_mem_init\n"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; kernel_bootstrap_kprintf("calling sched_init\n"); sched_init(); kernel_bootstrap_kprintf("calling wait_queue_bootstrap\n"); wait_queue_bootstrap(); kernel_bootstrap_kprintf("calling ipc_bootstrap\n"); ipc_bootstrap(); #if CONFIG_MACF mac_policy_init(); #endif kernel_bootstrap_kprintf("calling ipc_init\n"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_kprintf("calling PMAP_ACTIVATE_KERNEL\n"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_kprintf("calling mapping_free_prime\n"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_kprintf("calling machine_init\n"); machine_init(); kernel_bootstrap_kprintf("calling clock_init\n"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ kernel_bootstrap_kprintf("calling task_init\n"); task_init(); kernel_bootstrap_kprintf("calling thread_init\n"); thread_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_kprintf("calling kernel_thread_create\n"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread_deallocate(thread); kernel_bootstrap_kprintf("calling load_context - done\n"); load_context(thread); /*NOTREACHED*/ }
void kernel_bootstrap(void) { kern_return_t result; thread_t thread; char namep[16]; printf("%s\n", version); /* log kernel version */ if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */ turn_on_log_leaks = 1; PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs)); PE_parse_boot_argn("trace_wake", &wake_nkdbufs, sizeof (wake_nkdbufs)); PE_parse_boot_argn("trace_panic", &write_trace_on_panic, sizeof(write_trace_on_panic)); PE_parse_boot_argn("trace_typefilter", &trace_typefilter, sizeof(trace_typefilter)); scale_setup(); kernel_bootstrap_log("vm_mem_bootstrap"); vm_mem_bootstrap(); kernel_bootstrap_log("cs_init"); cs_init(); kernel_bootstrap_log("vm_mem_init"); vm_mem_init(); machine_info.memory_size = (uint32_t)mem_size; machine_info.max_mem = max_mem; machine_info.major_version = version_major; machine_info.minor_version = version_minor; #if CONFIG_TELEMETRY kernel_bootstrap_log("telemetry_init"); telemetry_init(); #endif #if CONFIG_CSR kernel_bootstrap_log("csr_init"); csr_init(); #endif kernel_bootstrap_log("stackshot_lock_init"); stackshot_lock_init(); kernel_bootstrap_log("sched_init"); sched_init(); kernel_bootstrap_log("waitq_bootstrap"); waitq_bootstrap(); kernel_bootstrap_log("ipc_bootstrap"); ipc_bootstrap(); #if CONFIG_MACF kernel_bootstrap_log("mac_policy_init"); mac_policy_init(); #endif kernel_bootstrap_log("ipc_init"); ipc_init(); /* * As soon as the virtual memory system is up, we record * that this CPU is using the kernel pmap. */ kernel_bootstrap_log("PMAP_ACTIVATE_KERNEL"); PMAP_ACTIVATE_KERNEL(master_cpu); kernel_bootstrap_log("mapping_free_prime"); mapping_free_prime(); /* Load up with temporary mapping blocks */ kernel_bootstrap_log("machine_init"); machine_init(); kernel_bootstrap_log("clock_init"); clock_init(); ledger_init(); /* * Initialize the IPC, task, and thread subsystems. */ #if CONFIG_COALITIONS kernel_bootstrap_log("coalitions_init"); coalitions_init(); #endif kernel_bootstrap_log("task_init"); task_init(); kernel_bootstrap_log("thread_init"); thread_init(); #if CONFIG_ATM /* Initialize the Activity Trace Resource Manager. */ kernel_bootstrap_log("atm_init"); atm_init(); #endif #if CONFIG_BANK /* Initialize the BANK Manager. */ kernel_bootstrap_log("bank_init"); bank_init(); #endif /* initialize the corpse config based on boot-args */ corpses_init(); /* * Create a kernel thread to execute the kernel bootstrap. */ kernel_bootstrap_log("kernel_thread_create"); result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result); thread->state = TH_RUN; thread->last_made_runnable_time = mach_absolute_time(); thread_deallocate(thread); kernel_bootstrap_log("load_context - done"); load_context(thread); /*NOTREACHED*/ }
kern_return_t processor_start( processor_t processor) { processor_set_t pset; thread_t thread; kern_return_t result; spl_t s; if (processor == PROCESSOR_NULL || processor->processor_set == PROCESSOR_SET_NULL) return (KERN_INVALID_ARGUMENT); if (processor == master_processor) { processor_t prev; prev = thread_bind(processor); thread_block(THREAD_CONTINUE_NULL); result = cpu_start(processor->cpu_id); thread_bind(prev); return (result); } s = splsched(); pset = processor->processor_set; pset_lock(pset); if (processor->state != PROCESSOR_OFF_LINE) { pset_unlock(pset); splx(s); return (KERN_FAILURE); } processor->state = PROCESSOR_START; pset_unlock(pset); splx(s); /* * Create the idle processor thread. */ if (processor->idle_thread == THREAD_NULL) { result = idle_thread_create(processor); if (result != KERN_SUCCESS) { s = splsched(); pset_lock(pset); processor->state = PROCESSOR_OFF_LINE; pset_unlock(pset); splx(s); return (result); } } /* * If there is no active thread, the processor * has never been started. Create a dedicated * start up thread. */ if ( processor->active_thread == THREAD_NULL && processor->next_thread == THREAD_NULL ) { result = kernel_thread_create((thread_continue_t)processor_start_thread, NULL, MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) { s = splsched(); pset_lock(pset); processor->state = PROCESSOR_OFF_LINE; pset_unlock(pset); splx(s); return (result); } s = splsched(); thread_lock(thread); thread->bound_processor = processor; processor->next_thread = thread; thread->state = TH_RUN; thread_unlock(thread); splx(s); thread_deallocate(thread); } if (processor->processor_self == IP_NULL) ipc_processor_init(processor); result = cpu_start(processor->cpu_id); if (result != KERN_SUCCESS) { s = splsched(); pset_lock(pset); processor->state = PROCESSOR_OFF_LINE; pset_unlock(pset); splx(s); return (result); } ipc_processor_enable(processor); return (KERN_SUCCESS); }