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

/*
 * Copyright (c) 2005-2008 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * 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. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * 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_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_FREE_COPYRIGHT@
 */
/*
 * @APPLE_FREE_COPYRIGHT@
 */

/*
 *	Author: Bill Angell, Apple
 *	Date:	10/auht-five
 *
 *	Random diagnostics
 *
 *	Try to keep the x86 selectors in-sync with the ppc selectors.
 *
 */


#include <kern/machine.h>
#include <kern/processor.h>
#include <mach/machine.h>
#include <mach/processor_info.h>
#include <mach/mach_types.h>
#include <mach/boolean.h>
#include <kern/thread.h>
#include <kern/task.h>
#include <kern/ipc_kobject.h>
#include <mach/vm_param.h>
#include <ipc/port.h>
#include <ipc/ipc_entry.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_object.h>
#include <ipc/ipc_port.h>
#include <vm/vm_kern.h>
#include <vm/vm_map.h>
#include <vm/vm_page.h>
#include <vm/pmap.h>
#include <pexpert/pexpert.h>
#include <console/video_console.h>
#include <i386/cpu_data.h>
#include <i386/Diagnostics.h>
#include <i386/mp.h>
#include <i386/pmCPU.h>
#include <i386/tsc.h>
#include <mach/i386/syscall_sw.h>

extern uint64_t lastNapClear;

diagWork        dgWork;
uint64_t        lastNapClear = 0ULL;
uint64_t        lastRuptClear = 0ULL;


int 
diagCall64(x86_saved_state_t * state)
{
	uint64_t        curpos, i, j;
	uint64_t        selector, data;
	uint64_t        currNap, durNap;
	x86_saved_state64_t	*regs;

	assert(is_saved_state64(state));
	regs = saved_state64(state);

	if (!(dgWork.dgFlags & enaDiagSCs))
		return 0;	/* If not enabled, cause an exception */

	selector = regs->rdi;

	switch (selector) {	/* Select the routine */
	case dgRuptStat:	/* Suck Interruption statistics */
		data = regs->rsi; /* Get the number of processors */

		if (data == 0) { /* If no location is specified for data, clear all
				  * counts
				  */
			for (i = 0; i < real_ncpus; i++) {	/* Cycle through
								 * processors */
				for (j = 0; j < 256; j++)
					cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
			}

			lastRuptClear = mach_absolute_time();	/* Get the time of clear */
			return 1;	/* Normal return */
		}

		(void) copyout((char *) &real_ncpus, data, sizeof(real_ncpus));	/* Copy out number of
										 * processors */

		currNap = mach_absolute_time();	/* Get the time now */
		durNap = currNap - lastRuptClear;	/* Get the last interval
							 * duration */
		if (durNap == 0)
			durNap = 1;	/* This is a very short time, make it
					 * bigger */

		curpos = data + sizeof(real_ncpus);	/* Point to the next
							 * available spot */

		for (i = 0; i < real_ncpus; i++) {	/* Move 'em all out */
			(void) copyout((char *) &durNap, curpos, 8);	/* Copy out the time
									 * since last clear */
			(void) copyout((char *) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 * sizeof(uint32_t));	/* Copy out interrupt
															 * data for this
															 * processor */
			curpos = curpos + (256 * sizeof(uint32_t) + 8);	/* Point to next out put
									 * slot */
		}
		break;

	default:		/* Handle invalid ones */
		return 0;	/* Return an exception */

	}

	return 1;		/* Normal non-ast check return */
}


int 
diagCall(x86_saved_state_t * state)
{
	uint32_t        stk, curpos, i, j;
	uint32_t        selector, data;
	int             err;
	uint64_t        currNap, durNap;
	x86_saved_state32_t	*regs;

	assert(is_saved_state32(state));
	regs = saved_state32(state);

	if (!(dgWork.dgFlags & enaDiagSCs))
		return 0;	/* If not enabled, cause an exception */

	stk = regs->uesp;	/* Point to the stack */
	err = copyin((user_addr_t) (stk + 4), (char *) &selector, sizeof(uint32_t));	/* Get the selector */
	if (err) {
		return 0;	/* Failed to fetch stack */
	}
	switch (selector) {	/* Select the routine */
	case dgRuptStat:	/* Suck Interruption statistics */

		err = copyin((user_addr_t) (stk + 8), (char *) &data, sizeof(uint32_t));	/* Get the selector */

		if (data == 0) {/* If number of processors is 0, clear all
				 * counts */
			for (i = 0; i < real_ncpus; i++) {	/* Cycle through
								 * processors */
				for (j = 0; j < 256; j++)
					cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
			}

			lastRuptClear = mach_absolute_time();	/* Get the time of clear */
			return 1;	/* Normal return */
		}

		(void) copyout((char *) &real_ncpus, data, sizeof(real_ncpus));	/* Copy out number of
										 * processors */

		currNap = mach_absolute_time();	/* Get the time now */
		durNap = currNap - lastRuptClear;	/* Get the last interval
							 * duration */
		if (durNap == 0)
			durNap = 1;	/* This is a very short time, make it
					 * bigger */

		curpos = (uint32_t)(data + sizeof(real_ncpus));	/* Point to the next
							 * available spot */

		for (i = 0; i < real_ncpus; i++) {	/* Move 'em all out */
			(void) copyout((char *) &durNap, curpos, 8);	/* Copy out the time
									 * since last clear */
			(void) copyout((char *) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 * sizeof(uint32_t));	/* Copy out interrupt
															 * data for this
															 * processor */
			curpos = (uint32_t)(curpos + (256 * sizeof(uint32_t) + 8));	/* Point to next out put
									 * slot */
		}

		break;

	default:		/* Handle invalid ones */
		return 0;	/* Return an exception */

	}

	return 1;		/* Normal non-ast check return */
}
Commit	Line	Data
0c530ab8	1	/*
593a1d5f	2	* Copyright (c) 2005-2008 Apple Inc. All rights reserved.
0c530ab8	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
0c530ab8	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
0c530ab8	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
0c530ab8 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
0c530ab8 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
0c530ab8	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
0c530ab8 A	27	*/
	28	/*
	29	* @OSF_FREE_COPYRIGHT@
	30	*/
	31	/*
	32	* @APPLE_FREE_COPYRIGHT@
	33	*/
	34
	35	/*
	36	* Author: Bill Angell, Apple
	37	* Date: 10/auht-five
	38	*
	39	* Random diagnostics
	40	*
	41	* Try to keep the x86 selectors in-sync with the ppc selectors.
	42	*
	43	*/
	44
	45
	46	#include <kern/machine.h>
	47	#include <kern/processor.h>
	48	#include <mach/machine.h>
	49	#include <mach/processor_info.h>
	50	#include <mach/mach_types.h>
	51	#include <mach/boolean.h>
	52	#include <kern/thread.h>
	53	#include <kern/task.h>
	54	#include <kern/ipc_kobject.h>
	55	#include <mach/vm_param.h>
	56	#include <ipc/port.h>
	57	#include <ipc/ipc_entry.h>
	58	#include <ipc/ipc_space.h>
	59	#include <ipc/ipc_object.h>
	60	#include <ipc/ipc_port.h>
	61	#include <vm/vm_kern.h>
	62	#include <vm/vm_map.h>
	63	#include <vm/vm_page.h>
	64	#include <vm/pmap.h>
	65	#include <pexpert/pexpert.h>
	66	#include <console/video_console.h>
	67	#include <i386/cpu_data.h>
	68	#include <i386/Diagnostics.h>
	69	#include <i386/mp.h>
	70	#include <i386/pmCPU.h>
	71	#include <i386/tsc.h>
0c530ab8 A	72	#include <mach/i386/syscall_sw.h>
	73
	74	extern uint64_t lastNapClear;
	75
	76	diagWork dgWork;
	77	uint64_t lastNapClear = 0ULL;
	78	uint64_t lastRuptClear = 0ULL;
	79
0c530ab8 A	80
0c530ab8 A	81	int
2d21ac55	82	diagCall64(x86_saved_state_t * state)
0c530ab8	83	{
2d21ac55 A	84	uint64_t curpos, i, j;
	85	uint64_t selector, data;
	86	uint64_t currNap, durNap;
	87	x86_saved_state64_t *regs;
	88
	89	assert(is_saved_state64(state));
	90	regs = saved_state64(state);
	91
	92	if (!(dgWork.dgFlags & enaDiagSCs))
	93	return 0; /* If not enabled, cause an exception */
	94
	95	selector = regs->rdi;
	96
	97	switch (selector) { /* Select the routine */
	98	case dgRuptStat: /* Suck Interruption statistics */
	99	data = regs->rsi; /* Get the number of processors */
	100
	101	if (data == 0) { /* If no location is specified for data, clear all
	102	* counts
	103	*/
	104	for (i = 0; i < real_ncpus; i++) { /* Cycle through
	105	* processors */
	106	for (j = 0; j < 256; j++)
	107	cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
	108	}
	109
	110	lastRuptClear = mach_absolute_time(); /* Get the time of clear */
	111	return 1; /* Normal return */
	112	}
	113
	114	(void) copyout((char ) &real_ncpus, data, sizeof(real_ncpus)); / Copy out number of
	115	* processors */
	116
	117	currNap = mach_absolute_time(); /* Get the time now */
	118	durNap = currNap - lastRuptClear; /* Get the last interval
	119	* duration */
	120	if (durNap == 0)
	121	durNap = 1; /* This is a very short time, make it
	122	* bigger */
	123
	124	curpos = data + sizeof(real_ncpus); /* Point to the next
	125	* available spot */
	126
	127	for (i = 0; i < real_ncpus; i++) { /* Move 'em all out */
	128	(void) copyout((char ) &durNap, curpos, 8); / Copy out the time
	129	* since last clear */
	130	(void) copyout((char ) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 sizeof(uint32_t)); /* Copy out interrupt
	131	* data for this
	132	* processor */
	133	curpos = curpos + (256 * sizeof(uint32_t) + 8); /* Point to next out put
	134	* slot */
	135	}
	136	break;
	137
	138	default: /* Handle invalid ones */
	139	return 0; /* Return an exception */
	140
	141	}
	142
	143	return 1; /* Normal non-ast check return */
0c530ab8 A	144	}
	145
	146
	147	int
	148	diagCall(x86_saved_state_t * state)
	149	{
0c530ab8 A	150	uint32_t stk, curpos, i, j;
	151	uint32_t selector, data;
	152	int err;
	153	uint64_t currNap, durNap;
	154	x86_saved_state32_t *regs;
	155
	156	assert(is_saved_state32(state));
	157	regs = saved_state32(state);
	158
	159	if (!(dgWork.dgFlags & enaDiagSCs))
	160	return 0; /* If not enabled, cause an exception */
	161
	162	stk = regs->uesp; /* Point to the stack */
	163	err = copyin((user_addr_t) (stk + 4), (char ) &selector, sizeof(uint32_t)); / Get the selector */
	164	if (err) {
	165	return 0; /* Failed to fetch stack */
	166	}
	167	switch (selector) { /* Select the routine */
0c530ab8 A	168	case dgRuptStat: /* Suck Interruption statistics */
	169
	170	err = copyin((user_addr_t) (stk + 8), (char ) &data, sizeof(uint32_t)); / Get the selector */
	171
	172	if (data == 0) {/* If number of processors is 0, clear all
	173	* counts */
	174	for (i = 0; i < real_ncpus; i++) { /* Cycle through
	175	* processors */
	176	for (j = 0; j < 256; j++)
	177	cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
	178	}
	179
	180	lastRuptClear = mach_absolute_time(); /* Get the time of clear */
	181	return 1; /* Normal return */
	182	}
0c530ab8 A	183
	184	(void) copyout((char ) &real_ncpus, data, sizeof(real_ncpus)); / Copy out number of
	185	* processors */
	186
	187	currNap = mach_absolute_time(); /* Get the time now */
	188	durNap = currNap - lastRuptClear; /* Get the last interval
	189	* duration */
	190	if (durNap == 0)
	191	durNap = 1; /* This is a very short time, make it
	192	* bigger */
	193
b0d623f7	194	curpos = (uint32_t)(data + sizeof(real_ncpus)); /* Point to the next
0c530ab8 A	195	* available spot */
	196
	197	for (i = 0; i < real_ncpus; i++) { /* Move 'em all out */
	198	(void) copyout((char ) &durNap, curpos, 8); / Copy out the time
	199	* since last clear */
	200	(void) copyout((char ) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 sizeof(uint32_t)); /* Copy out interrupt
	201	* data for this
	202	* processor */
b0d623f7	203	curpos = (uint32_t)(curpos + (256 * sizeof(uint32_t) + 8)); /* Point to next out put
0c530ab8 A	204	* slot */
	205	}
	206
	207	break;
	208
	209	default: /* Handle invalid ones */
	210	return 0; /* Return an exception */
	211
	212	}
	213
	214	return 1; /* Normal non-ast check return */
	215	}