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   task_t task_port;
 750
 751   /* Check message header.  */
 752   if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
 753     return -1;
 754
 755   /* Check descriptors.  */
 756   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
 757     return -2;
 758
 759   /* Check data representation.  */
 760   if (darwin_check_message_ndr (ndr) != 0)
 761     return -3;
 762
 763   task_port = data[0];
 764
 765   /* Find process by port.  */
 766   inf = darwin_find_inferior_by_task (task_port);
 767   *pinf = inf;
 768
 769   /* Check message destination.  */
 770   if (inf != NULL)
 771     {
 772       darwin_inferior *priv = get_darwin_inferior (inf);
 773       if (hdr->msgh_local_port != priv->notify_port)
 774         return -4;
 775     }
 776
 777   return 0;
 778 }
 779
 780 static void
 781 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
 782                      integer_t code)
 783 {
 784   mach_msg_header_t *rh = &reply->Head;
 785
 786   rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
 787   rh->msgh_remote_port = hdr->msgh_remote_port;
 788   rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
 789   rh->msgh_local_port = MACH_PORT_NULL;
 790   rh->msgh_id = hdr->msgh_id + 100;
 791
 792   reply->NDR = NDR_record;
 793   reply->RetCode = code;
 794 }
 795
 796 static void
 797 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
 798 {
 799   kern_return_t kret;
 800   mig_reply_error_t reply;
 801   darwin_inferior *priv = get_darwin_inferior (inf);
 802
 803   darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
 804
 805   kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
 806                    reply.Head.msgh_size, 0,
 807                    MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 808                    MACH_PORT_NULL);
 809   MACH_CHECK_ERROR (kret);
 810
 811   priv->pending_messages--;
 812 }
 813
 814 /* Wrapper around the __pthread_kill syscall.  We use this instead of the
 815    pthread_kill function to be able to send a signal to any kind of thread,
 816    including GCD threads.  */
 817
 818 static int
 819 darwin_pthread_kill (darwin_thread_t *thread, int nsignal)
 820 {
 821   DIAGNOSTIC_PUSH;
 822   DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS;
 823   int res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
 824   DIAGNOSTIC_POP;
 825   return res;
 826 }
 827
 828 static void
 829 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
 830                       int step, int nsignal)
 831 {
 832   inferior_debug
 833     (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
 834      thread->msg_state, thread->gdb_port, step, nsignal);
 835
 836   switch (thread->msg_state)
 837     {
 838     case DARWIN_MESSAGE:
 839       if (thread->event.ex_type == EXC_SOFTWARE
 840           && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
 841         {
 842           /* Either deliver a new signal or cancel the signal received.  */
 843           int res = PTRACE (PT_THUPDATE, inf->pid,
 844                             (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
 845           if (res < 0)
 846             inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
 847         }
 848       else if (nsignal)
 849         {
 850           /* Note: ptrace is allowed only if the process is stopped.
 851              Directly send the signal to the thread.  */
 852           int res = darwin_pthread_kill (thread, nsignal);
 853           inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
 854                           thread->gdb_port, nsignal, res);
 855           thread->signaled = 1;
 856         }
 857
 858       /* Set or reset single step.  */
 859       inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
 860                       thread->gdb_port, step);
 861       darwin_set_sstep (thread->gdb_port, step);
 862       thread->single_step = step;
 863
 864       darwin_send_reply (inf, thread);
 865       thread->msg_state = DARWIN_RUNNING;
 866       break;
 867
 868     case DARWIN_RUNNING:
 869       break;
 870
 871     case DARWIN_STOPPED:
 872       kern_return_t kret = thread_resume (thread->gdb_port);
 873       MACH_CHECK_ERROR (kret);
 874
 875       thread->msg_state = DARWIN_RUNNING;
 876       break;
 877     }
 878 }
 879
 880 /* Resume all threads of the inferior.  */
 881
 882 static void
 883 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
 884 {
 885   darwin_inferior *priv = get_darwin_inferior (inf);
 886
 887   if (priv != nullptr)
 888     for (darwin_thread_t *thread : priv->threads)
 889       darwin_resume_thread (inf, thread, step, nsignal);
 890 }
 891
 892 struct resume_inferior_threads_param
 893 {
 894   int step;
 895   int nsignal;
 896 };
 897
 898 static int
 899 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
 900 {
 901   int step = ((struct resume_inferior_threads_param *)param)->step;
 902   int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
 903
 904   darwin_resume_inferior_threads (inf, step, nsignal);
 905
 906   return 0;
 907 }
 908
 909 /* Suspend all threads of INF.  */
 910
 911 static void
 912 darwin_suspend_inferior_threads (struct inferior *inf)
 913 {
 914   darwin_inferior *priv = get_darwin_inferior (inf);
 915
 916   for (darwin_thread_t *thread : priv->threads)
 917     {
 918       switch (thread->msg_state)
 919         {
 920         case DARWIN_STOPPED:
 921         case DARWIN_MESSAGE:
 922           break;
 923         case DARWIN_RUNNING:
 924           {
 925             kern_return_t kret = thread_suspend (thread->gdb_port);
 926             MACH_CHECK_ERROR (kret);
 927             thread->msg_state = DARWIN_STOPPED;
 928             break;
 929           }
 930         }
 931     }
 932 }
 933
 934 void
 935 darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
 936 {
 937   struct target_waitstatus status;
 938
 939   int nsignal;
 940
 941   inferior_debug
 942     (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
 943      ptid.pid (), ptid.tid (), step, signal);
 944
 945   if (signal == GDB_SIGNAL_0)
 946     nsignal = 0;
 947   else
 948     nsignal = gdb_signal_to_host (signal);
 949
 950   /* Don't try to single step all threads.  */
 951   if (step)
 952     ptid = inferior_ptid;
 953
 954   /* minus_one_ptid is RESUME_ALL.  */
 955   if (ptid == minus_one_ptid)
 956     {
 957       struct resume_inferior_threads_param param;
 958
 959       param.nsignal = nsignal;
 960       param.step = step;
 961
 962       /* Resume threads.  */
 963       iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
 964       /* Resume tasks.  */
 965       iterate_over_inferiors (darwin_resume_inferior_it, NULL);
 966     }
 967   else
 968     {
 969       struct inferior *inf = find_inferior_ptid (ptid);
 970       long tid = ptid.tid ();
 971
 972       /* Stop the inferior (should be useless).  */
 973       darwin_suspend_inferior (inf);
 974
 975       if (tid == 0)
 976         darwin_resume_inferior_threads (inf, step, nsignal);
 977       else
 978         {
 979           darwin_thread_t *thread;
 980
 981           /* Suspend threads of the task.  */
 982           darwin_suspend_inferior_threads (inf);
 983
 984           /* Resume the selected thread.  */
 985           thread = darwin_find_thread (inf, tid);
 986           gdb_assert (thread);
 987           darwin_resume_thread (inf, thread, step, nsignal);
 988         }
 989
 990       /* Resume the task.  */
 991       darwin_resume_inferior (inf);
 992     }
 993 }
 994
 995 static ptid_t
 996 darwin_decode_message (mach_msg_header_t *hdr,
 997                        darwin_thread_t **pthread,
 998                        struct inferior **pinf,
 999                        struct target_waitstatus *status)
1000 {
1001   darwin_thread_t *thread;
1002   struct inferior *inf;
1003
1004   /* Exception message.  2401 == 0x961 is exc.  */
1005   if (hdr->msgh_id == 2401)
1006     {
1007       int res;
1008
1009       /* Decode message.  */
1010       res = darwin_decode_exception_message (hdr, &inf, &thread);
1011
1012       if (res < 0)
1013         {
1014           /* Should not happen...  */
1015           printf_unfiltered
1016             (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
1017           /* FIXME: send a failure reply?  */
1018           status->kind = TARGET_WAITKIND_IGNORE;
1019           return minus_one_ptid;
1020         }
1021       if (inf == NULL)
1022         {
1023           status->kind = TARGET_WAITKIND_IGNORE;
1024           return minus_one_ptid;
1025         }
1026       *pinf = inf;
1027       *pthread = thread;
1028
1029       darwin_inferior *priv = get_darwin_inferior (inf);
1030
1031       priv->pending_messages++;
1032
1033       status->kind = TARGET_WAITKIND_STOPPED;
1034       thread->msg_state = DARWIN_MESSAGE;
1035
1036       inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1037                       thread->gdb_port,
1038                       unparse_exception_type (thread->event.ex_type));
1039
1040       switch (thread->event.ex_type)
1041         {
1042         case EXC_BAD_ACCESS:
1043           status->value.sig = GDB_EXC_BAD_ACCESS;
1044           break;
1045         case EXC_BAD_INSTRUCTION:
1046           status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1047           break;
1048         case EXC_ARITHMETIC:
1049           status->value.sig = GDB_EXC_ARITHMETIC;
1050           break;
1051         case EXC_EMULATION:
1052           status->value.sig = GDB_EXC_EMULATION;
1053           break;
1054         case EXC_SOFTWARE:
1055           if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1056             {
1057               status->value.sig =
1058                 gdb_signal_from_host (thread->event.ex_data[1]);
1059               inferior_debug (5, _("  (signal %d: %s)\n"),
1060                               thread->event.ex_data[1],
1061                               gdb_signal_to_name (status->value.sig));
1062
1063               /* If the thread is stopped because it has received a signal
1064                  that gdb has just sent, continue.  */
1065               if (thread->signaled)
1066                 {
1067                   thread->signaled = 0;
1068                   darwin_send_reply (inf, thread);
1069                   thread->msg_state = DARWIN_RUNNING;
1070                   status->kind = TARGET_WAITKIND_IGNORE;
1071                 }
1072             }
1073           else
1074             status->value.sig = GDB_EXC_SOFTWARE;
1075           break;
1076         case EXC_BREAKPOINT:
1077           /* Many internal GDB routines expect breakpoints to be reported
1078              as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1079              as a spurious signal.  */
1080           status->value.sig = GDB_SIGNAL_TRAP;
1081           break;
1082         default:
1083           status->value.sig = GDB_SIGNAL_UNKNOWN;
1084           break;
1085         }
1086
1087       return ptid_t (inf->pid, 0, thread->gdb_port);
1088     }
1089   else if (hdr->msgh_id == 0x48)
1090     {
1091       /* MACH_NOTIFY_DEAD_NAME: notification for exit.  */
1092       int res;
1093
1094       res = darwin_decode_notify_message (hdr, &inf);
1095
1096       if (res < 0)
1097         {
1098           /* Should not happen...  */
1099           printf_unfiltered
1100             (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1101              hdr->msgh_id, res);
1102         }
1103
1104       *pinf = NULL;
1105       *pthread = NULL;
1106
1107       if (res < 0 || inf == NULL)
1108         {
1109           status->kind = TARGET_WAITKIND_IGNORE;
1110           return minus_one_ptid;
1111         }
1112
1113       if (inf != NULL)
1114         {
1115           darwin_inferior *priv = get_darwin_inferior (inf);
1116
1117           if (!priv->no_ptrace)
1118             {
1119               pid_t res;
1120               int wstatus;
1121
1122               res = wait4 (inf->pid, &wstatus, 0, NULL);
1123               if (res < 0 || res != inf->pid)
1124                 {
1125                   printf_unfiltered (_("wait4: res=%d: %s\n"),
1126                                      res, safe_strerror (errno));
1127                   status->kind = TARGET_WAITKIND_IGNORE;
1128                   return minus_one_ptid;
1129                 }
1130               if (WIFEXITED (wstatus))
1131                 {
1132                   status->kind = TARGET_WAITKIND_EXITED;
1133                   status->value.integer = WEXITSTATUS (wstatus);
1134                 }
1135               else
1136                 {
1137                   status->kind = TARGET_WAITKIND_SIGNALLED;
1138                   status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1139                 }
1140
1141               inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1142                               res, wstatus);
1143
1144               /* Looks necessary on Leopard and harmless...  */
1145               wait4 (inf->pid, &wstatus, 0, NULL);
1146
1147               inferior_ptid = ptid_t (inf->pid, 0, 0);
1148               return inferior_ptid;
1149             }
1150           else
1151             {
1152               inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1153               status->kind = TARGET_WAITKIND_EXITED;
1154               status->value.integer = 0; /* Don't know.  */
1155               return ptid_t (inf->pid, 0, 0);
1156             }
1157         }
1158     }
1159
1160   /* Unknown message.  */
1161   warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1162   status->kind = TARGET_WAITKIND_IGNORE;
1163   return minus_one_ptid;
1164 }
1165
1166 static int
1167 cancel_breakpoint (ptid_t ptid)
1168 {
1169   /* Arrange for a breakpoint to be hit again later.  We will handle
1170      the current event, eventually we will resume this thread, and this
1171      breakpoint will trap again.
1172
1173      If we do not do this, then we run the risk that the user will
1174      delete or disable the breakpoint, but the thread will have already
1175      tripped on it.  */
1176
1177   struct regcache *regcache = get_thread_regcache (ptid);
1178   struct gdbarch *gdbarch = regcache->arch ();
1179   CORE_ADDR pc;
1180
1181   pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1182   if (breakpoint_inserted_here_p (regcache->aspace (), pc))
1183     {
1184       inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1185                       (unsigned long) ptid.tid ());
1186
1187       /* Back up the PC if necessary.  */
1188       if (gdbarch_decr_pc_after_break (gdbarch))
1189         regcache_write_pc (regcache, pc);
1190
1191       return 1;
1192     }
1193   return 0;
1194 }
1195
1196 static ptid_t
1197 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1198 {
1199   kern_return_t kret;
1200   union
1201   {
1202     mach_msg_header_t hdr;
1203     char data[0x100];
1204   } msgin;
1205   mach_msg_header_t *hdr = &msgin.hdr;
1206   ptid_t res;
1207   darwin_thread_t *thread;
1208   struct inferior *inf;
1209
1210   inferior_debug
1211     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1212      ptid.pid (), ptid.tid ());
1213
1214   /* Handle fake stop events at first.  */
1215   if (darwin_inf_fake_stop != NULL)
1216     {
1217       inf = darwin_inf_fake_stop;
1218       darwin_inf_fake_stop = NULL;
1219
1220       darwin_inferior *priv = get_darwin_inferior (inf);
1221
1222       status->kind = TARGET_WAITKIND_STOPPED;
1223       status->value.sig = GDB_SIGNAL_TRAP;
1224       thread = priv->threads[0];
1225       thread->msg_state = DARWIN_STOPPED;
1226       return ptid_t (inf->pid, 0, thread->gdb_port);
1227     }
1228
1229   do
1230     {
1231       /* set_sigint_trap (); */
1232
1233       /* Wait for a message.  */
1234       kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1235                        sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1236
1237       /* clear_sigint_trap (); */
1238
1239       if (kret == MACH_RCV_INTERRUPTED)
1240         {
1241           status->kind = TARGET_WAITKIND_IGNORE;
1242           return minus_one_ptid;
1243         }
1244
1245       if (kret != MACH_MSG_SUCCESS)
1246         {
1247           inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1248           status->kind = TARGET_WAITKIND_SPURIOUS;
1249           return minus_one_ptid;
1250         }
1251
1252       /* Debug: display message.  */
1253       if (darwin_debug_flag > 10)
1254         darwin_dump_message (hdr, darwin_debug_flag > 11);
1255
1256       res = darwin_decode_message (hdr, &thread, &inf, status);
1257       if (res == minus_one_ptid)
1258         continue;
1259
1260       /* Early return in case an inferior has exited.  */
1261       if (inf == NULL)
1262         return res;
1263     }
1264   while (status->kind == TARGET_WAITKIND_IGNORE);
1265
1266   /* Stop all tasks.  */
1267   iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1268
1269   /* Read pending messages.  */
1270   while (1)
1271     {
1272       struct target_waitstatus status2;
1273       ptid_t ptid2;
1274
1275       kret = mach_msg (&msgin.hdr,
1276                        MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1277                        sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1278
1279       if (kret == MACH_RCV_TIMED_OUT)
1280         break;
1281       if (kret != MACH_MSG_SUCCESS)
1282         {
1283           inferior_debug
1284             (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1285           break;
1286         }
1287
1288       /* Debug: display message.  */
1289       if (darwin_debug_flag > 10)
1290         darwin_dump_message (hdr, darwin_debug_flag > 11);
1291
1292       ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1293
1294       if (inf != NULL && thread != NULL
1295           && thread->event.ex_type == EXC_BREAKPOINT)
1296         {
1297           if (thread->single_step
1298               || cancel_breakpoint (ptid_t (inf->pid, 0, thread->gdb_port)))
1299             {
1300               gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1301               darwin_send_reply (inf, thread);
1302               thread->msg_state = DARWIN_RUNNING;
1303             }
1304           else
1305             inferior_debug
1306               (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1307                thread->gdb_port);
1308         }
1309       else
1310         inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1311     }
1312   return res;
1313 }
1314
1315 ptid_t
1316 darwin_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
1317                          int options)
1318 {
1319   return darwin_wait (ptid, status);
1320 }
1321
1322 void
1323 darwin_nat_target::interrupt ()
1324 {
1325   struct inferior *inf = current_inferior ();
1326   darwin_inferior *priv = get_darwin_inferior (inf);
1327
1328   /* FIXME: handle in no_ptrace mode.  */
1329   gdb_assert (!priv->no_ptrace);
1330   ::kill (inf->pid, SIGINT);
1331 }
1332
1333 /* Deallocate threads port and vector.  */
1334
1335 static void
1336 darwin_deallocate_threads (struct inferior *inf)
1337 {
1338   darwin_inferior *priv = get_darwin_inferior (inf);
1339
1340   for (darwin_thread_t *t : priv->threads)
1341     {
1342       kern_return_t kret = mach_port_deallocate (gdb_task, t->gdb_port);
1343       MACH_CHECK_ERROR (kret);
1344     }
1345
1346   priv->threads.clear ();
1347 }
1348
1349 void
1350 darwin_nat_target::mourn_inferior ()
1351 {
1352   struct inferior *inf = current_inferior ();
1353   darwin_inferior *priv = get_darwin_inferior (inf);
1354   kern_return_t kret;
1355   mach_port_t prev;
1356
1357   /* Deallocate threads.  */
1358   darwin_deallocate_threads (inf);
1359
1360   /* Remove notify_port from darwin_port_set.  */
1361   kret = mach_port_move_member (gdb_task,
1362                                 priv->notify_port, MACH_PORT_NULL);
1363   MACH_CHECK_ERROR (kret);
1364
1365   /* Remove task port dead_name notification.  */
1366   kret = mach_port_request_notification (gdb_task, priv->task,
1367                                          MACH_NOTIFY_DEAD_NAME, 0,
1368                                          MACH_PORT_NULL,
1369                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1370                                          &prev);
1371   /* This can fail if the task is dead.  */
1372   inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1373                   priv->task, prev, priv->notify_port);
1374
1375   if (kret == KERN_SUCCESS)
1376     {
1377       kret = mach_port_deallocate (gdb_task, prev);
1378       MACH_CHECK_ERROR (kret);
1379     }
1380
1381   /* Destroy notify_port.  */
1382   kret = mach_port_destroy (gdb_task, priv->notify_port);
1383   MACH_CHECK_ERROR (kret);
1384
1385   /* Deallocate saved exception ports.  */
1386   darwin_deallocate_exception_ports (priv);
1387
1388   /* Deallocate task port.  */
1389   kret = mach_port_deallocate (gdb_task, priv->task);
1390   MACH_CHECK_ERROR (kret);
1391
1392   inf->priv = NULL;
1393
1394   inf_child_target::mourn_inferior ();
1395 }
1396
1397 static void
1398 darwin_reply_to_all_pending_messages (struct inferior *inf)
1399 {
1400   darwin_inferior *priv = get_darwin_inferior (inf);
1401
1402   for (darwin_thread_t *t : priv->threads)
1403     {
1404       if (t->msg_state == DARWIN_MESSAGE)
1405         darwin_resume_thread (inf, t, 0, 0);
1406     }
1407 }
1408
1409 static void
1410 darwin_stop_inferior (struct inferior *inf)
1411 {
1412   struct target_waitstatus wstatus;
1413   ptid_t ptid;
1414   int res;
1415   darwin_inferior *priv = get_darwin_inferior (inf);
1416
1417   gdb_assert (inf != NULL);
1418
1419   darwin_suspend_inferior (inf);
1420
1421   darwin_reply_to_all_pending_messages (inf);
1422
1423   if (priv->no_ptrace)
1424     return;
1425
1426   res = kill (inf->pid, SIGSTOP);
1427   if (res != 0)
1428     warning (_("cannot kill: %s"), safe_strerror (errno));
1429
1430   /* Wait until the process is really stopped.  */
1431   while (1)
1432     {
1433       ptid = darwin_wait (inferior_ptid, &wstatus);
1434       if (wstatus.kind == TARGET_WAITKIND_STOPPED
1435           && wstatus.value.sig == GDB_SIGNAL_STOP)
1436         break;
1437     }
1438 }
1439
1440 static kern_return_t
1441 darwin_save_exception_ports (darwin_inferior *inf)
1442 {
1443   kern_return_t kret;
1444
1445   inf->exception_info.count =
1446     sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1447
1448   kret = task_get_exception_ports
1449     (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1450      &inf->exception_info.count, inf->exception_info.ports,
1451      inf->exception_info.behaviors, inf->exception_info.flavors);
1452   return kret;
1453 }
1454
1455 static kern_return_t
1456 darwin_restore_exception_ports (darwin_inferior *inf)
1457 {
1458   int i;
1459   kern_return_t kret;
1460
1461   for (i = 0; i < inf->exception_info.count; i++)
1462     {
1463       kret = task_set_exception_ports
1464         (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1465          inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1466       if (kret != KERN_SUCCESS)
1467         return kret;
1468     }
1469
1470   return KERN_SUCCESS;
1471 }
1472
1473 /* Deallocate saved exception ports.  */
1474
1475 static void
1476 darwin_deallocate_exception_ports (darwin_inferior *inf)
1477 {
1478   int i;
1479   kern_return_t kret;
1480
1481   for (i = 0; i < inf->exception_info.count; i++)
1482     {
1483       kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1484       MACH_CHECK_ERROR (kret);
1485     }
1486   inf->exception_info.count = 0;
1487 }
1488
1489 static void
1490 darwin_setup_exceptions (struct inferior *inf)
1491 {
1492   darwin_inferior *priv = get_darwin_inferior (inf);
1493   kern_return_t kret;
1494   exception_mask_t mask;
1495
1496   kret = darwin_save_exception_ports (priv);
1497   if (kret != KERN_SUCCESS)
1498     error (_("Unable to save exception ports, task_get_exception_ports"
1499              "returned: %d"),
1500            kret);
1501
1502   /* Set exception port.  */
1503   if (enable_mach_exceptions)
1504     mask = EXC_MASK_ALL;
1505   else
1506     mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1507   kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
1508                                    EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1509   if (kret != KERN_SUCCESS)
1510     error (_("Unable to set exception ports, task_set_exception_ports"
1511              "returned: %d"),
1512            kret);
1513 }
1514
1515 void
1516 darwin_nat_target::kill ()
1517 {
1518   struct inferior *inf = current_inferior ();
1519   darwin_inferior *priv = get_darwin_inferior (inf);
1520   struct target_waitstatus wstatus;
1521   ptid_t ptid;
1522   kern_return_t kret;
1523   int res;
1524
1525   if (inferior_ptid == null_ptid)
1526     return;
1527
1528   gdb_assert (inf != NULL);
1529
1530   kret = darwin_restore_exception_ports (priv);
1531   MACH_CHECK_ERROR (kret);
1532
1533   darwin_reply_to_all_pending_messages (inf);
1534
1535   res = ::kill (inf->pid, 9);
1536
1537   if (res == 0)
1538     {
1539       /* On MacOS version Sierra, the darwin_restore_exception_ports call
1540          does not work as expected.
1541          When the kill function is called, the SIGKILL signal is received
1542          by gdb whereas it should have been received by the kernel since
1543          the exception ports have been restored.
1544          This behavior is not the expected one thus gdb does not reply to
1545          the received SIGKILL message. This situation leads to a "busy"
1546          resource from the kernel point of view and the inferior is never
1547          released, causing it to remain as a zombie process, even after
1548          GDB exits.
1549          To work around this, we mark all the threads of the inferior as
1550          signaled thus darwin_decode_message function knows that the kill
1551          signal was sent by gdb and will take the appropriate action
1552          (cancel signal and reply to the signal message).  */
1553       darwin_inferior *priv = get_darwin_inferior (inf);
1554       for (darwin_thread_t *thread : priv->threads)
1555         thread->signaled = 1;
1556
1557       darwin_resume_inferior (inf);
1558
1559       ptid = darwin_wait (inferior_ptid, &wstatus);
1560     }
1561   else if (errno != ESRCH)
1562     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1563              inf->pid, safe_strerror (errno));
1564
1565   target_mourn_inferior (inferior_ptid);
1566 }
1567
1568 static void
1569 darwin_setup_request_notification (struct inferior *inf)
1570 {
1571   darwin_inferior *priv = get_darwin_inferior (inf);
1572   kern_return_t kret;
1573   mach_port_t prev_not;
1574
1575   kret = mach_port_request_notification (gdb_task, priv->task,
1576                                          MACH_NOTIFY_DEAD_NAME, 0,
1577                                          priv->notify_port,
1578                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1579                                          &prev_not);
1580   if (kret != KERN_SUCCESS)
1581     error (_("Termination notification request failed, "
1582              "mach_port_request_notification\n"
1583              "returned: %d"),
1584            kret);
1585   if (prev_not != MACH_PORT_NULL)
1586     {
1587       /* This is unexpected, as there should not be any previously
1588          registered notification request.  But this is not a fatal
1589          issue, so just emit a warning.  */
1590       warning (_("\
1591 A task termination request was registered before the debugger registered\n\
1592 its own.  This is unexpected, but should otherwise not have any actual\n\
1593 impact on the debugging session."));
1594     }
1595 }
1596
1597 static void
1598 darwin_attach_pid (struct inferior *inf)
1599 {
1600   kern_return_t kret;
1601
1602   darwin_inferior *priv = new darwin_inferior;
1603   inf->priv.reset (priv);
1604
1605   TRY
1606     {
1607       kret = task_for_pid (gdb_task, inf->pid, &priv->task);
1608       if (kret != KERN_SUCCESS)
1609         {
1610           int status;
1611
1612           if (!inf->attach_flag)
1613             {
1614               kill (inf->pid, 9);
1615               waitpid (inf->pid, &status, 0);
1616             }
1617
1618           error
1619             (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1620                " (please check gdb is codesigned - see taskgated(8))"),
1621              inf->pid, mach_error_string (kret), (unsigned long) kret);
1622         }
1623
1624       inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1625                       priv->task, inf->pid);
1626
1627       if (darwin_ex_port == MACH_PORT_NULL)
1628         {
1629           /* Create a port to get exceptions.  */
1630           kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1631                                      &darwin_ex_port);
1632           if (kret != KERN_SUCCESS)
1633             error (_("Unable to create exception port, mach_port_allocate "
1634                      "returned: %d"),
1635                    kret);
1636
1637           kret = mach_port_insert_right (gdb_task, darwin_ex_port,
1638                                          darwin_ex_port,
1639                                          MACH_MSG_TYPE_MAKE_SEND);
1640           if (kret != KERN_SUCCESS)
1641             error (_("Unable to create exception port, mach_port_insert_right "
1642                      "returned: %d"),
1643                    kret);
1644
1645           /* Create a port set and put ex_port in it.  */
1646           kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1647                                      &darwin_port_set);
1648           if (kret != KERN_SUCCESS)
1649             error (_("Unable to create port set, mach_port_allocate "
1650                      "returned: %d"),
1651                    kret);
1652
1653           kret = mach_port_move_member (gdb_task, darwin_ex_port,
1654                                         darwin_port_set);
1655           if (kret != KERN_SUCCESS)
1656             error (_("Unable to move exception port into new port set, "
1657                      "mach_port_move_member\n"
1658                      "returned: %d"),
1659                    kret);
1660         }
1661
1662       /* Create a port to be notified when the child task terminates.  */
1663       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1664                                  &priv->notify_port);
1665       if (kret != KERN_SUCCESS)
1666         error (_("Unable to create notification port, mach_port_allocate "
1667                  "returned: %d"),
1668                kret);
1669
1670       kret = mach_port_move_member (gdb_task,
1671                                     priv->notify_port, darwin_port_set);
1672       if (kret != KERN_SUCCESS)
1673         error (_("Unable to move notification port into new port set, "
1674                  "mach_port_move_member\n"
1675                  "returned: %d"),
1676                kret);
1677
1678       darwin_setup_request_notification (inf);
1679
1680       darwin_setup_exceptions (inf);
1681     }
1682   CATCH (ex, RETURN_MASK_ALL)
1683     {
1684       exit_inferior (inf);
1685       inferior_ptid = null_ptid;
1686
1687       throw_exception (ex);
1688     }
1689   END_CATCH
1690
1691   target_ops *darwin_ops = get_native_target ();
1692   if (!target_is_pushed (darwin_ops))
1693     push_target (darwin_ops);
1694 }
1695
1696 /* Get the thread_info object corresponding to this darwin_thread_info.  */
1697
1698 static struct thread_info *
1699 thread_info_from_private_thread_info (darwin_thread_info *pti)
1700 {
1701   struct thread_info *it;
1702
1703   ALL_THREADS (it)
1704     {
1705       darwin_thread_info *iter_pti = get_darwin_thread_info (it);
1706
1707       if (iter_pti->gdb_port == pti->gdb_port)
1708         break;
1709     }
1710
1711   gdb_assert (it != NULL);
1712
1713   return it;
1714 }
1715
1716 static void
1717 darwin_init_thread_list (struct inferior *inf)
1718 {
1719   darwin_check_new_threads (inf);
1720
1721   darwin_inferior *priv = get_darwin_inferior (inf);
1722
1723   gdb_assert (!priv->threads.empty ());
1724
1725   darwin_thread_info *first_pti = priv->threads.front ();
1726   struct thread_info *first_thread
1727     = thread_info_from_private_thread_info (first_pti);
1728
1729   inferior_ptid = first_thread->ptid;
1730 }
1731
1732 /* The child must synchronize with gdb: gdb must set the exception port
1733    before the child call PTRACE_SIGEXC.  We use a pipe to achieve this.
1734    FIXME: is there a lighter way ?  */
1735 static int ptrace_fds[2];
1736
1737 static void
1738 darwin_ptrace_me (void)
1739 {
1740   int res;
1741   char c;
1742
1743   /* Close write end point.  */
1744   if (close (ptrace_fds[1]) < 0)
1745     trace_start_error_with_name ("close");
1746
1747   /* Wait until gdb is ready.  */
1748   res = read (ptrace_fds[0], &c, 1);
1749   if (res != 0)
1750     trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1751
1752   if (close (ptrace_fds[0]) < 0)
1753     trace_start_error_with_name ("close");
1754
1755   /* Get rid of privileges.  */
1756   if (setegid (getgid ()) < 0)
1757     trace_start_error_with_name ("setegid");
1758
1759   /* Set TRACEME.  */
1760   if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1761     trace_start_error_with_name ("PTRACE");
1762
1763   /* Redirect signals to exception port.  */
1764   if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1765     trace_start_error_with_name ("PTRACE");
1766 }
1767
1768 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).  */
1769 static void
1770 darwin_pre_ptrace (void)
1771 {
1772   if (pipe (ptrace_fds) != 0)
1773     {
1774       ptrace_fds[0] = -1;
1775       ptrace_fds[1] = -1;
1776       error (_("unable to create a pipe: %s"), safe_strerror (errno));
1777     }
1778
1779   mark_fd_no_cloexec (ptrace_fds[0]);
1780   mark_fd_no_cloexec (ptrace_fds[1]);
1781 }
1782
1783 static void
1784 darwin_ptrace_him (int pid)
1785 {
1786   struct inferior *inf = current_inferior ();
1787
1788   darwin_attach_pid (inf);
1789
1790   /* Let's the child run.  */
1791   close (ptrace_fds[0]);
1792   close (ptrace_fds[1]);
1793
1794   unmark_fd_no_cloexec (ptrace_fds[0]);
1795   unmark_fd_no_cloexec (ptrace_fds[1]);
1796
1797   darwin_init_thread_list (inf);
1798
1799   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1800 }
1801
1802 static void
1803 darwin_execvp (const char *file, char * const argv[], char * const env[])
1804 {
1805   posix_spawnattr_t attr;
1806   short ps_flags = 0;
1807   int res;
1808
1809   res = posix_spawnattr_init (&attr);
1810   if (res != 0)
1811     {
1812       fprintf_unfiltered
1813         (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1814       return;
1815     }
1816
1817   /* Do like execve: replace the image.  */
1818   ps_flags = POSIX_SPAWN_SETEXEC;
1819
1820   /* Disable ASLR.  The constant doesn't look to be available outside the
1821      kernel include files.  */
1822 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1823 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1824 #endif
1825   ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1826   res = posix_spawnattr_setflags (&attr, ps_flags);
1827   if (res != 0)
1828     {
1829       fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1830       return;
1831     }
1832
1833   posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1834 }
1835
1836 /* Read kernel version, and return TRUE on Sierra or later.  */
1837
1838 static bool
1839 should_disable_startup_with_shell ()
1840 {
1841   char str[16];
1842   size_t sz = sizeof (str);
1843   int ret;
1844
1845   ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
1846   if (ret == 0 && sz < sizeof (str))
1847     {
1848       unsigned long ver = strtoul (str, NULL, 10);
1849       if (ver >= 16)
1850         return true;
1851     }
1852   return false;
1853 }
1854
1855 void
1856 darwin_nat_target::create_inferior (const char *exec_file,
1857                                     const std::string &allargs,
1858                                     char **env, int from_tty)
1859 {
1860   gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
1861
1862   if (startup_with_shell && should_disable_startup_with_shell ())
1863     {
1864       warning (_("startup-with-shell not supported on this macOS version,"
1865                  " disabling it."));
1866       restore_startup_with_shell.emplace (&startup_with_shell, 0);
1867     }
1868
1869   /* Do the hard work.  */
1870   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1871                  darwin_ptrace_him, darwin_pre_ptrace, NULL,
1872                  darwin_execvp);
1873 }
1874 \f
1875
1876 /* Set things up such that the next call to darwin_wait will immediately
1877    return a fake stop event for inferior INF.
1878
1879    This assumes that the inferior's thread list has been initialized,
1880    as it will suspend the inferior's first thread.  */
1881
1882 static void
1883 darwin_setup_fake_stop_event (struct inferior *inf)
1884 {
1885   darwin_inferior *priv = get_darwin_inferior (inf);
1886   darwin_thread_t *thread;
1887   kern_return_t kret;
1888
1889   gdb_assert (darwin_inf_fake_stop == NULL);
1890   darwin_inf_fake_stop = inf;
1891
1892   /* When detecting a fake pending stop event, darwin_wait returns
1893      an event saying that the first thread is in a DARWIN_STOPPED
1894      state.  To make that accurate, we need to suspend that thread
1895      as well.  Otherwise, we'll try resuming it when resuming the
1896      inferior, and get a warning because the thread's suspend count
1897      is already zero, making the resume request useless.  */
1898   thread = priv->threads[0];
1899   kret = thread_suspend (thread->gdb_port);
1900   MACH_CHECK_ERROR (kret);
1901 }
1902
1903 /* Attach to process PID, then initialize for debugging it
1904    and wait for the trace-trap that results from attaching.  */
1905 void
1906 darwin_nat_target::attach (const char *args, int from_tty)
1907 {
1908   pid_t pid;
1909   struct inferior *inf;
1910
1911   pid = parse_pid_to_attach (args);
1912
1913   if (pid == getpid ())         /* Trying to masturbate?  */
1914     error (_("I refuse to debug myself!"));
1915
1916   if (from_tty)
1917     {
1918       char *exec_file = get_exec_file (0);
1919
1920       if (exec_file)
1921         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1922                            target_pid_to_str (ptid_t (pid)));
1923       else
1924         printf_unfiltered (_("Attaching to %s\n"),
1925                            target_pid_to_str (ptid_t (pid)));
1926
1927       gdb_flush (gdb_stdout);
1928     }
1929
1930   if (pid == 0 || ::kill (pid, 0) < 0)
1931     error (_("Can't attach to process %d: %s (%d)"),
1932            pid, safe_strerror (errno), errno);
1933
1934   inferior_ptid = ptid_t (pid);
1935   inf = current_inferior ();
1936   inferior_appeared (inf, pid);
1937   inf->attach_flag = 1;
1938
1939   darwin_attach_pid (inf);
1940
1941   darwin_suspend_inferior (inf);
1942
1943   darwin_init_thread_list (inf);
1944
1945   darwin_inferior *priv = get_darwin_inferior (inf);
1946
1947   darwin_check_osabi (priv, inferior_ptid.tid ());
1948
1949   darwin_setup_fake_stop_event (inf);
1950
1951   priv->no_ptrace = 1;
1952 }
1953
1954 /* Take a program previously attached to and detaches it.
1955    The program resumes execution and will no longer stop
1956    on signals, etc.  We'd better not have left any breakpoints
1957    in the program or it'll die when it hits one.  For this
1958    to work, it may be necessary for the process to have been
1959    previously attached.  It *might* work if the program was
1960    started via fork.  */
1961
1962 void
1963 darwin_nat_target::detach (inferior *inf, int from_tty)
1964 {
1965   darwin_inferior *priv = get_darwin_inferior (inf);
1966   kern_return_t kret;
1967   int res;
1968
1969   /* Display message.  */
1970   target_announce_detach (from_tty);
1971
1972   /* If ptrace() is in use, stop the process.  */
1973   if (!priv->no_ptrace)
1974     darwin_stop_inferior (inf);
1975
1976   kret = darwin_restore_exception_ports (priv);
1977   MACH_CHECK_ERROR (kret);
1978
1979   if (!priv->no_ptrace)
1980     {
1981       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1982       if (res != 0)
1983         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1984                            inf->pid, safe_strerror (errno), errno);
1985     }
1986
1987   darwin_reply_to_all_pending_messages (inf);
1988
1989   /* When using ptrace, we have just performed a PT_DETACH, which
1990      resumes the inferior.  On the other hand, when we are not using
1991      ptrace, we need to resume its execution ourselves.  */
1992   if (priv->no_ptrace)
1993     darwin_resume_inferior (inf);
1994
1995   mourn_inferior ();
1996 }
1997
1998 const char *
1999 darwin_nat_target::pid_to_str (ptid_t ptid)
2000 {
2001   static char buf[80];
2002   long tid = ptid.tid ();
2003
2004   if (tid != 0)
2005     {
2006       snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
2007                 tid, ptid.pid ());
2008       return buf;
2009     }
2010
2011   return normal_pid_to_str (ptid);
2012 }
2013
2014 bool
2015 darwin_nat_target::thread_alive (ptid_t ptid)
2016 {
2017   return true;
2018 }
2019
2020 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2021    copy it to RDADDR in gdb's address space.
2022    If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2023    to ADDR in inferior task's address space.
2024    Return 0 on failure; number of bytes read / writen otherwise.  */
2025
2026 static int
2027 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2028                             gdb_byte *rdaddr, const gdb_byte *wraddr,
2029                             ULONGEST length)
2030 {
2031   kern_return_t kret;
2032   mach_vm_size_t res_length = 0;
2033
2034   inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2035                   task, core_addr_to_string (addr), pulongest (length));
2036
2037   /* First read.  */
2038   if (rdaddr != NULL)
2039     {
2040       mach_vm_size_t count;
2041
2042       /* According to target.h(to_xfer_partial), one and only one may be
2043          non-null.  */
2044       gdb_assert (wraddr == NULL);
2045
2046       kret = mach_vm_read_overwrite (task, addr, length,
2047                                      (mach_vm_address_t) rdaddr, &count);
2048       if (kret != KERN_SUCCESS)
2049         {
2050           inferior_debug
2051             (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2052              core_addr_to_string (addr), mach_error_string (kret));
2053           return 0;
2054         }
2055       return count;
2056     }
2057
2058   /* See above.  */
2059   gdb_assert (wraddr != NULL);
2060
2061   while (length != 0)
2062     {
2063       mach_vm_address_t offset = addr & (mach_page_size - 1);
2064       mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2065       mach_vm_size_t aligned_length =
2066         (mach_vm_size_t) PAGE_ROUND (offset + length);
2067       vm_region_submap_short_info_data_64_t info;
2068       mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2069       natural_t region_depth = 1000;
2070       mach_vm_address_t region_start = region_address;
2071       mach_vm_size_t region_length;
2072       mach_vm_size_t write_length;
2073
2074       /* Read page protection.  */
2075       kret = mach_vm_region_recurse
2076         (task, &region_start, &region_length, &region_depth,
2077          (vm_region_recurse_info_t) &info, &count);
2078
2079       if (kret != KERN_SUCCESS)
2080         {
2081           inferior_debug (1, _("darwin_read_write_inferior: "
2082                                "mach_vm_region_recurse failed at %s: %s\n"),
2083                           core_addr_to_string (region_address),
2084                           mach_error_string (kret));
2085           return res_length;
2086         }
2087
2088       inferior_debug
2089         (9, _("darwin_read_write_inferior: "
2090               "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2091          core_addr_to_string (region_address),
2092          core_addr_to_string (region_start),
2093          core_addr_to_string (region_length));
2094
2095       /* Check for holes in memory.  */
2096       if (region_start > region_address)
2097         {
2098           warning (_("No memory at %s (vs %s+0x%x).  Nothing written"),
2099                    core_addr_to_string (region_address),
2100                    core_addr_to_string (region_start),
2101                    (unsigned)region_length);
2102           return res_length;
2103         }
2104
2105       /* Adjust the length.  */
2106       region_length -= (region_address - region_start);
2107       if (region_length > aligned_length)
2108         region_length = aligned_length;
2109
2110       /* Make the pages RW.  */
2111       if (!(info.protection & VM_PROT_WRITE))
2112         {
2113           vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2114
2115           kret = mach_vm_protect (task, region_address, region_length,
2116                                   FALSE, prot);
2117           if (kret != KERN_SUCCESS)
2118             {
2119               prot |= VM_PROT_COPY;
2120               kret = mach_vm_protect (task, region_address, region_length,
2121                                       FALSE, prot);
2122             }
2123           if (kret != KERN_SUCCESS)
2124             {
2125               warning (_("darwin_read_write_inferior: "
2126                          "mach_vm_protect failed at %s "
2127                          "(len=0x%lx, prot=0x%x): %s"),
2128                        core_addr_to_string (region_address),
2129                        (unsigned long) region_length, (unsigned) prot,
2130                        mach_error_string (kret));
2131               return res_length;
2132             }
2133         }
2134
2135       if (offset + length > region_length)
2136         write_length = region_length - offset;
2137       else
2138         write_length = length;
2139
2140       /* Write.  */
2141       kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2142       if (kret != KERN_SUCCESS)
2143         {
2144           warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2145                    mach_error_string (kret));
2146           return res_length;
2147         }
2148
2149       /* Restore page rights.  */
2150       if (!(info.protection & VM_PROT_WRITE))
2151         {
2152           kret = mach_vm_protect (task, region_address, region_length,
2153                                   FALSE, info.protection);
2154           if (kret != KERN_SUCCESS)
2155             {
2156               warning (_("darwin_read_write_inferior: "
2157                          "mach_vm_protect restore failed at %s "
2158                          "(len=0x%lx): %s"),
2159                        core_addr_to_string (region_address),
2160                        (unsigned long) region_length,
2161                        mach_error_string (kret));
2162             }
2163         }
2164
2165       addr += write_length;
2166       wraddr += write_length;
2167       res_length += write_length;
2168       length -= write_length;
2169     }
2170
2171   return res_length;
2172 }
2173
2174 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2175    to RDADDR (in big endian).
2176    Return 0 on failure; number of bytes read / written otherwise.  */
2177
2178 #ifdef TASK_DYLD_INFO_COUNT
2179 /* This is not available in Darwin 9.  */
2180 static enum target_xfer_status
2181 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2182                        ULONGEST length, ULONGEST *xfered_len)
2183 {
2184   struct task_dyld_info task_dyld_info;
2185   mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2186   kern_return_t kret;
2187
2188   if (addr != 0 || length > sizeof (mach_vm_address_t))
2189     return TARGET_XFER_EOF;
2190
2191   kret = task_info (task, TASK_DYLD_INFO,
2192                     (task_info_t) &task_dyld_info, &count);
2193   MACH_CHECK_ERROR (kret);
2194   if (kret != KERN_SUCCESS)
2195     return TARGET_XFER_E_IO;
2196
2197   store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2198                           task_dyld_info.all_image_info_addr);
2199   *xfered_len = (ULONGEST) length;
2200   return TARGET_XFER_OK;
2201 }
2202 #endif
2203
2204 \f
2205
2206 enum target_xfer_status
2207 darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
2208                                  gdb_byte *readbuf, const gdb_byte *writebuf,
2209                                  ULONGEST offset, ULONGEST len,
2210                                  ULONGEST *xfered_len)
2211 {
2212   struct inferior *inf = current_inferior ();
2213   darwin_inferior *priv = get_darwin_inferior (inf);
2214
2215   inferior_debug
2216     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2217      core_addr_to_string (offset), pulongest (len),
2218      host_address_to_string (readbuf), host_address_to_string (writebuf),
2219      inf->pid);
2220
2221   switch (object)
2222     {
2223     case TARGET_OBJECT_MEMORY:
2224       {
2225         int l = darwin_read_write_inferior (priv->task, offset,
2226                                             readbuf, writebuf, len);
2227
2228         if (l == 0)
2229           return TARGET_XFER_EOF;
2230         else
2231           {
2232             gdb_assert (l > 0);
2233             *xfered_len = (ULONGEST) l;
2234             return TARGET_XFER_OK;
2235           }
2236       }
2237 #ifdef TASK_DYLD_INFO_COUNT
2238     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2239       if (writebuf != NULL || readbuf == NULL)
2240         {
2241           /* Support only read.  */
2242           return TARGET_XFER_E_IO;
2243         }
2244       return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2245                                     xfered_len);
2246 #endif
2247     default:
2248       return TARGET_XFER_E_IO;
2249     }
2250
2251 }
2252
2253 static void
2254 set_enable_mach_exceptions (const char *args, int from_tty,
2255                             struct cmd_list_element *c)
2256 {
2257   if (inferior_ptid != null_ptid)
2258     {
2259       struct inferior *inf = current_inferior ();
2260       darwin_inferior *priv = get_darwin_inferior (inf);
2261       exception_mask_t mask;
2262       kern_return_t kret;
2263
2264       if (enable_mach_exceptions)
2265         mask = EXC_MASK_ALL;
2266       else
2267         {
2268           darwin_restore_exception_ports (priv);
2269           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2270         }
2271       kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2272                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2273       MACH_CHECK_ERROR (kret);
2274     }
2275 }
2276
2277 char *
2278 darwin_nat_target::pid_to_exec_file (int pid)
2279 {
2280   static char path[PATH_MAX];
2281   int res;
2282
2283   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2284   if (res >= 0)
2285     return path;
2286   else
2287     return NULL;
2288 }
2289
2290 ptid_t
2291 darwin_nat_target::get_ada_task_ptid (long lwp, long thread)
2292 {
2293   struct inferior *inf = current_inferior ();
2294   darwin_inferior *priv = get_darwin_inferior (inf);
2295   kern_return_t kret;
2296   mach_port_name_array_t names;
2297   mach_msg_type_number_t names_count;
2298   mach_port_type_array_t types;
2299   mach_msg_type_number_t types_count;
2300   long res = 0;
2301
2302   /* First linear search.  */
2303   for (darwin_thread_t *t : priv->threads)
2304     {
2305       if (t->inf_port == lwp)
2306         return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
2307     }
2308
2309   /* Maybe the port was never extract.  Do it now.  */
2310
2311   /* First get inferior port names.  */
2312   kret = mach_port_names (priv->task, &names, &names_count, &types,
2313                           &types_count);
2314   MACH_CHECK_ERROR (kret);
2315   if (kret != KERN_SUCCESS)
2316     return null_ptid;
2317
2318   /* For each name, copy the right in the gdb space and then compare with
2319      our view of the inferior threads.  We don't forget to deallocate the
2320      right.  */
2321   for (int i = 0; i < names_count; i++)
2322     {
2323       mach_port_t local_name;
2324       mach_msg_type_name_t local_type;
2325
2326       /* We just need to know the corresponding name in gdb name space.
2327          So extract and deallocate the right.  */
2328       kret = mach_port_extract_right (priv->task, names[i],
2329                                       MACH_MSG_TYPE_COPY_SEND,
2330                                       &local_name, &local_type);
2331       if (kret != KERN_SUCCESS)
2332         continue;
2333       mach_port_deallocate (gdb_task, local_name);
2334
2335       for (darwin_thread_t *t : priv->threads)
2336         {
2337           if (t->gdb_port == local_name)
2338             {
2339               t->inf_port = names[i];
2340               if (names[i] == lwp)
2341                 res = t->gdb_port;
2342             }
2343         }
2344     }
2345
2346   vm_deallocate (gdb_task, (vm_address_t) names,
2347                  names_count * sizeof (mach_port_t));
2348
2349   if (res)
2350     return ptid_t (inferior_ptid.pid (), 0, res);
2351   else
2352     return null_ptid;
2353 }
2354
2355 bool
2356 darwin_nat_target::supports_multi_process ()
2357 {
2358   return true;
2359 }
2360
2361 void
2362 _initialize_darwin_nat ()
2363 {
2364   kern_return_t kret;
2365
2366   gdb_task = mach_task_self ();
2367   darwin_host_self = mach_host_self ();
2368
2369   /* Read page size.  */
2370   kret = host_page_size (darwin_host_self, &mach_page_size);
2371   if (kret != KERN_SUCCESS)
2372     {
2373       mach_page_size = 0x1000;
2374       MACH_CHECK_ERROR (kret);
2375     }
2376
2377   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2378                   (unsigned long) mach_task_self (), getpid ());
2379
2380   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2381                              &darwin_debug_flag, _("\
2382 Set if printing inferior communication debugging statements."), _("\
2383 Show if printing inferior communication debugging statements."), NULL,
2384                              NULL, NULL,
2385                              &setdebuglist, &showdebuglist);
2386
2387   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2388                            &enable_mach_exceptions, _("\
2389 Set if mach exceptions are caught."), _("\
2390 Show if mach exceptions are caught."), _("\
2391 When this mode is on, all low level exceptions are reported before being\n\
2392 reported by the kernel."),
2393                            &set_enable_mach_exceptions, NULL,
2394                            &setlist, &showlist);
2395 }