[RFA] Darwin/x86 port (v2 - part 2: darwin-nat.?)

Tristan Gingold
2008-11-13T09:17:40Z

darwin-nat.h:

/* Common things used by the various darwin files
Copyright (C) 1995, 1996, 1997, 1999, 2000, 2007, 2008
Free Software Foundation, Inc.

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
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __DARWIN_NAT_H__
#define __DARWIN_NAT_H__

#include <mach/mach.h>

DEF_VEC_I(thread_t);

struct darwin_exception_info
{
exception_mask_t masks[EXC_TYPES_COUNT];
mach_port_t ports[EXC_TYPES_COUNT];
exception_behavior_t behaviors[EXC_TYPES_COUNT];
thread_state_flavor_t flavors[EXC_TYPES_COUNT];
mach_msg_type_number_t count;
};
typedef struct darwin_exception_info darwin_exception_info;

struct darwin_inferior
{
int pid;
task_t task;
/* Previous port for requesr notification on task. */
mach_port_t prev_not_port;

darwin_exception_info exception_info;

/* Sorted vector of known threads. */
VEC(thread_t) *threads;
};
typedef struct darwin_inferior darwin_inferior;

extern darwin_inferior *darwin_inf;

/* Exception port. */
extern mach_port_t darwin_ex_port;

/* Notification port. */
extern mach_port_t darwin_not_port;

/* Port set. */
extern mach_port_t darwin_port_set;

/* A copy of mach_host_self (). */
extern mach_port_t darwin_host_self;

#if (defined __GNUC__)
#define __MACH_CHECK_FUNCTION __PRETTY_FUNCTION__
#else
#define __MACH_CHECK_FUNCTION ((__const char *) 0)
#endif

#define MACH_CHECK_ERROR(ret) \
mach_check_error (ret, __FILE__, __LINE__, __MACH_CHECK_FUNCTION);

extern void mach_check_error (kern_return_t ret, const char *file,
unsigned int line, const char *func);

#endif /* __DARWIN_NAT_H__ */

darwin-nat.c:

/* Darwin support for GDB, the GNU debugger.
Copyright (C) 2008 Free Software Foundation, Inc.

Contributed by AdaCore.

This file is part of GDB.

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
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "defs.h"
#include "top.h"
#include "inferior.h"
#include "target.h"
#include "symfile.h"
#include "symtab.h"
#include "objfiles.h"
#include "gdb.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "gdbthread.h"
#include "regcache.h"
#include "event-top.h"
#include "inf-loop.h"
#include "gdb_stat.h"
#include "exceptions.h"
#include "inf-child.h"
#include "value.h"
#include "arch-utils.h"
#include "bfd.h"

#include <sys/ptrace.h>
#include <sys/signal.h>
#include <machine/setjmp.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <ctype.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/proc.h>

#include <mach/mach_error.h>
#include <mach/mach_vm.h>
#include <mach/mach_init.h>
#include <mach/vm_map.h>
#include <mach/task.h>
#include <mach/mach_port.h>
#include <mach/thread_act.h>
#include <mach/port.h>

#include "darwin-nat.h"

#define PTRACE(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);

static void darwin_stop (ptid_t);

static void darwin_resume (ptid_t ptid, int step,
enum target_signal signal);

static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);

static void darwin_mourn_inferior (struct target_ops *ops);

static int darwin_lookup_task (char *args, task_t * ptask, int *ppid);

static void darwin_kill_inferior (void);

static void darwin_ptrace_me (void);

static void darwin_ptrace_him (int pid);

static void darwin_create_inferior (struct target_ops *ops, char *exec_file,
char *allargs, char **env, int from_tty);

static void darwin_files_info (struct target_ops *ops);

static char *darwin_pid_to_str (ptid_t tpid);

static int darwin_thread_alive (ptid_t tpid);

/* This one is called in darwin-nat.c, but needs to be provided by the
platform specific nat code. It allows each platform to add platform specific
stuff to the darwin_ops. */
extern void darwin_complete_target (struct target_ops *target);

darwin_inferior *darwin_inf = NULL;

static struct target_ops *darwin_ops;

/* Task identifier of gdb. */
static task_t gdb_task;

/* A copy of mach_host_self (). */
mach_port_t darwin_host_self;

/* Exception port. */
mach_port_t darwin_ex_port;

/* Notification port. */
mach_port_t darwin_not_port;

/* Port set. */
mach_port_t darwin_port_set;

/* Page size. */
static vm_size_t mach_page_size;

/* If Set, catch all mach exceptions (before they are converted to signals
by the kernel). */
static int enable_mach_exceptions;

#define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
#define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)

static union {
mach_msg_header_t hdr;
char data[1024];
} msgin, msgout;

static enum msg_state { NO_MESSAGE, GOT_MESSAGE, REPLY_SENT } msg_state;

static struct exc_msg
{
mach_port_t port;
mach_port_t thread_port;
mach_port_t task_port;
exception_type_t ex_type;
mach_msg_type_number_t data_count;
integer_t ex_data[4];
} exc_msg;

/* This controls output of inferior debugging.
1 = basic exception handling
2 = task management
3 = thread management
4 = pending_event_handler
6 = most chatty level */

static int inferior_debug_flag = 0;

static void
inferior_debug (int level, const char *fmt, ...)
{
va_list ap;

if (inferior_debug_flag < level)
return;

va_start (ap, fmt);
printf_unfiltered ("[%d inferior]: ", getpid ());
vprintf_unfiltered (fmt, ap);
va_end (ap);
}

void
mach_check_error (kern_return_t ret, const char *file,
unsigned int line, const char *func)
{
if (ret == KERN_SUCCESS)
return;
if (func == NULL)
func = "[UNKNOWN]";

error ("error on line %u of \"%s\" in function \"%s\": %s (0x%lx)\n",
line, file, func, mach_error_string (ret), (unsigned long) ret);
}

static const char *
unparse_exception_type (unsigned int i)
{
static char unknown_exception_buf[32];

switch (i)
{
case EXC_BAD_ACCESS:
return "EXC_BAD_ACCESS";
case EXC_BAD_INSTRUCTION:
return "EXC_BAD_INSTRUCTION";
case EXC_ARITHMETIC:
return "EXC_ARITHMETIC";
case EXC_EMULATION:
return "EXC_EMULATION";
case EXC_SOFTWARE:
return "EXC_SOFTWARE";
case EXC_BREAKPOINT:
return "EXC_BREAKPOINT";
case EXC_SYSCALL:
return "EXC_SYSCALL";
case EXC_MACH_SYSCALL:
return "EXC_MACH_SYSCALL";
case EXC_RPC_ALERT:
return "EXC_RPC_ALERT";
case EXC_CRASH:
return "EXC_CRASH";
default:
snprintf (unknown_exception_buf, 32, "??? (%d)", i);
return unknown_exception_buf;
}
}

static int
darwin_ptrace (const char *name,
int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
{
int ret;

ret = ptrace (request, pid, (caddr_t) arg3, arg4);

inferior_debug (2, "ptrace (%s, %d, 0x%x, %d): %d (%s)\n",
name, pid, arg3, arg4, ret,
(ret != 0) ? strerror (errno) : "no error");
return ret;
}

static int
cmp_thread_t (const void *l, const void *r)
{
thread_t lt = *(const thread_t *)l;
thread_t lr = *(const thread_t *)r;
return (int)(lr - lt);
}

static void
darwin_check_new_threads (darwin_inferior *inf)
{
kern_return_t kret;
unsigned int i;
thread_array_t thread_list;
unsigned int new_nbr;
unsigned int old_nbr;
unsigned int new_ix, old_ix;
VEC(thread_t) *thread_vec;

/* Get list of threads. */
kret = task_threads (inf->task, &thread_list, &new_nbr);
MACH_CHECK_ERROR (kret);
if (kret != KERN_SUCCESS)
return;

if (new_nbr > 1)
qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);

thread_vec = VEC_alloc (thread_t, new_nbr);

if (inf->threads)
old_nbr = VEC_length (thread_t, inf->threads);
else
old_nbr = 0;

if (0)
printf_unfiltered ("darwin_check_new_threads: old=%d new=%d\n",
old_nbr, new_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_list[new_ix] : THREAD_NULL;
thread_t old_id = (old_ix < old_nbr) ?
VEC_index (thread_t, inf->threads, old_ix) : THREAD_NULL;

if (0)
printf_unfiltered (" old=%x new=%x\n", old_id, new_id);

if (old_id == new_id)
{
/* Thread still exist. */
VEC_safe_push (thread_t, thread_vec, old_id);
new_ix++;
old_ix++;

kret = mach_port_deallocate (gdb_task, old_id);
MACH_CHECK_ERROR (kret);
continue;
}
if (new_id < old_id || old_ix == old_nbr)
{
/* A thread was created. */
struct thread_info *tp;

tp = add_thread (ptid_build (inf->pid, 0, new_id));
VEC_safe_push (thread_t, thread_vec, new_id);
new_ix++;
continue;
}
if (new_id > old_id || new_ix == new_nbr)
{
/* A thread was removed. */
delete_thread (ptid_build (inf->pid, 0, old_id));
kret = mach_port_deallocate (gdb_task, old_id);
MACH_CHECK_ERROR (kret);
old_ix++;
}
}

if (inf->threads)
VEC_free (thread_t, inf->threads);
inf->threads = thread_vec;

kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
(new_nbr * sizeof (int)));
MACH_CHECK_ERROR (kret);
}

static void
darwin_check_osabi (darwin_inferior *inf, thread_t thread)
{
if (gdbarch_osabi (current_gdbarch) == GDB_OSABI_UNKNOWN)
{
/* Attaching to a process. Let's figure out what kind it is. */
x86_thread_state_t gp_regs;
struct gdbarch_info info;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t ret;

ret = thread_get_state (thread, x86_THREAD_STATE,
(thread_state_t) &gp_regs, &gp_count);
if (ret != KERN_SUCCESS)
{
MACH_CHECK_ERROR (ret);
return;
}

gdbarch_info_init (&info);
gdbarch_info_fill (&info);
info.byte_order = gdbarch_byte_order (current_gdbarch);
info.osabi = GDB_OSABI_DARWIN;
if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_x86_64);
else
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_i386_i386);
gdbarch_update_p (info);
}
}

static void
darwin_stop (ptid_t t)
{
int ret;

ret = kill (ptid_get_pid (inferior_ptid), SIGINT);
}

#define X86_EFLAGS_T 0x100UL

static void
darwin_set_sstep (thread_t thread, int enable)
{
x86_thread_state_t regs;
unsigned int count = x86_THREAD_STATE_COUNT;
kern_return_t kret;

inferior_debug (2, "darwin_set_sstep (thread=%x, enable=%d)\n",
thread, enable);

kret = thread_get_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, &count);
if (kret != KERN_SUCCESS)
{
printf_unfiltered ("darwin_set_sstep: error %x, thread=%x\n",
kret, thread);
return;
}
switch (regs.tsh.flavor)
{
case x86_THREAD_STATE32:
{
__uint32_t bit = enable ? X86_EFLAGS_T : 0;

if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts32.__eflags = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
kret = thread_set_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, count);
MACH_CHECK_ERROR (kret);
}
break;
case x86_THREAD_STATE64:
{
__uint64_t bit = enable ? X86_EFLAGS_T : 0;

if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts64.__rflags = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
kret = thread_set_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, count);
MACH_CHECK_ERROR (kret);
}
break;
default:
error ("darwin_set_sstep: unknown flavour: %d\n", regs.tsh.flavor);
}
}

static void
darwin_resume (ptid_t ptid, int step, enum target_signal signal)
{
struct target_waitstatus status;
int pid;
thread_t thread;
kern_return_t kret;
int res;

/* minus_one_ptid is RESUME_ALL. */
if (ptid_equal (ptid, minus_one_ptid))
ptid = inferior_ptid;

pid = ptid_get_pid (ptid);
thread = ptid_get_tid (ptid);

inferior_debug
(2, "darwin_resume: state=%d, thread=0x%x, step=%d signal=%d\n",
msg_state, thread, step, signal);

switch (msg_state)
{
case GOT_MESSAGE:
switch (exc_msg.ex_type)
{
case EXC_SOFTWARE:
if (exc_msg.ex_data[0] == EXC_SOFT_SIGNAL)
{
int nsignal = target_signal_to_host (signal);
res = PTRACE (PT_THUPDATE, pid,
(void *)exc_msg.thread_port, nsignal);
if (res < 0)
printf_unfiltered ("ptrace THUP: res=%d\n", res);
}
break;

default:
break;
}

if (thread != 0)
darwin_set_sstep (thread, step);

kret = mach_msg (&msgout.hdr, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
msgout.hdr.msgh_size, 0,
MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (kret != 0)
printf_unfiltered ("mach_msg (reply) ret=%d\n", kret);

msg_state = REPLY_SENT;

#if 0
kret = mach_port_deallocate (gdb_task, exc_msg.thread_port);
MACH_CHECK_ERROR (kret);
#endif
break;

case NO_MESSAGE:
if (step)
res = PTRACE (PT_STEP, pid, (caddr_t)1, 0);
else
res = PTRACE (PT_CONTINUE, pid, (caddr_t)1, 0);
if (res < 0)
printf_unfiltered ("ptrace CONT: res=%d\n", res);
break;

default:
gdb_assert (0);
}
}

kern_return_t
#ifdef HAVE_64_BIT_MACH_EXCEPTIONS
catch_mach_exception_raise_state
#else
catch_exception_raise_state
#endif
(mach_port_t port,
exception_type_t exception_type, mach_exception_data_t exception_data,
mach_msg_type_number_t data_count, thread_state_flavor_t * state_flavor,
thread_state_t in_state, mach_msg_type_number_t in_state_count,
thread_state_t out_state, mach_msg_type_number_t out_state_count)
{
return KERN_FAILURE;
}

kern_return_t
#ifdef HAVE_64_BIT_MACH_EXCEPTIONS
catch_mach_exception_raise_state_identity
#else
catch_exception_raise_state_identity
#endif
(mach_port_t port, mach_port_t thread_port, mach_port_t task_port,
exception_type_t exception_type, mach_exception_data_t exception_data,
mach_msg_type_number_t data_count, thread_state_flavor_t * state_flavor,
thread_state_t in_state, mach_msg_type_number_t in_state_count,
thread_state_t out_state, mach_msg_type_number_t out_state_count)
{
kern_return_t kret;

kret = mach_port_deallocate (mach_task_self (), task_port);
MACH_CHECK_ERROR (kret);
kret = mach_port_deallocate (mach_task_self (), thread_port);
MACH_CHECK_ERROR (kret);

return KERN_FAILURE;
}

kern_return_t
catch_exception_raise (mach_port_t port,
mach_port_t thread_port,
mach_port_t task_port,
exception_type_t exception_type,
exception_data_t exception_data,
mach_msg_type_number_t data_count)
{
kern_return_t kret;
int i;
int res;

/* We got new rights to the task. Get rid of it. */
kret = mach_port_deallocate (mach_task_self (), task_port);
MACH_CHECK_ERROR (kret);

inferior_debug
(7, "catch_exception_raise: exception_type=%d, data_count=%d\n",
exception_type, data_count);
if (0)
{
for (i = 0; i < data_count; i++)
printf_unfiltered (" %08x", exception_data[i]);
printf_unfiltered ("\n");
}

/* Save the message.
FIXME: this should be in a per-thread variable. */
exc_msg.port = port;
exc_msg.thread_port = thread_port;
exc_msg.task_port = task_port;
exc_msg.ex_type = exception_type;
exc_msg.data_count = data_count;
for (i = 0; i < data_count && i < 4; i++)
exc_msg.ex_data[i] = exception_data[i];

return KERN_SUCCESS;
}

static ptid_t
darwin_wait (ptid_t ptid, struct target_waitstatus *status)
{
kern_return_t kret;
mach_msg_header_t *hdr = &msgin.hdr;
pid_t pid = ptid_get_pid (inferior_ptid); /* FIXME. */

gdb_assert (msg_state != GOT_MESSAGE);

/* Debug: poll child status. */
if (0)
{
pid_t pid2;
int wstatus;

pid2 = wait4 (-1, &wstatus, WNOHANG | WUNTRACED, NULL);
if (pid2 > 0)
printf_unfiltered ("darwin_wait: wait4 pid=%d, status=0x%x\n",
pid2, wstatus);
}

inferior_debug (6, "darwin_wait: waiting for a message\n");

/* Wait for a message. */
kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);

if (kret == MACH_RCV_INTERRUPTED)
{
status->kind = TARGET_WAITKIND_IGNORE;
return minus_one_ptid;
}

if (kret != MACH_MSG_SUCCESS)
{
printf_unfiltered ("mach_msg: ret=%x\n", kret);
status->kind = TARGET_WAITKIND_SPURIOUS;
return minus_one_ptid;
}

/* Debug: display message. */
if (0)
{
const unsigned long *buf = (unsigned long *) hdr;
unsigned int i;

printf (" bits: 0x%x", hdr->msgh_bits);
printf (", size: 0x%x", hdr->msgh_size);
printf (", remote-port: 0x%x", hdr->msgh_remote_port);
printf (", local-port: 0x%x", hdr->msgh_local_port);
printf (", reserved: 0x%x", hdr->msgh_reserved);
printf (", id: 0x%x\n", hdr->msgh_id);

if (0)
{
printf (" data:");
for (i = 0; i < hdr->msgh_size; i++)
printf (" %08lx", buf[i]);
printf ("\n");
}
}

/* Exception message. */
if (hdr->msgh_local_port == darwin_ex_port)
{
/* Handle it via the exception server. */
if (!exc_server (&msgin.hdr, &msgout.hdr))
{
printf_unfiltered ("exc_server: unknown message (id=%x)\n",
hdr->msgh_id);
status->kind = TARGET_WAITKIND_SPURIOUS;
return minus_one_ptid;
}

status->kind = TARGET_WAITKIND_STOPPED;

inferior_debug (2, "darwin_wait: thread=%x, got %s\n",
exc_msg.thread_port,
unparse_exception_type (exc_msg.ex_type));

switch (exc_msg.ex_type)
{
case EXC_BAD_ACCESS:
status->value.sig = TARGET_EXC_BAD_ACCESS;
break;
case EXC_BAD_INSTRUCTION:
status->value.sig = TARGET_EXC_BAD_INSTRUCTION;
break;
case EXC_ARITHMETIC:
status->value.sig = TARGET_EXC_ARITHMETIC;
break;
case EXC_EMULATION:
status->value.sig = TARGET_EXC_EMULATION;
break;
case EXC_SOFTWARE:
if (exc_msg.ex_data[0] == EXC_SOFT_SIGNAL)
{
status->value.sig = target_signal_from_host (exc_msg.ex_data[1]);
inferior_debug (2, " (signal %d: %s)\n",
exc_msg.ex_data[1],
target_signal_to_name (status->value.sig));
}
else
status->value.sig = TARGET_EXC_SOFTWARE;
break;
case EXC_BREAKPOINT:
/* Many internal GDB routines expect breakpoints to be reported
as TARGET_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
as a spurious signal. */
status->value.sig = TARGET_SIGNAL_TRAP;
break;
default:
status->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
}

msg_state = GOT_MESSAGE;

return ptid_build (pid, 0, exc_msg.thread_port);
}
else if (hdr->msgh_local_port == darwin_not_port)
{
pid_t res;
int wstatus;

/* FIXME: translate task port to pid. */
res = wait4 (pid, &wstatus, 0, NULL);
if (res != pid)
{
printf_unfiltered ("wait4: res=%x\n", res);
wstatus = 0;
}
status->kind = TARGET_WAITKIND_EXITED;
status->value.integer = WEXITSTATUS (wstatus);

inferior_debug (2, "darwin_wait: pid=%d exit, status=%x\n",
pid, wstatus);

msg_state = NO_MESSAGE;

return ptid;
}
else
{
printf ("Bad local-port: %x\n", hdr->msgh_local_port);
status->kind = TARGET_WAITKIND_SPURIOUS;
return minus_one_ptid;
}
}

#if 0
static void
darwin_list_gdb_ports (const char *msg)
{
mach_port_name_array_t names;
mach_port_type_array_t types;
unsigned int name_count, type_count;
kern_return_t result;
int i;

result = mach_port_names (gdb_task, &names, &name_count, &types, &type_count);
MACH_CHECK_ERROR (result);

gdb_assert (name_count == type_count);

printf_unfiltered ("Ports for %s:", msg);
for (i = 0; i < name_count; ++i)
printf_unfiltered (" 0x%04x", names[i]);
printf_unfiltered ("\n");

vm_deallocate (gdb_task, (vm_address_t) names,
(name_count * sizeof (mach_port_t)));
vm_deallocate (gdb_task, (vm_address_t) types,
(type_count * sizeof (mach_port_type_t)));
}
#endif

static void
darwin_mourn_inferior (struct target_ops *ops)
{
struct inferior *inf = current_inferior ();
kern_return_t kret;
mach_port_t prev;
int i;

unpush_target (darwin_ops);

/* Deallocate threads. */
if (darwin_inf->threads)
{
int k;
thread_t t;
for (k = 0; VEC_iterate(thread_t, darwin_inf->threads, k, t); k++)
{
kret = mach_port_deallocate (gdb_task, t);
MACH_CHECK_ERROR (kret);
}
VEC_free (thread_t, darwin_inf->threads);
darwin_inf->threads = NULL;
}

/* FIXME: only if the task is still alive. */
kret = mach_port_request_notification (gdb_task, darwin_inf->task,
MACH_NOTIFY_DEAD_NAME, 0,
darwin_inf->prev_not_port,
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&prev);
#if 0
MACH_CHECK_ERROR (kret);
#endif

if (kret == KERN_SUCCESS)
{
kret = mach_port_deallocate (gdb_task, prev);
MACH_CHECK_ERROR (kret);
}

/* Deallocate saved exception ports. */
for (i = 0; i < darwin_inf->exception_info.count; i++)
{
kret = mach_port_deallocate
(gdb_task, darwin_inf->exception_info.ports[i]);
MACH_CHECK_ERROR (kret);
}
darwin_inf->exception_info.count = 0;

kret = mach_port_deallocate (gdb_task, darwin_inf->task);
MACH_CHECK_ERROR (kret);

darwin_inf->task = 0;
darwin_inf->pid = 0;

generic_mourn_inferior ();
}

static void
darwin_stop_inferior (darwin_inferior *inf)
{
struct target_waitstatus wstatus;
ptid_t ptid;
kern_return_t kret;
int status;
int res;

gdb_assert (inf != NULL);

kret = task_suspend (inf->task);
MACH_CHECK_ERROR (kret);

if (msg_state == GOT_MESSAGE)
darwin_resume (inferior_ptid, 0, 0);

res = kill (inf->pid, SIGSTOP);
if (res != 0)
printf_unfiltered ("cannot kill: %s\n", strerror (errno));

ptid = darwin_wait (inferior_ptid, &wstatus);
gdb_assert (wstatus.kind = TARGET_WAITKIND_STOPPED);
}

static void
darwin_kill_inferior (void)
{
struct target_waitstatus wstatus;
ptid_t ptid;
kern_return_t kret;
int status;
int res;

gdb_assert (darwin_inf != NULL);

if (ptid_equal (inferior_ptid, null_ptid))
return;

darwin_stop_inferior (darwin_inf);

res = PTRACE (PT_KILL, darwin_inf->pid, 0, 0);
gdb_assert (res == 0);

if (msg_state == GOT_MESSAGE)
{
exc_msg.ex_type = 0;
darwin_resume (inferior_ptid, 0, 0);
}

kret = task_resume (darwin_inf->task);
MACH_CHECK_ERROR (kret);

ptid = darwin_wait (inferior_ptid, &wstatus);

/* This double wait seems required... */
res = waitpid (darwin_inf->pid, &status, 0);
gdb_assert (res == darwin_inf->pid);

msg_state = NO_MESSAGE;

target_mourn_inferior ();
}

/* 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.
FIXME: is there a lighter way ? */
static int ptrace_fds[2];

static void
darwin_ptrace_me (void)
{
int res;
char c;

/* Close write end point. */
close (ptrace_fds[1]);

/* Wait until gdb is ready. */
res = read (ptrace_fds[0], &c, 1);
if (res != 0)
fprintf (stderr, "unexpected read result: %d\n", res);
close (ptrace_fds[0]);

/* Get rid of privileges. */
setegid (getgid ());

/* Set TRACEME. */
PTRACE (PT_TRACE_ME, 0, 0, 0);

/* Redirect signals to exception port. */
PTRACE (PT_SIGEXC, 0, 0, 0);
}

/* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
static void
darwin_pre_ptrace (void)
{
if (pipe (ptrace_fds) != 0)
{
error ("unable to create a pipe");
ptrace_fds[0] = -1;
ptrace_fds[1] = -1;
}
}

static kern_return_t
darwin_save_exception_ports (darwin_inferior *inf)
{
kern_return_t kret;

inf->exception_info.count =
sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);

kret = task_get_exception_ports
(inf->task, EXC_MASK_ALL, inf->exception_info.masks,
&inf->exception_info.count, inf->exception_info.ports,
inf->exception_info.behaviors, inf->exception_info.flavors);
return kret;
}

static kern_return_t
darwin_restore_exception_ports (darwin_inferior *inf)
{
int i;
kern_return_t kret;

for (i = 0; i < inf->exception_info.count; i++)
{
kret = task_set_exception_ports
(inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
if (kret != KERN_SUCCESS)
return kret;
}

return KERN_SUCCESS;
}

static void
darwin_attach_pid (int pid)
{
task_t itask;
kern_return_t kret;
mach_port_t prev_port;
int traps_expected;
exception_mask_t mask;

kret = task_for_pid (gdb_task, pid, &itask);
if (kret != KERN_SUCCESS)
{
int status;
struct inferior *inf = current_inferior ();

if (!inf->attach_flag)
{
kill (pid, 9);
waitpid (pid, &status, 0);
}

error ("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
" (please check gdb is setgid procmod)",
pid, mach_error_string (kret), (unsigned long) kret);
}

inferior_debug (2, "inferior task: 0x%08x, pid: %d\n", itask, pid);

if (darwin_ex_port == MACH_PORT_NULL)
{
/* Create a port to get exceptions. */
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
&darwin_ex_port);
gdb_assert (kret == KERN_SUCCESS);

kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
MACH_MSG_TYPE_MAKE_SEND);
gdb_assert (kret == KERN_SUCCESS);

/* Create a port set and put ex_port in it. */
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
&darwin_port_set);
gdb_assert (kret == KERN_SUCCESS);

kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
gdb_assert (kret == KERN_SUCCESS);

/* Create a port to be notified when the child task terminates. */
kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
&darwin_not_port);
gdb_assert (kret == KERN_SUCCESS);

kret = mach_port_insert_right (gdb_task, darwin_not_port, darwin_not_port,
MACH_MSG_TYPE_MAKE_SEND);
gdb_assert (kret == KERN_SUCCESS);

kret = mach_port_move_member (gdb_task, darwin_not_port, darwin_port_set);
gdb_assert (kret == KERN_SUCCESS);
}

kret = mach_port_request_notification (gdb_task, itask,
MACH_NOTIFY_DEAD_NAME, 0,
darwin_not_port,
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&darwin_inf->prev_not_port);
gdb_assert (kret == KERN_SUCCESS);

darwin_inf->task = itask;
darwin_inf->pid = pid;

kret = darwin_save_exception_ports (darwin_inf);
gdb_assert (kret == KERN_SUCCESS);

/* Set exception port. */
if (enable_mach_exceptions)
mask = EXC_MASK_ALL;
else
mask = EXC_MASK_SOFTWARE;
kret = task_set_exception_ports
(itask, mask, darwin_ex_port, EXCEPTION_DEFAULT, THREAD_STATE_NONE);
gdb_assert (kret == KERN_SUCCESS);

push_target (darwin_ops);
}

static void
darwin_init_thread_list (darwin_inferior *inf)
{
thread_t thread;

darwin_check_new_threads (inf);

gdb_assert (inf->threads && VEC_length (thread_t, inf->threads) > 0);
thread = VEC_index (thread_t, inf->threads, 0);
inferior_ptid = ptid_build (inf->pid, 0, thread);
}

static void
darwin_ptrace_him (int pid)
{
task_t itask;
kern_return_t kret;
mach_port_t prev_port;
int traps_expected;

darwin_attach_pid (pid);

/* Let's the child run. */
close (ptrace_fds[0]);
close (ptrace_fds[1]);

/* fork_inferior automatically add a thread - but it uses a wrong tid. */
delete_thread_silent (inferior_ptid);
darwin_init_thread_list (darwin_inf);

startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
}

static void
darwin_create_inferior (struct target_ops *ops, char *exec_file,
char *allargs, char **env, int from_tty)
{
/* Do the hard work. */
fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
darwin_pre_ptrace, NULL);

/* Return now in case of error. */
if (ptid_equal (inferior_ptid, null_ptid))
return;
}

/* Attach to process PID, then initialize for debugging it
and wait for the trace-trap that results from attaching. */
static void
darwin_attach (struct target_ops *ops, char *args, int from_tty)
{
pid_t pid;
pid_t pid2;
int wstatus;
int res;
struct inferior *inf;

gdb_assert (msg_state == NO_MESSAGE);

if (!args)
error_no_arg ("process-id to attach");

pid = atoi (args);

if (pid == getpid ()) /* Trying to masturbate? */
error ("I refuse to debug myself!");

if (from_tty)
printf_unfiltered ("Attaching to pid %d\n", pid);

res = PTRACE (PT_ATTACHEXC, pid, 0, 0);
if (res != 0)
error ("Unable to attach to process-id %d: %s (%d)",
pid, strerror (errno), errno);

inf = add_inferior (pid);
inf->attach_flag = 1;

darwin_attach_pid (pid);

pid2 = wait4 (pid, &wstatus, WUNTRACED, NULL);
gdb_assert (pid2 == pid);
inferior_debug (1, "darwin_attach: wait4 pid=%d, status=0x%x\n",
pid2, wstatus);

darwin_init_thread_list (darwin_inf);

darwin_check_osabi (darwin_inf, ptid_get_tid (inferior_ptid));

/* Looks strange, but the kernel doesn't stop the process...
(Bug in Leopard ?)
Do it manually. */
/* FIXME: doesn't look to work with multi-threads!! */
kill (pid, SIGSTOP);
}

\f
/* Take a program previously attached to and detaches it.
The program resumes execution and will no longer stop
on signals, etc. We'd better not have left any breakpoints
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
previously attached. It *might* work if the program was
started via fork. */
static void
darwin_detach (struct target_ops *ops, char *args, int from_tty)
{
kern_return_t kret;
int res;

if (from_tty)
{
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
printf_unfiltered ("Detaching from program: %s, %d\n", exec_file,
ptid_get_pid (inferior_ptid));
gdb_flush (gdb_stdout);
}

darwin_stop_inferior (darwin_inf);

kret = darwin_restore_exception_ports (darwin_inf);
MACH_CHECK_ERROR (kret);

if (msg_state == GOT_MESSAGE)
{
exc_msg.ex_type = 0;
darwin_resume (inferior_ptid, 0, 0);
}

kret = task_resume (darwin_inf->task);
gdb_assert (kret == KERN_SUCCESS);

res = PTRACE (PT_DETACH, darwin_inf->pid, 0, 0);
if (res != 0)
printf_unfiltered ("Unable to detach to process-id %d: %s (%d)",
darwin_inf->pid, strerror (errno), errno);

msg_state = NO_MESSAGE;

darwin_mourn_inferior (ops);
}

static void
darwin_files_info (struct target_ops *ops)
{
gdb_assert (darwin_inf != NULL);
}

static char *
darwin_pid_to_str (ptid_t ptid)
{
static char buf[128];

snprintf (buf, sizeof (buf),
"process %d gdb-thread 0x%lx",
(unsigned) ptid_get_pid (ptid),
(unsigned long) ptid_get_tid (ptid));
return buf;
}

static int
darwin_thread_alive (ptid_t ptid)
{
return 1;
}

/* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
copy it to RDADDR in gdb's address space.
If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
to ADDR in inferior task's address space.
Return 0 on failure; number of bytes read / writen otherwise. */
static int
darwin_read_write_inferior (task_t task, CORE_ADDR addr,
char *rdaddr, const char *wraddr, int length)
{
kern_return_t err;
mach_vm_address_t offset = addr & (mach_page_size - 1);
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);
pointer_t copied;
int copy_count;
mach_vm_size_t remaining_length;
mach_vm_address_t region_address;
mach_vm_size_t region_length;

inferior_debug (8, "darwin_read_write_inferior(%s, len=%d)\n",
core_addr_to_string (addr), length);

/* Get memory from inferior with page aligned addresses */
err = mach_vm_read (task, low_address, aligned_length,
&copied, &copy_count);
if (err != KERN_SUCCESS)
{
warning ("darwin_read_write_inferior: vm_read failed: %s",
mach_error_string (err));
return 0;
}

if (rdaddr != NULL)
memcpy (rdaddr, (char *)copied + offset, length);

if (wraddr == NULL)
goto out;

memcpy ((char *)copied + offset, wraddr, length);

/* Do writes atomically.
First check for holes and unwritable memory. */
for (region_address = low_address, remaining_length = aligned_length;
region_address < low_address + aligned_length;
region_address += region_length, remaining_length -= region_length)
{
vm_region_basic_info_data_64_t info;
mach_port_t object_name;
mach_vm_address_t old_address = region_address;
mach_msg_type_number_t count;

region_length = remaining_length;
count = VM_REGION_BASIC_INFO_COUNT_64;
err = mach_vm_region (task, &region_address, &region_length,
VM_REGION_BASIC_INFO_64,
(vm_region_info_t) &info, &count, &object_name);

if (err != KERN_SUCCESS)
{
warning ("darwin_write_inferior: mach_vm_region failed: %s",
mach_error_string (err));
goto out;
}

/* Check for holes in memory */
if (region_address > old_address)
{
warning ("No memory at %s (vs %s+0x%x). Nothing written",
core_addr_to_string (old_address),
core_addr_to_string (region_address),
(unsigned)region_length);
length = 0;
goto out;
}

if (!(info.max_protection & VM_PROT_WRITE))
{
warning ("Memory at address %s is unwritable. Nothing written",
core_addr_to_string (old_address));
length = 0;
goto out;
}

if (!(info.protection & VM_PROT_WRITE))
{
err = mach_vm_protect (task, old_address, region_length,
FALSE, info.protection | VM_PROT_WRITE);
if (err != KERN_SUCCESS)
{
warning
("darwin_read_write_inferior: mach_vm_protect failed: %s",
mach_error_string (err));
length = 0;
goto out;
}
}
}

err = mach_vm_write (task, low_address, copied, aligned_length);

if (err != KERN_SUCCESS)
{
warning ("darwin_read_write_inferior: mach_vm_write failed: %s",
mach_error_string (err));
length = 0;
}
out:
mach_vm_deallocate (mach_task_self (), copied, copy_count);
return length;
}

\f
/* Return 0 on failure, number of bytes handled otherwise. TARGET
is ignored. */
static int
darwin_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
task_t task = darwin_inf->task;

if (task == MACH_PORT_NULL)
return 0;

inferior_debug (8, "darwin_xfer_memory(%s, %d, %c)\n",
core_addr_to_string (memaddr), len, write ? 'w' : 'r');

if (write)
return darwin_read_write_inferior (task, memaddr, NULL, myaddr, len);
else
return darwin_read_write_inferior (task, memaddr, myaddr, NULL, len);
}

static LONGEST
darwin_xfer_partial (struct target_ops *ops,
enum target_object object, const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len)
{
inferior_debug (8, "darwin_xfer_partial(%s, %d, rbuf=%p, wbuf=%p)\n",
core_addr_to_string (offset), (int)len, readbuf, writebuf);

if (object != TARGET_OBJECT_MEMORY)
return -1;

return darwin_read_write_inferior (darwin_inf->task, offset,
readbuf, writebuf, len);
}

static void
set_enable_mach_exceptions (char *args, int from_tty,
struct cmd_list_element *c)
{
if (darwin_inf && darwin_inf->task != TASK_NULL)
{
exception_mask_t mask;
kern_return_t kret;

if (enable_mach_exceptions)
mask = EXC_MASK_ALL;
else
{
darwin_restore_exception_ports (darwin_inf);
mask = EXC_MASK_SOFTWARE;
}
kret = task_set_exception_ports (darwin_inf->task, mask, darwin_ex_port,
EXCEPTION_DEFAULT, THREAD_STATE_NONE);
MACH_CHECK_ERROR (kret);
}
}

void
_initialize_darwin_inferior ()
{
kern_return_t kret;

gdb_assert (darwin_inf == NULL);

gdb_task = mach_task_self ();
darwin_host_self = mach_host_self ();

/* Read page size. */
kret = host_page_size (darwin_host_self, &mach_page_size);
if (kret != KERN_SUCCESS)
{
mach_page_size = 0x1000;
MACH_CHECK_ERROR (kret);
}

darwin_inf = (struct darwin_inferior *)
xmalloc (sizeof (struct darwin_inferior));

memset (darwin_inf, 0, sizeof (*darwin_inf));

darwin_ops = inf_child_target ();

darwin_ops->to_shortname = "darwin-child";
darwin_ops->to_longname = "Darwin child process";
darwin_ops->to_doc =
"Darwin child process (started by the \"run\" command).";
darwin_ops->to_create_inferior = darwin_create_inferior;
darwin_ops->to_attach = darwin_attach;
darwin_ops->to_attach_no_wait = 0;
darwin_ops->to_detach = darwin_detach;
darwin_ops->to_files_info = darwin_files_info;
darwin_ops->to_wait = darwin_wait;
darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
darwin_ops->to_kill = darwin_kill_inferior;
darwin_ops->to_stop = darwin_stop;
darwin_ops->to_resume = darwin_resume;
darwin_ops->to_thread_alive = darwin_thread_alive;
darwin_ops->to_pid_to_str = darwin_pid_to_str;
darwin_ops->to_load = NULL;
darwin_ops->deprecated_xfer_memory = darwin_xfer_memory;
darwin_ops->to_xfer_partial = darwin_xfer_partial;
darwin_ops->to_has_thread_control = tc_schedlock /*| tc_switch */;

darwin_complete_target (darwin_ops);

add_target (darwin_ops);

inferior_debug (2, "GDB task: 0x%lx, pid: %d\n", mach_task_self (),
getpid ());

add_setshow_zinteger_cmd ("inferior", class_obscure,
&inferior_debug_flag, _("\
Set if printing inferior communication debugging statements."), _("\
Show if printing inferior communication debugging statements."), NULL,
NULL, NULL,
&setdebuglist, &showdebuglist);

add_setshow_boolean_cmd ("mach-exceptions", class_support,
&enable_mach_exceptions, _("\
Set 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\
reported by the kernel."),
&set_enable_mach_exceptions, NULL,
&setlist, &showlist);
}