[apple/xnu.git] / osfmk / i386 / hardclock.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 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	*
de355530 A	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.
1c79356b	11	*
de355530 A	12	* This Original Code and all software distributed under the License are
de355530 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
de355530 A	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.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* Mach Operating System
	27	* Copyright (c) 1991,1990 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	* Clock interrupt.
	55	*/
	56	#include <cpus.h>
	57	#include <time_stamp.h>
	58	#include <mach_kdb.h>
	59	#include <kern/cpu_number.h>
	60	#include <kern/cpu_data.h>
	61	#include <kern/kern_types.h>
	62	#include <platforms.h>
	63	#include <mp_v1_1.h>
	64	#include <mach_kprof.h>
	65	#include <mach_mp_debug.h>
	66	#include <mach/std_types.h>
	67
	68	#include <mach/clock_types.h>
	69	#include <mach/boolean.h>
	70	#include <i386/thread.h>
	71	#include <i386/eflags.h>
	72	#include <kern/assert.h>
	73	#include <kern/misc_protos.h>
	74	#include <i386/misc_protos.h>
	75	#include <kern/time_out.h>
	76
	77	#include <i386/ipl.h>
	78
	79	#include <i386/hardclock_entries.h>
	80	#include <i386/rtclock_entries.h>
	81
	82	#if MACH_MP_DEBUG
83	#include <i386/mach_param.h> /* for HZ */
84	#endif /* MACH_MP_DEBUG */
85
86	extern char return_to_iret[];
87
88	#if TIME_STAMP && NCPUS > 1
89	extern unsigned time_stamp;
90	unsigned old_time_stamp, time_stamp_cum, nstamps;
91
92	/*
93	* If H/W provides a counter, record number of ticks and cumulated
94	* time stamps to know timestamps rate.
95	* This should go away when ALARMCLOCKS installed
96	*/
97	#define time_stamp_stat() \
98	if (my_cpu == 0) \
99	if (!old_time_stamp) { \
100	old_time_stamp = time_stamp; \
101	nstamps = 0; \
102	} else { \
103	nstamps++; \
104	time_stamp_cum = (time_stamp - old_time_stamp); \
105	}
106	#else /* TIME_STAMP && AT386 && NCPUS > 1 */
107	#define time_stamp_stat()
108	#endif /* TIME_STAMP && AT386 && NCPUS > 1 */
109
110	#if MACH_KPROF
111	int masked_pc[NCPUS];
112	int missed_clock[NCPUS];
113	int detect_lost_tick = 0;
114	#endif /* MACH_KPROF */
115
116	#if MACH_MP_DEBUG
117	int masked_state_cnt[NCPUS];
118	int masked_state_max = 10*HZ;
119	#endif /* MACH_MP_DEBUG */
120
121	/*
122	* In the interest of a fast clock interrupt service path,
123	* this routine should be folded into assembly language with
124	* a direct interrupt vector on the i386. The "pit" interrupt
125	* should always call the rtclock_intr() routine on the master
126	* processor. The return value of the rtclock_intr() routine
127	* indicates whether HZ rate clock processing should be
128	* performed. (On the Sequent, all slave processors will
129	* run at HZ rate). For now, we'll leave this routine in C
130	* (with TIME_STAMP, MACH_MP_DEBUG and MACH_KPROF code this
131	* routine is way too large for assembler anyway).
132	*/
133
134	#ifdef PARANOID_KDB
135	int paranoid_debugger = TRUE;
136	int paranoid_count = 1000;
137	int paranoid_current = 0;
138	int paranoid_cpu = 0;
139	#endif /* PARANOID_KDB */
140
141	void
142	hardclock(struct i386_interrupt_state regs) / saved registers */
143	{
144	int mycpu;
145	register unsigned pc;
146	register boolean_t usermode;
147
148	mp_disable_preemption();
149	mycpu = cpu_number();
150
151	#ifdef PARANOID_KDB
152	if (paranoid_cpu == mycpu &&
153	paranoid_current++ >= paranoid_count) {
154	paranoid_current = 0;
155	if (paranoid_debugger)
156	Debugger("hardclock");
157	}
158	#endif /* PARANOID_KDB */
159
160	#if 0
161	#if MACH_MP_DEBUG
162	/*
163	* Increments counter of clock ticks handled under a masked state.
164	* Debugger() is called if masked state is kept during 1 sec.
165	* The counter is reset by splx() when ipl mask is set back to SPL0,
166	* and by spl0().
167	*/
168	if (SPL_CMP_GT((old_ipl & 0xFF), SPL0)) {
169	if (masked_state_cnt[mycpu]++ >= masked_state_max) {
170	int max_save = masked_state_max;
171
172	masked_state_cnt[mycpu] = 0;
173	masked_state_max = 0x7fffffff;
174
175	if (ret_addr == return_to_iret) {
176	usermode = (regs->efl & EFL_VM) \|\|
177	((regs->cs & 0x03) != 0);
178	pc = (unsigned)regs->eip;
179	} else {
180	usermode = FALSE;
181	pc = (unsigned)
182	((struct i386_interrupt_state *)&old_ipl)->eip;
183	}
184	printf("looping at high IPL, usermode=%d pc=0x%x\n",
185	usermode, pc);
186	Debugger("");
187
188	masked_state_cnt[mycpu] = 0;
189	masked_state_max = max_save;
190	}
191	} else
192	masked_state_cnt[mycpu] = 0;
193	#endif /* MACH_MP_DEBUG */
194	#endif
195
196	#if MACH_KPROF
197	/*
198	* If we were masked against the clock skip call
199	* to rtclock_intr(). When MACH_KPROF is set, the
200	* clock frequency of the master-cpu is confined
201	* to the HZ rate.
202	*/
203	if (SPL_CMP_LT(old_ipl & 0xFF, SPL7))
204	#endif /* MACH_KPROF */
205	/*
206	* The master processor executes the rtclock_intr() routine
207	* on every clock tick. The rtclock_intr() routine returns
208	* a zero value on a HZ tick boundary.
209	*/
210	if (mycpu == master_cpu) {
211	if (rtclock_intr() != 0) {
212	mp_enable_preemption();
213	return;
214	}
215	}
216
217	/*
218	* The following code is executed at HZ rate by all processors
219	* in the system. This implies that the clock rate on slave
220	* processors must be HZ rate.
221	*/
222
223	time_stamp_stat();
224
225	#if 0
226	if (ret_addr == return_to_iret) {
227	/*
228	* A kernel-loaded task executing within itself will look like
229	* "kernel mode", here. This is correct with syscalls
230	* implemented using migrating threads, because it means that
231	* the time spent in the server by a client thread will be
232	* treated as "system" time for the client thread (and nothing
233	* for the server). This conforms to the CPU reporting for an
234	* integrated kernel.
235	*/
236	#endif
237	usermode = (regs->efl & EFL_VM) \|\| ((regs->cs & 0x03) != 0);
238	pc = (unsigned)regs->eip;
239	#if 0
240	} else {
241	usermode = FALSE;
242	pc = (unsigned)((struct i386_interrupt_state *)&old_ipl)->eip;
243	}
244	#endif
245
246	#if MACH_KPROF
247	/*
248	* If we were masked against the clock, just memorize pc
249	* and the fact that the clock interrupt is delayed
250	*/
251	if (SPL_CMP_GE((old_ipl & 0xFF), SPL7)) {
252	assert(!usermode);
253	if (missed_clock[mycpu]++ && detect_lost_tick > 1)
254	Debugger("Mach_KPROF");
255	masked_pc[mycpu] = pc;
256	} else
257	#endif /* MACH_KPROF */
258
259	hertz_tick(usermode, pc);
260
261	#if NCPUS >1
262	/*
263	* Instead of having the master processor interrupt
264	* all active processors, each processor in turn interrupts
265	* the next active one. This avoids all slave processors
266	* accessing the same R/W data simultaneously.
267	*/
268	slave_clock();
269	#endif /* NCPUS >1 && AT386 */
270
271	mp_enable_preemption();
272	}
273
274	#if MACH_KPROF
275	void
276	delayed_clock(void)
277	{
278	int i;
279	int my_cpu;
280
281	mp_disable_preemption();
282	my_cpu = cpu_number();
283
284	if (missed_clock[my_cpu] > 1 && detect_lost_tick)
285	printf("hardclock: missed %d clock interrupt(s) at %x\n",
286	missed_clock[my_cpu]-1, masked_pc[my_cpu]);
287	if (my_cpu == master_cpu) {
288	i = rtclock_intr();
289	assert(i == 0);
290	}
291	hertz_tick(0, masked_pc[my_cpu]);
292	missed_clock[my_cpu] = 0;
293
294	mp_enable_preemption();
295	}
296	#endif /* MACH_KPROF */