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