[apple/xnu.git] / osfmk / ppc / chud / chud_osfmk_callback.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 <ppc/machine_routines.h>
#include <ppc/cpu_data.h>
#include <ppc/cpu_internal.h>
#include <ppc/exception.h>
#include <ppc/thread.h>
#include <ppc/trap.h>

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

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

#pragma mark **** cpu timer ****
typedef struct {
	timer_call_data_t	cpu_timer_call;
	uint64_t		t_deadline;
	chudxnu_cpu_timer_callback_func_t	cpu_timer_callback_fn;
} chudcpu_data_t;

static chudcpu_data_t chudcpu_boot_cpu;

void *chudxnu_per_proc_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;
	return (void *)chud_proc_info;
}

void chudxnu_per_proc_free(void *per_proc_chud)
{
	if (per_proc_chud == (void *)&chudcpu_boot_cpu) {
		return;
	} else {
		kfree(per_proc_chud,sizeof(chudcpu_data_t));
	}
}

static void chudxnu_private_cpu_timer_callback(timer_call_param_t param0, timer_call_param_t param1)
{
    chudcpu_data_t	*chud_proc_info;
    boolean_t oldlevel;
    struct ppc_thread_state64 state;
    mach_msg_type_number_t count;

    oldlevel = ml_set_interrupts_enabled(FALSE);
    chud_proc_info = (chudcpu_data_t *)(getPerProc()->pp_chud);

    count = PPC_THREAD_STATE64_COUNT;
    if(chudxnu_thread_get_state(current_thread(), PPC_THREAD_STATE64, (thread_state_t)&state, &count, FALSE)==KERN_SUCCESS) {
        if(chud_proc_info->cpu_timer_callback_fn) {
            (chud_proc_info->cpu_timer_callback_fn)(PPC_THREAD_STATE64, (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 *)(getPerProc()->pp_chud);

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

    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);

    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 *)(getPerProc()->pp_chud);

    timer_call_cancel(&(chud_proc_info->cpu_timer_call));
    chud_proc_info->t_deadline = chud_proc_info->t_deadline | ~(chud_proc_info->t_deadline); // set to max value
    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++) {
    	if ((PerProcTable[cpu].ppe_vaddr == 0)
    	    || (PerProcTable[cpu].ppe_vaddr->pp_chud == 0))
			continue;
    	chud_proc_info = (chudcpu_data_t *)PerProcTable[cpu].ppe_vaddr->pp_chud;
        timer_call_cancel(&(chud_proc_info->cpu_timer_call));
        chud_proc_info->t_deadline = chud_proc_info->t_deadline | ~(chud_proc_info->t_deadline); // set to max value
        chud_proc_info->cpu_timer_callback_fn = NULL;
    }
    return KERN_SUCCESS;
}

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

#define TRAP_ENTRY_POINT(t) ((t==T_RESET) ? 0x100 : \
                             (t==T_MACHINE_CHECK) ? 0x200 : \
                             (t==T_DATA_ACCESS) ? 0x300 : \
                             (t==T_DATA_SEGMENT) ? 0x380 : \
                             (t==T_INSTRUCTION_ACCESS) ? 0x400 : \
                             (t==T_INSTRUCTION_SEGMENT) ? 0x480 : \
                             (t==T_INTERRUPT) ? 0x500 : \
                             (t==T_ALIGNMENT) ? 0x600 : \
                             (t==T_PROGRAM) ? 0x700 : \
                             (t==T_FP_UNAVAILABLE) ? 0x800 : \
                             (t==T_DECREMENTER) ? 0x900 : \
                             (t==T_IO_ERROR) ? 0xa00 : \
                             (t==T_RESERVED) ? 0xb00 : \
                             (t==T_SYSTEM_CALL) ? 0xc00 : \
                             (t==T_TRACE) ? 0xd00 : \
                             (t==T_FP_ASSIST) ? 0xe00 : \
                             (t==T_PERF_MON) ? 0xf00 : \
                             (t==T_VMX) ? 0xf20 : \
                             (t==T_INVALID_EXCP0) ? 0x1000 : \
                             (t==T_INVALID_EXCP1) ? 0x1100 : \
                             (t==T_INVALID_EXCP2) ? 0x1200 : \
                             (t==T_INSTRUCTION_BKPT) ? 0x1300 : \
                             (t==T_SYSTEM_MANAGEMENT) ? 0x1400 : \
                             (t==T_SOFT_PATCH) ? 0x1500 : \
                             (t==T_ALTIVEC_ASSIST) ? 0x1600 : \
                             (t==T_THERMAL) ? 0x1700 : \
                             (t==T_ARCHDEP0) ? 0x1800 : \
                             (t==T_INSTRUMENTATION) ? 0x2000 : \
                             0x0)

static kern_return_t chudxnu_private_trap_callback(int trapno, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
{
    boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
    kern_return_t retval = KERN_FAILURE;
    uint32_t trapentry = TRAP_ENTRY_POINT(trapno);

    if(trapentry!=0x0) {
        if(trap_callback_fn) {
            struct ppc_thread_state64 state;
            mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
            chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
            retval = (trap_callback_fn)(trapentry, PPC_THREAD_STATE64, (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;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_trap_callback_cancel(void)
{
    trap_callback_fn = NULL;
        perfTrapHook = NULL;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    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, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
{
    boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
    ast_t *myast = ast_pending();
    kern_return_t retval = KERN_FAILURE;
    
	if(*myast & AST_PPC_CHUD_URGENT) {
		*myast &= ~(AST_PPC_CHUD_URGENT | AST_PPC_CHUD);
		if((*myast & AST_PREEMPTION) != AST_PREEMPTION) *myast &= ~(AST_URGENT);
		retval = KERN_SUCCESS;
	} else if(*myast & AST_PPC_CHUD) {
		*myast &= ~(AST_PPC_CHUD);
		retval = KERN_SUCCESS;
	}

    if(perfmon_ast_callback_fn) {
		struct ppc_thread_state64 state;
		mach_msg_type_number_t count;
		count = PPC_THREAD_STATE64_COUNT;
		
		if(chudxnu_thread_get_state(current_thread(), PPC_THREAD_STATE64, (thread_state_t)&state, &count, FALSE)==KERN_SUCCESS) {
			(perfmon_ast_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
		}
    }
    
#if 0
    // ASTs from ihandler go through thandler and are made to look like traps
    // always handle AST_PPC_CHUD_URGENT if there's a callback
    // only handle AST_PPC_CHUD if it's the only AST pending
    if(perfmon_ast_callback_fn && ((*myast & AST_PPC_CHUD_URGENT) || ((*myast & AST_PPC_CHUD) && !(*myast & AST_URGENT)))) {
        struct ppc_thread_state64 state;
        mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
        chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
        if(*myast & AST_PPC_CHUD_URGENT) {
            *myast &= ~(AST_PPC_CHUD_URGENT | AST_PPC_CHUD);
            if((*myast & AST_PREEMPTION) != AST_PREEMPTION) *myast &= ~(AST_URGENT);
			retval = KERN_SUCCESS;
        } else if(*myast & AST_PPC_CHUD) {
            *myast &= ~(AST_PPC_CHUD);
			retval = KERN_SUCCESS;
        }
        (perfmon_ast_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
    }
#endif

    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;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_perfmon_ast_callback_cancel(void)
{
    perfmon_ast_callback_fn = NULL;
    perfASTHook = NULL;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    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_PPC_CHUD_URGENT | AST_URGENT);
    } else {
        *myast |= (AST_PPC_CHUD);
    }

    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;
//extern perfCallback perfIntHook; /* function hook into interrupt() */

static kern_return_t chudxnu_private_interrupt_callback(int trapno, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
{
    if(interrupt_callback_fn) {
        struct ppc_thread_state64 state;
        mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
        chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
        return (interrupt_callback_fn)(TRAP_ENTRY_POINT(trapno), PPC_THREAD_STATE64, (thread_state_t)&state, count);
    } else {
        return KERN_FAILURE;
    }
}

__private_extern__
kern_return_t chudxnu_interrupt_callback_enter(chudxnu_interrupt_callback_func_t func)
{
    interrupt_callback_fn = func;
    perfIntHook = chudxnu_private_interrupt_callback;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_interrupt_callback_cancel(void)
{
    interrupt_callback_fn = NULL;
    perfIntHook = NULL;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

#pragma mark **** cpu signal ****
static chudxnu_cpusig_callback_func_t cpusig_callback_fn = NULL;
extern perfCallback perfCpuSigHook; /* function hook into cpu_signal_handler() */

static kern_return_t chudxnu_private_cpu_signal_handler(int request, struct savearea *ssp, unsigned int arg0, unsigned int arg1)
{
    if(cpusig_callback_fn) {
        struct ppc_thread_state64 state;
        mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
        chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
        (cpusig_callback_fn)(request, PPC_THREAD_STATE64, (thread_state_t)&state, count);
    }
    return KERN_SUCCESS; // ignored
}

__private_extern__
kern_return_t chudxnu_cpusig_callback_enter(chudxnu_cpusig_callback_func_t func)
{
    cpusig_callback_fn = func;
    perfCpuSigHook = chudxnu_private_cpu_signal_handler;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_cpusig_callback_cancel(void)
{
    cpusig_callback_fn = NULL;
    perfCpuSigHook = NULL;
    __asm__ volatile("eieio");	/* force order */
    __asm__ volatile("sync");	/* force to memory */
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_cpusig_send(int otherCPU, uint32_t request)
{
    int thisCPU;
    kern_return_t retval = KERN_FAILURE;
    int retries = 0;
    boolean_t oldlevel;
    uint32_t temp[2];

    oldlevel = ml_set_interrupts_enabled(FALSE);
    thisCPU = cpu_number();

    if(thisCPU!=otherCPU) {
        temp[0] = 0xFFFFFFFF;		/* set sync flag */
        temp[1] = request;			/* set request */
        __asm__ volatile("eieio");	/* force order */
        __asm__ volatile("sync");	/* force to memory */

        do {
            retval=cpu_signal(otherCPU, SIGPcpureq, CPRQchud, (uint32_t)&temp);
        } while(retval!=KERN_SUCCESS && (retries++)<16);
    
        if(retries>=16) {
            retval = KERN_FAILURE;
        } else {
            retval = hw_cpu_sync(temp, LockTimeOut); /* wait for the other processor */
            if(!retval) {
                retval = KERN_FAILURE;
            } else {
                retval = KERN_SUCCESS;
            }
        }
    } else {
        retval = KERN_INVALID_ARGUMENT;
    }

    ml_set_interrupts_enabled(oldlevel);
    return retval;
}

#pragma mark **** timer ****
__private_extern__
chud_timer_t chudxnu_timer_alloc(chudxnu_timer_callback_func_t func, uint32_t param0)
{
    return (chud_timer_t)thread_call_allocate((thread_call_func_t)func, (thread_call_param_t)param0);
}

__private_extern__
kern_return_t chudxnu_timer_callback_enter(chud_timer_t timer, uint32_t param1, uint32_t time, uint32_t units)
{
    uint64_t t_delay;
    clock_interval_to_deadline(time, units, &t_delay);
    thread_call_enter1_delayed((thread_call_t)timer, (thread_call_param_t)param1, t_delay);
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_timer_callback_cancel(chud_timer_t timer)
{
    thread_call_cancel((thread_call_t)timer);
    return KERN_SUCCESS;
}

__private_extern__
kern_return_t chudxnu_timer_free(chud_timer_t timer)
{
    thread_call_cancel((thread_call_t)timer);
    thread_call_free((thread_call_t)timer);
    return KERN_SUCCESS;
}

#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;
}

#pragma mark **** thread timer - DEPRECATED ****

static thread_call_t thread_timer_call = NULL;
static chudxnu_thread_timer_callback_func_t thread_timer_callback_fn = NULL;

static void chudxnu_private_thread_timer_callback(thread_call_param_t param0, thread_call_param_t param1)
{
    if(thread_timer_call) {
        thread_call_free(thread_timer_call);
        thread_timer_call = NULL;

        if(thread_timer_callback_fn) {
            (thread_timer_callback_fn)((uint32_t)param0);
        }
    }
}

// DEPRECATED
__private_extern__
kern_return_t chudxnu_thread_timer_callback_enter(chudxnu_thread_timer_callback_func_t func, uint32_t param, uint32_t time, uint32_t units)
{
    if(!thread_timer_call) {
        uint64_t t_delay;
        thread_timer_callback_fn = func;
        thread_timer_call = thread_call_allocate((thread_call_func_t)chudxnu_private_thread_timer_callback, (thread_call_param_t)param);
        clock_interval_to_deadline(time, units, &t_delay);
        thread_call_enter_delayed(thread_timer_call, t_delay);
        return KERN_SUCCESS;
    } else {
        return KERN_FAILURE; // thread timer call already pending
    }
}

// DEPRECATED
__private_extern__
kern_return_t chudxnu_thread_timer_callback_cancel(void)
{
    if(thread_timer_call) {
    	thread_call_cancel(thread_timer_call);
        thread_call_free(thread_timer_call);
        thread_timer_call = NULL;
    }
    thread_timer_callback_fn = NULL;
    return KERN_SUCCESS;
}
Commit	Line	Data
55e303ae	1	/*
91447636	2	* Copyright (c) 2003-2004 Apple Computer, Inc. All rights reserved.
55e303ae	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
8ad349bb	5	*
8f6c56a5 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.
	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
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
55e303ae A	27	*/
	28
	29	#include <stdint.h>
	30	#include <mach/boolean.h>
	31	#include <mach/mach_types.h>
	32
91447636 A	33	#include <kern/kern_types.h>
91447636 A	34	#include <kern/processor.h>
8f6c56a5	35	#include <kern/timer_call.h>
91447636 A	36	#include <kern/thread_call.h>
	37	#include <kern/kalloc.h>
	38	#include <kern/thread.h>
	39
55e303ae	40	#include <ppc/machine_routines.h>
91447636 A	41	#include <ppc/cpu_data.h>
91447636 A	42	#include <ppc/cpu_internal.h>
55e303ae	43	#include <ppc/exception.h>
91447636 A	44	#include <ppc/thread.h>
91447636 A	45	#include <ppc/trap.h>
55e303ae	46
8f6c56a5 A	47	#include <ppc/chud/chud_xnu.h>
8f6c56a5 A	48	#include <ppc/chud/chud_xnu_private.h>
55e303ae A	49
	50	__private_extern__
	51	void chudxnu_cancel_all_callbacks(void)
	52	{
55e303ae A	53	chudxnu_cpu_timer_callback_cancel_all();
	54	chudxnu_trap_callback_cancel();
	55	chudxnu_interrupt_callback_cancel();
	56	chudxnu_perfmon_ast_callback_cancel();
	57	chudxnu_cpusig_callback_cancel();
	58	chudxnu_kdebug_callback_cancel();
55e303ae	59	chudxnu_thread_timer_callback_cancel();
91447636	60	chudxnu_syscall_callback_cancel();
55e303ae A	61	}
55e303ae A	62
8f6c56a5 A	63	#pragma mark ** cpu timer **
	64	typedef struct {
	65	timer_call_data_t cpu_timer_call;
	66	uint64_t t_deadline;
	67	chudxnu_cpu_timer_callback_func_t cpu_timer_callback_fn;
	68	} chudcpu_data_t;
	69
91447636 A	70	static chudcpu_data_t chudcpu_boot_cpu;
	71
	72	void *chudxnu_per_proc_alloc(boolean_t boot_processor)
	73	{
	74	chudcpu_data_t *chud_proc_info;
	75
	76	if (boot_processor) {
	77	chud_proc_info = &chudcpu_boot_cpu;
	78	} else {
	79	chud_proc_info = (chudcpu_data_t *)kalloc(sizeof(chudcpu_data_t));
	80	if (chud_proc_info == (chudcpu_data_t *)NULL) {
	81	return (void *)NULL;
	82	}
	83	}
	84	bzero((char *)chud_proc_info, sizeof(chudcpu_data_t));
	85	chud_proc_info->t_deadline = 0xFFFFFFFFFFFFFFFFULL;
	86	return (void *)chud_proc_info;
	87	}
	88
	89	void chudxnu_per_proc_free(void *per_proc_chud)
	90	{
	91	if (per_proc_chud == (void *)&chudcpu_boot_cpu) {
	92	return;
	93	} else {
	94	kfree(per_proc_chud,sizeof(chudcpu_data_t));
	95	}
	96	}
55e303ae A	97
	98	static void chudxnu_private_cpu_timer_callback(timer_call_param_t param0, timer_call_param_t param1)
	99	{
91447636	100	chudcpu_data_t *chud_proc_info;
55e303ae A	101	boolean_t oldlevel;
	102	struct ppc_thread_state64 state;
	103	mach_msg_type_number_t count;
	104
	105	oldlevel = ml_set_interrupts_enabled(FALSE);
91447636	106	chud_proc_info = (chudcpu_data_t *)(getPerProc()->pp_chud);
55e303ae A	107
55e303ae A	108	count = PPC_THREAD_STATE64_COUNT;
91447636	109	if(chudxnu_thread_get_state(current_thread(), PPC_THREAD_STATE64, (thread_state_t)&state, &count, FALSE)==KERN_SUCCESS) {
8f6c56a5 A	110	if(chud_proc_info->cpu_timer_callback_fn) {
8f6c56a5 A	111	(chud_proc_info->cpu_timer_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
55e303ae A	112	}
	113	}
	114
	115	ml_set_interrupts_enabled(oldlevel);
	116	}
	117
	118	__private_extern__
	119	kern_return_t chudxnu_cpu_timer_callback_enter(chudxnu_cpu_timer_callback_func_t func, uint32_t time, uint32_t units)
	120	{
91447636	121	chudcpu_data_t *chud_proc_info;
55e303ae A	122	boolean_t oldlevel;
	123
	124	oldlevel = ml_set_interrupts_enabled(FALSE);
91447636	125	chud_proc_info = (chudcpu_data_t *)(getPerProc()->pp_chud);
55e303ae	126
91447636	127	timer_call_cancel(&(chud_proc_info->cpu_timer_call)); // cancel any existing callback for this cpu
55e303ae	128
91447636	129	chud_proc_info->cpu_timer_callback_fn = func;
55e303ae	130
91447636 A	131	clock_interval_to_deadline(time, units, &(chud_proc_info->t_deadline));
	132	timer_call_setup(&(chud_proc_info->cpu_timer_call), chudxnu_private_cpu_timer_callback, NULL);
	133	timer_call_enter(&(chud_proc_info->cpu_timer_call), chud_proc_info->t_deadline);
55e303ae A	134
	135	ml_set_interrupts_enabled(oldlevel);
	136	return KERN_SUCCESS;
	137	}
	138
	139	__private_extern__
	140	kern_return_t chudxnu_cpu_timer_callback_cancel(void)
	141	{
91447636	142	chudcpu_data_t *chud_proc_info;
55e303ae A	143	boolean_t oldlevel;
	144
	145	oldlevel = ml_set_interrupts_enabled(FALSE);
91447636	146	chud_proc_info = (chudcpu_data_t *)(getPerProc()->pp_chud);
55e303ae	147
91447636 A	148	timer_call_cancel(&(chud_proc_info->cpu_timer_call));
	149	chud_proc_info->t_deadline = chud_proc_info->t_deadline \| ~(chud_proc_info->t_deadline); // set to max value
	150	chud_proc_info->cpu_timer_callback_fn = NULL;
55e303ae A	151
	152	ml_set_interrupts_enabled(oldlevel);
	153	return KERN_SUCCESS;
	154	}
	155
	156	__private_extern__
	157	kern_return_t chudxnu_cpu_timer_callback_cancel_all(void)
	158	{
91447636 A	159	unsigned int cpu;
	160	chudcpu_data_t *chud_proc_info;
	161
	162	for(cpu=0; cpu<real_ncpus; cpu++) {
	163	if ((PerProcTable[cpu].ppe_vaddr == 0)
	164	\|\| (PerProcTable[cpu].ppe_vaddr->pp_chud == 0))
	165	continue;
	166	chud_proc_info = (chudcpu_data_t *)PerProcTable[cpu].ppe_vaddr->pp_chud;
	167	timer_call_cancel(&(chud_proc_info->cpu_timer_call));
	168	chud_proc_info->t_deadline = chud_proc_info->t_deadline \| ~(chud_proc_info->t_deadline); // set to max value
	169	chud_proc_info->cpu_timer_callback_fn = NULL;
55e303ae A	170	}
	171	return KERN_SUCCESS;
	172	}
	173
91447636	174	#pragma mark ** trap **
55e303ae A	175	static chudxnu_trap_callback_func_t trap_callback_fn = NULL;
55e303ae A	176
55e303ae A	177	#define TRAP_ENTRY_POINT(t) ((t==T_RESET) ? 0x100 : \
	178	(t==T_MACHINE_CHECK) ? 0x200 : \
	179	(t==T_DATA_ACCESS) ? 0x300 : \
	180	(t==T_DATA_SEGMENT) ? 0x380 : \
	181	(t==T_INSTRUCTION_ACCESS) ? 0x400 : \
	182	(t==T_INSTRUCTION_SEGMENT) ? 0x480 : \
	183	(t==T_INTERRUPT) ? 0x500 : \
	184	(t==T_ALIGNMENT) ? 0x600 : \
	185	(t==T_PROGRAM) ? 0x700 : \
	186	(t==T_FP_UNAVAILABLE) ? 0x800 : \
	187	(t==T_DECREMENTER) ? 0x900 : \
	188	(t==T_IO_ERROR) ? 0xa00 : \
	189	(t==T_RESERVED) ? 0xb00 : \
	190	(t==T_SYSTEM_CALL) ? 0xc00 : \
	191	(t==T_TRACE) ? 0xd00 : \
	192	(t==T_FP_ASSIST) ? 0xe00 : \
	193	(t==T_PERF_MON) ? 0xf00 : \
	194	(t==T_VMX) ? 0xf20 : \
	195	(t==T_INVALID_EXCP0) ? 0x1000 : \
	196	(t==T_INVALID_EXCP1) ? 0x1100 : \
	197	(t==T_INVALID_EXCP2) ? 0x1200 : \
	198	(t==T_INSTRUCTION_BKPT) ? 0x1300 : \
	199	(t==T_SYSTEM_MANAGEMENT) ? 0x1400 : \
	200	(t==T_SOFT_PATCH) ? 0x1500 : \
	201	(t==T_ALTIVEC_ASSIST) ? 0x1600 : \
	202	(t==T_THERMAL) ? 0x1700 : \
	203	(t==T_ARCHDEP0) ? 0x1800 : \
	204	(t==T_INSTRUMENTATION) ? 0x2000 : \
	205	0x0)
	206
	207	static kern_return_t chudxnu_private_trap_callback(int trapno, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
	208	{
	209	boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
55e303ae A	210	kern_return_t retval = KERN_FAILURE;
	211	uint32_t trapentry = TRAP_ENTRY_POINT(trapno);
	212
55e303ae	213	if(trapentry!=0x0) {
8f6c56a5	214	if(trap_callback_fn) {
55e303ae A	215	struct ppc_thread_state64 state;
	216	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
	217	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
8f6c56a5	218	retval = (trap_callback_fn)(trapentry, PPC_THREAD_STATE64, (thread_state_t)&state, count);
55e303ae A	219	}
	220	}
	221
	222	ml_set_interrupts_enabled(oldlevel);
	223
	224	return retval;
	225	}
	226
	227	__private_extern__
	228	kern_return_t chudxnu_trap_callback_enter(chudxnu_trap_callback_func_t func)
	229	{
	230	trap_callback_fn = func;
	231	perfTrapHook = chudxnu_private_trap_callback;
	232	__asm__ volatile("eieio"); /* force order */
	233	__asm__ volatile("sync"); /* force to memory */
	234	return KERN_SUCCESS;
	235	}
	236
	237	__private_extern__
	238	kern_return_t chudxnu_trap_callback_cancel(void)
	239	{
	240	trap_callback_fn = NULL;
55e303ae	241	perfTrapHook = NULL;
55e303ae A	242	__asm__ volatile("eieio"); /* force order */
	243	__asm__ volatile("sync"); /* force to memory */
	244	return KERN_SUCCESS;
	245	}
	246
91447636 A	247	#pragma mark ** ast **
	248	static chudxnu_perfmon_ast_callback_func_t perfmon_ast_callback_fn = NULL;
	249
	250	static kern_return_t chudxnu_private_chud_ast_callback(int trapno, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
	251	{
	252	boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
	253	ast_t *myast = ast_pending();
	254	kern_return_t retval = KERN_FAILURE;
	255
8f6c56a5 A	256	if(*myast & AST_PPC_CHUD_URGENT) {
8f6c56a5 A	257	*myast &= ~(AST_PPC_CHUD_URGENT \| AST_PPC_CHUD);
91447636 A	258	if((myast & AST_PREEMPTION) != AST_PREEMPTION) myast &= ~(AST_URGENT);
91447636 A	259	retval = KERN_SUCCESS;
8f6c56a5 A	260	} else if(*myast & AST_PPC_CHUD) {
8f6c56a5 A	261	*myast &= ~(AST_PPC_CHUD);
91447636 A	262	retval = KERN_SUCCESS;
	263	}
	264
8f6c56a5	265	if(perfmon_ast_callback_fn) {
91447636 A	266	struct ppc_thread_state64 state;
	267	mach_msg_type_number_t count;
	268	count = PPC_THREAD_STATE64_COUNT;
	269
	270	if(chudxnu_thread_get_state(current_thread(), PPC_THREAD_STATE64, (thread_state_t)&state, &count, FALSE)==KERN_SUCCESS) {
8f6c56a5	271	(perfmon_ast_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
91447636 A	272	}
	273	}
	274
	275	#if 0
	276	// ASTs from ihandler go through thandler and are made to look like traps
8f6c56a5 A	277	// always handle AST_PPC_CHUD_URGENT if there's a callback
	278	// only handle AST_PPC_CHUD if it's the only AST pending
	279	if(perfmon_ast_callback_fn && ((myast & AST_PPC_CHUD_URGENT) \|\| ((myast & AST_PPC_CHUD) && !(*myast & AST_URGENT)))) {
91447636 A	280	struct ppc_thread_state64 state;
	281	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
	282	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
8f6c56a5 A	283	if(*myast & AST_PPC_CHUD_URGENT) {
8f6c56a5 A	284	*myast &= ~(AST_PPC_CHUD_URGENT \| AST_PPC_CHUD);
91447636 A	285	if((myast & AST_PREEMPTION) != AST_PREEMPTION) myast &= ~(AST_URGENT);
91447636 A	286	retval = KERN_SUCCESS;
8f6c56a5 A	287	} else if(*myast & AST_PPC_CHUD) {
8f6c56a5 A	288	*myast &= ~(AST_PPC_CHUD);
91447636 A	289	retval = KERN_SUCCESS;
	290	}
	291	(perfmon_ast_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
	292	}
	293	#endif
	294
	295	ml_set_interrupts_enabled(oldlevel);
	296	return retval;
	297	}
	298
55e303ae A	299	__private_extern__
	300	kern_return_t chudxnu_perfmon_ast_callback_enter(chudxnu_perfmon_ast_callback_func_t func)
	301	{
	302	perfmon_ast_callback_fn = func;
91447636	303	perfASTHook = chudxnu_private_chud_ast_callback;
55e303ae A	304	__asm__ volatile("eieio"); /* force order */
	305	__asm__ volatile("sync"); /* force to memory */
	306	return KERN_SUCCESS;
	307	}
	308
	309	__private_extern__
	310	kern_return_t chudxnu_perfmon_ast_callback_cancel(void)
	311	{
	312	perfmon_ast_callback_fn = NULL;
91447636	313	perfASTHook = NULL;
55e303ae A	314	__asm__ volatile("eieio"); /* force order */
	315	__asm__ volatile("sync"); /* force to memory */
	316	return KERN_SUCCESS;
	317	}
	318
	319	__private_extern__
91447636	320	kern_return_t chudxnu_perfmon_ast_send_urgent(boolean_t urgent)
55e303ae	321	{
91447636 A	322	boolean_t oldlevel = ml_set_interrupts_enabled(FALSE);
91447636 A	323	ast_t *myast = ast_pending();
55e303ae	324
91447636	325	if(urgent) {
8f6c56a5	326	*myast \|= (AST_PPC_CHUD_URGENT \| AST_URGENT);
91447636	327	} else {
8f6c56a5	328	*myast \|= (AST_PPC_CHUD);
91447636	329	}
55e303ae A	330
	331	ml_set_interrupts_enabled(oldlevel);
	332	return KERN_SUCCESS;
	333	}
	334
91447636 A	335	__private_extern__
	336	kern_return_t chudxnu_perfmon_ast_send(void)
	337	{
	338	return chudxnu_perfmon_ast_send_urgent(TRUE);
	339	}
	340
55e303ae	341	#pragma mark ** interrupt **
55e303ae	342	static chudxnu_interrupt_callback_func_t interrupt_callback_fn = NULL;
91447636	343	//extern perfCallback perfIntHook; /* function hook into interrupt() */
55e303ae A	344
	345	static kern_return_t chudxnu_private_interrupt_callback(int trapno, struct savearea *ssp, unsigned int dsisr, unsigned int dar)
	346	{
8f6c56a5	347	if(interrupt_callback_fn) {
55e303ae A	348	struct ppc_thread_state64 state;
	349	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
	350	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
8f6c56a5	351	return (interrupt_callback_fn)(TRAP_ENTRY_POINT(trapno), PPC_THREAD_STATE64, (thread_state_t)&state, count);
55e303ae A	352	} else {
	353	return KERN_FAILURE;
	354	}
	355	}
	356
	357	__private_extern__
	358	kern_return_t chudxnu_interrupt_callback_enter(chudxnu_interrupt_callback_func_t func)
	359	{
	360	interrupt_callback_fn = func;
	361	perfIntHook = chudxnu_private_interrupt_callback;
	362	__asm__ volatile("eieio"); /* force order */
	363	__asm__ volatile("sync"); /* force to memory */
	364	return KERN_SUCCESS;
	365	}
	366
	367	__private_extern__
	368	kern_return_t chudxnu_interrupt_callback_cancel(void)
	369	{
	370	interrupt_callback_fn = NULL;
	371	perfIntHook = NULL;
	372	__asm__ volatile("eieio"); /* force order */
	373	__asm__ volatile("sync"); /* force to memory */
	374	return KERN_SUCCESS;
	375	}
	376
	377	#pragma mark ** cpu signal **
55e303ae	378	static chudxnu_cpusig_callback_func_t cpusig_callback_fn = NULL;
91447636	379	extern perfCallback perfCpuSigHook; /* function hook into cpu_signal_handler() */
55e303ae A	380
	381	static kern_return_t chudxnu_private_cpu_signal_handler(int request, struct savearea *ssp, unsigned int arg0, unsigned int arg1)
	382	{
8f6c56a5	383	if(cpusig_callback_fn) {
55e303ae A	384	struct ppc_thread_state64 state;
	385	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
	386	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
8f6c56a5	387	(cpusig_callback_fn)(request, PPC_THREAD_STATE64, (thread_state_t)&state, count);
55e303ae A	388	}
	389	return KERN_SUCCESS; // ignored
	390	}
	391
	392	__private_extern__
	393	kern_return_t chudxnu_cpusig_callback_enter(chudxnu_cpusig_callback_func_t func)
	394	{
	395	cpusig_callback_fn = func;
	396	perfCpuSigHook = chudxnu_private_cpu_signal_handler;
	397	__asm__ volatile("eieio"); /* force order */
	398	__asm__ volatile("sync"); /* force to memory */
	399	return KERN_SUCCESS;
	400	}
	401
	402	__private_extern__
	403	kern_return_t chudxnu_cpusig_callback_cancel(void)
	404	{
	405	cpusig_callback_fn = NULL;
	406	perfCpuSigHook = NULL;
	407	__asm__ volatile("eieio"); /* force order */
	408	__asm__ volatile("sync"); /* force to memory */
	409	return KERN_SUCCESS;
	410	}
	411
	412	__private_extern__
	413	kern_return_t chudxnu_cpusig_send(int otherCPU, uint32_t request)
	414	{
	415	int thisCPU;
	416	kern_return_t retval = KERN_FAILURE;
	417	int retries = 0;
	418	boolean_t oldlevel;
	419	uint32_t temp[2];
	420
	421	oldlevel = ml_set_interrupts_enabled(FALSE);
	422	thisCPU = cpu_number();
	423
	424	if(thisCPU!=otherCPU) {
	425	temp[0] = 0xFFFFFFFF; /* set sync flag */
	426	temp[1] = request; /* set request */
	427	__asm__ volatile("eieio"); /* force order */
	428	__asm__ volatile("sync"); /* force to memory */
	429
	430	do {
	431	retval=cpu_signal(otherCPU, SIGPcpureq, CPRQchud, (uint32_t)&temp);
	432	} while(retval!=KERN_SUCCESS && (retries++)<16);
	433
	434	if(retries>=16) {
	435	retval = KERN_FAILURE;
	436	} else {
	437	retval = hw_cpu_sync(temp, LockTimeOut); /* wait for the other processor */
	438	if(!retval) {
	439	retval = KERN_FAILURE;
	440	} else {
	441	retval = KERN_SUCCESS;
	442	}
	443	}
	444	} else {
	445	retval = KERN_INVALID_ARGUMENT;
	446	}
	447
	448	ml_set_interrupts_enabled(oldlevel);
	449	return retval;
	450	}
8f6c56a5 A	451
	452	#pragma mark ** timer **
	453	__private_extern__
	454	chud_timer_t chudxnu_timer_alloc(chudxnu_timer_callback_func_t func, uint32_t param0)
	455	{
	456	return (chud_timer_t)thread_call_allocate((thread_call_func_t)func, (thread_call_param_t)param0);
	457	}
	458
	459	__private_extern__
	460	kern_return_t chudxnu_timer_callback_enter(chud_timer_t timer, uint32_t param1, uint32_t time, uint32_t units)
	461	{
	462	uint64_t t_delay;
	463	clock_interval_to_deadline(time, units, &t_delay);
	464	thread_call_enter1_delayed((thread_call_t)timer, (thread_call_param_t)param1, t_delay);
	465	return KERN_SUCCESS;
	466	}
	467
	468	__private_extern__
	469	kern_return_t chudxnu_timer_callback_cancel(chud_timer_t timer)
	470	{
	471	thread_call_cancel((thread_call_t)timer);
	472	return KERN_SUCCESS;
	473	}
	474
	475	__private_extern__
	476	kern_return_t chudxnu_timer_free(chud_timer_t timer)
	477	{
	478	thread_call_cancel((thread_call_t)timer);
	479	thread_call_free((thread_call_t)timer);
	480	return KERN_SUCCESS;
	481	}
	482
	483	#pragma mark ** CHUD syscall (PPC) **
	484
	485	typedef int (PPCcallEnt)(struct savearea save);
	486	extern PPCcallEnt PPCcalls[];
	487
	488	static chudxnu_syscall_callback_func_t syscall_callback_fn = NULL;
	489
	490	static int chudxnu_private_syscall_callback(struct savearea *ssp)
	491	{
	492	if(ssp) {
	493	if(syscall_callback_fn) {
	494	struct ppc_thread_state64 state;
	495	kern_return_t retval;
	496	mach_msg_type_number_t count = PPC_THREAD_STATE64_COUNT;
	497	chudxnu_copy_savearea_to_threadstate(PPC_THREAD_STATE64, (thread_state_t)&state, &count, ssp);
	498	ssp->save_r3 = (syscall_callback_fn)(PPC_THREAD_STATE64, (thread_state_t)&state, count);
	499	} else {
	500	ssp->save_r3 = KERN_FAILURE;
	501	}
	502	}
	503
	504	return 1; // check for ASTs (always)
	505	}
	506
	507	__private_extern__
	508	kern_return_t chudxnu_syscall_callback_enter(chudxnu_syscall_callback_func_t func)
	509	{
	510	syscall_callback_fn = func;
	511	PPCcalls[9] = chudxnu_private_syscall_callback;
	512	__asm__ volatile("eieio"); /* force order */
	513	__asm__ volatile("sync"); /* force to memory */
	514	return KERN_SUCCESS;
515	}
516
517	__private_extern__
518	kern_return_t chudxnu_syscall_callback_cancel(void)
519	{
520	syscall_callback_fn = NULL;
521	PPCcalls[9] = NULL;
522	__asm__ volatile("eieio"); /* force order */
523	__asm__ volatile("sync"); /* force to memory */
524	return KERN_SUCCESS;
525	}
526
527	#pragma mark ** thread timer - DEPRECATED **
528
529	static thread_call_t thread_timer_call = NULL;
530	static chudxnu_thread_timer_callback_func_t thread_timer_callback_fn = NULL;
531
532	static void chudxnu_private_thread_timer_callback(thread_call_param_t param0, thread_call_param_t param1)
533	{
534	if(thread_timer_call) {
535	thread_call_free(thread_timer_call);
536	thread_timer_call = NULL;
537
538	if(thread_timer_callback_fn) {
539	(thread_timer_callback_fn)((uint32_t)param0);
540	}
541	}
542	}
543
544	// DEPRECATED
545	__private_extern__
546	kern_return_t chudxnu_thread_timer_callback_enter(chudxnu_thread_timer_callback_func_t func, uint32_t param, uint32_t time, uint32_t units)
547	{
548	if(!thread_timer_call) {
549	uint64_t t_delay;
550	thread_timer_callback_fn = func;
551	thread_timer_call = thread_call_allocate((thread_call_func_t)chudxnu_private_thread_timer_callback, (thread_call_param_t)param);
552	clock_interval_to_deadline(time, units, &t_delay);
553	thread_call_enter_delayed(thread_timer_call, t_delay);
554	return KERN_SUCCESS;
555	} else {
556	return KERN_FAILURE; // thread timer call already pending
557	}
558	}
559
560	// DEPRECATED
561	__private_extern__
562	kern_return_t chudxnu_thread_timer_callback_cancel(void)
563	{
564	if(thread_timer_call) {
565	thread_call_cancel(thread_timer_call);
566	thread_call_free(thread_timer_call);
567	thread_timer_call = NULL;
568	}
569	thread_timer_callback_fn = NULL;
570	return KERN_SUCCESS;
571	}