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);
}
