[apple/xnu.git] / bsd / uxkern / ux_exception.c

/*
 * Copyright (c) 2000-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@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1987 Carnegie-Mellon University
 * All rights reserved.  The CMU software License Agreement specifies
 * the terms and conditions for use and redistribution.
 */

/*
 *********************************************************************
 * HISTORY
 **********************************************************************
 */

#include <sys/param.h>

#include <mach/boolean.h>
#include <mach/exception.h>
#include <mach/kern_return.h>
#include <mach/message.h>
#include <mach/port.h>
#include <mach/mach_port.h>
#include <mach/mig_errors.h>
#include <mach/exc_server.h>
#include <mach/mach_exc_server.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/sched_prim.h>
#include <kern/kalloc.h>

#include <sys/proc.h>
#include <sys/user.h>
#include <sys/systm.h>
#include <sys/ux_exception.h>
#include <sys/vmparam.h>	/* MAXSSIZ */

#include <vm/vm_protos.h>	/* get_task_ipcspace() */
/*
 * XXX Things that should be retrieved from Mach headers, but aren't
 */
struct ipc_object;
extern kern_return_t ipc_object_copyin(ipc_space_t space, mach_port_name_t name,
		mach_msg_type_name_t msgt_name, struct ipc_object **objectp);
extern mach_msg_return_t mach_msg_receive(mach_msg_header_t *msg,
		mach_msg_option_t option, mach_msg_size_t rcv_size,
		mach_port_name_t rcv_name, mach_msg_timeout_t rcv_timeout,
		void (*continuation)(mach_msg_return_t),
		mach_msg_size_t slist_size);
extern mach_msg_return_t mach_msg_send(mach_msg_header_t *msg,
		mach_msg_option_t option, mach_msg_size_t send_size,
		mach_msg_timeout_t send_timeout, mach_port_name_t notify);
extern thread_t convert_port_to_thread(ipc_port_t port);
extern void ipc_port_release(ipc_port_t);


/*
 *	Unix exception handler.
 */

static void	ux_exception(int exception, mach_exception_code_t code, 
				mach_exception_subcode_t subcode,
				int *ux_signal, mach_exception_code_t *ux_code);

mach_port_name_t		ux_exception_port;
static task_t			ux_handler_self;

static
void
ux_handler(void)
{
    task_t		self = current_task();
    mach_port_name_t	exc_port_name;
    mach_port_name_t	exc_set_name;

    /* self->kernel_vm_space = TRUE; */
    ux_handler_self = self;


    /*
     *	Allocate a port set that we will receive on.
     */
    if (mach_port_allocate(get_task_ipcspace(ux_handler_self), MACH_PORT_RIGHT_PORT_SET,  &exc_set_name) != MACH_MSG_SUCCESS)
	    panic("ux_handler: port_set_allocate failed");

    /*
     *	Allocate an exception port and use object_copyin to
     *	translate it to the global name.  Put it into the set.
     */
    if (mach_port_allocate(get_task_ipcspace(ux_handler_self), MACH_PORT_RIGHT_RECEIVE, &exc_port_name) != MACH_MSG_SUCCESS)
	panic("ux_handler: port_allocate failed");
    if (mach_port_move_member(get_task_ipcspace(ux_handler_self),
    			exc_port_name,  exc_set_name) != MACH_MSG_SUCCESS)
	panic("ux_handler: port_set_add failed");

    if (ipc_object_copyin(get_task_ipcspace(self), exc_port_name,
			MACH_MSG_TYPE_MAKE_SEND, 
			(void *) &ux_exception_port) != MACH_MSG_SUCCESS)
		panic("ux_handler: object_copyin(ux_exception_port) failed");

    proc_list_lock();
    thread_wakeup(&ux_exception_port);
    proc_list_unlock();

    /* Message handling loop. */

    for (;;) {
	struct rep_msg {
		mach_msg_header_t Head;
		NDR_record_t NDR;
		kern_return_t RetCode;
	} rep_msg;
	struct exc_msg {
		mach_msg_header_t Head;
		/* start of the kernel processed data */
		mach_msg_body_t msgh_body;
		mach_msg_port_descriptor_t thread;
		mach_msg_port_descriptor_t task;
		/* end of the kernel processed data */
		NDR_record_t NDR;
		exception_type_t exception;
		mach_msg_type_number_t codeCnt;
		mach_exception_data_t code;
		/* some times RCV_TO_LARGE probs */
		char pad[512];
	} exc_msg;
	mach_port_name_t	reply_port;
	kern_return_t	 result;

	exc_msg.Head.msgh_local_port = (mach_port_t)exc_set_name;
	exc_msg.Head.msgh_size = sizeof (exc_msg);
#if 0
	result = mach_msg_receive(&exc_msg.Head);
#else
	result = mach_msg_receive(&exc_msg.Head, MACH_RCV_MSG,
			     sizeof (exc_msg), exc_set_name,
			     MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL,
			     0);
#endif
	if (result == MACH_MSG_SUCCESS) {
	    reply_port = (mach_port_name_t)exc_msg.Head.msgh_remote_port;

	    if (mach_exc_server(&exc_msg.Head, &rep_msg.Head))
		(void) mach_msg_send(&rep_msg.Head, MACH_SEND_MSG,
			sizeof (rep_msg),MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);

	    if (reply_port != MACH_PORT_NULL)
		(void) mach_port_deallocate(get_task_ipcspace(ux_handler_self), reply_port);
	}
	else if (result == MACH_RCV_TOO_LARGE)
		/* ignore oversized messages */;
	else
		panic("exception_handler");
    }
}

void
ux_handler_init(void)
{
	ux_exception_port = MACH_PORT_NULL;
	(void) kernel_thread(kernel_task, ux_handler);
	proc_list_lock();
	if (ux_exception_port == MACH_PORT_NULL)  {
		(void)msleep(&ux_exception_port, proc_list_mlock, 0, "ux_handler_wait", 0);
	}
	proc_list_unlock();
}

kern_return_t
catch_exception_raise(
        __unused mach_port_t exception_port,
        mach_port_t thread,
        mach_port_t task,
        exception_type_t exception,
        exception_data_t code,
        __unused mach_msg_type_number_t codeCnt
)
{
	mach_exception_data_type_t big_code[EXCEPTION_CODE_MAX];
	big_code[0] = code[0];
	big_code[1] = code[1];

	return catch_mach_exception_raise(exception_port,
			thread,
			task,
			exception,
			big_code,
			codeCnt);

}

kern_return_t
catch_mach_exception_raise(
        __unused mach_port_t exception_port,
        mach_port_t thread,
        mach_port_t task,
        exception_type_t exception,
        mach_exception_data_t code,
        __unused mach_msg_type_number_t codeCnt
)
{
	task_t			self = current_task();
	thread_t		th_act;
	ipc_port_t 		thread_port;
	struct task		*sig_task;
	struct proc		*p;
	kern_return_t		result = MACH_MSG_SUCCESS;
	int			ux_signal = 0;
	mach_exception_code_t 	ucode = 0;
	struct uthread 		*ut;
	mach_port_name_t thread_name = (mach_port_name_t)thread; /* XXX */
	mach_port_name_t task_name = (mach_port_name_t)task;	/* XXX */

	/*
	 *	Convert local thread name to global port.
	 */
   if (MACH_PORT_VALID(thread_name) &&
       (ipc_object_copyin(get_task_ipcspace(self), thread_name,
		       MACH_MSG_TYPE_PORT_SEND,
		       (void *) &thread_port) == MACH_MSG_SUCCESS)) {
        if (IPC_PORT_VALID(thread_port)) {
	   th_act = convert_port_to_thread(thread_port);
	   ipc_port_release(thread_port);
	} else {
	   th_act = THREAD_NULL;
	}

	/*
	 *	Catch bogus ports
	 */
	if (th_act != THREAD_NULL) {

	    /*
	     *	Convert exception to unix signal and code.
	     */
	    ux_exception(exception, code[0], code[1], &ux_signal, &ucode);

	    ut = get_bsdthread_info(th_act);
	    sig_task = get_threadtask(th_act);
	    p = (struct proc *) get_bsdtask_info(sig_task);

	    /* Can't deliver a signal without a bsd process */
	    if (p == NULL) {
		    ux_signal = 0;
		    result = KERN_FAILURE;
	    }

	    /*
	     * Stack overflow should result in a SIGSEGV signal
	     * on the alternate stack.
	     * but we have one or more guard pages after the
	     * stack top, so we would get a KERN_PROTECTION_FAILURE
	     * exception instead of KERN_INVALID_ADDRESS, resulting in
	     * a SIGBUS signal.
	     * Detect that situation and select the correct signal.
	     */
	    if (code[0] == KERN_PROTECTION_FAILURE &&
		ux_signal == SIGBUS) {
		    user_addr_t		sp, stack_min, stack_max;
		    int			mask;
		    struct sigacts	*ps;

		    sp = code[1];
		    if (ut && (ut->uu_flag & UT_VFORK))
			    p = ut->uu_proc;
#if STACK_GROWTH_UP
		    stack_min = p->user_stack;
		    stack_max = p->user_stack + MAXSSIZ;
#else /* STACK_GROWTH_UP */
		    stack_max = p->user_stack;
		    stack_min = p->user_stack - MAXSSIZ;
#endif /* STACK_GROWTH_UP */
		    if (sp >= stack_min &&
			sp < stack_max) {
			    /*
			     * This is indeed a stack overflow.  Deliver a
			     * SIGSEGV signal.
			     */
			    ux_signal = SIGSEGV;

			    /*
			     * If the thread/process is not ready to handle
			     * SIGSEGV on an alternate stack, force-deliver
			     * SIGSEGV with a SIG_DFL handler.
			     */
			    mask = sigmask(ux_signal);
			    ps = p->p_sigacts;
			    if ((p->p_sigignore & mask) ||
				(ut->uu_sigwait & mask) ||
				(ut->uu_sigmask & mask) ||
				(ps->ps_sigact[SIGSEGV] == SIG_IGN) ||
				(! (ps->ps_sigonstack & mask))) {
				    p->p_sigignore &= ~mask;
				    p->p_sigcatch &= ~mask;
				    ps->ps_sigact[SIGSEGV] = SIG_DFL;
				    ut->uu_sigwait &= ~mask;
				    ut->uu_sigmask &= ~mask;
			    }
		    }
	    }
	    /*
	     *	Send signal.
	     */
	    if (ux_signal != 0) {
			ut->uu_exception = exception;
			//ut->uu_code = code[0]; // filled in by threadsignal
			ut->uu_subcode = code[1];			
			threadsignal(th_act, ux_signal, code[0]);
	    }

	    thread_deallocate(th_act);
	}
	else
	    result = KERN_INVALID_ARGUMENT;
    }
    else
    	result = KERN_INVALID_ARGUMENT;

    /*
     *	Delete our send rights to the task and thread ports.
     */
    (void)mach_port_deallocate(get_task_ipcspace(ux_handler_self), task_name);
    (void)mach_port_deallocate(get_task_ipcspace(ux_handler_self), thread_name);

    return (result);
}

kern_return_t
catch_exception_raise_state(
        __unused mach_port_t exception_port,
        __unused exception_type_t exception,
        __unused const exception_data_t code,
        __unused mach_msg_type_number_t codeCnt,
        __unused int *flavor,
        __unused const thread_state_t old_state,
        __unused mach_msg_type_number_t old_stateCnt,
        __unused thread_state_t new_state,
        __unused mach_msg_type_number_t *new_stateCnt)
{
	return(KERN_INVALID_ARGUMENT);
}

kern_return_t
catch_mach_exception_raise_state(
        __unused mach_port_t exception_port,
        __unused exception_type_t exception,
        __unused const mach_exception_data_t code,
        __unused mach_msg_type_number_t codeCnt,
        __unused int *flavor,
        __unused const thread_state_t old_state,
        __unused mach_msg_type_number_t old_stateCnt,
        __unused thread_state_t new_state,
        __unused mach_msg_type_number_t *new_stateCnt)
{
	return(KERN_INVALID_ARGUMENT);
}

kern_return_t
catch_exception_raise_state_identity(
        __unused mach_port_t exception_port,
        __unused mach_port_t thread,
        __unused mach_port_t task,
        __unused exception_type_t exception,
        __unused exception_data_t code,
        __unused mach_msg_type_number_t codeCnt,
        __unused int *flavor,
        __unused thread_state_t old_state,
        __unused mach_msg_type_number_t old_stateCnt,
        __unused thread_state_t new_state,
        __unused mach_msg_type_number_t *new_stateCnt)
{
	return(KERN_INVALID_ARGUMENT);
}

kern_return_t
catch_mach_exception_raise_state_identity(
        __unused mach_port_t exception_port,
        __unused mach_port_t thread,
        __unused mach_port_t task,
        __unused exception_type_t exception,
        __unused mach_exception_data_t code,
        __unused mach_msg_type_number_t codeCnt,
        __unused int *flavor,
        __unused thread_state_t old_state,
        __unused mach_msg_type_number_t old_stateCnt,
        __unused thread_state_t new_state,
        __unused mach_msg_type_number_t *new_stateCnt)
{
	return(KERN_INVALID_ARGUMENT);
}


/*
 *	ux_exception translates a mach exception, code and subcode to
 *	a signal and u.u_code.  Calls machine_exception (machine dependent)
 *	to attempt translation first.
 */

static
void ux_exception(
		int			exception,
		mach_exception_code_t 	code,
		mach_exception_subcode_t subcode,
		int			*ux_signal,
		mach_exception_code_t 	*ux_code)
{
    /*
     *	Try machine-dependent translation first.
     */
    if (machine_exception(exception, code, subcode, ux_signal, ux_code))
	return;
	
    switch(exception) {

	case EXC_BAD_ACCESS:
		if (code == KERN_INVALID_ADDRESS)
			*ux_signal = SIGSEGV;
		else
			*ux_signal = SIGBUS;
		break;

	case EXC_BAD_INSTRUCTION:
	    *ux_signal = SIGILL;
	    break;

	case EXC_ARITHMETIC:
	    *ux_signal = SIGFPE;
	    break;

	case EXC_EMULATION:
	    *ux_signal = SIGEMT;
	    break;

	case EXC_SOFTWARE:
	    switch (code) {

	    case EXC_UNIX_BAD_SYSCALL:
		*ux_signal = SIGSYS;
		break;
	    case EXC_UNIX_BAD_PIPE:
		*ux_signal = SIGPIPE;
		break;
	    case EXC_UNIX_ABORT:
		*ux_signal = SIGABRT;
		break;
	    case EXC_SOFT_SIGNAL:
		*ux_signal = SIGKILL;
		break;
	    }
	    break;

	case EXC_BREAKPOINT:
	    *ux_signal = SIGTRAP;
	    break;
    }
}
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	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.
8f6c56a5	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
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 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.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* Mach Operating System
	30	* Copyright (c) 1987 Carnegie-Mellon University
	31	* All rights reserved. The CMU software License Agreement specifies
	32	* the terms and conditions for use and redistribution.
	33	*/
	34
	35	/*
	36	*********************************************************************
	37	* HISTORY
	38	**********************************************************************
	39	*/
	40
	41	#include <sys/param.h>
	42
	43	#include <mach/boolean.h>
	44	#include <mach/exception.h>
	45	#include <mach/kern_return.h>
	46	#include <mach/message.h>
	47	#include <mach/port.h>
91447636	48	#include <mach/mach_port.h>
1c79356b	49	#include <mach/mig_errors.h>
91447636	50	#include <mach/exc_server.h>
2d21ac55	51	#include <mach/mach_exc_server.h>
1c79356b A	52	#include <kern/task.h>
1c79356b A	53	#include <kern/thread.h>
9bccf70c	54	#include <kern/sched_prim.h>
1c79356b A	55	#include <kern/kalloc.h>
	56
	57	#include <sys/proc.h>
	58	#include <sys/user.h>
	59	#include <sys/systm.h>
	60	#include <sys/ux_exception.h>
2d21ac55	61	#include <sys/vmparam.h> /* MAXSSIZ */
1c79356b	62
91447636	63	#include <vm/vm_protos.h> /* get_task_ipcspace() */
91447636 A	64	/*
	65	* XXX Things that should be retrieved from Mach headers, but aren't
	66	*/
	67	struct ipc_object;
	68	extern kern_return_t ipc_object_copyin(ipc_space_t space, mach_port_name_t name,
	69	mach_msg_type_name_t msgt_name, struct ipc_object **objectp);
	70	extern mach_msg_return_t mach_msg_receive(mach_msg_header_t *msg,
	71	mach_msg_option_t option, mach_msg_size_t rcv_size,
	72	mach_port_name_t rcv_name, mach_msg_timeout_t rcv_timeout,
	73	void (*continuation)(mach_msg_return_t),
	74	mach_msg_size_t slist_size);
	75	extern mach_msg_return_t mach_msg_send(mach_msg_header_t *msg,
	76	mach_msg_option_t option, mach_msg_size_t send_size,
	77	mach_msg_timeout_t send_timeout, mach_port_name_t notify);
	78	extern thread_t convert_port_to_thread(ipc_port_t port);
	79	extern void ipc_port_release(ipc_port_t);
	80
	81
	82
	83
2d21ac55	84
1c79356b A	85	/*
	86	* Unix exception handler.
	87	*/
	88
2d21ac55 A	89	static void ux_exception(int exception, mach_exception_code_t code,
	90	mach_exception_subcode_t subcode,
	91	int ux_signal, mach_exception_code_t ux_code);
1c79356b	92
1c79356b A	93	mach_port_name_t ux_exception_port;
	94	static task_t ux_handler_self;
	95
	96	static
	97	void
	98	ux_handler(void)
	99	{
	100	task_t self = current_task();
	101	mach_port_name_t exc_port_name;
	102	mach_port_name_t exc_set_name;
	103
1c79356b A	104	/* self->kernel_vm_space = TRUE; */
	105	ux_handler_self = self;
	106
	107
	108	/*
	109	* Allocate a port set that we will receive on.
	110	*/
	111	if (mach_port_allocate(get_task_ipcspace(ux_handler_self), MACH_PORT_RIGHT_PORT_SET, &exc_set_name) != MACH_MSG_SUCCESS)
	112	panic("ux_handler: port_set_allocate failed");
	113
	114	/*
	115	* Allocate an exception port and use object_copyin to
	116	* translate it to the global name. Put it into the set.
	117	*/
	118	if (mach_port_allocate(get_task_ipcspace(ux_handler_self), MACH_PORT_RIGHT_RECEIVE, &exc_port_name) != MACH_MSG_SUCCESS)
	119	panic("ux_handler: port_allocate failed");
	120	if (mach_port_move_member(get_task_ipcspace(ux_handler_self),
	121	exc_port_name, exc_set_name) != MACH_MSG_SUCCESS)
	122	panic("ux_handler: port_set_add failed");
	123
	124	if (ipc_object_copyin(get_task_ipcspace(self), exc_port_name,
	125	MACH_MSG_TYPE_MAKE_SEND,
	126	(void *) &ux_exception_port) != MACH_MSG_SUCCESS)
	127	panic("ux_handler: object_copyin(ux_exception_port) failed");
	128
cf7d32b8	129	proc_list_lock();
1c79356b	130	thread_wakeup(&ux_exception_port);
cf7d32b8	131	proc_list_unlock();
1c79356b A	132
	133	/* Message handling loop. */
	134
	135	for (;;) {
	136	struct rep_msg {
	137	mach_msg_header_t Head;
	138	NDR_record_t NDR;
	139	kern_return_t RetCode;
	140	} rep_msg;
	141	struct exc_msg {
	142	mach_msg_header_t Head;
	143	/* start of the kernel processed data */
	144	mach_msg_body_t msgh_body;
	145	mach_msg_port_descriptor_t thread;
	146	mach_msg_port_descriptor_t task;
	147	/* end of the kernel processed data */
	148	NDR_record_t NDR;
	149	exception_type_t exception;
	150	mach_msg_type_number_t codeCnt;
2d21ac55	151	mach_exception_data_t code;
1c79356b A	152	/* some times RCV_TO_LARGE probs */
	153	char pad[512];
	154	} exc_msg;
	155	mach_port_name_t reply_port;
	156	kern_return_t result;
	157
	158	exc_msg.Head.msgh_local_port = (mach_port_t)exc_set_name;
	159	exc_msg.Head.msgh_size = sizeof (exc_msg);
	160	#if 0
	161	result = mach_msg_receive(&exc_msg.Head);
	162	#else
	163	result = mach_msg_receive(&exc_msg.Head, MACH_RCV_MSG,
	164	sizeof (exc_msg), exc_set_name,
	165	MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL,
	166	0);
	167	#endif
	168	if (result == MACH_MSG_SUCCESS) {
	169	reply_port = (mach_port_name_t)exc_msg.Head.msgh_remote_port;
	170
2d21ac55	171	if (mach_exc_server(&exc_msg.Head, &rep_msg.Head))
1c79356b A	172	(void) mach_msg_send(&rep_msg.Head, MACH_SEND_MSG,
	173	sizeof (rep_msg),MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);
	174
	175	if (reply_port != MACH_PORT_NULL)
	176	(void) mach_port_deallocate(get_task_ipcspace(ux_handler_self), reply_port);
	177	}
	178	else if (result == MACH_RCV_TOO_LARGE)
	179	/* ignore oversized messages */;
	180	else
	181	panic("exception_handler");
	182	}
1c79356b A	183	}
	184
	185	void
	186	ux_handler_init(void)
	187	{
1c79356b	188	ux_exception_port = MACH_PORT_NULL;
55e303ae	189	(void) kernel_thread(kernel_task, ux_handler);
cf7d32b8	190	proc_list_lock();
1c79356b	191	if (ux_exception_port == MACH_PORT_NULL) {
cf7d32b8	192	(void)msleep(&ux_exception_port, proc_list_mlock, 0, "ux_handler_wait", 0);
2d21ac55	193	}
cf7d32b8	194	proc_list_unlock();
1c79356b A	195	}
	196
	197	kern_return_t
	198	catch_exception_raise(
91447636 A	199	__unused mach_port_t exception_port,
	200	mach_port_t thread,
	201	mach_port_t task,
	202	exception_type_t exception,
	203	exception_data_t code,
	204	__unused mach_msg_type_number_t codeCnt
1c79356b A	205	)
1c79356b A	206	{
2d21ac55 A	207	mach_exception_data_type_t big_code[EXCEPTION_CODE_MAX];
	208	big_code[0] = code[0];
	209	big_code[1] = code[1];
	210
	211	return catch_mach_exception_raise(exception_port,
	212	thread,
	213	task,
	214	exception,
	215	big_code,
	216	codeCnt);
	217
	218	}
	219
	220	kern_return_t
	221	catch_mach_exception_raise(
	222	__unused mach_port_t exception_port,
	223	mach_port_t thread,
	224	mach_port_t task,
	225	exception_type_t exception,
	226	mach_exception_data_t code,
	227	__unused mach_msg_type_number_t codeCnt
	228	)
	229	{
	230	task_t self = current_task();
	231	thread_t th_act;
	232	ipc_port_t thread_port;
	233	struct task *sig_task;
	234	struct proc *p;
	235	kern_return_t result = MACH_MSG_SUCCESS;
	236	int ux_signal = 0;
	237	mach_exception_code_t ucode = 0;
	238	struct uthread *ut;
91447636 A	239	mach_port_name_t thread_name = (mach_port_name_t)thread; /* XXX */
91447636 A	240	mach_port_name_t task_name = (mach_port_name_t)task; /* XXX */
1c79356b	241
2d21ac55 A	242	/*
	243	* Convert local thread name to global port.
	244	*/
1c79356b A	245	if (MACH_PORT_VALID(thread_name) &&
	246	(ipc_object_copyin(get_task_ipcspace(self), thread_name,
	247	MACH_MSG_TYPE_PORT_SEND,
	248	(void *) &thread_port) == MACH_MSG_SUCCESS)) {
9bccf70c	249	if (IPC_PORT_VALID(thread_port)) {
91447636	250	th_act = convert_port_to_thread(thread_port);
1c79356b A	251	ipc_port_release(thread_port);
1c79356b A	252	} else {
91447636	253	th_act = THREAD_NULL;
1c79356b A	254	}
	255
	256	/*
	257	* Catch bogus ports
	258	*/
91447636	259	if (th_act != THREAD_NULL) {
2d21ac55	260
1c79356b A	261	/*
	262	* Convert exception to unix signal and code.
	263	*/
2d21ac55 A	264	ux_exception(exception, code[0], code[1], &ux_signal, &ucode);
	265
	266	ut = get_bsdthread_info(th_act);
	267	sig_task = get_threadtask(th_act);
	268	p = (struct proc *) get_bsdtask_info(sig_task);
	269
	270	/* Can't deliver a signal without a bsd process */
	271	if (p == NULL) {
	272	ux_signal = 0;
	273	result = KERN_FAILURE;
	274	}
1c79356b	275
2d21ac55 A	276	/*
	277	* Stack overflow should result in a SIGSEGV signal
	278	* on the alternate stack.
	279	* but we have one or more guard pages after the
	280	* stack top, so we would get a KERN_PROTECTION_FAILURE
	281	* exception instead of KERN_INVALID_ADDRESS, resulting in
	282	* a SIGBUS signal.
	283	* Detect that situation and select the correct signal.
	284	*/
	285	if (code[0] == KERN_PROTECTION_FAILURE &&
	286	ux_signal == SIGBUS) {
	287	user_addr_t sp, stack_min, stack_max;
	288	int mask;
	289	struct sigacts *ps;
	290
	291	sp = code[1];
	292	if (ut && (ut->uu_flag & UT_VFORK))
	293	p = ut->uu_proc;
	294	#if STACK_GROWTH_UP
	295	stack_min = p->user_stack;
	296	stack_max = p->user_stack + MAXSSIZ;
	297	#else /* STACK_GROWTH_UP */
	298	stack_max = p->user_stack;
	299	stack_min = p->user_stack - MAXSSIZ;
	300	#endif /* STACK_GROWTH_UP */
	301	if (sp >= stack_min &&
	302	sp < stack_max) {
	303	/*
	304	* This is indeed a stack overflow. Deliver a
	305	* SIGSEGV signal.
	306	*/
	307	ux_signal = SIGSEGV;
	308
	309	/*
	310	* If the thread/process is not ready to handle
	311	* SIGSEGV on an alternate stack, force-deliver
	312	* SIGSEGV with a SIG_DFL handler.
	313	*/
	314	mask = sigmask(ux_signal);
	315	ps = p->p_sigacts;
	316	if ((p->p_sigignore & mask) \|\|
	317	(ut->uu_sigwait & mask) \|\|
	318	(ut->uu_sigmask & mask) \|\|
	319	(ps->ps_sigact[SIGSEGV] == SIG_IGN) \|\|
	320	(! (ps->ps_sigonstack & mask))) {
	321	p->p_sigignore &= ~mask;
	322	p->p_sigcatch &= ~mask;
	323	ps->ps_sigact[SIGSEGV] = SIG_DFL;
	324	ut->uu_sigwait &= ~mask;
	325	ut->uu_sigmask &= ~mask;
	326	}
	327	}
	328	}
1c79356b A	329	/*
	330	* Send signal.
	331	*/
0c530ab8 A	332	if (ux_signal != 0) {
	333	ut->uu_exception = exception;
	334	//ut->uu_code = code[0]; // filled in by threadsignal
	335	ut->uu_subcode = code[1];
	336	threadsignal(th_act, ux_signal, code[0]);
2d21ac55	337	}
1c79356b	338
91447636	339	thread_deallocate(th_act);
1c79356b A	340	}
	341	else
	342	result = KERN_INVALID_ARGUMENT;
	343	}
	344	else
	345	result = KERN_INVALID_ARGUMENT;
	346
	347	/*
	348	* Delete our send rights to the task and thread ports.
	349	*/
	350	(void)mach_port_deallocate(get_task_ipcspace(ux_handler_self), task_name);
91447636	351	(void)mach_port_deallocate(get_task_ipcspace(ux_handler_self), thread_name);
1c79356b A	352
	353	return (result);
	354	}
91447636	355
1c79356b	356	kern_return_t
91447636 A	357	catch_exception_raise_state(
	358	__unused mach_port_t exception_port,
	359	__unused exception_type_t exception,
	360	__unused const exception_data_t code,
	361	__unused mach_msg_type_number_t codeCnt,
	362	__unused int *flavor,
	363	__unused const thread_state_t old_state,
	364	__unused mach_msg_type_number_t old_stateCnt,
	365	__unused thread_state_t new_state,
	366	__unused mach_msg_type_number_t *new_stateCnt)
1c79356b A	367	{
	368	return(KERN_INVALID_ARGUMENT);
	369	}
91447636	370
2d21ac55 A	371	kern_return_t
	372	catch_mach_exception_raise_state(
	373	__unused mach_port_t exception_port,
	374	__unused exception_type_t exception,
	375	__unused const mach_exception_data_t code,
	376	__unused mach_msg_type_number_t codeCnt,
	377	__unused int *flavor,
	378	__unused const thread_state_t old_state,
	379	__unused mach_msg_type_number_t old_stateCnt,
	380	__unused thread_state_t new_state,
	381	__unused mach_msg_type_number_t *new_stateCnt)
	382	{
	383	return(KERN_INVALID_ARGUMENT);
	384	}
	385
1c79356b	386	kern_return_t
91447636 A	387	catch_exception_raise_state_identity(
	388	__unused mach_port_t exception_port,
	389	__unused mach_port_t thread,
	390	__unused mach_port_t task,
	391	__unused exception_type_t exception,
	392	__unused exception_data_t code,
	393	__unused mach_msg_type_number_t codeCnt,
	394	__unused int *flavor,
	395	__unused thread_state_t old_state,
	396	__unused mach_msg_type_number_t old_stateCnt,
	397	__unused thread_state_t new_state,
	398	__unused mach_msg_type_number_t *new_stateCnt)
1c79356b A	399	{
	400	return(KERN_INVALID_ARGUMENT);
	401	}
	402
2d21ac55 A	403	kern_return_t
	404	catch_mach_exception_raise_state_identity(
	405	__unused mach_port_t exception_port,
	406	__unused mach_port_t thread,
	407	__unused mach_port_t task,
	408	__unused exception_type_t exception,
	409	__unused mach_exception_data_t code,
	410	__unused mach_msg_type_number_t codeCnt,
	411	__unused int *flavor,
	412	__unused thread_state_t old_state,
	413	__unused mach_msg_type_number_t old_stateCnt,
	414	__unused thread_state_t new_state,
	415	__unused mach_msg_type_number_t *new_stateCnt)
	416	{
	417	return(KERN_INVALID_ARGUMENT);
	418	}
	419
	420
1c79356b A	421	/*
	422	* ux_exception translates a mach exception, code and subcode to
	423	* a signal and u.u_code. Calls machine_exception (machine dependent)
	424	* to attempt translation first.
	425	*/
	426
	427	static
	428	void ux_exception(
2d21ac55 A	429	int exception,
	430	mach_exception_code_t code,
	431	mach_exception_subcode_t subcode,
	432	int *ux_signal,
	433	mach_exception_code_t *ux_code)
1c79356b A	434	{
	435	/*
	436	* Try machine-dependent translation first.
	437	*/
	438	if (machine_exception(exception, code, subcode, ux_signal, ux_code))
	439	return;
	440
	441	switch(exception) {
	442
	443	case EXC_BAD_ACCESS:
	444	if (code == KERN_INVALID_ADDRESS)
	445	*ux_signal = SIGSEGV;
	446	else
	447	*ux_signal = SIGBUS;
	448	break;
	449
	450	case EXC_BAD_INSTRUCTION:
	451	*ux_signal = SIGILL;
	452	break;
	453
	454	case EXC_ARITHMETIC:
	455	*ux_signal = SIGFPE;
	456	break;
	457
	458	case EXC_EMULATION:
	459	*ux_signal = SIGEMT;
	460	break;
	461
	462	case EXC_SOFTWARE:
	463	switch (code) {
	464
	465	case EXC_UNIX_BAD_SYSCALL:
	466	*ux_signal = SIGSYS;
	467	break;
	468	case EXC_UNIX_BAD_PIPE:
	469	*ux_signal = SIGPIPE;
	470	break;
	471	case EXC_UNIX_ABORT:
	472	*ux_signal = SIGABRT;
	473	break;
9bccf70c A	474	case EXC_SOFT_SIGNAL:
	475	*ux_signal = SIGKILL;
	476	break;
1c79356b A	477	}
	478	break;
	479
	480	case EXC_BREAKPOINT:
	481	*ux_signal = SIGTRAP;
	482	break;
	483	}
	484	}