gdb/darwin-nat.c

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