/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
- *
* 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
#include <mach/message.h>
#include <mach/port.h>
#include <mach/mig_errors.h>
+#include <mach/task.h>
#include <mach/thread_status.h>
#include <mach/exception_types.h>
#include <ipc/port.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_pset.h>
#include <ipc/ipc_machdep.h>
-#include <kern/etap_macros.h>
#include <kern/counters.h>
#include <kern/ipc_tt.h>
#include <kern/task.h>
#include <kern/thread.h>
-#include <kern/thread_swap.h>
#include <kern/processor.h>
#include <kern/sched.h>
#include <kern/sched_prim.h>
unsigned long c_tsk_exc_raise_state = 0;
unsigned long c_tsk_exc_raise_state_id = 0;
+/* forward declarations */
+void exception_deliver(
+ exception_type_t exception,
+ exception_data_t code,
+ mach_msg_type_number_t codeCnt,
+ struct exception_action *excp,
+ mutex_t *mutex);
+
+#ifdef MACH_BSD
+kern_return_t bsd_exception(
+ exception_type_t exception,
+ exception_data_t code,
+ mach_msg_type_number_t codeCnt);
+#endif /* MACH_BSD */
/*
* Routine: exception_deliver
struct exception_action *excp,
mutex_t *mutex)
{
- thread_act_t a_self = current_act();
+ thread_t self = current_thread();
ipc_port_t exc_port;
int behavior;
int flavor;
* Save work if we are terminating.
* Just go back to our AST handler.
*/
- if (!a_self->active)
+ if (!self->active)
thread_exception_return();
/*
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];
- kr = thread_getstatus(a_self, flavor,
+ state_cnt = _MachineStateCount[flavor];
+ kr = thread_getstatus(self, flavor,
(thread_state_t)state,
&state_cnt);
if (kr == KERN_SUCCESS) {
state, state_cnt,
state, &state_cnt);
if (kr == MACH_MSG_SUCCESS)
- kr = thread_setstatus(a_self, flavor,
+ kr = thread_setstatus(self, flavor,
(thread_state_t)state,
state_cnt);
}
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),
+ retrieve_thread_self_fast(self),
+ retrieve_task_self_fast(self->task),
exception,
code, codeCnt);
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];
- kr = thread_getstatus(a_self, flavor,
+ state_cnt = _MachineStateCount[flavor];
+ kr = thread_getstatus(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),
+ retrieve_thread_self_fast(self),
+ retrieve_task_self_fast(self->task),
exception,
code, codeCnt,
&flavor,
state, state_cnt,
state, &state_cnt);
if (kr == MACH_MSG_SUCCESS)
- kr = thread_setstatus(a_self, flavor,
+ kr = thread_setstatus(self, flavor,
(thread_state_t)state,
state_cnt);
}
* Doesn't return.
*/
void
-exception(
+exception_triage(
exception_type_t exception,
exception_data_t code,
mach_msg_type_number_t codeCnt)
{
- thread_act_t thr_act;
+ thread_t thread;
task_t task;
host_priv_t host_priv;
struct exception_action *excp;
/*
* Try to raise the exception at the activation level.
*/
- thr_act = current_act();
- mutex = mutex_addr(thr_act->lock);
- excp = &thr_act->exc_actions[exception];
+ thread = current_thread();
+ mutex = mutex_addr(thread->mutex);
+ excp = &thread->exc_actions[exception];
exception_deliver(exception, code, codeCnt, excp, mutex);
/*
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();
+ thread_t self = current_thread();
ipc_port_t exc_port;
int behavior;
int flavor;
* Save work if we are terminating.
* Just go back to our AST handler.
*/
- if (!a_self->active) {
+ if (!self->active) {
return(KERN_FAILURE);
}
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];
- kr = thread_getstatus(a_self, flavor,
+ state_cnt = _MachineStateCount[flavor];
+ kr = thread_getstatus(self, flavor,
(thread_state_t)state,
&state_cnt);
if (kr == KERN_SUCCESS) {
state, state_cnt,
state, &state_cnt);
if (kr == MACH_MSG_SUCCESS)
- kr = thread_setstatus(a_self, flavor,
+ kr = thread_setstatus(self, flavor,
(thread_state_t)state,
state_cnt);
}
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),
+ retrieve_thread_self_fast(self),
+ retrieve_task_self_fast(self->task),
exception,
code, codeCnt);
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];
- kr = thread_getstatus(a_self, flavor,
+ state_cnt = _MachineStateCount[flavor];
+ kr = thread_getstatus(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),
+ retrieve_thread_self_fast(self),
+ retrieve_task_self_fast(self->task),
exception,
code, codeCnt,
&flavor,
state, state_cnt,
state, &state_cnt);
if (kr == MACH_MSG_SUCCESS)
- kr = thread_setstatus(a_self, flavor,
+ kr = thread_setstatus(self, flavor,
(thread_state_t)state,
state_cnt);
}
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_t thread = current_thread();
+ ipc_port_t xport;
+ kern_return_t ret;
+ 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_thread_self_fast(thread), /* Not always the dying guy */
+ retrieve_task_self_fast(thread->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