[apple/xnu.git] / osfmk / kern / startup.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */

/*
 *	Mach kernel startup.
 */

#include <debug.h>
#include <xpr_debug.h>
#include <mach_kdp.h>
#include <cpus.h>
#include <mach_host.h>
#include <norma_vm.h>
#include <etap.h>

#include <mach/boolean.h>
#include <mach/machine.h>
#include <mach/task_special_ports.h>
#include <mach/vm_param.h>
#include <ipc/ipc_init.h>
#include <kern/assert.h>
#include <kern/misc_protos.h>
#include <kern/clock.h>
#include <kern/cpu_number.h>
#include <kern/etap_macros.h>
#include <kern/machine.h>
#include <kern/processor.h>
#include <kern/sched_prim.h>
#include <kern/mk_sp.h>
#include <kern/startup.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/timer.h>
#include <kern/timer_call.h>
#include <kern/xpr.h>
#include <kern/zalloc.h>
#include <vm/vm_kern.h>
#include <vm/vm_init.h>
#include <vm/vm_map.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_pageout.h>
#include <machine/pmap.h>
#include <sys/version.h>

#ifdef __ppc__
#include <ppc/Firmware.h>
#include <ppc/mappings.h>
#endif

/* Externs XXX */
extern void	rtclock_reset(void);

/* Forwards */
void		cpu_launch_first_thread(
			thread_t			thread);
void		start_kernel_threads(void);
void        swapin_thread();

/*
 *	Running in virtual memory, on the interrupt stack.
 *	Does not return.  Dispatches initial thread.
 *
 *	Assumes that master_cpu is set.
 */
void
setup_main(void)
{
	thread_t	startup_thread;

	sched_init();
	vm_mem_bootstrap();
	ipc_bootstrap();
	vm_mem_init();
	ipc_init();

	/*
	 * As soon as the virtual memory system is up, we record
	 * that this CPU is using the kernel pmap.
	 */
	PMAP_ACTIVATE_KERNEL(master_cpu);

#ifdef __ppc__
	mapping_free_prime();						/* Load up with temporary mapping blocks */
#endif

	machine_init();
	kmod_init();
	clock_init();

	init_timers();
	timer_call_initialize();

	machine_info.max_cpus = NCPUS;
	machine_info.memory_size = mem_size;
	machine_info.avail_cpus = 0;
	machine_info.major_version = KERNEL_MAJOR_VERSION;
	machine_info.minor_version = KERNEL_MINOR_VERSION;

	/*
	 *	Initialize the IPC, task, and thread subsystems.
	 */
	ledger_init();
	task_init();
	act_init();
	thread_init();

	/*
	 *	Initialize the Event Trace Analysis Package.
	 * 	Dynamic Phase: 2 of 2
	 */
	etap_init_phase2();
	
	/*
	 *	Create a kernel thread to start the other kernel
	 *	threads.
	 */
	startup_thread = kernel_thread_with_priority(
										kernel_task, MAXPRI_KERNEL,
											start_kernel_threads, TRUE, FALSE);
	/*
	 * Pretend it is already running.
	 *
	 * We can do this without locking, because nothing
	 * else is running yet.
	 */
	startup_thread->state = TH_RUN;
	hw_atomic_add(&startup_thread->processor_set->run_count, 1);

	/*
	 * Start the thread.
	 */
	cpu_launch_first_thread(startup_thread);
	/*NOTREACHED*/
	panic("cpu_launch_first_thread returns!");
}

/*
 * Now running in a thread.  Create the rest of the kernel threads
 * and the bootstrap task.
 */
void
start_kernel_threads(void)
{
	register int				i;

	thread_bind(current_thread(), cpu_to_processor(cpu_number()));

	/*
	 *	Create the idle threads and the other
	 *	service threads.
	 */
	for (i = 0; i < NCPUS; i++) {
		processor_t		processor = cpu_to_processor(i);
		thread_t		thread;
		spl_t			s;

		thread = kernel_thread_with_priority(
									kernel_task, MAXPRI_KERNEL,
											idle_thread, TRUE, FALSE);
		s = splsched();
		thread_lock(thread);
		thread_bind_locked(thread, processor);
		processor->idle_thread = thread;
		thread->ref_count++;
		thread->state |= TH_IDLE;
		thread_go_locked(thread, THREAD_AWAKENED);
		thread_unlock(thread);
		splx(s);
	}

	/*
	 * Initialize the thread reaper mechanism.
	 */
	thread_reaper_init();

	/*
	 * Initialize the stack swapin mechanism.
	 */
	swapin_init();

	/*
	 * Initialize the periodic scheduler mechanism.
	 */
	sched_tick_init();

	/*
	 * Initialize the thread callout mechanism.
	 */
	thread_call_initialize();

	/*
	 * Invoke some black magic.
	 */
#if __ppc__
	mapping_adjust();
#endif

	/*
	 *	Create the clock service.
	 */
	clock_service_create();

	/*
	 *	Create the device service.
	 */
	device_service_create();

	shared_file_boot_time_init();

#ifdef	IOKIT
	{
		PE_init_iokit();
	}
#endif

	/*
	 *	Start the user bootstrap.
	 */
	
	(void) spllo();		/* Allow interruptions */
	
#ifdef	MACH_BSD
	{ 
		extern void bsd_init(void);
		bsd_init();
	}
#endif

	thread_bind(current_thread(), PROCESSOR_NULL);

	/*
	 *	Become the pageout daemon.
	 */

	vm_pageout();
	/*NOTREACHED*/
}

void
slave_main(void)
{
	processor_t		myprocessor = current_processor();
	thread_t		thread;

	myprocessor->cpu_data = get_cpu_data();
	thread = myprocessor->next_thread;
	myprocessor->next_thread = THREAD_NULL;
	if (thread == THREAD_NULL) {
		thread = machine_wake_thread;
		machine_wake_thread = THREAD_NULL;
	}
        thread_machine_set_current(thread);
	if (thread == machine_wake_thread)
		thread_bind(thread, myprocessor);

	cpu_launch_first_thread(thread);
	/*NOTREACHED*/
	panic("slave_main");
}

/*
 * Now running in a thread context
 */
void
start_cpu_thread(void)
{
	processor_t	processor;

	processor = cpu_to_processor(cpu_number());

	slave_machine_init();

	if (processor->processor_self == IP_NULL) {
		ipc_processor_init(processor);
		ipc_processor_enable(processor);
	}

	(void) thread_terminate(current_act());
}

/*
 *	Start up the first thread on a CPU.
 */
void
cpu_launch_first_thread(
	thread_t		thread)
{
	register int	mycpu = cpu_number();
	processor_t		processor = cpu_to_processor(mycpu);

	processor->cpu_data->preemption_level = 0;

	cpu_up(mycpu);
	start_timer(&kernel_timer[mycpu]);
	clock_get_uptime(&processor->last_dispatch);

	if (thread == THREAD_NULL || thread == processor->idle_thread)
		panic("cpu_launch_first_thread");

	rtclock_reset();		/* start realtime clock ticking */
	PMAP_ACTIVATE_KERNEL(mycpu);

	thread_machine_set_current(thread);
	thread_lock(thread);
	thread->state &= ~TH_UNINT;
	thread->last_processor = processor;
	processor->current_pri = thread->sched_pri;
	_mk_sp_thread_begin(thread, processor);
	thread_unlock(thread);
	timer_switch(&thread->system_timer);

	PMAP_ACTIVATE_USER(thread->top_act, mycpu);

	/* preemption enabled by load_context */
	load_context(thread);
	/*NOTREACHED*/
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* Mach Operating System
	27	* Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
	28	* All Rights Reserved.
	29	*
	30	* Permission to use, copy, modify and distribute this software and its
	31	* documentation is hereby granted, provided that both the copyright
	32	* notice and this permission notice appear in all copies of the
	33	* software, derivative works or modified versions, and any portions
	34	* thereof, and that both notices appear in supporting documentation.
	35	*
	36	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	37	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	38	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	39	*
	40	* Carnegie Mellon requests users of this software to return to
	41	*
	42	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	43	* School of Computer Science
	44	* Carnegie Mellon University
	45	* Pittsburgh PA 15213-3890
	46	*
	47	* any improvements or extensions that they make and grant Carnegie Mellon
	48	* the rights to redistribute these changes.
	49	*/
	50	/*
	51	*/
	52
	53	/*
	54	* Mach kernel startup.
	55	*/
	56
	57	#include <debug.h>
	58	#include <xpr_debug.h>
	59	#include <mach_kdp.h>
	60	#include <cpus.h>
	61	#include <mach_host.h>
	62	#include <norma_vm.h>
	63	#include <etap.h>
	64
65	#include <mach/boolean.h>
66	#include <mach/machine.h>
67	#include <mach/task_special_ports.h>
68	#include <mach/vm_param.h>
69	#include <ipc/ipc_init.h>
70	#include <kern/assert.h>
71	#include <kern/misc_protos.h>
72	#include <kern/clock.h>
73	#include <kern/cpu_number.h>
74	#include <kern/etap_macros.h>
75	#include <kern/machine.h>
76	#include <kern/processor.h>
77	#include <kern/sched_prim.h>
0b4e3aa0	78	#include <kern/mk_sp.h>
1c79356b A	79	#include <kern/startup.h>
	80	#include <kern/task.h>
	81	#include <kern/thread.h>
	82	#include <kern/timer.h>
	83	#include <kern/timer_call.h>
	84	#include <kern/xpr.h>
	85	#include <kern/zalloc.h>
	86	#include <vm/vm_kern.h>
	87	#include <vm/vm_init.h>
	88	#include <vm/vm_map.h>
	89	#include <vm/vm_object.h>
	90	#include <vm/vm_page.h>
	91	#include <vm/vm_pageout.h>
	92	#include <machine/pmap.h>
	93	#include <sys/version.h>
	94
	95	#ifdef __ppc__
	96	#include <ppc/Firmware.h>
	97	#include <ppc/mappings.h>
	98	#endif
	99
	100	/* Externs XXX */
	101	extern void rtclock_reset(void);
	102
	103	/* Forwards */
	104	void cpu_launch_first_thread(
	105	thread_t thread);
	106	void start_kernel_threads(void);
	107	void swapin_thread();
	108
	109	/*
	110	* Running in virtual memory, on the interrupt stack.
	111	* Does not return. Dispatches initial thread.
	112	*
	113	* Assumes that master_cpu is set.
	114	*/
	115	void
	116	setup_main(void)
	117	{
	118	thread_t startup_thread;
	119
	120	sched_init();
	121	vm_mem_bootstrap();
	122	ipc_bootstrap();
	123	vm_mem_init();
	124	ipc_init();
1c79356b A	125
	126	/*
	127	* As soon as the virtual memory system is up, we record
	128	* that this CPU is using the kernel pmap.
	129	*/
	130	PMAP_ACTIVATE_KERNEL(master_cpu);
	131
	132	#ifdef __ppc__
	133	mapping_free_prime(); /* Load up with temporary mapping blocks */
	134	#endif
	135
	136	machine_init();
	137	kmod_init();
	138	clock_init();
	139
	140	init_timers();
	141	timer_call_initialize();
	142
	143	machine_info.max_cpus = NCPUS;
	144	machine_info.memory_size = mem_size;
	145	machine_info.avail_cpus = 0;
	146	machine_info.major_version = KERNEL_MAJOR_VERSION;
	147	machine_info.minor_version = KERNEL_MINOR_VERSION;
	148
	149	/*
	150	* Initialize the IPC, task, and thread subsystems.
	151	*/
	152	ledger_init();
1c79356b A	153	task_init();
	154	act_init();
	155	thread_init();
1c79356b A	156
	157	/*
	158	* Initialize the Event Trace Analysis Package.
	159	* Dynamic Phase: 2 of 2
	160	*/
	161	etap_init_phase2();
	162
	163	/*
	164	* Create a kernel thread to start the other kernel
9bccf70c	165	* threads.
1c79356b	166	*/
0b4e3aa0 A	167	startup_thread = kernel_thread_with_priority(
	168	kernel_task, MAXPRI_KERNEL,
	169	start_kernel_threads, TRUE, FALSE);
1c79356b	170	/*
9bccf70c	171	* Pretend it is already running.
1c79356b	172	*
9bccf70c	173	* We can do this without locking, because nothing
1c79356b A	174	* else is running yet.
	175	*/
	176	startup_thread->state = TH_RUN;
9bccf70c A	177	hw_atomic_add(&startup_thread->processor_set->run_count, 1);
9bccf70c A	178
1c79356b A	179	/*
	180	* Start the thread.
	181	*/
	182	cpu_launch_first_thread(startup_thread);
	183	/NOTREACHED/
	184	panic("cpu_launch_first_thread returns!");
	185	}
	186
	187	/*
	188	* Now running in a thread. Create the rest of the kernel threads
	189	* and the bootstrap task.
	190	*/
	191	void
	192	start_kernel_threads(void)
	193	{
	194	register int i;
	195
	196	thread_bind(current_thread(), cpu_to_processor(cpu_number()));
	197
	198	/*
	199	* Create the idle threads and the other
	200	* service threads.
	201	*/
	202	for (i = 0; i < NCPUS; i++) {
0b4e3aa0 A	203	processor_t processor = cpu_to_processor(i);
	204	thread_t thread;
	205	spl_t s;
	206
	207	thread = kernel_thread_with_priority(
	208	kernel_task, MAXPRI_KERNEL,
	209	idle_thread, TRUE, FALSE);
	210	s = splsched();
	211	thread_lock(thread);
	212	thread_bind_locked(thread, processor);
	213	processor->idle_thread = thread;
	214	thread->ref_count++;
	215	thread->state \|= TH_IDLE;
	216	thread_go_locked(thread, THREAD_AWAKENED);
	217	thread_unlock(thread);
	218	splx(s);
1c79356b A	219	}
1c79356b A	220
9bccf70c A	221	/*
	222	* Initialize the thread reaper mechanism.
	223	*/
	224	thread_reaper_init();
	225
0b4e3aa0 A	226	/*
	227	* Initialize the stack swapin mechanism.
	228	*/
	229	swapin_init();
	230
	231	/*
	232	* Initialize the periodic scheduler mechanism.
	233	*/
	234	sched_tick_init();
	235
1c79356b A	236	/*
	237	* Initialize the thread callout mechanism.
	238	*/
	239	thread_call_initialize();
	240
	241	/*
	242	* Invoke some black magic.
	243	*/
	244	#if __ppc__
	245	mapping_adjust();
	246	#endif
	247
1c79356b A	248	/*
	249	* Create the clock service.
	250	*/
	251	clock_service_create();
	252
	253	/*
	254	* Create the device service.
	255	*/
	256	device_service_create();
	257
	258	shared_file_boot_time_init();
	259
	260	#ifdef IOKIT
	261	{
	262	PE_init_iokit();
	263	}
	264	#endif
	265
	266	/*
	267	* Start the user bootstrap.
	268	*/
	269
	270	(void) spllo(); /* Allow interruptions */
	271
	272	#ifdef MACH_BSD
	273	{
	274	extern void bsd_init(void);
	275	bsd_init();
	276	}
	277	#endif
	278
	279	thread_bind(current_thread(), PROCESSOR_NULL);
	280
	281	/*
	282	* Become the pageout daemon.
	283	*/
	284
	285	vm_pageout();
	286	/NOTREACHED/
	287	}
	288
	289	void
	290	slave_main(void)
	291	{
	292	processor_t myprocessor = current_processor();
	293	thread_t thread;
	294
9bccf70c	295	myprocessor->cpu_data = get_cpu_data();
1c79356b A	296	thread = myprocessor->next_thread;
	297	myprocessor->next_thread = THREAD_NULL;
	298	if (thread == THREAD_NULL) {
	299	thread = machine_wake_thread;
	300	machine_wake_thread = THREAD_NULL;
	301	}
9bccf70c A	302	thread_machine_set_current(thread);
	303	if (thread == machine_wake_thread)
	304	thread_bind(thread, myprocessor);
	305
1c79356b A	306	cpu_launch_first_thread(thread);
	307	/NOTREACHED/
	308	panic("slave_main");
	309	}
	310
	311	/*
	312	* Now running in a thread context
	313	*/
	314	void
	315	start_cpu_thread(void)
	316	{
	317	processor_t processor;
	318
	319	processor = cpu_to_processor(cpu_number());
	320
	321	slave_machine_init();
	322
	323	if (processor->processor_self == IP_NULL) {
	324	ipc_processor_init(processor);
	325	ipc_processor_enable(processor);
	326	}
	327
1c79356b A	328	(void) thread_terminate(current_act());
	329	}
	330
	331	/*
	332	* Start up the first thread on a CPU.
	333	*/
	334	void
	335	cpu_launch_first_thread(
	336	thread_t thread)
	337	{
	338	register int mycpu = cpu_number();
9bccf70c	339	processor_t processor = cpu_to_processor(mycpu);
1c79356b	340
9bccf70c	341	processor->cpu_data->preemption_level = 0;
1c79356b A	342
	343	cpu_up(mycpu);
	344	start_timer(&kernel_timer[mycpu]);
9bccf70c	345	clock_get_uptime(&processor->last_dispatch);
1c79356b	346
9bccf70c A	347	if (thread == THREAD_NULL \|\| thread == processor->idle_thread)
9bccf70c A	348	panic("cpu_launch_first_thread");
1c79356b A	349
	350	rtclock_reset(); /* start realtime clock ticking */
	351	PMAP_ACTIVATE_KERNEL(mycpu);
	352
	353	thread_machine_set_current(thread);
	354	thread_lock(thread);
	355	thread->state &= ~TH_UNINT;
9bccf70c A	356	thread->last_processor = processor;
	357	processor->current_pri = thread->sched_pri;
	358	_mk_sp_thread_begin(thread, processor);
1c79356b A	359	thread_unlock(thread);
	360	timer_switch(&thread->system_timer);
	361
	362	PMAP_ACTIVATE_USER(thread->top_act, mycpu);
	363
	364	/* preemption enabled by load_context */
	365	load_context(thread);
	366	/NOTREACHED/
	367	}