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   gdb_startup_inferior (pid, 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   pid_t pid;
1837   ptid_t ptid;
1838
1839   /* Do the hard work.  */
1840   pid = fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1841                        darwin_ptrace_him, darwin_pre_ptrace, NULL,
1842                        darwin_execvp);
1843
1844   ptid = pid_to_ptid (pid);
1845   /* Return now in case of error.  */
1846   if (ptid_equal (inferior_ptid, null_ptid))
1847     return;
1848
1849   /* We have something that executes now.  We'll be running through
1850      the shell at this point (if startup-with-shell is true), but the
1851      pid shouldn't change.  */
1852   add_thread_silent (ptid);
1853 }
1854 \f
1855
1856 /* Set things up such that the next call to darwin_wait will immediately
1857    return a fake stop event for inferior INF.
1858
1859    This assumes that the inferior's thread list has been initialized,
1860    as it will suspend the inferior's first thread.  */
1861
1862 static void
1863 darwin_setup_fake_stop_event (struct inferior *inf)
1864 {
1865   darwin_thread_t *thread;
1866   kern_return_t kret;
1867
1868   gdb_assert (darwin_inf_fake_stop == NULL);
1869   darwin_inf_fake_stop = inf;
1870
1871   /* When detecting a fake pending stop event, darwin_wait returns
1872      an event saying that the first thread is in a DARWIN_STOPPED
1873      state.  To make that accurate, we need to suspend that thread
1874      as well.  Otherwise, we'll try resuming it when resuming the
1875      inferior, and get a warning because the thread's suspend count
1876      is already zero, making the resume request useless.  */
1877   thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1878   kret = thread_suspend (thread->gdb_port);
1879   MACH_CHECK_ERROR (kret);
1880 }
1881
1882 /* Attach to process PID, then initialize for debugging it
1883    and wait for the trace-trap that results from attaching.  */
1884 static void
1885 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1886 {
1887   pid_t pid;
1888   pid_t pid2;
1889   int wstatus;
1890   int res;
1891   struct inferior *inf;
1892   kern_return_t kret;
1893
1894   pid = parse_pid_to_attach (args);
1895
1896   if (pid == getpid ())         /* Trying to masturbate?  */
1897     error (_("I refuse to debug myself!"));
1898
1899   if (from_tty)
1900     {
1901       char *exec_file = get_exec_file (0);
1902
1903       if (exec_file)
1904         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1905                            target_pid_to_str (pid_to_ptid (pid)));
1906       else
1907         printf_unfiltered (_("Attaching to %s\n"),
1908                            target_pid_to_str (pid_to_ptid (pid)));
1909
1910       gdb_flush (gdb_stdout);
1911     }
1912
1913   if (pid == 0 || kill (pid, 0) < 0)
1914     error (_("Can't attach to process %d: %s (%d)"),
1915            pid, safe_strerror (errno), errno);
1916
1917   inferior_ptid = pid_to_ptid (pid);
1918   inf = current_inferior ();
1919   inferior_appeared (inf, pid);
1920   inf->attach_flag = 1;
1921
1922   /* Always add a main thread.  */
1923   add_thread_silent (inferior_ptid);
1924
1925   darwin_attach_pid (inf);
1926
1927   darwin_suspend_inferior (inf);
1928
1929   darwin_init_thread_list (inf);
1930
1931   darwin_check_osabi (inf->priv, ptid_get_tid (inferior_ptid));
1932
1933   darwin_setup_fake_stop_event (inf);
1934
1935   inf->priv->no_ptrace = 1;
1936 }
1937
1938 /* Take a program previously attached to and detaches it.
1939    The program resumes execution and will no longer stop
1940    on signals, etc.  We'd better not have left any breakpoints
1941    in the program or it'll die when it hits one.  For this
1942    to work, it may be necessary for the process to have been
1943    previously attached.  It *might* work if the program was
1944    started via fork.  */
1945 static void
1946 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1947 {
1948   pid_t pid = ptid_get_pid (inferior_ptid);
1949   struct inferior *inf = current_inferior ();
1950   kern_return_t kret;
1951   int res;
1952
1953   /* Display message.  */
1954   target_announce_detach (from_tty);
1955
1956   /* If ptrace() is in use, stop the process.  */
1957   if (!inf->priv->no_ptrace)
1958     darwin_stop_inferior (inf);
1959
1960   kret = darwin_restore_exception_ports (inf->priv);
1961   MACH_CHECK_ERROR (kret);
1962
1963   if (!inf->priv->no_ptrace)
1964     {
1965       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1966       if (res != 0)
1967         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1968                            inf->pid, safe_strerror (errno), errno);
1969     }
1970
1971   darwin_reply_to_all_pending_messages (inf);
1972
1973   /* When using ptrace, we have just performed a PT_DETACH, which
1974      resumes the inferior.  On the other hand, when we are not using
1975      ptrace, we need to resume its execution ourselves.  */
1976   if (inf->priv->no_ptrace)
1977     darwin_resume_inferior (inf);
1978
1979   darwin_mourn_inferior (ops);
1980 }
1981
1982 static void
1983 darwin_files_info (struct target_ops *ops)
1984 {
1985 }
1986
1987 static const char *
1988 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1989 {
1990   static char buf[80];
1991   long tid = ptid_get_tid (ptid);
1992
1993   if (tid != 0)
1994     {
1995       snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1996                 tid, ptid_get_pid (ptid));
1997       return buf;
1998     }
1999
2000   return normal_pid_to_str (ptid);
2001 }
2002
2003 static int
2004 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
2005 {
2006   return 1;
2007 }
2008
2009 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2010    copy it to RDADDR in gdb's address space.
2011    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2012    to ADDR in inferior task's address space.
2013    Return 0 on failure; number of bytes read / writen otherwise.  */
2014
2015 static int
2016 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2017                             gdb_byte *rdaddr, const gdb_byte *wraddr,
2018                             ULONGEST length)
2019 {
2020   kern_return_t kret;
2021   mach_vm_size_t res_length = 0;
2022   pointer_t copied;
2023   mach_msg_type_number_t copy_count;
2024   mach_vm_size_t remaining_length;
2025   mach_vm_address_t region_address;
2026   mach_vm_size_t region_length;
2027
2028   inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2029                   task, core_addr_to_string (addr), pulongest (length));
2030
2031   /* First read.  */
2032   if (rdaddr != NULL)
2033     {
2034       mach_vm_size_t count;
2035
2036       /* According to target.h(to_xfer_partial), one and only one may be
2037          non-null.  */
2038       gdb_assert (wraddr == NULL);
2039
2040       kret = mach_vm_read_overwrite (task, addr, length,
2041                                      (mach_vm_address_t) rdaddr, &count);
2042       if (kret != KERN_SUCCESS)
2043         {
2044           inferior_debug
2045             (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2046              core_addr_to_string (addr), mach_error_string (kret));
2047           return 0;
2048         }
2049       return count;
2050     }
2051
2052   /* See above.  */
2053   gdb_assert (wraddr != NULL);
2054
2055   while (length != 0)
2056     {
2057       mach_vm_address_t offset = addr & (mach_page_size - 1);
2058       mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2059       mach_vm_size_t aligned_length =
2060         (mach_vm_size_t) PAGE_ROUND (offset + length);
2061       vm_region_submap_short_info_data_64_t info;
2062       mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2063       natural_t region_depth = 1000;
2064       mach_vm_address_t region_start = region_address;
2065       mach_vm_size_t region_length;
2066       mach_vm_size_t write_length;
2067
2068       /* Read page protection.  */
2069       kret = mach_vm_region_recurse
2070         (task, &region_start, &region_length, &region_depth,
2071          (vm_region_recurse_info_t) &info, &count);
2072
2073       if (kret != KERN_SUCCESS)
2074         {
2075           inferior_debug (1, _("darwin_read_write_inferior: "
2076                                "mach_vm_region_recurse failed at %s: %s\n"),
2077                           core_addr_to_string (region_address),
2078                           mach_error_string (kret));
2079           return res_length;
2080         }
2081
2082       inferior_debug
2083         (9, _("darwin_read_write_inferior: "
2084               "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2085          core_addr_to_string (region_address),
2086          core_addr_to_string (region_start),
2087          core_addr_to_string (region_length));
2088
2089       /* Check for holes in memory.  */
2090       if (region_start > region_address)
2091         {
2092           warning (_("No memory at %s (vs %s+0x%x).  Nothing written"),
2093                    core_addr_to_string (region_address),
2094                    core_addr_to_string (region_start),
2095                    (unsigned)region_length);
2096           return res_length;
2097         }
2098
2099       /* Adjust the length.  */
2100       region_length -= (region_address - region_start);
2101       if (region_length > aligned_length)
2102         region_length = aligned_length;
2103
2104       /* Make the pages RW.  */
2105       if (!(info.protection & VM_PROT_WRITE))
2106         {
2107           vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2108
2109           kret = mach_vm_protect (task, region_address, region_length,
2110                                   FALSE, prot);
2111           if (kret != KERN_SUCCESS)
2112             {
2113               prot |= VM_PROT_COPY;
2114               kret = mach_vm_protect (task, region_address, region_length,
2115                                       FALSE, prot);
2116             }
2117           if (kret != KERN_SUCCESS)
2118             {
2119               warning (_("darwin_read_write_inferior: "
2120                          "mach_vm_protect failed at %s "
2121                          "(len=0x%lx, prot=0x%x): %s"),
2122                        core_addr_to_string (region_address),
2123                        (unsigned long) region_length, (unsigned) prot,
2124                        mach_error_string (kret));
2125               return res_length;
2126             }
2127         }
2128
2129       if (offset + length > region_length)
2130         write_length = region_length - offset;
2131       else
2132         write_length = length;
2133
2134       /* Write.  */
2135       kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2136       if (kret != KERN_SUCCESS)
2137         {
2138           warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2139                    mach_error_string (kret));
2140           return res_length;
2141         }
2142
2143       /* Restore page rights.  */
2144       if (!(info.protection & VM_PROT_WRITE))
2145         {
2146           kret = mach_vm_protect (task, region_address, region_length,
2147                                   FALSE, info.protection);
2148           if (kret != KERN_SUCCESS)
2149             {
2150               warning (_("darwin_read_write_inferior: "
2151                          "mach_vm_protect restore failed at %s "
2152                          "(len=0x%lx): %s"),
2153                        core_addr_to_string (region_address),
2154                        (unsigned long) region_length,
2155                        mach_error_string (kret));
2156             }
2157         }
2158
2159       addr += write_length;
2160       wraddr += write_length;
2161       res_length += write_length;
2162       length -= write_length;
2163     }
2164
2165   return res_length;
2166 }
2167
2168 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2169    to RDADDR (in big endian).
2170    Return 0 on failure; number of bytes read / written otherwise.  */
2171
2172 #ifdef TASK_DYLD_INFO_COUNT
2173 /* This is not available in Darwin 9.  */
2174 static enum target_xfer_status
2175 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2176                        ULONGEST length, ULONGEST *xfered_len)
2177 {
2178   struct task_dyld_info task_dyld_info;
2179   mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2180   int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
2181   kern_return_t kret;
2182
2183   if (addr != 0 || length > sizeof (mach_vm_address_t))
2184     return TARGET_XFER_EOF;
2185
2186   kret = task_info (task, TASK_DYLD_INFO,
2187                     (task_info_t) &task_dyld_info, &count);
2188   MACH_CHECK_ERROR (kret);
2189   if (kret != KERN_SUCCESS)
2190     return TARGET_XFER_E_IO;
2191
2192   store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2193                           task_dyld_info.all_image_info_addr);
2194   *xfered_len = (ULONGEST) length;
2195   return TARGET_XFER_OK;
2196 }
2197 #endif
2198
2199 \f
2200
2201 static enum target_xfer_status
2202 darwin_xfer_partial (struct target_ops *ops,
2203                      enum target_object object, const char *annex,
2204                      gdb_byte *readbuf, const gdb_byte *writebuf,
2205                      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
2206 {
2207   struct inferior *inf = current_inferior ();
2208
2209   inferior_debug
2210     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2211      core_addr_to_string (offset), pulongest (len),
2212      host_address_to_string (readbuf), host_address_to_string (writebuf),
2213      inf->pid);
2214
2215   switch (object)
2216     {
2217     case TARGET_OBJECT_MEMORY:
2218       {
2219         int l = darwin_read_write_inferior (inf->priv->task, offset,
2220                                             readbuf, writebuf, len);
2221
2222         if (l == 0)
2223           return TARGET_XFER_EOF;
2224         else
2225           {
2226             gdb_assert (l > 0);
2227             *xfered_len = (ULONGEST) l;
2228             return TARGET_XFER_OK;
2229           }
2230       }
2231 #ifdef TASK_DYLD_INFO_COUNT
2232     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2233       if (writebuf != NULL || readbuf == NULL)
2234         {
2235           /* Support only read.  */
2236           return TARGET_XFER_E_IO;
2237         }
2238       return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
2239                                     xfered_len);
2240 #endif
2241     default:
2242       return TARGET_XFER_E_IO;
2243     }
2244
2245 }
2246
2247 static void
2248 set_enable_mach_exceptions (char *args, int from_tty,
2249                             struct cmd_list_element *c)
2250 {
2251   if (!ptid_equal (inferior_ptid, null_ptid))
2252     {
2253       struct inferior *inf = current_inferior ();
2254       exception_mask_t mask;
2255       kern_return_t kret;
2256
2257       if (enable_mach_exceptions)
2258         mask = EXC_MASK_ALL;
2259       else
2260         {
2261           darwin_restore_exception_ports (inf->priv);
2262           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2263         }
2264       kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
2265                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2266       MACH_CHECK_ERROR (kret);
2267     }
2268 }
2269
2270 static char *
2271 darwin_pid_to_exec_file (struct target_ops *self, int pid)
2272 {
2273   static char path[PATH_MAX];
2274   int res;
2275
2276   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2277   if (res >= 0)
2278     return path;
2279   else
2280     return NULL;
2281 }
2282
2283 static ptid_t
2284 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2285 {
2286   int i;
2287   darwin_thread_t *t;
2288   int k;
2289   struct inferior *inf = current_inferior ();
2290   kern_return_t kret;
2291   mach_port_name_array_t names;
2292   mach_msg_type_number_t names_count;
2293   mach_port_type_array_t types;
2294   mach_msg_type_number_t types_count;
2295   long res = 0;
2296
2297   /* First linear search.  */
2298   for (k = 0;
2299        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2300        k++)
2301     if (t->inf_port == lwp)
2302       return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2303
2304   /* Maybe the port was never extract.  Do it now.  */
2305
2306   /* First get inferior port names.  */
2307   kret = mach_port_names (inf->priv->task, &names, &names_count, &types,
2308                           &types_count);
2309   MACH_CHECK_ERROR (kret);
2310   if (kret != KERN_SUCCESS)
2311     return null_ptid;
2312
2313   /* For each name, copy the right in the gdb space and then compare with
2314      our view of the inferior threads.  We don't forget to deallocate the
2315      right.  */
2316   for (i = 0; i < names_count; i++)
2317     {
2318       mach_port_t local_name;
2319       mach_msg_type_name_t local_type;
2320
2321       /* We just need to know the corresponding name in gdb name space.
2322          So extract and deallocate the right.  */
2323       kret = mach_port_extract_right (inf->priv->task, names[i],
2324                                       MACH_MSG_TYPE_COPY_SEND,
2325                                       &local_name, &local_type);
2326       if (kret != KERN_SUCCESS)
2327         continue;
2328       mach_port_deallocate (gdb_task, local_name);
2329
2330       for (k = 0;
2331            VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2332            k++)
2333         if (t->gdb_port == local_name)
2334           {
2335             t->inf_port = names[i];
2336             if (names[i] == lwp)
2337               res = t->gdb_port;
2338           }
2339     }
2340
2341   vm_deallocate (gdb_task, (vm_address_t) names,
2342                  names_count * sizeof (mach_port_t));
2343
2344   if (res)
2345     return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2346   else
2347     return null_ptid;
2348 }
2349
2350 static int
2351 darwin_supports_multi_process (struct target_ops *self)
2352 {
2353   return 1;
2354 }
2355
2356 /* -Wmissing-prototypes */
2357 extern initialize_file_ftype _initialize_darwin_inferior;
2358
2359 void
2360 _initialize_darwin_inferior (void)
2361 {
2362   kern_return_t kret;
2363
2364   gdb_task = mach_task_self ();
2365   darwin_host_self = mach_host_self ();
2366
2367   /* Read page size.  */
2368   kret = host_page_size (darwin_host_self, &mach_page_size);
2369   if (kret != KERN_SUCCESS)
2370     {
2371       mach_page_size = 0x1000;
2372       MACH_CHECK_ERROR (kret);
2373     }
2374
2375   darwin_ops = inf_child_target ();
2376
2377   darwin_ops->to_create_inferior = darwin_create_inferior;
2378   darwin_ops->to_attach = darwin_attach;
2379   darwin_ops->to_attach_no_wait = 0;
2380   darwin_ops->to_detach = darwin_detach;
2381   darwin_ops->to_files_info = darwin_files_info;
2382   darwin_ops->to_wait = darwin_wait_to;
2383   darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2384   darwin_ops->to_kill = darwin_kill_inferior;
2385   darwin_ops->to_interrupt = darwin_interrupt;
2386   darwin_ops->to_resume = darwin_resume_to;
2387   darwin_ops->to_thread_alive = darwin_thread_alive;
2388   darwin_ops->to_pid_to_str = darwin_pid_to_str;
2389   darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
2390   darwin_ops->to_load = NULL;
2391   darwin_ops->to_xfer_partial = darwin_xfer_partial;
2392   darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2393   darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
2394
2395   darwin_complete_target (darwin_ops);
2396
2397   add_target (darwin_ops);
2398
2399   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2400                   (unsigned long) mach_task_self (), getpid ());
2401
2402   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2403                              &darwin_debug_flag, _("\
2404 Set if printing inferior communication debugging statements."), _("\
2405 Show if printing inferior communication debugging statements."), NULL,
2406                              NULL, NULL,
2407                              &setdebuglist, &showdebuglist);
2408
2409   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2410                            &enable_mach_exceptions, _("\
2411 Set if mach exceptions are caught."), _("\
2412 Show if mach exceptions are caught."), _("\
2413 When this mode is on, all low level exceptions are reported before being\n\
2414 reported by the kernel."),
2415                            &set_enable_mach_exceptions, NULL,
2416                            &setlist, &showlist);
2417 }