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