gdb/darwin-nat.c

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