/* Darwin support for GDB, the GNU debugger.
|
/* Darwin support for GDB, the GNU debugger.
|
Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
|
Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
|
|
|
Contributed by AdaCore.
|
Contributed by AdaCore.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
*/
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "top.h"
|
#include "top.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "target.h"
|
#include "target.h"
|
#include "symfile.h"
|
#include "symfile.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "objfiles.h"
|
#include "objfiles.h"
|
#include "gdb.h"
|
#include "gdb.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "gdbthread.h"
|
#include "gdbthread.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
#include "event-top.h"
|
#include "event-top.h"
|
#include "inf-loop.h"
|
#include "inf-loop.h"
|
#include "gdb_stat.h"
|
#include "gdb_stat.h"
|
#include "exceptions.h"
|
#include "exceptions.h"
|
#include "inf-child.h"
|
#include "inf-child.h"
|
#include "value.h"
|
#include "value.h"
|
#include "arch-utils.h"
|
#include "arch-utils.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
|
|
#include <sys/ptrace.h>
|
#include <sys/ptrace.h>
|
#include <sys/signal.h>
|
#include <sys/signal.h>
|
#include <machine/setjmp.h>
|
#include <machine/setjmp.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <signal.h>
|
#include <signal.h>
|
#include <string.h>
|
#include <string.h>
|
#include <ctype.h>
|
#include <ctype.h>
|
#include <sys/param.h>
|
#include <sys/param.h>
|
#include <sys/sysctl.h>
|
#include <sys/sysctl.h>
|
#include <sys/proc.h>
|
#include <sys/proc.h>
|
#include <libproc.h>
|
#include <libproc.h>
|
#include <sys/syscall.h>
|
#include <sys/syscall.h>
|
|
|
#include <mach/mach_error.h>
|
#include <mach/mach_error.h>
|
#include <mach/mach_vm.h>
|
#include <mach/mach_vm.h>
|
#include <mach/mach_init.h>
|
#include <mach/mach_init.h>
|
#include <mach/vm_map.h>
|
#include <mach/vm_map.h>
|
#include <mach/task.h>
|
#include <mach/task.h>
|
#include <mach/mach_port.h>
|
#include <mach/mach_port.h>
|
#include <mach/thread_act.h>
|
#include <mach/thread_act.h>
|
#include <mach/port.h>
|
#include <mach/port.h>
|
|
|
#include "darwin-nat.h"
|
#include "darwin-nat.h"
|
|
|
/* Quick overview.
|
/* Quick overview.
|
Darwin kernel is Mach + BSD derived kernel. Note that they share the
|
Darwin kernel is Mach + BSD derived kernel. Note that they share the
|
same memory space and are linked together (ie there is no micro-kernel).
|
same memory space and are linked together (ie there is no micro-kernel).
|
|
|
Although ptrace(2) is available on Darwin, it is not complete. We have
|
Although ptrace(2) is available on Darwin, it is not complete. We have
|
to use Mach calls to read and write memory and to modify registers. We
|
to use Mach calls to read and write memory and to modify registers. We
|
also use Mach to get inferior faults. As we cannot use select(2) or
|
also use Mach to get inferior faults. As we cannot use select(2) or
|
signals with Mach port (the Mach communication channel), signals are
|
signals with Mach port (the Mach communication channel), signals are
|
reported to gdb as an exception. Furthermore we detect death of the
|
reported to gdb as an exception. Furthermore we detect death of the
|
inferior through a Mach notification message. This way we only wait
|
inferior through a Mach notification message. This way we only wait
|
on Mach ports.
|
on Mach ports.
|
|
|
Some Mach documentation is available for Apple xnu source package or
|
Some Mach documentation is available for Apple xnu source package or
|
from the web. */
|
from the web. */
|
|
|
|
|
#define PTRACE(CMD, PID, ADDR, SIG) \
|
#define PTRACE(CMD, PID, ADDR, SIG) \
|
darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
|
darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
|
|
|
extern boolean_t exc_server (mach_msg_header_t *in, mach_msg_header_t *out);
|
extern boolean_t exc_server (mach_msg_header_t *in, mach_msg_header_t *out);
|
|
|
static void darwin_stop (ptid_t);
|
static void darwin_stop (ptid_t);
|
|
|
static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
|
static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
|
enum target_signal signal);
|
enum target_signal signal);
|
static void darwin_resume (ptid_t ptid, int step,
|
static void darwin_resume (ptid_t ptid, int step,
|
enum target_signal signal);
|
enum target_signal signal);
|
|
|
static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
|
static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
|
struct target_waitstatus *status, int options);
|
struct target_waitstatus *status, int options);
|
static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
|
static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
|
|
|
static void darwin_mourn_inferior (struct target_ops *ops);
|
static void darwin_mourn_inferior (struct target_ops *ops);
|
|
|
static void darwin_kill_inferior (struct target_ops *ops);
|
static void darwin_kill_inferior (struct target_ops *ops);
|
|
|
static void darwin_ptrace_me (void);
|
static void darwin_ptrace_me (void);
|
|
|
static void darwin_ptrace_him (int pid);
|
static void darwin_ptrace_him (int pid);
|
|
|
static void darwin_create_inferior (struct target_ops *ops, char *exec_file,
|
static void darwin_create_inferior (struct target_ops *ops, char *exec_file,
|
char *allargs, char **env, int from_tty);
|
char *allargs, char **env, int from_tty);
|
|
|
static void darwin_files_info (struct target_ops *ops);
|
static void darwin_files_info (struct target_ops *ops);
|
|
|
static char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
|
static char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
|
|
|
static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
|
static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
|
|
|
/* Target operations for Darwin. */
|
/* Target operations for Darwin. */
|
static struct target_ops *darwin_ops;
|
static struct target_ops *darwin_ops;
|
|
|
/* Task identifier of gdb. */
|
/* Task identifier of gdb. */
|
static task_t gdb_task;
|
static task_t gdb_task;
|
|
|
/* A copy of mach_host_self (). */
|
/* A copy of mach_host_self (). */
|
mach_port_t darwin_host_self;
|
mach_port_t darwin_host_self;
|
|
|
/* Exception port. */
|
/* Exception port. */
|
mach_port_t darwin_ex_port;
|
mach_port_t darwin_ex_port;
|
|
|
/* Port set. */
|
/* Port set. */
|
mach_port_t darwin_port_set;
|
mach_port_t darwin_port_set;
|
|
|
/* Page size. */
|
/* Page size. */
|
static vm_size_t mach_page_size;
|
static vm_size_t mach_page_size;
|
|
|
/* If Set, catch all mach exceptions (before they are converted to signals
|
/* If Set, catch all mach exceptions (before they are converted to signals
|
by the kernel). */
|
by the kernel). */
|
static int enable_mach_exceptions;
|
static int enable_mach_exceptions;
|
|
|
/* Inferior that should report a fake stop event. */
|
/* Inferior that should report a fake stop event. */
|
static struct inferior *darwin_inf_fake_stop;
|
static struct inferior *darwin_inf_fake_stop;
|
|
|
#define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
|
#define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
|
#define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
|
#define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
|
|
|
/* This controls output of inferior debugging. */
|
/* This controls output of inferior debugging. */
|
static int darwin_debug_flag = 0;
|
static int darwin_debug_flag = 0;
|
|
|
/* Create a __TEXT __info_plist section in the executable so that gdb could
|
/* Create a __TEXT __info_plist section in the executable so that gdb could
|
be signed. This is required to get an authorization for task_for_pid.
|
be signed. This is required to get an authorization for task_for_pid.
|
|
|
Once gdb is built, you can either:
|
Once gdb is built, you can either:
|
* make it setgid procmod
|
* make it setgid procmod
|
* or codesign it with any system-trusted signing authority.
|
* or codesign it with any system-trusted signing authority.
|
See taskgated(8) for details. */
|
See taskgated(8) for details. */
|
static const unsigned char info_plist[]
|
static const unsigned char info_plist[]
|
__attribute__ ((section ("__TEXT,__info_plist"),used)) =
|
__attribute__ ((section ("__TEXT,__info_plist"),used)) =
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
|
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
|
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
|
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
|
" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
|
" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
|
"<plist version=\"1.0\">\n"
|
"<plist version=\"1.0\">\n"
|
"<dict>\n"
|
"<dict>\n"
|
" <key>CFBundleIdentifier</key>\n"
|
" <key>CFBundleIdentifier</key>\n"
|
" <string>org.gnu.gdb</string>\n"
|
" <string>org.gnu.gdb</string>\n"
|
" <key>CFBundleName</key>\n"
|
" <key>CFBundleName</key>\n"
|
" <string>gdb</string>\n"
|
" <string>gdb</string>\n"
|
" <key>CFBundleVersion</key>\n"
|
" <key>CFBundleVersion</key>\n"
|
" <string>1.0</string>\n"
|
" <string>1.0</string>\n"
|
" <key>SecTaskAccess</key>\n"
|
" <key>SecTaskAccess</key>\n"
|
" <array>\n"
|
" <array>\n"
|
" <string>allowed</string>\n"
|
" <string>allowed</string>\n"
|
" <string>debug</string>\n"
|
" <string>debug</string>\n"
|
" </array>\n"
|
" </array>\n"
|
"</dict>\n"
|
"</dict>\n"
|
"</plist>\n";
|
"</plist>\n";
|
|
|
static void
|
static void
|
inferior_debug (int level, const char *fmt, ...)
|
inferior_debug (int level, const char *fmt, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
|
|
if (darwin_debug_flag < level)
|
if (darwin_debug_flag < level)
|
return;
|
return;
|
|
|
va_start (ap, fmt);
|
va_start (ap, fmt);
|
printf_unfiltered (_("[%d inferior]: "), getpid ());
|
printf_unfiltered (_("[%d inferior]: "), getpid ());
|
vprintf_unfiltered (fmt, ap);
|
vprintf_unfiltered (fmt, ap);
|
va_end (ap);
|
va_end (ap);
|
}
|
}
|
|
|
void
|
void
|
mach_check_error (kern_return_t ret, const char *file,
|
mach_check_error (kern_return_t ret, const char *file,
|
unsigned int line, const char *func)
|
unsigned int line, const char *func)
|
{
|
{
|
if (ret == KERN_SUCCESS)
|
if (ret == KERN_SUCCESS)
|
return;
|
return;
|
if (func == NULL)
|
if (func == NULL)
|
func = _("[UNKNOWN]");
|
func = _("[UNKNOWN]");
|
|
|
warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)\n"),
|
warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)\n"),
|
file, line, func, mach_error_string (ret), (unsigned long) ret);
|
file, line, func, mach_error_string (ret), (unsigned long) ret);
|
}
|
}
|
|
|
static const char *
|
static const char *
|
unparse_exception_type (unsigned int i)
|
unparse_exception_type (unsigned int i)
|
{
|
{
|
static char unknown_exception_buf[32];
|
static char unknown_exception_buf[32];
|
|
|
switch (i)
|
switch (i)
|
{
|
{
|
case EXC_BAD_ACCESS:
|
case EXC_BAD_ACCESS:
|
return "EXC_BAD_ACCESS";
|
return "EXC_BAD_ACCESS";
|
case EXC_BAD_INSTRUCTION:
|
case EXC_BAD_INSTRUCTION:
|
return "EXC_BAD_INSTRUCTION";
|
return "EXC_BAD_INSTRUCTION";
|
case EXC_ARITHMETIC:
|
case EXC_ARITHMETIC:
|
return "EXC_ARITHMETIC";
|
return "EXC_ARITHMETIC";
|
case EXC_EMULATION:
|
case EXC_EMULATION:
|
return "EXC_EMULATION";
|
return "EXC_EMULATION";
|
case EXC_SOFTWARE:
|
case EXC_SOFTWARE:
|
return "EXC_SOFTWARE";
|
return "EXC_SOFTWARE";
|
case EXC_BREAKPOINT:
|
case EXC_BREAKPOINT:
|
return "EXC_BREAKPOINT";
|
return "EXC_BREAKPOINT";
|
case EXC_SYSCALL:
|
case EXC_SYSCALL:
|
return "EXC_SYSCALL";
|
return "EXC_SYSCALL";
|
case EXC_MACH_SYSCALL:
|
case EXC_MACH_SYSCALL:
|
return "EXC_MACH_SYSCALL";
|
return "EXC_MACH_SYSCALL";
|
case EXC_RPC_ALERT:
|
case EXC_RPC_ALERT:
|
return "EXC_RPC_ALERT";
|
return "EXC_RPC_ALERT";
|
case EXC_CRASH:
|
case EXC_CRASH:
|
return "EXC_CRASH";
|
return "EXC_CRASH";
|
default:
|
default:
|
snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
|
snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
|
return unknown_exception_buf;
|
return unknown_exception_buf;
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
darwin_ptrace (const char *name,
|
darwin_ptrace (const char *name,
|
int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
|
int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
|
{
|
{
|
int ret;
|
int ret;
|
|
|
ret = ptrace (request, pid, (caddr_t) arg3, arg4);
|
ret = ptrace (request, pid, (caddr_t) arg3, arg4);
|
|
|
inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
|
inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
|
name, pid, arg3, arg4, ret,
|
name, pid, arg3, arg4, ret,
|
(ret != 0) ? safe_strerror (errno) : _("no error"));
|
(ret != 0) ? safe_strerror (errno) : _("no error"));
|
return ret;
|
return ret;
|
}
|
}
|
|
|
static int
|
static int
|
cmp_thread_t (const void *l, const void *r)
|
cmp_thread_t (const void *l, const void *r)
|
{
|
{
|
thread_t tl = *(const thread_t *)l;
|
thread_t tl = *(const thread_t *)l;
|
thread_t tr = *(const thread_t *)r;
|
thread_t tr = *(const thread_t *)r;
|
return (int)(tl - tr);
|
return (int)(tl - tr);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_check_new_threads (struct inferior *inf)
|
darwin_check_new_threads (struct inferior *inf)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
unsigned int i;
|
unsigned int i;
|
thread_array_t thread_list;
|
thread_array_t thread_list;
|
unsigned int new_nbr;
|
unsigned int new_nbr;
|
unsigned int old_nbr;
|
unsigned int old_nbr;
|
unsigned int new_ix, old_ix;
|
unsigned int new_ix, old_ix;
|
darwin_inferior *darwin_inf = inf->private;
|
darwin_inferior *darwin_inf = inf->private;
|
VEC (darwin_thread_t) *thread_vec;
|
VEC (darwin_thread_t) *thread_vec;
|
|
|
/* Get list of threads. */
|
/* Get list of threads. */
|
kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
|
kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
return;
|
return;
|
|
|
/* Sort the list. */
|
/* Sort the list. */
|
if (new_nbr > 1)
|
if (new_nbr > 1)
|
qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
|
qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
|
|
|
if (darwin_inf->threads)
|
if (darwin_inf->threads)
|
old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
|
old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
|
else
|
else
|
old_nbr = 0;
|
old_nbr = 0;
|
|
|
/* Quick check for no changes. */
|
/* Quick check for no changes. */
|
if (old_nbr == new_nbr)
|
if (old_nbr == new_nbr)
|
{
|
{
|
for (i = 0; i < new_nbr; i++)
|
for (i = 0; i < new_nbr; i++)
|
if (thread_list[i]
|
if (thread_list[i]
|
!= VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
|
!= VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
|
break;
|
break;
|
if (i == new_nbr)
|
if (i == new_nbr)
|
{
|
{
|
kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
|
kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
|
new_nbr * sizeof (int));
|
new_nbr * sizeof (int));
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
|
thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
|
|
|
for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
|
for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
|
{
|
{
|
thread_t new_id = (new_ix < new_nbr) ?
|
thread_t new_id = (new_ix < new_nbr) ?
|
thread_list[new_ix] : THREAD_NULL;
|
thread_list[new_ix] : THREAD_NULL;
|
darwin_thread_t *old = (old_ix < old_nbr) ?
|
darwin_thread_t *old = (old_ix < old_nbr) ?
|
VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
|
VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
|
thread_t old_id = old ? old->gdb_port : THREAD_NULL;
|
thread_t old_id = old ? old->gdb_port : THREAD_NULL;
|
|
|
inferior_debug
|
inferior_debug
|
(12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:%x old_id:%x\n"),
|
(12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:%x old_id:%x\n"),
|
new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
|
new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
|
|
|
if (old_id == new_id)
|
if (old_id == new_id)
|
{
|
{
|
/* Thread still exist. */
|
/* Thread still exist. */
|
VEC_safe_push (darwin_thread_t, thread_vec, old);
|
VEC_safe_push (darwin_thread_t, thread_vec, old);
|
new_ix++;
|
new_ix++;
|
old_ix++;
|
old_ix++;
|
|
|
kret = mach_port_deallocate (gdb_task, old_id);
|
kret = mach_port_deallocate (gdb_task, old_id);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
continue;
|
continue;
|
}
|
}
|
if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
|
if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
|
{
|
{
|
/* Ignore dead ports.
|
/* Ignore dead ports.
|
In some weird cases, we might get dead ports. They should
|
In some weird cases, we might get dead ports. They should
|
correspond to dead thread so they could safely be ignored. */
|
correspond to dead thread so they could safely be ignored. */
|
new_ix++;
|
new_ix++;
|
continue;
|
continue;
|
}
|
}
|
if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
|
if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
|
{
|
{
|
/* A thread was created. */
|
/* A thread was created. */
|
struct thread_info *tp;
|
struct thread_info *tp;
|
struct private_thread_info *pti;
|
struct private_thread_info *pti;
|
|
|
pti = XZALLOC (struct private_thread_info);
|
pti = XZALLOC (struct private_thread_info);
|
pti->gdb_port = new_id;
|
pti->gdb_port = new_id;
|
pti->msg_state = DARWIN_RUNNING;
|
pti->msg_state = DARWIN_RUNNING;
|
|
|
/* Add a new thread unless this is the first one ever met. */
|
/* Add a new thread unless this is the first one ever met. */
|
if (!(old_nbr == 0 && new_ix == 0))
|
if (!(old_nbr == 0 && new_ix == 0))
|
tp = add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
|
tp = add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
|
else
|
else
|
{
|
{
|
tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));
|
tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));
|
gdb_assert (tp);
|
gdb_assert (tp);
|
tp->private = pti;
|
tp->private = pti;
|
}
|
}
|
VEC_safe_push (darwin_thread_t, thread_vec, pti);
|
VEC_safe_push (darwin_thread_t, thread_vec, pti);
|
new_ix++;
|
new_ix++;
|
continue;
|
continue;
|
}
|
}
|
if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
|
if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
|
{
|
{
|
/* A thread was removed. */
|
/* A thread was removed. */
|
delete_thread (ptid_build (inf->pid, 0, old_id));
|
delete_thread (ptid_build (inf->pid, 0, old_id));
|
kret = mach_port_deallocate (gdb_task, old_id);
|
kret = mach_port_deallocate (gdb_task, old_id);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
old_ix++;
|
old_ix++;
|
continue;
|
continue;
|
}
|
}
|
gdb_assert (0);
|
gdb_assert (0);
|
}
|
}
|
|
|
if (darwin_inf->threads)
|
if (darwin_inf->threads)
|
VEC_free (darwin_thread_t, darwin_inf->threads);
|
VEC_free (darwin_thread_t, darwin_inf->threads);
|
darwin_inf->threads = thread_vec;
|
darwin_inf->threads = thread_vec;
|
|
|
kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
|
kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
|
new_nbr * sizeof (int));
|
new_nbr * sizeof (int));
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
|
|
static int
|
static int
|
find_inferior_task_it (struct inferior *inf, void *port_ptr)
|
find_inferior_task_it (struct inferior *inf, void *port_ptr)
|
{
|
{
|
return inf->private->task == *(task_t*)port_ptr;
|
return inf->private->task == *(task_t*)port_ptr;
|
}
|
}
|
|
|
static int
|
static int
|
find_inferior_notify_it (struct inferior *inf, void *port_ptr)
|
find_inferior_notify_it (struct inferior *inf, void *port_ptr)
|
{
|
{
|
return inf->private->notify_port == *(task_t*)port_ptr;
|
return inf->private->notify_port == *(task_t*)port_ptr;
|
}
|
}
|
|
|
/* Return an inferior by task port. */
|
/* Return an inferior by task port. */
|
static struct inferior *
|
static struct inferior *
|
darwin_find_inferior_by_task (task_t port)
|
darwin_find_inferior_by_task (task_t port)
|
{
|
{
|
return iterate_over_inferiors (&find_inferior_task_it, &port);
|
return iterate_over_inferiors (&find_inferior_task_it, &port);
|
}
|
}
|
|
|
/* Return an inferior by notification port. */
|
/* Return an inferior by notification port. */
|
static struct inferior *
|
static struct inferior *
|
darwin_find_inferior_by_notify (mach_port_t port)
|
darwin_find_inferior_by_notify (mach_port_t port)
|
{
|
{
|
return iterate_over_inferiors (&find_inferior_notify_it, &port);
|
return iterate_over_inferiors (&find_inferior_notify_it, &port);
|
}
|
}
|
|
|
/* Return a thread by port. */
|
/* Return a thread by port. */
|
static darwin_thread_t *
|
static darwin_thread_t *
|
darwin_find_thread (struct inferior *inf, thread_t thread)
|
darwin_find_thread (struct inferior *inf, thread_t thread)
|
{
|
{
|
darwin_thread_t *t;
|
darwin_thread_t *t;
|
int k;
|
int k;
|
|
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
k++)
|
k++)
|
if (t->gdb_port == thread)
|
if (t->gdb_port == thread)
|
return t;
|
return t;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Suspend (ie stop) an inferior at Mach level. */
|
/* Suspend (ie stop) an inferior at Mach level. */
|
|
|
static void
|
static void
|
darwin_suspend_inferior (struct inferior *inf)
|
darwin_suspend_inferior (struct inferior *inf)
|
{
|
{
|
if (!inf->private->suspended)
|
if (!inf->private->suspended)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
kret = task_suspend (inf->private->task);
|
kret = task_suspend (inf->private->task);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
inf->private->suspended = 1;
|
inf->private->suspended = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Resume an inferior at Mach level. */
|
/* Resume an inferior at Mach level. */
|
|
|
static void
|
static void
|
darwin_resume_inferior (struct inferior *inf)
|
darwin_resume_inferior (struct inferior *inf)
|
{
|
{
|
if (inf->private->suspended)
|
if (inf->private->suspended)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
kret = task_resume (inf->private->task);
|
kret = task_resume (inf->private->task);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
inf->private->suspended = 0;
|
inf->private->suspended = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Iterator functions. */
|
/* Iterator functions. */
|
|
|
static int
|
static int
|
darwin_suspend_inferior_it (struct inferior *inf, void *arg)
|
darwin_suspend_inferior_it (struct inferior *inf, void *arg)
|
{
|
{
|
darwin_suspend_inferior (inf);
|
darwin_suspend_inferior (inf);
|
darwin_check_new_threads (inf);
|
darwin_check_new_threads (inf);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static int
|
static int
|
darwin_resume_inferior_it (struct inferior *inf, void *arg)
|
darwin_resume_inferior_it (struct inferior *inf, void *arg)
|
{
|
{
|
darwin_resume_inferior (inf);
|
darwin_resume_inferior (inf);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
|
darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
|
{
|
{
|
printf_unfiltered (_("message header:\n"));
|
printf_unfiltered (_("message header:\n"));
|
printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
|
printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
|
printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
|
printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
|
printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
|
printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
|
printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
|
printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
|
printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
|
printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
|
printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
|
printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
|
|
|
if (disp_body)
|
if (disp_body)
|
{
|
{
|
const unsigned char *data;
|
const unsigned char *data;
|
const unsigned long *ldata;
|
const unsigned long *ldata;
|
int size;
|
int size;
|
int i;
|
int i;
|
|
|
data = (unsigned char *)(hdr + 1);
|
data = (unsigned char *)(hdr + 1);
|
size = hdr->msgh_size - sizeof (mach_msg_header_t);
|
size = hdr->msgh_size - sizeof (mach_msg_header_t);
|
|
|
if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
|
if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
|
{
|
{
|
mach_msg_body_t *bod = (mach_msg_body_t*)data;
|
mach_msg_body_t *bod = (mach_msg_body_t*)data;
|
mach_msg_port_descriptor_t *desc =
|
mach_msg_port_descriptor_t *desc =
|
(mach_msg_port_descriptor_t *)(bod + 1);
|
(mach_msg_port_descriptor_t *)(bod + 1);
|
int k;
|
int k;
|
NDR_record_t *ndr;
|
NDR_record_t *ndr;
|
printf_unfiltered (_("body: descriptor_count=%u\n"),
|
printf_unfiltered (_("body: descriptor_count=%u\n"),
|
bod->msgh_descriptor_count);
|
bod->msgh_descriptor_count);
|
data += sizeof (mach_msg_body_t);
|
data += sizeof (mach_msg_body_t);
|
size -= sizeof (mach_msg_body_t);
|
size -= sizeof (mach_msg_body_t);
|
for (k = 0; k < bod->msgh_descriptor_count; k++)
|
for (k = 0; k < bod->msgh_descriptor_count; k++)
|
switch (desc[k].type)
|
switch (desc[k].type)
|
{
|
{
|
case MACH_MSG_PORT_DESCRIPTOR:
|
case MACH_MSG_PORT_DESCRIPTOR:
|
printf_unfiltered
|
printf_unfiltered
|
(_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
|
(_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
|
k, desc[k].type, desc[k].name, desc[k].disposition);
|
k, desc[k].type, desc[k].name, desc[k].disposition);
|
break;
|
break;
|
default:
|
default:
|
printf_unfiltered (_(" descr %d: type=%u\n"),
|
printf_unfiltered (_(" descr %d: type=%u\n"),
|
k, desc[k].type);
|
k, desc[k].type);
|
break;
|
break;
|
}
|
}
|
data += bod->msgh_descriptor_count
|
data += bod->msgh_descriptor_count
|
* sizeof (mach_msg_port_descriptor_t);
|
* sizeof (mach_msg_port_descriptor_t);
|
size -= bod->msgh_descriptor_count
|
size -= bod->msgh_descriptor_count
|
* sizeof (mach_msg_port_descriptor_t);
|
* sizeof (mach_msg_port_descriptor_t);
|
ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
|
ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
|
printf_unfiltered
|
printf_unfiltered
|
(_("NDR: mig=%02x if=%02x encod=%02x "
|
(_("NDR: mig=%02x if=%02x encod=%02x "
|
"int=%02x char=%02x float=%02x\n"),
|
"int=%02x char=%02x float=%02x\n"),
|
ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
|
ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
|
ndr->int_rep, ndr->char_rep, ndr->float_rep);
|
ndr->int_rep, ndr->char_rep, ndr->float_rep);
|
data += sizeof (NDR_record_t);
|
data += sizeof (NDR_record_t);
|
size -= sizeof (NDR_record_t);
|
size -= sizeof (NDR_record_t);
|
}
|
}
|
|
|
printf_unfiltered (_(" data:"));
|
printf_unfiltered (_(" data:"));
|
ldata = (const unsigned long *)data;
|
ldata = (const unsigned long *)data;
|
for (i = 0; i < size / sizeof (unsigned long); i++)
|
for (i = 0; i < size / sizeof (unsigned long); i++)
|
printf_unfiltered (" %08lx", ldata[i]);
|
printf_unfiltered (" %08lx", ldata[i]);
|
printf_unfiltered (_("\n"));
|
printf_unfiltered (_("\n"));
|
}
|
}
|
}
|
}
|
|
|
static int
|
static int
|
darwin_decode_exception_message (mach_msg_header_t *hdr,
|
darwin_decode_exception_message (mach_msg_header_t *hdr,
|
struct inferior **pinf,
|
struct inferior **pinf,
|
darwin_thread_t **pthread)
|
darwin_thread_t **pthread)
|
{
|
{
|
mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
|
mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
|
mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
|
mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
|
NDR_record_t *ndr;
|
NDR_record_t *ndr;
|
integer_t *data;
|
integer_t *data;
|
struct inferior *inf;
|
struct inferior *inf;
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
task_t task_port;
|
task_t task_port;
|
thread_t thread_port;
|
thread_t thread_port;
|
kern_return_t kret;
|
kern_return_t kret;
|
int i;
|
int i;
|
|
|
/* Check message identifier. 2401 is exc. */
|
/* Check message identifier. 2401 is exc. */
|
if (hdr->msgh_id != 2401)
|
if (hdr->msgh_id != 2401)
|
return -1;
|
return -1;
|
|
|
/* Check message header. */
|
/* Check message header. */
|
if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
|
if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
|
return -1;
|
return -1;
|
|
|
/* Check descriptors. */
|
/* Check descriptors. */
|
if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
|
if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
|
+ sizeof (*ndr) + 2 * sizeof (integer_t))
|
+ sizeof (*ndr) + 2 * sizeof (integer_t))
|
|| bod->msgh_descriptor_count != 2
|
|| bod->msgh_descriptor_count != 2
|
|| desc[0].type != MACH_MSG_PORT_DESCRIPTOR
|
|| desc[0].type != MACH_MSG_PORT_DESCRIPTOR
|
|| desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
|
|| desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
|
|| desc[1].type != MACH_MSG_PORT_DESCRIPTOR
|
|| desc[1].type != MACH_MSG_PORT_DESCRIPTOR
|
|| desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
|
|| desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
|
return -1;
|
return -1;
|
|
|
/* Check data representation. */
|
/* Check data representation. */
|
ndr = (NDR_record_t *)(desc + 2);
|
ndr = (NDR_record_t *)(desc + 2);
|
if (ndr->mig_vers != NDR_PROTOCOL_2_0
|
if (ndr->mig_vers != NDR_PROTOCOL_2_0
|
|| ndr->if_vers != NDR_PROTOCOL_2_0
|
|| ndr->if_vers != NDR_PROTOCOL_2_0
|
|| ndr->mig_encoding != NDR_record.mig_encoding
|
|| ndr->mig_encoding != NDR_record.mig_encoding
|
|| ndr->int_rep != NDR_record.int_rep
|
|| ndr->int_rep != NDR_record.int_rep
|
|| ndr->char_rep != NDR_record.char_rep
|
|| ndr->char_rep != NDR_record.char_rep
|
|| ndr->float_rep != NDR_record.float_rep)
|
|| ndr->float_rep != NDR_record.float_rep)
|
return -1;
|
return -1;
|
|
|
/* Ok, the hard work. */
|
/* Ok, the hard work. */
|
data = (integer_t *)(ndr + 1);
|
data = (integer_t *)(ndr + 1);
|
|
|
/* Find process by port. */
|
/* Find process by port. */
|
task_port = desc[1].name;
|
task_port = desc[1].name;
|
thread_port = desc[0].name;
|
thread_port = desc[0].name;
|
inf = darwin_find_inferior_by_task (task_port);
|
inf = darwin_find_inferior_by_task (task_port);
|
if (inf == NULL)
|
if (inf == NULL)
|
return -1;
|
return -1;
|
*pinf = inf;
|
*pinf = inf;
|
|
|
/* Find thread by port. */
|
/* Find thread by port. */
|
/* Check for new threads. Do it early so that the port in the exception
|
/* Check for new threads. Do it early so that the port in the exception
|
message can be deallocated. */
|
message can be deallocated. */
|
darwin_check_new_threads (inf);
|
darwin_check_new_threads (inf);
|
|
|
/* We got new rights to the task and the thread. Get rid of them. */
|
/* We got new rights to the task and the thread. Get rid of them. */
|
kret = mach_port_deallocate (mach_task_self (), task_port);
|
kret = mach_port_deallocate (mach_task_self (), task_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
kret = mach_port_deallocate (mach_task_self (), thread_port);
|
kret = mach_port_deallocate (mach_task_self (), thread_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
thread = darwin_find_thread (inf, thread_port);
|
thread = darwin_find_thread (inf, thread_port);
|
if (thread == NULL)
|
if (thread == NULL)
|
return -1;
|
return -1;
|
*pthread = thread;
|
*pthread = thread;
|
|
|
/* Finish decoding. */
|
/* Finish decoding. */
|
gdb_assert (thread->msg_state == DARWIN_RUNNING);
|
gdb_assert (thread->msg_state == DARWIN_RUNNING);
|
thread->event.header = *hdr;
|
thread->event.header = *hdr;
|
thread->event.thread_port = thread_port;
|
thread->event.thread_port = thread_port;
|
thread->event.task_port = task_port;
|
thread->event.task_port = task_port;
|
thread->event.ex_type = data[0];
|
thread->event.ex_type = data[0];
|
thread->event.data_count = data[1];
|
thread->event.data_count = data[1];
|
|
|
if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
|
if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
|
+ sizeof (*ndr) + 2 * sizeof (integer_t)
|
+ sizeof (*ndr) + 2 * sizeof (integer_t)
|
+ data[1] * sizeof (integer_t)))
|
+ data[1] * sizeof (integer_t)))
|
return -1;
|
return -1;
|
for (i = 0; i < data[1]; i++)
|
for (i = 0; i < data[1]; i++)
|
thread->event.ex_data[i] = data[2 + i];
|
thread->event.ex_data[i] = data[2 + i];
|
|
|
thread->msg_state = DARWIN_MESSAGE;
|
thread->msg_state = DARWIN_MESSAGE;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
|
darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
|
integer_t code)
|
integer_t code)
|
{
|
{
|
mach_msg_header_t *rh = &reply->Head;
|
mach_msg_header_t *rh = &reply->Head;
|
rh->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(hdr->msgh_bits), 0);
|
rh->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(hdr->msgh_bits), 0);
|
rh->msgh_remote_port = hdr->msgh_remote_port;
|
rh->msgh_remote_port = hdr->msgh_remote_port;
|
rh->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
|
rh->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
|
rh->msgh_local_port = MACH_PORT_NULL;
|
rh->msgh_local_port = MACH_PORT_NULL;
|
rh->msgh_id = hdr->msgh_id + 100;
|
rh->msgh_id = hdr->msgh_id + 100;
|
|
|
reply->NDR = NDR_record;
|
reply->NDR = NDR_record;
|
reply->RetCode = code;
|
reply->RetCode = code;
|
}
|
}
|
|
|
static void
|
static void
|
darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
|
darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
mig_reply_error_t reply;
|
mig_reply_error_t reply;
|
|
|
darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
|
darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
|
|
|
kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
|
kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
|
reply.Head.msgh_size, 0,
|
reply.Head.msgh_size, 0,
|
MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
|
MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
|
MACH_PORT_NULL);
|
MACH_PORT_NULL);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
inf->private->pending_messages--;
|
inf->private->pending_messages--;
|
}
|
}
|
|
|
static void
|
static void
|
darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
|
darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
|
int step, int nsignal)
|
int step, int nsignal)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
int res;
|
int res;
|
|
|
inferior_debug
|
inferior_debug
|
(3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
|
(3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
|
thread->msg_state, thread->gdb_port, step, nsignal);
|
thread->msg_state, thread->gdb_port, step, nsignal);
|
|
|
switch (thread->msg_state)
|
switch (thread->msg_state)
|
{
|
{
|
case DARWIN_MESSAGE:
|
case DARWIN_MESSAGE:
|
if (thread->event.ex_type == EXC_SOFTWARE
|
if (thread->event.ex_type == EXC_SOFTWARE
|
&& thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
|
&& thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
|
{
|
{
|
/* Either deliver a new signal or cancel the signal received. */
|
/* Either deliver a new signal or cancel the signal received. */
|
res = PTRACE (PT_THUPDATE, inf->pid,
|
res = PTRACE (PT_THUPDATE, inf->pid,
|
(void *)(uintptr_t)thread->gdb_port, nsignal);
|
(void *)(uintptr_t)thread->gdb_port, nsignal);
|
if (res < 0)
|
if (res < 0)
|
inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
|
inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
|
}
|
}
|
else if (nsignal)
|
else if (nsignal)
|
{
|
{
|
/* Note: ptrace is allowed only if the process is stopped.
|
/* Note: ptrace is allowed only if the process is stopped.
|
Directly send the signal to the thread. */
|
Directly send the signal to the thread. */
|
res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
|
res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
|
inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
|
inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
|
thread->gdb_port, nsignal, res);
|
thread->gdb_port, nsignal, res);
|
thread->signaled = 1;
|
thread->signaled = 1;
|
}
|
}
|
|
|
/* Set single step. */
|
/* Set single step. */
|
inferior_debug (4, _("darwin_set_sstep (thread=%x, enable=%d)\n"),
|
inferior_debug (4, _("darwin_set_sstep (thread=%x, enable=%d)\n"),
|
thread->gdb_port, step);
|
thread->gdb_port, step);
|
darwin_set_sstep (thread->gdb_port, step);
|
darwin_set_sstep (thread->gdb_port, step);
|
thread->single_step = step;
|
thread->single_step = step;
|
|
|
darwin_send_reply (inf, thread);
|
darwin_send_reply (inf, thread);
|
thread->msg_state = DARWIN_RUNNING;
|
thread->msg_state = DARWIN_RUNNING;
|
break;
|
break;
|
|
|
case DARWIN_RUNNING:
|
case DARWIN_RUNNING:
|
break;
|
break;
|
|
|
case DARWIN_STOPPED:
|
case DARWIN_STOPPED:
|
kret = thread_resume (thread->gdb_port);
|
kret = thread_resume (thread->gdb_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
thread->msg_state = DARWIN_RUNNING;
|
thread->msg_state = DARWIN_RUNNING;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Resume all threads of the inferior. */
|
/* Resume all threads of the inferior. */
|
|
|
static void
|
static void
|
darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
|
darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
|
{
|
{
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
int k;
|
int k;
|
|
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
|
k++)
|
k++)
|
darwin_resume_thread (inf, thread, step, nsignal);
|
darwin_resume_thread (inf, thread, step, nsignal);
|
}
|
}
|
|
|
struct resume_inferior_threads_param
|
struct resume_inferior_threads_param
|
{
|
{
|
int step;
|
int step;
|
int nsignal;
|
int nsignal;
|
};
|
};
|
|
|
static int
|
static int
|
darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
|
darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
|
{
|
{
|
int step = ((struct resume_inferior_threads_param *)param)->step;
|
int step = ((struct resume_inferior_threads_param *)param)->step;
|
int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
|
int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
|
|
|
darwin_resume_inferior_threads (inf, step, nsignal);
|
darwin_resume_inferior_threads (inf, step, nsignal);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Suspend all threads of INF. */
|
/* Suspend all threads of INF. */
|
|
|
static void
|
static void
|
darwin_suspend_inferior_threads (struct inferior *inf)
|
darwin_suspend_inferior_threads (struct inferior *inf)
|
{
|
{
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
kern_return_t kret;
|
kern_return_t kret;
|
int k;
|
int k;
|
|
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
|
k++)
|
k++)
|
switch (thread->msg_state)
|
switch (thread->msg_state)
|
{
|
{
|
case DARWIN_STOPPED:
|
case DARWIN_STOPPED:
|
case DARWIN_MESSAGE:
|
case DARWIN_MESSAGE:
|
break;
|
break;
|
case DARWIN_RUNNING:
|
case DARWIN_RUNNING:
|
kret = thread_suspend (thread->gdb_port);
|
kret = thread_suspend (thread->gdb_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
thread->msg_state = DARWIN_STOPPED;
|
thread->msg_state = DARWIN_STOPPED;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
darwin_resume (ptid_t ptid, int step, enum target_signal signal)
|
darwin_resume (ptid_t ptid, int step, enum target_signal signal)
|
{
|
{
|
struct target_waitstatus status;
|
struct target_waitstatus status;
|
int pid;
|
int pid;
|
|
|
kern_return_t kret;
|
kern_return_t kret;
|
int res;
|
int res;
|
int nsignal;
|
int nsignal;
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
inferior_debug
|
inferior_debug
|
(2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
|
(2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
|
ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
|
ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
|
|
|
if (signal == TARGET_SIGNAL_0)
|
if (signal == TARGET_SIGNAL_0)
|
nsignal = 0;
|
nsignal = 0;
|
else
|
else
|
nsignal = target_signal_to_host (signal);
|
nsignal = target_signal_to_host (signal);
|
|
|
/* Don't try to single step all threads. */
|
/* Don't try to single step all threads. */
|
if (step)
|
if (step)
|
ptid = inferior_ptid;
|
ptid = inferior_ptid;
|
|
|
/* minus_one_ptid is RESUME_ALL. */
|
/* minus_one_ptid is RESUME_ALL. */
|
if (ptid_equal (ptid, minus_one_ptid))
|
if (ptid_equal (ptid, minus_one_ptid))
|
{
|
{
|
struct resume_inferior_threads_param param;
|
struct resume_inferior_threads_param param;
|
|
|
param.nsignal = nsignal;
|
param.nsignal = nsignal;
|
param.step = step;
|
param.step = step;
|
|
|
/* Resume threads. */
|
/* Resume threads. */
|
iterate_over_inferiors (darwin_resume_inferior_threads_it, ¶m);
|
iterate_over_inferiors (darwin_resume_inferior_threads_it, ¶m);
|
/* Resume tasks. */
|
/* Resume tasks. */
|
iterate_over_inferiors (darwin_resume_inferior_it, NULL);
|
iterate_over_inferiors (darwin_resume_inferior_it, NULL);
|
}
|
}
|
else
|
else
|
{
|
{
|
struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
|
struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
|
long tid = ptid_get_tid (ptid);
|
long tid = ptid_get_tid (ptid);
|
|
|
/* Stop the inferior (should be useless). */
|
/* Stop the inferior (should be useless). */
|
darwin_suspend_inferior (inf);
|
darwin_suspend_inferior (inf);
|
|
|
if (tid == 0)
|
if (tid == 0)
|
darwin_resume_inferior_threads (inf, step, nsignal);
|
darwin_resume_inferior_threads (inf, step, nsignal);
|
else
|
else
|
{
|
{
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
|
|
/* Suspend threads of the task. */
|
/* Suspend threads of the task. */
|
darwin_suspend_inferior_threads (inf);
|
darwin_suspend_inferior_threads (inf);
|
|
|
/* Resume the selected thread. */
|
/* Resume the selected thread. */
|
thread = darwin_find_thread (inf, tid);
|
thread = darwin_find_thread (inf, tid);
|
gdb_assert (thread);
|
gdb_assert (thread);
|
darwin_resume_thread (inf, thread, step, nsignal);
|
darwin_resume_thread (inf, thread, step, nsignal);
|
}
|
}
|
|
|
/* Resume the task. */
|
/* Resume the task. */
|
darwin_resume_inferior (inf);
|
darwin_resume_inferior (inf);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
|
darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
|
enum target_signal signal)
|
enum target_signal signal)
|
{
|
{
|
return darwin_resume (ptid, step, signal);
|
return darwin_resume (ptid, step, signal);
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
darwin_decode_message (mach_msg_header_t *hdr,
|
darwin_decode_message (mach_msg_header_t *hdr,
|
darwin_thread_t **pthread,
|
darwin_thread_t **pthread,
|
struct inferior **pinf,
|
struct inferior **pinf,
|
struct target_waitstatus *status)
|
struct target_waitstatus *status)
|
{
|
{
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
/* Exception message. */
|
/* Exception message. */
|
if (hdr->msgh_local_port == darwin_ex_port)
|
if (hdr->msgh_local_port == darwin_ex_port)
|
{
|
{
|
int res;
|
int res;
|
|
|
/* Decode message. */
|
/* Decode message. */
|
res = darwin_decode_exception_message (hdr, &inf, &thread);
|
res = darwin_decode_exception_message (hdr, &inf, &thread);
|
|
|
if (res < 0)
|
if (res < 0)
|
{
|
{
|
/* Should not happen... */
|
/* Should not happen... */
|
printf_unfiltered (_("darwin_wait: ill-formatted message (id=%x)\n"),
|
printf_unfiltered (_("darwin_wait: ill-formatted message (id=%x)\n"),
|
hdr->msgh_id);
|
hdr->msgh_id);
|
/* FIXME: send a failure reply? */
|
/* FIXME: send a failure reply? */
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
*pinf = inf;
|
*pinf = inf;
|
*pthread = thread;
|
*pthread = thread;
|
inf->private->pending_messages++;
|
inf->private->pending_messages++;
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
thread->msg_state = DARWIN_MESSAGE;
|
thread->msg_state = DARWIN_MESSAGE;
|
|
|
inferior_debug (4, _("darwin_wait: thread=%x, got %s\n"),
|
inferior_debug (4, _("darwin_wait: thread=%x, got %s\n"),
|
thread->gdb_port,
|
thread->gdb_port,
|
unparse_exception_type (thread->event.ex_type));
|
unparse_exception_type (thread->event.ex_type));
|
|
|
switch (thread->event.ex_type)
|
switch (thread->event.ex_type)
|
{
|
{
|
case EXC_BAD_ACCESS:
|
case EXC_BAD_ACCESS:
|
status->value.sig = TARGET_EXC_BAD_ACCESS;
|
status->value.sig = TARGET_EXC_BAD_ACCESS;
|
break;
|
break;
|
case EXC_BAD_INSTRUCTION:
|
case EXC_BAD_INSTRUCTION:
|
status->value.sig = TARGET_EXC_BAD_INSTRUCTION;
|
status->value.sig = TARGET_EXC_BAD_INSTRUCTION;
|
break;
|
break;
|
case EXC_ARITHMETIC:
|
case EXC_ARITHMETIC:
|
status->value.sig = TARGET_EXC_ARITHMETIC;
|
status->value.sig = TARGET_EXC_ARITHMETIC;
|
break;
|
break;
|
case EXC_EMULATION:
|
case EXC_EMULATION:
|
status->value.sig = TARGET_EXC_EMULATION;
|
status->value.sig = TARGET_EXC_EMULATION;
|
break;
|
break;
|
case EXC_SOFTWARE:
|
case EXC_SOFTWARE:
|
if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
|
if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
|
{
|
{
|
status->value.sig =
|
status->value.sig =
|
target_signal_from_host (thread->event.ex_data[1]);
|
target_signal_from_host (thread->event.ex_data[1]);
|
inferior_debug (5, _(" (signal %d: %s)\n"),
|
inferior_debug (5, _(" (signal %d: %s)\n"),
|
thread->event.ex_data[1],
|
thread->event.ex_data[1],
|
target_signal_to_name (status->value.sig));
|
target_signal_to_name (status->value.sig));
|
|
|
/* If the thread is stopped because it has received a signal
|
/* If the thread is stopped because it has received a signal
|
that gdb has just sent, continue. */
|
that gdb has just sent, continue. */
|
if (thread->signaled)
|
if (thread->signaled)
|
{
|
{
|
thread->signaled = 0;
|
thread->signaled = 0;
|
darwin_send_reply (inf, thread);
|
darwin_send_reply (inf, thread);
|
thread->msg_state = DARWIN_RUNNING;
|
thread->msg_state = DARWIN_RUNNING;
|
status->kind = TARGET_WAITKIND_IGNORE;
|
status->kind = TARGET_WAITKIND_IGNORE;
|
}
|
}
|
}
|
}
|
else
|
else
|
status->value.sig = TARGET_EXC_SOFTWARE;
|
status->value.sig = TARGET_EXC_SOFTWARE;
|
break;
|
break;
|
case EXC_BREAKPOINT:
|
case EXC_BREAKPOINT:
|
/* Many internal GDB routines expect breakpoints to be reported
|
/* Many internal GDB routines expect breakpoints to be reported
|
as TARGET_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
|
as TARGET_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
|
as a spurious signal. */
|
as a spurious signal. */
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
break;
|
break;
|
default:
|
default:
|
status->value.sig = TARGET_SIGNAL_UNKNOWN;
|
status->value.sig = TARGET_SIGNAL_UNKNOWN;
|
break;
|
break;
|
}
|
}
|
|
|
return ptid_build (inf->pid, 0, thread->gdb_port);
|
return ptid_build (inf->pid, 0, thread->gdb_port);
|
}
|
}
|
|
|
*pinf = NULL;
|
*pinf = NULL;
|
*pthread = NULL;
|
*pthread = NULL;
|
|
|
inf = darwin_find_inferior_by_notify (hdr->msgh_local_port);
|
inf = darwin_find_inferior_by_notify (hdr->msgh_local_port);
|
if (inf != NULL)
|
if (inf != NULL)
|
{
|
{
|
if (!inf->private->no_ptrace)
|
if (!inf->private->no_ptrace)
|
{
|
{
|
pid_t res;
|
pid_t res;
|
int wstatus;
|
int wstatus;
|
|
|
res = wait4 (inf->pid, &wstatus, 0, NULL);
|
res = wait4 (inf->pid, &wstatus, 0, NULL);
|
if (res < 0 || res != inf->pid)
|
if (res < 0 || res != inf->pid)
|
{
|
{
|
printf_unfiltered (_("wait4: res=%d: %s\n"),
|
printf_unfiltered (_("wait4: res=%d: %s\n"),
|
res, safe_strerror (errno));
|
res, safe_strerror (errno));
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
if (WIFEXITED (wstatus))
|
if (WIFEXITED (wstatus))
|
{
|
{
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->value.integer = WEXITSTATUS (wstatus);
|
status->value.integer = WEXITSTATUS (wstatus);
|
}
|
}
|
else
|
else
|
{
|
{
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
status->value.sig = WTERMSIG (wstatus);
|
status->value.sig = WTERMSIG (wstatus);
|
}
|
}
|
|
|
inferior_debug (4, _("darwin_wait: pid=%d exit, status=%x\n"),
|
inferior_debug (4, _("darwin_wait: pid=%d exit, status=%x\n"),
|
res, wstatus);
|
res, wstatus);
|
|
|
/* Looks necessary on Leopard and harmless... */
|
/* Looks necessary on Leopard and harmless... */
|
wait4 (inf->pid, &wstatus, 0, NULL);
|
wait4 (inf->pid, &wstatus, 0, NULL);
|
|
|
return ptid_build (inf->pid, 0, 0);
|
return ptid_build (inf->pid, 0, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
|
inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->value.integer = 0; /* Don't know. */
|
status->value.integer = 0; /* Don't know. */
|
return ptid_build (inf->pid, 0, 0);
|
return ptid_build (inf->pid, 0, 0);
|
}
|
}
|
}
|
}
|
|
|
printf_unfiltered (_("Bad local-port: %x\n"), hdr->msgh_local_port);
|
printf_unfiltered (_("Bad local-port: %x\n"), hdr->msgh_local_port);
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
static int
|
static int
|
cancel_breakpoint (ptid_t ptid)
|
cancel_breakpoint (ptid_t ptid)
|
{
|
{
|
/* Arrange for a breakpoint to be hit again later. We will handle
|
/* Arrange for a breakpoint to be hit again later. We will handle
|
the current event, eventually we will resume this thread, and this
|
the current event, eventually we will resume this thread, and this
|
breakpoint will trap again.
|
breakpoint will trap again.
|
|
|
If we do not do this, then we run the risk that the user will
|
If we do not do this, then we run the risk that the user will
|
delete or disable the breakpoint, but the thread will have already
|
delete or disable the breakpoint, but the thread will have already
|
tripped on it. */
|
tripped on it. */
|
|
|
struct regcache *regcache = get_thread_regcache (ptid);
|
struct regcache *regcache = get_thread_regcache (ptid);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
|
|
pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
|
pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
|
{
|
{
|
inferior_debug (4, "cancel_breakpoint for thread %x\n",
|
inferior_debug (4, "cancel_breakpoint for thread %x\n",
|
ptid_get_tid (ptid));
|
ptid_get_tid (ptid));
|
|
|
/* Back up the PC if necessary. */
|
/* Back up the PC if necessary. */
|
if (gdbarch_decr_pc_after_break (gdbarch))
|
if (gdbarch_decr_pc_after_break (gdbarch))
|
regcache_write_pc (regcache, pc);
|
regcache_write_pc (regcache, pc);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
darwin_wait (ptid_t ptid, struct target_waitstatus *status)
|
darwin_wait (ptid_t ptid, struct target_waitstatus *status)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
union
|
union
|
{
|
{
|
mach_msg_header_t hdr;
|
mach_msg_header_t hdr;
|
char data[0x100];
|
char data[0x100];
|
} msgin;
|
} msgin;
|
mach_msg_header_t *hdr = &msgin.hdr;
|
mach_msg_header_t *hdr = &msgin.hdr;
|
ptid_t res;
|
ptid_t res;
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
struct inferior *inf;
|
struct inferior *inf;
|
|
|
inferior_debug
|
inferior_debug
|
(2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
|
(2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
|
ptid_get_pid (ptid), ptid_get_tid (ptid));
|
ptid_get_pid (ptid), ptid_get_tid (ptid));
|
|
|
/* Handle fake stop events at first. */
|
/* Handle fake stop events at first. */
|
if (darwin_inf_fake_stop != NULL)
|
if (darwin_inf_fake_stop != NULL)
|
{
|
{
|
inf = darwin_inf_fake_stop;
|
inf = darwin_inf_fake_stop;
|
darwin_inf_fake_stop = NULL;
|
darwin_inf_fake_stop = NULL;
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
|
thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
|
thread->msg_state = DARWIN_STOPPED;
|
thread->msg_state = DARWIN_STOPPED;
|
return ptid_build (inf->pid, 0, thread->gdb_port);
|
return ptid_build (inf->pid, 0, thread->gdb_port);
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
/* set_sigint_trap (); */
|
/* set_sigint_trap (); */
|
|
|
/* Wait for a message. */
|
/* Wait for a message. */
|
kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
|
kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
|
sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
|
sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
|
|
|
/* clear_sigint_trap (); */
|
/* clear_sigint_trap (); */
|
|
|
if (kret == MACH_RCV_INTERRUPTED)
|
if (kret == MACH_RCV_INTERRUPTED)
|
{
|
{
|
status->kind = TARGET_WAITKIND_IGNORE;
|
status->kind = TARGET_WAITKIND_IGNORE;
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
if (kret != MACH_MSG_SUCCESS)
|
if (kret != MACH_MSG_SUCCESS)
|
{
|
{
|
inferior_debug (5, _("mach_msg: ret=%x\n"), kret);
|
inferior_debug (5, _("mach_msg: ret=%x\n"), kret);
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
status->kind = TARGET_WAITKIND_SPURIOUS;
|
return minus_one_ptid;
|
return minus_one_ptid;
|
}
|
}
|
|
|
/* Debug: display message. */
|
/* Debug: display message. */
|
if (darwin_debug_flag > 10)
|
if (darwin_debug_flag > 10)
|
darwin_dump_message (hdr, darwin_debug_flag > 11);
|
darwin_dump_message (hdr, darwin_debug_flag > 11);
|
|
|
res = darwin_decode_message (hdr, &thread, &inf, status);
|
res = darwin_decode_message (hdr, &thread, &inf, status);
|
|
|
if (inf == NULL)
|
if (inf == NULL)
|
return res;
|
return res;
|
}
|
}
|
while (status->kind == TARGET_WAITKIND_IGNORE);
|
while (status->kind == TARGET_WAITKIND_IGNORE);
|
|
|
/* Stop all tasks. */
|
/* Stop all tasks. */
|
iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
|
iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
|
|
|
/* Read pending messages. */
|
/* Read pending messages. */
|
while (1)
|
while (1)
|
{
|
{
|
struct target_waitstatus status2;
|
struct target_waitstatus status2;
|
ptid_t ptid2;
|
ptid_t ptid2;
|
|
|
kret = mach_msg (&msgin.hdr,
|
kret = mach_msg (&msgin.hdr,
|
MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
|
MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
|
sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
|
sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
|
|
|
if (kret == MACH_RCV_TIMED_OUT)
|
if (kret == MACH_RCV_TIMED_OUT)
|
break;
|
break;
|
if (kret != MACH_MSG_SUCCESS)
|
if (kret != MACH_MSG_SUCCESS)
|
{
|
{
|
inferior_debug
|
inferior_debug
|
(5, _("darwin_wait: mach_msg(pending) ret=%x\n"), kret);
|
(5, _("darwin_wait: mach_msg(pending) ret=%x\n"), kret);
|
break;
|
break;
|
}
|
}
|
|
|
ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
|
ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
|
|
|
if (inf != NULL && thread != NULL
|
if (inf != NULL && thread != NULL
|
&& thread->event.ex_type == EXC_BREAKPOINT)
|
&& thread->event.ex_type == EXC_BREAKPOINT)
|
{
|
{
|
if (thread->single_step
|
if (thread->single_step
|
|| cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
|
|| cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
|
{
|
{
|
gdb_assert (thread->msg_state == DARWIN_MESSAGE);
|
gdb_assert (thread->msg_state == DARWIN_MESSAGE);
|
darwin_send_reply (inf, thread);
|
darwin_send_reply (inf, thread);
|
thread->msg_state = DARWIN_RUNNING;
|
thread->msg_state = DARWIN_RUNNING;
|
}
|
}
|
else
|
else
|
inferior_debug
|
inferior_debug
|
(3, _("darwin_wait: thread %x hit a non-gdb breakpoint\n"),
|
(3, _("darwin_wait: thread %x hit a non-gdb breakpoint\n"),
|
thread->gdb_port);
|
thread->gdb_port);
|
}
|
}
|
else
|
else
|
inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
|
inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
|
}
|
}
|
return res;
|
return res;
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
darwin_wait_to (struct target_ops *ops,
|
darwin_wait_to (struct target_ops *ops,
|
ptid_t ptid, struct target_waitstatus *status, int options)
|
ptid_t ptid, struct target_waitstatus *status, int options)
|
{
|
{
|
return darwin_wait (ptid, status);
|
return darwin_wait (ptid, status);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_stop (ptid_t t)
|
darwin_stop (ptid_t t)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
|
|
/* FIXME: handle in no_ptrace mode. */
|
/* FIXME: handle in no_ptrace mode. */
|
gdb_assert (!inf->private->no_ptrace);
|
gdb_assert (!inf->private->no_ptrace);
|
kill (inf->pid, SIGINT);
|
kill (inf->pid, SIGINT);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_mourn_inferior (struct target_ops *ops)
|
darwin_mourn_inferior (struct target_ops *ops)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
kern_return_t kret;
|
kern_return_t kret;
|
mach_port_t prev;
|
mach_port_t prev;
|
int i;
|
int i;
|
|
|
unpush_target (darwin_ops);
|
unpush_target (darwin_ops);
|
|
|
/* Deallocate threads. */
|
/* Deallocate threads. */
|
if (inf->private->threads)
|
if (inf->private->threads)
|
{
|
{
|
int k;
|
int k;
|
darwin_thread_t *t;
|
darwin_thread_t *t;
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
k++)
|
k++)
|
{
|
{
|
kret = mach_port_deallocate (gdb_task, t->gdb_port);
|
kret = mach_port_deallocate (gdb_task, t->gdb_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
VEC_free (darwin_thread_t, inf->private->threads);
|
VEC_free (darwin_thread_t, inf->private->threads);
|
inf->private->threads = NULL;
|
inf->private->threads = NULL;
|
}
|
}
|
|
|
kret = mach_port_move_member (gdb_task,
|
kret = mach_port_move_member (gdb_task,
|
inf->private->notify_port, MACH_PORT_NULL);
|
inf->private->notify_port, MACH_PORT_NULL);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
kret = mach_port_request_notification (gdb_task, inf->private->task,
|
kret = mach_port_request_notification (gdb_task, inf->private->task,
|
MACH_NOTIFY_DEAD_NAME, 0,
|
MACH_NOTIFY_DEAD_NAME, 0,
|
MACH_PORT_NULL,
|
MACH_PORT_NULL,
|
MACH_MSG_TYPE_MAKE_SEND_ONCE,
|
MACH_MSG_TYPE_MAKE_SEND_ONCE,
|
&prev);
|
&prev);
|
/* This can fail if the task is dead. */
|
/* This can fail if the task is dead. */
|
inferior_debug (4, "task=%x, prev=%x, notify_port=%x\n",
|
inferior_debug (4, "task=%x, prev=%x, notify_port=%x\n",
|
inf->private->task, prev, inf->private->notify_port);
|
inf->private->task, prev, inf->private->notify_port);
|
|
|
if (kret == KERN_SUCCESS)
|
if (kret == KERN_SUCCESS)
|
{
|
{
|
kret = mach_port_deallocate (gdb_task, prev);
|
kret = mach_port_deallocate (gdb_task, prev);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
|
|
kret = mach_port_destroy (gdb_task, inf->private->notify_port);
|
kret = mach_port_destroy (gdb_task, inf->private->notify_port);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
|
|
/* Deallocate saved exception ports. */
|
/* Deallocate saved exception ports. */
|
for (i = 0; i < inf->private->exception_info.count; i++)
|
for (i = 0; i < inf->private->exception_info.count; i++)
|
{
|
{
|
kret = mach_port_deallocate
|
kret = mach_port_deallocate
|
(gdb_task, inf->private->exception_info.ports[i]);
|
(gdb_task, inf->private->exception_info.ports[i]);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
inf->private->exception_info.count = 0;
|
inf->private->exception_info.count = 0;
|
|
|
kret = mach_port_deallocate (gdb_task, inf->private->task);
|
kret = mach_port_deallocate (gdb_task, inf->private->task);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
xfree (inf->private);
|
xfree (inf->private);
|
inf->private = NULL;
|
inf->private = NULL;
|
|
|
generic_mourn_inferior ();
|
generic_mourn_inferior ();
|
}
|
}
|
|
|
static void
|
static void
|
darwin_reply_to_all_pending_messages (struct inferior *inf)
|
darwin_reply_to_all_pending_messages (struct inferior *inf)
|
{
|
{
|
int k;
|
int k;
|
darwin_thread_t *t;
|
darwin_thread_t *t;
|
|
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
k++)
|
k++)
|
{
|
{
|
if (t->msg_state == DARWIN_MESSAGE)
|
if (t->msg_state == DARWIN_MESSAGE)
|
darwin_resume_thread (inf, t, 0, 0);
|
darwin_resume_thread (inf, t, 0, 0);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
darwin_stop_inferior (struct inferior *inf)
|
darwin_stop_inferior (struct inferior *inf)
|
{
|
{
|
struct target_waitstatus wstatus;
|
struct target_waitstatus wstatus;
|
ptid_t ptid;
|
ptid_t ptid;
|
kern_return_t kret;
|
kern_return_t kret;
|
int status;
|
int status;
|
int res;
|
int res;
|
|
|
gdb_assert (inf != NULL);
|
gdb_assert (inf != NULL);
|
|
|
darwin_suspend_inferior (inf);
|
darwin_suspend_inferior (inf);
|
|
|
darwin_reply_to_all_pending_messages (inf);
|
darwin_reply_to_all_pending_messages (inf);
|
|
|
if (inf->private->no_ptrace)
|
if (inf->private->no_ptrace)
|
return;
|
return;
|
|
|
res = kill (inf->pid, SIGSTOP);
|
res = kill (inf->pid, SIGSTOP);
|
if (res != 0)
|
if (res != 0)
|
warning (_("cannot kill: %s\n"), safe_strerror (errno));
|
warning (_("cannot kill: %s\n"), safe_strerror (errno));
|
|
|
/* Wait until the process is really stopped. */
|
/* Wait until the process is really stopped. */
|
while (1)
|
while (1)
|
{
|
{
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
if (wstatus.kind == TARGET_WAITKIND_STOPPED
|
if (wstatus.kind == TARGET_WAITKIND_STOPPED
|
&& wstatus.value.sig == TARGET_SIGNAL_STOP)
|
&& wstatus.value.sig == TARGET_SIGNAL_STOP)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
static kern_return_t
|
static kern_return_t
|
darwin_save_exception_ports (darwin_inferior *inf)
|
darwin_save_exception_ports (darwin_inferior *inf)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
inf->exception_info.count =
|
inf->exception_info.count =
|
sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
|
sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
|
|
|
kret = task_get_exception_ports
|
kret = task_get_exception_ports
|
(inf->task, EXC_MASK_ALL, inf->exception_info.masks,
|
(inf->task, EXC_MASK_ALL, inf->exception_info.masks,
|
&inf->exception_info.count, inf->exception_info.ports,
|
&inf->exception_info.count, inf->exception_info.ports,
|
inf->exception_info.behaviors, inf->exception_info.flavors);
|
inf->exception_info.behaviors, inf->exception_info.flavors);
|
return kret;
|
return kret;
|
}
|
}
|
|
|
static kern_return_t
|
static kern_return_t
|
darwin_restore_exception_ports (darwin_inferior *inf)
|
darwin_restore_exception_ports (darwin_inferior *inf)
|
{
|
{
|
int i;
|
int i;
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
for (i = 0; i < inf->exception_info.count; i++)
|
for (i = 0; i < inf->exception_info.count; i++)
|
{
|
{
|
kret = task_set_exception_ports
|
kret = task_set_exception_ports
|
(inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
|
(inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
|
inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
|
inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
return kret;
|
return kret;
|
}
|
}
|
|
|
return KERN_SUCCESS;
|
return KERN_SUCCESS;
|
}
|
}
|
|
|
static void
|
static void
|
darwin_kill_inferior (struct target_ops *ops)
|
darwin_kill_inferior (struct target_ops *ops)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
struct target_waitstatus wstatus;
|
struct target_waitstatus wstatus;
|
ptid_t ptid;
|
ptid_t ptid;
|
kern_return_t kret;
|
kern_return_t kret;
|
int status;
|
int status;
|
int res;
|
int res;
|
|
|
if (ptid_equal (inferior_ptid, null_ptid))
|
if (ptid_equal (inferior_ptid, null_ptid))
|
return;
|
return;
|
|
|
gdb_assert (inf != NULL);
|
gdb_assert (inf != NULL);
|
|
|
if (!inf->private->no_ptrace)
|
if (!inf->private->no_ptrace)
|
{
|
{
|
darwin_stop_inferior (inf);
|
darwin_stop_inferior (inf);
|
|
|
res = PTRACE (PT_KILL, inf->pid, 0, 0);
|
res = PTRACE (PT_KILL, inf->pid, 0, 0);
|
gdb_assert (res == 0);
|
gdb_assert (res == 0);
|
|
|
darwin_reply_to_all_pending_messages (inf);
|
darwin_reply_to_all_pending_messages (inf);
|
|
|
darwin_resume_inferior (inf);
|
darwin_resume_inferior (inf);
|
|
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
}
|
}
|
else
|
else
|
{
|
{
|
kret = darwin_restore_exception_ports (inf->private);
|
kret = darwin_restore_exception_ports (inf->private);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
darwin_reply_to_all_pending_messages (inf);
|
darwin_reply_to_all_pending_messages (inf);
|
|
|
darwin_resume_inferior (inf);
|
darwin_resume_inferior (inf);
|
|
|
res = kill (inf->pid, 9);
|
res = kill (inf->pid, 9);
|
|
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
ptid = darwin_wait (inferior_ptid, &wstatus);
|
}
|
}
|
|
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
}
|
}
|
|
|
static void
|
static void
|
darwin_attach_pid (struct inferior *inf)
|
darwin_attach_pid (struct inferior *inf)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
mach_port_t prev_port;
|
mach_port_t prev_port;
|
int traps_expected;
|
int traps_expected;
|
mach_port_t prev_not;
|
mach_port_t prev_not;
|
exception_mask_t mask;
|
exception_mask_t mask;
|
|
|
inf->private = XZALLOC (darwin_inferior);
|
inf->private = XZALLOC (darwin_inferior);
|
|
|
kret = task_for_pid (gdb_task, inf->pid, &inf->private->task);
|
kret = task_for_pid (gdb_task, inf->pid, &inf->private->task);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
int status;
|
int status;
|
|
|
if (!inf->attach_flag)
|
if (!inf->attach_flag)
|
{
|
{
|
kill (inf->pid, 9);
|
kill (inf->pid, 9);
|
waitpid (inf->pid, &status, 0);
|
waitpid (inf->pid, &status, 0);
|
}
|
}
|
|
|
error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
|
error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
|
" (please check gdb is codesigned - see taskgated(8))"),
|
" (please check gdb is codesigned - see taskgated(8))"),
|
inf->pid, mach_error_string (kret), (unsigned long) kret);
|
inf->pid, mach_error_string (kret), (unsigned long) kret);
|
}
|
}
|
|
|
inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
|
inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
|
inf->private->task, inf->pid);
|
inf->private->task, inf->pid);
|
|
|
if (darwin_ex_port == MACH_PORT_NULL)
|
if (darwin_ex_port == MACH_PORT_NULL)
|
{
|
{
|
/* Create a port to get exceptions. */
|
/* Create a port to get exceptions. */
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
|
&darwin_ex_port);
|
&darwin_ex_port);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
|
kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
|
MACH_MSG_TYPE_MAKE_SEND);
|
MACH_MSG_TYPE_MAKE_SEND);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
/* Create a port set and put ex_port in it. */
|
/* Create a port set and put ex_port in it. */
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
|
&darwin_port_set);
|
&darwin_port_set);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
|
kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
}
|
}
|
|
|
/* Create a port to be notified when the child task terminates. */
|
/* Create a port to be notified when the child task terminates. */
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
|
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
|
&inf->private->notify_port);
|
&inf->private->notify_port);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
kret = mach_port_move_member (gdb_task,
|
kret = mach_port_move_member (gdb_task,
|
inf->private->notify_port, darwin_port_set);
|
inf->private->notify_port, darwin_port_set);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
kret = mach_port_request_notification (gdb_task, inf->private->task,
|
kret = mach_port_request_notification (gdb_task, inf->private->task,
|
MACH_NOTIFY_DEAD_NAME, 0,
|
MACH_NOTIFY_DEAD_NAME, 0,
|
inf->private->notify_port,
|
inf->private->notify_port,
|
MACH_MSG_TYPE_MAKE_SEND_ONCE,
|
MACH_MSG_TYPE_MAKE_SEND_ONCE,
|
&prev_not);
|
&prev_not);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (prev_not == MACH_PORT_NULL);
|
gdb_assert (prev_not == MACH_PORT_NULL);
|
|
|
kret = darwin_save_exception_ports (inf->private);
|
kret = darwin_save_exception_ports (inf->private);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
/* Set exception port. */
|
/* Set exception port. */
|
if (enable_mach_exceptions)
|
if (enable_mach_exceptions)
|
mask = EXC_MASK_ALL;
|
mask = EXC_MASK_ALL;
|
else
|
else
|
mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
|
mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
|
kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
|
kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
|
EXCEPTION_DEFAULT, THREAD_STATE_NONE);
|
EXCEPTION_DEFAULT, THREAD_STATE_NONE);
|
gdb_assert (kret == KERN_SUCCESS);
|
gdb_assert (kret == KERN_SUCCESS);
|
|
|
push_target (darwin_ops);
|
push_target (darwin_ops);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_init_thread_list (struct inferior *inf)
|
darwin_init_thread_list (struct inferior *inf)
|
{
|
{
|
darwin_thread_t *thread;
|
darwin_thread_t *thread;
|
ptid_t new_ptid;
|
ptid_t new_ptid;
|
|
|
darwin_check_new_threads (inf);
|
darwin_check_new_threads (inf);
|
|
|
gdb_assert (inf->private->threads
|
gdb_assert (inf->private->threads
|
&& VEC_length (darwin_thread_t, inf->private->threads) > 0);
|
&& VEC_length (darwin_thread_t, inf->private->threads) > 0);
|
thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
|
thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
|
|
|
/* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
|
/* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
|
Fix up. */
|
Fix up. */
|
new_ptid = ptid_build (inf->pid, 0, thread->gdb_port);
|
new_ptid = ptid_build (inf->pid, 0, thread->gdb_port);
|
thread_change_ptid (inferior_ptid, new_ptid);
|
thread_change_ptid (inferior_ptid, new_ptid);
|
inferior_ptid = new_ptid;
|
inferior_ptid = new_ptid;
|
}
|
}
|
|
|
/* The child must synchronize with gdb: gdb must set the exception port
|
/* The child must synchronize with gdb: gdb must set the exception port
|
before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
|
before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
|
FIXME: is there a lighter way ? */
|
FIXME: is there a lighter way ? */
|
static int ptrace_fds[2];
|
static int ptrace_fds[2];
|
|
|
static void
|
static void
|
darwin_ptrace_me (void)
|
darwin_ptrace_me (void)
|
{
|
{
|
int res;
|
int res;
|
char c;
|
char c;
|
|
|
/* Close write end point. */
|
/* Close write end point. */
|
close (ptrace_fds[1]);
|
close (ptrace_fds[1]);
|
|
|
/* Wait until gdb is ready. */
|
/* Wait until gdb is ready. */
|
res = read (ptrace_fds[0], &c, 1);
|
res = read (ptrace_fds[0], &c, 1);
|
gdb_assert (res == 0);
|
gdb_assert (res == 0);
|
close (ptrace_fds[0]);
|
close (ptrace_fds[0]);
|
|
|
/* Get rid of privileges. */
|
/* Get rid of privileges. */
|
setegid (getgid ());
|
setegid (getgid ());
|
|
|
/* Set TRACEME. */
|
/* Set TRACEME. */
|
PTRACE (PT_TRACE_ME, 0, 0, 0);
|
PTRACE (PT_TRACE_ME, 0, 0, 0);
|
|
|
/* Redirect signals to exception port. */
|
/* Redirect signals to exception port. */
|
PTRACE (PT_SIGEXC, 0, 0, 0);
|
PTRACE (PT_SIGEXC, 0, 0, 0);
|
}
|
}
|
|
|
/* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
|
/* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
|
static void
|
static void
|
darwin_pre_ptrace (void)
|
darwin_pre_ptrace (void)
|
{
|
{
|
if (pipe (ptrace_fds) != 0)
|
if (pipe (ptrace_fds) != 0)
|
{
|
{
|
ptrace_fds[0] = -1;
|
ptrace_fds[0] = -1;
|
ptrace_fds[1] = -1;
|
ptrace_fds[1] = -1;
|
error (_("unable to create a pipe: %s"), safe_strerror (errno));
|
error (_("unable to create a pipe: %s"), safe_strerror (errno));
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
darwin_ptrace_him (int pid)
|
darwin_ptrace_him (int pid)
|
{
|
{
|
task_t itask;
|
task_t itask;
|
kern_return_t kret;
|
kern_return_t kret;
|
mach_port_t prev_port;
|
mach_port_t prev_port;
|
int traps_expected;
|
int traps_expected;
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
|
|
darwin_attach_pid (inf);
|
darwin_attach_pid (inf);
|
|
|
/* Let's the child run. */
|
/* Let's the child run. */
|
close (ptrace_fds[0]);
|
close (ptrace_fds[0]);
|
close (ptrace_fds[1]);
|
close (ptrace_fds[1]);
|
|
|
darwin_init_thread_list (inf);
|
darwin_init_thread_list (inf);
|
|
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_create_inferior (struct target_ops *ops, char *exec_file,
|
darwin_create_inferior (struct target_ops *ops, char *exec_file,
|
char *allargs, char **env, int from_tty)
|
char *allargs, char **env, int from_tty)
|
{
|
{
|
/* Do the hard work. */
|
/* Do the hard work. */
|
fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
|
fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
|
darwin_pre_ptrace, NULL);
|
darwin_pre_ptrace, NULL);
|
|
|
/* Return now in case of error. */
|
/* Return now in case of error. */
|
if (ptid_equal (inferior_ptid, null_ptid))
|
if (ptid_equal (inferior_ptid, null_ptid))
|
return;
|
return;
|
}
|
}
|
|
|
|
|
/* Attach to process PID, then initialize for debugging it
|
/* Attach to process PID, then initialize for debugging it
|
and wait for the trace-trap that results from attaching. */
|
and wait for the trace-trap that results from attaching. */
|
static void
|
static void
|
darwin_attach (struct target_ops *ops, char *args, int from_tty)
|
darwin_attach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
pid_t pid;
|
pid_t pid;
|
pid_t pid2;
|
pid_t pid2;
|
int wstatus;
|
int wstatus;
|
int res;
|
int res;
|
struct inferior *inf;
|
struct inferior *inf;
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
pid = parse_pid_to_attach (args);
|
pid = parse_pid_to_attach (args);
|
|
|
if (pid == getpid ()) /* Trying to masturbate? */
|
if (pid == getpid ()) /* Trying to masturbate? */
|
error (_("I refuse to debug myself!"));
|
error (_("I refuse to debug myself!"));
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
char *exec_file = get_exec_file (0);
|
char *exec_file = get_exec_file (0);
|
|
|
if (exec_file)
|
if (exec_file)
|
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
|
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
else
|
else
|
printf_unfiltered (_("Attaching to %s\n"),
|
printf_unfiltered (_("Attaching to %s\n"),
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
|
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
if (pid == 0 || kill (pid, 0) < 0)
|
if (pid == 0 || kill (pid, 0) < 0)
|
error (_("Can't attach to process %d: %s (%d)"),
|
error (_("Can't attach to process %d: %s (%d)"),
|
pid, safe_strerror (errno), errno);
|
pid, safe_strerror (errno), errno);
|
|
|
inferior_ptid = pid_to_ptid (pid);
|
inferior_ptid = pid_to_ptid (pid);
|
inf = current_inferior ();
|
inf = current_inferior ();
|
inferior_appeared (inf, pid);
|
inferior_appeared (inf, pid);
|
inf->attach_flag = 1;
|
inf->attach_flag = 1;
|
|
|
/* Always add a main thread. */
|
/* Always add a main thread. */
|
add_thread_silent (inferior_ptid);
|
add_thread_silent (inferior_ptid);
|
|
|
darwin_attach_pid (inf);
|
darwin_attach_pid (inf);
|
|
|
darwin_suspend_inferior (inf);
|
darwin_suspend_inferior (inf);
|
|
|
darwin_init_thread_list (inf);
|
darwin_init_thread_list (inf);
|
|
|
darwin_check_osabi (inf->private, ptid_get_tid (inferior_ptid));
|
darwin_check_osabi (inf->private, ptid_get_tid (inferior_ptid));
|
|
|
gdb_assert (darwin_inf_fake_stop == NULL);
|
gdb_assert (darwin_inf_fake_stop == NULL);
|
darwin_inf_fake_stop = inf;
|
darwin_inf_fake_stop = inf;
|
inf->private->no_ptrace = 1;
|
inf->private->no_ptrace = 1;
|
}
|
}
|
|
|
/* Take a program previously attached to and detaches it.
|
/* Take a program previously attached to and detaches it.
|
The program resumes execution and will no longer stop
|
The program resumes execution and will no longer stop
|
on signals, etc. We'd better not have left any breakpoints
|
on signals, etc. We'd better not have left any breakpoints
|
in the program or it'll die when it hits one. For this
|
in the program or it'll die when it hits one. For this
|
to work, it may be necessary for the process to have been
|
to work, it may be necessary for the process to have been
|
previously attached. It *might* work if the program was
|
previously attached. It *might* work if the program was
|
started via fork. */
|
started via fork. */
|
static void
|
static void
|
darwin_detach (struct target_ops *ops, char *args, int from_tty)
|
darwin_detach (struct target_ops *ops, char *args, int from_tty)
|
{
|
{
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
pid_t pid = ptid_get_pid (inferior_ptid);
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
kern_return_t kret;
|
kern_return_t kret;
|
int res;
|
int res;
|
|
|
/* Display message. */
|
/* Display message. */
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
char *exec_file = get_exec_file (0);
|
char *exec_file = get_exec_file (0);
|
if (exec_file == 0)
|
if (exec_file == 0)
|
exec_file = "";
|
exec_file = "";
|
printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
|
printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
|
target_pid_to_str (pid_to_ptid (pid)));
|
target_pid_to_str (pid_to_ptid (pid)));
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
/* If ptrace() is in use, stop the process. */
|
/* If ptrace() is in use, stop the process. */
|
if (!inf->private->no_ptrace)
|
if (!inf->private->no_ptrace)
|
darwin_stop_inferior (inf);
|
darwin_stop_inferior (inf);
|
|
|
kret = darwin_restore_exception_ports (inf->private);
|
kret = darwin_restore_exception_ports (inf->private);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
|
|
if (!inf->private->no_ptrace)
|
if (!inf->private->no_ptrace)
|
{
|
{
|
res = PTRACE (PT_DETACH, inf->pid, 0, 0);
|
res = PTRACE (PT_DETACH, inf->pid, 0, 0);
|
if (res != 0)
|
if (res != 0)
|
printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
|
printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
|
inf->pid, safe_strerror (errno), errno);
|
inf->pid, safe_strerror (errno), errno);
|
}
|
}
|
|
|
darwin_reply_to_all_pending_messages (inf);
|
darwin_reply_to_all_pending_messages (inf);
|
|
|
darwin_resume_inferior (inf);
|
darwin_resume_inferior (inf);
|
|
|
darwin_mourn_inferior (ops);
|
darwin_mourn_inferior (ops);
|
}
|
}
|
|
|
static void
|
static void
|
darwin_files_info (struct target_ops *ops)
|
darwin_files_info (struct target_ops *ops)
|
{
|
{
|
}
|
}
|
|
|
static char *
|
static char *
|
darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
static char buf[80];
|
static char buf[80];
|
long tid = ptid_get_tid (ptid);
|
long tid = ptid_get_tid (ptid);
|
|
|
if (tid != 0)
|
if (tid != 0)
|
{
|
{
|
snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
|
snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
|
tid, ptid_get_pid (ptid));
|
tid, ptid_get_pid (ptid));
|
return buf;
|
return buf;
|
}
|
}
|
|
|
return normal_pid_to_str (ptid);
|
return normal_pid_to_str (ptid);
|
}
|
}
|
|
|
static int
|
static int
|
darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
|
darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
|
/* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
|
copy it to RDADDR in gdb's address space.
|
copy it to RDADDR in gdb's address space.
|
If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
|
If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
|
to ADDR in inferior task's address space.
|
to ADDR in inferior task's address space.
|
Return 0 on failure; number of bytes read / writen otherwise. */
|
Return 0 on failure; number of bytes read / writen otherwise. */
|
static int
|
static int
|
darwin_read_write_inferior (task_t task, CORE_ADDR addr,
|
darwin_read_write_inferior (task_t task, CORE_ADDR addr,
|
char *rdaddr, const char *wraddr, int length)
|
char *rdaddr, const char *wraddr, int length)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
mach_vm_address_t offset = addr & (mach_page_size - 1);
|
mach_vm_address_t offset = addr & (mach_page_size - 1);
|
mach_vm_address_t low_address = (mach_vm_address_t) (addr - offset);
|
mach_vm_address_t low_address = (mach_vm_address_t) (addr - offset);
|
mach_vm_size_t aligned_length = (mach_vm_size_t) PAGE_ROUND (offset + length);
|
mach_vm_size_t aligned_length = (mach_vm_size_t) PAGE_ROUND (offset + length);
|
pointer_t copied;
|
pointer_t copied;
|
int copy_count;
|
int copy_count;
|
mach_vm_size_t remaining_length;
|
mach_vm_size_t remaining_length;
|
mach_vm_address_t region_address;
|
mach_vm_address_t region_address;
|
mach_vm_size_t region_length;
|
mach_vm_size_t region_length;
|
|
|
inferior_debug (8, _("darwin_read_write_inferior(task=%x, %s, len=%d)\n"),
|
inferior_debug (8, _("darwin_read_write_inferior(task=%x, %s, len=%d)\n"),
|
task, core_addr_to_string (addr), length);
|
task, core_addr_to_string (addr), length);
|
|
|
/* Get memory from inferior with page aligned addresses */
|
/* Get memory from inferior with page aligned addresses */
|
kret = mach_vm_read (task, low_address, aligned_length,
|
kret = mach_vm_read (task, low_address, aligned_length,
|
&copied, ©_count);
|
&copied, ©_count);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
inferior_debug
|
inferior_debug
|
(1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
|
(1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
|
core_addr_to_string (addr), mach_error_string (kret));
|
core_addr_to_string (addr), mach_error_string (kret));
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (rdaddr != NULL)
|
if (rdaddr != NULL)
|
memcpy (rdaddr, (char *)copied + offset, length);
|
memcpy (rdaddr, (char *)copied + offset, length);
|
|
|
if (wraddr == NULL)
|
if (wraddr == NULL)
|
goto out;
|
goto out;
|
|
|
memcpy ((char *)copied + offset, wraddr, length);
|
memcpy ((char *)copied + offset, wraddr, length);
|
|
|
/* Do writes atomically.
|
/* Do writes atomically.
|
First check for holes and unwritable memory. */
|
First check for holes and unwritable memory. */
|
for (region_address = low_address, remaining_length = aligned_length;
|
for (region_address = low_address, remaining_length = aligned_length;
|
region_address < low_address + aligned_length;
|
region_address < low_address + aligned_length;
|
region_address += region_length, remaining_length -= region_length)
|
region_address += region_length, remaining_length -= region_length)
|
{
|
{
|
vm_region_submap_short_info_data_64_t info;
|
vm_region_submap_short_info_data_64_t info;
|
mach_vm_address_t region_start = region_address;
|
mach_vm_address_t region_start = region_address;
|
mach_msg_type_number_t count;
|
mach_msg_type_number_t count;
|
natural_t region_depth;
|
natural_t region_depth;
|
|
|
region_depth = 100000;
|
region_depth = 100000;
|
count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
|
count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
|
kret = mach_vm_region_recurse
|
kret = mach_vm_region_recurse
|
(task, ®ion_start, ®ion_length, ®ion_depth,
|
(task, ®ion_start, ®ion_length, ®ion_depth,
|
(vm_region_recurse_info_t) &info, &count);
|
(vm_region_recurse_info_t) &info, &count);
|
|
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
inferior_debug (1, _("darwin_read_write_inferior: "
|
inferior_debug (1, _("darwin_read_write_inferior: "
|
"mach_vm_region_recurse failed at %s: %s\n"),
|
"mach_vm_region_recurse failed at %s: %s\n"),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_address),
|
mach_error_string (kret));
|
mach_error_string (kret));
|
goto out;
|
goto out;
|
}
|
}
|
|
|
inferior_debug
|
inferior_debug
|
(9, _("darwin_read_write_inferior: "
|
(9, _("darwin_read_write_inferior: "
|
"mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
|
"mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_start),
|
core_addr_to_string (region_start),
|
core_addr_to_string (region_length));
|
core_addr_to_string (region_length));
|
|
|
/* Check for holes in memory */
|
/* Check for holes in memory */
|
if (region_start > region_address)
|
if (region_start > region_address)
|
{
|
{
|
warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
|
warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_start),
|
core_addr_to_string (region_start),
|
(unsigned)region_length);
|
(unsigned)region_length);
|
length = 0;
|
length = 0;
|
goto out;
|
goto out;
|
}
|
}
|
|
|
/* Adjust the length. */
|
/* Adjust the length. */
|
region_length -= (region_address - region_start);
|
region_length -= (region_address - region_start);
|
|
|
if (!(info.max_protection & VM_PROT_WRITE))
|
if (!(info.max_protection & VM_PROT_WRITE))
|
{
|
{
|
kret = mach_vm_protect
|
kret = mach_vm_protect
|
(task, region_address, region_length,
|
(task, region_address, region_length,
|
TRUE, info.max_protection | VM_PROT_WRITE | VM_PROT_COPY);
|
TRUE, info.max_protection | VM_PROT_WRITE | VM_PROT_COPY);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
warning (_("darwin_read_write_inf: "
|
warning (_("darwin_read_write_inf: "
|
"mach_vm_protect max failed at %s: %s"),
|
"mach_vm_protect max failed at %s: %s"),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_address),
|
mach_error_string (kret));
|
mach_error_string (kret));
|
length = 0;
|
length = 0;
|
goto out;
|
goto out;
|
}
|
}
|
}
|
}
|
|
|
if (!(info.protection & VM_PROT_WRITE))
|
if (!(info.protection & VM_PROT_WRITE))
|
{
|
{
|
kret = mach_vm_protect (task, region_address, region_length,
|
kret = mach_vm_protect (task, region_address, region_length,
|
FALSE, info.protection | VM_PROT_WRITE);
|
FALSE, info.protection | VM_PROT_WRITE);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
warning (_("darwin_read_write_inf: "
|
warning (_("darwin_read_write_inf: "
|
"mach_vm_protect failed at %s (len=0x%lx): %s"),
|
"mach_vm_protect failed at %s (len=0x%lx): %s"),
|
core_addr_to_string (region_address),
|
core_addr_to_string (region_address),
|
(unsigned long)region_length, mach_error_string (kret));
|
(unsigned long)region_length, mach_error_string (kret));
|
length = 0;
|
length = 0;
|
goto out;
|
goto out;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
kret = mach_vm_write (task, low_address, copied, aligned_length);
|
kret = mach_vm_write (task, low_address, copied, aligned_length);
|
|
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
|
warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
|
mach_error_string (kret));
|
mach_error_string (kret));
|
length = 0;
|
length = 0;
|
}
|
}
|
out:
|
out:
|
mach_vm_deallocate (mach_task_self (), copied, copy_count);
|
mach_vm_deallocate (mach_task_self (), copied, copy_count);
|
return length;
|
return length;
|
}
|
}
|
|
|
|
|
/* Return 0 on failure, number of bytes handled otherwise. TARGET
|
/* Return 0 on failure, number of bytes handled otherwise. TARGET
|
is ignored. */
|
is ignored. */
|
static int
|
static int
|
darwin_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
|
darwin_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
|
struct mem_attrib *attrib, struct target_ops *target)
|
struct mem_attrib *attrib, struct target_ops *target)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
task_t task = inf->private->task;
|
task_t task = inf->private->task;
|
|
|
if (task == MACH_PORT_NULL)
|
if (task == MACH_PORT_NULL)
|
return 0;
|
return 0;
|
|
|
inferior_debug (8, _("darwin_xfer_memory(%s, %d, %c)\n"),
|
inferior_debug (8, _("darwin_xfer_memory(%s, %d, %c)\n"),
|
core_addr_to_string (memaddr), len, write ? 'w' : 'r');
|
core_addr_to_string (memaddr), len, write ? 'w' : 'r');
|
|
|
if (write)
|
if (write)
|
return darwin_read_write_inferior (task, memaddr, NULL, myaddr, len);
|
return darwin_read_write_inferior (task, memaddr, NULL, myaddr, len);
|
else
|
else
|
return darwin_read_write_inferior (task, memaddr, myaddr, NULL, len);
|
return darwin_read_write_inferior (task, memaddr, myaddr, NULL, len);
|
}
|
}
|
|
|
static LONGEST
|
static LONGEST
|
darwin_xfer_partial (struct target_ops *ops,
|
darwin_xfer_partial (struct target_ops *ops,
|
enum target_object object, const char *annex,
|
enum target_object object, const char *annex,
|
gdb_byte *readbuf, const gdb_byte *writebuf,
|
gdb_byte *readbuf, const gdb_byte *writebuf,
|
ULONGEST offset, LONGEST len)
|
ULONGEST offset, LONGEST len)
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
|
|
inferior_debug
|
inferior_debug
|
(8, _("darwin_xfer_partial(%s, %d, rbuf=%s, wbuf=%s) pid=%u\n"),
|
(8, _("darwin_xfer_partial(%s, %d, rbuf=%s, wbuf=%s) pid=%u\n"),
|
core_addr_to_string (offset), (int)len,
|
core_addr_to_string (offset), (int)len,
|
host_address_to_string (readbuf), host_address_to_string (writebuf),
|
host_address_to_string (readbuf), host_address_to_string (writebuf),
|
inf->pid);
|
inf->pid);
|
|
|
if (object != TARGET_OBJECT_MEMORY)
|
if (object != TARGET_OBJECT_MEMORY)
|
return -1;
|
return -1;
|
|
|
return darwin_read_write_inferior (inf->private->task, offset,
|
return darwin_read_write_inferior (inf->private->task, offset,
|
readbuf, writebuf, len);
|
readbuf, writebuf, len);
|
}
|
}
|
|
|
static void
|
static void
|
set_enable_mach_exceptions (char *args, int from_tty,
|
set_enable_mach_exceptions (char *args, int from_tty,
|
struct cmd_list_element *c)
|
struct cmd_list_element *c)
|
{
|
{
|
if (!ptid_equal (inferior_ptid, null_ptid))
|
if (!ptid_equal (inferior_ptid, null_ptid))
|
{
|
{
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
exception_mask_t mask;
|
exception_mask_t mask;
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
if (enable_mach_exceptions)
|
if (enable_mach_exceptions)
|
mask = EXC_MASK_ALL;
|
mask = EXC_MASK_ALL;
|
else
|
else
|
{
|
{
|
darwin_restore_exception_ports (inf->private);
|
darwin_restore_exception_ports (inf->private);
|
mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
|
mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
|
}
|
}
|
kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
|
kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
|
EXCEPTION_DEFAULT, THREAD_STATE_NONE);
|
EXCEPTION_DEFAULT, THREAD_STATE_NONE);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
}
|
}
|
|
|
static char *
|
static char *
|
darwin_pid_to_exec_file (int pid)
|
darwin_pid_to_exec_file (int pid)
|
{
|
{
|
char *path;
|
char *path;
|
int res;
|
int res;
|
|
|
path = xmalloc (MAXPATHLEN);
|
path = xmalloc (MAXPATHLEN);
|
make_cleanup (xfree, path);
|
make_cleanup (xfree, path);
|
|
|
res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, MAXPATHLEN);
|
res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, MAXPATHLEN);
|
if (res >= 0)
|
if (res >= 0)
|
return path;
|
return path;
|
else
|
else
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
static ptid_t
|
static ptid_t
|
darwin_get_ada_task_ptid (long lwp, long thread)
|
darwin_get_ada_task_ptid (long lwp, long thread)
|
{
|
{
|
int i;
|
int i;
|
darwin_thread_t *t;
|
darwin_thread_t *t;
|
int k;
|
int k;
|
struct inferior *inf = current_inferior ();
|
struct inferior *inf = current_inferior ();
|
kern_return_t kret;
|
kern_return_t kret;
|
mach_port_name_array_t names;
|
mach_port_name_array_t names;
|
mach_msg_type_number_t names_count;
|
mach_msg_type_number_t names_count;
|
mach_port_type_array_t types;
|
mach_port_type_array_t types;
|
mach_msg_type_number_t types_count;
|
mach_msg_type_number_t types_count;
|
long res = 0;
|
long res = 0;
|
|
|
/* First linear search. */
|
/* First linear search. */
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
k++)
|
k++)
|
if (t->inf_port == lwp)
|
if (t->inf_port == lwp)
|
return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
|
return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
|
|
|
/* Maybe the port was never extract. Do it now. */
|
/* Maybe the port was never extract. Do it now. */
|
|
|
/* First get inferior port names. */
|
/* First get inferior port names. */
|
kret = mach_port_names (inf->private->task, &names, &names_count, &types,
|
kret = mach_port_names (inf->private->task, &names, &names_count, &types,
|
&types_count);
|
&types_count);
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
return null_ptid;
|
return null_ptid;
|
|
|
/* For each name, copy the right in the gdb space and then compare with
|
/* For each name, copy the right in the gdb space and then compare with
|
our view of the inferior threads. We don't forget to deallocate the
|
our view of the inferior threads. We don't forget to deallocate the
|
right. */
|
right. */
|
for (i = 0; i < names_count; i++)
|
for (i = 0; i < names_count; i++)
|
{
|
{
|
mach_port_t local_name;
|
mach_port_t local_name;
|
mach_msg_type_name_t local_type;
|
mach_msg_type_name_t local_type;
|
|
|
/* We just need to know the corresponding name in gdb name space.
|
/* We just need to know the corresponding name in gdb name space.
|
So extract and deallocate the right. */
|
So extract and deallocate the right. */
|
kret = mach_port_extract_right (inf->private->task, names[i],
|
kret = mach_port_extract_right (inf->private->task, names[i],
|
MACH_MSG_TYPE_COPY_SEND,
|
MACH_MSG_TYPE_COPY_SEND,
|
&local_name, &local_type);
|
&local_name, &local_type);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
continue;
|
continue;
|
mach_port_deallocate (gdb_task, local_name);
|
mach_port_deallocate (gdb_task, local_name);
|
|
|
for (k = 0;
|
for (k = 0;
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
|
k++)
|
k++)
|
if (t->gdb_port == local_name)
|
if (t->gdb_port == local_name)
|
{
|
{
|
t->inf_port = names[i];
|
t->inf_port = names[i];
|
if (names[i] == lwp)
|
if (names[i] == lwp)
|
res = t->gdb_port;
|
res = t->gdb_port;
|
}
|
}
|
}
|
}
|
|
|
vm_deallocate (gdb_task, (vm_address_t) names,
|
vm_deallocate (gdb_task, (vm_address_t) names,
|
names_count * sizeof (mach_port_t));
|
names_count * sizeof (mach_port_t));
|
|
|
if (res)
|
if (res)
|
return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
|
return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
|
else
|
else
|
return null_ptid;
|
return null_ptid;
|
}
|
}
|
|
|
static int
|
static int
|
darwin_supports_multi_process (void)
|
darwin_supports_multi_process (void)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
void
|
void
|
_initialize_darwin_inferior (void)
|
_initialize_darwin_inferior (void)
|
{
|
{
|
kern_return_t kret;
|
kern_return_t kret;
|
|
|
gdb_task = mach_task_self ();
|
gdb_task = mach_task_self ();
|
darwin_host_self = mach_host_self ();
|
darwin_host_self = mach_host_self ();
|
|
|
/* Read page size. */
|
/* Read page size. */
|
kret = host_page_size (darwin_host_self, &mach_page_size);
|
kret = host_page_size (darwin_host_self, &mach_page_size);
|
if (kret != KERN_SUCCESS)
|
if (kret != KERN_SUCCESS)
|
{
|
{
|
mach_page_size = 0x1000;
|
mach_page_size = 0x1000;
|
MACH_CHECK_ERROR (kret);
|
MACH_CHECK_ERROR (kret);
|
}
|
}
|
|
|
darwin_ops = inf_child_target ();
|
darwin_ops = inf_child_target ();
|
|
|
darwin_ops->to_shortname = "darwin-child";
|
darwin_ops->to_shortname = "darwin-child";
|
darwin_ops->to_longname = _("Darwin child process");
|
darwin_ops->to_longname = _("Darwin child process");
|
darwin_ops->to_doc =
|
darwin_ops->to_doc =
|
_("Darwin child process (started by the \"run\" command).");
|
_("Darwin child process (started by the \"run\" command).");
|
darwin_ops->to_create_inferior = darwin_create_inferior;
|
darwin_ops->to_create_inferior = darwin_create_inferior;
|
darwin_ops->to_attach = darwin_attach;
|
darwin_ops->to_attach = darwin_attach;
|
darwin_ops->to_attach_no_wait = 0;
|
darwin_ops->to_attach_no_wait = 0;
|
darwin_ops->to_detach = darwin_detach;
|
darwin_ops->to_detach = darwin_detach;
|
darwin_ops->to_files_info = darwin_files_info;
|
darwin_ops->to_files_info = darwin_files_info;
|
darwin_ops->to_wait = darwin_wait_to;
|
darwin_ops->to_wait = darwin_wait_to;
|
darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
|
darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
|
darwin_ops->to_kill = darwin_kill_inferior;
|
darwin_ops->to_kill = darwin_kill_inferior;
|
darwin_ops->to_stop = darwin_stop;
|
darwin_ops->to_stop = darwin_stop;
|
darwin_ops->to_resume = darwin_resume_to;
|
darwin_ops->to_resume = darwin_resume_to;
|
darwin_ops->to_thread_alive = darwin_thread_alive;
|
darwin_ops->to_thread_alive = darwin_thread_alive;
|
darwin_ops->to_pid_to_str = darwin_pid_to_str;
|
darwin_ops->to_pid_to_str = darwin_pid_to_str;
|
darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
|
darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
|
darwin_ops->to_load = NULL;
|
darwin_ops->to_load = NULL;
|
darwin_ops->deprecated_xfer_memory = darwin_xfer_memory;
|
darwin_ops->deprecated_xfer_memory = darwin_xfer_memory;
|
darwin_ops->to_xfer_partial = darwin_xfer_partial;
|
darwin_ops->to_xfer_partial = darwin_xfer_partial;
|
darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
|
darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
|
darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
|
darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
|
|
|
darwin_complete_target (darwin_ops);
|
darwin_complete_target (darwin_ops);
|
|
|
add_target (darwin_ops);
|
add_target (darwin_ops);
|
|
|
inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
|
inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
|
getpid ());
|
getpid ());
|
|
|
add_setshow_zinteger_cmd ("darwin", class_obscure,
|
add_setshow_zinteger_cmd ("darwin", class_obscure,
|
&darwin_debug_flag, _("\
|
&darwin_debug_flag, _("\
|
Set if printing inferior communication debugging statements."), _("\
|
Set if printing inferior communication debugging statements."), _("\
|
Show if printing inferior communication debugging statements."), NULL,
|
Show if printing inferior communication debugging statements."), NULL,
|
NULL, NULL,
|
NULL, NULL,
|
&setdebuglist, &showdebuglist);
|
&setdebuglist, &showdebuglist);
|
|
|
add_setshow_boolean_cmd ("mach-exceptions", class_support,
|
add_setshow_boolean_cmd ("mach-exceptions", class_support,
|
&enable_mach_exceptions, _("\
|
&enable_mach_exceptions, _("\
|
Set if mach exceptions are caught."), _("\
|
Set if mach exceptions are caught."), _("\
|
Show if mach exceptions are caught."), _("\
|
Show if mach exceptions are caught."), _("\
|
When this mode is on, all low level exceptions are reported before being\n\
|
When this mode is on, all low level exceptions are reported before being\n\
|
reported by the kernel."),
|
reported by the kernel."),
|
&set_enable_mach_exceptions, NULL,
|
&set_enable_mach_exceptions, NULL,
|
&setlist, &showlist);
|
&setlist, &showlist);
|
}
|
}
|
|
|
