gdb/darwin-nat.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2017 Free Software Foundation, Inc.
   3
   4    Contributed by AdaCore.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "top.h"
  23 #include "inferior.h"
  24 #include "target.h"
  25 #include "symfile.h"
  26 #include "symtab.h"
  27 #include "objfiles.h"
  28 #include "gdb.h"
  29 #include "gdbcmd.h"
  30 #include "gdbcore.h"
  31 #include "gdbthread.h"
  32 #include "regcache.h"
  33 #include "event-top.h"
  34 #include "inf-loop.h"
  35 #include <sys/stat.h>
  36 #include "inf-child.h"
  37 #include "value.h"
  38 #include "arch-utils.h"
  39 #include "bfd.h"
  40 #include "bfd/mach-o.h"
  41
  42 #include <sys/ptrace.h>
  43 #include <sys/signal.h>
  44 #include <setjmp.h>
  45 #include <sys/types.h>
  46 #include <unistd.h>
  47 #include <signal.h>
  48 #include <ctype.h>
  49 #include <sys/sysctl.h>
  50 #include <sys/proc.h>
  51 #include <libproc.h>
  52 #include <sys/syscall.h>
  53 #include <spawn.h>
  54
  55 #include <mach/mach_error.h>
  56 #include <mach/mach_vm.h>
  57 #include <mach/mach_init.h>
  58 #include <mach/vm_map.h>
  59 #include <mach/task.h>
  60 #include <mach/mach_port.h>
  61 #include <mach/thread_act.h>
  62 #include <mach/port.h>
  63
  64 #include "darwin-nat.h"
  65 #include "common/filestuff.h"
  66
  67 /* Quick overview.
  68    Darwin kernel is Mach + BSD derived kernel.  Note that they share the
  69    same memory space and are linked together (ie there is no micro-kernel).
  70
  71    Although ptrace(2) is available on Darwin, it is not complete.  We have
  72    to use Mach calls to read and write memory and to modify registers.  We
  73    also use Mach to get inferior faults.  As we cannot use select(2) or
  74    signals with Mach port (the Mach communication channel), signals are
  75    reported to gdb as an exception.  Furthermore we detect death of the
  76    inferior through a Mach notification message.  This way we only wait
  77    on Mach ports.
  78
  79    Some Mach documentation is available for Apple xnu source package or
  80    from the web.  */
  81
  82
  83 #define PTRACE(CMD, PID, ADDR, SIG) \
  84  darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
  85
  86 static void darwin_interrupt (struct target_ops *self, ptid_t);
  87
  88 static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
  89                               enum gdb_signal signal);
  90 static void darwin_resume (ptid_t ptid, int step,
  91                            enum gdb_signal signal);
  92
  93 static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
  94                               struct target_waitstatus *status, int options);
  95 static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
  96
  97 static void darwin_mourn_inferior (struct target_ops *ops);
  98
  99 static void darwin_kill_inferior (struct target_ops *ops);
 100
 101 static void darwin_ptrace_me (void);
 102
 103 static void darwin_ptrace_him (int pid);
 104
 105 static void darwin_create_inferior (struct target_ops *ops,
 106                                     const char *exec_file,
 107                                     const std::string &allargs,
 108                                     char **env, int from_tty);
 109
 110 static void darwin_files_info (struct target_ops *ops);
 111
 112 static const char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
 113
 114 static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
 115
 116 static void darwin_encode_reply (mig_reply_error_t *reply,
 117                                  mach_msg_header_t *hdr, integer_t code);
 118
 119 static void darwin_setup_request_notification (struct inferior *inf);
 120 static void darwin_deallocate_exception_ports (darwin_inferior *inf);
 121 static void darwin_setup_exceptions (struct inferior *inf);
 122 static void darwin_deallocate_threads (struct inferior *inf);
 123
 124 /* Target operations for Darwin.  */
 125 static struct target_ops *darwin_ops;
 126
 127 /* Task identifier of gdb.  */
 128 static task_t gdb_task;
 129
 130 /* A copy of mach_host_self ().  */
 131 mach_port_t darwin_host_self;
 132
 133 /* Exception port.  */
 134 mach_port_t darwin_ex_port;
 135
 136 /* Port set, to wait for answer on all ports.  */
 137 mach_port_t darwin_port_set;
 138
 139 /* Page size.  */
 140 static vm_size_t mach_page_size;
 141
 142 /* If Set, catch all mach exceptions (before they are converted to signals
 143    by the kernel).  */
 144 static int enable_mach_exceptions;
 145
 146 /* Inferior that should report a fake stop event.  */
 147 static struct inferior *darwin_inf_fake_stop;
 148
 149 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
 150 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
 151
 152 /* This controls output of inferior debugging.  */
 153 static unsigned int darwin_debug_flag = 0;
 154
 155 /* Create a __TEXT __info_plist section in the executable so that gdb could
 156    be signed.  This is required to get an authorization for task_for_pid.
 157
 158    Once gdb is built, you must codesign it with any system-trusted signing
 159    authority.  See taskgated(8) for details.  */
 160 static const unsigned char info_plist[]
 161 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
 162   "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 163   "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
 164   " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
 165   "<plist version=\"1.0\">\n"
 166   "<dict>\n"
 167   "  <key>CFBundleIdentifier</key>\n"
 168   "  <string>org.gnu.gdb</string>\n"
 169   "  <key>CFBundleName</key>\n"
 170   "  <string>gdb</string>\n"
 171   "  <key>CFBundleVersion</key>\n"
 172   "  <string>1.0</string>\n"
 173   "  <key>SecTaskAccess</key>\n"
 174   "  <array>\n"
 175   "    <string>allowed</string>\n"
 176   "    <string>debug</string>\n"
 177   "  </array>\n"
 178   "</dict>\n"
 179   "</plist>\n";
 180
 181 static void inferior_debug (int level, const char *fmt, ...)
 182   ATTRIBUTE_PRINTF (2, 3);
 183
 184 static void
 185 inferior_debug (int level, const char *fmt, ...)
 186 {
 187   va_list ap;
 188
 189   if (darwin_debug_flag < level)
 190     return;
 191
 192   va_start (ap, fmt);
 193   printf_unfiltered (_("[%d inferior]: "), getpid ());
 194   vprintf_unfiltered (fmt, ap);
 195   va_end (ap);
 196 }
 197
 198 void
 199 mach_check_error (kern_return_t ret, const char *file,
 200                   unsigned int line, const char *func)
 201 {
 202   if (ret == KERN_SUCCESS)
 203     return;
 204   if (func == NULL)
 205     func = _("[UNKNOWN]");
 206
 207   warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
 208            file, line, func, mach_error_string (ret), (unsigned long) ret);
 209 }
 210
 211 static const char *
 212 unparse_exception_type (unsigned int i)
 213 {
 214   static char unknown_exception_buf[32];
 215
 216   switch (i)
 217     {
 218     case EXC_BAD_ACCESS:
 219       return "EXC_BAD_ACCESS";
 220     case EXC_BAD_INSTRUCTION:
 221       return "EXC_BAD_INSTRUCTION";
 222     case EXC_ARITHMETIC:
 223       return "EXC_ARITHMETIC";
 224     case EXC_EMULATION:
 225       return "EXC_EMULATION";
 226     case EXC_SOFTWARE:
 227       return "EXC_SOFTWARE";
 228     case EXC_BREAKPOINT:
 229       return "EXC_BREAKPOINT";
 230     case EXC_SYSCALL:
 231       return "EXC_SYSCALL";
 232     case EXC_MACH_SYSCALL:
 233       return "EXC_MACH_SYSCALL";
 234     case EXC_RPC_ALERT:
 235       return "EXC_RPC_ALERT";
 236     case EXC_CRASH:
 237       return "EXC_CRASH";
 238     default:
 239       snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
 240       return unknown_exception_buf;
 241     }
 242 }
 243
 244 /* Set errno to zero, and then call ptrace with the given arguments.
 245    If inferior debugging traces are on, then also print a debug
 246    trace.
 247
 248    The returned value is the same as the value returned by ptrace,
 249    except in the case where that value is -1 but errno is zero.
 250    This case is documented to be a non-error situation, so we
 251    return zero in that case. */
 252
 253 static int
 254 darwin_ptrace (const char *name,
 255                int request, int pid, caddr_t arg3, int arg4)
 256 {
 257   int ret;
 258
 259   errno = 0;
 260   ret = ptrace (request, pid, arg3, arg4);
 261   if (ret == -1 && errno == 0)
 262     ret = 0;
 263
 264   inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
 265                   name, pid, (unsigned long) arg3, arg4, ret,
 266                   (ret != 0) ? safe_strerror (errno) : _("no error"));
 267   return ret;
 268 }
 269
 270 static int
 271 cmp_thread_t (const void *l, const void *r)
 272 {
 273   thread_t tl = *(const thread_t *)l;
 274   thread_t tr = *(const thread_t *)r;
 275   return (int)(tl - tr);
 276 }
 277
 278 static void
 279 darwin_check_new_threads (struct inferior *inf)
 280 {
 281   kern_return_t kret;
 282   unsigned int i;
 283   thread_array_t thread_list;
 284   unsigned int new_nbr;
 285   unsigned int old_nbr;
 286   unsigned int new_ix, old_ix;
 287   darwin_inferior *darwin_inf = inf->priv;
 288   VEC (darwin_thread_t) *thread_vec;
 289
 290   /* Get list of threads.  */
 291   kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
 292   MACH_CHECK_ERROR (kret);
 293   if (kret != KERN_SUCCESS)
 294     return;
 295
 296   /* Sort the list.  */
 297   if (new_nbr > 1)
 298     qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
 299
 300   if (darwin_inf->threads)
 301     old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
 302   else
 303     old_nbr = 0;
 304
 305   /* Quick check for no changes.  */
 306   if (old_nbr == new_nbr)
 307     {
 308       for (i = 0; i < new_nbr; i++)
 309         if (thread_list[i]
 310             != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
 311           break;
 312       if (i == new_nbr)
 313         {
 314           /* Deallocate ports.  */
 315           for (i = 0; i < new_nbr; i++)
 316             {
 317               kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
 318               MACH_CHECK_ERROR (kret);
 319             }
 320
 321           /* Deallocate the buffer.  */
 322           kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 323                                 new_nbr * sizeof (int));
 324           MACH_CHECK_ERROR (kret);
 325
 326           return;
 327         }
 328     }
 329
 330   /* Full handling: detect new threads, remove dead threads.  */
 331   thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
 332
 333   for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
 334     {
 335       thread_t new_id = (new_ix < new_nbr) ?
 336         thread_list[new_ix] : THREAD_NULL;
 337       darwin_thread_t *old = (old_ix < old_nbr) ?
 338         VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
 339       thread_t old_id = old ? old->gdb_port : THREAD_NULL;
 340
 341       inferior_debug
 342         (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
 343          new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
 344
 345       if (old_id == new_id)
 346         {
 347           /* Thread still exist.  */
 348           VEC_safe_push (darwin_thread_t, thread_vec, old);
 349           new_ix++;
 350           old_ix++;
 351
 352           /* Deallocate the port.  */
 353           kret = mach_port_deallocate (gdb_task, new_id);
 354           MACH_CHECK_ERROR (kret);
 355
 356           continue;
 357         }
 358       if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
 359         {
 360           /* Ignore dead ports.
 361              In some weird cases, we might get dead ports.  They should
 362              correspond to dead thread so they could safely be ignored.  */
 363           new_ix++;
 364           continue;
 365         }
 366       if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
 367         {
 368           /* A thread was created.  */
 369           struct thread_info *tp;
 370           struct private_thread_info *pti;
 371
 372           pti = XCNEW (struct private_thread_info);
 373           pti->gdb_port = new_id;
 374           pti->msg_state = DARWIN_RUNNING;
 375
 376           if (old_nbr == 0 && new_ix == 0)
 377             {
 378               /* A ptid is create when the inferior is started (see
 379                  fork-child.c) with lwp=tid=0.  This ptid will be renamed
 380                  later by darwin_init_thread_list ().  */
 381               tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));
 382               gdb_assert (tp);
 383               gdb_assert (tp->priv == NULL);
 384               tp->priv = pti;
 385             }
 386           else
 387             {
 388               /* Add the new thread.  */
 389               tp = add_thread_with_info
 390                 (ptid_build (inf->pid, 0, new_id), pti);
 391             }
 392           VEC_safe_push (darwin_thread_t, thread_vec, pti);
 393           new_ix++;
 394           continue;
 395         }
 396       if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
 397         {
 398           /* A thread was removed.  */
 399           delete_thread (ptid_build (inf->pid, 0, old_id));
 400           kret = mach_port_deallocate (gdb_task, old_id);
 401           MACH_CHECK_ERROR (kret);
 402           old_ix++;
 403           continue;
 404         }
 405       gdb_assert_not_reached ("unexpected thread case");
 406     }
 407
 408   if (darwin_inf->threads)
 409     VEC_free (darwin_thread_t, darwin_inf->threads);
 410   darwin_inf->threads = thread_vec;
 411
 412   /* Deallocate the buffer.  */
 413   kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 414                         new_nbr * sizeof (int));
 415   MACH_CHECK_ERROR (kret);
 416 }
 417
 418 static int
 419 find_inferior_task_it (struct inferior *inf, void *port_ptr)
 420 {
 421   return inf->priv->task == *(task_t *)port_ptr;
 422 }
 423
 424 static int
 425 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
 426 {
 427   return inf->pid == *(int *)pid_ptr;
 428 }
 429
 430 /* Return an inferior by task port.  */
 431 static struct inferior *
 432 darwin_find_inferior_by_task (task_t port)
 433 {
 434   return iterate_over_inferiors (&find_inferior_task_it, &port);
 435 }
 436
 437 /* Return an inferior by pid port.  */
 438 static struct inferior *
 439 darwin_find_inferior_by_pid (int pid)
 440 {
 441   return iterate_over_inferiors (&find_inferior_pid_it, &pid);
 442 }
 443
 444 /* Return a thread by port.  */
 445 static darwin_thread_t *
 446 darwin_find_thread (struct inferior *inf, thread_t thread)
 447 {
 448   darwin_thread_t *t;
 449   int k;
 450
 451   for (k = 0;
 452        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
 453        k++)
 454     if (t->gdb_port == thread)
 455       return t;
 456   return NULL;
 457 }
 458
 459 /* Suspend (ie stop) an inferior at Mach level.  */
 460
 461 static void
 462 darwin_suspend_inferior (struct inferior *inf)
 463 {
 464   if (!inf->priv->suspended)
 465     {
 466       kern_return_t kret;
 467
 468       kret = task_suspend (inf->priv->task);
 469       MACH_CHECK_ERROR (kret);
 470
 471       inf->priv->suspended = 1;
 472     }
 473 }
 474
 475 /* Resume an inferior at Mach level.  */
 476
 477 static void
 478 darwin_resume_inferior (struct inferior *inf)
 479 {
 480   if (inf->priv->suspended)
 481     {
 482       kern_return_t kret;
 483
 484       kret = task_resume (inf->priv->task);
 485       MACH_CHECK_ERROR (kret);
 486
 487       inf->priv->suspended = 0;
 488     }
 489 }
 490
 491 /* Iterator functions.  */
 492
 493 static int
 494 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
 495 {
 496   darwin_suspend_inferior (inf);
 497   darwin_check_new_threads (inf);
 498   return 0;
 499 }
 500
 501 static int
 502 darwin_resume_inferior_it (struct inferior *inf, void *arg)
 503 {
 504   darwin_resume_inferior (inf);
 505   return 0;
 506 }
 507
 508 static void
 509 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
 510 {
 511   printf_unfiltered (_("message header:\n"));
 512   printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
 513   printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
 514   printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
 515   printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
 516   printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
 517   printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
 518
 519   if (disp_body)
 520     {
 521       const unsigned char *data;
 522       const unsigned int *ldata;
 523       int size;
 524       int i;
 525
 526       data = (unsigned char *)(hdr + 1);
 527       size = hdr->msgh_size - sizeof (mach_msg_header_t);
 528
 529       if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
 530         {
 531           mach_msg_body_t *bod = (mach_msg_body_t*)data;
 532           mach_msg_port_descriptor_t *desc =
 533             (mach_msg_port_descriptor_t *)(bod + 1);
 534           int k;
 535           NDR_record_t *ndr;
 536           printf_unfiltered (_("body: descriptor_count=%u\n"),
 537                              bod->msgh_descriptor_count);
 538           data += sizeof (mach_msg_body_t);
 539           size -= sizeof (mach_msg_body_t);
 540           for (k = 0; k < bod->msgh_descriptor_count; k++)
 541             switch (desc[k].type)
 542               {
 543               case MACH_MSG_PORT_DESCRIPTOR:
 544                 printf_unfiltered
 545                   (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
 546                    k, desc[k].type, desc[k].name, desc[k].disposition);
 547                 break;
 548               default:
 549                 printf_unfiltered (_(" descr %d: type=%u\n"),
 550                                    k, desc[k].type);
 551                 break;
 552               }
 553           data += bod->msgh_descriptor_count
 554             * sizeof (mach_msg_port_descriptor_t);
 555           size -= bod->msgh_descriptor_count
 556             * sizeof (mach_msg_port_descriptor_t);
 557           ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
 558           printf_unfiltered
 559             (_("NDR: mig=%02x if=%02x encod=%02x "
 560                "int=%02x char=%02x float=%02x\n"),
 561              ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
 562              ndr->int_rep, ndr->char_rep, ndr->float_rep);
 563           data += sizeof (NDR_record_t);
 564           size -= sizeof (NDR_record_t);
 565         }
 566
 567       printf_unfiltered (_("  data:"));
 568       ldata = (const unsigned int *)data;
 569       for (i = 0; i < size / sizeof (unsigned int); i++)
 570         printf_unfiltered (" %08x", ldata[i]);
 571       printf_unfiltered (_("\n"));
 572     }
 573 }
 574
 575 /* Adjust inferior data when a new task was created.  */
 576
 577 static struct inferior *
 578 darwin_find_new_inferior (task_t task_port, thread_t thread_port)
 579 {
 580   int task_pid;
 581   struct inferior *inf;
 582   kern_return_t kret;
 583   mach_port_t prev;
 584
 585   /* Find the corresponding pid.  */
 586   kret = pid_for_task (task_port, &task_pid);
 587   if (kret != KERN_SUCCESS)
 588     {
 589       MACH_CHECK_ERROR (kret);
 590       return NULL;
 591     }
 592
 593   /* Find the inferior for this pid.  */
 594   inf = darwin_find_inferior_by_pid (task_pid);
 595   if (inf == NULL)
 596     return NULL;
 597
 598   /* Deallocate saved exception ports.  */
 599   darwin_deallocate_exception_ports (inf->priv);
 600
 601   /* No need to remove dead_name notification, but still...  */
 602   kret = mach_port_request_notification (gdb_task, inf->priv->task,
 603                                          MACH_NOTIFY_DEAD_NAME, 0,
 604                                          MACH_PORT_NULL,
 605                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
 606                                          &prev);
 607   if (kret != KERN_INVALID_ARGUMENT)
 608     MACH_CHECK_ERROR (kret);
 609
 610   /* Replace old task port.  */
 611   kret = mach_port_deallocate (gdb_task, inf->priv->task);
 612   MACH_CHECK_ERROR (kret);
 613   inf->priv->task = task_port;
 614
 615   darwin_setup_request_notification (inf);
 616   darwin_setup_exceptions (inf);
 617
 618   return inf;
 619 }
 620
 621 /* Check data representation.  */
 622
 623 static int
 624 darwin_check_message_ndr (NDR_record_t *ndr)
 625 {
 626   if (ndr->mig_vers != NDR_PROTOCOL_2_0
 627       || ndr->if_vers != NDR_PROTOCOL_2_0
 628       || ndr->mig_encoding != NDR_record.mig_encoding
 629       || ndr->int_rep != NDR_record.int_rep
 630       || ndr->char_rep != NDR_record.char_rep
 631       || ndr->float_rep != NDR_record.float_rep)
 632     return -1;
 633   return 0;
 634 }
 635
 636 /* Decode an exception message.  */
 637
 638 static int
 639 darwin_decode_exception_message (mach_msg_header_t *hdr,
 640                                  struct inferior **pinf,
 641                                  darwin_thread_t **pthread)
 642 {
 643   mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
 644   mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
 645   NDR_record_t *ndr;
 646   integer_t *data;
 647   struct inferior *inf;
 648   darwin_thread_t *thread;
 649   task_t task_port;
 650   thread_t thread_port;
 651   kern_return_t kret;
 652   int i;
 653
 654   /* Check message destination.  */
 655   if (hdr->msgh_local_port != darwin_ex_port)
 656     return -1;
 657
 658   /* Check message header.  */
 659   if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
 660     return -1;
 661
 662   /* Check descriptors.  */
 663   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
 664                         + sizeof (*ndr) + 2 * sizeof (integer_t))
 665       || bod->msgh_descriptor_count != 2
 666       || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
 667       || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
 668       || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
 669       || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
 670     return -1;
 671
 672   /* Check data representation.  */
 673   ndr = (NDR_record_t *)(desc + 2);
 674   if (darwin_check_message_ndr (ndr) != 0)
 675     return -1;
 676
 677   /* Ok, the hard work.  */
 678   data = (integer_t *)(ndr + 1);
 679
 680   task_port = desc[1].name;
 681   thread_port = desc[0].name;
 682
 683   /* Find process by port.  */
 684   inf = darwin_find_inferior_by_task (task_port);
 685   *pinf = inf;
 686
 687   if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
 688       && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
 689     {
 690       /* Not a known inferior, but a sigtrap.  This happens on darwin 16.1.0,
 691          as a new Mach task is created when a process exec.  */
 692       inf = darwin_find_new_inferior (task_port, thread_port);
 693       *pinf = inf;
 694
 695       if (inf == NULL)
 696         {
 697           /* Deallocate task_port, unless it was saved.  */
 698           kret = mach_port_deallocate (mach_task_self (), task_port);
 699           MACH_CHECK_ERROR (kret);
 700         }
 701     }
 702   else
 703     {
 704       /* We got new rights to the task, get rid of it.  Do not get rid of
 705          thread right, as we will need it to find the thread.  */
 706       kret = mach_port_deallocate (mach_task_self (), task_port);
 707       MACH_CHECK_ERROR (kret);
 708     }
 709
 710   if (inf == NULL)
 711     {
 712       /* Not a known inferior.  This could happen if the child fork, as
 713          the created process will inherit its exception port.
 714          FIXME: should the exception port be restored ?  */
 715       kern_return_t kret;
 716       mig_reply_error_t reply;
 717
 718       inferior_debug
 719         (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
 720          task_port);
 721
 722       /* Free thread port (we don't know it).  */
 723       kret = mach_port_deallocate (mach_task_self (), thread_port);
 724       MACH_CHECK_ERROR (kret);
 725
 726       darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
 727
 728       kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
 729                        reply.Head.msgh_size, 0,
 730                        MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 731                        MACH_PORT_NULL);
 732       MACH_CHECK_ERROR (kret);
 733
 734       return 0;
 735     }
 736
 737   /* Find thread by port.  */
 738   /* Check for new threads.  Do it early so that the port in the exception
 739      message can be deallocated.  */
 740   darwin_check_new_threads (inf);
 741
 742   /* Free the thread port (as gdb knows the thread, it has already has a right
 743      for it, so this just decrement a reference counter).  */
 744   kret = mach_port_deallocate (mach_task_self (), thread_port);
 745   MACH_CHECK_ERROR (kret);
 746
 747   thread = darwin_find_thread (inf, thread_port);
 748   if (thread == NULL)
 749     return -1;
 750   *pthread = thread;
 751
 752   /* The thread should be running.  However we have observed cases where a
 753      thread got a SIGTTIN message after being stopped.  */
 754   gdb_assert (thread->msg_state != DARWIN_MESSAGE);
 755
 756   /* Finish decoding.  */
 757   thread->event.header = *hdr;
 758   thread->event.thread_port = thread_port;
 759   thread->event.task_port = task_port;
 760   thread->event.ex_type = data[0];
 761   thread->event.data_count = data[1];
 762
 763   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
 764                         + sizeof (*ndr) + 2 * sizeof (integer_t)
 765                         + data[1] * sizeof (integer_t)))
 766       return -1;
 767   for (i = 0; i < data[1]; i++)
 768     thread->event.ex_data[i] = data[2 + i];
 769
 770   thread->msg_state = DARWIN_MESSAGE;
 771
 772   return 0;
 773 }
 774
 775 /* Decode dead_name notify message.  */
 776
 777 static int
 778 darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
 779 {
 780   NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
 781   integer_t *data = (integer_t *)(ndr + 1);
 782   struct inferior *inf;
 783   darwin_thread_t *thread;
 784   task_t task_port;
 785   thread_t thread_port;
 786   kern_return_t kret;
 787   int i;
 788
 789   /* Check message header.  */
 790   if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
 791     return -1;
 792
 793   /* Check descriptors.  */
 794   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
 795     return -2;
 796
 797   /* Check data representation.  */
 798   if (darwin_check_message_ndr (ndr) != 0)
 799     return -3;
 800
 801   task_port = data[0];
 802
 803   /* Find process by port.  */
 804   inf = darwin_find_inferior_by_task (task_port);
 805   *pinf = inf;
 806
 807   /* Check message destination.  */
 808   if (inf != NULL && hdr->msgh_local_port != inf->priv->notify_port)
 809     return -4;
 810
 811   return 0;
 812 }
 813
 814 static void
 815 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
 816                      integer_t code)
 817 {
 818   mach_msg_header_t *rh = &reply->Head;
 819
 820   rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
 821   rh->msgh_remote_port = hdr->msgh_remote_port;
 822   rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
 823   rh->msgh_local_port = MACH_PORT_NULL;
 824   rh->msgh_id = hdr->msgh_id + 100;
 825
 826   reply->NDR = NDR_record;
 827   reply->RetCode = code;
 828 }
 829
 830 static void
 831 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
 832 {
 833   kern_return_t kret;
 834   mig_reply_error_t reply;
 835
 836   darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
 837
 838   kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
 839                    reply.Head.msgh_size, 0,
 840                    MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 841                    MACH_PORT_NULL);
 842   MACH_CHECK_ERROR (kret);
 843
 844   inf->priv->pending_messages--;
 845 }
 846
 847 static void
 848 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
 849                       int step, int nsignal)
 850 {
 851   kern_return_t kret;
 852   int res;
 853
 854   inferior_debug
 855     (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
 856      thread->msg_state, thread->gdb_port, step, nsignal);
 857
 858   switch (thread->msg_state)
 859     {
 860     case DARWIN_MESSAGE:
 861       if (thread->event.ex_type == EXC_SOFTWARE
 862           && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
 863         {
 864           /* Either deliver a new signal or cancel the signal received.  */
 865           res = PTRACE (PT_THUPDATE, inf->pid,
 866                         (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
 867           if (res < 0)
 868             inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
 869         }
 870       else if (nsignal)
 871         {
 872           /* Note: ptrace is allowed only if the process is stopped.
 873              Directly send the signal to the thread.  */
 874           res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
 875           inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
 876                           thread->gdb_port, nsignal, res);
 877           thread->signaled = 1;
 878         }
 879
 880       /* Set or reset single step.  */
 881       inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
 882                       thread->gdb_port, step);
 883       darwin_set_sstep (thread->gdb_port, step);
 884       thread->single_step = step;
 885
 886       darwin_send_reply (inf, thread);
 887       thread->msg_state = DARWIN_RUNNING;
 888       break;
 889
 890     case DARWIN_RUNNING:
 891       break;
 892
 893     case DARWIN_STOPPED:
 894       kret = thread_resume (thread->gdb_port);
 895       MACH_CHECK_ERROR (kret);
 896
 897       thread->msg_state = DARWIN_RUNNING;
 898       break;
 899     }
 900 }
 901
 902 /* Resume all threads of the inferior.  */
 903
 904 static void
 905 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
 906 {
 907   darwin_thread_t *thread;
 908   int k;
 909
 910   for (k = 0;
 911        VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
 912        k++)
 913     darwin_resume_thread (inf, thread, step, nsignal);
 914 }
 915
 916 struct resume_inferior_threads_param
 917 {
 918   int step;
 919   int nsignal;
 920 };
 921
 922 static int
 923 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
 924 {
 925   int step = ((struct resume_inferior_threads_param *)param)->step;
 926   int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
 927
 928   darwin_resume_inferior_threads (inf, step, nsignal);
 929
 930   return 0;
 931 }
 932
 933 /* Suspend all threads of INF.  */
 934
 935 static void
 936 darwin_suspend_inferior_threads (struct inferior *inf)
 937 {
 938   darwin_thread_t *thread;
 939   kern_return_t kret;
 940   int k;
 941
 942   for (k = 0;
 943        VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
 944        k++)
 945     switch (thread->msg_state)
 946       {
 947       case DARWIN_STOPPED:
 948       case DARWIN_MESSAGE:
 949         break;
 950       case DARWIN_RUNNING:
 951         kret = thread_suspend (thread->gdb_port);
 952         MACH_CHECK_ERROR (kret);
 953         thread->msg_state = DARWIN_STOPPED;
 954         break;
 955       }
 956 }
 957
 958 static void
 959 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
 960 {
 961   struct target_waitstatus status;
 962   int pid;
 963
 964   kern_return_t kret;
 965   int res;
 966   int nsignal;
 967   struct inferior *inf;
 968
 969   inferior_debug
 970     (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
 971      ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
 972
 973   if (signal == GDB_SIGNAL_0)
 974     nsignal = 0;
 975   else
 976     nsignal = gdb_signal_to_host (signal);
 977
 978   /* Don't try to single step all threads.  */
 979   if (step)
 980     ptid = inferior_ptid;
 981
 982   /* minus_one_ptid is RESUME_ALL.  */
 983   if (ptid_equal (ptid, minus_one_ptid))
 984     {
 985       struct resume_inferior_threads_param param;
 986
 987       param.nsignal = nsignal;
 988       param.step = step;
 989
 990       /* Resume threads.  */
 991       iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
 992       /* Resume tasks.  */
 993       iterate_over_inferiors (darwin_resume_inferior_it, NULL);
 994     }
 995   else
 996     {
 997       struct inferior *inf = find_inferior_ptid (ptid);
 998       long tid = ptid_get_tid (ptid);
 999
1000       /* Stop the inferior (should be useless).  */
1001       darwin_suspend_inferior (inf);
1002
1003       if (tid == 0)
1004         darwin_resume_inferior_threads (inf, step, nsignal);
1005       else
1006         {
1007           darwin_thread_t *thread;
1008
1009           /* Suspend threads of the task.  */
1010           darwin_suspend_inferior_threads (inf);
1011
1012           /* Resume the selected thread.  */
1013           thread = darwin_find_thread (inf, tid);
1014           gdb_assert (thread);
1015           darwin_resume_thread (inf, thread, step, nsignal);
1016         }
1017
1018       /* Resume the task.  */
1019       darwin_resume_inferior (inf);
1020     }
1021 }
1022
1023 static void
1024 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
1025                   enum gdb_signal signal)
1026 {
1027   return darwin_resume (ptid, step, signal);
1028 }
1029
1030 static ptid_t
1031 darwin_decode_message (mach_msg_header_t *hdr,
1032                        darwin_thread_t **pthread,
1033                        struct inferior **pinf,
1034                        struct target_waitstatus *status)
1035 {
1036   darwin_thread_t *thread;
1037   struct inferior *inf;
1038
1039   /* Exception message.  2401 == 0x961 is exc.  */
1040   if (hdr->msgh_id == 2401)
1041     {
1042       int res;
1043
1044       /* Decode message.  */
1045       res = darwin_decode_exception_message (hdr, &inf, &thread);
1046
1047       if (res < 0)
1048         {
1049           /* Should not happen...  */
1050           printf_unfiltered
1051             (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
1052           /* FIXME: send a failure reply?  */
1053           status->kind = TARGET_WAITKIND_IGNORE;
1054           return minus_one_ptid;
1055         }
1056       if (inf == NULL)
1057         {
1058           status->kind = TARGET_WAITKIND_IGNORE;
1059           return minus_one_ptid;
1060         }
1061       *pinf = inf;
1062       *pthread = thread;
1063       inf->priv->pending_messages++;
1064
1065       status->kind = TARGET_WAITKIND_STOPPED;
1066       thread->msg_state = DARWIN_MESSAGE;
1067
1068       inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1069                       thread->gdb_port,
1070                       unparse_exception_type (thread->event.ex_type));
1071
1072       switch (thread->event.ex_type)
1073         {
1074         case EXC_BAD_ACCESS:
1075           status->value.sig = GDB_EXC_BAD_ACCESS;
1076           break;
1077         case EXC_BAD_INSTRUCTION:
1078           status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1079           break;
1080         case EXC_ARITHMETIC:
1081           status->value.sig = GDB_EXC_ARITHMETIC;
1082           break;
1083         case EXC_EMULATION:
1084           status->value.sig = GDB_EXC_EMULATION;
1085           break;
1086         case EXC_SOFTWARE:
1087           if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1088             {
1089               status->value.sig =
1090                 gdb_signal_from_host (thread->event.ex_data[1]);
1091               inferior_debug (5, _("  (signal %d: %s)\n"),
1092                               thread->event.ex_data[1],
1093                               gdb_signal_to_name (status->value.sig));
1094
1095               /* If the thread is stopped because it has received a signal
1096                  that gdb has just sent, continue.  */
1097               if (thread->signaled)
1098                 {
1099                   thread->signaled = 0;
1100                   darwin_send_reply (inf, thread);
1101                   thread->msg_state = DARWIN_RUNNING;
1102                   status->kind = TARGET_WAITKIND_IGNORE;
1103                 }
1104             }
1105           else
1106             status->value.sig = GDB_EXC_SOFTWARE;
1107           break;
1108         case EXC_BREAKPOINT:
1109           /* Many internal GDB routines expect breakpoints to be reported
1110              as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1111              as a spurious signal.  */
1112           status->value.sig = GDB_SIGNAL_TRAP;
1113           break;
1114         default:
1115           status->value.sig = GDB_SIGNAL_UNKNOWN;
1116           break;
1117         }
1118
1119       return ptid_build (inf->pid, 0, thread->gdb_port);
1120     }
1121   else if (hdr->msgh_id == 0x48)
1122     {
1123       /* MACH_NOTIFY_DEAD_NAME: notification for exit.  */
1124       int res;
1125
1126       res = darwin_decode_notify_message (hdr, &inf);
1127
1128       if (res < 0)
1129         {
1130           /* Should not happen...  */
1131           printf_unfiltered
1132             (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1133              hdr->msgh_id, res);
1134         }
1135
1136       *pinf = NULL;
1137       *pthread = NULL;
1138
1139       if (res < 0 || inf == NULL)
1140         {
1141           status->kind = TARGET_WAITKIND_IGNORE;
1142           return minus_one_ptid;
1143         }
1144
1145       if (inf != NULL)
1146         {
1147           if (!inf->priv->no_ptrace)
1148             {
1149               pid_t res;
1150               int wstatus;
1151
1152               res = wait4 (inf->pid, &wstatus, 0, NULL);
1153               if (res < 0 || res != inf->pid)
1154                 {
1155                   printf_unfiltered (_("wait4: res=%d: %s\n"),
1156                                      res, safe_strerror (errno));
1157                   status->kind = TARGET_WAITKIND_IGNORE;
1158                   return minus_one_ptid;
1159                 }
1160               if (WIFEXITED (wstatus))
1161                 {
1162                   status->kind = TARGET_WAITKIND_EXITED;
1163                   status->value.integer = WEXITSTATUS (wstatus);
1164                 }
1165               else
1166                 {
1167                   status->kind = TARGET_WAITKIND_SIGNALLED;
1168                   status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1169                 }
1170
1171               inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1172                               res, wstatus);
1173
1174               /* Looks necessary on Leopard and harmless...  */
1175               wait4 (inf->pid, &wstatus, 0, NULL);
1176
1177               inferior_ptid = ptid_build (inf->pid, 0, 0);
1178               return inferior_ptid;
1179             }
1180           else
1181             {
1182               inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1183               status->kind = TARGET_WAITKIND_EXITED;
1184               status->value.integer = 0; /* Don't know.  */
1185               return ptid_build (inf->pid, 0, 0);
1186             }
1187         }
1188     }
1189
1190   /* Unknown message.  */
1191   warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1192   status->kind = TARGET_WAITKIND_IGNORE;
1193   return minus_one_ptid;
1194 }
1195
1196 static int
1197 cancel_breakpoint (ptid_t ptid)
1198 {
1199   /* Arrange for a breakpoint to be hit again later.  We will handle
1200      the current event, eventually we will resume this thread, and this
1201      breakpoint will trap again.
1202
1203      If we do not do this, then we run the risk that the user will
1204      delete or disable the breakpoint, but the thread will have already
1205      tripped on it.  */
1206
1207   struct regcache *regcache = get_thread_regcache (ptid);
1208   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1209   CORE_ADDR pc;
1210
1211   pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1212   if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
1213     {
1214       inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1215                       (unsigned long) ptid_get_tid (ptid));
1216
1217       /* Back up the PC if necessary.  */
1218       if (gdbarch_decr_pc_after_break (gdbarch))
1219         regcache_write_pc (regcache, pc);
1220
1221       return 1;
1222     }
1223   return 0;
1224 }
1225
1226 static ptid_t
1227 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1228 {
1229   kern_return_t kret;
1230   union
1231   {
1232     mach_msg_header_t hdr;
1233     char data[0x100];
1234   } msgin;
1235   mach_msg_header_t *hdr = &msgin.hdr;
1236   ptid_t res;
1237   darwin_thread_t *thread;
1238   struct inferior *inf;
1239
1240   inferior_debug
1241     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1242      ptid_get_pid (ptid), ptid_get_tid (ptid));
1243
1244   /* Handle fake stop events at first.  */
1245   if (darwin_inf_fake_stop != NULL)
1246     {
1247       inf = darwin_inf_fake_stop;
1248       darwin_inf_fake_stop = NULL;
1249
1250       status->kind = TARGET_WAITKIND_STOPPED;
1251       status->value.sig = GDB_SIGNAL_TRAP;
1252       thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1253       thread->msg_state = DARWIN_STOPPED;
1254       return ptid_build (inf->pid, 0, thread->gdb_port);
1255     }
1256
1257   do
1258     {
1259       /* set_sigint_trap (); */
1260
1261       /* Wait for a message.  */
1262       kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1263                        sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1264
1265       /* clear_sigint_trap (); */
1266
1267       if (kret == MACH_RCV_INTERRUPTED)
1268         {
1269           status->kind = TARGET_WAITKIND_IGNORE;
1270           return minus_one_ptid;
1271         }
1272
1273       if (kret != MACH_MSG_SUCCESS)
1274         {
1275           inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1276           status->kind = TARGET_WAITKIND_SPURIOUS;
1277           return minus_one_ptid;
1278         }
1279
1280       /* Debug: display message.  */
1281       if (darwin_debug_flag > 10)
1282         darwin_dump_message (hdr, darwin_debug_flag > 11);
1283
1284       res = darwin_decode_message (hdr, &thread, &inf, status);
1285       if (ptid_equal (res, minus_one_ptid))
1286         continue;
1287
1288       /* Early return in case an inferior has exited.  */
1289       if (inf == NULL)
1290         return res;
1291     }
1292   while (status->kind == TARGET_WAITKIND_IGNORE);
1293
1294   /* Stop all tasks.  */
1295   iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1296
1297   /* Read pending messages.  */
1298   while (1)
1299     {
1300       struct target_waitstatus status2;
1301       ptid_t ptid2;
1302
1303       kret = mach_msg (&msgin.hdr,
1304                        MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1305                        sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1306
1307       if (kret == MACH_RCV_TIMED_OUT)
1308         break;
1309       if (kret != MACH_MSG_SUCCESS)
1310         {
1311           inferior_debug
1312             (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1313           break;
1314         }
1315
1316       /* Debug: display message.  */
1317       if (darwin_debug_flag > 10)
1318         darwin_dump_message (hdr, darwin_debug_flag > 11);
1319
1320       ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1321
1322       if (inf != NULL && thread != NULL
1323           && thread->event.ex_type == EXC_BREAKPOINT)
1324         {
1325           if (thread->single_step
1326               || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1327             {
1328               gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1329               darwin_send_reply (inf, thread);
1330               thread->msg_state = DARWIN_RUNNING;
1331             }
1332           else
1333             inferior_debug
1334               (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1335                thread->gdb_port);
1336         }
1337       else
1338         inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1339     }
1340   return res;
1341 }
1342
1343 static ptid_t
1344 darwin_wait_to (struct target_ops *ops,
1345                 ptid_t ptid, struct target_waitstatus *status, int options)
1346 {
1347   return darwin_wait (ptid, status);
1348 }
1349
1350 static void
1351 darwin_interrupt (struct target_ops *self, ptid_t t)
1352 {
1353   struct inferior *inf = current_inferior ();
1354
1355   /* FIXME: handle in no_ptrace mode.  */
1356   gdb_assert (!inf->priv->no_ptrace);
1357   kill (inf->pid, SIGINT);
1358 }
1359
1360 /* Deallocate threads port and vector.  */
1361
1362 static void
1363 darwin_deallocate_threads (struct inferior *inf)
1364 {
1365   if (inf->priv->threads)
1366     {
1367       kern_return_t kret;
1368       int k;
1369       darwin_thread_t *t;
1370       for (k = 0;
1371            VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1372            k++)
1373         {
1374           kret = mach_port_deallocate (gdb_task, t->gdb_port);
1375           MACH_CHECK_ERROR (kret);
1376         }
1377       VEC_free (darwin_thread_t, inf->priv->threads);
1378       inf->priv->threads = NULL;
1379     }
1380 }
1381
1382 static void
1383 darwin_mourn_inferior (struct target_ops *ops)
1384 {
1385   struct inferior *inf = current_inferior ();
1386   kern_return_t kret;
1387   mach_port_t prev;
1388   int i;
1389
1390   /* Deallocate threads.  */
1391   darwin_deallocate_threads (inf);
1392
1393   /* Remove notify_port from darwin_port_set.  */
1394   kret = mach_port_move_member (gdb_task,
1395                                 inf->priv->notify_port, MACH_PORT_NULL);
1396   MACH_CHECK_ERROR (kret);
1397
1398   /* Remove task port dead_name notification.  */
1399   kret = mach_port_request_notification (gdb_task, inf->priv->task,
1400                                          MACH_NOTIFY_DEAD_NAME, 0,
1401                                          MACH_PORT_NULL,
1402                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1403                                          &prev);
1404   /* This can fail if the task is dead.  */
1405   inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1406                   inf->priv->task, prev, inf->priv->notify_port);
1407
1408   if (kret == KERN_SUCCESS)
1409     {
1410       kret = mach_port_deallocate (gdb_task, prev);
1411       MACH_CHECK_ERROR (kret);
1412     }
1413
1414   /* Destroy notify_port.  */
1415   kret = mach_port_destroy (gdb_task, inf->priv->notify_port);
1416   MACH_CHECK_ERROR (kret);
1417
1418   /* Deallocate saved exception ports.  */
1419   darwin_deallocate_exception_ports (inf->priv);
1420
1421   /* Deallocate task port.  */
1422   kret = mach_port_deallocate (gdb_task, inf->priv->task);
1423   MACH_CHECK_ERROR (kret);
1424
1425   xfree (inf->priv);
1426   inf->priv = NULL;
1427
1428   inf_child_mourn_inferior (ops);
1429 }
1430
1431 static void
1432 darwin_reply_to_all_pending_messages (struct inferior *inf)
1433 {
1434   int k;
1435   darwin_thread_t *t;
1436
1437   for (k = 0;
1438        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1439        k++)
1440     {
1441       if (t->msg_state == DARWIN_MESSAGE)
1442         darwin_resume_thread (inf, t, 0, 0);
1443     }
1444 }
1445
1446 static void
1447 darwin_stop_inferior (struct inferior *inf)
1448 {
1449   struct target_waitstatus wstatus;
1450   ptid_t ptid;
1451   kern_return_t kret;
1452   int status;
1453   int res;
1454
1455   gdb_assert (inf != NULL);
1456
1457   darwin_suspend_inferior (inf);
1458
1459   darwin_reply_to_all_pending_messages (inf);
1460
1461   if (inf->priv->no_ptrace)
1462     return;
1463
1464   res = kill (inf->pid, SIGSTOP);
1465   if (res != 0)
1466     warning (_("cannot kill: %s"), safe_strerror (errno));
1467
1468   /* Wait until the process is really stopped.  */
1469   while (1)
1470     {
1471       ptid = darwin_wait (inferior_ptid, &wstatus);
1472       if (wstatus.kind == TARGET_WAITKIND_STOPPED
1473           && wstatus.value.sig == GDB_SIGNAL_STOP)
1474         break;
1475     }
1476 }
1477
1478 static kern_return_t
1479 darwin_save_exception_ports (darwin_inferior *inf)
1480 {
1481   kern_return_t kret;
1482
1483   inf->exception_info.count =
1484     sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1485
1486   kret = task_get_exception_ports
1487     (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1488      &inf->exception_info.count, inf->exception_info.ports,
1489      inf->exception_info.behaviors, inf->exception_info.flavors);
1490   return kret;
1491 }
1492
1493 static kern_return_t
1494 darwin_restore_exception_ports (darwin_inferior *inf)
1495 {
1496   int i;
1497   kern_return_t kret;
1498
1499   for (i = 0; i < inf->exception_info.count; i++)
1500     {
1501       kret = task_set_exception_ports
1502         (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1503          inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1504       if (kret != KERN_SUCCESS)
1505         return kret;
1506     }
1507
1508   return KERN_SUCCESS;
1509 }
1510
1511 /* Deallocate saved exception ports.  */
1512
1513 static void
1514 darwin_deallocate_exception_ports (darwin_inferior *inf)
1515 {
1516   int i;
1517   kern_return_t kret;
1518
1519   for (i = 0; i < inf->exception_info.count; i++)
1520     {
1521       kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1522       MACH_CHECK_ERROR (kret);
1523     }
1524   inf->exception_info.count = 0;
1525 }
1526
1527 static void
1528 darwin_setup_exceptions (struct inferior *inf)
1529 {
1530   kern_return_t kret;
1531   int traps_expected;
1532   exception_mask_t mask;
1533
1534   kret = darwin_save_exception_ports (inf->priv);
1535   if (kret != KERN_SUCCESS)
1536     error (_("Unable to save exception ports, task_get_exception_ports"
1537              "returned: %d"),
1538            kret);
1539
1540   /* Set exception port.  */
1541   if (enable_mach_exceptions)
1542     mask = EXC_MASK_ALL;
1543   else
1544     mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1545   kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
1546                                    EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1547   if (kret != KERN_SUCCESS)
1548     error (_("Unable to set exception ports, task_set_exception_ports"
1549              "returned: %d"),
1550            kret);
1551 }
1552
1553 static void
1554 darwin_kill_inferior (struct target_ops *ops)
1555 {
1556   struct inferior *inf = current_inferior ();
1557   struct target_waitstatus wstatus;
1558   ptid_t ptid;
1559   kern_return_t kret;
1560   int status;
1561   int res;
1562
1563   if (ptid_equal (inferior_ptid, null_ptid))
1564     return;
1565
1566   gdb_assert (inf != NULL);
1567
1568   kret = darwin_restore_exception_ports (inf->priv);
1569   MACH_CHECK_ERROR (kret);
1570
1571   darwin_reply_to_all_pending_messages (inf);
1572
1573   res = kill (inf->pid, 9);
1574
1575   if (res == 0)
1576     {
1577       darwin_resume_inferior (inf);
1578
1579       ptid = darwin_wait (inferior_ptid, &wstatus);
1580     }
1581   else if (errno != ESRCH)
1582     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1583              inf->pid, safe_strerror (errno));
1584
1585   target_mourn_inferior (inferior_ptid);
1586 }
1587
1588 static void
1589 darwin_setup_request_notification (struct inferior *inf)
1590 {
1591   kern_return_t kret;
1592   mach_port_t prev_not;
1593
1594   kret = mach_port_request_notification (gdb_task, inf->priv->task,
1595                                          MACH_NOTIFY_DEAD_NAME, 0,
1596                                          inf->priv->notify_port,
1597                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1598                                          &prev_not);
1599   if (kret != KERN_SUCCESS)
1600     error (_("Termination notification request failed, "
1601              "mach_port_request_notification\n"
1602              "returned: %d"),
1603            kret);
1604   if (prev_not != MACH_PORT_NULL)
1605     {
1606       /* This is unexpected, as there should not be any previously
1607          registered notification request.  But this is not a fatal
1608          issue, so just emit a warning.  */
1609       warning (_("\
1610 A task termination request was registered before the debugger registered\n\
1611 its own.  This is unexpected, but should otherwise not have any actual\n\
1612 impact on the debugging session."));
1613     }
1614 }
1615
1616 static void
1617 darwin_attach_pid (struct inferior *inf)
1618 {
1619   kern_return_t kret;
1620   mach_port_t prev_port;
1621   int traps_expected;
1622   mach_port_t prev_not;
1623   exception_mask_t mask;
1624
1625   inf->priv = XCNEW (darwin_inferior);
1626
1627   kret = task_for_pid (gdb_task, inf->pid, &inf->priv->task);
1628   if (kret != KERN_SUCCESS)
1629     {
1630       int status;
1631
1632       if (!inf->attach_flag)
1633         {
1634           kill (inf->pid, 9);
1635           waitpid (inf->pid, &status, 0);
1636         }
1637
1638       error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1639                " (please check gdb is codesigned - see taskgated(8))"),
1640              inf->pid, mach_error_string (kret), (unsigned long) kret);
1641     }
1642
1643   inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1644                   inf->priv->task, inf->pid);
1645
1646   if (darwin_ex_port == MACH_PORT_NULL)
1647     {
1648       /* Create a port to get exceptions.  */
1649       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1650                                  &darwin_ex_port);
1651       if (kret != KERN_SUCCESS)
1652         error (_("Unable to create exception port, mach_port_allocate "
1653                  "returned: %d"),
1654                kret);
1655
1656       kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1657                                      MACH_MSG_TYPE_MAKE_SEND);
1658       if (kret != KERN_SUCCESS)
1659         error (_("Unable to create exception port, mach_port_insert_right "
1660                  "returned: %d"),
1661                kret);
1662
1663       /* Create a port set and put ex_port in it.  */
1664       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1665                                  &darwin_port_set);
1666       if (kret != KERN_SUCCESS)
1667         error (_("Unable to create port set, mach_port_allocate "
1668                  "returned: %d"),
1669                kret);
1670
1671       kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
1672       if (kret != KERN_SUCCESS)
1673         error (_("Unable to move exception port into new port set, "
1674                  "mach_port_move_member\n"
1675                  "returned: %d"),
1676                kret);
1677     }
1678
1679   /* Create a port to be notified when the child task terminates.  */
1680   kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1681                              &inf->priv->notify_port);
1682   if (kret != KERN_SUCCESS)
1683     error (_("Unable to create notification port, mach_port_allocate "
1684              "returned: %d"),
1685            kret);
1686
1687   kret = mach_port_move_member (gdb_task,
1688                                 inf->priv->notify_port, darwin_port_set);
1689   if (kret != KERN_SUCCESS)
1690     error (_("Unable to move notification port into new port set, "
1691              "mach_port_move_member\n"
1692              "returned: %d"),
1693            kret);
1694
1695   darwin_setup_request_notification (inf);
1696
1697   darwin_setup_exceptions (inf);
1698
1699   if (!target_is_pushed (darwin_ops))
1700     push_target (darwin_ops);
1701 }
1702
1703 static void
1704 darwin_init_thread_list (struct inferior *inf)
1705 {
1706   darwin_thread_t *thread;
1707   ptid_t new_ptid;
1708
1709   darwin_check_new_threads (inf);
1710
1711   gdb_assert (inf->priv->threads
1712               && VEC_length (darwin_thread_t, inf->priv->threads) > 0);
1713   thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1714
1715   /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1716      Fix up.  */
1717   new_ptid = ptid_build (inf->pid, 0, thread->gdb_port);
1718   thread_change_ptid (inferior_ptid, new_ptid);
1719   inferior_ptid = new_ptid;
1720 }
1721
1722 /* The child must synchronize with gdb: gdb must set the exception port
1723    before the child call PTRACE_SIGEXC.  We use a pipe to achieve this.
1724    FIXME: is there a lighter way ?  */
1725 static int ptrace_fds[2];
1726
1727 static void
1728 darwin_ptrace_me (void)
1729 {
1730   int res;
1731   char c;
1732
1733   /* Close write end point.  */
1734   if (close (ptrace_fds[1]) < 0)
1735     trace_start_error_with_name ("close");
1736
1737   /* Wait until gdb is ready.  */
1738   res = read (ptrace_fds[0], &c, 1);
1739   if (res != 0)
1740     trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1741
1742   if (close (ptrace_fds[0]) < 0)
1743     trace_start_error_with_name ("close");
1744
1745   /* Get rid of privileges.  */
1746   if (setegid (getgid ()) < 0)
1747     trace_start_error_with_name ("setegid");
1748
1749   /* Set TRACEME.  */
1750   if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1751     trace_start_error_with_name ("PTRACE");
1752
1753   /* Redirect signals to exception port.  */
1754   if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1755     trace_start_error_with_name ("PTRACE");
1756 }
1757
1758 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).  */
1759 static void
1760 darwin_pre_ptrace (void)
1761 {
1762   if (pipe (ptrace_fds) != 0)
1763     {
1764       ptrace_fds[0] = -1;
1765       ptrace_fds[1] = -1;
1766       error (_("unable to create a pipe: %s"), safe_strerror (errno));
1767     }
1768
1769   mark_fd_no_cloexec (ptrace_fds[0]);
1770   mark_fd_no_cloexec (ptrace_fds[1]);
1771 }
1772
1773 static void
1774 darwin_ptrace_him (int pid)
1775 {
1776   task_t itask;
1777   kern_return_t kret;
1778   mach_port_t prev_port;
1779   int traps_expected;
1780   struct inferior *inf = current_inferior ();
1781
1782   darwin_attach_pid (inf);
1783
1784   /* Let's the child run.  */
1785   close (ptrace_fds[0]);
1786   close (ptrace_fds[1]);
1787
1788   unmark_fd_no_cloexec (ptrace_fds[0]);
1789   unmark_fd_no_cloexec (ptrace_fds[1]);
1790
1791   darwin_init_thread_list (inf);
1792
1793   startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
1794 }
1795
1796 static void
1797 darwin_execvp (const char *file, char * const argv[], char * const env[])
1798 {
1799   posix_spawnattr_t attr;
1800   short ps_flags = 0;
1801   int res;
1802
1803   res = posix_spawnattr_init (&attr);
1804   if (res != 0)
1805     {
1806       fprintf_unfiltered
1807         (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1808       return;
1809     }
1810
1811   /* Do like execve: replace the image.  */
1812   ps_flags = POSIX_SPAWN_SETEXEC;
1813
1814   /* Disable ASLR.  The constant doesn't look to be available outside the
1815      kernel include files.  */
1816 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1817 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1818 #endif
1819   ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1820   res = posix_spawnattr_setflags (&attr, ps_flags);
1821   if (res != 0)
1822     {
1823       fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1824       return;
1825     }
1826
1827   posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1828 }
1829
1830 static void
1831 darwin_create_inferior (struct target_ops *ops,
1832                         const char *exec_file,
1833                         const std::string &allargs,
1834                         char **env, int from_tty)
1835 {
1836   /* Do the hard work.  */
1837   fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
1838                  darwin_pre_ptrace, NULL, darwin_execvp);
1839
1840   /* Return now in case of error.  */
1841   if (ptid_equal (inferior_ptid, null_ptid))
1842     return;
1843 }
1844 \f
1845
1846 /* Set things up such that the next call to darwin_wait will immediately
1847    return a fake stop event for inferior INF.
1848
1849    This assumes that the inferior's thread list has been initialized,
1850    as it will suspend the inferior's first thread.  */
1851
1852 static void
1853 darwin_setup_fake_stop_event (struct inferior *inf)
1854 {
1855   darwin_thread_t *thread;
1856   kern_return_t kret;
1857
1858   gdb_assert (darwin_inf_fake_stop == NULL);
1859   darwin_inf_fake_stop = inf;
1860
1861   /* When detecting a fake pending stop event, darwin_wait returns
1862      an event saying that the first thread is in a DARWIN_STOPPED
1863      state.  To make that accurate, we need to suspend that thread
1864      as well.  Otherwise, we'll try resuming it when resuming the
1865      inferior, and get a warning because the thread's suspend count
1866      is already zero, making the resume request useless.  */
1867   thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1868   kret = thread_suspend (thread->gdb_port);
1869   MACH_CHECK_ERROR (kret);
1870 }
1871
1872 /* Attach to process PID, then initialize for debugging it
1873    and wait for the trace-trap that results from attaching.  */
1874 static void
1875 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1876 {
1877   pid_t pid;
1878   pid_t pid2;
1879   int wstatus;
1880   int res;
1881   struct inferior *inf;
1882   kern_return_t kret;
1883
1884   pid = parse_pid_to_attach (args);
1885
1886   if (pid == getpid ())         /* Trying to masturbate?  */
1887     error (_("I refuse to debug myself!"));
1888
1889   if (from_tty)
1890     {
1891       char *exec_file = get_exec_file (0);
1892
1893       if (exec_file)
1894         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1895                            target_pid_to_str (pid_to_ptid (pid)));
1896       else
1897         printf_unfiltered (_("Attaching to %s\n"),
1898                            target_pid_to_str (pid_to_ptid (pid)));
1899
1900       gdb_flush (gdb_stdout);
1901     }
1902
1903   if (pid == 0 || kill (pid, 0) < 0)
1904     error (_("Can't attach to process %d: %s (%d)"),
1905            pid, safe_strerror (errno), errno);
1906
1907   inferior_ptid = pid_to_ptid (pid);
1908   inf = current_inferior ();
1909   inferior_appeared (inf, pid);
1910   inf->attach_flag = 1;
1911
1912   /* Always add a main thread.  */
1913   add_thread_silent (inferior_ptid);
1914
1915   darwin_attach_pid (inf);
1916
1917   darwin_suspend_inferior (inf);
1918
1919   darwin_init_thread_list (inf);
1920
1921   darwin_check_osabi (inf->priv, ptid_get_tid (inferior_ptid));
1922
1923   darwin_setup_fake_stop_event (inf);
1924
1925   inf->priv->no_ptrace = 1;
1926 }
1927
1928 /* Take a program previously attached to and detaches it.
1929    The program resumes execution and will no longer stop
1930    on signals, etc.  We'd better not have left any breakpoints
1931    in the program or it'll die when it hits one.  For this
1932    to work, it may be necessary for the process to have been
1933    previously attached.  It *might* work if the program was
1934    started via fork.  */
1935 static void
1936 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1937 {
1938   pid_t pid = ptid_get_pid (inferior_ptid);
1939   struct inferior *inf = current_inferior ();
1940   kern_return_t kret;
1941   int res;
1942
1943   /* Display message.  */
1944   target_announce_detach (from_tty);
1945
1946   /* If ptrace() is in use, stop the process.  */
1947   if (!inf->priv->no_ptrace)
1948     darwin_stop_inferior (inf);
1949
1950   kret = darwin_restore_exception_ports (inf->priv);
1951   MACH_CHECK_ERROR (kret);
1952
1953   if (!inf->priv->no_ptrace)
1954     {
1955       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1956       if (res != 0)
1957         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1958                            inf->pid, safe_strerror (errno), errno);
1959     }
1960
1961   darwin_reply_to_all_pending_messages (inf);
1962
1963   /* When using ptrace, we have just performed a PT_DETACH, which
1964      resumes the inferior.  On the other hand, when we are not using
1965      ptrace, we need to resume its execution ourselves.  */
1966   if (inf->priv->no_ptrace)
1967     darwin_resume_inferior (inf);
1968
1969   darwin_mourn_inferior (ops);
1970 }
1971
1972 static void
1973 darwin_files_info (struct target_ops *ops)
1974 {
1975 }
1976
1977 static const char *
1978 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1979 {
1980   static char buf[80];
1981   long tid = ptid_get_tid (ptid);
1982
1983   if (tid != 0)
1984     {
1985       snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1986                 tid, ptid_get_pid (ptid));
1987       return buf;
1988     }
1989
1990   return normal_pid_to_str (ptid);
1991 }
1992
1993 static int
1994 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
1995 {
1996   return 1;
1997 }
1998
1999 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2000    copy it to RDADDR in gdb's address space.
2001    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2002    to ADDR in inferior task's address space.
2003    Return 0 on failure; number of bytes read / writen otherwise.  */
2004
2005 static int
2006 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2007                             gdb_byte *rdaddr, const gdb_byte *wraddr,
2008                             ULONGEST length)
2009 {
2010   kern_return_t kret;
2011   mach_vm_size_t res_length = 0;
2012   pointer_t copied;
2013   mach_msg_type_number_t copy_count;
2014   mach_vm_size_t remaining_length;
2015   mach_vm_address_t region_address;
2016   mach_vm_size_t region_length;
2017
2018   inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2019                   task, core_addr_to_string (addr), pulongest (length));
2020
2021   /* First read.  */
2022   if (rdaddr != NULL)
2023     {
2024       mach_vm_size_t count;
2025
2026       /* According to target.h(to_xfer_partial), one and only one may be
2027          non-null.  */
2028       gdb_assert (wraddr == NULL);
2029
2030       kret = mach_vm_read_overwrite (task, addr, length,
2031                                      (mach_vm_address_t) rdaddr, &count);
2032       if (kret != KERN_SUCCESS)
2033         {
2034           inferior_debug
2035             (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2036              core_addr_to_string (addr), mach_error_string (kret));
2037           return 0;
2038         }
2039       return count;
2040     }
2041
2042   /* See above.  */
2043   gdb_assert (wraddr != NULL);
2044
2045   while (length != 0)
2046     {
2047       mach_vm_address_t offset = addr & (mach_page_size - 1);
2048       mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2049       mach_vm_size_t aligned_length =
2050         (mach_vm_size_t) PAGE_ROUND (offset + length);
2051       vm_region_submap_short_info_data_64_t info;
2052       mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2053       natural_t region_depth = 1000;
2054       mach_vm_address_t region_start = region_address;
2055       mach_vm_size_t region_length;
2056       mach_vm_size_t write_length;
2057
2058       /* Read page protection.  */
2059       kret = mach_vm_region_recurse
2060         (task, &region_start, &region_length, &region_depth,
2061          (vm_region_recurse_info_t) &info, &count);
2062
2063       if (kret != KERN_SUCCESS)
2064         {
2065           inferior_debug (1, _("darwin_read_write_inferior: "
2066                                "mach_vm_region_recurse failed at %s: %s\n"),
2067                           core_addr_to_string (region_address),
2068                           mach_error_string (kret));
2069           return res_length;
2070         }
2071
2072       inferior_debug
2073         (9, _("darwin_read_write_inferior: "
2074               "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2075          core_addr_to_string (region_address),
2076          core_addr_to_string (region_start),
2077          core_addr_to_string (region_length));
2078
2079       /* Check for holes in memory.  */
2080       if (region_start > region_address)
2081         {
2082           warning (_("No memory at %s (vs %s+0x%x).  Nothing written"),
2083                    core_addr_to_string (region_address),
2084                    core_addr_to_string (region_start),
2085                    (unsigned)region_length);
2086           return res_length;
2087         }
2088
2089       /* Adjust the length.  */
2090       region_length -= (region_address - region_start);
2091       if (region_length > aligned_length)
2092         region_length = aligned_length;
2093
2094       /* Make the pages RW.  */
2095       if (!(info.protection & VM_PROT_WRITE))
2096         {
2097           vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2098
2099           kret = mach_vm_protect (task, region_address, region_length,
2100                                   FALSE, prot);
2101           if (kret != KERN_SUCCESS)
2102             {
2103               prot |= VM_PROT_COPY;
2104               kret = mach_vm_protect (task, region_address, region_length,
2105                                       FALSE, prot);
2106             }
2107           if (kret != KERN_SUCCESS)
2108             {
2109               warning (_("darwin_read_write_inferior: "
2110                          "mach_vm_protect failed at %s "
2111                          "(len=0x%lx, prot=0x%x): %s"),
2112                        core_addr_to_string (region_address),
2113                        (unsigned long) region_length, (unsigned) prot,
2114                        mach_error_string (kret));
2115               return res_length;
2116             }
2117         }
2118
2119       if (offset + length > region_length)
2120         write_length = region_length - offset;
2121       else
2122         write_length = length;
2123
2124       /* Write.  */
2125       kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2126       if (kret != KERN_SUCCESS)
2127         {
2128           warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2129                    mach_error_string (kret));
2130           return res_length;
2131         }
2132
2133       /* Restore page rights.  */
2134       if (!(info.protection & VM_PROT_WRITE))
2135         {
2136           kret = mach_vm_protect (task, region_address, region_length,
2137                                   FALSE, info.protection);
2138           if (kret != KERN_SUCCESS)
2139             {
2140               warning (_("darwin_read_write_inferior: "
2141                          "mach_vm_protect restore failed at %s "
2142                          "(len=0x%lx): %s"),
2143                        core_addr_to_string (region_address),
2144                        (unsigned long) region_length,
2145                        mach_error_string (kret));
2146             }
2147         }
2148
2149       addr += write_length;
2150       wraddr += write_length;
2151       res_length += write_length;
2152       length -= write_length;
2153     }
2154
2155   return res_length;
2156 }
2157
2158 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2159    to RDADDR (in big endian).
2160    Return 0 on failure; number of bytes read / written otherwise.  */
2161
2162 #ifdef TASK_DYLD_INFO_COUNT
2163 /* This is not available in Darwin 9.  */
2164 static enum target_xfer_status
2165 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2166                        ULONGEST length, ULONGEST *xfered_len)
2167 {
2168   struct task_dyld_info task_dyld_info;
2169   mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2170   int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
2171   kern_return_t kret;
2172
2173   if (addr != 0 || length > sizeof (mach_vm_address_t))
2174     return TARGET_XFER_EOF;
2175
2176   kret = task_info (task, TASK_DYLD_INFO,
2177                     (task_info_t) &task_dyld_info, &count);
2178   MACH_CHECK_ERROR (kret);
2179   if (kret != KERN_SUCCESS)
2180     return TARGET_XFER_E_IO;
2181
2182   store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2183                           task_dyld_info.all_image_info_addr);
2184   *xfered_len = (ULONGEST) length;
2185   return TARGET_XFER_OK;
2186 }
2187 #endif
2188
2189 \f
2190
2191 static enum target_xfer_status
2192 darwin_xfer_partial (struct target_ops *ops,
2193                      enum target_object object, const char *annex,
2194                      gdb_byte *readbuf, const gdb_byte *writebuf,
2195                      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
2196 {
2197   struct inferior *inf = current_inferior ();
2198
2199   inferior_debug
2200     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2201      core_addr_to_string (offset), pulongest (len),
2202      host_address_to_string (readbuf), host_address_to_string (writebuf),
2203      inf->pid);
2204
2205   switch (object)
2206     {
2207     case TARGET_OBJECT_MEMORY:
2208       {
2209         int l = darwin_read_write_inferior (inf->priv->task, offset,
2210                                             readbuf, writebuf, len);
2211
2212         if (l == 0)
2213           return TARGET_XFER_EOF;
2214         else
2215           {
2216             gdb_assert (l > 0);
2217             *xfered_len = (ULONGEST) l;
2218             return TARGET_XFER_OK;
2219           }
2220       }
2221 #ifdef TASK_DYLD_INFO_COUNT
2222     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2223       if (writebuf != NULL || readbuf == NULL)
2224         {
2225           /* Support only read.  */
2226           return TARGET_XFER_E_IO;
2227         }
2228       return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
2229                                     xfered_len);
2230 #endif
2231     default:
2232       return TARGET_XFER_E_IO;
2233     }
2234
2235 }
2236
2237 static void
2238 set_enable_mach_exceptions (char *args, int from_tty,
2239                             struct cmd_list_element *c)
2240 {
2241   if (!ptid_equal (inferior_ptid, null_ptid))
2242     {
2243       struct inferior *inf = current_inferior ();
2244       exception_mask_t mask;
2245       kern_return_t kret;
2246
2247       if (enable_mach_exceptions)
2248         mask = EXC_MASK_ALL;
2249       else
2250         {
2251           darwin_restore_exception_ports (inf->priv);
2252           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2253         }
2254       kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
2255                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2256       MACH_CHECK_ERROR (kret);
2257     }
2258 }
2259
2260 static char *
2261 darwin_pid_to_exec_file (struct target_ops *self, int pid)
2262 {
2263   static char path[PATH_MAX];
2264   int res;
2265
2266   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2267   if (res >= 0)
2268     return path;
2269   else
2270     return NULL;
2271 }
2272
2273 static ptid_t
2274 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2275 {
2276   int i;
2277   darwin_thread_t *t;
2278   int k;
2279   struct inferior *inf = current_inferior ();
2280   kern_return_t kret;
2281   mach_port_name_array_t names;
2282   mach_msg_type_number_t names_count;
2283   mach_port_type_array_t types;
2284   mach_msg_type_number_t types_count;
2285   long res = 0;
2286
2287   /* First linear search.  */
2288   for (k = 0;
2289        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2290        k++)
2291     if (t->inf_port == lwp)
2292       return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2293
2294   /* Maybe the port was never extract.  Do it now.  */
2295
2296   /* First get inferior port names.  */
2297   kret = mach_port_names (inf->priv->task, &names, &names_count, &types,
2298                           &types_count);
2299   MACH_CHECK_ERROR (kret);
2300   if (kret != KERN_SUCCESS)
2301     return null_ptid;
2302
2303   /* For each name, copy the right in the gdb space and then compare with
2304      our view of the inferior threads.  We don't forget to deallocate the
2305      right.  */
2306   for (i = 0; i < names_count; i++)
2307     {
2308       mach_port_t local_name;
2309       mach_msg_type_name_t local_type;
2310
2311       /* We just need to know the corresponding name in gdb name space.
2312          So extract and deallocate the right.  */
2313       kret = mach_port_extract_right (inf->priv->task, names[i],
2314                                       MACH_MSG_TYPE_COPY_SEND,
2315                                       &local_name, &local_type);
2316       if (kret != KERN_SUCCESS)
2317         continue;
2318       mach_port_deallocate (gdb_task, local_name);
2319
2320       for (k = 0;
2321            VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2322            k++)
2323         if (t->gdb_port == local_name)
2324           {
2325             t->inf_port = names[i];
2326             if (names[i] == lwp)
2327               res = t->gdb_port;
2328           }
2329     }
2330
2331   vm_deallocate (gdb_task, (vm_address_t) names,
2332                  names_count * sizeof (mach_port_t));
2333
2334   if (res)
2335     return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2336   else
2337     return null_ptid;
2338 }
2339
2340 static int
2341 darwin_supports_multi_process (struct target_ops *self)
2342 {
2343   return 1;
2344 }
2345
2346 /* -Wmissing-prototypes */
2347 extern initialize_file_ftype _initialize_darwin_inferior;
2348
2349 void
2350 _initialize_darwin_inferior (void)
2351 {
2352   kern_return_t kret;
2353
2354   gdb_task = mach_task_self ();
2355   darwin_host_self = mach_host_self ();
2356
2357   /* Read page size.  */
2358   kret = host_page_size (darwin_host_self, &mach_page_size);
2359   if (kret != KERN_SUCCESS)
2360     {
2361       mach_page_size = 0x1000;
2362       MACH_CHECK_ERROR (kret);
2363     }
2364
2365   darwin_ops = inf_child_target ();
2366
2367   darwin_ops->to_create_inferior = darwin_create_inferior;
2368   darwin_ops->to_attach = darwin_attach;
2369   darwin_ops->to_attach_no_wait = 0;
2370   darwin_ops->to_detach = darwin_detach;
2371   darwin_ops->to_files_info = darwin_files_info;
2372   darwin_ops->to_wait = darwin_wait_to;
2373   darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2374   darwin_ops->to_kill = darwin_kill_inferior;
2375   darwin_ops->to_interrupt = darwin_interrupt;
2376   darwin_ops->to_resume = darwin_resume_to;
2377   darwin_ops->to_thread_alive = darwin_thread_alive;
2378   darwin_ops->to_pid_to_str = darwin_pid_to_str;
2379   darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
2380   darwin_ops->to_load = NULL;
2381   darwin_ops->to_xfer_partial = darwin_xfer_partial;
2382   darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2383   darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
2384
2385   darwin_complete_target (darwin_ops);
2386
2387   add_target (darwin_ops);
2388
2389   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2390                   (unsigned long) mach_task_self (), getpid ());
2391
2392   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2393                              &darwin_debug_flag, _("\
2394 Set if printing inferior communication debugging statements."), _("\
2395 Show if printing inferior communication debugging statements."), NULL,
2396                              NULL, NULL,
2397                              &setdebuglist, &showdebuglist);
2398
2399   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2400                            &enable_mach_exceptions, _("\
2401 Set if mach exceptions are caught."), _("\
2402 Show if mach exceptions are caught."), _("\
2403 When this mode is on, all low level exceptions are reported before being\n\
2404 reported by the kernel."),
2405                            &set_enable_mach_exceptions, NULL,
2406                            &setlist, &showlist);
2407 }