#include <mach_kdb.h>
+#include <mach/mach_types.h>
#include <mach/boolean.h>
#include <mach/kern_return.h>
#include <mach/message.h>
#include <kern/host.h>
#include <kern/misc_protos.h>
#include <string.h>
-#include <mach/exc.h> /* JMM - will become exception.h */
-#include <machine/machine_rpc.h>
+#include <mach/exc.h>
#if MACH_KDB
#include <ddb/db_trap.h>
switch (behavior) {
case EXCEPTION_STATE: {
mach_msg_type_number_t state_cnt;
- natural_t state[ THREAD_MACHINE_STATE_MAX ];
+ thread_state_data_t state;
c_thr_exc_raise_state++;
state_cnt = state_count[flavor];
case EXCEPTION_STATE_IDENTITY: {
mach_msg_type_number_t state_cnt;
- natural_t state[ THREAD_MACHINE_STATE_MAX ];
+ thread_state_data_t state;
c_thr_exc_raise_state_id++;
state_cnt = state_count[flavor];
thread_exception_return();
/*NOTREACHED*/
}
+
+kern_return_t
+bsd_exception(
+ exception_type_t exception,
+ exception_data_t code,
+ mach_msg_type_number_t codeCnt)
+{
+ task_t task;
+ host_priv_t host_priv;
+ struct exception_action *excp;
+ mutex_t *mutex;
+ thread_act_t a_self = current_act();
+ ipc_port_t exc_port;
+ int behavior;
+ int flavor;
+ kern_return_t kr;
+
+ /*
+ * Maybe the task level will handle it.
+ */
+ task = current_task();
+ mutex = mutex_addr(task->lock);
+ excp = &task->exc_actions[exception];
+
+ /*
+ * Save work if we are terminating.
+ * Just go back to our AST handler.
+ */
+ if (!a_self->active) {
+ return(KERN_FAILURE);
+ }
+
+ /*
+ * Snapshot the exception action data under lock for consistency.
+ * Hold a reference to the port over the exception_raise_* calls
+ * so it can't be destroyed. This seems like overkill, but keeps
+ * the port from disappearing between now and when
+ * ipc_object_copyin_from_kernel is finally called.
+ */
+ mutex_lock(mutex);
+ exc_port = excp->port;
+ if (!IP_VALID(exc_port)) {
+ mutex_unlock(mutex);
+ return(KERN_FAILURE);
+ }
+ ip_lock(exc_port);
+ if (!ip_active(exc_port)) {
+ ip_unlock(exc_port);
+ mutex_unlock(mutex);
+ return(KERN_FAILURE);
+ }
+ ip_reference(exc_port);
+ exc_port->ip_srights++;
+ ip_unlock(exc_port);
+
+ flavor = excp->flavor;
+ behavior = excp->behavior;
+ mutex_unlock(mutex);
+
+ switch (behavior) {
+ case EXCEPTION_STATE: {
+ mach_msg_type_number_t state_cnt;
+ thread_state_data_t state;
+
+ c_thr_exc_raise_state++;
+ state_cnt = state_count[flavor];
+ kr = thread_getstatus(a_self, flavor,
+ (thread_state_t)state,
+ &state_cnt);
+ if (kr == KERN_SUCCESS) {
+ kr = exception_raise_state(exc_port, exception,
+ code, codeCnt,
+ &flavor,
+ state, state_cnt,
+ state, &state_cnt);
+ if (kr == MACH_MSG_SUCCESS)
+ kr = thread_setstatus(a_self, flavor,
+ (thread_state_t)state,
+ state_cnt);
+ }
+
+ if (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)
+ return(KERN_SUCCESS);
+
+ return(KERN_FAILURE);
+ }
+
+ case EXCEPTION_DEFAULT:
+ c_thr_exc_raise++;
+ kr = exception_raise(exc_port,
+ retrieve_act_self_fast(a_self),
+ retrieve_task_self_fast(a_self->task),
+ exception,
+ code, codeCnt);
+
+ if (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)
+ return(KERN_SUCCESS);
+ return(KERN_FAILURE);
+
+ case EXCEPTION_STATE_IDENTITY: {
+ mach_msg_type_number_t state_cnt;
+ thread_state_data_t state;
+
+ c_thr_exc_raise_state_id++;
+ state_cnt = state_count[flavor];
+ kr = thread_getstatus(a_self, flavor,
+ (thread_state_t)state,
+ &state_cnt);
+ if (kr == KERN_SUCCESS) {
+ kr = exception_raise_state_identity(exc_port,
+ retrieve_act_self_fast(a_self),
+ retrieve_task_self_fast(a_self->task),
+ exception,
+ code, codeCnt,
+ &flavor,
+ state, state_cnt,
+ state, &state_cnt);
+ if (kr == MACH_MSG_SUCCESS)
+ kr = thread_setstatus(a_self, flavor,
+ (thread_state_t)state,
+ state_cnt);
+ }
+
+ if (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED)
+ return(KERN_SUCCESS);
+ return(KERN_FAILURE);
+ }
+
+ default:
+
+ return(KERN_FAILURE);
+ }/* switch */
+ return(KERN_FAILURE);
+}
+
+
+
+
+/*
+ * Handle interface for special perfomance monitoring
+ * This is a special case of the host exception handler
+ */
+
+kern_return_t sys_perf_notify(struct task *task,
+ exception_data_t code,
+ mach_msg_type_number_t codeCnt)
+{
+ host_priv_t hostp;
+ struct exception_action *excp;
+ thread_act_t act = current_act();
+ thread_t thr = current_thread();
+ ipc_port_t xport;
+ kern_return_t ret;
+ int abrt;
+ spl_t ints;
+ wait_interrupt_t wsave;
+
+ hostp = host_priv_self(); /* Get the host privileged ports */
+ excp = &hostp->exc_actions[EXC_RPC_ALERT]; /* Point to the RPC_ALERT action */
+
+ mutex_lock(&hostp->lock); /* Lock the priv port */
+ xport = excp->port; /* Get the port for this exception */
+ if (!IP_VALID(xport)) { /* Is it valid? */
+ mutex_unlock(&hostp->lock); /* Unlock */
+ return(KERN_FAILURE); /* Go away... */
+ }
+
+ ip_lock(xport); /* Lock the exception port */
+ if (!ip_active(xport)) { /* and is it active? */
+ ip_unlock(xport); /* Nope, fail */
+ mutex_unlock(&hostp->lock); /* Unlock */
+ return(KERN_FAILURE); /* Go away... */
+ }
+
+ if (task->itk_space == xport->data.receiver) { /* Are we trying to send to ourselves? */
+ ip_unlock(xport); /* Yes, fail */
+ mutex_unlock(&hostp->lock); /* Unlock */
+ return(KERN_FAILURE); /* Go away... */
+ }
+
+ ip_reference(xport); /* Bump reference so it doesn't go away */
+ xport->ip_srights++; /* Bump send rights */
+ ip_unlock(xport); /* We can unlock it now */
+
+ mutex_unlock(&hostp->lock); /* All done with the lock */
+
+ wsave = thread_interrupt_level(THREAD_UNINT); /* Make sure we aren't aborted here */
+
+ ret = exception_raise(xport, /* Send the exception to the perf handler */
+ retrieve_act_self_fast(act), /* Not always the dying guy */
+ retrieve_task_self_fast(act->task), /* Not always the dying guy */
+ EXC_RPC_ALERT, /* Unused exception type until now */
+ code, codeCnt);
+
+ (void)thread_interrupt_level(wsave); /* Restore interrupt level */
+
+ return(ret); /* Tell caller how it went */
+}
+
projects / apple / xnu.git / blobdiff