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 #include "gdbarch.h"
  41
  42 #include <copyfile.h>
  43 #include <sys/ptrace.h>
  44 #include <sys/signal.h>
  45 #include <setjmp.h>
  46 #include <sys/types.h>
  47 #include <unistd.h>
  48 #include <signal.h>
  49 #include <ctype.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/proc.h>
  52 #include <libproc.h>
  53 #include <sys/syscall.h>
  54 #include <spawn.h>
  55
  56 #include <mach/mach_error.h>
  57 #include <mach/mach_vm.h>
  58 #include <mach/mach_init.h>
  59 #include <mach/vm_map.h>
  60 #include <mach/task.h>
  61 #include <mach/mach_port.h>
  62 #include <mach/thread_act.h>
  63 #include <mach/port.h>
  64
  65 #include "darwin-nat.h"
  66 #include "filenames.h"
  67 #include "gdbsupport/filestuff.h"
  68 #include "gdbsupport/gdb_unlinker.h"
  69 #include "gdbsupport/pathstuff.h"
  70 #include "gdbsupport/scoped_fd.h"
  71 #include "nat/fork-inferior.h"
  72
  73 /* Quick overview.
  74    Darwin kernel is Mach + BSD derived kernel.  Note that they share the
  75    same memory space and are linked together (ie there is no micro-kernel).
  76
  77    Although ptrace(2) is available on Darwin, it is not complete.  We have
  78    to use Mach calls to read and write memory and to modify registers.  We
  79    also use Mach to get inferior faults.  As we cannot use select(2) or
  80    signals with Mach port (the Mach communication channel), signals are
  81    reported to gdb as an exception.  Furthermore we detect death of the
  82    inferior through a Mach notification message.  This way we only wait
  83    on Mach ports.
  84
  85    Some Mach documentation is available for Apple xnu source package or
  86    from the web.  */
  87
  88
  89 #define PTRACE(CMD, PID, ADDR, SIG) \
  90  darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
  91
  92 static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
  93
  94 static void darwin_ptrace_me (void);
  95
  96 static void darwin_ptrace_him (int pid);
  97
  98 static void darwin_encode_reply (mig_reply_error_t *reply,
  99                                  mach_msg_header_t *hdr, integer_t code);
 100
 101 static void darwin_setup_request_notification (struct inferior *inf);
 102 static void darwin_deallocate_exception_ports (darwin_inferior *inf);
 103 static void darwin_setup_exceptions (struct inferior *inf);
 104 static void darwin_deallocate_threads (struct inferior *inf);
 105
 106 /* Task identifier of gdb.  */
 107 static task_t gdb_task;
 108
 109 /* A copy of mach_host_self ().  */
 110 mach_port_t darwin_host_self;
 111
 112 /* Exception port.  */
 113 mach_port_t darwin_ex_port;
 114
 115 /* Port set, to wait for answer on all ports.  */
 116 mach_port_t darwin_port_set;
 117
 118 /* Page size.  */
 119 static vm_size_t mach_page_size;
 120
 121 /* If Set, catch all mach exceptions (before they are converted to signals
 122    by the kernel).  */
 123 static int enable_mach_exceptions;
 124
 125 /* Inferior that should report a fake stop event.  */
 126 static struct inferior *darwin_inf_fake_stop;
 127
 128 /* If non-NULL, the shell we actually invoke.  See maybe_cache_shell
 129    for details.  */
 130 static const char *copied_shell;
 131
 132 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
 133 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
 134
 135 /* This controls output of inferior debugging.  */
 136 static unsigned int darwin_debug_flag = 0;
 137
 138 /* Create a __TEXT __info_plist section in the executable so that gdb could
 139    be signed.  This is required to get an authorization for task_for_pid.
 140
 141    Once gdb is built, you must codesign it with any system-trusted signing
 142    authority.  See taskgated(8) for details.  */
 143 static const unsigned char info_plist[]
 144 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
 145   "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 146   "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
 147   " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
 148   "<plist version=\"1.0\">\n"
 149   "<dict>\n"
 150   "  <key>CFBundleIdentifier</key>\n"
 151   "  <string>org.gnu.gdb</string>\n"
 152   "  <key>CFBundleName</key>\n"
 153   "  <string>gdb</string>\n"
 154   "  <key>CFBundleVersion</key>\n"
 155   "  <string>1.0</string>\n"
 156   "  <key>SecTaskAccess</key>\n"
 157   "  <array>\n"
 158   "    <string>allowed</string>\n"
 159   "    <string>debug</string>\n"
 160   "  </array>\n"
 161   "</dict>\n"
 162   "</plist>\n";
 163
 164 static void inferior_debug (int level, const char *fmt, ...)
 165   ATTRIBUTE_PRINTF (2, 3);
 166
 167 static void
 168 inferior_debug (int level, const char *fmt, ...)
 169 {
 170   va_list ap;
 171
 172   if (darwin_debug_flag < level)
 173     return;
 174
 175   va_start (ap, fmt);
 176   printf_unfiltered (_("[%d inferior]: "), getpid ());
 177   vprintf_unfiltered (fmt, ap);
 178   va_end (ap);
 179 }
 180
 181 void
 182 mach_check_error (kern_return_t ret, const char *file,
 183                   unsigned int line, const char *func)
 184 {
 185   if (ret == KERN_SUCCESS)
 186     return;
 187   if (func == NULL)
 188     func = _("[UNKNOWN]");
 189
 190   warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
 191            file, line, func, mach_error_string (ret), (unsigned long) ret);
 192 }
 193
 194 static const char *
 195 unparse_exception_type (unsigned int i)
 196 {
 197   static char unknown_exception_buf[32];
 198
 199   switch (i)
 200     {
 201     case EXC_BAD_ACCESS:
 202       return "EXC_BAD_ACCESS";
 203     case EXC_BAD_INSTRUCTION:
 204       return "EXC_BAD_INSTRUCTION";
 205     case EXC_ARITHMETIC:
 206       return "EXC_ARITHMETIC";
 207     case EXC_EMULATION:
 208       return "EXC_EMULATION";
 209     case EXC_SOFTWARE:
 210       return "EXC_SOFTWARE";
 211     case EXC_BREAKPOINT:
 212       return "EXC_BREAKPOINT";
 213     case EXC_SYSCALL:
 214       return "EXC_SYSCALL";
 215     case EXC_MACH_SYSCALL:
 216       return "EXC_MACH_SYSCALL";
 217     case EXC_RPC_ALERT:
 218       return "EXC_RPC_ALERT";
 219     case EXC_CRASH:
 220       return "EXC_CRASH";
 221     default:
 222       snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
 223       return unknown_exception_buf;
 224     }
 225 }
 226
 227 /* Set errno to zero, and then call ptrace with the given arguments.
 228    If inferior debugging traces are on, then also print a debug
 229    trace.
 230
 231    The returned value is the same as the value returned by ptrace,
 232    except in the case where that value is -1 but errno is zero.
 233    This case is documented to be a non-error situation, so we
 234    return zero in that case. */
 235
 236 static int
 237 darwin_ptrace (const char *name,
 238                int request, int pid, caddr_t arg3, int arg4)
 239 {
 240   int ret;
 241
 242   errno = 0;
 243   ret = ptrace (request, pid, arg3, arg4);
 244   if (ret == -1 && errno == 0)
 245     ret = 0;
 246
 247   inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
 248                   name, pid, (unsigned long) arg3, arg4, ret,
 249                   (ret != 0) ? safe_strerror (errno) : _("no error"));
 250   return ret;
 251 }
 252
 253 static int
 254 cmp_thread_t (const void *l, const void *r)
 255 {
 256   thread_t tl = *(const thread_t *)l;
 257   thread_t tr = *(const thread_t *)r;
 258   return (int)(tl - tr);
 259 }
 260
 261 static void
 262 darwin_check_new_threads (struct inferior *inf)
 263 {
 264   kern_return_t kret;
 265   thread_array_t thread_list;
 266   unsigned int new_nbr;
 267   unsigned int old_nbr;
 268   unsigned int new_ix, old_ix;
 269   darwin_inferior *darwin_inf = get_darwin_inferior (inf);
 270   std::vector<darwin_thread_t *> new_thread_vec;
 271
 272   if (darwin_inf == nullptr)
 273     return;
 274
 275   /* Get list of threads.  */
 276   kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
 277   MACH_CHECK_ERROR (kret);
 278   if (kret != KERN_SUCCESS)
 279     return;
 280
 281   /* Sort the list.  */
 282   if (new_nbr > 1)
 283     qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
 284
 285   old_nbr = darwin_inf->threads.size ();
 286
 287   /* Quick check for no changes.  */
 288   if (old_nbr == new_nbr)
 289     {
 290       size_t i;
 291
 292       for (i = 0; i < new_nbr; i++)
 293         if (thread_list[i] != darwin_inf->threads[i]->gdb_port)
 294           break;
 295       if (i == new_nbr)
 296         {
 297           /* Deallocate ports.  */
 298           for (i = 0; i < new_nbr; i++)
 299             {
 300               kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
 301               MACH_CHECK_ERROR (kret);
 302             }
 303
 304           /* Deallocate the buffer.  */
 305           kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 306                                 new_nbr * sizeof (int));
 307           MACH_CHECK_ERROR (kret);
 308
 309           return;
 310         }
 311     }
 312
 313   /* Full handling: detect new threads, remove dead threads.  */
 314
 315   new_thread_vec.reserve (new_nbr);
 316
 317   for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
 318     {
 319       thread_t new_id = (new_ix < new_nbr) ? thread_list[new_ix] : THREAD_NULL;
 320       darwin_thread_t *old
 321         = (old_ix < old_nbr) ? darwin_inf->threads[old_ix] : NULL;
 322       thread_t old_id = old != NULL ? old->gdb_port : THREAD_NULL;
 323
 324       inferior_debug
 325         (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
 326          new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
 327
 328       if (old_id == new_id)
 329         {
 330           /* Thread still exist.  */
 331           new_thread_vec.push_back (old);
 332           new_ix++;
 333           old_ix++;
 334
 335           /* Deallocate the port.  */
 336           kret = mach_port_deallocate (gdb_task, new_id);
 337           MACH_CHECK_ERROR (kret);
 338
 339           continue;
 340         }
 341       if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
 342         {
 343           /* Ignore dead ports.
 344              In some weird cases, we might get dead ports.  They should
 345              correspond to dead thread so they could safely be ignored.  */
 346           new_ix++;
 347           continue;
 348         }
 349       if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
 350         {
 351           /* A thread was created.  */
 352           darwin_thread_info *pti = new darwin_thread_info;
 353
 354           pti->gdb_port = new_id;
 355           pti->msg_state = DARWIN_RUNNING;
 356
 357           /* Add the new thread.  */
 358           add_thread_with_info (ptid_t (inf->pid, 0, new_id), pti);
 359           new_thread_vec.push_back (pti);
 360           new_ix++;
 361           continue;
 362         }
 363       if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
 364         {
 365           /* A thread was removed.  */
 366           struct thread_info *thr
 367             = find_thread_ptid (ptid_t (inf->pid, 0, old_id));
 368           delete_thread (thr);
 369           kret = mach_port_deallocate (gdb_task, old_id);
 370           MACH_CHECK_ERROR (kret);
 371           old_ix++;
 372           continue;
 373         }
 374       gdb_assert_not_reached ("unexpected thread case");
 375     }
 376
 377   darwin_inf->threads = std::move (new_thread_vec);
 378
 379   /* Deallocate the buffer.  */
 380   kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 381                         new_nbr * sizeof (int));
 382   MACH_CHECK_ERROR (kret);
 383 }
 384
 385 static int
 386 find_inferior_task_it (struct inferior *inf, void *port_ptr)
 387 {
 388   darwin_inferior *priv = get_darwin_inferior (inf);
 389
 390   return priv != nullptr && priv->task == *(task_t *)port_ptr;
 391 }
 392
 393 static int
 394 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
 395 {
 396   return inf->pid == *(int *)pid_ptr;
 397 }
 398
 399 /* Return an inferior by task port.  */
 400 static struct inferior *
 401 darwin_find_inferior_by_task (task_t port)
 402 {
 403   return iterate_over_inferiors (&find_inferior_task_it, &port);
 404 }
 405
 406 /* Return an inferior by pid port.  */
 407 static struct inferior *
 408 darwin_find_inferior_by_pid (int pid)
 409 {
 410   return iterate_over_inferiors (&find_inferior_pid_it, &pid);
 411 }
 412
 413 /* Return a thread by port.  */
 414 static darwin_thread_t *
 415 darwin_find_thread (struct inferior *inf, thread_t thread)
 416 {
 417   darwin_inferior *priv = get_darwin_inferior (inf);
 418
 419   if (priv != nullptr)
 420     for (darwin_thread_t *t : priv->threads)
 421       {
 422         if (t->gdb_port == thread)
 423           return t;
 424       }
 425
 426   return NULL;
 427 }
 428
 429 /* Suspend (ie stop) an inferior at Mach level.  */
 430
 431 static void
 432 darwin_suspend_inferior (struct inferior *inf)
 433 {
 434   darwin_inferior *priv = get_darwin_inferior (inf);
 435
 436   if (priv != nullptr && !priv->suspended)
 437     {
 438       kern_return_t kret;
 439
 440       kret = task_suspend (priv->task);
 441       MACH_CHECK_ERROR (kret);
 442
 443       priv->suspended = 1;
 444     }
 445 }
 446
 447 /* Resume an inferior at Mach level.  */
 448
 449 static void
 450 darwin_resume_inferior (struct inferior *inf)
 451 {
 452   darwin_inferior *priv = get_darwin_inferior (inf);
 453
 454   if (priv != nullptr && priv->suspended)
 455     {
 456       kern_return_t kret;
 457
 458       kret = task_resume (priv->task);
 459       MACH_CHECK_ERROR (kret);
 460
 461       priv->suspended = 0;
 462     }
 463 }
 464
 465 /* Iterator functions.  */
 466
 467 static int
 468 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
 469 {
 470   darwin_suspend_inferior (inf);
 471   darwin_check_new_threads (inf);
 472   return 0;
 473 }
 474
 475 static int
 476 darwin_resume_inferior_it (struct inferior *inf, void *arg)
 477 {
 478   darwin_resume_inferior (inf);
 479   return 0;
 480 }
 481
 482 static void
 483 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
 484 {
 485   printf_unfiltered (_("message header:\n"));
 486   printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
 487   printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
 488   printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
 489   printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
 490   printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
 491   printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
 492
 493   if (disp_body)
 494     {
 495       const unsigned char *data;
 496       const unsigned int *ldata;
 497       int size;
 498       int i;
 499
 500       data = (unsigned char *)(hdr + 1);
 501       size = hdr->msgh_size - sizeof (mach_msg_header_t);
 502
 503       if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
 504         {
 505           mach_msg_body_t *bod = (mach_msg_body_t*)data;
 506           mach_msg_port_descriptor_t *desc =
 507             (mach_msg_port_descriptor_t *)(bod + 1);
 508           int k;
 509           NDR_record_t *ndr;
 510           printf_unfiltered (_("body: descriptor_count=%u\n"),
 511                              bod->msgh_descriptor_count);
 512           data += sizeof (mach_msg_body_t);
 513           size -= sizeof (mach_msg_body_t);
 514           for (k = 0; k < bod->msgh_descriptor_count; k++)
 515             switch (desc[k].type)
 516               {
 517               case MACH_MSG_PORT_DESCRIPTOR:
 518                 printf_unfiltered
 519                   (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
 520                    k, desc[k].type, desc[k].name, desc[k].disposition);
 521                 break;
 522               default:
 523                 printf_unfiltered (_(" descr %d: type=%u\n"),
 524                                    k, desc[k].type);
 525                 break;
 526               }
 527           data += bod->msgh_descriptor_count
 528             * sizeof (mach_msg_port_descriptor_t);
 529           size -= bod->msgh_descriptor_count
 530             * sizeof (mach_msg_port_descriptor_t);
 531           ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
 532           printf_unfiltered
 533             (_("NDR: mig=%02x if=%02x encod=%02x "
 534                "int=%02x char=%02x float=%02x\n"),
 535              ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
 536              ndr->int_rep, ndr->char_rep, ndr->float_rep);
 537           data += sizeof (NDR_record_t);
 538           size -= sizeof (NDR_record_t);
 539         }
 540
 541       printf_unfiltered (_("  data:"));
 542       ldata = (const unsigned int *)data;
 543       for (i = 0; i < size / sizeof (unsigned int); i++)
 544         printf_unfiltered (" %08x", ldata[i]);
 545       printf_unfiltered (_("\n"));
 546     }
 547 }
 548
 549 /* Adjust inferior data when a new task was created.  */
 550
 551 static struct inferior *
 552 darwin_find_new_inferior (task_t task_port, thread_t thread_port)
 553 {
 554   int task_pid;
 555   struct inferior *inf;
 556   kern_return_t kret;
 557   mach_port_t prev;
 558
 559   /* Find the corresponding pid.  */
 560   kret = pid_for_task (task_port, &task_pid);
 561   if (kret != KERN_SUCCESS)
 562     {
 563       MACH_CHECK_ERROR (kret);
 564       return NULL;
 565     }
 566
 567   /* Find the inferior for this pid.  */
 568   inf = darwin_find_inferior_by_pid (task_pid);
 569   if (inf == NULL)
 570     return NULL;
 571
 572   darwin_inferior *priv = get_darwin_inferior (inf);
 573
 574   /* Deallocate saved exception ports.  */
 575   darwin_deallocate_exception_ports (priv);
 576
 577   /* No need to remove dead_name notification, but still...  */
 578   kret = mach_port_request_notification (gdb_task, priv->task,
 579                                          MACH_NOTIFY_DEAD_NAME, 0,
 580                                          MACH_PORT_NULL,
 581                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
 582                                          &prev);
 583   if (kret != KERN_INVALID_ARGUMENT)
 584     MACH_CHECK_ERROR (kret);
 585
 586   /* Replace old task port.  */
 587   kret = mach_port_deallocate (gdb_task, priv->task);
 588   MACH_CHECK_ERROR (kret);
 589   priv->task = task_port;
 590
 591   darwin_setup_request_notification (inf);
 592   darwin_setup_exceptions (inf);
 593
 594   return inf;
 595 }
 596
 597 /* Check data representation.  */
 598
 599 static int
 600 darwin_check_message_ndr (NDR_record_t *ndr)
 601 {
 602   if (ndr->mig_vers != NDR_PROTOCOL_2_0
 603       || ndr->if_vers != NDR_PROTOCOL_2_0
 604       || ndr->mig_encoding != NDR_record.mig_encoding
 605       || ndr->int_rep != NDR_record.int_rep
 606       || ndr->char_rep != NDR_record.char_rep
 607       || ndr->float_rep != NDR_record.float_rep)
 608     return -1;
 609   return 0;
 610 }
 611
 612 /* Decode an exception message.  */
 613
 614 static int
 615 darwin_decode_exception_message (mach_msg_header_t *hdr,
 616                                  struct inferior **pinf,
 617                                  darwin_thread_t **pthread)
 618 {
 619   mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
 620   mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
 621   NDR_record_t *ndr;
 622   integer_t *data;
 623   struct inferior *inf;
 624   darwin_thread_t *thread;
 625   task_t task_port;
 626   thread_t thread_port;
 627   kern_return_t kret;
 628   int i;
 629
 630   /* Check message destination.  */
 631   if (hdr->msgh_local_port != darwin_ex_port)
 632     return -1;
 633
 634   /* Check message header.  */
 635   if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
 636     return -1;
 637
 638   /* Check descriptors.  */
 639   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
 640                         + sizeof (*ndr) + 2 * sizeof (integer_t))
 641       || bod->msgh_descriptor_count != 2
 642       || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
 643       || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
 644       || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
 645       || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
 646     return -1;
 647
 648   /* Check data representation.  */
 649   ndr = (NDR_record_t *)(desc + 2);
 650   if (darwin_check_message_ndr (ndr) != 0)
 651     return -1;
 652
 653   /* Ok, the hard work.  */
 654   data = (integer_t *)(ndr + 1);
 655
 656   task_port = desc[1].name;
 657   thread_port = desc[0].name;
 658
 659   /* Find process by port.  */
 660   inf = darwin_find_inferior_by_task (task_port);
 661   *pinf = inf;
 662
 663   if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
 664       && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
 665     {
 666       /* Not a known inferior, but a sigtrap.  This happens on darwin 16.1.0,
 667          as a new Mach task is created when a process exec.  */
 668       inf = darwin_find_new_inferior (task_port, thread_port);
 669       *pinf = inf;
 670
 671       if (inf == NULL)
 672         {
 673           /* Deallocate task_port, unless it was saved.  */
 674           kret = mach_port_deallocate (mach_task_self (), task_port);
 675           MACH_CHECK_ERROR (kret);
 676         }
 677     }
 678   else
 679     {
 680       /* We got new rights to the task, get rid of it.  Do not get rid of
 681          thread right, as we will need it to find the thread.  */
 682       kret = mach_port_deallocate (mach_task_self (), task_port);
 683       MACH_CHECK_ERROR (kret);
 684     }
 685
 686   if (inf == NULL)
 687     {
 688       /* Not a known inferior.  This could happen if the child fork, as
 689          the created process will inherit its exception port.
 690          FIXME: should the exception port be restored ?  */
 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_pid;
1129               int wstatus;
1130
1131               res_pid = wait4 (inf->pid, &wstatus, 0, NULL);
1132               if (res_pid < 0 || res_pid != inf->pid)
1133                 {
1134                   printf_unfiltered (_("wait4: res=%d: %s\n"),
1135                                      res_pid, 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_pid, 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       for (darwin_thread_t *thread : priv->threads)
1563         thread->signaled = 1;
1564
1565       darwin_resume_inferior (inf);
1566
1567       ptid = darwin_wait (inferior_ptid, &wstatus);
1568     }
1569   else if (errno != ESRCH)
1570     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1571              inf->pid, safe_strerror (errno));
1572
1573   target_mourn_inferior (inferior_ptid);
1574 }
1575
1576 static void
1577 darwin_setup_request_notification (struct inferior *inf)
1578 {
1579   darwin_inferior *priv = get_darwin_inferior (inf);
1580   kern_return_t kret;
1581   mach_port_t prev_not;
1582
1583   kret = mach_port_request_notification (gdb_task, priv->task,
1584                                          MACH_NOTIFY_DEAD_NAME, 0,
1585                                          priv->notify_port,
1586                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1587                                          &prev_not);
1588   if (kret != KERN_SUCCESS)
1589     error (_("Termination notification request failed, "
1590              "mach_port_request_notification\n"
1591              "returned: %d"),
1592            kret);
1593   if (prev_not != MACH_PORT_NULL)
1594     {
1595       /* This is unexpected, as there should not be any previously
1596          registered notification request.  But this is not a fatal
1597          issue, so just emit a warning.  */
1598       warning (_("\
1599 A task termination request was registered before the debugger registered\n\
1600 its own.  This is unexpected, but should otherwise not have any actual\n\
1601 impact on the debugging session."));
1602     }
1603 }
1604
1605 static void
1606 darwin_attach_pid (struct inferior *inf)
1607 {
1608   kern_return_t kret;
1609
1610   darwin_inferior *priv = new darwin_inferior;
1611   inf->priv.reset (priv);
1612
1613   try
1614     {
1615       kret = task_for_pid (gdb_task, inf->pid, &priv->task);
1616       if (kret != KERN_SUCCESS)
1617         {
1618           int status;
1619
1620           if (!inf->attach_flag)
1621             {
1622               kill (inf->pid, 9);
1623               waitpid (inf->pid, &status, 0);
1624             }
1625
1626           error
1627             (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1628                " (please check gdb is codesigned - see taskgated(8))"),
1629              inf->pid, mach_error_string (kret), (unsigned long) kret);
1630         }
1631
1632       inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1633                       priv->task, inf->pid);
1634
1635       if (darwin_ex_port == MACH_PORT_NULL)
1636         {
1637           /* Create a port to get exceptions.  */
1638           kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1639                                      &darwin_ex_port);
1640           if (kret != KERN_SUCCESS)
1641             error (_("Unable to create exception port, mach_port_allocate "
1642                      "returned: %d"),
1643                    kret);
1644
1645           kret = mach_port_insert_right (gdb_task, darwin_ex_port,
1646                                          darwin_ex_port,
1647                                          MACH_MSG_TYPE_MAKE_SEND);
1648           if (kret != KERN_SUCCESS)
1649             error (_("Unable to create exception port, mach_port_insert_right "
1650                      "returned: %d"),
1651                    kret);
1652
1653           /* Create a port set and put ex_port in it.  */
1654           kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1655                                      &darwin_port_set);
1656           if (kret != KERN_SUCCESS)
1657             error (_("Unable to create port set, mach_port_allocate "
1658                      "returned: %d"),
1659                    kret);
1660
1661           kret = mach_port_move_member (gdb_task, darwin_ex_port,
1662                                         darwin_port_set);
1663           if (kret != KERN_SUCCESS)
1664             error (_("Unable to move exception port into new port set, "
1665                      "mach_port_move_member\n"
1666                      "returned: %d"),
1667                    kret);
1668         }
1669
1670       /* Create a port to be notified when the child task terminates.  */
1671       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1672                                  &priv->notify_port);
1673       if (kret != KERN_SUCCESS)
1674         error (_("Unable to create notification port, mach_port_allocate "
1675                  "returned: %d"),
1676                kret);
1677
1678       kret = mach_port_move_member (gdb_task,
1679                                     priv->notify_port, darwin_port_set);
1680       if (kret != KERN_SUCCESS)
1681         error (_("Unable to move notification port into new port set, "
1682                  "mach_port_move_member\n"
1683                  "returned: %d"),
1684                kret);
1685
1686       darwin_setup_request_notification (inf);
1687
1688       darwin_setup_exceptions (inf);
1689     }
1690   catch (const gdb_exception &ex)
1691     {
1692       exit_inferior (inf);
1693       inferior_ptid = null_ptid;
1694
1695       throw;
1696     }
1697
1698   target_ops *darwin_ops = get_native_target ();
1699   if (!target_is_pushed (darwin_ops))
1700     push_target (darwin_ops);
1701 }
1702
1703 /* Get the thread_info object corresponding to this darwin_thread_info.  */
1704
1705 static struct thread_info *
1706 thread_info_from_private_thread_info (darwin_thread_info *pti)
1707 {
1708   for (struct thread_info *it : all_threads ())
1709     {
1710       darwin_thread_info *iter_pti = get_darwin_thread_info (it);
1711
1712       if (iter_pti->gdb_port == pti->gdb_port)
1713         return it;
1714     }
1715
1716   gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1717 }
1718
1719 static void
1720 darwin_init_thread_list (struct inferior *inf)
1721 {
1722   darwin_check_new_threads (inf);
1723
1724   darwin_inferior *priv = get_darwin_inferior (inf);
1725
1726   gdb_assert (!priv->threads.empty ());
1727
1728   darwin_thread_info *first_pti = priv->threads.front ();
1729   struct thread_info *first_thread
1730     = thread_info_from_private_thread_info (first_pti);
1731
1732   inferior_ptid = first_thread->ptid;
1733 }
1734
1735 /* The child must synchronize with gdb: gdb must set the exception port
1736    before the child call PTRACE_SIGEXC.  We use a pipe to achieve this.
1737    FIXME: is there a lighter way ?  */
1738 static int ptrace_fds[2];
1739
1740 static void
1741 darwin_ptrace_me (void)
1742 {
1743   int res;
1744   char c;
1745
1746   /* Close write end point.  */
1747   if (close (ptrace_fds[1]) < 0)
1748     trace_start_error_with_name ("close");
1749
1750   /* Wait until gdb is ready.  */
1751   res = read (ptrace_fds[0], &c, 1);
1752   if (res != 0)
1753     trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1754
1755   if (close (ptrace_fds[0]) < 0)
1756     trace_start_error_with_name ("close");
1757
1758   /* Get rid of privileges.  */
1759   if (setegid (getgid ()) < 0)
1760     trace_start_error_with_name ("setegid");
1761
1762   /* Set TRACEME.  */
1763   if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1764     trace_start_error_with_name ("PTRACE");
1765
1766   /* Redirect signals to exception port.  */
1767   if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1768     trace_start_error_with_name ("PTRACE");
1769 }
1770
1771 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).  */
1772 static void
1773 darwin_pre_ptrace (void)
1774 {
1775   if (pipe (ptrace_fds) != 0)
1776     {
1777       ptrace_fds[0] = -1;
1778       ptrace_fds[1] = -1;
1779       error (_("unable to create a pipe: %s"), safe_strerror (errno));
1780     }
1781
1782   mark_fd_no_cloexec (ptrace_fds[0]);
1783   mark_fd_no_cloexec (ptrace_fds[1]);
1784 }
1785
1786 static void
1787 darwin_ptrace_him (int pid)
1788 {
1789   struct inferior *inf = current_inferior ();
1790
1791   darwin_attach_pid (inf);
1792
1793   /* Let's the child run.  */
1794   close (ptrace_fds[0]);
1795   close (ptrace_fds[1]);
1796
1797   unmark_fd_no_cloexec (ptrace_fds[0]);
1798   unmark_fd_no_cloexec (ptrace_fds[1]);
1799
1800   darwin_init_thread_list (inf);
1801
1802   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1803 }
1804
1805 static void
1806 darwin_execvp (const char *file, char * const argv[], char * const env[])
1807 {
1808   posix_spawnattr_t attr;
1809   short ps_flags = 0;
1810   int res;
1811
1812   res = posix_spawnattr_init (&attr);
1813   if (res != 0)
1814     {
1815       fprintf_unfiltered
1816         (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1817       return;
1818     }
1819
1820   /* Do like execve: replace the image.  */
1821   ps_flags = POSIX_SPAWN_SETEXEC;
1822
1823   /* Disable ASLR.  The constant doesn't look to be available outside the
1824      kernel include files.  */
1825 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1826 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1827 #endif
1828   ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1829   res = posix_spawnattr_setflags (&attr, ps_flags);
1830   if (res != 0)
1831     {
1832       fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1833       return;
1834     }
1835
1836   posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1837 }
1838
1839 /* Read kernel version, and return TRUE if this host may have System
1840    Integrity Protection (Sierra or later).  */
1841
1842 static bool
1843 may_have_sip ()
1844 {
1845   char str[16];
1846   size_t sz = sizeof (str);
1847   int ret;
1848
1849   ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
1850   if (ret == 0 && sz < sizeof (str))
1851     {
1852       unsigned long ver = strtoul (str, NULL, 10);
1853       if (ver >= 16)
1854         return true;
1855     }
1856   return false;
1857 }
1858
1859 /* A helper for maybe_cache_shell.  This copies the shell to the
1860    cache.  It will throw an exception on any failure.  */
1861
1862 static void
1863 copy_shell_to_cache (const char *shell, const std::string &new_name)
1864 {
1865   scoped_fd from_fd (gdb_open_cloexec (shell, O_RDONLY, 0));
1866   if (from_fd.get () < 0)
1867     error (_("Could not open shell (%s) for reading: %s"),
1868            shell, safe_strerror (errno));
1869
1870   std::string new_dir = ldirname (new_name.c_str ());
1871   if (!mkdir_recursive (new_dir.c_str ()))
1872     error (_("Could not make cache directory \"%s\": %s"),
1873            new_dir.c_str (), safe_strerror (errno));
1874
1875   gdb::char_vector temp_name = make_temp_filename (new_name);
1876   scoped_fd to_fd (gdb_mkostemp_cloexec (&temp_name[0]));
1877   gdb::unlinker unlink_file_on_error (temp_name.data ());
1878
1879   if (to_fd.get () < 0)
1880     error (_("Could not open temporary file \"%s\" for writing: %s"),
1881            temp_name.data (), safe_strerror (errno));
1882
1883   if (fcopyfile (from_fd.get (), to_fd.get (), nullptr,
1884                  COPYFILE_STAT | COPYFILE_DATA) != 0)
1885     error (_("Could not copy shell to cache as \"%s\": %s"),
1886            temp_name.data (), safe_strerror (errno));
1887
1888   /* Be sure that the caching is atomic so that we don't get bad
1889      results from multiple copies of gdb running at the same time.  */
1890   if (rename (temp_name.data (), new_name.c_str ()) != 0)
1891     error (_("Could not rename shell cache file to \"%s\": %s"),
1892            new_name.c_str (), safe_strerror (errno));
1893
1894   unlink_file_on_error.keep ();
1895 }
1896
1897 /* If $SHELL is restricted, try to cache a copy.  Starting with El
1898    Capitan, macOS introduced System Integrity Protection.  Among other
1899    things, this prevents certain executables from being ptrace'd.  In
1900    particular, executables in /bin, like most shells, are affected.
1901    To work around this, while preserving command-line glob expansion
1902    and redirections, gdb will cache a copy of the shell.  Return true
1903    if all is well -- either the shell is not subject to SIP or it has
1904    been successfully cached.  Returns false if something failed.  */
1905
1906 static bool
1907 maybe_cache_shell ()
1908 {
1909   /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1910      given file is subject to SIP.  */
1911 #ifdef SF_RESTRICTED
1912
1913   /* If a check fails we want to revert -- maybe the user deleted the
1914      cache while gdb was running, or something like that.  */
1915   copied_shell = nullptr;
1916
1917   const char *shell = get_shell ();
1918   if (!IS_ABSOLUTE_PATH (shell))
1919     {
1920       warning (_("This version of macOS has System Integrity Protection.\n\
1921 Normally gdb would try to work around this by caching a copy of your shell,\n\
1922 but because your shell (%s) is not an absolute path, this is being skipped."),
1923                shell);
1924       return false;
1925     }
1926
1927   struct stat sb;
1928   if (stat (shell, &sb) < 0)
1929     {
1930       warning (_("This version of macOS has System Integrity Protection.\n\
1931 Normally gdb would try to work around this by caching a copy of your shell,\n\
1932 but because gdb could not stat your shell (%s), this is being skipped.\n\
1933 The error was: %s"),
1934                shell, safe_strerror (errno));
1935       return false;
1936     }
1937
1938   if ((sb.st_flags & SF_RESTRICTED) == 0)
1939     return true;
1940
1941   /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh.  */
1942   std::string new_name = get_standard_cache_dir ();
1943   /* There's no need to insert a directory separator here, because
1944      SHELL is known to be absolute.  */
1945   new_name.append (shell);
1946
1947   /* Maybe it was cached by some earlier gdb.  */
1948   if (stat (new_name.c_str (), &sb) != 0 || !S_ISREG (sb.st_mode))
1949     {
1950       try
1951         {
1952           copy_shell_to_cache (shell, new_name);
1953         }
1954       catch (const gdb_exception_error &ex)
1955         {
1956           warning (_("This version of macOS has System Integrity Protection.\n\
1957 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1958 caching a copy of your shell.  However, this failed:\n\
1959 %s\n\
1960 If you correct the problem, gdb will automatically try again the next time\n\
1961 you \"run\".  To prevent these attempts, you can use:\n\
1962     set startup-with-shell off"),
1963                    ex.what ());
1964           return false;
1965         }
1966
1967       printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1968 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1969 caching a copy of your shell.  The shell used by \"run\" is now:\n\
1970     %s\n"),
1971                        new_name.c_str ());
1972     }
1973
1974   /* We need to make sure that the new name has the correct lifetime.  */
1975   static std::string saved_shell = std::move (new_name);
1976   copied_shell = saved_shell.c_str ();
1977
1978 #endif /* SF_RESTRICTED */
1979
1980   return true;
1981 }
1982
1983 void
1984 darwin_nat_target::create_inferior (const char *exec_file,
1985                                     const std::string &allargs,
1986                                     char **env, int from_tty)
1987 {
1988   gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
1989
1990   if (startup_with_shell && may_have_sip ())
1991     {
1992       if (!maybe_cache_shell ())
1993         {
1994           warning (_("startup-with-shell is now temporarily disabled"));
1995           restore_startup_with_shell.emplace (&startup_with_shell, 0);
1996         }
1997     }
1998
1999   /* Do the hard work.  */
2000   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
2001                  darwin_ptrace_him, darwin_pre_ptrace, copied_shell,
2002                  darwin_execvp);
2003 }
2004 \f
2005
2006 /* Set things up such that the next call to darwin_wait will immediately
2007    return a fake stop event for inferior INF.
2008
2009    This assumes that the inferior's thread list has been initialized,
2010    as it will suspend the inferior's first thread.  */
2011
2012 static void
2013 darwin_setup_fake_stop_event (struct inferior *inf)
2014 {
2015   darwin_inferior *priv = get_darwin_inferior (inf);
2016   darwin_thread_t *thread;
2017   kern_return_t kret;
2018
2019   gdb_assert (darwin_inf_fake_stop == NULL);
2020   darwin_inf_fake_stop = inf;
2021
2022   /* When detecting a fake pending stop event, darwin_wait returns
2023      an event saying that the first thread is in a DARWIN_STOPPED
2024      state.  To make that accurate, we need to suspend that thread
2025      as well.  Otherwise, we'll try resuming it when resuming the
2026      inferior, and get a warning because the thread's suspend count
2027      is already zero, making the resume request useless.  */
2028   thread = priv->threads[0];
2029   kret = thread_suspend (thread->gdb_port);
2030   MACH_CHECK_ERROR (kret);
2031 }
2032
2033 /* Attach to process PID, then initialize for debugging it
2034    and wait for the trace-trap that results from attaching.  */
2035 void
2036 darwin_nat_target::attach (const char *args, int from_tty)
2037 {
2038   pid_t pid;
2039   struct inferior *inf;
2040
2041   pid = parse_pid_to_attach (args);
2042
2043   if (pid == getpid ())         /* Trying to masturbate?  */
2044     error (_("I refuse to debug myself!"));
2045
2046   if (from_tty)
2047     {
2048       char *exec_file = get_exec_file (0);
2049
2050       if (exec_file)
2051         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
2052                            target_pid_to_str (ptid_t (pid)).c_str ());
2053       else
2054         printf_unfiltered (_("Attaching to %s\n"),
2055                            target_pid_to_str (ptid_t (pid)).c_str ());
2056     }
2057
2058   if (pid == 0 || ::kill (pid, 0) < 0)
2059     error (_("Can't attach to process %d: %s (%d)"),
2060            pid, safe_strerror (errno), errno);
2061
2062   inferior_ptid = ptid_t (pid);
2063   inf = current_inferior ();
2064   inferior_appeared (inf, pid);
2065   inf->attach_flag = 1;
2066
2067   darwin_attach_pid (inf);
2068
2069   darwin_suspend_inferior (inf);
2070
2071   darwin_init_thread_list (inf);
2072
2073   darwin_inferior *priv = get_darwin_inferior (inf);
2074
2075   darwin_check_osabi (priv, inferior_ptid.tid ());
2076
2077   darwin_setup_fake_stop_event (inf);
2078
2079   priv->no_ptrace = 1;
2080 }
2081
2082 /* Take a program previously attached to and detaches it.
2083    The program resumes execution and will no longer stop
2084    on signals, etc.  We'd better not have left any breakpoints
2085    in the program or it'll die when it hits one.  For this
2086    to work, it may be necessary for the process to have been
2087    previously attached.  It *might* work if the program was
2088    started via fork.  */
2089
2090 void
2091 darwin_nat_target::detach (inferior *inf, int from_tty)
2092 {
2093   darwin_inferior *priv = get_darwin_inferior (inf);
2094   kern_return_t kret;
2095   int res;
2096
2097   /* Display message.  */
2098   target_announce_detach (from_tty);
2099
2100   /* If ptrace() is in use, stop the process.  */
2101   if (!priv->no_ptrace)
2102     darwin_stop_inferior (inf);
2103
2104   kret = darwin_restore_exception_ports (priv);
2105   MACH_CHECK_ERROR (kret);
2106
2107   if (!priv->no_ptrace)
2108     {
2109       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
2110       if (res != 0)
2111         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2112                            inf->pid, safe_strerror (errno), errno);
2113     }
2114
2115   darwin_reply_to_all_pending_messages (inf);
2116
2117   /* When using ptrace, we have just performed a PT_DETACH, which
2118      resumes the inferior.  On the other hand, when we are not using
2119      ptrace, we need to resume its execution ourselves.  */
2120   if (priv->no_ptrace)
2121     darwin_resume_inferior (inf);
2122
2123   mourn_inferior ();
2124 }
2125
2126 std::string
2127 darwin_nat_target::pid_to_str (ptid_t ptid)
2128 {
2129   long tid = ptid.tid ();
2130
2131   if (tid != 0)
2132     return string_printf (_("Thread 0x%lx of process %u"),
2133                           tid, ptid.pid ());
2134
2135   return normal_pid_to_str (ptid);
2136 }
2137
2138 bool
2139 darwin_nat_target::thread_alive (ptid_t ptid)
2140 {
2141   return true;
2142 }
2143
2144 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2145    copy it to RDADDR in gdb's address space.
2146    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2147    to ADDR in inferior task's address space.
2148    Return 0 on failure; number of bytes read / writen otherwise.  */
2149
2150 static int
2151 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2152                             gdb_byte *rdaddr, const gdb_byte *wraddr,
2153                             ULONGEST length)
2154 {
2155   kern_return_t kret;
2156   mach_vm_size_t res_length = 0;
2157
2158   inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2159                   task, core_addr_to_string (addr), pulongest (length));
2160
2161   /* First read.  */
2162   if (rdaddr != NULL)
2163     {
2164       mach_vm_size_t count;
2165
2166       /* According to target.h(to_xfer_partial), one and only one may be
2167          non-null.  */
2168       gdb_assert (wraddr == NULL);
2169
2170       kret = mach_vm_read_overwrite (task, addr, length,
2171                                      (mach_vm_address_t) rdaddr, &count);
2172       if (kret != KERN_SUCCESS)
2173         {
2174           inferior_debug
2175             (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2176              core_addr_to_string (addr), mach_error_string (kret));
2177           return 0;
2178         }
2179       return count;
2180     }
2181
2182   /* See above.  */
2183   gdb_assert (wraddr != NULL);
2184
2185   while (length != 0)
2186     {
2187       mach_vm_address_t offset = addr & (mach_page_size - 1);
2188       mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2189       mach_vm_size_t aligned_length =
2190         (mach_vm_size_t) PAGE_ROUND (offset + length);
2191       vm_region_submap_short_info_data_64_t info;
2192       mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2193       natural_t region_depth = 1000;
2194       mach_vm_address_t region_start = region_address;
2195       mach_vm_size_t region_length;
2196       mach_vm_size_t write_length;
2197
2198       /* Read page protection.  */
2199       kret = mach_vm_region_recurse
2200         (task, &region_start, &region_length, &region_depth,
2201          (vm_region_recurse_info_t) &info, &count);
2202
2203       if (kret != KERN_SUCCESS)
2204         {
2205           inferior_debug (1, _("darwin_read_write_inferior: "
2206                                "mach_vm_region_recurse failed at %s: %s\n"),
2207                           core_addr_to_string (region_address),
2208                           mach_error_string (kret));
2209           return res_length;
2210         }
2211
2212       inferior_debug
2213         (9, _("darwin_read_write_inferior: "
2214               "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2215          core_addr_to_string (region_address),
2216          core_addr_to_string (region_start),
2217          core_addr_to_string (region_length));
2218
2219       /* Check for holes in memory.  */
2220       if (region_start > region_address)
2221         {
2222           warning (_("No memory at %s (vs %s+0x%x).  Nothing written"),
2223                    core_addr_to_string (region_address),
2224                    core_addr_to_string (region_start),
2225                    (unsigned)region_length);
2226           return res_length;
2227         }
2228
2229       /* Adjust the length.  */
2230       region_length -= (region_address - region_start);
2231       if (region_length > aligned_length)
2232         region_length = aligned_length;
2233
2234       /* Make the pages RW.  */
2235       if (!(info.protection & VM_PROT_WRITE))
2236         {
2237           vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2238
2239           kret = mach_vm_protect (task, region_address, region_length,
2240                                   FALSE, prot);
2241           if (kret != KERN_SUCCESS)
2242             {
2243               prot |= VM_PROT_COPY;
2244               kret = mach_vm_protect (task, region_address, region_length,
2245                                       FALSE, prot);
2246             }
2247           if (kret != KERN_SUCCESS)
2248             {
2249               warning (_("darwin_read_write_inferior: "
2250                          "mach_vm_protect failed at %s "
2251                          "(len=0x%lx, prot=0x%x): %s"),
2252                        core_addr_to_string (region_address),
2253                        (unsigned long) region_length, (unsigned) prot,
2254                        mach_error_string (kret));
2255               return res_length;
2256             }
2257         }
2258
2259       if (offset + length > region_length)
2260         write_length = region_length - offset;
2261       else
2262         write_length = length;
2263
2264       /* Write.  */
2265       kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2266       if (kret != KERN_SUCCESS)
2267         {
2268           warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2269                    mach_error_string (kret));
2270           return res_length;
2271         }
2272
2273       /* Restore page rights.  */
2274       if (!(info.protection & VM_PROT_WRITE))
2275         {
2276           kret = mach_vm_protect (task, region_address, region_length,
2277                                   FALSE, info.protection);
2278           if (kret != KERN_SUCCESS)
2279             {
2280               warning (_("darwin_read_write_inferior: "
2281                          "mach_vm_protect restore failed at %s "
2282                          "(len=0x%lx): %s"),
2283                        core_addr_to_string (region_address),
2284                        (unsigned long) region_length,
2285                        mach_error_string (kret));
2286             }
2287         }
2288
2289       addr += write_length;
2290       wraddr += write_length;
2291       res_length += write_length;
2292       length -= write_length;
2293     }
2294
2295   return res_length;
2296 }
2297
2298 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2299    to RDADDR (in big endian).
2300    Return 0 on failure; number of bytes read / written otherwise.  */
2301
2302 #ifdef TASK_DYLD_INFO_COUNT
2303 /* This is not available in Darwin 9.  */
2304 static enum target_xfer_status
2305 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2306                        ULONGEST length, ULONGEST *xfered_len)
2307 {
2308   struct task_dyld_info task_dyld_info;
2309   mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2310   kern_return_t kret;
2311
2312   if (addr != 0 || length > sizeof (mach_vm_address_t))
2313     return TARGET_XFER_EOF;
2314
2315   kret = task_info (task, TASK_DYLD_INFO,
2316                     (task_info_t) &task_dyld_info, &count);
2317   MACH_CHECK_ERROR (kret);
2318   if (kret != KERN_SUCCESS)
2319     return TARGET_XFER_E_IO;
2320
2321   store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2322                           task_dyld_info.all_image_info_addr);
2323   *xfered_len = (ULONGEST) length;
2324   return TARGET_XFER_OK;
2325 }
2326 #endif
2327
2328 \f
2329
2330 enum target_xfer_status
2331 darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
2332                                  gdb_byte *readbuf, const gdb_byte *writebuf,
2333                                  ULONGEST offset, ULONGEST len,
2334                                  ULONGEST *xfered_len)
2335 {
2336   struct inferior *inf = current_inferior ();
2337   darwin_inferior *priv = get_darwin_inferior (inf);
2338
2339   inferior_debug
2340     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2341      core_addr_to_string (offset), pulongest (len),
2342      host_address_to_string (readbuf), host_address_to_string (writebuf),
2343      inf->pid);
2344
2345   switch (object)
2346     {
2347     case TARGET_OBJECT_MEMORY:
2348       {
2349         int l = darwin_read_write_inferior (priv->task, offset,
2350                                             readbuf, writebuf, len);
2351
2352         if (l == 0)
2353           return TARGET_XFER_EOF;
2354         else
2355           {
2356             gdb_assert (l > 0);
2357             *xfered_len = (ULONGEST) l;
2358             return TARGET_XFER_OK;
2359           }
2360       }
2361 #ifdef TASK_DYLD_INFO_COUNT
2362     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2363       if (writebuf != NULL || readbuf == NULL)
2364         {
2365           /* Support only read.  */
2366           return TARGET_XFER_E_IO;
2367         }
2368       return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2369                                     xfered_len);
2370 #endif
2371     default:
2372       return TARGET_XFER_E_IO;
2373     }
2374
2375 }
2376
2377 static void
2378 set_enable_mach_exceptions (const char *args, int from_tty,
2379                             struct cmd_list_element *c)
2380 {
2381   if (inferior_ptid != null_ptid)
2382     {
2383       struct inferior *inf = current_inferior ();
2384       darwin_inferior *priv = get_darwin_inferior (inf);
2385       exception_mask_t mask;
2386       kern_return_t kret;
2387
2388       if (enable_mach_exceptions)
2389         mask = EXC_MASK_ALL;
2390       else
2391         {
2392           darwin_restore_exception_ports (priv);
2393           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2394         }
2395       kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2396                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2397       MACH_CHECK_ERROR (kret);
2398     }
2399 }
2400
2401 char *
2402 darwin_nat_target::pid_to_exec_file (int pid)
2403 {
2404   static char path[PATH_MAX];
2405   int res;
2406
2407   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2408   if (res >= 0)
2409     return path;
2410   else
2411     return NULL;
2412 }
2413
2414 ptid_t
2415 darwin_nat_target::get_ada_task_ptid (long lwp, long thread)
2416 {
2417   struct inferior *inf = current_inferior ();
2418   darwin_inferior *priv = get_darwin_inferior (inf);
2419   kern_return_t kret;
2420   mach_port_name_array_t names;
2421   mach_msg_type_number_t names_count;
2422   mach_port_type_array_t types;
2423   mach_msg_type_number_t types_count;
2424   long res = 0;
2425
2426   /* First linear search.  */
2427   for (darwin_thread_t *t : priv->threads)
2428     {
2429       if (t->inf_port == lwp)
2430         return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
2431     }
2432
2433   /* Maybe the port was never extract.  Do it now.  */
2434
2435   /* First get inferior port names.  */
2436   kret = mach_port_names (priv->task, &names, &names_count, &types,
2437                           &types_count);
2438   MACH_CHECK_ERROR (kret);
2439   if (kret != KERN_SUCCESS)
2440     return null_ptid;
2441
2442   /* For each name, copy the right in the gdb space and then compare with
2443      our view of the inferior threads.  We don't forget to deallocate the
2444      right.  */
2445   for (int i = 0; i < names_count; i++)
2446     {
2447       mach_port_t local_name;
2448       mach_msg_type_name_t local_type;
2449
2450       /* We just need to know the corresponding name in gdb name space.
2451          So extract and deallocate the right.  */
2452       kret = mach_port_extract_right (priv->task, names[i],
2453                                       MACH_MSG_TYPE_COPY_SEND,
2454                                       &local_name, &local_type);
2455       if (kret != KERN_SUCCESS)
2456         continue;
2457       mach_port_deallocate (gdb_task, local_name);
2458
2459       for (darwin_thread_t *t : priv->threads)
2460         {
2461           if (t->gdb_port == local_name)
2462             {
2463               t->inf_port = names[i];
2464               if (names[i] == lwp)
2465                 res = t->gdb_port;
2466             }
2467         }
2468     }
2469
2470   vm_deallocate (gdb_task, (vm_address_t) names,
2471                  names_count * sizeof (mach_port_t));
2472
2473   if (res)
2474     return ptid_t (inferior_ptid.pid (), 0, res);
2475   else
2476     return null_ptid;
2477 }
2478
2479 bool
2480 darwin_nat_target::supports_multi_process ()
2481 {
2482   return true;
2483 }
2484
2485 void
2486 _initialize_darwin_nat ()
2487 {
2488   kern_return_t kret;
2489
2490   gdb_task = mach_task_self ();
2491   darwin_host_self = mach_host_self ();
2492
2493   /* Read page size.  */
2494   kret = host_page_size (darwin_host_self, &mach_page_size);
2495   if (kret != KERN_SUCCESS)
2496     {
2497       mach_page_size = 0x1000;
2498       MACH_CHECK_ERROR (kret);
2499     }
2500
2501   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2502                   (unsigned long) mach_task_self (), getpid ());
2503
2504   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2505                              &darwin_debug_flag, _("\
2506 Set if printing inferior communication debugging statements."), _("\
2507 Show if printing inferior communication debugging statements."), NULL,
2508                              NULL, NULL,
2509                              &setdebuglist, &showdebuglist);
2510
2511   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2512                            &enable_mach_exceptions, _("\
2513 Set if mach exceptions are caught."), _("\
2514 Show if mach exceptions are caught."), _("\
2515 When this mode is on, all low level exceptions are reported before being\n\
2516 reported by the kernel."),
2517                            &set_enable_mach_exceptions, NULL,
2518                            &setlist, &showlist);
2519 }