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