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

/*
 * Copyright (c) 2005-2006 Apple Computer, 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 <i386/hpet.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 = 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 */
}
Commit	Line	Data
0c530ab8	1	/*
2d21ac55	2	* Copyright (c) 2005-2006 Apple Computer, 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>
	72	#include <i386/hpet.h>
	73	#include <mach/i386/syscall_sw.h>
	74
	75	extern uint64_t lastNapClear;
	76
	77	diagWork dgWork;
	78	uint64_t lastNapClear = 0ULL;
	79	uint64_t lastRuptClear = 0ULL;
	80
0c530ab8 A	81
0c530ab8 A	82	int
2d21ac55	83	diagCall64(x86_saved_state_t * state)
0c530ab8	84	{
2d21ac55 A	85	uint64_t curpos, i, j;
	86	uint64_t selector, data;
	87	uint64_t currNap, durNap;
	88	x86_saved_state64_t *regs;
	89
	90	assert(is_saved_state64(state));
	91	regs = saved_state64(state);
	92
	93	if (!(dgWork.dgFlags & enaDiagSCs))
	94	return 0; /* If not enabled, cause an exception */
	95
	96	selector = regs->rdi;
	97
	98	switch (selector) { /* Select the routine */
	99	case dgRuptStat: /* Suck Interruption statistics */
	100	data = regs->rsi; /* Get the number of processors */
	101
	102	if (data == 0) { /* If no location is specified for data, clear all
	103	* counts
	104	*/
	105	for (i = 0; i < real_ncpus; i++) { /* Cycle through
	106	* processors */
	107	for (j = 0; j < 256; j++)
	108	cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
	109	}
	110
	111	lastRuptClear = mach_absolute_time(); /* Get the time of clear */
	112	return 1; /* Normal return */
	113	}
	114
	115	(void) copyout((char ) &real_ncpus, data, sizeof(real_ncpus)); / Copy out number of
	116	* processors */
	117
	118	currNap = mach_absolute_time(); /* Get the time now */
	119	durNap = currNap - lastRuptClear; /* Get the last interval
	120	* duration */
	121	if (durNap == 0)
	122	durNap = 1; /* This is a very short time, make it
	123	* bigger */
	124
	125	curpos = data + sizeof(real_ncpus); /* Point to the next
	126	* available spot */
	127
	128	for (i = 0; i < real_ncpus; i++) { /* Move 'em all out */
	129	(void) copyout((char ) &durNap, curpos, 8); / Copy out the time
	130	* since last clear */
	131	(void) copyout((char ) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 sizeof(uint32_t)); /* Copy out interrupt
	132	* data for this
	133	* processor */
	134	curpos = curpos + (256 * sizeof(uint32_t) + 8); /* Point to next out put
	135	* slot */
	136	}
	137	break;
	138
	139	default: /* Handle invalid ones */
	140	return 0; /* Return an exception */
	141
	142	}
	143
	144	return 1; /* Normal non-ast check return */
0c530ab8 A	145	}
	146
	147
	148	int
	149	diagCall(x86_saved_state_t * state)
	150	{
0c530ab8 A	151	uint32_t stk, curpos, i, j;
	152	uint32_t selector, data;
	153	int err;
	154	uint64_t currNap, durNap;
	155	x86_saved_state32_t *regs;
	156
	157	assert(is_saved_state32(state));
	158	regs = saved_state32(state);
	159
	160	if (!(dgWork.dgFlags & enaDiagSCs))
	161	return 0; /* If not enabled, cause an exception */
	162
	163	stk = regs->uesp; /* Point to the stack */
	164	err = copyin((user_addr_t) (stk + 4), (char ) &selector, sizeof(uint32_t)); / Get the selector */
	165	if (err) {
	166	return 0; /* Failed to fetch stack */
	167	}
	168	switch (selector) { /* Select the routine */
0c530ab8 A	169	case dgRuptStat: /* Suck Interruption statistics */
	170
	171	err = copyin((user_addr_t) (stk + 8), (char ) &data, sizeof(uint32_t)); / Get the selector */
	172
	173	if (data == 0) {/* If number of processors is 0, clear all
	174	* counts */
	175	for (i = 0; i < real_ncpus; i++) { /* Cycle through
	176	* processors */
	177	for (j = 0; j < 256; j++)
	178	cpu_data_ptr[i]->cpu_hwIntCnt[j] = 0;
	179	}
	180
	181	lastRuptClear = mach_absolute_time(); /* Get the time of clear */
	182	return 1; /* Normal return */
	183	}
0c530ab8 A	184
	185	(void) copyout((char ) &real_ncpus, data, sizeof(real_ncpus)); / Copy out number of
	186	* processors */
	187
	188	currNap = mach_absolute_time(); /* Get the time now */
	189	durNap = currNap - lastRuptClear; /* Get the last interval
	190	* duration */
	191	if (durNap == 0)
	192	durNap = 1; /* This is a very short time, make it
	193	* bigger */
	194
	195	curpos = data + sizeof(real_ncpus); /* Point to the next
	196	* available spot */
	197
	198	for (i = 0; i < real_ncpus; i++) { /* Move 'em all out */
	199	(void) copyout((char ) &durNap, curpos, 8); / Copy out the time
	200	* since last clear */
	201	(void) copyout((char ) &cpu_data_ptr[i]->cpu_hwIntCnt, curpos + 8, 256 sizeof(uint32_t)); /* Copy out interrupt
	202	* data for this
	203	* processor */
	204	curpos = curpos + (256 * sizeof(uint32_t) + 8); /* Point to next out put
	205	* slot */
	206	}
	207
	208	break;
	209
	210	default: /* Handle invalid ones */
	211	return 0; /* Return an exception */
	212
	213	}
	214
	215	return 1; /* Normal non-ast check return */
	216	}