gdb/darwin-nat.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2018 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 (ex, RETURN_MASK_ALL)
1692     {
1693       exit_inferior (inf);
1694       inferior_ptid = null_ptid;
1695
1696       throw_exception (ex);
1697     }
1698   END_CATCH
1699
1700   target_ops *darwin_ops = get_native_target ();
1701   if (!target_is_pushed (darwin_ops))
1702     push_target (darwin_ops);
1703 }
1704
1705 /* Get the thread_info object corresponding to this darwin_thread_info.  */
1706
1707 static struct thread_info *
1708 thread_info_from_private_thread_info (darwin_thread_info *pti)
1709 {
1710   struct thread_info *it;
1711
1712   ALL_THREADS (it)
1713     {
1714       darwin_thread_info *iter_pti = get_darwin_thread_info (it);
1715
1716       if (iter_pti->gdb_port == pti->gdb_port)
1717         break;
1718     }
1719
1720   gdb_assert (it != NULL);
1721
1722   return it;
1723 }
1724
1725 static void
1726 darwin_init_thread_list (struct inferior *inf)
1727 {
1728   darwin_check_new_threads (inf);
1729
1730   darwin_inferior *priv = get_darwin_inferior (inf);
1731
1732   gdb_assert (!priv->threads.empty ());
1733
1734   darwin_thread_info *first_pti = priv->threads.front ();
1735   struct thread_info *first_thread
1736     = thread_info_from_private_thread_info (first_pti);
1737
1738   inferior_ptid = first_thread->ptid;
1739 }
1740
1741 /* The child must synchronize with gdb: gdb must set the exception port
1742    before the child call PTRACE_SIGEXC.  We use a pipe to achieve this.
1743    FIXME: is there a lighter way ?  */
1744 static int ptrace_fds[2];
1745
1746 static void
1747 darwin_ptrace_me (void)
1748 {
1749   int res;
1750   char c;
1751
1752   /* Close write end point.  */
1753   if (close (ptrace_fds[1]) < 0)
1754     trace_start_error_with_name ("close");
1755
1756   /* Wait until gdb is ready.  */
1757   res = read (ptrace_fds[0], &c, 1);
1758   if (res != 0)
1759     trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1760
1761   if (close (ptrace_fds[0]) < 0)
1762     trace_start_error_with_name ("close");
1763
1764   /* Get rid of privileges.  */
1765   if (setegid (getgid ()) < 0)
1766     trace_start_error_with_name ("setegid");
1767
1768   /* Set TRACEME.  */
1769   if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1770     trace_start_error_with_name ("PTRACE");
1771
1772   /* Redirect signals to exception port.  */
1773   if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1774     trace_start_error_with_name ("PTRACE");
1775 }
1776
1777 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).  */
1778 static void
1779 darwin_pre_ptrace (void)
1780 {
1781   if (pipe (ptrace_fds) != 0)
1782     {
1783       ptrace_fds[0] = -1;
1784       ptrace_fds[1] = -1;
1785       error (_("unable to create a pipe: %s"), safe_strerror (errno));
1786     }
1787
1788   mark_fd_no_cloexec (ptrace_fds[0]);
1789   mark_fd_no_cloexec (ptrace_fds[1]);
1790 }
1791
1792 static void
1793 darwin_ptrace_him (int pid)
1794 {
1795   struct inferior *inf = current_inferior ();
1796
1797   darwin_attach_pid (inf);
1798
1799   /* Let's the child run.  */
1800   close (ptrace_fds[0]);
1801   close (ptrace_fds[1]);
1802
1803   unmark_fd_no_cloexec (ptrace_fds[0]);
1804   unmark_fd_no_cloexec (ptrace_fds[1]);
1805
1806   darwin_init_thread_list (inf);
1807
1808   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1809 }
1810
1811 static void
1812 darwin_execvp (const char *file, char * const argv[], char * const env[])
1813 {
1814   posix_spawnattr_t attr;
1815   short ps_flags = 0;
1816   int res;
1817
1818   res = posix_spawnattr_init (&attr);
1819   if (res != 0)
1820     {
1821       fprintf_unfiltered
1822         (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1823       return;
1824     }
1825
1826   /* Do like execve: replace the image.  */
1827   ps_flags = POSIX_SPAWN_SETEXEC;
1828
1829   /* Disable ASLR.  The constant doesn't look to be available outside the
1830      kernel include files.  */
1831 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1832 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1833 #endif
1834   ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1835   res = posix_spawnattr_setflags (&attr, ps_flags);
1836   if (res != 0)
1837     {
1838       fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1839       return;
1840     }
1841
1842   posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1843 }
1844
1845 /* Read kernel version, and return TRUE if this host may have System
1846    Integrity Protection (Sierra or later).  */
1847
1848 static bool
1849 may_have_sip ()
1850 {
1851   char str[16];
1852   size_t sz = sizeof (str);
1853   int ret;
1854
1855   ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
1856   if (ret == 0 && sz < sizeof (str))
1857     {
1858       unsigned long ver = strtoul (str, NULL, 10);
1859       if (ver >= 16)
1860         return true;
1861     }
1862   return false;
1863 }
1864
1865 /* A helper for maybe_cache_shell.  This copies the shell to the
1866    cache.  It will throw an exception on any failure.  */
1867
1868 static void
1869 copy_shell_to_cache (const char *shell, const std::string &new_name)
1870 {
1871   scoped_fd from_fd (gdb_open_cloexec (shell, O_RDONLY, 0));
1872   if (from_fd.get () < 0)
1873     error (_("Could not open shell (%s) for reading: %s"),
1874            shell, safe_strerror (errno));
1875
1876   std::string new_dir = ldirname (new_name.c_str ());
1877   if (!mkdir_recursive (new_dir.c_str ()))
1878     error (_("Could not make cache directory \"%s\": %s"),
1879            new_dir.c_str (), safe_strerror (errno));
1880
1881   gdb::char_vector temp_name = make_temp_filename (new_name);
1882   scoped_fd to_fd (gdb_mkostemp_cloexec (&temp_name[0]));
1883   gdb::unlinker unlink_file_on_error (temp_name.data ());
1884
1885   if (to_fd.get () < 0)
1886     error (_("Could not open temporary file \"%s\" for writing: %s"),
1887            temp_name.data (), safe_strerror (errno));
1888
1889   if (fcopyfile (from_fd.get (), to_fd.get (), nullptr,
1890                  COPYFILE_STAT | COPYFILE_DATA) != 0)
1891     error (_("Could not copy shell to cache as \"%s\": %s"),
1892            temp_name.data (), safe_strerror (errno));
1893
1894   /* Be sure that the caching is atomic so that we don't get bad
1895      results from multiple copies of gdb running at the same time.  */
1896   if (rename (temp_name.data (), new_name.c_str ()) != 0)
1897     error (_("Could not rename shell cache file to \"%s\": %s"),
1898            new_name.c_str (), safe_strerror (errno));
1899
1900   unlink_file_on_error.keep ();
1901 }
1902
1903 /* If $SHELL is restricted, try to cache a copy.  Starting with El
1904    Capitan, macOS introduced System Integrity Protection.  Among other
1905    things, this prevents certain executables from being ptrace'd.  In
1906    particular, executables in /bin, like most shells, are affected.
1907    To work around this, while preserving command-line glob expansion
1908    and redirections, gdb will cache a copy of the shell.  Return true
1909    if all is well -- either the shell is not subject to SIP or it has
1910    been successfully cached.  Returns false if something failed.  */
1911
1912 static bool
1913 maybe_cache_shell ()
1914 {
1915   /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1916      given file is subject to SIP.  */
1917 #ifdef SF_RESTRICTED
1918
1919   /* If a check fails we want to revert -- maybe the user deleted the
1920      cache while gdb was running, or something like that.  */
1921   copied_shell = nullptr;
1922
1923   const char *shell = get_shell ();
1924   if (!IS_ABSOLUTE_PATH (shell))
1925     {
1926       warning (_("This version of macOS has System Integrity Protection.\n\
1927 Normally gdb would try to work around this by caching a copy of your shell,\n\
1928 but because your shell (%s) is not an absolute path, this is being skipped."),
1929                shell);
1930       return false;
1931     }
1932
1933   struct stat sb;
1934   if (stat (shell, &sb) < 0)
1935     {
1936       warning (_("This version of macOS has System Integrity Protection.\n\
1937 Normally gdb would try to work around this by caching a copy of your shell,\n\
1938 but because gdb could not stat your shell (%s), this is being skipped.\n\
1939 The error was: %s"),
1940                shell, safe_strerror (errno));
1941       return false;
1942     }
1943
1944   if ((sb.st_flags & SF_RESTRICTED) == 0)
1945     return true;
1946
1947   /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh.  */
1948   std::string new_name = get_standard_cache_dir ();
1949   /* There's no need to insert a directory separator here, because
1950      SHELL is known to be absolute.  */
1951   new_name.append (shell);
1952
1953   /* Maybe it was cached by some earlier gdb.  */
1954   if (stat (new_name.c_str (), &sb) != 0 || !S_ISREG (sb.st_mode))
1955     {
1956       TRY
1957         {
1958           copy_shell_to_cache (shell, new_name);
1959         }
1960       CATCH (ex, RETURN_MASK_ERROR)
1961         {
1962           warning (_("This version of macOS has System Integrity Protection.\n\
1963 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1964 caching a copy of your shell.  However, this failed:\n\
1965 %s\n\
1966 If you correct the problem, gdb will automatically try again the next time\n\
1967 you \"run\".  To prevent these attempts, you can use:\n\
1968     set startup-with-shell off"),
1969                    ex.message);
1970           return false;
1971         }
1972       END_CATCH
1973
1974       printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1975 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1976 caching a copy of your shell.  The shell used by \"run\" is now:\n\
1977     %s\n"),
1978                        new_name.c_str ());
1979     }
1980
1981   /* We need to make sure that the new name has the correct lifetime.  */
1982   static std::string saved_shell = std::move (new_name);
1983   copied_shell = saved_shell.c_str ();
1984
1985 #endif /* SF_RESTRICTED */
1986
1987   return true;
1988 }
1989
1990 void
1991 darwin_nat_target::create_inferior (const char *exec_file,
1992                                     const std::string &allargs,
1993                                     char **env, int from_tty)
1994 {
1995   gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
1996
1997   if (startup_with_shell && may_have_sip ())
1998     {
1999       if (!maybe_cache_shell ())
2000         {
2001           warning (_("startup-with-shell is now temporarily disabled"));
2002           restore_startup_with_shell.emplace (&startup_with_shell, 0);
2003         }
2004     }
2005
2006   /* Do the hard work.  */
2007   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
2008                  darwin_ptrace_him, darwin_pre_ptrace, copied_shell,
2009                  darwin_execvp);
2010 }
2011 \f
2012
2013 /* Set things up such that the next call to darwin_wait will immediately
2014    return a fake stop event for inferior INF.
2015
2016    This assumes that the inferior's thread list has been initialized,
2017    as it will suspend the inferior's first thread.  */
2018
2019 static void
2020 darwin_setup_fake_stop_event (struct inferior *inf)
2021 {
2022   darwin_inferior *priv = get_darwin_inferior (inf);
2023   darwin_thread_t *thread;
2024   kern_return_t kret;
2025
2026   gdb_assert (darwin_inf_fake_stop == NULL);
2027   darwin_inf_fake_stop = inf;
2028
2029   /* When detecting a fake pending stop event, darwin_wait returns
2030      an event saying that the first thread is in a DARWIN_STOPPED
2031      state.  To make that accurate, we need to suspend that thread
2032      as well.  Otherwise, we'll try resuming it when resuming the
2033      inferior, and get a warning because the thread's suspend count
2034      is already zero, making the resume request useless.  */
2035   thread = priv->threads[0];
2036   kret = thread_suspend (thread->gdb_port);
2037   MACH_CHECK_ERROR (kret);
2038 }
2039
2040 /* Attach to process PID, then initialize for debugging it
2041    and wait for the trace-trap that results from attaching.  */
2042 void
2043 darwin_nat_target::attach (const char *args, int from_tty)
2044 {
2045   pid_t pid;
2046   struct inferior *inf;
2047
2048   pid = parse_pid_to_attach (args);
2049
2050   if (pid == getpid ())         /* Trying to masturbate?  */
2051     error (_("I refuse to debug myself!"));
2052
2053   if (from_tty)
2054     {
2055       char *exec_file = get_exec_file (0);
2056
2057       if (exec_file)
2058         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
2059                            target_pid_to_str (ptid_t (pid)));
2060       else
2061         printf_unfiltered (_("Attaching to %s\n"),
2062                            target_pid_to_str (ptid_t (pid)));
2063
2064       gdb_flush (gdb_stdout);
2065     }
2066
2067   if (pid == 0 || ::kill (pid, 0) < 0)
2068     error (_("Can't attach to process %d: %s (%d)"),
2069            pid, safe_strerror (errno), errno);
2070
2071   inferior_ptid = ptid_t (pid);
2072   inf = current_inferior ();
2073   inferior_appeared (inf, pid);
2074   inf->attach_flag = 1;
2075
2076   darwin_attach_pid (inf);
2077
2078   darwin_suspend_inferior (inf);
2079
2080   darwin_init_thread_list (inf);
2081
2082   darwin_inferior *priv = get_darwin_inferior (inf);
2083
2084   darwin_check_osabi (priv, inferior_ptid.tid ());
2085
2086   darwin_setup_fake_stop_event (inf);
2087
2088   priv->no_ptrace = 1;
2089 }
2090
2091 /* Take a program previously attached to and detaches it.
2092    The program resumes execution and will no longer stop
2093    on signals, etc.  We'd better not have left any breakpoints
2094    in the program or it'll die when it hits one.  For this
2095    to work, it may be necessary for the process to have been
2096    previously attached.  It *might* work if the program was
2097    started via fork.  */
2098
2099 void
2100 darwin_nat_target::detach (inferior *inf, int from_tty)
2101 {
2102   darwin_inferior *priv = get_darwin_inferior (inf);
2103   kern_return_t kret;
2104   int res;
2105
2106   /* Display message.  */
2107   target_announce_detach (from_tty);
2108
2109   /* If ptrace() is in use, stop the process.  */
2110   if (!priv->no_ptrace)
2111     darwin_stop_inferior (inf);
2112
2113   kret = darwin_restore_exception_ports (priv);
2114   MACH_CHECK_ERROR (kret);
2115
2116   if (!priv->no_ptrace)
2117     {
2118       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
2119       if (res != 0)
2120         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2121                            inf->pid, safe_strerror (errno), errno);
2122     }
2123
2124   darwin_reply_to_all_pending_messages (inf);
2125
2126   /* When using ptrace, we have just performed a PT_DETACH, which
2127      resumes the inferior.  On the other hand, when we are not using
2128      ptrace, we need to resume its execution ourselves.  */
2129   if (priv->no_ptrace)
2130     darwin_resume_inferior (inf);
2131
2132   mourn_inferior ();
2133 }
2134
2135 const char *
2136 darwin_nat_target::pid_to_str (ptid_t ptid)
2137 {
2138   static char buf[80];
2139   long tid = ptid.tid ();
2140
2141   if (tid != 0)
2142     {
2143       snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
2144                 tid, ptid.pid ());
2145       return buf;
2146     }
2147
2148   return normal_pid_to_str (ptid);
2149 }
2150
2151 bool
2152 darwin_nat_target::thread_alive (ptid_t ptid)
2153 {
2154   return true;
2155 }
2156
2157 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2158    copy it to RDADDR in gdb's address space.
2159    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2160    to ADDR in inferior task's address space.
2161    Return 0 on failure; number of bytes read / writen otherwise.  */
2162
2163 static int
2164 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2165                             gdb_byte *rdaddr, const gdb_byte *wraddr,
2166                             ULONGEST length)
2167 {
2168   kern_return_t kret;
2169   mach_vm_size_t res_length = 0;
2170
2171   inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2172                   task, core_addr_to_string (addr), pulongest (length));
2173
2174   /* First read.  */
2175   if (rdaddr != NULL)
2176     {
2177       mach_vm_size_t count;
2178
2179       /* According to target.h(to_xfer_partial), one and only one may be
2180          non-null.  */
2181       gdb_assert (wraddr == NULL);
2182
2183       kret = mach_vm_read_overwrite (task, addr, length,
2184                                      (mach_vm_address_t) rdaddr, &count);
2185       if (kret != KERN_SUCCESS)
2186         {
2187           inferior_debug
2188             (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2189              core_addr_to_string (addr), mach_error_string (kret));
2190           return 0;
2191         }
2192       return count;
2193     }
2194
2195   /* See above.  */
2196   gdb_assert (wraddr != NULL);
2197
2198   while (length != 0)
2199     {
2200       mach_vm_address_t offset = addr & (mach_page_size - 1);
2201       mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2202       mach_vm_size_t aligned_length =
2203         (mach_vm_size_t) PAGE_ROUND (offset + length);
2204       vm_region_submap_short_info_data_64_t info;
2205       mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2206       natural_t region_depth = 1000;
2207       mach_vm_address_t region_start = region_address;
2208       mach_vm_size_t region_length;
2209       mach_vm_size_t write_length;
2210
2211       /* Read page protection.  */
2212       kret = mach_vm_region_recurse
2213         (task, &region_start, &region_length, &region_depth,
2214          (vm_region_recurse_info_t) &info, &count);
2215
2216       if (kret != KERN_SUCCESS)
2217         {
2218           inferior_debug (1, _("darwin_read_write_inferior: "
2219                                "mach_vm_region_recurse failed at %s: %s\n"),
2220                           core_addr_to_string (region_address),
2221                           mach_error_string (kret));
2222           return res_length;
2223         }
2224
2225       inferior_debug
2226         (9, _("darwin_read_write_inferior: "
2227               "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2228          core_addr_to_string (region_address),
2229          core_addr_to_string (region_start),
2230          core_addr_to_string (region_length));
2231
2232       /* Check for holes in memory.  */
2233       if (region_start > region_address)
2234         {
2235           warning (_("No memory at %s (vs %s+0x%x).  Nothing written"),
2236                    core_addr_to_string (region_address),
2237                    core_addr_to_string (region_start),
2238                    (unsigned)region_length);
2239           return res_length;
2240         }
2241
2242       /* Adjust the length.  */
2243       region_length -= (region_address - region_start);
2244       if (region_length > aligned_length)
2245         region_length = aligned_length;
2246
2247       /* Make the pages RW.  */
2248       if (!(info.protection & VM_PROT_WRITE))
2249         {
2250           vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2251
2252           kret = mach_vm_protect (task, region_address, region_length,
2253                                   FALSE, prot);
2254           if (kret != KERN_SUCCESS)
2255             {
2256               prot |= VM_PROT_COPY;
2257               kret = mach_vm_protect (task, region_address, region_length,
2258                                       FALSE, prot);
2259             }
2260           if (kret != KERN_SUCCESS)
2261             {
2262               warning (_("darwin_read_write_inferior: "
2263                          "mach_vm_protect failed at %s "
2264                          "(len=0x%lx, prot=0x%x): %s"),
2265                        core_addr_to_string (region_address),
2266                        (unsigned long) region_length, (unsigned) prot,
2267                        mach_error_string (kret));
2268               return res_length;
2269             }
2270         }
2271
2272       if (offset + length > region_length)
2273         write_length = region_length - offset;
2274       else
2275         write_length = length;
2276
2277       /* Write.  */
2278       kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2279       if (kret != KERN_SUCCESS)
2280         {
2281           warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2282                    mach_error_string (kret));
2283           return res_length;
2284         }
2285
2286       /* Restore page rights.  */
2287       if (!(info.protection & VM_PROT_WRITE))
2288         {
2289           kret = mach_vm_protect (task, region_address, region_length,
2290                                   FALSE, info.protection);
2291           if (kret != KERN_SUCCESS)
2292             {
2293               warning (_("darwin_read_write_inferior: "
2294                          "mach_vm_protect restore failed at %s "
2295                          "(len=0x%lx): %s"),
2296                        core_addr_to_string (region_address),
2297                        (unsigned long) region_length,
2298                        mach_error_string (kret));
2299             }
2300         }
2301
2302       addr += write_length;
2303       wraddr += write_length;
2304       res_length += write_length;
2305       length -= write_length;
2306     }
2307
2308   return res_length;
2309 }
2310
2311 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2312    to RDADDR (in big endian).
2313    Return 0 on failure; number of bytes read / written otherwise.  */
2314
2315 #ifdef TASK_DYLD_INFO_COUNT
2316 /* This is not available in Darwin 9.  */
2317 static enum target_xfer_status
2318 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2319                        ULONGEST length, ULONGEST *xfered_len)
2320 {
2321   struct task_dyld_info task_dyld_info;
2322   mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2323   kern_return_t kret;
2324
2325   if (addr != 0 || length > sizeof (mach_vm_address_t))
2326     return TARGET_XFER_EOF;
2327
2328   kret = task_info (task, TASK_DYLD_INFO,
2329                     (task_info_t) &task_dyld_info, &count);
2330   MACH_CHECK_ERROR (kret);
2331   if (kret != KERN_SUCCESS)
2332     return TARGET_XFER_E_IO;
2333
2334   store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2335                           task_dyld_info.all_image_info_addr);
2336   *xfered_len = (ULONGEST) length;
2337   return TARGET_XFER_OK;
2338 }
2339 #endif
2340
2341 \f
2342
2343 enum target_xfer_status
2344 darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
2345                                  gdb_byte *readbuf, const gdb_byte *writebuf,
2346                                  ULONGEST offset, ULONGEST len,
2347                                  ULONGEST *xfered_len)
2348 {
2349   struct inferior *inf = current_inferior ();
2350   darwin_inferior *priv = get_darwin_inferior (inf);
2351
2352   inferior_debug
2353     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2354      core_addr_to_string (offset), pulongest (len),
2355      host_address_to_string (readbuf), host_address_to_string (writebuf),
2356      inf->pid);
2357
2358   switch (object)
2359     {
2360     case TARGET_OBJECT_MEMORY:
2361       {
2362         int l = darwin_read_write_inferior (priv->task, offset,
2363                                             readbuf, writebuf, len);
2364
2365         if (l == 0)
2366           return TARGET_XFER_EOF;
2367         else
2368           {
2369             gdb_assert (l > 0);
2370             *xfered_len = (ULONGEST) l;
2371             return TARGET_XFER_OK;
2372           }
2373       }
2374 #ifdef TASK_DYLD_INFO_COUNT
2375     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2376       if (writebuf != NULL || readbuf == NULL)
2377         {
2378           /* Support only read.  */
2379           return TARGET_XFER_E_IO;
2380         }
2381       return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2382                                     xfered_len);
2383 #endif
2384     default:
2385       return TARGET_XFER_E_IO;
2386     }
2387
2388 }
2389
2390 static void
2391 set_enable_mach_exceptions (const char *args, int from_tty,
2392                             struct cmd_list_element *c)
2393 {
2394   if (inferior_ptid != null_ptid)
2395     {
2396       struct inferior *inf = current_inferior ();
2397       darwin_inferior *priv = get_darwin_inferior (inf);
2398       exception_mask_t mask;
2399       kern_return_t kret;
2400
2401       if (enable_mach_exceptions)
2402         mask = EXC_MASK_ALL;
2403       else
2404         {
2405           darwin_restore_exception_ports (priv);
2406           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2407         }
2408       kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2409                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2410       MACH_CHECK_ERROR (kret);
2411     }
2412 }
2413
2414 char *
2415 darwin_nat_target::pid_to_exec_file (int pid)
2416 {
2417   static char path[PATH_MAX];
2418   int res;
2419
2420   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2421   if (res >= 0)
2422     return path;
2423   else
2424     return NULL;
2425 }
2426
2427 ptid_t
2428 darwin_nat_target::get_ada_task_ptid (long lwp, long thread)
2429 {
2430   struct inferior *inf = current_inferior ();
2431   darwin_inferior *priv = get_darwin_inferior (inf);
2432   kern_return_t kret;
2433   mach_port_name_array_t names;
2434   mach_msg_type_number_t names_count;
2435   mach_port_type_array_t types;
2436   mach_msg_type_number_t types_count;
2437   long res = 0;
2438
2439   /* First linear search.  */
2440   for (darwin_thread_t *t : priv->threads)
2441     {
2442       if (t->inf_port == lwp)
2443         return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
2444     }
2445
2446   /* Maybe the port was never extract.  Do it now.  */
2447
2448   /* First get inferior port names.  */
2449   kret = mach_port_names (priv->task, &names, &names_count, &types,
2450                           &types_count);
2451   MACH_CHECK_ERROR (kret);
2452   if (kret != KERN_SUCCESS)
2453     return null_ptid;
2454
2455   /* For each name, copy the right in the gdb space and then compare with
2456      our view of the inferior threads.  We don't forget to deallocate the
2457      right.  */
2458   for (int i = 0; i < names_count; i++)
2459     {
2460       mach_port_t local_name;
2461       mach_msg_type_name_t local_type;
2462
2463       /* We just need to know the corresponding name in gdb name space.
2464          So extract and deallocate the right.  */
2465       kret = mach_port_extract_right (priv->task, names[i],
2466                                       MACH_MSG_TYPE_COPY_SEND,
2467                                       &local_name, &local_type);
2468       if (kret != KERN_SUCCESS)
2469         continue;
2470       mach_port_deallocate (gdb_task, local_name);
2471
2472       for (darwin_thread_t *t : priv->threads)
2473         {
2474           if (t->gdb_port == local_name)
2475             {
2476               t->inf_port = names[i];
2477               if (names[i] == lwp)
2478                 res = t->gdb_port;
2479             }
2480         }
2481     }
2482
2483   vm_deallocate (gdb_task, (vm_address_t) names,
2484                  names_count * sizeof (mach_port_t));
2485
2486   if (res)
2487     return ptid_t (inferior_ptid.pid (), 0, res);
2488   else
2489     return null_ptid;
2490 }
2491
2492 bool
2493 darwin_nat_target::supports_multi_process ()
2494 {
2495   return true;
2496 }
2497
2498 void
2499 _initialize_darwin_nat ()
2500 {
2501   kern_return_t kret;
2502
2503   gdb_task = mach_task_self ();
2504   darwin_host_self = mach_host_self ();
2505
2506   /* Read page size.  */
2507   kret = host_page_size (darwin_host_self, &mach_page_size);
2508   if (kret != KERN_SUCCESS)
2509     {
2510       mach_page_size = 0x1000;
2511       MACH_CHECK_ERROR (kret);
2512     }
2513
2514   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2515                   (unsigned long) mach_task_self (), getpid ());
2516
2517   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2518                              &darwin_debug_flag, _("\
2519 Set if printing inferior communication debugging statements."), _("\
2520 Show if printing inferior communication debugging statements."), NULL,
2521                              NULL, NULL,
2522                              &setdebuglist, &showdebuglist);
2523
2524   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2525                            &enable_mach_exceptions, _("\
2526 Set if mach exceptions are caught."), _("\
2527 Show if mach exceptions are caught."), _("\
2528 When this mode is on, all low level exceptions are reported before being\n\
2529 reported by the kernel."),
2530                            &set_enable_mach_exceptions, NULL,
2531                            &setlist, &showlist);
2532 }