gdb/darwin-nat.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2017 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, ptid_t);
  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   unsigned int i;
 283   thread_array_t thread_list;
 284   unsigned int new_nbr;
 285   unsigned int old_nbr;
 286   unsigned int new_ix, old_ix;
 287   darwin_inferior *darwin_inf = inf->priv;
 288   VEC (darwin_thread_t) *thread_vec;
 289
 290   /* Get list of threads.  */
 291   kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
 292   MACH_CHECK_ERROR (kret);
 293   if (kret != KERN_SUCCESS)
 294     return;
 295
 296   /* Sort the list.  */
 297   if (new_nbr > 1)
 298     qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
 299
 300   if (darwin_inf->threads)
 301     old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
 302   else
 303     old_nbr = 0;
 304
 305   /* Quick check for no changes.  */
 306   if (old_nbr == new_nbr)
 307     {
 308       for (i = 0; i < new_nbr; i++)
 309         if (thread_list[i]
 310             != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
 311           break;
 312       if (i == new_nbr)
 313         {
 314           /* Deallocate ports.  */
 315           for (i = 0; i < new_nbr; i++)
 316             {
 317               kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
 318               MACH_CHECK_ERROR (kret);
 319             }
 320
 321           /* Deallocate the buffer.  */
 322           kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 323                                 new_nbr * sizeof (int));
 324           MACH_CHECK_ERROR (kret);
 325
 326           return;
 327         }
 328     }
 329
 330   /* Full handling: detect new threads, remove dead threads.  */
 331   thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
 332
 333   for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
 334     {
 335       thread_t new_id = (new_ix < new_nbr) ?
 336         thread_list[new_ix] : THREAD_NULL;
 337       darwin_thread_t *old = (old_ix < old_nbr) ?
 338         VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
 339       thread_t old_id = old ? old->gdb_port : THREAD_NULL;
 340
 341       inferior_debug
 342         (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
 343          new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
 344
 345       if (old_id == new_id)
 346         {
 347           /* Thread still exist.  */
 348           VEC_safe_push (darwin_thread_t, thread_vec, old);
 349           new_ix++;
 350           old_ix++;
 351
 352           /* Deallocate the port.  */
 353           kret = mach_port_deallocate (gdb_task, new_id);
 354           MACH_CHECK_ERROR (kret);
 355
 356           continue;
 357         }
 358       if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
 359         {
 360           /* Ignore dead ports.
 361              In some weird cases, we might get dead ports.  They should
 362              correspond to dead thread so they could safely be ignored.  */
 363           new_ix++;
 364           continue;
 365         }
 366       if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
 367         {
 368           /* A thread was created.  */
 369           struct private_thread_info *pti;
 370
 371           pti = XCNEW (struct private_thread_info);
 372           pti->gdb_port = new_id;
 373           pti->msg_state = DARWIN_RUNNING;
 374
 375           /* Add the new thread.  */
 376           add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
 377           VEC_safe_push (darwin_thread_t, thread_vec, pti);
 378           new_ix++;
 379           continue;
 380         }
 381       if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
 382         {
 383           /* A thread was removed.  */
 384           delete_thread (ptid_build (inf->pid, 0, old_id));
 385           kret = mach_port_deallocate (gdb_task, old_id);
 386           MACH_CHECK_ERROR (kret);
 387           old_ix++;
 388           continue;
 389         }
 390       gdb_assert_not_reached ("unexpected thread case");
 391     }
 392
 393   if (darwin_inf->threads)
 394     VEC_free (darwin_thread_t, darwin_inf->threads);
 395   darwin_inf->threads = thread_vec;
 396
 397   /* Deallocate the buffer.  */
 398   kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
 399                         new_nbr * sizeof (int));
 400   MACH_CHECK_ERROR (kret);
 401 }
 402
 403 static int
 404 find_inferior_task_it (struct inferior *inf, void *port_ptr)
 405 {
 406   return inf->priv->task == *(task_t *)port_ptr;
 407 }
 408
 409 static int
 410 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
 411 {
 412   return inf->pid == *(int *)pid_ptr;
 413 }
 414
 415 /* Return an inferior by task port.  */
 416 static struct inferior *
 417 darwin_find_inferior_by_task (task_t port)
 418 {
 419   return iterate_over_inferiors (&find_inferior_task_it, &port);
 420 }
 421
 422 /* Return an inferior by pid port.  */
 423 static struct inferior *
 424 darwin_find_inferior_by_pid (int pid)
 425 {
 426   return iterate_over_inferiors (&find_inferior_pid_it, &pid);
 427 }
 428
 429 /* Return a thread by port.  */
 430 static darwin_thread_t *
 431 darwin_find_thread (struct inferior *inf, thread_t thread)
 432 {
 433   darwin_thread_t *t;
 434   int k;
 435
 436   for (k = 0;
 437        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
 438        k++)
 439     if (t->gdb_port == thread)
 440       return t;
 441   return NULL;
 442 }
 443
 444 /* Suspend (ie stop) an inferior at Mach level.  */
 445
 446 static void
 447 darwin_suspend_inferior (struct inferior *inf)
 448 {
 449   if (!inf->priv->suspended)
 450     {
 451       kern_return_t kret;
 452
 453       kret = task_suspend (inf->priv->task);
 454       MACH_CHECK_ERROR (kret);
 455
 456       inf->priv->suspended = 1;
 457     }
 458 }
 459
 460 /* Resume an inferior at Mach level.  */
 461
 462 static void
 463 darwin_resume_inferior (struct inferior *inf)
 464 {
 465   if (inf->priv->suspended)
 466     {
 467       kern_return_t kret;
 468
 469       kret = task_resume (inf->priv->task);
 470       MACH_CHECK_ERROR (kret);
 471
 472       inf->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   /* Deallocate saved exception ports.  */
 584   darwin_deallocate_exception_ports (inf->priv);
 585
 586   /* No need to remove dead_name notification, but still...  */
 587   kret = mach_port_request_notification (gdb_task, inf->priv->task,
 588                                          MACH_NOTIFY_DEAD_NAME, 0,
 589                                          MACH_PORT_NULL,
 590                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
 591                                          &prev);
 592   if (kret != KERN_INVALID_ARGUMENT)
 593     MACH_CHECK_ERROR (kret);
 594
 595   /* Replace old task port.  */
 596   kret = mach_port_deallocate (gdb_task, inf->priv->task);
 597   MACH_CHECK_ERROR (kret);
 598   inf->priv->task = task_port;
 599
 600   darwin_setup_request_notification (inf);
 601   darwin_setup_exceptions (inf);
 602
 603   return inf;
 604 }
 605
 606 /* Check data representation.  */
 607
 608 static int
 609 darwin_check_message_ndr (NDR_record_t *ndr)
 610 {
 611   if (ndr->mig_vers != NDR_PROTOCOL_2_0
 612       || ndr->if_vers != NDR_PROTOCOL_2_0
 613       || ndr->mig_encoding != NDR_record.mig_encoding
 614       || ndr->int_rep != NDR_record.int_rep
 615       || ndr->char_rep != NDR_record.char_rep
 616       || ndr->float_rep != NDR_record.float_rep)
 617     return -1;
 618   return 0;
 619 }
 620
 621 /* Decode an exception message.  */
 622
 623 static int
 624 darwin_decode_exception_message (mach_msg_header_t *hdr,
 625                                  struct inferior **pinf,
 626                                  darwin_thread_t **pthread)
 627 {
 628   mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
 629   mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
 630   NDR_record_t *ndr;
 631   integer_t *data;
 632   struct inferior *inf;
 633   darwin_thread_t *thread;
 634   task_t task_port;
 635   thread_t thread_port;
 636   kern_return_t kret;
 637   int i;
 638
 639   /* Check message destination.  */
 640   if (hdr->msgh_local_port != darwin_ex_port)
 641     return -1;
 642
 643   /* Check message header.  */
 644   if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
 645     return -1;
 646
 647   /* Check descriptors.  */
 648   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
 649                         + sizeof (*ndr) + 2 * sizeof (integer_t))
 650       || bod->msgh_descriptor_count != 2
 651       || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
 652       || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
 653       || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
 654       || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
 655     return -1;
 656
 657   /* Check data representation.  */
 658   ndr = (NDR_record_t *)(desc + 2);
 659   if (darwin_check_message_ndr (ndr) != 0)
 660     return -1;
 661
 662   /* Ok, the hard work.  */
 663   data = (integer_t *)(ndr + 1);
 664
 665   task_port = desc[1].name;
 666   thread_port = desc[0].name;
 667
 668   /* Find process by port.  */
 669   inf = darwin_find_inferior_by_task (task_port);
 670   *pinf = inf;
 671
 672   if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
 673       && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
 674     {
 675       /* Not a known inferior, but a sigtrap.  This happens on darwin 16.1.0,
 676          as a new Mach task is created when a process exec.  */
 677       inf = darwin_find_new_inferior (task_port, thread_port);
 678       *pinf = inf;
 679
 680       if (inf == NULL)
 681         {
 682           /* Deallocate task_port, unless it was saved.  */
 683           kret = mach_port_deallocate (mach_task_self (), task_port);
 684           MACH_CHECK_ERROR (kret);
 685         }
 686     }
 687   else
 688     {
 689       /* We got new rights to the task, get rid of it.  Do not get rid of
 690          thread right, as we will need it to find the thread.  */
 691       kret = mach_port_deallocate (mach_task_self (), task_port);
 692       MACH_CHECK_ERROR (kret);
 693     }
 694
 695   if (inf == NULL)
 696     {
 697       /* Not a known inferior.  This could happen if the child fork, as
 698          the created process will inherit its exception port.
 699          FIXME: should the exception port be restored ?  */
 700       kern_return_t kret;
 701       mig_reply_error_t reply;
 702
 703       inferior_debug
 704         (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
 705          task_port);
 706
 707       /* Free thread port (we don't know it).  */
 708       kret = mach_port_deallocate (mach_task_self (), thread_port);
 709       MACH_CHECK_ERROR (kret);
 710
 711       darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
 712
 713       kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
 714                        reply.Head.msgh_size, 0,
 715                        MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 716                        MACH_PORT_NULL);
 717       MACH_CHECK_ERROR (kret);
 718
 719       return 0;
 720     }
 721
 722   /* Find thread by port.  */
 723   /* Check for new threads.  Do it early so that the port in the exception
 724      message can be deallocated.  */
 725   darwin_check_new_threads (inf);
 726
 727   /* Free the thread port (as gdb knows the thread, it has already has a right
 728      for it, so this just decrement a reference counter).  */
 729   kret = mach_port_deallocate (mach_task_self (), thread_port);
 730   MACH_CHECK_ERROR (kret);
 731
 732   thread = darwin_find_thread (inf, thread_port);
 733   if (thread == NULL)
 734     return -1;
 735   *pthread = thread;
 736
 737   /* The thread should be running.  However we have observed cases where a
 738      thread got a SIGTTIN message after being stopped.  */
 739   gdb_assert (thread->msg_state != DARWIN_MESSAGE);
 740
 741   /* Finish decoding.  */
 742   thread->event.header = *hdr;
 743   thread->event.thread_port = thread_port;
 744   thread->event.task_port = task_port;
 745   thread->event.ex_type = data[0];
 746   thread->event.data_count = data[1];
 747
 748   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
 749                         + sizeof (*ndr) + 2 * sizeof (integer_t)
 750                         + data[1] * sizeof (integer_t)))
 751       return -1;
 752   for (i = 0; i < data[1]; i++)
 753     thread->event.ex_data[i] = data[2 + i];
 754
 755   thread->msg_state = DARWIN_MESSAGE;
 756
 757   return 0;
 758 }
 759
 760 /* Decode dead_name notify message.  */
 761
 762 static int
 763 darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
 764 {
 765   NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
 766   integer_t *data = (integer_t *)(ndr + 1);
 767   struct inferior *inf;
 768   darwin_thread_t *thread;
 769   task_t task_port;
 770   thread_t thread_port;
 771   kern_return_t kret;
 772   int i;
 773
 774   /* Check message header.  */
 775   if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
 776     return -1;
 777
 778   /* Check descriptors.  */
 779   if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
 780     return -2;
 781
 782   /* Check data representation.  */
 783   if (darwin_check_message_ndr (ndr) != 0)
 784     return -3;
 785
 786   task_port = data[0];
 787
 788   /* Find process by port.  */
 789   inf = darwin_find_inferior_by_task (task_port);
 790   *pinf = inf;
 791
 792   /* Check message destination.  */
 793   if (inf != NULL && hdr->msgh_local_port != inf->priv->notify_port)
 794     return -4;
 795
 796   return 0;
 797 }
 798
 799 static void
 800 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
 801                      integer_t code)
 802 {
 803   mach_msg_header_t *rh = &reply->Head;
 804
 805   rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
 806   rh->msgh_remote_port = hdr->msgh_remote_port;
 807   rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
 808   rh->msgh_local_port = MACH_PORT_NULL;
 809   rh->msgh_id = hdr->msgh_id + 100;
 810
 811   reply->NDR = NDR_record;
 812   reply->RetCode = code;
 813 }
 814
 815 static void
 816 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
 817 {
 818   kern_return_t kret;
 819   mig_reply_error_t reply;
 820
 821   darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
 822
 823   kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
 824                    reply.Head.msgh_size, 0,
 825                    MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
 826                    MACH_PORT_NULL);
 827   MACH_CHECK_ERROR (kret);
 828
 829   inf->priv->pending_messages--;
 830 }
 831
 832 static void
 833 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
 834                       int step, int nsignal)
 835 {
 836   kern_return_t kret;
 837   int res;
 838
 839   inferior_debug
 840     (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
 841      thread->msg_state, thread->gdb_port, step, nsignal);
 842
 843   switch (thread->msg_state)
 844     {
 845     case DARWIN_MESSAGE:
 846       if (thread->event.ex_type == EXC_SOFTWARE
 847           && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
 848         {
 849           /* Either deliver a new signal or cancel the signal received.  */
 850           res = PTRACE (PT_THUPDATE, inf->pid,
 851                         (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
 852           if (res < 0)
 853             inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
 854         }
 855       else if (nsignal)
 856         {
 857           /* Note: ptrace is allowed only if the process is stopped.
 858              Directly send the signal to the thread.  */
 859           res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
 860           inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
 861                           thread->gdb_port, nsignal, res);
 862           thread->signaled = 1;
 863         }
 864
 865       /* Set or reset single step.  */
 866       inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
 867                       thread->gdb_port, step);
 868       darwin_set_sstep (thread->gdb_port, step);
 869       thread->single_step = step;
 870
 871       darwin_send_reply (inf, thread);
 872       thread->msg_state = DARWIN_RUNNING;
 873       break;
 874
 875     case DARWIN_RUNNING:
 876       break;
 877
 878     case DARWIN_STOPPED:
 879       kret = thread_resume (thread->gdb_port);
 880       MACH_CHECK_ERROR (kret);
 881
 882       thread->msg_state = DARWIN_RUNNING;
 883       break;
 884     }
 885 }
 886
 887 /* Resume all threads of the inferior.  */
 888
 889 static void
 890 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
 891 {
 892   darwin_thread_t *thread;
 893   int k;
 894
 895   for (k = 0;
 896        VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
 897        k++)
 898     darwin_resume_thread (inf, thread, step, nsignal);
 899 }
 900
 901 struct resume_inferior_threads_param
 902 {
 903   int step;
 904   int nsignal;
 905 };
 906
 907 static int
 908 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
 909 {
 910   int step = ((struct resume_inferior_threads_param *)param)->step;
 911   int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
 912
 913   darwin_resume_inferior_threads (inf, step, nsignal);
 914
 915   return 0;
 916 }
 917
 918 /* Suspend all threads of INF.  */
 919
 920 static void
 921 darwin_suspend_inferior_threads (struct inferior *inf)
 922 {
 923   darwin_thread_t *thread;
 924   kern_return_t kret;
 925   int k;
 926
 927   for (k = 0;
 928        VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
 929        k++)
 930     switch (thread->msg_state)
 931       {
 932       case DARWIN_STOPPED:
 933       case DARWIN_MESSAGE:
 934         break;
 935       case DARWIN_RUNNING:
 936         kret = thread_suspend (thread->gdb_port);
 937         MACH_CHECK_ERROR (kret);
 938         thread->msg_state = DARWIN_STOPPED;
 939         break;
 940       }
 941 }
 942
 943 static void
 944 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
 945 {
 946   struct target_waitstatus status;
 947   int pid;
 948
 949   kern_return_t kret;
 950   int res;
 951   int nsignal;
 952   struct inferior *inf;
 953
 954   inferior_debug
 955     (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
 956      ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
 957
 958   if (signal == GDB_SIGNAL_0)
 959     nsignal = 0;
 960   else
 961     nsignal = gdb_signal_to_host (signal);
 962
 963   /* Don't try to single step all threads.  */
 964   if (step)
 965     ptid = inferior_ptid;
 966
 967   /* minus_one_ptid is RESUME_ALL.  */
 968   if (ptid_equal (ptid, minus_one_ptid))
 969     {
 970       struct resume_inferior_threads_param param;
 971
 972       param.nsignal = nsignal;
 973       param.step = step;
 974
 975       /* Resume threads.  */
 976       iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
 977       /* Resume tasks.  */
 978       iterate_over_inferiors (darwin_resume_inferior_it, NULL);
 979     }
 980   else
 981     {
 982       struct inferior *inf = find_inferior_ptid (ptid);
 983       long tid = ptid_get_tid (ptid);
 984
 985       /* Stop the inferior (should be useless).  */
 986       darwin_suspend_inferior (inf);
 987
 988       if (tid == 0)
 989         darwin_resume_inferior_threads (inf, step, nsignal);
 990       else
 991         {
 992           darwin_thread_t *thread;
 993
 994           /* Suspend threads of the task.  */
 995           darwin_suspend_inferior_threads (inf);
 996
 997           /* Resume the selected thread.  */
 998           thread = darwin_find_thread (inf, tid);
 999           gdb_assert (thread);
1000           darwin_resume_thread (inf, thread, step, nsignal);
1001         }
1002
1003       /* Resume the task.  */
1004       darwin_resume_inferior (inf);
1005     }
1006 }
1007
1008 static void
1009 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
1010                   enum gdb_signal signal)
1011 {
1012   return darwin_resume (ptid, step, signal);
1013 }
1014
1015 static ptid_t
1016 darwin_decode_message (mach_msg_header_t *hdr,
1017                        darwin_thread_t **pthread,
1018                        struct inferior **pinf,
1019                        struct target_waitstatus *status)
1020 {
1021   darwin_thread_t *thread;
1022   struct inferior *inf;
1023
1024   /* Exception message.  2401 == 0x961 is exc.  */
1025   if (hdr->msgh_id == 2401)
1026     {
1027       int res;
1028
1029       /* Decode message.  */
1030       res = darwin_decode_exception_message (hdr, &inf, &thread);
1031
1032       if (res < 0)
1033         {
1034           /* Should not happen...  */
1035           printf_unfiltered
1036             (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
1037           /* FIXME: send a failure reply?  */
1038           status->kind = TARGET_WAITKIND_IGNORE;
1039           return minus_one_ptid;
1040         }
1041       if (inf == NULL)
1042         {
1043           status->kind = TARGET_WAITKIND_IGNORE;
1044           return minus_one_ptid;
1045         }
1046       *pinf = inf;
1047       *pthread = thread;
1048       inf->priv->pending_messages++;
1049
1050       status->kind = TARGET_WAITKIND_STOPPED;
1051       thread->msg_state = DARWIN_MESSAGE;
1052
1053       inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1054                       thread->gdb_port,
1055                       unparse_exception_type (thread->event.ex_type));
1056
1057       switch (thread->event.ex_type)
1058         {
1059         case EXC_BAD_ACCESS:
1060           status->value.sig = GDB_EXC_BAD_ACCESS;
1061           break;
1062         case EXC_BAD_INSTRUCTION:
1063           status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1064           break;
1065         case EXC_ARITHMETIC:
1066           status->value.sig = GDB_EXC_ARITHMETIC;
1067           break;
1068         case EXC_EMULATION:
1069           status->value.sig = GDB_EXC_EMULATION;
1070           break;
1071         case EXC_SOFTWARE:
1072           if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1073             {
1074               status->value.sig =
1075                 gdb_signal_from_host (thread->event.ex_data[1]);
1076               inferior_debug (5, _("  (signal %d: %s)\n"),
1077                               thread->event.ex_data[1],
1078                               gdb_signal_to_name (status->value.sig));
1079
1080               /* If the thread is stopped because it has received a signal
1081                  that gdb has just sent, continue.  */
1082               if (thread->signaled)
1083                 {
1084                   thread->signaled = 0;
1085                   darwin_send_reply (inf, thread);
1086                   thread->msg_state = DARWIN_RUNNING;
1087                   status->kind = TARGET_WAITKIND_IGNORE;
1088                 }
1089             }
1090           else
1091             status->value.sig = GDB_EXC_SOFTWARE;
1092           break;
1093         case EXC_BREAKPOINT:
1094           /* Many internal GDB routines expect breakpoints to be reported
1095              as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1096              as a spurious signal.  */
1097           status->value.sig = GDB_SIGNAL_TRAP;
1098           break;
1099         default:
1100           status->value.sig = GDB_SIGNAL_UNKNOWN;
1101           break;
1102         }
1103
1104       return ptid_build (inf->pid, 0, thread->gdb_port);
1105     }
1106   else if (hdr->msgh_id == 0x48)
1107     {
1108       /* MACH_NOTIFY_DEAD_NAME: notification for exit.  */
1109       int res;
1110
1111       res = darwin_decode_notify_message (hdr, &inf);
1112
1113       if (res < 0)
1114         {
1115           /* Should not happen...  */
1116           printf_unfiltered
1117             (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1118              hdr->msgh_id, res);
1119         }
1120
1121       *pinf = NULL;
1122       *pthread = NULL;
1123
1124       if (res < 0 || inf == NULL)
1125         {
1126           status->kind = TARGET_WAITKIND_IGNORE;
1127           return minus_one_ptid;
1128         }
1129
1130       if (inf != NULL)
1131         {
1132           if (!inf->priv->no_ptrace)
1133             {
1134               pid_t res;
1135               int wstatus;
1136
1137               res = wait4 (inf->pid, &wstatus, 0, NULL);
1138               if (res < 0 || res != inf->pid)
1139                 {
1140                   printf_unfiltered (_("wait4: res=%d: %s\n"),
1141                                      res, safe_strerror (errno));
1142                   status->kind = TARGET_WAITKIND_IGNORE;
1143                   return minus_one_ptid;
1144                 }
1145               if (WIFEXITED (wstatus))
1146                 {
1147                   status->kind = TARGET_WAITKIND_EXITED;
1148                   status->value.integer = WEXITSTATUS (wstatus);
1149                 }
1150               else
1151                 {
1152                   status->kind = TARGET_WAITKIND_SIGNALLED;
1153                   status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1154                 }
1155
1156               inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1157                               res, wstatus);
1158
1159               /* Looks necessary on Leopard and harmless...  */
1160               wait4 (inf->pid, &wstatus, 0, NULL);
1161
1162               inferior_ptid = ptid_build (inf->pid, 0, 0);
1163               return inferior_ptid;
1164             }
1165           else
1166             {
1167               inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1168               status->kind = TARGET_WAITKIND_EXITED;
1169               status->value.integer = 0; /* Don't know.  */
1170               return ptid_build (inf->pid, 0, 0);
1171             }
1172         }
1173     }
1174
1175   /* Unknown message.  */
1176   warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1177   status->kind = TARGET_WAITKIND_IGNORE;
1178   return minus_one_ptid;
1179 }
1180
1181 static int
1182 cancel_breakpoint (ptid_t ptid)
1183 {
1184   /* Arrange for a breakpoint to be hit again later.  We will handle
1185      the current event, eventually we will resume this thread, and this
1186      breakpoint will trap again.
1187
1188      If we do not do this, then we run the risk that the user will
1189      delete or disable the breakpoint, but the thread will have already
1190      tripped on it.  */
1191
1192   struct regcache *regcache = get_thread_regcache (ptid);
1193   struct gdbarch *gdbarch = regcache->arch ();
1194   CORE_ADDR pc;
1195
1196   pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1197   if (breakpoint_inserted_here_p (regcache->aspace (), pc))
1198     {
1199       inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1200                       (unsigned long) ptid_get_tid (ptid));
1201
1202       /* Back up the PC if necessary.  */
1203       if (gdbarch_decr_pc_after_break (gdbarch))
1204         regcache_write_pc (regcache, pc);
1205
1206       return 1;
1207     }
1208   return 0;
1209 }
1210
1211 static ptid_t
1212 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1213 {
1214   kern_return_t kret;
1215   union
1216   {
1217     mach_msg_header_t hdr;
1218     char data[0x100];
1219   } msgin;
1220   mach_msg_header_t *hdr = &msgin.hdr;
1221   ptid_t res;
1222   darwin_thread_t *thread;
1223   struct inferior *inf;
1224
1225   inferior_debug
1226     (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1227      ptid_get_pid (ptid), ptid_get_tid (ptid));
1228
1229   /* Handle fake stop events at first.  */
1230   if (darwin_inf_fake_stop != NULL)
1231     {
1232       inf = darwin_inf_fake_stop;
1233       darwin_inf_fake_stop = NULL;
1234
1235       status->kind = TARGET_WAITKIND_STOPPED;
1236       status->value.sig = GDB_SIGNAL_TRAP;
1237       thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1238       thread->msg_state = DARWIN_STOPPED;
1239       return ptid_build (inf->pid, 0, thread->gdb_port);
1240     }
1241
1242   do
1243     {
1244       /* set_sigint_trap (); */
1245
1246       /* Wait for a message.  */
1247       kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1248                        sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1249
1250       /* clear_sigint_trap (); */
1251
1252       if (kret == MACH_RCV_INTERRUPTED)
1253         {
1254           status->kind = TARGET_WAITKIND_IGNORE;
1255           return minus_one_ptid;
1256         }
1257
1258       if (kret != MACH_MSG_SUCCESS)
1259         {
1260           inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1261           status->kind = TARGET_WAITKIND_SPURIOUS;
1262           return minus_one_ptid;
1263         }
1264
1265       /* Debug: display message.  */
1266       if (darwin_debug_flag > 10)
1267         darwin_dump_message (hdr, darwin_debug_flag > 11);
1268
1269       res = darwin_decode_message (hdr, &thread, &inf, status);
1270       if (ptid_equal (res, minus_one_ptid))
1271         continue;
1272
1273       /* Early return in case an inferior has exited.  */
1274       if (inf == NULL)
1275         return res;
1276     }
1277   while (status->kind == TARGET_WAITKIND_IGNORE);
1278
1279   /* Stop all tasks.  */
1280   iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1281
1282   /* Read pending messages.  */
1283   while (1)
1284     {
1285       struct target_waitstatus status2;
1286       ptid_t ptid2;
1287
1288       kret = mach_msg (&msgin.hdr,
1289                        MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1290                        sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1291
1292       if (kret == MACH_RCV_TIMED_OUT)
1293         break;
1294       if (kret != MACH_MSG_SUCCESS)
1295         {
1296           inferior_debug
1297             (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1298           break;
1299         }
1300
1301       /* Debug: display message.  */
1302       if (darwin_debug_flag > 10)
1303         darwin_dump_message (hdr, darwin_debug_flag > 11);
1304
1305       ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1306
1307       if (inf != NULL && thread != NULL
1308           && thread->event.ex_type == EXC_BREAKPOINT)
1309         {
1310           if (thread->single_step
1311               || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1312             {
1313               gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1314               darwin_send_reply (inf, thread);
1315               thread->msg_state = DARWIN_RUNNING;
1316             }
1317           else
1318             inferior_debug
1319               (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1320                thread->gdb_port);
1321         }
1322       else
1323         inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1324     }
1325   return res;
1326 }
1327
1328 static ptid_t
1329 darwin_wait_to (struct target_ops *ops,
1330                 ptid_t ptid, struct target_waitstatus *status, int options)
1331 {
1332   return darwin_wait (ptid, status);
1333 }
1334
1335 static void
1336 darwin_interrupt (struct target_ops *self, ptid_t t)
1337 {
1338   struct inferior *inf = current_inferior ();
1339
1340   /* FIXME: handle in no_ptrace mode.  */
1341   gdb_assert (!inf->priv->no_ptrace);
1342   kill (inf->pid, SIGINT);
1343 }
1344
1345 /* Deallocate threads port and vector.  */
1346
1347 static void
1348 darwin_deallocate_threads (struct inferior *inf)
1349 {
1350   if (inf->priv->threads)
1351     {
1352       kern_return_t kret;
1353       int k;
1354       darwin_thread_t *t;
1355       for (k = 0;
1356            VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1357            k++)
1358         {
1359           kret = mach_port_deallocate (gdb_task, t->gdb_port);
1360           MACH_CHECK_ERROR (kret);
1361         }
1362       VEC_free (darwin_thread_t, inf->priv->threads);
1363       inf->priv->threads = NULL;
1364     }
1365 }
1366
1367 static void
1368 darwin_mourn_inferior (struct target_ops *ops)
1369 {
1370   struct inferior *inf = current_inferior ();
1371   kern_return_t kret;
1372   mach_port_t prev;
1373   int i;
1374
1375   /* Deallocate threads.  */
1376   darwin_deallocate_threads (inf);
1377
1378   /* Remove notify_port from darwin_port_set.  */
1379   kret = mach_port_move_member (gdb_task,
1380                                 inf->priv->notify_port, MACH_PORT_NULL);
1381   MACH_CHECK_ERROR (kret);
1382
1383   /* Remove task port dead_name notification.  */
1384   kret = mach_port_request_notification (gdb_task, inf->priv->task,
1385                                          MACH_NOTIFY_DEAD_NAME, 0,
1386                                          MACH_PORT_NULL,
1387                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1388                                          &prev);
1389   /* This can fail if the task is dead.  */
1390   inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1391                   inf->priv->task, prev, inf->priv->notify_port);
1392
1393   if (kret == KERN_SUCCESS)
1394     {
1395       kret = mach_port_deallocate (gdb_task, prev);
1396       MACH_CHECK_ERROR (kret);
1397     }
1398
1399   /* Destroy notify_port.  */
1400   kret = mach_port_destroy (gdb_task, inf->priv->notify_port);
1401   MACH_CHECK_ERROR (kret);
1402
1403   /* Deallocate saved exception ports.  */
1404   darwin_deallocate_exception_ports (inf->priv);
1405
1406   /* Deallocate task port.  */
1407   kret = mach_port_deallocate (gdb_task, inf->priv->task);
1408   MACH_CHECK_ERROR (kret);
1409
1410   xfree (inf->priv);
1411   inf->priv = NULL;
1412
1413   inf_child_mourn_inferior (ops);
1414 }
1415
1416 static void
1417 darwin_reply_to_all_pending_messages (struct inferior *inf)
1418 {
1419   int k;
1420   darwin_thread_t *t;
1421
1422   for (k = 0;
1423        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1424        k++)
1425     {
1426       if (t->msg_state == DARWIN_MESSAGE)
1427         darwin_resume_thread (inf, t, 0, 0);
1428     }
1429 }
1430
1431 static void
1432 darwin_stop_inferior (struct inferior *inf)
1433 {
1434   struct target_waitstatus wstatus;
1435   ptid_t ptid;
1436   kern_return_t kret;
1437   int status;
1438   int res;
1439
1440   gdb_assert (inf != NULL);
1441
1442   darwin_suspend_inferior (inf);
1443
1444   darwin_reply_to_all_pending_messages (inf);
1445
1446   if (inf->priv->no_ptrace)
1447     return;
1448
1449   res = kill (inf->pid, SIGSTOP);
1450   if (res != 0)
1451     warning (_("cannot kill: %s"), safe_strerror (errno));
1452
1453   /* Wait until the process is really stopped.  */
1454   while (1)
1455     {
1456       ptid = darwin_wait (inferior_ptid, &wstatus);
1457       if (wstatus.kind == TARGET_WAITKIND_STOPPED
1458           && wstatus.value.sig == GDB_SIGNAL_STOP)
1459         break;
1460     }
1461 }
1462
1463 static kern_return_t
1464 darwin_save_exception_ports (darwin_inferior *inf)
1465 {
1466   kern_return_t kret;
1467
1468   inf->exception_info.count =
1469     sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1470
1471   kret = task_get_exception_ports
1472     (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1473      &inf->exception_info.count, inf->exception_info.ports,
1474      inf->exception_info.behaviors, inf->exception_info.flavors);
1475   return kret;
1476 }
1477
1478 static kern_return_t
1479 darwin_restore_exception_ports (darwin_inferior *inf)
1480 {
1481   int i;
1482   kern_return_t kret;
1483
1484   for (i = 0; i < inf->exception_info.count; i++)
1485     {
1486       kret = task_set_exception_ports
1487         (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1488          inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1489       if (kret != KERN_SUCCESS)
1490         return kret;
1491     }
1492
1493   return KERN_SUCCESS;
1494 }
1495
1496 /* Deallocate saved exception ports.  */
1497
1498 static void
1499 darwin_deallocate_exception_ports (darwin_inferior *inf)
1500 {
1501   int i;
1502   kern_return_t kret;
1503
1504   for (i = 0; i < inf->exception_info.count; i++)
1505     {
1506       kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1507       MACH_CHECK_ERROR (kret);
1508     }
1509   inf->exception_info.count = 0;
1510 }
1511
1512 static void
1513 darwin_setup_exceptions (struct inferior *inf)
1514 {
1515   kern_return_t kret;
1516   int traps_expected;
1517   exception_mask_t mask;
1518
1519   kret = darwin_save_exception_ports (inf->priv);
1520   if (kret != KERN_SUCCESS)
1521     error (_("Unable to save exception ports, task_get_exception_ports"
1522              "returned: %d"),
1523            kret);
1524
1525   /* Set exception port.  */
1526   if (enable_mach_exceptions)
1527     mask = EXC_MASK_ALL;
1528   else
1529     mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1530   kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
1531                                    EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1532   if (kret != KERN_SUCCESS)
1533     error (_("Unable to set exception ports, task_set_exception_ports"
1534              "returned: %d"),
1535            kret);
1536 }
1537
1538 static void
1539 darwin_kill_inferior (struct target_ops *ops)
1540 {
1541   struct inferior *inf = current_inferior ();
1542   struct target_waitstatus wstatus;
1543   ptid_t ptid;
1544   kern_return_t kret;
1545   int status;
1546   int res;
1547
1548   if (ptid_equal (inferior_ptid, null_ptid))
1549     return;
1550
1551   gdb_assert (inf != NULL);
1552
1553   kret = darwin_restore_exception_ports (inf->priv);
1554   MACH_CHECK_ERROR (kret);
1555
1556   darwin_reply_to_all_pending_messages (inf);
1557
1558   res = kill (inf->pid, 9);
1559
1560   if (res == 0)
1561     {
1562       darwin_resume_inferior (inf);
1563
1564       ptid = darwin_wait (inferior_ptid, &wstatus);
1565     }
1566   else if (errno != ESRCH)
1567     warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1568              inf->pid, safe_strerror (errno));
1569
1570   target_mourn_inferior (inferior_ptid);
1571 }
1572
1573 static void
1574 darwin_setup_request_notification (struct inferior *inf)
1575 {
1576   kern_return_t kret;
1577   mach_port_t prev_not;
1578
1579   kret = mach_port_request_notification (gdb_task, inf->priv->task,
1580                                          MACH_NOTIFY_DEAD_NAME, 0,
1581                                          inf->priv->notify_port,
1582                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
1583                                          &prev_not);
1584   if (kret != KERN_SUCCESS)
1585     error (_("Termination notification request failed, "
1586              "mach_port_request_notification\n"
1587              "returned: %d"),
1588            kret);
1589   if (prev_not != MACH_PORT_NULL)
1590     {
1591       /* This is unexpected, as there should not be any previously
1592          registered notification request.  But this is not a fatal
1593          issue, so just emit a warning.  */
1594       warning (_("\
1595 A task termination request was registered before the debugger registered\n\
1596 its own.  This is unexpected, but should otherwise not have any actual\n\
1597 impact on the debugging session."));
1598     }
1599 }
1600
1601 static void
1602 darwin_attach_pid (struct inferior *inf)
1603 {
1604   kern_return_t kret;
1605   mach_port_t prev_port;
1606   int traps_expected;
1607   mach_port_t prev_not;
1608   exception_mask_t mask;
1609
1610   inf->priv = XCNEW (darwin_inferior);
1611
1612   kret = task_for_pid (gdb_task, inf->pid, &inf->priv->task);
1613   if (kret != KERN_SUCCESS)
1614     {
1615       int status;
1616
1617       if (!inf->attach_flag)
1618         {
1619           kill (inf->pid, 9);
1620           waitpid (inf->pid, &status, 0);
1621         }
1622
1623       error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1624                " (please check gdb is codesigned - see taskgated(8))"),
1625              inf->pid, mach_error_string (kret), (unsigned long) kret);
1626     }
1627
1628   inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1629                   inf->priv->task, inf->pid);
1630
1631   if (darwin_ex_port == MACH_PORT_NULL)
1632     {
1633       /* Create a port to get exceptions.  */
1634       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1635                                  &darwin_ex_port);
1636       if (kret != KERN_SUCCESS)
1637         error (_("Unable to create exception port, mach_port_allocate "
1638                  "returned: %d"),
1639                kret);
1640
1641       kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1642                                      MACH_MSG_TYPE_MAKE_SEND);
1643       if (kret != KERN_SUCCESS)
1644         error (_("Unable to create exception port, mach_port_insert_right "
1645                  "returned: %d"),
1646                kret);
1647
1648       /* Create a port set and put ex_port in it.  */
1649       kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1650                                  &darwin_port_set);
1651       if (kret != KERN_SUCCESS)
1652         error (_("Unable to create port set, mach_port_allocate "
1653                  "returned: %d"),
1654                kret);
1655
1656       kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
1657       if (kret != KERN_SUCCESS)
1658         error (_("Unable to move exception port into new port set, "
1659                  "mach_port_move_member\n"
1660                  "returned: %d"),
1661                kret);
1662     }
1663
1664   /* Create a port to be notified when the child task terminates.  */
1665   kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1666                              &inf->priv->notify_port);
1667   if (kret != KERN_SUCCESS)
1668     error (_("Unable to create notification port, mach_port_allocate "
1669              "returned: %d"),
1670            kret);
1671
1672   kret = mach_port_move_member (gdb_task,
1673                                 inf->priv->notify_port, darwin_port_set);
1674   if (kret != KERN_SUCCESS)
1675     error (_("Unable to move notification port into new port set, "
1676              "mach_port_move_member\n"
1677              "returned: %d"),
1678            kret);
1679
1680   darwin_setup_request_notification (inf);
1681
1682   darwin_setup_exceptions (inf);
1683
1684   if (!target_is_pushed (darwin_ops))
1685     push_target (darwin_ops);
1686 }
1687
1688 /* Get the thread_info object corresponding to this private_thread_info.  */
1689
1690 static struct thread_info *
1691 thread_info_from_private_thread_info (private_thread_info *pti)
1692 {
1693   struct thread_info *it;
1694
1695   ALL_THREADS (it)
1696     {
1697       if (it->priv->gdb_port == pti->gdb_port)
1698         break;
1699     }
1700
1701   gdb_assert (it != NULL);
1702
1703   return it;
1704 }
1705
1706 static void
1707 darwin_init_thread_list (struct inferior *inf)
1708 {
1709   darwin_check_new_threads (inf);
1710
1711   gdb_assert (inf->priv->threads != NULL);
1712   gdb_assert (VEC_length (darwin_thread_t, inf->priv->threads) > 0);
1713
1714   private_thread_info *first_pti
1715     = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1716   struct thread_info *first_thread
1717     = thread_info_from_private_thread_info (first_pti);
1718
1719   inferior_ptid = first_thread->ptid;
1720 }
1721
1722 /* The child must synchronize with gdb: gdb must set the exception port
1723    before the child call PTRACE_SIGEXC.  We use a pipe to achieve this.
1724    FIXME: is there a lighter way ?  */
1725 static int ptrace_fds[2];
1726
1727 static void
1728 darwin_ptrace_me (void)
1729 {
1730   int res;
1731   char c;
1732
1733   /* Close write end point.  */
1734   if (close (ptrace_fds[1]) < 0)
1735     trace_start_error_with_name ("close");
1736
1737   /* Wait until gdb is ready.  */
1738   res = read (ptrace_fds[0], &c, 1);
1739   if (res != 0)
1740     trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1741
1742   if (close (ptrace_fds[0]) < 0)
1743     trace_start_error_with_name ("close");
1744
1745   /* Get rid of privileges.  */
1746   if (setegid (getgid ()) < 0)
1747     trace_start_error_with_name ("setegid");
1748
1749   /* Set TRACEME.  */
1750   if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1751     trace_start_error_with_name ("PTRACE");
1752
1753   /* Redirect signals to exception port.  */
1754   if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1755     trace_start_error_with_name ("PTRACE");
1756 }
1757
1758 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2).  */
1759 static void
1760 darwin_pre_ptrace (void)
1761 {
1762   if (pipe (ptrace_fds) != 0)
1763     {
1764       ptrace_fds[0] = -1;
1765       ptrace_fds[1] = -1;
1766       error (_("unable to create a pipe: %s"), safe_strerror (errno));
1767     }
1768
1769   mark_fd_no_cloexec (ptrace_fds[0]);
1770   mark_fd_no_cloexec (ptrace_fds[1]);
1771 }
1772
1773 static void
1774 darwin_ptrace_him (int pid)
1775 {
1776   task_t itask;
1777   kern_return_t kret;
1778   mach_port_t prev_port;
1779   int traps_expected;
1780   struct inferior *inf = current_inferior ();
1781
1782   darwin_attach_pid (inf);
1783
1784   /* Let's the child run.  */
1785   close (ptrace_fds[0]);
1786   close (ptrace_fds[1]);
1787
1788   unmark_fd_no_cloexec (ptrace_fds[0]);
1789   unmark_fd_no_cloexec (ptrace_fds[1]);
1790
1791   darwin_init_thread_list (inf);
1792
1793   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1794 }
1795
1796 static void
1797 darwin_execvp (const char *file, char * const argv[], char * const env[])
1798 {
1799   posix_spawnattr_t attr;
1800   short ps_flags = 0;
1801   int res;
1802
1803   res = posix_spawnattr_init (&attr);
1804   if (res != 0)
1805     {
1806       fprintf_unfiltered
1807         (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1808       return;
1809     }
1810
1811   /* Do like execve: replace the image.  */
1812   ps_flags = POSIX_SPAWN_SETEXEC;
1813
1814   /* Disable ASLR.  The constant doesn't look to be available outside the
1815      kernel include files.  */
1816 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1817 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1818 #endif
1819   ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1820   res = posix_spawnattr_setflags (&attr, ps_flags);
1821   if (res != 0)
1822     {
1823       fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1824       return;
1825     }
1826
1827   posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1828 }
1829
1830 static void
1831 darwin_create_inferior (struct target_ops *ops,
1832                         const char *exec_file,
1833                         const std::string &allargs,
1834                         char **env, int from_tty)
1835 {
1836   /* Do the hard work.  */
1837   fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1838                  darwin_ptrace_him, darwin_pre_ptrace, NULL,
1839                  darwin_execvp);
1840 }
1841 \f
1842
1843 /* Set things up such that the next call to darwin_wait will immediately
1844    return a fake stop event for inferior INF.
1845
1846    This assumes that the inferior's thread list has been initialized,
1847    as it will suspend the inferior's first thread.  */
1848
1849 static void
1850 darwin_setup_fake_stop_event (struct inferior *inf)
1851 {
1852   darwin_thread_t *thread;
1853   kern_return_t kret;
1854
1855   gdb_assert (darwin_inf_fake_stop == NULL);
1856   darwin_inf_fake_stop = inf;
1857
1858   /* When detecting a fake pending stop event, darwin_wait returns
1859      an event saying that the first thread is in a DARWIN_STOPPED
1860      state.  To make that accurate, we need to suspend that thread
1861      as well.  Otherwise, we'll try resuming it when resuming the
1862      inferior, and get a warning because the thread's suspend count
1863      is already zero, making the resume request useless.  */
1864   thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1865   kret = thread_suspend (thread->gdb_port);
1866   MACH_CHECK_ERROR (kret);
1867 }
1868
1869 /* Attach to process PID, then initialize for debugging it
1870    and wait for the trace-trap that results from attaching.  */
1871 static void
1872 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1873 {
1874   pid_t pid;
1875   pid_t pid2;
1876   int wstatus;
1877   int res;
1878   struct inferior *inf;
1879   kern_return_t kret;
1880
1881   pid = parse_pid_to_attach (args);
1882
1883   if (pid == getpid ())         /* Trying to masturbate?  */
1884     error (_("I refuse to debug myself!"));
1885
1886   if (from_tty)
1887     {
1888       char *exec_file = get_exec_file (0);
1889
1890       if (exec_file)
1891         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1892                            target_pid_to_str (pid_to_ptid (pid)));
1893       else
1894         printf_unfiltered (_("Attaching to %s\n"),
1895                            target_pid_to_str (pid_to_ptid (pid)));
1896
1897       gdb_flush (gdb_stdout);
1898     }
1899
1900   if (pid == 0 || kill (pid, 0) < 0)
1901     error (_("Can't attach to process %d: %s (%d)"),
1902            pid, safe_strerror (errno), errno);
1903
1904   inferior_ptid = pid_to_ptid (pid);
1905   inf = current_inferior ();
1906   inferior_appeared (inf, pid);
1907   inf->attach_flag = 1;
1908
1909   darwin_attach_pid (inf);
1910
1911   darwin_suspend_inferior (inf);
1912
1913   darwin_init_thread_list (inf);
1914
1915   darwin_check_osabi (inf->priv, ptid_get_tid (inferior_ptid));
1916
1917   darwin_setup_fake_stop_event (inf);
1918
1919   inf->priv->no_ptrace = 1;
1920 }
1921
1922 /* Take a program previously attached to and detaches it.
1923    The program resumes execution and will no longer stop
1924    on signals, etc.  We'd better not have left any breakpoints
1925    in the program or it'll die when it hits one.  For this
1926    to work, it may be necessary for the process to have been
1927    previously attached.  It *might* work if the program was
1928    started via fork.  */
1929 static void
1930 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1931 {
1932   pid_t pid = ptid_get_pid (inferior_ptid);
1933   struct inferior *inf = current_inferior ();
1934   kern_return_t kret;
1935   int res;
1936
1937   /* Display message.  */
1938   target_announce_detach (from_tty);
1939
1940   /* If ptrace() is in use, stop the process.  */
1941   if (!inf->priv->no_ptrace)
1942     darwin_stop_inferior (inf);
1943
1944   kret = darwin_restore_exception_ports (inf->priv);
1945   MACH_CHECK_ERROR (kret);
1946
1947   if (!inf->priv->no_ptrace)
1948     {
1949       res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1950       if (res != 0)
1951         printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1952                            inf->pid, safe_strerror (errno), errno);
1953     }
1954
1955   darwin_reply_to_all_pending_messages (inf);
1956
1957   /* When using ptrace, we have just performed a PT_DETACH, which
1958      resumes the inferior.  On the other hand, when we are not using
1959      ptrace, we need to resume its execution ourselves.  */
1960   if (inf->priv->no_ptrace)
1961     darwin_resume_inferior (inf);
1962
1963   darwin_mourn_inferior (ops);
1964 }
1965
1966 static void
1967 darwin_files_info (struct target_ops *ops)
1968 {
1969 }
1970
1971 static const char *
1972 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1973 {
1974   static char buf[80];
1975   long tid = ptid_get_tid (ptid);
1976
1977   if (tid != 0)
1978     {
1979       snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1980                 tid, ptid_get_pid (ptid));
1981       return buf;
1982     }
1983
1984   return normal_pid_to_str (ptid);
1985 }
1986
1987 static int
1988 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
1989 {
1990   return 1;
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 static enum target_xfer_status
2186 darwin_xfer_partial (struct target_ops *ops,
2187                      enum target_object object, const char *annex,
2188                      gdb_byte *readbuf, const gdb_byte *writebuf,
2189                      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
2190 {
2191   struct inferior *inf = current_inferior ();
2192
2193   inferior_debug
2194     (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2195      core_addr_to_string (offset), pulongest (len),
2196      host_address_to_string (readbuf), host_address_to_string (writebuf),
2197      inf->pid);
2198
2199   switch (object)
2200     {
2201     case TARGET_OBJECT_MEMORY:
2202       {
2203         int l = darwin_read_write_inferior (inf->priv->task, offset,
2204                                             readbuf, writebuf, len);
2205
2206         if (l == 0)
2207           return TARGET_XFER_EOF;
2208         else
2209           {
2210             gdb_assert (l > 0);
2211             *xfered_len = (ULONGEST) l;
2212             return TARGET_XFER_OK;
2213           }
2214       }
2215 #ifdef TASK_DYLD_INFO_COUNT
2216     case TARGET_OBJECT_DARWIN_DYLD_INFO:
2217       if (writebuf != NULL || readbuf == NULL)
2218         {
2219           /* Support only read.  */
2220           return TARGET_XFER_E_IO;
2221         }
2222       return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
2223                                     xfered_len);
2224 #endif
2225     default:
2226       return TARGET_XFER_E_IO;
2227     }
2228
2229 }
2230
2231 static void
2232 set_enable_mach_exceptions (const char *args, int from_tty,
2233                             struct cmd_list_element *c)
2234 {
2235   if (!ptid_equal (inferior_ptid, null_ptid))
2236     {
2237       struct inferior *inf = current_inferior ();
2238       exception_mask_t mask;
2239       kern_return_t kret;
2240
2241       if (enable_mach_exceptions)
2242         mask = EXC_MASK_ALL;
2243       else
2244         {
2245           darwin_restore_exception_ports (inf->priv);
2246           mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2247         }
2248       kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
2249                                        EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2250       MACH_CHECK_ERROR (kret);
2251     }
2252 }
2253
2254 static char *
2255 darwin_pid_to_exec_file (struct target_ops *self, int pid)
2256 {
2257   static char path[PATH_MAX];
2258   int res;
2259
2260   res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2261   if (res >= 0)
2262     return path;
2263   else
2264     return NULL;
2265 }
2266
2267 static ptid_t
2268 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2269 {
2270   int i;
2271   darwin_thread_t *t;
2272   int k;
2273   struct inferior *inf = current_inferior ();
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 (k = 0;
2283        VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2284        k++)
2285     if (t->inf_port == lwp)
2286       return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2287
2288   /* Maybe the port was never extract.  Do it now.  */
2289
2290   /* First get inferior port names.  */
2291   kret = mach_port_names (inf->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 (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 (inf->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 (k = 0;
2315            VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2316            k++)
2317         if (t->gdb_port == local_name)
2318           {
2319             t->inf_port = names[i];
2320             if (names[i] == lwp)
2321               res = t->gdb_port;
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_build (ptid_get_pid (inferior_ptid), 0, res);
2330   else
2331     return null_ptid;
2332 }
2333
2334 static int
2335 darwin_supports_multi_process (struct target_ops *self)
2336 {
2337   return 1;
2338 }
2339
2340 void
2341 _initialize_darwin_inferior (void)
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   darwin_ops = inf_child_target ();
2357
2358   darwin_ops->to_create_inferior = darwin_create_inferior;
2359   darwin_ops->to_attach = darwin_attach;
2360   darwin_ops->to_attach_no_wait = 0;
2361   darwin_ops->to_detach = darwin_detach;
2362   darwin_ops->to_files_info = darwin_files_info;
2363   darwin_ops->to_wait = darwin_wait_to;
2364   darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2365   darwin_ops->to_kill = darwin_kill_inferior;
2366   darwin_ops->to_interrupt = darwin_interrupt;
2367   darwin_ops->to_resume = darwin_resume_to;
2368   darwin_ops->to_thread_alive = darwin_thread_alive;
2369   darwin_ops->to_pid_to_str = darwin_pid_to_str;
2370   darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
2371   darwin_ops->to_load = NULL;
2372   darwin_ops->to_xfer_partial = darwin_xfer_partial;
2373   darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2374   darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
2375
2376   darwin_complete_target (darwin_ops);
2377
2378   add_target (darwin_ops);
2379
2380   inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2381                   (unsigned long) mach_task_self (), getpid ());
2382
2383   add_setshow_zuinteger_cmd ("darwin", class_obscure,
2384                              &darwin_debug_flag, _("\
2385 Set if printing inferior communication debugging statements."), _("\
2386 Show if printing inferior communication debugging statements."), NULL,
2387                              NULL, NULL,
2388                              &setdebuglist, &showdebuglist);
2389
2390   add_setshow_boolean_cmd ("mach-exceptions", class_support,
2391                            &enable_mach_exceptions, _("\
2392 Set if mach exceptions are caught."), _("\
2393 Show if mach exceptions are caught."), _("\
2394 When this mode is on, all low level exceptions are reported before being\n\
2395 reported by the kernel."),
2396                            &set_enable_mach_exceptions, NULL,
2397                            &setlist, &showlist);
2398 }