Subversion Repositories openrisc_2011-10-31

/* Darwin support for GDB, the GNU debugger.

   Copyright (C) 2008, 2009, 2010 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 <libproc.h>

#include <sys/syscall.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"

/* Quick overview.

   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).

   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

   also use Mach to get inferior faults.  As we cannot use select(2) or

   signals with Mach port (the Mach communication channel), signals are

   reported to gdb as an exception.  Furthermore we detect death of the

   inferior through a Mach notification message.  This way we only wait

   on Mach ports.

   Some Mach documentation is available for Apple xnu source package or

   from the web.  */

#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_to (struct target_ops *ops, ptid_t ptid, int step,

                              enum target_signal signal);

static void darwin_resume (ptid_t ptid, int step,

                           enum target_signal signal);

static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,

                              struct target_waitstatus *status, int options);

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

static void darwin_mourn_inferior (struct target_ops *ops);

static void darwin_kill_inferior (struct target_ops *ops);

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 (struct target_ops *ops, ptid_t tpid);

static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);

/* Target operations for Darwin.  */

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;

/* 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;

/* Inferior that should report a fake stop event.  */

static struct inferior *darwin_inf_fake_stop;

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

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

/* This controls output of inferior debugging.  */

static int darwin_debug_flag = 0;

/* 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.

   Once gdb is built, you can either:

   * make it setgid procmod

   * or codesign it with any system-trusted signing authority.

   See taskgated(8) for details.  */

static const unsigned char info_plist[]

__attribute__ ((section ("__TEXT,__info_plist"),used)) =

  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

  "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""

  " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"

  "<plist version=\"1.0\">\n"

  "<dict>\n"

  "  <key>CFBundleIdentifier</key>\n"

  "  <string>org.gnu.gdb</string>\n"

  "  <key>CFBundleName</key>\n"

  "  <string>gdb</string>\n"

  "  <key>CFBundleVersion</key>\n"

  "  <string>1.0</string>\n"

  "  <key>SecTaskAccess</key>\n"

  "  <array>\n"

  "    <string>allowed</string>\n"

  "    <string>debug</string>\n"

  "  </array>\n"

  "</dict>\n"

  "</plist>\n";

static void

inferior_debug (int level, const char *fmt, ...)

{

  va_list ap;

  if (darwin_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]");

  warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)\n"),

           file, line, 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, _("unknown (%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 (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),

                  name, pid, arg3, arg4, ret,

                  (ret != 0) ? safe_strerror (errno) : _("no error"));

  return ret;

}

static int

cmp_thread_t (const void *l, const void *r)

{

  thread_t tl = *(const thread_t *)l;

  thread_t tr = *(const thread_t *)r;

  return (int)(tl - tr);

}

static void

darwin_check_new_threads (struct 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;

  darwin_inferior *darwin_inf = inf->private;

  VEC (darwin_thread_t) *thread_vec;

  /* Get list of threads.  */

  kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);

  MACH_CHECK_ERROR (kret);

  if (kret != KERN_SUCCESS)

    return;

  /* Sort the list.  */

  if (new_nbr > 1)

    qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);

  if (darwin_inf->threads)

    old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);

  else

    old_nbr = 0;

  /* Quick check for no changes.  */

  if (old_nbr == new_nbr)

    {

      for (i = 0; i < new_nbr; i++)

        if (thread_list[i]

            != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)

          break;

      if (i == new_nbr)

        {

          kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,

                                new_nbr * sizeof (int));

          MACH_CHECK_ERROR (kret);

          return;

        }

    }

  thread_vec = VEC_alloc (darwin_thread_t, 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;

      darwin_thread_t *old = (old_ix < old_nbr) ?

        VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;

      thread_t old_id = old ? old->gdb_port : THREAD_NULL;

      inferior_debug

        (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);

      if (old_id == new_id)

        {

          /* Thread still exist.  */

          VEC_safe_push (darwin_thread_t, thread_vec, old);

          new_ix++;

          old_ix++;

          kret = mach_port_deallocate (gdb_task, old_id);

          MACH_CHECK_ERROR (kret);

          continue;

        }

      if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)

        {

          /* Ignore dead ports.

             In some weird cases, we might get dead ports.  They should

             correspond to dead thread so they could safely be ignored.  */

          new_ix++;

          continue;

        }

      if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))

        {

          /* A thread was created.  */

          struct thread_info *tp;

          struct private_thread_info *pti;

          pti = XZALLOC (struct private_thread_info);

          pti->gdb_port = new_id;

          pti->msg_state = DARWIN_RUNNING;

          /* Add a new thread unless this is the first one ever met.  */

          if (!(old_nbr == 0 && new_ix == 0))

            tp = add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);

          else

            {

              tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));

              gdb_assert (tp);

              tp->private = pti;

            }

          VEC_safe_push (darwin_thread_t, thread_vec, pti);

          new_ix++;

          continue;

        }

      if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))

        {

          /* 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++;

          continue;

        }

      gdb_assert (0);

    }

  if (darwin_inf->threads)

    VEC_free (darwin_thread_t, darwin_inf->threads);

  darwin_inf->threads = thread_vec;

  kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,

                        new_nbr * sizeof (int));

  MACH_CHECK_ERROR (kret);

}

static int

find_inferior_task_it (struct inferior *inf, void *port_ptr)

{

  return inf->private->task == *(task_t*)port_ptr;

}

static int

find_inferior_notify_it (struct inferior *inf, void *port_ptr)

{

  return inf->private->notify_port == *(task_t*)port_ptr;

}

/* Return an inferior by task port.  */

static struct inferior *

darwin_find_inferior_by_task (task_t port)

{

  return iterate_over_inferiors (&find_inferior_task_it, &port);

}

/* Return an inferior by notification port.  */

static struct inferior *

darwin_find_inferior_by_notify (mach_port_t port)

{

  return iterate_over_inferiors (&find_inferior_notify_it, &port);

}

/* Return a thread by port.  */

static darwin_thread_t *

darwin_find_thread (struct inferior *inf, thread_t thread)

{

  darwin_thread_t *t;

  int k;

  for (k = 0;

       VEC_iterate (darwin_thread_t, inf->private->threads, k, t);

       k++)

    if (t->gdb_port == thread)

      return t;

  return NULL;

}

/* Suspend (ie stop) an inferior at Mach level.  */

static void

darwin_suspend_inferior (struct inferior *inf)

{

  if (!inf->private->suspended)

    {

      kern_return_t kret;

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

      MACH_CHECK_ERROR (kret);

      inf->private->suspended = 1;

    }

}

/* Resume an inferior at Mach level.  */

static void

darwin_resume_inferior (struct inferior *inf)

{

  if (inf->private->suspended)

    {

      kern_return_t kret;

      kret = task_resume (inf->private->task);

      MACH_CHECK_ERROR (kret);

      inf->private->suspended = 0;

    }

}

/* Iterator functions.  */

static int

darwin_suspend_inferior_it (struct inferior *inf, void *arg)

{

  darwin_suspend_inferior (inf);

  darwin_check_new_threads (inf);

  return 0;

}

static int

darwin_resume_inferior_it (struct inferior *inf, void *arg)

{

  darwin_resume_inferior (inf);

  return 0;

}

static void

darwin_dump_message (mach_msg_header_t *hdr, int disp_body)

{

  printf_unfiltered (_("message header:\n"));

  printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);

  printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);

  printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);

  printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);

  printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);

  printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);

  if (disp_body)

    {

      const unsigned char *data;

      const unsigned long *ldata;

      int size;

      int i;

      data = (unsigned char *)(hdr + 1);

      size = hdr->msgh_size - sizeof (mach_msg_header_t);

      if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)

        {

          mach_msg_body_t *bod = (mach_msg_body_t*)data;

          mach_msg_port_descriptor_t *desc =

            (mach_msg_port_descriptor_t *)(bod + 1);

          int k;

          NDR_record_t *ndr;

          printf_unfiltered (_("body: descriptor_count=%u\n"),

                             bod->msgh_descriptor_count);

          data += sizeof (mach_msg_body_t);

          size -= sizeof (mach_msg_body_t);

          for (k = 0; k < bod->msgh_descriptor_count; k++)

            switch (desc[k].type)

              {

              case MACH_MSG_PORT_DESCRIPTOR:

                printf_unfiltered

                  (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),

                   k, desc[k].type, desc[k].name, desc[k].disposition);

                break;

              default:

                printf_unfiltered (_(" descr %d: type=%u\n"),

                                   k, desc[k].type);

                break;

              }

          data += bod->msgh_descriptor_count

            * sizeof (mach_msg_port_descriptor_t);

          size -= bod->msgh_descriptor_count

            * sizeof (mach_msg_port_descriptor_t);

          ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);

          printf_unfiltered

            (_("NDR: mig=%02x if=%02x encod=%02x "

               "int=%02x char=%02x float=%02x\n"),

             ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,

             ndr->int_rep, ndr->char_rep, ndr->float_rep);

          data += sizeof (NDR_record_t);

          size -= sizeof (NDR_record_t);

        }

      printf_unfiltered (_("  data:"));

      ldata = (const unsigned long *)data;

      for (i = 0; i < size / sizeof (unsigned long); i++)

        printf_unfiltered (" %08lx", ldata[i]);

      printf_unfiltered (_("\n"));

    }

}

static int

darwin_decode_exception_message (mach_msg_header_t *hdr,

                                 struct inferior **pinf,

                                 darwin_thread_t **pthread)

{

  mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);

  mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);

  NDR_record_t *ndr;

  integer_t *data;

  struct inferior *inf;

  darwin_thread_t *thread;

  task_t task_port;

  thread_t thread_port;

  kern_return_t kret;

  int i;

  /* Check message identifier.  2401 is exc.  */

  if (hdr->msgh_id != 2401)

    return -1;

  /* Check message header.  */

  if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))

    return -1;

  /* Check descriptors.  */

  if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)

                        + sizeof (*ndr) + 2 * sizeof (integer_t))

      || bod->msgh_descriptor_count != 2

      || desc[0].type != MACH_MSG_PORT_DESCRIPTOR

      || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND

      || desc[1].type != MACH_MSG_PORT_DESCRIPTOR

      || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)

    return -1;

  /* Check data representation.  */

  ndr = (NDR_record_t *)(desc + 2);

  if (ndr->mig_vers != NDR_PROTOCOL_2_0

      || ndr->if_vers != NDR_PROTOCOL_2_0

      || ndr->mig_encoding != NDR_record.mig_encoding

      || ndr->int_rep != NDR_record.int_rep

      || ndr->char_rep != NDR_record.char_rep

      || ndr->float_rep != NDR_record.float_rep)

    return -1;

  /* Ok, the hard work.  */

  data = (integer_t *)(ndr + 1);

  /* Find process by port.  */

  task_port = desc[1].name;

  thread_port = desc[0].name;

  inf = darwin_find_inferior_by_task (task_port);

  if (inf == NULL)

    return -1;

  *pinf = inf;

  /* Find thread by port.  */

  /* Check for new threads.  Do it early so that the port in the exception

     message can be deallocated.  */

  darwin_check_new_threads (inf);

  /* We got new rights to the task and the thread.  Get rid of them.  */

  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);

  thread = darwin_find_thread (inf, thread_port);

  if (thread == NULL)

    return -1;

  *pthread = thread;

  /* Finish decoding.  */

  gdb_assert (thread->msg_state == DARWIN_RUNNING);

  thread->event.header = *hdr;

  thread->event.thread_port = thread_port;

  thread->event.task_port = task_port;

  thread->event.ex_type = data[0];

  thread->event.data_count = data[1];

  if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)

                        + sizeof (*ndr) + 2 * sizeof (integer_t)

                        + data[1] * sizeof (integer_t)))

      return -1;

  for (i = 0; i < data[1]; i++)

    thread->event.ex_data[i] = data[2 + i];

  thread->msg_state = DARWIN_MESSAGE;

  return 0;

}

static void

darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,

                     integer_t code)

{

  mach_msg_header_t *rh = &reply->Head;

  rh->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(hdr->msgh_bits), 0);

  rh->msgh_remote_port = hdr->msgh_remote_port;

  rh->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);

  rh->msgh_local_port = MACH_PORT_NULL;

  rh->msgh_id = hdr->msgh_id + 100;

  reply->NDR = NDR_record;

  reply->RetCode = code;

}

static void

darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)

{

  kern_return_t kret;

  mig_reply_error_t reply;

  darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);

  kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,

                   reply.Head.msgh_size, 0,

                   MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,

                   MACH_PORT_NULL);

  MACH_CHECK_ERROR (kret);

  inf->private->pending_messages--;

}

static void

darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,

                      int step, int nsignal)

{

  kern_return_t kret;

  int res;

  inferior_debug

    (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),