#include <stdio.h>
#include <mach.h>
#include <servers/netname.h>
#include <servers/machid.h>
#include <mach/message.h>
#include <mach/notify.h>
#include <mach_error.h>
#include <mach/exception.h>
#include <mach/vm_attributes.h>
#include "defs.h"
#include "inferior.h"
#include "symtab.h"
#include "value.h"
#include "language.h"
#include "target.h"
#include "gdb_wait.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "regcache.h"
#if 0
#include <servers/machid_lib.h>
#else
#define MACH_TYPE_TASK 1
#define MACH_TYPE_THREAD 2
#endif
#include <signal.h>
#define SIG_UNKNOWN 0
#include <cthreads.h>
#define CPROC_NEXT_OFFSET 0
#define CPROC_NEXT_SIZE (TARGET_PTR_BIT / HOST_CHAR_BIT)
#define CPROC_INCARNATION_OFFSET (CPROC_NEXT_OFFSET + CPROC_NEXT_SIZE)
#define CPROC_INCARNATION_SIZE (sizeof (cthread_t))
#define CPROC_LIST_OFFSET (CPROC_INCARNATION_OFFSET + CPROC_INCARNATION_SIZE)
#define CPROC_LIST_SIZE (TARGET_PTR_BIT / HOST_CHAR_BIT)
#define CPROC_WAIT_OFFSET (CPROC_LIST_OFFSET + CPROC_LIST_SIZE)
#define CPROC_WAIT_SIZE (TARGET_PTR_BIT / HOST_CHAR_BIT)
#define CPROC_REPLY_OFFSET (CPROC_WAIT_OFFSET + CPROC_WAIT_SIZE)
#define CPROC_REPLY_SIZE (sizeof (mach_port_t))
#define CPROC_CONTEXT_OFFSET (CPROC_REPLY_OFFSET + CPROC_REPLY_SIZE)
#define CPROC_CONTEXT_SIZE (TARGET_INT_BIT / HOST_CHAR_BIT)
#define CPROC_LOCK_OFFSET (CPROC_CONTEXT_OFFSET + CPROC_CONTEXT_SIZE)
#define CPROC_LOCK_SIZE (sizeof (spin_lock_t))
#define CPROC_STATE_OFFSET (CPROC_LOCK_OFFSET + CPROC_LOCK_SIZE)
#define CPROC_STATE_SIZE (TARGET_INT_BIT / HOST_CHAR_BIT)
#define CPROC_WIRED_OFFSET (CPROC_STATE_OFFSET + CPROC_STATE_SIZE)
#define CPROC_WIRED_SIZE (sizeof (mach_port_t))
#define CPROC_BUSY_OFFSET (CPROC_WIRED_OFFSET + CPROC_WIRED_SIZE)
#define CPROC_BUSY_SIZE (TARGET_INT_BIT / HOST_CHAR_BIT)
#define CPROC_MSG_OFFSET (CPROC_BUSY_OFFSET + CPROC_BUSY_SIZE)
#define CPROC_MSG_SIZE (sizeof (mach_msg_header_t))
#define CPROC_BASE_OFFSET (CPROC_MSG_OFFSET + CPROC_MSG_SIZE)
#define CPROC_BASE_SIZE (TARGET_INT_BIT / HOST_CHAR_BIT)
#define CPROC_SIZE_OFFSET (CPROC_BASE_OFFSET + CPROC_BASE_SIZE)
#define CPROC_SIZE_SIZE (TARGET_INT_BIT / HOST_CHAR_BIT)
#define CPROC_SIZE (CPROC_SIZE_OFFSET + CPROC_SIZE_SIZE)
#define CPROC_RUNNING 0
#define CPROC_SWITCHING 1
#define CPROC_BLOCKED 2
#define CPROC_CONDWAIT 4
typedef struct gdb_thread
{
mach_port_t name;
CORE_ADDR sp;
CORE_ADDR pc;
CORE_ADDR fp;
boolean_t in_emulator;
int slotid;
struct gdb_thread *cproc;
char raw_cproc[CPROC_SIZE];
cthread_t cthread;
int reverse_map;
struct gdb_thread *next;
}
*gdb_thread_t;
struct exception_list
{
char *name;
boolean_t forward;
boolean_t print;
int sigmap;
}
exception_map[] =
{
{
"not_mach3_exception", FALSE, TRUE, SIG_UNKNOWN
}
,
{
"EXC_BAD_ACCESS", FALSE, TRUE, SIGSEGV
}
,
{
"EXC_BAD_INSTRUCTION", FALSE, TRUE, SIGILL
}
,
{
"EXC_ARITHMETIC", FALSE, TRUE, SIGFPE
}
,
{
"EXC_EMULATION", FALSE, TRUE, SIGEMT
}
,
{
"EXC_SOFTWARE", FALSE, TRUE, SIG_UNKNOWN
}
,
{
"EXC_BREAKPOINT", FALSE, FALSE, SIGTRAP
}
};
int max_exception = sizeof (exception_map) / sizeof (struct exception_list) - 1;
#define MAX_EXCEPTION max_exception
WAITTYPE wait_status;
int debug_level = 0;
void
xx_debug (char *fmt, int a, int b, int c)
{
if (debug_level)
warning (fmt, a, b, c);
}
extern mach_port_t name_server_port;
int stop_exception, stop_code, stop_subcode;
int stopped_in_exception;
thread_t stop_thread = MACH_PORT_NULL;
char *hostname = "";
boolean_t emulator_present = FALSE;
task_t inferior_task;
thread_t current_thread;
mach_port_t inferior_exception_port = MACH_PORT_NULL;
mach_port_t inferior_old_exception_port = MACH_PORT_NULL;
mach_port_t inferior_wait_port_set = MACH_PORT_NULL;
mach_port_t our_notify_port = MACH_PORT_NULL;
mach_port_t currently_waiting_for = MACH_PORT_NULL;
mach_port_t our_message_port = MACH_PORT_NULL;
mach_port_t thread_exception_port = MACH_PORT_NULL;
mach_port_t thread_saved_exception_port = MACH_PORT_NULL;
mach_port_t singlestepped_thread_port = MACH_PORT_NULL;
mach_port_t mid_server = MACH_PORT_NULL;
mach_port_t mid_auth = MACH_PORT_NULL;
int must_suspend_thread = 0;
#define NULL_CLEANUP (struct cleanup *)0
struct cleanup *cleanup_step = NULL_CLEANUP;
static struct target_ops m3_ops;
static void m3_kill_inferior ();
#if 0
#define MACH_TYPE_EXCEPTION_PORT -1
#endif
struct port_chain
{
struct port_chain *next;
mach_port_t port;
int type;
int mid;
};
typedef struct port_chain *port_chain_t;
struct obstack pchain_obstack;
struct obstack *port_chain_obstack = &pchain_obstack;
struct obstack Cproc_obstack;
struct obstack *cproc_obstack = &Cproc_obstack;
port_chain_t notify_chain = (port_chain_t) NULL;
port_chain_t
port_chain_insert (port_chain_t list, mach_port_t name, int type)
{
kern_return_t ret;
port_chain_t new;
int mid;
if (!MACH_PORT_VALID (name))
return list;
if (type == MACH_TYPE_TASK || type == MACH_TYPE_THREAD)
{
if (!MACH_PORT_VALID (mid_server))
{
warning ("Machid server port invalid, can not map port 0x%x to MID",
name);
mid = name;
}
else
{
ret = machid_mach_register (mid_server, mid_auth, name, type, &mid);
if (ret != KERN_SUCCESS)
{
warning ("Can not map name (0x%x) to MID with machid", name);
mid = name;
}
}
}
else
internal_error (__FILE__, __LINE__, "failed internal consistency check");
new = (port_chain_t) obstack_alloc (port_chain_obstack,
sizeof (struct port_chain));
new->next = list;
new->port = name;
new->type = type;
new->mid = mid;
return new;
}
port_chain_t
port_chain_delete (port_chain_t list, mach_port_t elem)
{
if (list)
if (list->port == elem)
list = list->next;
else
while (list->next)
{
if (list->next->port == elem)
list->next = list->next->next;
else
list = list->next;
}
return list;
}
void
port_chain_destroy (struct obstack *ostack)
{
obstack_free (ostack, 0);
obstack_init (ostack);
}
port_chain_t
port_chain_member (port_chain_t list, mach_port_t elem)
{
while (list)
{
if (list->port == elem)
return list;
list = list->next;
}
return (port_chain_t) NULL;
}
int
map_port_name_to_mid (mach_port_t name, int type)
{
port_chain_t elem;
if (!MACH_PORT_VALID (name))
return -1;
elem = port_chain_member (notify_chain, name);
if (elem && (elem->type == type))
return elem->mid;
if (elem)
return -1;
if (!MACH_PORT_VALID (mid_server))
{
warning ("Machid server port invalid, can not map port 0x%x to mid",
name);
return -1;
}
else
{
int mid;
kern_return_t ret;
ret = machid_mach_register (mid_server, mid_auth, name, type, &mid);
if (ret != KERN_SUCCESS)
{
warning ("Can not map name (0x%x) to mid with machid", name);
return -1;
}
return mid;
}
}
static void
discard_single_step (thread_t thread)
{
currently_waiting_for = inferior_wait_port_set;
cleanup_step = NULL_CLEANUP;
if (MACH_PORT_VALID (thread) && MACH_PORT_VALID (singlestepped_thread_port))
setup_single_step (thread, FALSE);
}
setup_single_step (thread_t thread, boolean_t start_step)
{
kern_return_t ret;
if (!MACH_PORT_VALID (thread))
error ("Invalid thread supplied to setup_single_step");
else
{
mach_port_t teport;
ret = thread_get_exception_port (thread, &teport);
CHK ("Getting thread's exception port", ret);
if (start_step)
{
if (MACH_PORT_VALID (singlestepped_thread_port))
{
warning ("Singlestepped_thread_port (0x%x) is still valid?",
singlestepped_thread_port);
singlestepped_thread_port = MACH_PORT_NULL;
}
if (MACH_PORT_VALID (teport) && teport == thread_exception_port)
{
ret = mach_port_deallocate (mach_task_self (), teport);
CHK ("Could not deallocate thread exception port", ret);
}
else
{
ret = thread_set_exception_port (thread, thread_exception_port);
CHK ("Setting exception port for thread", ret);
#if 0
ret = mach_port_move_member (mach_task_self (),
thread_exception_port,
inferior_wait_port_set);
CHK ("Moving thread exception port to inferior_wait_port_set",
ret);
#endif
thread_saved_exception_port = teport;
}
thread_trace (thread, TRUE);
singlestepped_thread_port = thread_exception_port;
currently_waiting_for = singlestepped_thread_port;
cleanup_step = make_cleanup (discard_single_step, thread);
}
else
{
if (!MACH_PORT_VALID (teport))
error ("Single stepped thread had an invalid exception port?");
if (teport != thread_exception_port)
error ("Single stepped thread had an unknown exception port?");
ret = mach_port_deallocate (mach_task_self (), teport);
CHK ("Couldn't deallocate thread exception port", ret);
#if 0
ret = mach_port_move_member (mach_task_self (),
thread_exception_port,
MACH_PORT_NULL);
CHK ("Removing thread exception port from inferior_wait_port_set",
ret);
#endif
ret = thread_set_exception_port (thread,
thread_saved_exception_port);
CHK ("Restoring stepped thread's exception port", ret);
if (MACH_PORT_VALID (thread_saved_exception_port))
(void) mach_port_deallocate (mach_task_self (),
thread_saved_exception_port);
thread_trace (thread, FALSE);
singlestepped_thread_port = MACH_PORT_NULL;
currently_waiting_for = inferior_wait_port_set;
if (cleanup_step)
discard_cleanups (cleanup_step);
}
}
}
static
request_notify (mach_port_t name, mach_msg_id_t variant, int type)
{
kern_return_t ret;
mach_port_t previous_port_dummy = MACH_PORT_NULL;
if (!MACH_PORT_VALID (name))
return;
if (port_chain_member (notify_chain, name))
return;
ret = mach_port_request_notification (mach_task_self (),
name,
variant,
1,
our_notify_port,
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&previous_port_dummy);
CHK ("Serious: request_notify failed", ret);
(void) mach_port_deallocate (mach_task_self (),
previous_port_dummy);
notify_chain = port_chain_insert (notify_chain, name, type);
}
reverse_msg_bits (mach_msg_header_t *msgp, int type)
{
int rbits, lbits;
rbits = MACH_MSGH_BITS_REMOTE (msgp->msgh_bits);
lbits = type;
msgp->msgh_bits =
(msgp->msgh_bits & ~MACH_MSGH_BITS_PORTS_MASK) |
MACH_MSGH_BITS (lbits, rbits);
}
mach_port_t original_server_port_name = MACH_PORT_NULL;
static void
m3_trace_me (void)
{
kern_return_t ret;
ret = task_get_bootstrap_port (mach_task_self (),
&original_server_port_name);
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__, "failed internal consistency check");
ret = mach_port_deallocate (mach_task_self (),
original_server_port_name);
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__, "failed internal consistency check");
ret = task_suspend (mach_task_self ());
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
void
intercept_exec_calls (int exec_counter)
{
int terminal_initted = 0;
struct syscall_msg_t
{
mach_msg_header_t header;
mach_msg_type_t type;
char room[2000];
};
struct syscall_msg_t syscall_in, syscall_out;
mach_port_t fake_server;
mach_port_t original_server_send;
mach_port_t original_exec_reply;
mach_port_t exec_reply;
mach_port_t exec_reply_send;
mach_msg_type_name_t acquired;
mach_port_t emulator_server_port_name;
struct task_basic_info info;
mach_msg_type_number_t info_count;
kern_return_t ret;
if (exec_counter <= 0)
return;
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&fake_server);
CHK ("create inferior_fake_server port failed", ret);
while (1)
{
info_count = sizeof (info);
ret = task_info (inferior_task,
TASK_BASIC_INFO,
(task_info_t) & info,
&info_count);
CHK ("Task info", ret);
if (info.suspend_count)
break;
(void) swtch_pri (42);
}
if (!mach3_read_inferior (&original_server_port_name,
&original_server_port_name,
sizeof (original_server_port_name)))
error ("Can't read inferior task bootstrap port name");
ret = mach_port_extract_right (inferior_task,
original_server_port_name,
MACH_MSG_TYPE_MOVE_SEND,
&original_server_send,
&acquired);
CHK ("mach_port_extract_right (bsd server send)", ret);
if (acquired != MACH_MSG_TYPE_PORT_SEND)
error ("Incorrect right extracted, send right to bsd server expected");
ret = mach_port_insert_right (inferior_task,
original_server_port_name,
fake_server,
MACH_MSG_TYPE_MAKE_SEND);
CHK ("mach_port_insert_right (fake server send)", ret);
xx_debug ("inferior task bsd server ports set up \nfs %x, ospn %x, oss %x\n",
fake_server,
original_server_port_name, original_server_send);
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&exec_reply);
CHK ("create intercepted_reply_port port failed", ret);
ret = mach_port_extract_right (mach_task_self (),
exec_reply,
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&exec_reply_send,
&acquired);
CHK ("mach_port_extract_right (exec_reply)", ret);
if (acquired != MACH_MSG_TYPE_PORT_SEND_ONCE)
error ("Incorrect right extracted, send once expected for exec reply");
ret = mach_port_move_member (mach_task_self (),
fake_server,
inferior_wait_port_set);
CHK ("Moving fake syscall port to inferior_wait_port_set", ret);
xx_debug ("syscall fake server set up, resuming inferior\n");
ret = task_resume (inferior_task);
CHK ("task_resume (startup)", ret);
while (exec_counter > 0)
{
ret = mach_msg (&syscall_in.header,
MACH_RCV_MSG,
0,
sizeof (struct syscall_msg_t),
inferior_wait_port_set,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
CHK ("mach_msg (intercepted sycall)", ret);
#ifdef DUMP_SYSCALL
print_msg (&syscall_in.header);
#endif
if (notify_server (&syscall_in.header, &syscall_out.header))
error ("received a notify while intercepting syscalls");
if (syscall_in.header.msgh_id == MIG_EXEC_SYSCALL_ID)
{
xx_debug ("Received EXEC SYSCALL, counter = %d\n", exec_counter);
if (exec_counter == 1)
{
original_exec_reply = syscall_in.header.msgh_remote_port;
syscall_in.header.msgh_remote_port = exec_reply_send;
}
if (!terminal_initted)
{
target_terminal_init ();
target_terminal_inferior ();
terminal_initted = 1;
}
exec_counter--;
}
syscall_in.header.msgh_local_port = syscall_in.header.msgh_remote_port;
syscall_in.header.msgh_remote_port = original_server_send;
reverse_msg_bits (&syscall_in.header, MACH_MSG_TYPE_COPY_SEND);
ret = mach_msg_send (&syscall_in.header);
CHK ("Forwarded syscall", ret);
}
ret = mach_port_move_member (mach_task_self (),
fake_server,
MACH_PORT_NULL);
CHK ("Moving fake syscall out of inferior_wait_port_set", ret);
ret = mach_port_move_member (mach_task_self (),
exec_reply,
inferior_wait_port_set);
CHK ("Moving exec_reply to inferior_wait_port_set", ret);
ret = mach_msg (&syscall_in.header,
MACH_RCV_MSG,
0,
sizeof (struct syscall_msg_t),
inferior_wait_port_set,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
CHK ("mach_msg (exec reply)", ret);
ret = task_suspend (inferior_task);
CHK ("Suspending inferior after last exec", ret);
must_suspend_thread = 0;
xx_debug ("Received exec reply from bsd server, suspended inferior task\n");
#ifdef DUMP_SYSCALL
print_msg (&syscall_in.header);
#endif
syscall_in.header.msgh_local_port = MACH_PORT_NULL;
syscall_in.header.msgh_remote_port = original_exec_reply;
reverse_msg_bits (&syscall_in.header, MACH_MSG_TYPE_MOVE_SEND_ONCE);
ret = mach_msg_send (&syscall_in.header);
CHK ("Forwarding exec reply to inferior", ret);
ret = mach_port_deallocate (inferior_task,
original_server_port_name);
CHK ("deallocating fake server send right", ret);
ret = mach_port_insert_right (inferior_task,
original_server_port_name,
original_server_send,
MACH_MSG_TYPE_MOVE_SEND);
CHK ("Restoring the original bsd server send right", ret);
ret = mach_port_destroy (mach_task_self (),
fake_server);
fake_server = MACH_PORT_DEAD;
CHK ("mach_port_destroy (fake_server)", ret);
ret = mach_port_destroy (mach_task_self (),
exec_reply);
exec_reply = MACH_PORT_DEAD;
CHK ("mach_port_destroy (exec_reply)", ret);
xx_debug ("Done with exec call interception\n");
}
void
consume_send_rights (thread_array_t thread_list, int thread_count)
{
int index;
if (!thread_count)
return;
for (index = 0; index < thread_count; index++)
{
(void) mach_port_deallocate (mach_task_self (),
thread_list[index]);
}
}
setup_thread (mach_port_t thread, int what)
{
kern_return_t ret;
if (what)
{
ret = thread_suspend (thread);
CHK ("setup_thread thread_suspend", ret);
ret = thread_abort (thread);
CHK ("setup_thread thread_abort", ret);
}
else
{
ret = thread_resume (thread);
CHK ("setup_thread thread_resume", ret);
}
}
int
map_slot_to_mid (int slot, thread_array_t threads, int thread_count)
{
kern_return_t ret;
int deallocate = 0;
int index;
int mid;
if (!threads)
{
deallocate++;
ret = task_threads (inferior_task, &threads, &thread_count);
CHK ("Can not select a thread from a dead task", ret);
}
if (slot < 0 || slot >= thread_count)
{
if (deallocate)
{
consume_send_rights (threads, thread_count);
(void) vm_deallocate (mach_task_self (), (vm_address_t) threads,
(thread_count * sizeof (mach_port_t)));
}
if (slot < 0)
error ("invalid slot number");
else
return -(slot + 1);
}
mid = map_port_name_to_mid (threads[slot], MACH_TYPE_THREAD);
if (deallocate)
{
consume_send_rights (threads, thread_count);
(void) vm_deallocate (mach_task_self (), (vm_address_t) threads,
(thread_count * sizeof (mach_port_t)));
}
return mid;
}
static int
parse_thread_id (char *arg, int thread_count, int slots)
{
kern_return_t ret;
int mid;
int slot;
int index;
if (arg == 0)
return 0;
while (*arg && (*arg == ' ' || *arg == '\t'))
arg++;
if (!*arg)
return 0;
if (*arg != '@')
{
mid = atoi (arg);
if (mid <= 0)
error ("valid thread mid expected");
return mid;
}
arg++;
slot = atoi (arg);
if (slot < 0)
error ("invalid slot number");
if (slots)
return -(slot + 1);
if (thread_count && slot >= thread_count)
return -(slot + 1);
mid = map_slot_to_mid (slot);
return mid;
}
kern_return_t
select_thread (mach_port_t task, int thread_id, int flag)
{
thread_array_t thread_list;
int thread_count;
kern_return_t ret;
int index;
thread_t new_thread = MACH_PORT_NULL;
if (thread_id < 0)
error ("Can't select cprocs without kernel thread");
ret = task_threads (task, &thread_list, &thread_count);
if (ret != KERN_SUCCESS)
{
warning ("Can not select a thread from a dead task");
m3_kill_inferior ();
return KERN_FAILURE;
}
if (thread_count == 0)
{
registers_changed ();
warning ("Task %d has no threads",
map_port_name_to_mid (task, MACH_TYPE_TASK));
current_thread = MACH_PORT_NULL;
(void) vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (mach_port_t)));
return KERN_FAILURE;
}
if (!thread_id || flag == 2)
{
if (!thread_id)
new_thread = thread_list[0];
else
{
if (thread_id < thread_count)
new_thread = thread_list[thread_id];
else
{
(void) vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (mach_port_t)));
error ("No such thread slot number : %d", thread_id);
}
}
}
else
{
for (index = 0; index < thread_count; index++)
if (thread_id == map_port_name_to_mid (thread_list[index],
MACH_TYPE_THREAD))
{
new_thread = thread_list[index];
index = -1;
break;
}
if (index != -1)
error ("No thread with mid %d", thread_id);
}
request_notify (new_thread, MACH_NOTIFY_DEAD_NAME, MACH_TYPE_THREAD);
ret = vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (mach_port_t)));
CHK ("vm_deallocate", ret);
if (!flag)
current_thread = new_thread;
else
{
#if 0
if (MACH_PORT_VALID (current_thread))
{
ret = thread_abort (current_thread);
CHK ("Could not abort system calls when saving state of old thread",
ret);
target_prepare_to_store ();
target_store_registers (-1);
}
#endif
registers_changed ();
current_thread = new_thread;
ret = thread_abort (current_thread);
CHK ("Could not abort system calls when selecting a thread", ret);
stop_pc = read_pc ();
flush_cached_frames ();
select_frame (get_current_frame (), 0);
}
return KERN_SUCCESS;
}
int
switch_to_thread (thread_t new_thread)
{
thread_t saved_thread = current_thread;
int mid;
mid = map_port_name_to_mid (new_thread,
MACH_TYPE_THREAD);
if (mid == -1)
warning ("Can't map thread name 0x%x to mid", new_thread);
else if (select_thread (inferior_task, mid, 1) != KERN_SUCCESS)
{
if (current_thread)
current_thread = saved_thread;
error ("Could not select thread %d", mid);
}
return mid;
}
static int
m3_trace_him (int pid)
{
kern_return_t ret;
push_target (&m3_ops);
inferior_task = task_by_pid (pid);
if (!MACH_PORT_VALID (inferior_task))
error ("Can not map Unix pid %d to Mach task", pid);
setup_notify_port (1);
request_notify (inferior_task, MACH_NOTIFY_DEAD_NAME, MACH_TYPE_TASK);
emulator_present = have_emulator_p (inferior_task);
select_thread (inferior_task, 0, 0);
inferior_exception_port = MACH_PORT_NULL;
setup_exception_port ();
xx_debug ("Now the debugged task is created\n");
intercept_exec_calls (2);
return pid;
}
setup_exception_port (void)
{
kern_return_t ret;
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&inferior_exception_port);
CHK ("mach_port_allocate", ret);
ret = mach_port_insert_right (mach_task_self (),
inferior_exception_port,
inferior_exception_port,
MACH_MSG_TYPE_MAKE_SEND);
CHK ("mach_port_insert_right", ret);
ret = mach_port_move_member (mach_task_self (),
inferior_exception_port,
inferior_wait_port_set);
CHK ("mach_port_move_member", ret);
ret = task_get_special_port (inferior_task,
TASK_EXCEPTION_PORT,
&inferior_old_exception_port);
CHK ("task_get_special_port(old exc)", ret);
ret = task_set_special_port (inferior_task,
TASK_EXCEPTION_PORT,
inferior_exception_port);
CHK ("task_set_special_port", ret);
ret = mach_port_deallocate (mach_task_self (),
inferior_exception_port);
CHK ("mack_port_deallocate", ret);
#if 0
request_notify (inferior_exception_port,
MACH_NOTIFY_NO_SENDERS,
MACH_TYPE_EXCEPTION_PORT);
#endif
}
int mach_really_waiting;
ptid_t
mach_really_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
kern_return_t ret;
int w;
struct msg
{
mach_msg_header_t header;
mach_msg_type_t foo;
int data[8000];
}
in_msg, out_msg;
stopped_in_exception = FALSE;
while (1)
{
QUIT;
stop_exception = stop_code = stop_subcode = -1;
stop_thread = MACH_PORT_NULL;
mach_really_waiting = 1;
ret = mach_msg (&in_msg.header,
MACH_RCV_MSG,
0,
sizeof (struct msg),
currently_waiting_for,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
mach_really_waiting = 0;
CHK ("mach_msg (receive)", ret);
if (notify_server (&in_msg.header, &out_msg.header))
{
if (inferior_task != MACH_PORT_NULL)
continue;
else
{
wait3 (&w, WNOHANG, 0);
if ((!WIFEXITED (w) && WIFSTOPPED (w)) ||
(WIFEXITED (w) && WEXITSTATUS (w) > 0377))
{
WSETEXIT (w, 0);
warning ("Using exit value 0 for terminated task");
}
else if (!WIFEXITED (w))
{
int sig = WTERMSIG (w);
if (sig != SIGKILL)
warning ("The terminating signal stuff may be nonsense");
else if (sig > NSIG)
{
WSETEXIT (w, 0);
warning ("Using exit value 0 for terminated task");
}
}
store_waitstatus (ourstatus, w);
return inferior_ptid;
}
}
if (!exc_server (&in_msg.header, &out_msg.header))
{
if (gdb_message_server (&in_msg.header))
continue;
error ("Unrecognized message received in mach_really_wait");
}
ret = mach_msg_send (&out_msg.header);
CHK ("mach_msg_send (exc reply)", ret);
if (stopped_in_exception)
{
wait3 (&w, WNOHANG, 0);
mach3_exception_actions (&w, FALSE, "Task");
store_waitstatus (ourstatus, w);
return inferior_ptid;
}
}
}
void
mach3_quit (void)
{
int mid;
kern_return_t ret;
if (mach_really_waiting)
{
ret = task_suspend (inferior_task);
if (ret != KERN_SUCCESS)
{
warning ("Could not suspend task for interrupt: %s",
mach_error_string (ret));
mach_really_waiting = 0;
return;
}
}
must_suspend_thread = 0;
mach_really_waiting = 0;
mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
if (mid == -1)
{
warning ("Selecting first existing kernel thread");
mid = 0;
}
current_thread = MACH_PORT_NULL;
select_thread (inferior_task, mid, 1);
return;
}
#if 0
void
mach3_request_quit (void)
{
if (mach_really_waiting)
immediate_quit = 1;
}
#endif
int
gdb_message_server (mach_msg_header_t *InP)
{
kern_return_t ret;
int mid;
if (InP->msgh_local_port == our_message_port)
{
switch (InP->msgh_id)
{
case GDB_MESSAGE_ID_STOP:
ret = task_suspend (inferior_task);
if (ret != KERN_SUCCESS)
warning ("Could not suspend task for stop message: %s",
mach_error_string (ret));
request_quit (0);
break;
default:
warning ("Invalid message id %d received, ignored.",
InP->msgh_id);
break;
}
return 1;
}
return 0;
}
void
stop_inferior_gdb (void)
{
kern_return_t ret;
typedef struct
{
mach_msg_header_t Head;
}
Request;
Request Mess;
register Request *InP = &Mess;
InP->Head.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_COPY_SEND, 0);
InP->Head.msgh_remote_port = our_message_port;
InP->Head.msgh_local_port = MACH_PORT_NULL;
InP->Head.msgh_seqno = 0;
InP->Head.msgh_id = GDB_MESSAGE_ID_STOP;
ret = mach_msg (&InP->Head,
MACH_SEND_MSG | MACH_MSG_OPTION_NONE,
sizeof (Request),
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
}
#ifdef THREAD_ALLOWED_TO_BREAK
int
mach_thread_for_breakpoint (int mid)
{
int cmid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
if (mid < 0)
{
mid = map_slot_to_mid (-(mid + 1), 0, 0);
if (mid < 0)
return 0;
}
if (!mid || cmid == -1)
return 1;
return cmid == mid && stop_exception == EXC_BREAKPOINT;
}
#endif
#ifdef THREAD_PARSE_ID
int
mach_thread_parse_id (char *arg)
{
int mid;
if (arg == 0)
error ("thread id expected");
mid = parse_thread_id (arg, 0, 1);
return mid;
}
#endif
#ifdef THREAD_OUTPUT_ID
char *
mach_thread_output_id (int mid)
{
static char foobar[20];
if (mid > 0)
sprintf (foobar, "mid %d", mid);
else if (mid < 0)
sprintf (foobar, "@%d", -(mid + 1));
else
sprintf (foobar, "*any thread*");
return foobar;
}
#endif
mach3_prepare_to_proceed (int select_it)
{
if (stop_thread &&
stop_thread != current_thread &&
stop_exception == EXC_BREAKPOINT)
{
int mid;
if (!select_it)
return 1;
mid = switch_to_thread (stop_thread);
return 1;
}
return 0;
}
kern_return_t
catch_exception_raise (mach_port_t port, thread_t thread, task_t task,
int exception, int code, int subcode)
{
kern_return_t ret;
boolean_t signal_thread;
int mid = map_port_name_to_mid (thread, MACH_TYPE_THREAD);
if (!MACH_PORT_VALID (thread))
{
current_thread = thread = MACH_PORT_NULL;
error ("Received exception from nonexistent thread");
}
if (!MACH_PORT_VALID (task))
{
current_thread = thread = MACH_PORT_NULL;
error ("Received exception from nonexistent task");
}
if (exception < 0 || exception > MAX_EXCEPTION)
internal_error (__FILE__, __LINE__,
"catch_exception_raise: unknown exception code %d thread %d",
exception,
mid);
if (!MACH_PORT_VALID (inferior_task))
error ("got an exception, but inferior_task is null or dead");
stop_exception = exception;
stop_code = code;
stop_subcode = subcode;
stop_thread = thread;
signal_thread = exception != EXC_BREAKPOINT &&
port == singlestepped_thread_port &&
MACH_PORT_VALID (thread_saved_exception_port);
if (task != inferior_task ||
signal_thread ||
exception_map[exception].forward)
{
mach_port_t eport = inferior_old_exception_port;
if (signal_thread)
{
mach3_exception_actions ((WAITTYPE *) NULL, TRUE, "Thread");
eport = thread_saved_exception_port;
}
ret = exception_raise (eport,
thread,
task,
exception,
code,
subcode);
(void) mach_port_deallocate (mach_task_self (), task);
(void) mach_port_deallocate (mach_task_self (), thread);
discard_single_step (thread);
return ret;
}
stopped_in_exception = TRUE;
ret = task_suspend (task);
CHK ("Error suspending inferior after exception", ret);
must_suspend_thread = 0;
if (current_thread != thread)
{
if (MACH_PORT_VALID (singlestepped_thread_port))
error ("Exception from thread %d while singlestepping thread %d",
mid,
map_port_name_to_mid (current_thread, MACH_TYPE_THREAD));
if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
error ("Could not select thread %d causing exception", mid);
else
warning ("Gdb selected thread %d", mid);
}
if (MACH_PORT_VALID (singlestepped_thread_port))
{
if (stop_exception != EXC_BREAKPOINT)
warning ("Single step interrupted by exception");
else if (port == singlestepped_thread_port)
{
if (!MACH_PORT_VALID (current_thread))
error ("Single stepped thread is not valid");
resume_all_threads (0);
}
else
warning ("Breakpoint while single stepping?");
discard_single_step (current_thread);
}
(void) mach_port_deallocate (mach_task_self (), task);
(void) mach_port_deallocate (mach_task_self (), thread);
return KERN_SUCCESS;
}
int
port_valid (mach_port_t port, int mask)
{
kern_return_t ret;
mach_port_type_t type;
ret = mach_port_type (mach_task_self (),
port,
&type);
if (ret != KERN_SUCCESS || (type & mask) != mask)
return 0;
return 1;
}
boolean_t vm_read_cache_valid = FALSE;
int
mach3_read_inferior (CORE_ADDR addr, char *myaddr, int length)
{
kern_return_t ret;
vm_address_t low_address = (vm_address_t) trunc_page (addr);
vm_size_t aligned_length =
(vm_size_t) round_page (addr + length) - low_address;
pointer_t copied_memory;
int copy_count;
ret = vm_read (inferior_task,
low_address,
aligned_length,
&copied_memory,
©_count);
if (ret != KERN_SUCCESS)
{
if (!port_valid (inferior_task, MACH_PORT_TYPE_SEND))
{
m3_kill_inferior ();
error ("Inferior killed (task port invalid)");
}
else
{
#ifdef OSF
extern int errno;
warning ("[read inferior %x failed: %s]",
addr, mach_error_string (ret));
errno = 0;
#endif
return 0;
}
}
memcpy (myaddr, (char *) addr - low_address + copied_memory, length);
ret = vm_deallocate (mach_task_self (),
copied_memory,
copy_count);
CHK ("mach3_read_inferior vm_deallocate failed", ret);
return length;
}
#define CHK_GOTO_OUT(str,ret) \
do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
struct vm_region_list
{
struct vm_region_list *next;
vm_prot_t protection;
vm_address_t start;
vm_size_t length;
};
struct obstack region_obstack;
int
mach3_write_inferior (CORE_ADDR addr, char *myaddr, int length)
{
kern_return_t ret;
vm_address_t low_address = (vm_address_t) trunc_page (addr);
vm_size_t aligned_length =
(vm_size_t) round_page (addr + length) - low_address;
pointer_t copied_memory;
int copy_count;
int deallocate = 0;
char *errstr = "Bug in mach3_write_inferior";
struct vm_region_list *region_element;
struct vm_region_list *region_head = (struct vm_region_list *) NULL;
ret = vm_read (inferior_task,
low_address,
aligned_length,
&copied_memory,
©_count);
CHK_GOTO_OUT ("mach3_write_inferior vm_read failed", ret);
deallocate++;
memcpy ((char *) addr - low_address + copied_memory, myaddr, length);
obstack_init (®ion_obstack);
{
vm_size_t remaining_length = aligned_length;
vm_address_t region_address = low_address;
struct vm_region_list *scan;
while (region_address < low_address + aligned_length)
{
vm_prot_t protection;
vm_prot_t max_protection;
vm_inherit_t inheritance;
boolean_t shared;
mach_port_t object_name;
vm_offset_t offset;
vm_size_t region_length = remaining_length;
vm_address_t old_address = region_address;
ret = vm_region (inferior_task,
®ion_address,
®ion_length,
&protection,
&max_protection,
&inheritance,
&shared,
&object_name,
&offset);
CHK_GOTO_OUT ("vm_region failed", ret);
if (old_address != region_address)
{
warning ("No memory at 0x%x. Nothing written",
old_address);
ret = KERN_SUCCESS;
length = 0;
goto out;
}
if (!(max_protection & VM_PROT_WRITE))
{
warning ("Memory at address 0x%x is unwritable. Nothing written",
old_address);
ret = KERN_SUCCESS;
length = 0;
goto out;
}
region_element =
(struct vm_region_list *)
obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
region_element->protection = protection;
region_element->start = region_address;
region_element->length = region_length;
region_element->next = region_head;
region_head = region_element;
region_address += region_length;
remaining_length = remaining_length - region_length;
}
for (scan = region_head; scan; scan = scan->next)
{
boolean_t protection_changed = FALSE;
if (!(scan->protection & VM_PROT_WRITE))
{
ret = vm_protect (inferior_task,
scan->start,
scan->length,
FALSE,
scan->protection | VM_PROT_WRITE);
CHK_GOTO_OUT ("vm_protect: enable write failed", ret);
}
}
ret = vm_write (inferior_task,
low_address,
copied_memory,
aligned_length);
CHK_GOTO_OUT ("vm_write failed", ret);
for (scan = region_head; scan; scan = scan->next)
{
boolean_t protection_changed = FALSE;
if (!(scan->protection & VM_PROT_WRITE))
{
ret = vm_protect (inferior_task,
scan->start,
scan->length,
FALSE,
scan->protection);
CHK_GOTO_OUT ("vm_protect: enable write failed", ret);
}
}
}
out:
if (deallocate)
{
obstack_free (®ion_obstack, 0);
(void) vm_deallocate (mach_task_self (),
copied_memory,
copy_count);
}
if (ret != KERN_SUCCESS)
{
warning ("%s %s", errstr, mach_error_string (ret));
return 0;
}
return length;
}
static int
m3_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
struct target_ops *target)
{
int result;
if (write)
result = mach3_write_inferior (memaddr, myaddr, len);
else
result = mach3_read_inferior (memaddr, myaddr, len);
return result;
}
static char *
translate_state (int state)
{
switch (state)
{
case TH_STATE_RUNNING:
return ("R");
case TH_STATE_STOPPED:
return ("S");
case TH_STATE_WAITING:
return ("W");
case TH_STATE_UNINTERRUPTIBLE:
return ("U");
case TH_STATE_HALTED:
return ("H");
default:
return ("?");
}
}
static char *
translate_cstate (int state)
{
switch (state)
{
case CPROC_RUNNING:
return "R";
case CPROC_SWITCHING:
return "S";
case CPROC_BLOCKED:
return "B";
case CPROC_CONDWAIT:
return "C";
case CPROC_CONDWAIT | CPROC_SWITCHING:
return "CS";
default:
return "?";
}
}
mach_port_t
map_inferior_port_name (mach_port_t inferior_name, mach_msg_type_name_t type)
{
kern_return_t ret;
mach_msg_type_name_t acquired;
mach_port_t iport;
ret = mach_port_extract_right (inferior_task,
inferior_name,
type,
&iport,
&acquired);
CHK ("mach_port_extract_right (map_inferior_port_name)", ret);
if (acquired != MACH_MSG_TYPE_PORT_SEND)
error ("Incorrect right extracted, (map_inferior_port_name)");
ret = mach_port_deallocate (mach_task_self (),
iport);
CHK ("Deallocating mapped port (map_inferior_port_name)", ret);
return iport;
}
static char buf[7];
static char *
get_thread_name (gdb_thread_t one_cproc, int id)
{
if (one_cproc)
if (one_cproc->cthread == NULL)
{
sprintf (buf, "_C%d", id);
}
else if (!one_cproc->cthread->name)
{
sprintf (buf, "_t%d", id);
}
else
return (char *) (one_cproc->cthread->name);
else
{
if (id < 0)
warning ("Inconsistency in thread name id %d", id);
sprintf (buf, "_K%d", id);
}
return buf;
}
int
fetch_thread_info (mach_port_t task, gdb_thread_t *mthreads_out)
{
kern_return_t ret;
thread_array_t th_table;
int th_count;
gdb_thread_t mthreads = NULL;
int index;
ret = task_threads (task, &th_table, &th_count);
if (ret != KERN_SUCCESS)
{
warning ("Error getting inferior's thread list:%s",
mach_error_string (ret));
m3_kill_inferior ();
return -1;
}
mthreads = (gdb_thread_t)
obstack_alloc
(cproc_obstack,
th_count * sizeof (struct gdb_thread));
for (index = 0; index < th_count; index++)
{
thread_t saved_thread = MACH_PORT_NULL;
int mid;
if (must_suspend_thread)
setup_thread (th_table[index], 1);
if (th_table[index] != current_thread)
{
saved_thread = current_thread;
mid = switch_to_thread (th_table[index]);
}
mthreads[index].name = th_table[index];
mthreads[index].cproc = NULL;
mthreads[index].in_emulator = FALSE;
mthreads[index].slotid = index;
mthreads[index].sp = read_register (SP_REGNUM);
mthreads[index].fp = read_register (FP_REGNUM);
mthreads[index].pc = read_pc ();
if (MACH_PORT_VALID (saved_thread))
mid = switch_to_thread (saved_thread);
if (must_suspend_thread)
setup_thread (th_table[index], 0);
}
consume_send_rights (th_table, th_count);
ret = vm_deallocate (mach_task_self (), (vm_address_t) th_table,
(th_count * sizeof (mach_port_t)));
if (ret != KERN_SUCCESS)
{
warning ("Error trying to deallocate thread list : %s",
mach_error_string (ret));
}
*mthreads_out = mthreads;
return th_count;
}
CORE_ADDR
fetch_usp_from_emulator_stack (CORE_ADDR sp)
{
CORE_ADDR stack_pointer;
sp = (sp & ~(EMULATOR_STACK_SIZE - 1)) +
EMULATOR_STACK_SIZE - sizeof (struct emul_stack_top);
if (mach3_read_inferior (sp,
&stack_pointer,
sizeof (CORE_ADDR)) != sizeof (CORE_ADDR))
{
warning ("Can't read user sp from emulator stack address 0x%x", sp);
return 0;
}
return stack_pointer;
}
#ifdef MK67
#define EMUL_VECTOR_COUNT 400
#endif
boolean_t
have_emulator_p (task_t task)
{
kern_return_t ret;
#ifndef EMUL_VECTOR_COUNT
vm_offset_t *emulation_vector;
int n;
#else
vm_offset_t emulation_vector[EMUL_VECTOR_COUNT];
int n = EMUL_VECTOR_COUNT;
#endif
int i;
int vector_start;
ret = task_get_emulation_vector (task,
&vector_start,
#ifndef EMUL_VECTOR_COUNT
&emulation_vector,
#else
emulation_vector,
#endif
&n);
CHK ("task_get_emulation_vector", ret);
xx_debug ("%d vectors from %d at 0x%08x\n",
n, vector_start, emulation_vector);
for (i = 0; i < n; i++)
{
vm_offset_t entry = emulation_vector[i];
if (EMULATOR_BASE <= entry && entry <= EMULATOR_END)
return TRUE;
else if (entry)
{
static boolean_t informed = FALSE;
if (!informed)
{
warning ("Emulation vector address 0x08%x outside emulator space",
entry);
informed = TRUE;
}
}
}
return FALSE;
}
void
map_cprocs_to_kernel_threads (gdb_thread_t cprocs, gdb_thread_t mthreads,
int thread_count)
{
int index;
gdb_thread_t scan;
boolean_t all_mapped = TRUE;
LONGEST stack_base;
LONGEST stack_size;
for (scan = cprocs; scan; scan = scan->next)
{
scan->reverse_map = -1;
for (index = 0; index < thread_count; index++)
{
stack_base =
extract_signed_integer (scan->raw_cproc + CPROC_BASE_OFFSET,
CPROC_BASE_SIZE);
stack_size =
extract_signed_integer (scan->raw_cproc + CPROC_SIZE_OFFSET,
CPROC_SIZE_SIZE);
if ((mthreads + index)->sp > stack_base &&
(mthreads + index)->sp <= stack_base + stack_size)
{
(mthreads + index)->cproc = scan;
scan->reverse_map = index;
break;
}
}
all_mapped &= (scan->reverse_map != -1);
}
if (emulator_present)
{
for (index = 0; index < thread_count; index++)
{
CORE_ADDR emul_sp;
CORE_ADDR usp;
gdb_thread_t mthread = (mthreads + index);
emul_sp = mthread->sp;
if (mthread->cproc == NULL &&
EMULATOR_BASE <= emul_sp && emul_sp <= EMULATOR_END)
{
mthread->in_emulator = emulator_present;
if (!all_mapped && cprocs)
{
usp = fetch_usp_from_emulator_stack (emul_sp);
if (!usp)
error ("Zero stack pointer read from emulator?");
for (scan = cprocs; scan; scan = scan->next)
{
if (scan->reverse_map == -1)
{
stack_base =
extract_signed_integer
(scan->raw_cproc + CPROC_BASE_OFFSET,
CPROC_BASE_SIZE);
stack_size =
extract_signed_integer
(scan->raw_cproc + CPROC_SIZE_OFFSET,
CPROC_SIZE_SIZE);
if (usp > stack_base &&
usp <= stack_base + stack_size)
{
mthread->cproc = scan;
scan->reverse_map = index;
break;
}
}
}
}
}
}
}
}
#define TL_FORMAT "%-2.2s %5d%c %-10.10s %1.1s%s%-5.5s %-2.2s %-5.5s "
#define TL_HEADER "\n@ MID Name KState CState Where\n"
void
print_tl_address (struct ui_file *stream, CORE_ADDR pc)
{
if (!lookup_minimal_symbol_by_pc (pc))
fprintf_filtered (stream, local_hex_format (), pc);
else
{
extern int addressprint;
extern int asm_demangle;
int store = addressprint;
addressprint = 0;
print_address_symbolic (pc, stream, asm_demangle, "");
addressprint = store;
}
}
#define MAX_NAME_LEN 50
CORE_ADDR
lookup_address_of_variable (char *name)
{
struct symbol *sym;
CORE_ADDR symaddr = 0;
struct minimal_symbol *msymbol;
sym = lookup_symbol (name,
(struct block *) NULL,
VAR_NAMESPACE,
(int *) NULL,
(struct symtab **) NULL);
if (sym)
symaddr = SYMBOL_VALUE (sym);
if (!symaddr)
{
msymbol = lookup_minimal_symbol (name, NULL, NULL);
if (msymbol && msymbol->type == mst_data)
symaddr = SYMBOL_VALUE_ADDRESS (msymbol);
}
return symaddr;
}
static gdb_thread_t
get_cprocs (void)
{
gdb_thread_t cproc_head;
gdb_thread_t cproc_copy;
CORE_ADDR their_cprocs;
char *buf;
char *name;
cthread_t cthread;
CORE_ADDR symaddr;
buf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
symaddr = lookup_address_of_variable ("cproc_list");
if (!symaddr)
{
symaddr = lookup_address_of_variable ("cprocs");
if (symaddr)
{
static int informed = 0;
if (!informed)
{
informed++;
warning ("Your program is loaded with an old threads library.");
warning ("GDB does not know the old form of threads");
warning ("so things may not work.");
}
}
}
if (!symaddr)
return NULL;
if (!mach3_read_inferior (symaddr,
buf,
TARGET_PTR_BIT / HOST_CHAR_BIT))
error ("Can't read cproc master list at address (0x%x).", symaddr);
their_cprocs = extract_address (buf, TARGET_PTR_BIT / HOST_CHAR_BIT);
cproc_head = NULL;
while (their_cprocs != (CORE_ADDR) 0)
{
CORE_ADDR cproc_copy_incarnation;
cproc_copy = (gdb_thread_t) obstack_alloc (cproc_obstack,
sizeof (struct gdb_thread));
if (!mach3_read_inferior (their_cprocs,
&cproc_copy->raw_cproc[0],
CPROC_SIZE))
error ("Can't read next cproc at 0x%x.", their_cprocs);
their_cprocs =
extract_address (cproc_copy->raw_cproc + CPROC_LIST_OFFSET,
CPROC_LIST_SIZE);
cproc_copy_incarnation =
extract_address (cproc_copy->raw_cproc + CPROC_INCARNATION_OFFSET,
CPROC_INCARNATION_SIZE);
if (cproc_copy_incarnation == (CORE_ADDR) 0)
cproc_copy->cthread = NULL;
else
{
cthread = (cthread_t) obstack_alloc (cproc_obstack,
sizeof (struct cthread));
if (!mach3_read_inferior (cproc_copy_incarnation,
cthread,
sizeof (struct cthread)))
error ("Can't read next thread at 0x%x.",
cproc_copy_incarnation);
cproc_copy->cthread = cthread;
if (cthread->name)
{
name = (char *) obstack_alloc (cproc_obstack, MAX_NAME_LEN);
if (!mach3_read_inferior (cthread->name, name, MAX_NAME_LEN))
error ("Can't read next thread's name at 0x%x.", cthread->name);
cthread->name = name;
}
}
cproc_copy->next = cproc_head;
cproc_head = cproc_copy;
}
return cproc_head;
}
#ifndef FETCH_CPROC_STATE
#define FETCH_CPROC_STATE(mth) mach3_cproc_state (mth)
int
mach3_cproc_state (gdb_thread_t mthread)
{
int context;
if (!mthread || !mthread->cproc)
return -1;
context = extract_signed_integer
(mthread->cproc->raw_cproc + CPROC_CONTEXT_OFFSET,
CPROC_CONTEXT_SIZE);
if (context == 0)
return -1;
mthread->sp = context + MACHINE_CPROC_SP_OFFSET;
if (mach3_read_inferior (context + MACHINE_CPROC_PC_OFFSET,
&mthread->pc,
sizeof (CORE_ADDR)) != sizeof (CORE_ADDR))
{
warning ("Can't read cproc pc from inferior");
return -1;
}
if (mach3_read_inferior (context + MACHINE_CPROC_FP_OFFSET,
&mthread->fp,
sizeof (CORE_ADDR)) != sizeof (CORE_ADDR))
{
warning ("Can't read cproc fp from inferior");
return -1;
}
return 0;
}
#endif
void
thread_list_command (void)
{
thread_basic_info_data_t ths;
int thread_count;
gdb_thread_t cprocs;
gdb_thread_t scan;
int index;
char *name;
char selected;
char *wired;
int infoCnt;
kern_return_t ret;
mach_port_t mid_or_port;
gdb_thread_t their_threads;
gdb_thread_t kthread;
int neworder = 1;
char *fmt = "There are %d kernel threads in task %d.\n";
int tmid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
MACH_ERROR_NO_INFERIOR;
thread_count = fetch_thread_info (inferior_task,
&their_threads);
if (thread_count == -1)
return;
if (thread_count == 1)
fmt = "There is %d kernel thread in task %d.\n";
printf_filtered (fmt, thread_count, tmid);
puts_filtered (TL_HEADER);
cprocs = get_cprocs ();
map_cprocs_to_kernel_threads (cprocs, their_threads, thread_count);
for (scan = cprocs; scan; scan = scan->next)
{
int mid;
char buf[10];
char slot[3];
int cproc_state =
extract_signed_integer
(scan->raw_cproc + CPROC_STATE_OFFSET, CPROC_STATE_SIZE);
selected = ' ';
wired = (extract_address (scan->raw_cproc + CPROC_WIRED_OFFSET,
CPROC_WIRED_SIZE)
? "wired" : "");
if (scan->reverse_map != -1)
kthread = (their_threads + scan->reverse_map);
else
kthread = NULL;
if (kthread)
{
mid = map_port_name_to_mid (kthread->name, MACH_TYPE_THREAD);
infoCnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info (kthread->name,
THREAD_BASIC_INFO,
(thread_info_t) & ths,
&infoCnt);
if (ret != KERN_SUCCESS)
{
warning ("Unable to get basic info on thread %d : %s",
mid,
mach_error_string (ret));
continue;
}
sprintf (slot, "%d", kthread->slotid % 100);
if (kthread->name == current_thread)
selected = '*';
if (ths.suspend_count)
sprintf (buf, "%d", ths.suspend_count);
else
buf[0] = '\000';
#if 0
if (ths.flags & TH_FLAGS_SWAPPED)
strcat (buf, "S");
#endif
if (ths.flags & TH_FLAGS_IDLE)
strcat (buf, "I");
printf_filtered (TL_FORMAT,
slot,
mid,
selected,
get_thread_name (scan, kthread->slotid),
kthread->in_emulator ? "E" : "",
translate_state (ths.run_state),
buf,
translate_cstate (cproc_state),
wired);
print_tl_address (gdb_stdout, kthread->pc);
}
else
{
struct gdb_thread state;
#if 0
if (scan->incarnation == NULL)
continue;
#endif
printf_filtered (TL_FORMAT,
"-",
-neworder,
selected,
get_thread_name (scan, -neworder),
"",
"-",
"",
translate_cstate (cproc_state),
"");
state.cproc = scan;
if (FETCH_CPROC_STATE (&state) == -1)
puts_filtered ("???");
else
print_tl_address (gdb_stdout, state.pc);
neworder++;
}
puts_filtered ("\n");
}
for (index = 0; index < thread_count; index++)
{
if (!their_threads[index].cproc)
{
int mid;
char buf[10];
char slot[3];
mach_port_t name = their_threads[index].name;
mid = map_port_name_to_mid (name, MACH_TYPE_THREAD);
infoCnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info (name,
THREAD_BASIC_INFO,
(thread_info_t) & ths,
&infoCnt);
if (ret != KERN_SUCCESS)
{
warning ("Unable to get basic info on thread %d : %s",
mid,
mach_error_string (ret));
continue;
}
sprintf (slot, "%d", index % 100);
if (name == current_thread)
selected = '*';
else
selected = ' ';
if (ths.suspend_count)
sprintf (buf, "%d", ths.suspend_count);
else
buf[0] = '\000';
#if 0
if (ths.flags & TH_FLAGS_SWAPPED)
strcat (buf, "S");
#endif
if (ths.flags & TH_FLAGS_IDLE)
strcat (buf, "I");
printf_filtered (TL_FORMAT,
slot,
mid,
selected,
get_thread_name (NULL, index),
their_threads[index].in_emulator ? "E" : "",
translate_state (ths.run_state),
buf,
"",
"");
print_tl_address (gdb_stdout, their_threads[index].pc);
puts_filtered ("\n");
}
}
obstack_free (cproc_obstack, 0);
obstack_init (cproc_obstack);
}
void
thread_select_command (char *args, int from_tty)
{
int mid;
thread_array_t thread_list;
int thread_count;
kern_return_t ret;
int is_slot = 0;
MACH_ERROR_NO_INFERIOR;
if (!args)
error_no_arg ("MID or @SLOTNUMBER to specify a thread to select");
while (*args == ' ' || *args == '\t')
args++;
if (*args == '@')
{
is_slot++;
args++;
}
mid = atoi (args);
if (mid == 0)
if (!is_slot || *args != '0')
error ("You must select threads by MID or @SLOTNUMBER");
if (select_thread (inferior_task, mid, is_slot ? 2 : 1) != KERN_SUCCESS)
return;
if (from_tty)
printf_filtered ("Thread %d selected\n",
is_slot ? map_port_name_to_mid (current_thread,
MACH_TYPE_THREAD) : mid);
}
thread_trace (mach_port_t thread, boolean_t set)
{
int flavor = TRACE_FLAVOR;
unsigned int stateCnt = TRACE_FLAVOR_SIZE;
kern_return_t ret;
thread_state_data_t state;
if (!MACH_PORT_VALID (thread))
{
warning ("thread_trace: invalid thread");
return;
}
if (must_suspend_thread)
setup_thread (thread, 1);
ret = thread_get_state (thread, flavor, state, &stateCnt);
CHK ("thread_trace: error reading thread state", ret);
if (set)
{
TRACE_SET (thread, state);
}
else
{
if (!TRACE_CLEAR (thread, state))
{
if (must_suspend_thread)
setup_thread (thread, 0);
return;
}
}
ret = thread_set_state (thread, flavor, state, stateCnt);
CHK ("thread_trace: error writing thread state", ret);
if (must_suspend_thread)
setup_thread (thread, 0);
}
#ifdef FLUSH_INFERIOR_CACHE
flush_inferior_icache (CORE_ADDR pc, int amount)
{
vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
kern_return_t ret;
ret = vm_machine_attribute (inferior_task,
pc,
amount,
MATTR_CACHE,
&flush);
if (ret != KERN_SUCCESS)
warning ("Error flushing inferior's cache : %s",
mach_error_string (ret));
}
#endif
static
suspend_all_threads (int from_tty)
{
kern_return_t ret;
thread_array_t thread_list;
int thread_count, index;
int infoCnt;
thread_basic_info_data_t th_info;
ret = task_threads (inferior_task, &thread_list, &thread_count);
if (ret != KERN_SUCCESS)
{
warning ("Could not suspend inferior threads.");
m3_kill_inferior ();
return_to_top_level (RETURN_ERROR);
}
for (index = 0; index < thread_count; index++)
{
int mid;
mid = map_port_name_to_mid (thread_list[index],
MACH_TYPE_THREAD);
ret = thread_suspend (thread_list[index]);
if (ret != KERN_SUCCESS)
warning ("Error trying to suspend thread %d : %s",
mid, mach_error_string (ret));
if (from_tty)
{
infoCnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info (thread_list[index],
THREAD_BASIC_INFO,
(thread_info_t) & th_info,
&infoCnt);
CHK ("suspend can't get thread info", ret);
warning ("Thread %d suspend count is %d",
mid, th_info.suspend_count);
}
}
consume_send_rights (thread_list, thread_count);
ret = vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (int)));
CHK ("Error trying to deallocate thread list", ret);
}
void
thread_suspend_command (char *args, int from_tty)
{
kern_return_t ret;
int mid;
mach_port_t saved_thread;
int infoCnt;
thread_basic_info_data_t th_info;
MACH_ERROR_NO_INFERIOR;
if (!strcasecmp (args, "all"))
{
suspend_all_threads (from_tty);
return;
}
saved_thread = current_thread;
mid = parse_thread_id (args, 0, 0);
if (mid < 0)
error ("You can suspend only existing kernel threads with MID or @SLOTNUMBER");
if (mid == 0)
mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
else if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
{
if (current_thread)
current_thread = saved_thread;
error ("Could not select thread %d", mid);
}
ret = thread_suspend (current_thread);
if (ret != KERN_SUCCESS)
warning ("thread_suspend failed : %s",
mach_error_string (ret));
infoCnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info (current_thread,
THREAD_BASIC_INFO,
(thread_info_t) & th_info,
&infoCnt);
CHK ("suspend can't get thread info", ret);
warning ("Thread %d suspend count is %d", mid, th_info.suspend_count);
current_thread = saved_thread;
}
resume_all_threads (int from_tty)
{
kern_return_t ret;
thread_array_t thread_list;
int thread_count, index;
int mid;
int infoCnt;
thread_basic_info_data_t th_info;
ret = task_threads (inferior_task, &thread_list, &thread_count);
if (ret != KERN_SUCCESS)
{
m3_kill_inferior ();
error ("task_threads", mach_error_string (ret));
}
for (index = 0; index < thread_count; index++)
{
infoCnt = THREAD_BASIC_INFO_COUNT;
ret = thread_info (thread_list[index],
THREAD_BASIC_INFO,
(thread_info_t) & th_info,
&infoCnt);
CHK ("resume_all can't get thread info", ret);
mid = map_port_name_to_mid (thread_list[index],
MACH_TYPE_THREAD);
if (!th_info.suspend_count)
{
if (mid != -1 && from_tty)
warning ("Thread %d is not suspended", mid);
continue;
}
ret = thread_resume (thread_list[index]);
if (ret != KERN_SUCCESS)
warning ("Error trying to resume thread %d : %s",
mid, mach_error_string (ret));
else if (mid != -1 && from_tty)
warning ("Thread %d suspend count is %d",
mid, --th_info.suspend_count);
}
consume_send_rights (thread_list, thread_count);
ret = vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (int)));
CHK ("Error trying to deallocate thread list", ret);
}
void
thread_resume_command (char *args, int from_tty)
{
int mid;
mach_port_t saved_thread;
kern_return_t ret;
thread_basic_info_data_t th_info;
int infoCnt = THREAD_BASIC_INFO_COUNT;
MACH_ERROR_NO_INFERIOR;
if (!strcasecmp (args, "all"))
{
resume_all_threads (from_tty);
return;
}
saved_thread = current_thread;
mid = parse_thread_id (args, 0, 0);
if (mid < 0)
error ("You can resume only existing kernel threads with MID or @SLOTNUMBER");
if (mid == 0)
mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
else if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
{
if (current_thread)
current_thread = saved_thread;
return_to_top_level (RETURN_ERROR);
}
ret = thread_info (current_thread,
THREAD_BASIC_INFO,
(thread_info_t) & th_info,
&infoCnt);
CHK ("resume can't get thread info", ret);
if (!th_info.suspend_count)
{
warning ("Thread %d is not suspended", mid);
goto out;
}
ret = thread_resume (current_thread);
if (ret != KERN_SUCCESS)
warning ("thread_resume failed : %s",
mach_error_string (ret));
else
{
th_info.suspend_count--;
warning ("Thread %d suspend count is %d", mid, th_info.suspend_count);
}
out:
current_thread = saved_thread;
}
void
thread_kill_command (char *args, int from_tty)
{
int mid;
kern_return_t ret;
int thread_count;
thread_array_t thread_table;
int index;
mach_port_t thread_to_kill = MACH_PORT_NULL;
MACH_ERROR_NO_INFERIOR;
if (!args)
error_no_arg ("thread mid to kill from the inferior task");
mid = parse_thread_id (args, 0, 0);
if (mid < 0)
error ("You can kill only existing kernel threads with MID or @SLOTNUMBER");
if (mid)
{
ret = machid_mach_port (mid_server, mid_auth, mid, &thread_to_kill);
CHK ("thread_kill_command: machid_mach_port map failed", ret);
}
else
mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
ret = task_threads (inferior_task, &thread_table, &thread_count);
CHK ("Error getting inferior's thread list", ret);
if (thread_to_kill == current_thread)
{
ret = thread_terminate (thread_to_kill);
CHK ("Thread could not be terminated", ret);
if (select_thread (inferior_task, 0, 1) != KERN_SUCCESS)
warning ("Last thread was killed, use \"kill\" command to kill task");
}
else
for (index = 0; index < thread_count; index++)
if (thread_table[index] == thread_to_kill)
{
ret = thread_terminate (thread_to_kill);
CHK ("Thread could not be terminated", ret);
}
if (thread_count > 1)
consume_send_rights (thread_table, thread_count);
ret = vm_deallocate (mach_task_self (), (vm_address_t) thread_table,
(thread_count * sizeof (mach_port_t)));
CHK ("Error trying to deallocate thread list", ret);
warning ("Thread %d killed", mid);
}
void
task_resume_command (char *args, int from_tty)
{
kern_return_t ret;
task_basic_info_data_t ta_info;
int infoCnt = TASK_BASIC_INFO_COUNT;
int mid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
MACH_ERROR_NO_INFERIOR;
if (args)
error ("Currently gdb can resume only it's inferior task");
ret = task_info (inferior_task,
TASK_BASIC_INFO,
(task_info_t) & ta_info,
&infoCnt);
CHK ("task_resume_command: task_info failed", ret);
if (ta_info.suspend_count == 0)
error ("Inferior task %d is not suspended", mid);
else if (ta_info.suspend_count == 1 &&
from_tty &&
!query ("Suspend count is now 1. Do you know what you are doing? "))
error ("Task not resumed");
ret = task_resume (inferior_task);
CHK ("task_resume_command: task_resume", ret);
if (ta_info.suspend_count == 1)
{
warning ("Inferior task %d is no longer suspended", mid);
must_suspend_thread = 1;
registers_changed ();
}
else
warning ("Inferior task %d suspend count is now %d",
mid, ta_info.suspend_count - 1);
}
void
task_suspend_command (char *args, int from_tty)
{
kern_return_t ret;
task_basic_info_data_t ta_info;
int infoCnt = TASK_BASIC_INFO_COUNT;
int mid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
MACH_ERROR_NO_INFERIOR;
if (args)
error ("Currently gdb can suspend only it's inferior task");
ret = task_suspend (inferior_task);
CHK ("task_suspend_command: task_suspend", ret);
must_suspend_thread = 0;
ret = task_info (inferior_task,
TASK_BASIC_INFO,
(task_info_t) & ta_info,
&infoCnt);
CHK ("task_suspend_command: task_info failed", ret);
warning ("Inferior task %d suspend count is now %d",
mid, ta_info.suspend_count);
}
static char *
get_size (int bytes)
{
static char size[30];
int zz = bytes / 1024;
if (zz / 1024)
sprintf (size, "%-2.1f M", ((float) bytes) / (1024.0 * 1024.0));
else
sprintf (size, "%d K", zz);
return size;
}
void
task_info_command (char *args, int from_tty)
{
int mid = -5;
mach_port_t task;
kern_return_t ret;
task_basic_info_data_t ta_info;
int infoCnt = TASK_BASIC_INFO_COUNT;
int page_size = round_page (1);
int thread_count = 0;
if (MACH_PORT_VALID (inferior_task))
mid = map_port_name_to_mid (inferior_task,
MACH_TYPE_TASK);
task = inferior_task;
if (args)
{
int tmid = atoi (args);
if (tmid <= 0)
error ("Invalid mid %d for task info", tmid);
if (tmid != mid)
{
mid = tmid;
ret = machid_mach_port (mid_server, mid_auth, tmid, &task);
CHK ("task_info_command: machid_mach_port map failed", ret);
}
}
if (mid < 0)
error ("You have to give the task MID as an argument");
ret = task_info (task,
TASK_BASIC_INFO,
(task_info_t) & ta_info,
&infoCnt);
CHK ("task_info_command: task_info failed", ret);
printf_filtered ("\nTask info for task %d:\n\n", mid);
printf_filtered (" Suspend count : %d\n", ta_info.suspend_count);
printf_filtered (" Base priority : %d\n", ta_info.base_priority);
printf_filtered (" Virtual size : %s\n", get_size (ta_info.virtual_size));
printf_filtered (" Resident size : %s\n", get_size (ta_info.resident_size));
{
thread_array_t thread_list;
ret = task_threads (task, &thread_list, &thread_count);
CHK ("task_info_command: task_threads", ret);
printf_filtered (" Thread count : %d\n", thread_count);
consume_send_rights (thread_list, thread_count);
ret = vm_deallocate (mach_task_self (),
(vm_address_t) thread_list,
(thread_count * sizeof (int)));
CHK ("Error trying to deallocate thread list", ret);
}
if (have_emulator_p (task))
printf_filtered (" Emulator at : 0x%x..0x%x\n",
EMULATOR_BASE, EMULATOR_END);
else
printf_filtered (" No emulator.\n");
if (thread_count && task == inferior_task)
printf_filtered ("\nUse the \"thread list\" command to see the threads\n");
}
static void
exception_command (char *args, int from_tty)
{
char *scan = args;
int exception;
int len;
if (!args)
error_no_arg ("exception number action");
while (*scan == ' ' || *scan == '\t')
scan++;
if ('0' <= *scan && *scan <= '9')
while ('0' <= *scan && *scan <= '9')
scan++;
else
error ("exception number action");
exception = atoi (args);
if (exception <= 0 || exception > MAX_EXCEPTION)
error ("Allowed exception numbers are in range 1..%d",
MAX_EXCEPTION);
if (*scan != ' ' && *scan != '\t')
error ("exception number must be followed by a space");
else
while (*scan == ' ' || *scan == '\t')
scan++;
args = scan;
len = 0;
while (*scan)
{
len++;
scan++;
}
if (!len)
error ("exception number action");
if (!strncasecmp (args, "forward", len))
exception_map[exception].forward = TRUE;
else if (!strncasecmp (args, "keep", len))
exception_map[exception].forward = FALSE;
else
error ("exception action is either \"keep\" or \"forward\"");
}
static void
print_exception_info (int exception)
{
boolean_t forward = exception_map[exception].forward;
printf_filtered ("%s\t(%d): ", exception_map[exception].name,
exception);
if (!forward)
if (exception_map[exception].sigmap != SIG_UNKNOWN)
printf_filtered ("keep and handle as signal %d\n",
exception_map[exception].sigmap);
else
printf_filtered ("keep and handle as unknown signal %d\n",
exception_map[exception].sigmap);
else
printf_filtered ("forward exception to inferior\n");
}
void
exception_info (char *args, int from_tty)
{
int exception;
if (!args)
for (exception = 1; exception <= MAX_EXCEPTION; exception++)
print_exception_info (exception);
else
{
exception = atoi (args);
if (exception <= 0 || exception > MAX_EXCEPTION)
error ("Invalid exception number, values from 1 to %d allowed",
MAX_EXCEPTION);
print_exception_info (exception);
}
}
mach3_exception_actions (WAITTYPE *w, boolean_t force_print_only, char *who)
{
boolean_t force_print = FALSE;
if (force_print_only ||
exception_map[stop_exception].sigmap == SIG_UNKNOWN)
force_print = TRUE;
else
WSETSTOP (*w, exception_map[stop_exception].sigmap);
if (exception_map[stop_exception].print || force_print)
{
target_terminal_ours ();
printf_filtered ("\n%s received %s exception : ",
who,
exception_map[stop_exception].name);
wrap_here (" ");
switch (stop_exception)
{
case EXC_BAD_ACCESS:
printf_filtered ("referencing address 0x%x : %s\n",
stop_subcode,
mach_error_string (stop_code));
break;
case EXC_BAD_INSTRUCTION:
printf_filtered
("illegal or undefined instruction. code %d subcode %d\n",
stop_code, stop_subcode);
break;
case EXC_ARITHMETIC:
printf_filtered ("code %d\n", stop_code);
break;
case EXC_EMULATION:
printf_filtered ("code %d subcode %d\n", stop_code, stop_subcode);
break;
case EXC_SOFTWARE:
printf_filtered ("%s specific, code 0x%x\n",
stop_code < 0xffff ? "hardware" : "os emulation",
stop_code);
break;
case EXC_BREAKPOINT:
printf_filtered ("type %d (machine dependent)\n",
stop_code);
break;
default:
internal_error (__FILE__, __LINE__,
"Unknown exception");
}
}
}
setup_notify_port (int create_new)
{
kern_return_t ret;
if (MACH_PORT_VALID (our_notify_port))
{
ret = mach_port_destroy (mach_task_self (), our_notify_port);
CHK ("Could not destroy our_notify_port", ret);
}
our_notify_port = MACH_PORT_NULL;
notify_chain = (port_chain_t) NULL;
port_chain_destroy (port_chain_obstack);
if (create_new)
{
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&our_notify_port);
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__,
"Creating notify port %s", mach_error_string (ret));
ret = mach_port_move_member (mach_task_self (),
our_notify_port,
inferior_wait_port_set);
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__,
"initial move member %s", mach_error_string (ret));
}
}
char registered_name[MAX_NAME_LEN];
void
message_port_info (char *args, int from_tty)
{
if (registered_name[0])
printf_filtered ("gdb's message port name: '%s'\n",
registered_name);
else
printf_filtered ("gdb's message port is not currently registered\n");
}
void
gdb_register_port (char *name, mach_port_t port)
{
kern_return_t ret;
static int already_signed = 0;
int len;
if (!MACH_PORT_VALID (port) || !name || !*name)
{
warning ("Invalid registration request");
return;
}
if (!already_signed)
{
ret = mach_port_insert_right (mach_task_self (),
our_message_port,
our_message_port,
MACH_MSG_TYPE_MAKE_SEND);
CHK ("Failed to create a signature to our_message_port", ret);
already_signed = 1;
}
else if (already_signed > 1)
{
ret = netname_check_out (name_server_port,
registered_name,
our_message_port);
CHK ("Failed to check out gdb's message port", ret);
registered_name[0] = '\000';
already_signed = 1;
}
ret = netname_check_in (name_server_port,
name,
our_message_port,
port);
CHK ("Failed to check in the port", ret);
len = 0;
while (len < MAX_NAME_LEN && *(name + len))
{
registered_name[len] = *(name + len);
len++;
}
registered_name[len] = '\000';
already_signed = 2;
}
struct cmd_list_element *cmd_thread_list;
struct cmd_list_element *cmd_task_list;
static void
thread_command (char *arg, int from_tty)
{
printf_unfiltered ("\"thread\" must be followed by the name of a thread command.\n");
help_list (cmd_thread_list, "thread ", -1, gdb_stdout);
}
static void
task_command (char *arg, int from_tty)
{
printf_unfiltered ("\"task\" must be followed by the name of a task command.\n");
help_list (cmd_task_list, "task ", -1, gdb_stdout);
}
add_mach_specific_commands (void)
{
add_prefix_cmd ("mthread", class_stack, thread_command,
"Generic command for handling Mach threads in the debugged task.",
&cmd_thread_list, "thread ", 0, &cmdlist);
add_com_alias ("th", "mthread", class_stack, 1);
add_cmd ("select", class_stack, thread_select_command,
"Select and print MID of the selected thread",
&cmd_thread_list);
add_cmd ("list", class_stack, thread_list_command,
"List info of task's threads. Selected thread is marked with '*'",
&cmd_thread_list);
add_cmd ("suspend", class_run, thread_suspend_command,
"Suspend one or all of the threads in the selected task.",
&cmd_thread_list);
add_cmd ("resume", class_run, thread_resume_command,
"Resume one or all of the threads in the selected task.",
&cmd_thread_list);
add_cmd ("kill", class_run, thread_kill_command,
"Kill the specified thread MID from inferior task.",
&cmd_thread_list);
#if 0
add_cmd ("break", class_breakpoint, condition_thread,
"Breakpoint N will only be effective for thread MID or @SLOT\n\
If MID/@SLOT is omitted allow all threads to break at breakpoint",
&cmd_thread_list);
#endif
add_alias_cmd ("ts", "mthread select", 0, 0, &cmdlist);
add_alias_cmd ("tl", "mthread list", 0, 0, &cmdlist);
add_prefix_cmd ("task", class_stack, task_command,
"Generic command for handling debugged task.",
&cmd_task_list, "task ", 0, &cmdlist);
add_com_alias ("ta", "task", class_stack, 1);
add_cmd ("suspend", class_run, task_suspend_command,
"Suspend the inferior task.",
&cmd_task_list);
add_cmd ("resume", class_run, task_resume_command,
"Resume the inferior task.",
&cmd_task_list);
add_cmd ("info", no_class, task_info_command,
"Print information about the specified task.",
&cmd_task_list);
add_info ("message-port", message_port_info,
"Returns the name of gdb's message port in the netnameserver");
add_info ("exceptions", exception_info,
"What debugger does when program gets various exceptions.\n\
Specify an exception number as argument to print info on that\n\
exception only.");
add_com ("exception", class_run, exception_command,
"Specify how to handle an exception.\n\
Args are exception number followed by \"forward\" or \"keep\".\n\
`Forward' means forward the exception to the program's normal exception\n\
handler.\n\
`Keep' means reenter debugger if this exception happens, and GDB maps\n\
the exception to some signal (see info exception)\n\
Normally \"keep\" is used to return to GDB on exception.");
}
kern_return_t
do_mach_notify_dead_name (mach_port_t notify, mach_port_t name)
{
kern_return_t kr = KERN_SUCCESS;
port_chain_t element = port_chain_member (notify_chain, name);
notify_chain = port_chain_delete (notify_chain, name);
if (!element)
error ("Received a dead name notify from unchained port (0x%x)", name);
switch (element->type)
{
case MACH_TYPE_THREAD:
target_terminal_ours_for_output ();
if (name == current_thread)
{
printf_filtered ("\nCurrent thread %d died", element->mid);
current_thread = MACH_PORT_NULL;
}
else
printf_filtered ("\nThread %d died", element->mid);
break;
case MACH_TYPE_TASK:
target_terminal_ours_for_output ();
if (name != inferior_task)
printf_filtered ("Task %d died, but it was not the selected task",
element->mid);
else
{
printf_filtered ("Current task %d died", element->mid);
mach_port_destroy (mach_task_self (), name);
inferior_task = MACH_PORT_NULL;
if (notify_chain)
warning ("There were still unreceived dead_name_notifications???");
setup_notify_port (0);
}
break;
default:
error ("Unregistered dead_name 0x%x notification received. Type is %d, mid is 0x%x",
name, element->type, element->mid);
break;
}
return KERN_SUCCESS;
}
kern_return_t
do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
{
warning ("do_mach_notify_msg_accepted : notify %x, name %x",
notify, name);
return KERN_SUCCESS;
}
kern_return_t
do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t mscount)
{
warning ("do_mach_notify_no_senders : notify %x, mscount %x",
notify, mscount);
return KERN_SUCCESS;
}
kern_return_t
do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
{
warning ("do_mach_notify_port_deleted : notify %x, name %x",
notify, name);
return KERN_SUCCESS;
}
kern_return_t
do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t rights)
{
warning ("do_mach_notify_port_destroyed : notify %x, rights %x",
notify, rights);
return KERN_SUCCESS;
}
kern_return_t
do_mach_notify_send_once (mach_port_t notify)
{
#ifdef DUMP_SYSCALL
warning ("do_mach_notify_send_once : notify %x",
notify);
#endif
return KERN_SUCCESS;
}
static void
kill_inferior_fast (void)
{
WAITTYPE w;
if (PIDGET (inferior_ptid) == 0 || PIDGET (inferior_ptid) == 1)
return;
if (PIDGET (inferior_ptid) > 0)
kill (PIDGET (inferior_ptid), SIGKILL);
(void) task_terminate (inferior_task);
inferior_task = MACH_PORT_NULL;
current_thread = MACH_PORT_NULL;
wait3 (&w, WNOHANG, 0);
setup_notify_port (0);
}
static void
m3_kill_inferior (void)
{
kill_inferior_fast ();
target_mourn_inferior ();
}
static void
m3_mourn_inferior (void)
{
unpush_target (&m3_ops);
generic_mourn_inferior ();
}
static void
m3_create_inferior (char *exec_file, char *allargs, char **env)
{
fork_inferior (exec_file, allargs, env, m3_trace_me, m3_trace_him, NULL, NULL);
proceed ((CORE_ADDR) -1, 0, 0);
}
static int
m3_can_run (void)
{
return 1;
}
ptrace (int a, int b, int c, int d)
{
error ("Lose, Lose! Somebody called ptrace\n");
}
void
m3_resume (ptid_t ptid, int step, enum target_signal signal)
{
kern_return_t ret;
if (step)
{
thread_basic_info_data_t th_info;
unsigned int infoCnt = THREAD_BASIC_INFO_COUNT;
if (!MACH_PORT_VALID (current_thread))
error ("No thread selected; can not single step");
ret = thread_info (current_thread,
THREAD_BASIC_INFO,
(thread_info_t) & th_info,
&infoCnt);
CHK ("child_resume: can't get thread info", ret);
if (th_info.suspend_count)
error ("Can't trace a suspended thread. Use \"thread resume\" command to resume it");
}
vm_read_cache_valid = FALSE;
if (signal && PIDGET (inferior_ptid) > 0)
kill (PIDGET (inferior_ptid), target_signal_to_host (signal));
if (step)
{
suspend_all_threads (0);
setup_single_step (current_thread, TRUE);
ret = thread_resume (current_thread);
CHK ("thread_resume", ret);
}
ret = task_resume (inferior_task);
if (ret == KERN_FAILURE)
warning ("Task was not suspended");
else
CHK ("Resuming task", ret);
while ((ret = task_resume (inferior_task)) == KERN_SUCCESS)
;
}
#ifdef ATTACH_DETACH
void
task_attach (task_t tid)
{
kern_return_t ret;
inferior_task = tid;
ret = task_suspend (inferior_task);
CHK ("task_attach: task_suspend", ret);
must_suspend_thread = 0;
setup_notify_port (1);
request_notify (inferior_task, MACH_NOTIFY_DEAD_NAME, MACH_TYPE_TASK);
setup_exception_port ();
emulator_present = have_emulator_p (inferior_task);
attach_flag = 1;
}
void
attach_to_thread (void)
{
if (select_thread (inferior_task, 0, 1) != KERN_SUCCESS)
error ("Could not select any threads to attach to");
}
mid_attach (int mid)
{
kern_return_t ret;
ret = machid_mach_port (mid_server, mid_auth, mid, &inferior_task);
CHK ("mid_attach: machid_mach_port", ret);
task_attach (inferior_task);
return mid;
}
static int
m3_do_attach (int pid)
{
kern_return_t ret;
if (pid == 0)
error ("MID=0, Debugging the master unix server does not compute");
if (pid == getpid ())
error ("I will debug myself only by mid. (Gdb would suspend itself!)");
if (pid < 0)
{
mid_attach (-(pid));
inferior_ptid = pid_to_ptid (pid);
return PIDGET (inferior_ptid);
}
inferior_task = task_by_pid (pid);
if (!MACH_PORT_VALID (inferior_task))
error ("Cannot map Unix pid %d to Mach task port", pid);
task_attach (inferior_task);
inferior_ptid = pid_to_ptid (pid);
return PIDGET (inferior_ptid);
}
static void
m3_attach (char *args, int from_tty)
{
char *exec_file;
int pid;
if (!args)
error_no_arg ("process-id to attach");
pid = atoi (args);
if (pid == getpid ())
error ("I refuse to debug myself!");
if (from_tty)
{
exec_file = (char *) get_exec_file (0);
if (exec_file)
printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
printf_unfiltered ("Attaching to %s\n",
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
m3_do_attach (pid_to_ptid (pid));
inferior_ptid = pid_to_ptid (pid);
push_target (&m3_ops);
}
void
deallocate_inferior_ports (void)
{
kern_return_t ret;
thread_array_t thread_list;
int thread_count, index;
if (!MACH_PORT_VALID (inferior_task))
return;
ret = task_threads (inferior_task, &thread_list, &thread_count);
if (ret != KERN_SUCCESS)
{
warning ("deallocate_inferior_ports: task_threads",
mach_error_string (ret));
return;
}
for (index = 0; index < thread_count; index++)
{
int rights;
ret = mach_port_get_refs (mach_task_self (),
thread_list[index],
MACH_PORT_RIGHT_SEND,
&rights);
CHK ("deallocate_inferior_ports: get refs", ret);
if (rights > 0)
{
ret = mach_port_mod_refs (mach_task_self (),
thread_list[index],
MACH_PORT_RIGHT_SEND,
-rights);
CHK ("deallocate_inferior_ports: mod refs", ret);
}
}
ret = mach_port_mod_refs (mach_task_self (),
inferior_exception_port,
MACH_PORT_RIGHT_RECEIVE,
-1);
CHK ("deallocate_inferior_ports: cannot get rid of exception port", ret);
ret = mach_port_deallocate (mach_task_self (),
inferior_task);
CHK ("deallocate_task_port: deallocating inferior_task", ret);
current_thread = MACH_PORT_NULL;
inferior_task = MACH_PORT_NULL;
}
static void
m3_do_detach (int signal)
{
kern_return_t ret;
MACH_ERROR_NO_INFERIOR;
if (current_thread != MACH_PORT_NULL)
{
target_prepare_to_store ();
target_store_registers (-1);
}
ret = task_set_special_port (inferior_task,
TASK_EXCEPTION_PORT,
inferior_old_exception_port);
CHK ("task_set_special_port", ret);
setup_notify_port (0);
if (remove_breakpoints ())
warning ("Could not remove breakpoints when detaching");
if (signal && PIDGET (inferior_ptid) > 0)
kill (PIDGET (inferior_ptid), signal);
(void) task_resume (inferior_task);
deallocate_inferior_ports ();
attach_flag = 0;
}
static void
m3_detach (char *args, int from_tty)
{
int siggnal = 0;
if (from_tty)
{
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
printf_unfiltered ("Detaching from program: %s %s\n",
exec_file, target_pid_to_str (inferior_ptid));
gdb_flush (gdb_stdout);
}
if (args)
siggnal = atoi (args);
m3_do_detach (siggnal);
inferior_ptid = null_ptid;
unpush_target (&m3_ops);
}
#endif
static void
m3_prepare_to_store (void)
{
#ifdef CHILD_PREPARE_TO_STORE
CHILD_PREPARE_TO_STORE ();
#endif
}
static void
m3_files_info (struct target_ops *ignore)
{
printf_unfiltered ("\tUsing the running image of %s %s.\n",
attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
}
static void
m3_open (char *arg, int from_tty)
{
error ("Use the \"run\" command to start a Unix child process.");
}
#ifdef DUMP_SYSCALL
#define STR(x) #x
char *bsd1_names[] =
{
"execve",
"fork",
"take_signal",
"sigreturn",
"getrusage",
"chdir",
"chroot",
"open",
"creat",
"mknod",
"link",
"symlink",
"unlink",
"access",
"stat",
"readlink",
"chmod",
"chown",
"utimes",
"truncate",
"rename",
"mkdir",
"rmdir",
"xutimes",
"mount",
"umount",
"acct",
"setquota",
"write_short",
"write_long",
"send_short",
"send_long",
"sendto_short",
"sendto_long",
"select",
"task_by_pid",
"recvfrom_short",
"recvfrom_long",
"setgroups",
"setrlimit",
"sigvec",
"sigstack",
"settimeofday",
"adjtime",
"setitimer",
"sethostname",
"bind",
"accept",
"connect",
"setsockopt",
"getsockopt",
"getsockname",
"getpeername",
"init_process",
"table_set",
"table_get",
"pioctl",
"emulator_error",
"readwrite",
"share_wakeup",
0,
"maprw_request_it",
"maprw_release_it",
"maprw_remap",
"pid_by_task",
};
int bsd1_nnames = sizeof (bsd1_names) / sizeof (bsd1_names[0]);
char *
name_str (int name, char *buf)
{
switch (name)
{
case MACH_MSG_TYPE_BOOLEAN:
return "boolean";
case MACH_MSG_TYPE_INTEGER_16:
return "short";
case MACH_MSG_TYPE_INTEGER_32:
return "long";
case MACH_MSG_TYPE_CHAR:
return "char";
case MACH_MSG_TYPE_BYTE:
return "byte";
case MACH_MSG_TYPE_REAL:
return "real";
case MACH_MSG_TYPE_STRING:
return "string";
default:
sprintf (buf, "%d", name);
return buf;
}
}
char *
id_str (int id, char *buf)
{
char *p;
if (id >= 101000 && id < 101000 + bsd1_nnames)
{
if (p = bsd1_names[id - 101000])
return p;
}
if (id == 102000)
return "psignal_retry";
if (id == 100000)
return "syscall";
sprintf (buf, "%d", id);
return buf;
}
print_msg (mach_msg_header_t *mp)
{
char *fmt_x = "%20s : 0x%08x\n";
char *fmt_d = "%20s : %10d\n";
char *fmt_s = "%20s : %s\n";
char buf[100];
puts_filtered ("\n");
#define pr(fmt,h,x) printf_filtered(fmt,STR(x),(h).x)
pr (fmt_x, (*mp), msgh_bits);
pr (fmt_d, (*mp), msgh_size);
pr (fmt_x, (*mp), msgh_remote_port);
pr (fmt_x, (*mp), msgh_local_port);
pr (fmt_d, (*mp), msgh_kind);
printf_filtered (fmt_s, STR (msgh_id), id_str (mp->msgh_id, buf));
if (debug_level > 1)
{
char *p, *ep, *dp;
int plen;
p = (char *) mp;
ep = p + mp->msgh_size;
p += sizeof (*mp);
for (; p < ep; p += plen)
{
mach_msg_type_t *tp;
mach_msg_type_long_t *tlp;
int name, size, number;
tp = (mach_msg_type_t *) p;
if (tp->msgt_longform)
{
tlp = (mach_msg_type_long_t *) tp;
name = tlp->msgtl_name;
size = tlp->msgtl_size;
number = tlp->msgtl_number;
plen = sizeof (*tlp);
}
else
{
name = tp->msgt_name;
size = tp->msgt_size;
number = tp->msgt_number;
plen = sizeof (*tp);
}
printf_filtered ("name=%-16s size=%2d number=%7d inline=%d long=%d deal=%d\n",
name_str (name, buf), size, number, tp->msgt_inline,
tp->msgt_longform, tp->msgt_deallocate);
dp = p + plen;
if (tp->msgt_inline)
{
int l;
l = size * number / 8;
l = (l + sizeof (long) - 1) & ~((sizeof (long)) - 1);
plen += l;
print_data (dp, size, number);
}
else
{
plen += sizeof (int *);
}
printf_filtered ("plen=%d\n", plen);
}
}
}
print_data (char *p, int size, int number)
{
int *ip;
short *sp;
int i;
switch (size)
{
case 8:
for (i = 0; i < number; i++)
{
printf_filtered (" %02x", p[i]);
}
break;
case 16:
sp = (short *) p;
for (i = 0; i < number; i++)
{
printf_filtered (" %04x", sp[i]);
}
break;
case 32:
ip = (int *) p;
for (i = 0; i < number; i++)
{
printf_filtered (" %08x", ip[i]);
}
break;
}
puts_filtered ("\n");
}
#endif
static void
m3_stop (void)
{
error ("to_stop target function not implemented");
}
static char *
m3_pid_to_exec_file (int pid)
{
error ("to_pid_to_exec_file target function not implemented");
return NULL;
}
static void
init_m3_ops (void)
{
m3_ops.to_shortname = "mach";
m3_ops.to_longname = "Mach child process";
m3_ops.to_doc = "Mach child process (started by the \"run\" command).";
m3_ops.to_open = m3_open;
m3_ops.to_attach = m3_attach;
m3_ops.to_detach = m3_detach;
m3_ops.to_resume = m3_resume;
m3_ops.to_wait = mach_really_wait;
m3_ops.to_fetch_registers = fetch_inferior_registers;
m3_ops.to_store_registers = store_inferior_registers;
m3_ops.to_prepare_to_store = m3_prepare_to_store;
m3_ops.to_xfer_memory = m3_xfer_memory;
m3_ops.to_files_info = m3_files_info;
m3_ops.to_insert_breakpoint = memory_insert_breakpoint;
m3_ops.to_remove_breakpoint = memory_remove_breakpoint;
m3_ops.to_terminal_init = terminal_init_inferior;
m3_ops.to_terminal_inferior = terminal_inferior;
m3_ops.to_terminal_ours_for_output = terminal_ours_for_output;
m3_ops.to_terminal_ours = terminal_ours;
m3_ops.to_terminal_info = child_terminal_info;
m3_ops.to_kill = m3_kill_inferior;
m3_ops.to_create_inferior = m3_create_inferior;
m3_ops.to_mourn_inferior = m3_mourn_inferior;
m3_ops.to_can_run = m3_can_run;
m3_ops.to_stop = m3_stop;
m3_ops.to_pid_to_exec_file = m3_pid_to_exec_file;
m3_ops.to_stratum = process_stratum;
m3_ops.to_has_all_memory = 1;
m3_ops.to_has_memory = 1;
m3_ops.to_has_stack = 1;
m3_ops.to_has_registers = 1;
m3_ops.to_has_execution = 1;
m3_ops.to_magic = OPS_MAGIC;
}
void
_initialize_m3_nat (void)
{
kern_return_t ret;
init_m3_ops ();
add_target (&m3_ops);
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_PORT_SET,
&inferior_wait_port_set);
if (ret != KERN_SUCCESS)
internal_error (__FILE__, __LINE__,
"initial port set %s", mach_error_string (ret));
currently_waiting_for = inferior_wait_port_set;
ret = netname_look_up (name_server_port, hostname, "MachID", &mid_server);
if (ret != KERN_SUCCESS)
{
mid_server = MACH_PORT_NULL;
warning ("initialize machid: netname_lookup_up(MachID) : %s",
mach_error_string (ret));
warning ("Some (most?) features disabled...");
}
mid_auth = mach_privileged_host_port ();
if (mid_auth == MACH_PORT_NULL)
mid_auth = mach_task_self ();
obstack_init (port_chain_obstack);
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&thread_exception_port);
CHK ("Creating thread_exception_port for single stepping", ret);
ret = mach_port_insert_right (mach_task_self (),
thread_exception_port,
thread_exception_port,
MACH_MSG_TYPE_MAKE_SEND);
CHK ("Inserting send right to thread_exception_port", ret);
ret = mach_port_allocate (mach_task_self (),
MACH_PORT_RIGHT_RECEIVE,
&our_message_port);
if (ret != KERN_SUCCESS)
warning ("Creating message port %s", mach_error_string (ret));
else
{
char buf[MAX_NAME_LEN];
ret = mach_port_move_member (mach_task_self (),
our_message_port,
inferior_wait_port_set);
if (ret != KERN_SUCCESS)
warning ("message move member %s", mach_error_string (ret));
sprintf (buf, "gdb-%d", getpid ());
gdb_register_port (buf, our_message_port);
}
obstack_init (cproc_obstack);
add_mach_specific_commands ();
}