[apple/xnu.git] / osfmk / chud / i386 / chud_osfmk_callback_i386.c

/*
 * Copyright (c) 2003-2004 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@
 */

#include <stdint.h>
#include <mach/boolean.h>
#include <mach/mach_types.h>

#include <kern/kern_types.h>
#include <kern/processor.h>
#include <kern/timer_call.h>
#include <kern/thread_call.h>
#include <kern/kalloc.h>
#include <kern/thread.h>

#include <machine/machine_routines.h>
#include <machine/cpu_data.h>
#include <machine/trap.h>

#include <chud/chud_xnu.h>
#include <chud/chud_xnu_private.h>

#include <i386/misc_protos.h>
#include <i386/mp.h>
#include <i386/machine_cpu.h>

#include <sys/kdebug.h>
#define CHUD_TIMER_CALLBACK_CANCEL	0
#define CHUD_TIMER_CALLBACK_ENTER	1
#define CHUD_TIMER_CALLBACK		2
#define CHUD_AST_SEND			3
#define CHUD_AST_CALLBACK		4
#define CHUD_CPUSIG_SEND		5
#define CHUD_CPUSIG_CALLBACK		6

__private_extern__
void chudxnu_cancel_all_callbacks(void)
{
    chudxnu_cpusig_callback_cancel();
    chudxnu_cpu_timer_callback_cancel_all();
    chudxnu_interrupt_callback_cancel();
    chudxnu_perfmon_ast_callback_cancel();
    chudxnu_kdebug_callback_cancel();
    chudxnu_thread_timer_callback_cancel();
    chudxnu_trap_callback_cancel();
#if XXX
	chudxnu_syscall_callback_cancel();
#endif
}

static chudcpu_data_t chudcpu_boot_cpu;
void *
chudxnu_cpu_alloc(boolean_t boot_processor)
{
	chudcpu_data_t	*chud_proc_info;


	if (boot_processor) {
		chud_proc_info = &chudcpu_boot_cpu;
	} else {
		chud_proc_info = (chudcpu_data_t *)
					kalloc(sizeof(chudcpu_data_t));
		if (chud_proc_info == (chudcpu_data_t *)NULL) {
			return (void *)NULL;
		}
	}
	bzero((char *)chud_proc_info, sizeof(chudcpu_data_t));
	chud_proc_info->t_deadline = 0xFFFFFFFFFFFFFFFFULL;
	mpqueue_init(&chud_proc_info->cpu_request_queue);


	return (void *)chud_proc_info;
}

void
chudxnu_cpu_free(void *cp)
{
	if (cp == NULL || cp == (void *)&chudcpu_boot_cpu) {
		return;
	} else {
		kfree(cp,sizeof(chudcpu_data_t));
	}
}

static void
chudxnu_private_cpu_timer_callback(
	timer_call_param_t param0,
	timer_call_param_t param1)
{
#pragma unused (param0)
#pragma unused (param1)
	chudcpu_data_t			*chud_proc_info;
	boolean_t			oldlevel;
	x86_thread_state_t 		state;
	mach_msg_type_number_t		count;
	chudxnu_cpu_timer_callback_func_t fn;

	oldlevel = ml_set_interrupts_enabled(FALSE);
	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);

	count = x86_THREAD_STATE_COUNT;
	if (chudxnu_thread_get_state(current_thread(),
				     x86_THREAD_STATE,
				     (thread_state_t)&state,
				     &count,
				     FALSE) == KERN_SUCCESS) {
			fn = chud_proc_info->cpu_timer_callback_fn;
       		if (fn) {
			KERNEL_DEBUG_CONSTANT(
				MACHDBG_CODE(DBG_MACH_CHUD,
					CHUD_TIMER_CALLBACK) | DBG_FUNC_NONE,
				(uint32_t)fn, 0,0,0,0);
				//state.eip, state.cs, 0, 0);
       			(fn)(
				x86_THREAD_STATE,
				(thread_state_t)&state,
				count);
       		} 
	} 
	
	ml_set_interrupts_enabled(oldlevel);
}

__private_extern__ kern_return_t
chudxnu_cpu_timer_callback_enter(
	chudxnu_cpu_timer_callback_func_t	func,
	uint32_t				time,
	uint32_t				units)
{
	chudcpu_data_t	*chud_proc_info;
	boolean_t	oldlevel;

	oldlevel = ml_set_interrupts_enabled(FALSE);
	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);

	// cancel any existing callback for this cpu
	timer_call_cancel(&(chud_proc_info->cpu_timer_call));

	chud_proc_info->cpu_timer_callback_fn = func;

	clock_interval_to_deadline(time, units, &(chud_proc_info->t_deadline));
	timer_call_setup(&(chud_proc_info->cpu_timer_call),
			 chudxnu_private_cpu_timer_callback, NULL);
	timer_call_enter(&(chud_proc_info->cpu_timer_call),
			 chud_proc_info->t_deadline);

	KERNEL_DEBUG_CONSTANT(
		MACHDBG_CODE(DBG_MACH_CHUD,
			     CHUD_TIMER_CALLBACK_ENTER) | DBG_FUNC_NONE,
		(uint32_t) func, time, units, 0, 0);

	ml_set_interrupts_enabled(oldlevel);
	return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_cpu_timer_callback_cancel(void)
{
	chudcpu_data_t	*chud_proc_info;
	boolean_t	oldlevel;

	oldlevel = ml_set_interrupts_enabled(FALSE);
	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);

	timer_call_cancel(&(chud_proc_info->cpu_timer_call));

	KERNEL_DEBUG_CONSTANT(
		MACHDBG_CODE(DBG_MACH_CHUD,
			     CHUD_TIMER_CALLBACK_CANCEL) | DBG_FUNC_NONE,
		0, 0, 0, 0, 0);

	// set to max value:
	chud_proc_info->t_deadline |= ~(chud_proc_info->t_deadline);
	chud_proc_info->cpu_timer_callback_fn = NULL;

	ml_set_interrupts_enabled(oldlevel);
 	return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_cpu_timer_callback_cancel_all(void)
{
	unsigned int	cpu;
	chudcpu_data_t	*chud_proc_info;

	for(cpu=0; cpu < real_ncpus; cpu++) {
		chud_proc_info = (chudcpu_data_t *) cpu_data_ptr[cpu]->cpu_chud;
		if (chud_proc_info == NULL)
			continue;
		timer_call_cancel(&(chud_proc_info->cpu_timer_call));
		chud_proc_info->t_deadline |= ~(chud_proc_info->t_deadline);
		chud_proc_info->cpu_timer_callback_fn = NULL;
	}
	return KERN_SUCCESS;
}

#pragma mark **** trap ****
static chudxnu_trap_callback_func_t trap_callback_fn = NULL;

static kern_return_t
chudxnu_private_trap_callback(
	int			trapno,
	void			*regs,
	int			unused1,
	int			unused2)
{
#pragma unused (regs)
#pragma unused (unused1)
#pragma unused (unused2)
    kern_return_t retval = KERN_FAILURE;
	chudxnu_trap_callback_func_t fn = trap_callback_fn;

        if(fn) {
		boolean_t			oldlevel;
		x86_thread_state_t	state;	// once we have an 64bit- independent way to determine if a thread is
									// running kernel code, we'll switch to x86_thread_state_t.
		mach_msg_type_number_t		count;	

		oldlevel = ml_set_interrupts_enabled(FALSE);

		count = x86_THREAD_STATE_COUNT;
		if(chudxnu_thread_get_state(current_thread(),
				x86_THREAD_STATE,
				(thread_state_t)&state,
				&count,
				FALSE) == KERN_SUCCESS) {
	  
		  retval = (fn)(
				  trapno,
				  x86_THREAD_STATE,
				  (thread_state_t)&state,
				  count);
		}
    ml_set_interrupts_enabled(oldlevel);
	}

    return retval;
}

__private_extern__ kern_return_t
chudxnu_trap_callback_enter(chudxnu_trap_callback_func_t func)
{
    trap_callback_fn = func;
    perfTrapHook = chudxnu_private_trap_callback;
    return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_trap_callback_cancel(void)
{
    trap_callback_fn = NULL;
        perfTrapHook = NULL;
    return KERN_SUCCESS;
}

#pragma mark **** ast ****
static
chudxnu_perfmon_ast_callback_func_t perfmon_ast_callback_fn = NULL;

static kern_return_t
chudxnu_private_chud_ast_callback(
	int			trapno,
	void			*regs,
	int			unused1,
	int			unused2)
{
#pragma unused (trapno)
#pragma unused (regs)
#pragma unused (unused1)
#pragma unused (unused2)
	boolean_t	oldlevel = ml_set_interrupts_enabled(FALSE);
	ast_t		*myast = ast_pending();
	kern_return_t	retval = KERN_FAILURE;
	chudxnu_perfmon_ast_callback_func_t fn = perfmon_ast_callback_fn;
    
	if (*myast & AST_CHUD_URGENT) {
		*myast &= ~(AST_CHUD_URGENT | AST_CHUD);
		if ((*myast & AST_PREEMPTION) != AST_PREEMPTION)
			*myast &= ~(AST_URGENT);
		retval = KERN_SUCCESS;
	} else if (*myast & AST_CHUD) {
		*myast &= ~(AST_CHUD);
		retval = KERN_SUCCESS;
	}

	if (fn) {
		x86_thread_state_t state;
		mach_msg_type_number_t count;
		count = x86_THREAD_STATE_COUNT;
		
		if (chudxnu_thread_get_state(
			current_thread(),
			x86_THREAD_STATE,
			(thread_state_t) &state, &count,
			TRUE) == KERN_SUCCESS) {

			KERNEL_DEBUG_CONSTANT(
				MACHDBG_CODE(DBG_MACH_CHUD,
				    CHUD_AST_CALLBACK) | DBG_FUNC_NONE,
				(uint32_t) fn, 0, 0, 0, 0);

			(fn)(
				x86_THREAD_STATE,
				(thread_state_t) &state,
				count);
		}
	}
    
	ml_set_interrupts_enabled(oldlevel);
	return retval;
}

__private_extern__ kern_return_t
chudxnu_perfmon_ast_callback_enter(chudxnu_perfmon_ast_callback_func_t func)
{
	perfmon_ast_callback_fn = func;
	perfASTHook = chudxnu_private_chud_ast_callback;
	return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_perfmon_ast_callback_cancel(void)
{
    perfmon_ast_callback_fn = NULL;
    perfASTHook = NULL;
    return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_perfmon_ast_send_urgent(boolean_t urgent)
{
    boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
	ast_t *myast = ast_pending();

    if(urgent) {
        *myast |= (AST_CHUD_URGENT | AST_URGENT);
    } else {
        *myast |= (AST_CHUD);
    }

    KERNEL_DEBUG_CONSTANT(
	MACHDBG_CODE(DBG_MACH_CHUD, CHUD_AST_SEND) | DBG_FUNC_NONE,
	urgent, 0, 0, 0, 0);

    ml_set_interrupts_enabled(oldlevel);
    return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_perfmon_ast_send(void)
{
    return chudxnu_perfmon_ast_send_urgent(TRUE);
}

#pragma mark **** interrupt ****
static chudxnu_interrupt_callback_func_t interrupt_callback_fn = NULL;

static void
chudxnu_private_interrupt_callback(void *foo)
{
#pragma unused (foo)
	chudxnu_interrupt_callback_func_t fn = interrupt_callback_fn;

	if(fn) {
		boolean_t			oldlevel;
		x86_thread_state_t		state;
		mach_msg_type_number_t		count;

		oldlevel = ml_set_interrupts_enabled(FALSE);

		count = x86_THREAD_STATE_COUNT;
		if(chudxnu_thread_get_state(current_thread(),
					    x86_THREAD_STATE,
					    (thread_state_t)&state,
					    &count,
					    FALSE) == KERN_SUCCESS) {
			(fn)(
				X86_INTERRUPT_PERFMON,
				x86_THREAD_STATE,
				(thread_state_t)&state,
				count);
		}
		ml_set_interrupts_enabled(oldlevel);
	}
}

__private_extern__ kern_return_t
chudxnu_interrupt_callback_enter(chudxnu_interrupt_callback_func_t func)
{
    interrupt_callback_fn = func;
    lapic_set_pmi_func((i386_intr_func_t)chudxnu_private_interrupt_callback);
    return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_interrupt_callback_cancel(void)
{
    interrupt_callback_fn = NULL;
    lapic_set_pmi_func(NULL);
    return KERN_SUCCESS;
}

#pragma mark **** cpu signal ****
static chudxnu_cpusig_callback_func_t cpusig_callback_fn = NULL;

static          kern_return_t
chudxnu_private_cpu_signal_handler(int request)
{
	chudxnu_cpusig_callback_func_t fn = cpusig_callback_fn;
	
	if (fn) {
	x86_thread_state_t  state;
		mach_msg_type_number_t count = x86_THREAD_STATE_COUNT;

		if (chudxnu_thread_get_state(current_thread(),
					     x86_THREAD_STATE,
					     (thread_state_t) &state, &count,
					     FALSE) == KERN_SUCCESS) {
			KERNEL_DEBUG_CONSTANT(
				MACHDBG_CODE(DBG_MACH_CHUD,
					CHUD_CPUSIG_CALLBACK) | DBG_FUNC_NONE,
				(uint32_t)fn, request, 0, 0, 0);
			return (fn)(
					request, x86_THREAD_STATE,
					(thread_state_t) &state, count);
		} else {
			return KERN_FAILURE;
		}
	}
	return KERN_SUCCESS; //ignored
}
/*
 * chudxnu_cpu_signal_handler() is called from the IPI handler
 * when a CHUD signal arrives from another processor.
 */
__private_extern__ void
chudxnu_cpu_signal_handler(void)
{
	chudcpu_signal_request_t	*reqp;
	chudcpu_data_t			*chudinfop;

	chudinfop = (chudcpu_data_t *) current_cpu_datap()->cpu_chud;

	mpdequeue_head(&(chudinfop->cpu_request_queue),
		       (queue_entry_t *) &reqp);
	while (reqp != NULL) {
		chudxnu_private_cpu_signal_handler(reqp->req_code);
		reqp->req_sync = 0;
		mpdequeue_head(&(chudinfop->cpu_request_queue),
			       (queue_entry_t *) &reqp);
	}
}

__private_extern__ kern_return_t
chudxnu_cpusig_callback_enter(chudxnu_cpusig_callback_func_t func)
{
	cpusig_callback_fn = func;
	return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_cpusig_callback_cancel(void)
{
	cpusig_callback_fn = NULL;
	return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_cpusig_send(int otherCPU, uint32_t request_code)
{
	int				thisCPU;
	kern_return_t			retval = KERN_FAILURE;
	chudcpu_signal_request_t	request;
	uint64_t			deadline;
	chudcpu_data_t			*target_chudp;
	boolean_t old_level;

	disable_preemption();
	// force interrupts on for a cross CPU signal.
	old_level = chudxnu_set_interrupts_enabled(TRUE);
	thisCPU = cpu_number();

	if ((unsigned) otherCPU < real_ncpus &&
	    thisCPU != otherCPU &&
	    cpu_data_ptr[otherCPU]->cpu_running) {

		target_chudp = (chudcpu_data_t *)
					cpu_data_ptr[otherCPU]->cpu_chud;

		/* Fill out request */
		request.req_sync = 0xFFFFFFFF;		/* set sync flag */
		//request.req_type = CPRQchud;		/* set request type */
		request.req_code = request_code;	/* set request */

		KERNEL_DEBUG_CONSTANT(
			MACHDBG_CODE(DBG_MACH_CHUD,
				     CHUD_CPUSIG_SEND) | DBG_FUNC_NONE,
			otherCPU, request_code, 0, 0, 0);

		/*
		 * Insert the new request in the target cpu's request queue
		 * and signal target cpu.
		 */
		mpenqueue_tail(&target_chudp->cpu_request_queue,
			       &request.req_entry);
		i386_signal_cpu(otherCPU, MP_CHUD, ASYNC);

		/* Wait for response or timeout */
		deadline = mach_absolute_time() + LockTimeOut;
		while (request.req_sync != 0) {
			if (mach_absolute_time() > deadline) {
				panic("chudxnu_cpusig_send(%d,%d) timed out\n",
					otherCPU, request_code);
			}
			cpu_pause();
		}
		retval = KERN_SUCCESS;
	} else {
		retval = KERN_INVALID_ARGUMENT;
	}

	chudxnu_set_interrupts_enabled(old_level);
	enable_preemption();
	return retval;
}

#ifdef XXX
#pragma mark **** CHUD syscall (PPC) ****

typedef int (*PPCcallEnt)(struct savearea *save);
extern PPCcallEnt      PPCcalls[];

static chudxnu_syscall_callback_func_t syscall_callback_fn = NULL;

static int
chudxnu_private_syscall_callback(struct savearea *ssp)
{
	if(ssp) {
		if(syscall_callback_fn) {
			struct ppc_thread_state64 state;
			kern_return_t retval;
			mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
			chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
			ssp->save_r3 = (syscall_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
		} else {
			ssp->save_r3 = KERN_FAILURE;
		}
	}
	
    return 1; // check for ASTs (always)
}

__private_extern__ kern_return_t
chudxnu_syscall_callback_enter(chudxnu_syscall_callback_func_t func)
{
	syscall_callback_fn = func;
	PPCcalls[9] = chudxnu_private_syscall_callback;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__ kern_return_t
chudxnu_syscall_callback_cancel(void)
{
	syscall_callback_fn = NULL;
	PPCcalls[9] = NULL;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}
#endif
Commit	Line	Data
4452a7af A	1	/*
	2	* Copyright (c) 2003-2004 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	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.
	14	*
	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
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	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.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#include <stdint.h>
	30	#include <mach/boolean.h>
	31	#include <mach/mach_types.h>
	32
	33	#include <kern/kern_types.h>
	34	#include <kern/processor.h>
	35	#include <kern/timer_call.h>
	36	#include <kern/thread_call.h>
	37	#include <kern/kalloc.h>
	38	#include <kern/thread.h>
	39
	40	#include <machine/machine_routines.h>
	41	#include <machine/cpu_data.h>
	42	#include <machine/trap.h>
	43
	44	#include <chud/chud_xnu.h>
	45	#include <chud/chud_xnu_private.h>
	46
	47	#include <i386/misc_protos.h>
	48	#include <i386/mp.h>
	49	#include <i386/machine_cpu.h>
	50
	51	#include <sys/kdebug.h>
	52	#define CHUD_TIMER_CALLBACK_CANCEL 0
	53	#define CHUD_TIMER_CALLBACK_ENTER 1
	54	#define CHUD_TIMER_CALLBACK 2
	55	#define CHUD_AST_SEND 3
	56	#define CHUD_AST_CALLBACK 4
	57	#define CHUD_CPUSIG_SEND 5
	58	#define CHUD_CPUSIG_CALLBACK 6
	59
	60	__private_extern__
	61	void chudxnu_cancel_all_callbacks(void)
	62	{
	63	chudxnu_cpusig_callback_cancel();
	64	chudxnu_cpu_timer_callback_cancel_all();
65	chudxnu_interrupt_callback_cancel();
66	chudxnu_perfmon_ast_callback_cancel();
67	chudxnu_kdebug_callback_cancel();
68	chudxnu_thread_timer_callback_cancel();
69	chudxnu_trap_callback_cancel();
70	#if XXX
71	chudxnu_syscall_callback_cancel();
72	#endif
73	}
74
75	static chudcpu_data_t chudcpu_boot_cpu;
76	void *
77	chudxnu_cpu_alloc(boolean_t boot_processor)
78	{
79	chudcpu_data_t *chud_proc_info;
80
81
82	if (boot_processor) {
83	chud_proc_info = &chudcpu_boot_cpu;
84	} else {
85	chud_proc_info = (chudcpu_data_t *)
86	kalloc(sizeof(chudcpu_data_t));
87	if (chud_proc_info == (chudcpu_data_t *)NULL) {
88	return (void *)NULL;
89	}
90	}
91	bzero((char *)chud_proc_info, sizeof(chudcpu_data_t));
92	chud_proc_info->t_deadline = 0xFFFFFFFFFFFFFFFFULL;
93	mpqueue_init(&chud_proc_info->cpu_request_queue);
94
95
96	return (void *)chud_proc_info;
97	}
98
99	void
100	chudxnu_cpu_free(void *cp)
101	{
102	if (cp == NULL \|\| cp == (void *)&chudcpu_boot_cpu) {
103	return;
104	} else {
105	kfree(cp,sizeof(chudcpu_data_t));
106	}
107	}
108
109	static void
110	chudxnu_private_cpu_timer_callback(
111	timer_call_param_t param0,
112	timer_call_param_t param1)
113	{
114	#pragma unused (param0)
115	#pragma unused (param1)
116	chudcpu_data_t *chud_proc_info;
117	boolean_t oldlevel;
118	x86_thread_state_t state;
119	mach_msg_type_number_t count;
120	chudxnu_cpu_timer_callback_func_t fn;
121
122	oldlevel = ml_set_interrupts_enabled(FALSE);
123	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);
124
125	count = x86_THREAD_STATE_COUNT;
126	if (chudxnu_thread_get_state(current_thread(),
127	x86_THREAD_STATE,
128	(thread_state_t)&state,
129	&count,
130	FALSE) == KERN_SUCCESS) {
131	fn = chud_proc_info->cpu_timer_callback_fn;
132	if (fn) {
133	KERNEL_DEBUG_CONSTANT(
134	MACHDBG_CODE(DBG_MACH_CHUD,
135	CHUD_TIMER_CALLBACK) \| DBG_FUNC_NONE,
136	(uint32_t)fn, 0,0,0,0);
137	//state.eip, state.cs, 0, 0);
138	(fn)(
139	x86_THREAD_STATE,
140	(thread_state_t)&state,
141	count);
142	}
143	}
144
145	ml_set_interrupts_enabled(oldlevel);
146	}
147
148	__private_extern__ kern_return_t
149	chudxnu_cpu_timer_callback_enter(
150	chudxnu_cpu_timer_callback_func_t func,
151	uint32_t time,
152	uint32_t units)
153	{
154	chudcpu_data_t *chud_proc_info;
155	boolean_t oldlevel;
156
157	oldlevel = ml_set_interrupts_enabled(FALSE);
158	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);
159
160	// cancel any existing callback for this cpu
161	timer_call_cancel(&(chud_proc_info->cpu_timer_call));
162
163	chud_proc_info->cpu_timer_callback_fn = func;
164
165	clock_interval_to_deadline(time, units, &(chud_proc_info->t_deadline));
166	timer_call_setup(&(chud_proc_info->cpu_timer_call),
167	chudxnu_private_cpu_timer_callback, NULL);
168	timer_call_enter(&(chud_proc_info->cpu_timer_call),
169	chud_proc_info->t_deadline);
170
171	KERNEL_DEBUG_CONSTANT(
172	MACHDBG_CODE(DBG_MACH_CHUD,
173	CHUD_TIMER_CALLBACK_ENTER) \| DBG_FUNC_NONE,
174	(uint32_t) func, time, units, 0, 0);
175
176	ml_set_interrupts_enabled(oldlevel);
177	return KERN_SUCCESS;
178	}
179
180	__private_extern__ kern_return_t
181	chudxnu_cpu_timer_callback_cancel(void)
182	{
183	chudcpu_data_t *chud_proc_info;
184	boolean_t oldlevel;
185
186	oldlevel = ml_set_interrupts_enabled(FALSE);
187	chud_proc_info = (chudcpu_data_t *)(current_cpu_datap()->cpu_chud);
188
189	timer_call_cancel(&(chud_proc_info->cpu_timer_call));
190
191	KERNEL_DEBUG_CONSTANT(
192	MACHDBG_CODE(DBG_MACH_CHUD,
193	CHUD_TIMER_CALLBACK_CANCEL) \| DBG_FUNC_NONE,
194	0, 0, 0, 0, 0);
195
196	// set to max value:
197	chud_proc_info->t_deadline \|= ~(chud_proc_info->t_deadline);
198	chud_proc_info->cpu_timer_callback_fn = NULL;
199
200	ml_set_interrupts_enabled(oldlevel);
201	return KERN_SUCCESS;
202	}
203
204	__private_extern__ kern_return_t
205	chudxnu_cpu_timer_callback_cancel_all(void)
206	{
207	unsigned int cpu;
208	chudcpu_data_t *chud_proc_info;
209
210	for(cpu=0; cpu < real_ncpus; cpu++) {
211	chud_proc_info = (chudcpu_data_t *) cpu_data_ptr[cpu]->cpu_chud;
212	if (chud_proc_info == NULL)
213	continue;
214	timer_call_cancel(&(chud_proc_info->cpu_timer_call));
215	chud_proc_info->t_deadline \|= ~(chud_proc_info->t_deadline);
216	chud_proc_info->cpu_timer_callback_fn = NULL;
217	}
218	return KERN_SUCCESS;
219	}
220
221	#pragma mark ** trap **
222	static chudxnu_trap_callback_func_t trap_callback_fn = NULL;
223
224	static kern_return_t
225	chudxnu_private_trap_callback(
226	int trapno,
227	void *regs,
228	int unused1,
229	int unused2)
230	{
231	#pragma unused (regs)
232	#pragma unused (unused1)
233	#pragma unused (unused2)
234	kern_return_t retval = KERN_FAILURE;
235	chudxnu_trap_callback_func_t fn = trap_callback_fn;
236
237	if(fn) {
238	boolean_t oldlevel;
239	x86_thread_state_t state; // once we have an 64bit- independent way to determine if a thread is
240	// running kernel code, we'll switch to x86_thread_state_t.
241	mach_msg_type_number_t count;
242
243	oldlevel = ml_set_interrupts_enabled(FALSE);
244
245	count = x86_THREAD_STATE_COUNT;
246	if(chudxnu_thread_get_state(current_thread(),
247	x86_THREAD_STATE,
248	(thread_state_t)&state,
249	&count,
250	FALSE) == KERN_SUCCESS) {
251
252	retval = (fn)(
253	trapno,
254	x86_THREAD_STATE,
255	(thread_state_t)&state,
256	count);
257	}
258	ml_set_interrupts_enabled(oldlevel);
259	}
260
261	return retval;
262	}
263
264	__private_extern__ kern_return_t
265	chudxnu_trap_callback_enter(chudxnu_trap_callback_func_t func)
266	{
267	trap_callback_fn = func;
268	perfTrapHook = chudxnu_private_trap_callback;
269	return KERN_SUCCESS;
270	}
271
272	__private_extern__ kern_return_t
273	chudxnu_trap_callback_cancel(void)
274	{
275	trap_callback_fn = NULL;
276	perfTrapHook = NULL;
277	return KERN_SUCCESS;
278	}
279
280	#pragma mark ** ast **
281	static
282	chudxnu_perfmon_ast_callback_func_t perfmon_ast_callback_fn = NULL;
283
284	static kern_return_t
285	chudxnu_private_chud_ast_callback(
286	int trapno,
287	void *regs,
288	int unused1,
289	int unused2)
290	{
291	#pragma unused (trapno)
292	#pragma unused (regs)
293	#pragma unused (unused1)
294	#pragma unused (unused2)
295	boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
296	ast_t *myast = ast_pending();
297	kern_return_t retval = KERN_FAILURE;
298	chudxnu_perfmon_ast_callback_func_t fn = perfmon_ast_callback_fn;
299
300	if (*myast & AST_CHUD_URGENT) {
301	*myast &= ~(AST_CHUD_URGENT \| AST_CHUD);
302	if ((*myast & AST_PREEMPTION) != AST_PREEMPTION)
303	*myast &= ~(AST_URGENT);
304	retval = KERN_SUCCESS;
305	} else if (*myast & AST_CHUD) {
306	*myast &= ~(AST_CHUD);
307	retval = KERN_SUCCESS;
308	}
309
310	if (fn) {
311	x86_thread_state_t state;
312	mach_msg_type_number_t count;
313	count = x86_THREAD_STATE_COUNT;
314
315	if (chudxnu_thread_get_state(
316	current_thread(),
317	x86_THREAD_STATE,
318	(thread_state_t) &state, &count,
319	TRUE) == KERN_SUCCESS) {
320
321	KERNEL_DEBUG_CONSTANT(
322	MACHDBG_CODE(DBG_MACH_CHUD,
323	CHUD_AST_CALLBACK) \| DBG_FUNC_NONE,
324	(uint32_t) fn, 0, 0, 0, 0);
325
326	(fn)(
327	x86_THREAD_STATE,
328	(thread_state_t) &state,
329	count);
330	}
331	}
332
333	ml_set_interrupts_enabled(oldlevel);
334	return retval;
335	}
336
337	__private_extern__ kern_return_t
338	chudxnu_perfmon_ast_callback_enter(chudxnu_perfmon_ast_callback_func_t func)
339	{
340	perfmon_ast_callback_fn = func;
341	perfASTHook = chudxnu_private_chud_ast_callback;
342	return KERN_SUCCESS;
343	}
344
345	__private_extern__ kern_return_t
346	chudxnu_perfmon_ast_callback_cancel(void)
347	{
348	perfmon_ast_callback_fn = NULL;
349	perfASTHook = NULL;
350	return KERN_SUCCESS;
351	}
352
353	__private_extern__ kern_return_t
354	chudxnu_perfmon_ast_send_urgent(boolean_t urgent)
355	{
356	boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
357	ast_t *myast = ast_pending();
358
359	if(urgent) {
360	*myast \|= (AST_CHUD_URGENT \| AST_URGENT);
361	} else {
362	*myast \|= (AST_CHUD);
363	}
364
365	KERNEL_DEBUG_CONSTANT(
366	MACHDBG_CODE(DBG_MACH_CHUD, CHUD_AST_SEND) \| DBG_FUNC_NONE,
367	urgent, 0, 0, 0, 0);
368
369	ml_set_interrupts_enabled(oldlevel);
370	return KERN_SUCCESS;
371	}
372
373	__private_extern__ kern_return_t
374	chudxnu_perfmon_ast_send(void)
375	{
376	return chudxnu_perfmon_ast_send_urgent(TRUE);
377	}
378
379	#pragma mark ** interrupt **
380	static chudxnu_interrupt_callback_func_t interrupt_callback_fn = NULL;
381
382	static void
383	chudxnu_private_interrupt_callback(void *foo)
384	{
385	#pragma unused (foo)
386	chudxnu_interrupt_callback_func_t fn = interrupt_callback_fn;
387
388	if(fn) {
389	boolean_t oldlevel;
390	x86_thread_state_t state;
391	mach_msg_type_number_t count;
392
393	oldlevel = ml_set_interrupts_enabled(FALSE);
394
395	count = x86_THREAD_STATE_COUNT;
396	if(chudxnu_thread_get_state(current_thread(),
397	x86_THREAD_STATE,
398	(thread_state_t)&state,
399	&count,
400	FALSE) == KERN_SUCCESS) {
401	(fn)(
402	X86_INTERRUPT_PERFMON,
403	x86_THREAD_STATE,
404	(thread_state_t)&state,
405	count);
406	}
407	ml_set_interrupts_enabled(oldlevel);
408	}
409	}
410
411	__private_extern__ kern_return_t
412	chudxnu_interrupt_callback_enter(chudxnu_interrupt_callback_func_t func)
413	{
414	interrupt_callback_fn = func;
415	lapic_set_pmi_func((i386_intr_func_t)chudxnu_private_interrupt_callback);
416	return KERN_SUCCESS;
417	}
418
419	__private_extern__ kern_return_t
420	chudxnu_interrupt_callback_cancel(void)
421	{
422	interrupt_callback_fn = NULL;
423	lapic_set_pmi_func(NULL);
424	return KERN_SUCCESS;
425	}
426
427	#pragma mark ** cpu signal **
428	static chudxnu_cpusig_callback_func_t cpusig_callback_fn = NULL;
429
430	static kern_return_t
431	chudxnu_private_cpu_signal_handler(int request)
432	{
433	chudxnu_cpusig_callback_func_t fn = cpusig_callback_fn;
434
435	if (fn) {
436	x86_thread_state_t state;
437	mach_msg_type_number_t count = x86_THREAD_STATE_COUNT;
438
439	if (chudxnu_thread_get_state(current_thread(),
440	x86_THREAD_STATE,
441	(thread_state_t) &state, &count,
442	FALSE) == KERN_SUCCESS) {
443	KERNEL_DEBUG_CONSTANT(
444	MACHDBG_CODE(DBG_MACH_CHUD,
445	CHUD_CPUSIG_CALLBACK) \| DBG_FUNC_NONE,
446	(uint32_t)fn, request, 0, 0, 0);
447	return (fn)(
448	request, x86_THREAD_STATE,
449	(thread_state_t) &state, count);
450	} else {
451	return KERN_FAILURE;
452	}
453	}
454	return KERN_SUCCESS; //ignored
455	}
456	/*
457	* chudxnu_cpu_signal_handler() is called from the IPI handler
458	* when a CHUD signal arrives from another processor.
459	*/
460	__private_extern__ void
461	chudxnu_cpu_signal_handler(void)
462	{
463	chudcpu_signal_request_t *reqp;
464	chudcpu_data_t *chudinfop;
465
466	chudinfop = (chudcpu_data_t *) current_cpu_datap()->cpu_chud;
467
468	mpdequeue_head(&(chudinfop->cpu_request_queue),
469	(queue_entry_t *) &reqp);
470	while (reqp != NULL) {
471	chudxnu_private_cpu_signal_handler(reqp->req_code);
472	reqp->req_sync = 0;
473	mpdequeue_head(&(chudinfop->cpu_request_queue),
474	(queue_entry_t *) &reqp);
475	}
476	}
477
478	__private_extern__ kern_return_t
479	chudxnu_cpusig_callback_enter(chudxnu_cpusig_callback_func_t func)
480	{
481	cpusig_callback_fn = func;
482	return KERN_SUCCESS;
483	}
484
485	__private_extern__ kern_return_t
486	chudxnu_cpusig_callback_cancel(void)
487	{
488	cpusig_callback_fn = NULL;
489	return KERN_SUCCESS;
490	}
491
492	__private_extern__ kern_return_t
493	chudxnu_cpusig_send(int otherCPU, uint32_t request_code)
494	{
495	int thisCPU;
496	kern_return_t retval = KERN_FAILURE;
497	chudcpu_signal_request_t request;
498	uint64_t deadline;
499	chudcpu_data_t *target_chudp;
500	boolean_t old_level;
501
502	disable_preemption();
503	// force interrupts on for a cross CPU signal.
504	old_level = chudxnu_set_interrupts_enabled(TRUE);
505	thisCPU = cpu_number();
506
507	if ((unsigned) otherCPU < real_ncpus &&
508	thisCPU != otherCPU &&
509	cpu_data_ptr[otherCPU]->cpu_running) {
510
511	target_chudp = (chudcpu_data_t *)
512	cpu_data_ptr[otherCPU]->cpu_chud;
513
514	/* Fill out request */
515	request.req_sync = 0xFFFFFFFF; /* set sync flag */
516	//request.req_type = CPRQchud; /* set request type */
517	request.req_code = request_code; /* set request */
518
519	KERNEL_DEBUG_CONSTANT(
520	MACHDBG_CODE(DBG_MACH_CHUD,
521	CHUD_CPUSIG_SEND) \| DBG_FUNC_NONE,
522	otherCPU, request_code, 0, 0, 0);
523
524	/*
525	* Insert the new request in the target cpu's request queue
526	* and signal target cpu.
527	*/
528	mpenqueue_tail(&target_chudp->cpu_request_queue,
529	&request.req_entry);
530	i386_signal_cpu(otherCPU, MP_CHUD, ASYNC);
531
532	/* Wait for response or timeout */
533	deadline = mach_absolute_time() + LockTimeOut;
534	while (request.req_sync != 0) {
535	if (mach_absolute_time() > deadline) {
536	panic("chudxnu_cpusig_send(%d,%d) timed out\n",
537	otherCPU, request_code);
538	}
539	cpu_pause();
540	}
541	retval = KERN_SUCCESS;
542	} else {
543	retval = KERN_INVALID_ARGUMENT;
544	}
545
546	chudxnu_set_interrupts_enabled(old_level);
547	enable_preemption();
548	return retval;
549	}
550
551	#ifdef XXX
552	#pragma mark ** CHUD syscall (PPC) **
553
554	typedef int (PPCcallEnt)(struct savearea save);
555	extern PPCcallEnt PPCcalls[];
556
557	static chudxnu_syscall_callback_func_t syscall_callback_fn = NULL;
558
559	static int
560	chudxnu_private_syscall_callback(struct savearea *ssp)
561	{
562	if(ssp) {
563	if(syscall_callback_fn) {
564	struct ppc_thread_state64 state;
565	kern_return_t retval;
566	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
567	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
568	ssp->save_r3 = (syscall_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
569	} else {
570	ssp->save_r3 = KERN_FAILURE;
571	}
572	}
573
574	return 1; // check for ASTs (always)
575	}
576
577	__private_extern__ kern_return_t
578	chudxnu_syscall_callback_enter(chudxnu_syscall_callback_func_t func)
579	{
580	syscall_callback_fn = func;
581	PPCcalls[9] = chudxnu_private_syscall_callback;
582	__asm__ volatile("eieio"); /* force order */
583	__asm__ volatile("sync"); /* force to memory */
584	return KERN_SUCCESS;
585	}
586
587	__private_extern__ kern_return_t
588	chudxnu_syscall_callback_cancel(void)
589	{
590	syscall_callback_fn = NULL;
591	PPCcalls[9] = NULL;
592	__asm__ volatile("eieio"); /* force order */
593	__asm__ volatile("sync"); /* force to memory */
594	return KERN_SUCCESS;
595	}
596	#endif