gdb/darwin-nat.c

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