[apple/xnu.git] / osfmk / i386 / hardclock.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The 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, QUIET ENJOYMENT 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 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.
 */
/*
 */

/*
 * Clock interrupt.
 */
#include <cpus.h>
#include <time_stamp.h>
#include <mach_kdb.h>
#include <kern/cpu_number.h>
#include <kern/cpu_data.h>
#include <kern/kern_types.h>
#include <platforms.h>
#include <mp_v1_1.h>
#include <mach_kprof.h>
#include <mach_mp_debug.h>
#include <mach/std_types.h>

#include <mach/clock_types.h>
#include <mach/boolean.h>
#include <i386/thread.h>
#include <i386/eflags.h>
#include <kern/assert.h>
#include <kern/misc_protos.h>
#include <i386/misc_protos.h>
#include <kern/time_out.h>

#include <i386/ipl.h>

#include <i386/hardclock_entries.h>
#include <i386/rtclock_entries.h>

#if	MACH_MP_DEBUG
#include <i386/mach_param.h>	/* for HZ */
#endif	/* MACH_MP_DEBUG */

extern	char	return_to_iret[];

#if	TIME_STAMP && NCPUS > 1
extern	unsigned time_stamp;
unsigned old_time_stamp, time_stamp_cum, nstamps;

/*
 *	If H/W provides a counter, record number of ticks and cumulated
 *	time stamps to know timestamps rate.
 *	This should go away when ALARMCLOCKS installed
 */
#define time_stamp_stat()					\
	if (my_cpu == 0)					\
	if (!old_time_stamp) {					\
		old_time_stamp = time_stamp;			\
		nstamps = 0;					\
	} else {						\
		nstamps++;					\
		time_stamp_cum = (time_stamp - old_time_stamp);	\
	}
#else	/* TIME_STAMP && AT386 && NCPUS > 1 */
#define time_stamp_stat()
#endif	/* TIME_STAMP && AT386 && NCPUS > 1 */

#if	MACH_KPROF
int	masked_pc[NCPUS];
int	missed_clock[NCPUS];
int	detect_lost_tick = 0;
#endif	/* MACH_KPROF */

#if	MACH_MP_DEBUG
int	masked_state_cnt[NCPUS];
int	masked_state_max = 10*HZ;
#endif	/* MACH_MP_DEBUG */

/*
 * In the interest of a fast clock interrupt service path,
 * this routine should be folded into assembly language with
 * a direct interrupt vector on the i386. The "pit" interrupt
 * should always call the rtclock_intr() routine on the master
 * processor. The return value of the rtclock_intr() routine
 * indicates whether HZ rate clock processing should be
 * performed. (On the Sequent, all slave processors will
 * run at HZ rate). For now, we'll leave this routine in C
 * (with TIME_STAMP, MACH_MP_DEBUG and MACH_KPROF code this
 * routine is way too large for assembler anyway).
 */

#ifdef	PARANOID_KDB
int paranoid_debugger = TRUE;
int paranoid_count = 1000;
int paranoid_current = 0;
int paranoid_cpu = 0;
#endif	/* PARANOID_KDB */

void
hardclock(struct i386_interrupt_state	*regs) /* saved registers */
{
	int mycpu;
	register unsigned pc;
	register boolean_t usermode;

	mp_disable_preemption();
	mycpu = cpu_number();

#ifdef	PARANOID_KDB
	if (paranoid_cpu == mycpu &&
	    paranoid_current++ >= paranoid_count) {
		paranoid_current = 0;
		if (paranoid_debugger)
		    Debugger("hardclock");
	}
#endif	/* PARANOID_KDB */

#if 0
#if	MACH_MP_DEBUG
	/*
	 * Increments counter of clock ticks handled under a masked state.
	 * Debugger() is called if masked state is kept during 1 sec.
	 * The counter is reset by splx() when ipl mask is set back to SPL0,
	 * and by spl0().
	 */
	if (SPL_CMP_GT((old_ipl & 0xFF), SPL0)) {
		if (masked_state_cnt[mycpu]++ >= masked_state_max) {
			int max_save = masked_state_max;

			masked_state_cnt[mycpu] = 0;
			masked_state_max = 0x7fffffff;

			if (ret_addr == return_to_iret) {
				usermode = (regs->efl & EFL_VM) ||
						((regs->cs & 0x03) != 0);
				pc = (unsigned)regs->eip;
			} else {
				usermode = FALSE;
				pc = (unsigned)
				((struct i386_interrupt_state *)&old_ipl)->eip;
			}
			printf("looping at high IPL, usermode=%d pc=0x%x\n",
					usermode, pc);
			Debugger("");

			masked_state_cnt[mycpu] = 0;
			masked_state_max = max_save;
		}
	} else
		masked_state_cnt[mycpu] = 0;
#endif	/* MACH_MP_DEBUG */
#endif

#if	MACH_KPROF
	/*
	 * If we were masked against the clock skip call
	 * to rtclock_intr(). When MACH_KPROF is set, the
	 * clock frequency of the master-cpu is confined
	 * to the HZ rate.
	 */
	if (SPL_CMP_LT(old_ipl & 0xFF, SPL7))
#endif	/* MACH_KPROF */
	/*
	 * The master processor executes the rtclock_intr() routine
	 * on every clock tick. The rtclock_intr() routine returns
	 * a zero value on a HZ tick boundary.
	 */
	if (mycpu == master_cpu) {
		if (rtclock_intr() != 0) {
			mp_enable_preemption();
			return;
		}
	}

	/*
	 * The following code is executed at HZ rate by all processors
	 * in the system. This implies that the clock rate on slave
	 * processors must be HZ rate.
	 */

	time_stamp_stat();

#if 0
	if (ret_addr == return_to_iret) {
		/*
		 * A kernel-loaded task executing within itself will look like
		 * "kernel mode", here.  This is correct with syscalls
		 * implemented using migrating threads, because it means that  
		 * the time spent in the server by a client thread will be
		 * treated as "system" time for the client thread (and nothing
		 * for the server).  This conforms to the CPU reporting for an
		 * integrated kernel.
		 */
#endif
		usermode = (regs->efl & EFL_VM) || ((regs->cs & 0x03) != 0);
		pc = (unsigned)regs->eip;
#if 0
	} else {
		usermode = FALSE;
		pc = (unsigned)((struct i386_interrupt_state *)&old_ipl)->eip;
	}
#endif

#if	MACH_KPROF
	/*
	 * If we were masked against the clock, just memorize pc
	 * and the fact that the clock interrupt is delayed
	 */
	if (SPL_CMP_GE((old_ipl & 0xFF), SPL7)) {
		assert(!usermode);
		if (missed_clock[mycpu]++ && detect_lost_tick > 1)
			Debugger("Mach_KPROF");
		masked_pc[mycpu] = pc;
	} else
#endif	/* MACH_KPROF */

	hertz_tick(usermode, pc);

#if	NCPUS >1 
	/*
	 * Instead of having the master processor interrupt
	 * all active processors, each processor in turn interrupts
	 * the next active one. This avoids all slave processors
	 * accessing the same R/W data simultaneously.
	 */
	slave_clock();
#endif	/* NCPUS >1 && AT386 */

	mp_enable_preemption();
}

#if	MACH_KPROF
void
delayed_clock(void)
{
	int	i;
	int	my_cpu;

	mp_disable_preemption();
	my_cpu = cpu_number();

	if (missed_clock[my_cpu] > 1 && detect_lost_tick)
		printf("hardclock: missed %d clock interrupt(s) at %x\n",
		       missed_clock[my_cpu]-1, masked_pc[my_cpu]);
	if (my_cpu == master_cpu) {
		i = rtclock_intr();
		assert(i == 0);
	}
	hertz_tick(0, masked_pc[my_cpu]);
	missed_clock[my_cpu] = 0;

	mp_enable_preemption();
}
#endif	/* MACH_KPROF */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* @OSF_COPYRIGHT@
	27	*/
	28	/*
	29	* Mach Operating System
	30	* Copyright (c) 1991,1990 Carnegie Mellon University
	31	* All Rights Reserved.
	32	*
	33	* Permission to use, copy, modify and distribute this software and its
	34	* documentation is hereby granted, provided that both the copyright
	35	* notice and this permission notice appear in all copies of the
	36	* software, derivative works or modified versions, and any portions
	37	* thereof, and that both notices appear in supporting documentation.
	38	*
	39	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	40	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	41	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	42	*
	43	* Carnegie Mellon requests users of this software to return to
	44	*
	45	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	46	* School of Computer Science
	47	* Carnegie Mellon University
	48	* Pittsburgh PA 15213-3890
	49	*
	50	* any improvements or extensions that they make and grant Carnegie Mellon
	51	* the rights to redistribute these changes.
	52	*/
	53	/*
	54	*/
	55
	56	/*
	57	* Clock interrupt.
	58	*/
	59	#include <cpus.h>
	60	#include <time_stamp.h>
	61	#include <mach_kdb.h>
	62	#include <kern/cpu_number.h>
	63	#include <kern/cpu_data.h>
	64	#include <kern/kern_types.h>
	65	#include <platforms.h>
	66	#include <mp_v1_1.h>
	67	#include <mach_kprof.h>
	68	#include <mach_mp_debug.h>
	69	#include <mach/std_types.h>
	70
	71	#include <mach/clock_types.h>
	72	#include <mach/boolean.h>
	73	#include <i386/thread.h>
	74	#include <i386/eflags.h>
	75	#include <kern/assert.h>
	76	#include <kern/misc_protos.h>
	77	#include <i386/misc_protos.h>
	78	#include <kern/time_out.h>
	79
	80	#include <i386/ipl.h>
	81
	82	#include <i386/hardclock_entries.h>
	83	#include <i386/rtclock_entries.h>
	84
	85	#if MACH_MP_DEBUG
86	#include <i386/mach_param.h> /* for HZ */
87	#endif /* MACH_MP_DEBUG */
88
89	extern char return_to_iret[];
90
91	#if TIME_STAMP && NCPUS > 1
92	extern unsigned time_stamp;
93	unsigned old_time_stamp, time_stamp_cum, nstamps;
94
95	/*
96	* If H/W provides a counter, record number of ticks and cumulated
97	* time stamps to know timestamps rate.
98	* This should go away when ALARMCLOCKS installed
99	*/
100	#define time_stamp_stat() \
101	if (my_cpu == 0) \
102	if (!old_time_stamp) { \
103	old_time_stamp = time_stamp; \
104	nstamps = 0; \
105	} else { \
106	nstamps++; \
107	time_stamp_cum = (time_stamp - old_time_stamp); \
108	}
109	#else /* TIME_STAMP && AT386 && NCPUS > 1 */
110	#define time_stamp_stat()
111	#endif /* TIME_STAMP && AT386 && NCPUS > 1 */
112
113	#if MACH_KPROF
114	int masked_pc[NCPUS];
115	int missed_clock[NCPUS];
116	int detect_lost_tick = 0;
117	#endif /* MACH_KPROF */
118
119	#if MACH_MP_DEBUG
120	int masked_state_cnt[NCPUS];
121	int masked_state_max = 10*HZ;
122	#endif /* MACH_MP_DEBUG */
123
124	/*
125	* In the interest of a fast clock interrupt service path,
126	* this routine should be folded into assembly language with
127	* a direct interrupt vector on the i386. The "pit" interrupt
128	* should always call the rtclock_intr() routine on the master
129	* processor. The return value of the rtclock_intr() routine
130	* indicates whether HZ rate clock processing should be
131	* performed. (On the Sequent, all slave processors will
132	* run at HZ rate). For now, we'll leave this routine in C
133	* (with TIME_STAMP, MACH_MP_DEBUG and MACH_KPROF code this
134	* routine is way too large for assembler anyway).
135	*/
136
137	#ifdef PARANOID_KDB
138	int paranoid_debugger = TRUE;
139	int paranoid_count = 1000;
140	int paranoid_current = 0;
141	int paranoid_cpu = 0;
142	#endif /* PARANOID_KDB */
143
144	void
145	hardclock(struct i386_interrupt_state regs) / saved registers */
146	{
147	int mycpu;
148	register unsigned pc;
149	register boolean_t usermode;
150
151	mp_disable_preemption();
152	mycpu = cpu_number();
153
154	#ifdef PARANOID_KDB
155	if (paranoid_cpu == mycpu &&
156	paranoid_current++ >= paranoid_count) {
157	paranoid_current = 0;
158	if (paranoid_debugger)
159	Debugger("hardclock");
160	}
161	#endif /* PARANOID_KDB */
162
163	#if 0
164	#if MACH_MP_DEBUG
165	/*
166	* Increments counter of clock ticks handled under a masked state.
167	* Debugger() is called if masked state is kept during 1 sec.
168	* The counter is reset by splx() when ipl mask is set back to SPL0,
169	* and by spl0().
170	*/
171	if (SPL_CMP_GT((old_ipl & 0xFF), SPL0)) {
172	if (masked_state_cnt[mycpu]++ >= masked_state_max) {
173	int max_save = masked_state_max;
174
175	masked_state_cnt[mycpu] = 0;
176	masked_state_max = 0x7fffffff;
177
178	if (ret_addr == return_to_iret) {
179	usermode = (regs->efl & EFL_VM) \|\|
180	((regs->cs & 0x03) != 0);
181	pc = (unsigned)regs->eip;
182	} else {
183	usermode = FALSE;
184	pc = (unsigned)
185	((struct i386_interrupt_state *)&old_ipl)->eip;
186	}
187	printf("looping at high IPL, usermode=%d pc=0x%x\n",
188	usermode, pc);
189	Debugger("");
190
191	masked_state_cnt[mycpu] = 0;
192	masked_state_max = max_save;
193	}
194	} else
195	masked_state_cnt[mycpu] = 0;
196	#endif /* MACH_MP_DEBUG */
197	#endif
198
199	#if MACH_KPROF
200	/*
201	* If we were masked against the clock skip call
202	* to rtclock_intr(). When MACH_KPROF is set, the
203	* clock frequency of the master-cpu is confined
204	* to the HZ rate.
205	*/
206	if (SPL_CMP_LT(old_ipl & 0xFF, SPL7))
207	#endif /* MACH_KPROF */
208	/*
209	* The master processor executes the rtclock_intr() routine
210	* on every clock tick. The rtclock_intr() routine returns
211	* a zero value on a HZ tick boundary.
212	*/
213	if (mycpu == master_cpu) {
214	if (rtclock_intr() != 0) {
215	mp_enable_preemption();
216	return;
217	}
218	}
219
220	/*
221	* The following code is executed at HZ rate by all processors
222	* in the system. This implies that the clock rate on slave
223	* processors must be HZ rate.
224	*/
225
226	time_stamp_stat();
227
228	#if 0
229	if (ret_addr == return_to_iret) {
230	/*
231	* A kernel-loaded task executing within itself will look like
232	* "kernel mode", here. This is correct with syscalls
233	* implemented using migrating threads, because it means that
234	* the time spent in the server by a client thread will be
235	* treated as "system" time for the client thread (and nothing
236	* for the server). This conforms to the CPU reporting for an
237	* integrated kernel.
238	*/
239	#endif
240	usermode = (regs->efl & EFL_VM) \|\| ((regs->cs & 0x03) != 0);
241	pc = (unsigned)regs->eip;
242	#if 0
243	} else {
244	usermode = FALSE;
245	pc = (unsigned)((struct i386_interrupt_state *)&old_ipl)->eip;
246	}
247	#endif
248
249	#if MACH_KPROF
250	/*
251	* If we were masked against the clock, just memorize pc
252	* and the fact that the clock interrupt is delayed
253	*/
254	if (SPL_CMP_GE((old_ipl & 0xFF), SPL7)) {
255	assert(!usermode);
256	if (missed_clock[mycpu]++ && detect_lost_tick > 1)
257	Debugger("Mach_KPROF");
258	masked_pc[mycpu] = pc;
259	} else
260	#endif /* MACH_KPROF */
261
262	hertz_tick(usermode, pc);
263
264	#if NCPUS >1
265	/*
266	* Instead of having the master processor interrupt
267	* all active processors, each processor in turn interrupts
268	* the next active one. This avoids all slave processors
269	* accessing the same R/W data simultaneously.
270	*/
271	slave_clock();
272	#endif /* NCPUS >1 && AT386 */
273
274	mp_enable_preemption();
275	}
276
277	#if MACH_KPROF
278	void
279	delayed_clock(void)
280	{
281	int i;
282	int my_cpu;
283
284	mp_disable_preemption();
285	my_cpu = cpu_number();
286
287	if (missed_clock[my_cpu] > 1 && detect_lost_tick)
288	printf("hardclock: missed %d clock interrupt(s) at %x\n",
289	missed_clock[my_cpu]-1, masked_pc[my_cpu]);
290	if (my_cpu == master_cpu) {
291	i = rtclock_intr();
292	assert(i == 0);
293	}
294	hertz_tick(0, masked_pc[my_cpu]);
295	missed_clock[my_cpu] = 0;
296
297	mp_enable_preemption();
298	}
299	#endif /* MACH_KPROF */