GDB (xrefs)
/tmp/gdb-7.10/gdb/darwin-nat.c
Go to the documentation of this file.
1 /* Darwin support for GDB, the GNU debugger.
2  Copyright (C) 2008-2015 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 "gdb.h"
29 #include "gdbcmd.h"
30 #include "gdbcore.h"
31 #include "gdbthread.h"
32 #include "regcache.h"
33 #include "event-top.h"
34 #include "inf-loop.h"
35 #include <sys/stat.h>
36 #include "inf-child.h"
37 #include "value.h"
38 #include "arch-utils.h"
39 #include "bfd.h"
40 #include "bfd/mach-o.h"
41 
42 #include <sys/ptrace.h>
43 #include <sys/signal.h>
44 #include <setjmp.h>
45 #include <sys/types.h>
46 #include <unistd.h>
47 #include <signal.h>
48 #include <ctype.h>
49 #include <sys/sysctl.h>
50 #include <sys/proc.h>
51 #include <libproc.h>
52 #include <sys/syscall.h>
53 #include <spawn.h>
54 
55 #include <mach/mach_error.h>
56 #include <mach/mach_vm.h>
57 #include <mach/mach_init.h>
58 #include <mach/vm_map.h>
59 #include <mach/task.h>
60 #include <mach/mach_port.h>
61 #include <mach/thread_act.h>
62 #include <mach/port.h>
63 
64 #include "darwin-nat.h"
65 #include "common/filestuff.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_stop (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);
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, char *exec_file,
106  char *allargs, char **env, int from_tty);
107 
108 static void darwin_files_info (struct target_ops *ops);
109 
110 static char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
111 
112 static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
113 
114 static void darwin_encode_reply (mig_reply_error_t *reply,
115  mach_msg_header_t *hdr, integer_t code);
116 
117 /* Target operations for Darwin. */
118 static struct target_ops *darwin_ops;
119 
120 /* Task identifier of gdb. */
121 static task_t gdb_task;
122 
123 /* A copy of mach_host_self (). */
124 mach_port_t darwin_host_self;
125 
126 /* Exception port. */
127 mach_port_t darwin_ex_port;
128 
129 /* Port set, to wait for answer on all ports. */
130 mach_port_t darwin_port_set;
131 
132 /* Page size. */
133 static vm_size_t mach_page_size;
134 
135 /* If Set, catch all mach exceptions (before they are converted to signals
136  by the kernel). */
138 
139 /* Inferior that should report a fake stop event. */
141 
142 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
143 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
144 
145 /* This controls output of inferior debugging. */
146 static unsigned int darwin_debug_flag = 0;
147 
148 /* Create a __TEXT __info_plist section in the executable so that gdb could
149  be signed. This is required to get an authorization for task_for_pid.
150 
151  Once gdb is built, you must codesign it with any system-trusted signing
152  authority. See taskgated(8) for details. */
153 static const unsigned char info_plist[]
154 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
155  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
156  "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
157  " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
158  "<plist version=\"1.0\">\n"
159  "<dict>\n"
160  " <key>CFBundleIdentifier</key>\n"
161  " <string>org.gnu.gdb</string>\n"
162  " <key>CFBundleName</key>\n"
163  " <string>gdb</string>\n"
164  " <key>CFBundleVersion</key>\n"
165  " <string>1.0</string>\n"
166  " <key>SecTaskAccess</key>\n"
167  " <array>\n"
168  " <string>allowed</string>\n"
169  " <string>debug</string>\n"
170  " </array>\n"
171  "</dict>\n"
172  "</plist>\n";
173 
174 static void inferior_debug (int level, const char *fmt, ...)
175  ATTRIBUTE_PRINTF (2, 3);
176 
177 static void
178 inferior_debug (int level, const char *fmt, ...)
179 {
180  va_list ap;
181 
182  if (darwin_debug_flag < level)
183  return;
184 
185  va_start (ap, fmt);
186  printf_unfiltered (_("[%d inferior]: "), getpid ());
187  vprintf_unfiltered (fmt, ap);
188  va_end (ap);
189 }
190 
191 void
192 mach_check_error (kern_return_t ret, const char *file,
193  unsigned int line, const char *func)
194 {
195  if (ret == KERN_SUCCESS)
196  return;
197  if (func == NULL)
198  func = _("[UNKNOWN]");
199 
200  warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
201  file, line, func, mach_error_string (ret), (unsigned long) ret);
202 }
203 
204 static const char *
205 unparse_exception_type (unsigned int i)
206 {
207  static char unknown_exception_buf[32];
208 
209  switch (i)
210  {
211  case EXC_BAD_ACCESS:
212  return "EXC_BAD_ACCESS";
213  case EXC_BAD_INSTRUCTION:
214  return "EXC_BAD_INSTRUCTION";
215  case EXC_ARITHMETIC:
216  return "EXC_ARITHMETIC";
217  case EXC_EMULATION:
218  return "EXC_EMULATION";
219  case EXC_SOFTWARE:
220  return "EXC_SOFTWARE";
221  case EXC_BREAKPOINT:
222  return "EXC_BREAKPOINT";
223  case EXC_SYSCALL:
224  return "EXC_SYSCALL";
225  case EXC_MACH_SYSCALL:
226  return "EXC_MACH_SYSCALL";
227  case EXC_RPC_ALERT:
228  return "EXC_RPC_ALERT";
229  case EXC_CRASH:
230  return "EXC_CRASH";
231  default:
232  snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
233  return unknown_exception_buf;
234  }
235 }
236 
237 /* Set errno to zero, and then call ptrace with the given arguments.
238  If inferior debugging traces are on, then also print a debug
239  trace.
240 
241  The returned value is the same as the value returned by ptrace,
242  except in the case where that value is -1 but errno is zero.
243  This case is documented to be a non-error situation, so we
244  return zero in that case. */
245 
246 static int
247 darwin_ptrace (const char *name,
248  int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
249 {
250  int ret;
251 
252  errno = 0;
253  ret = ptrace (request, pid, (caddr_t) arg3, arg4);
254  if (ret == -1 && errno == 0)
255  ret = 0;
256 
257  inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
258  name, pid, arg3, arg4, ret,
259  (ret != 0) ? safe_strerror (errno) : _("no error"));
260  return ret;
261 }
262 
263 static int
264 cmp_thread_t (const void *l, const void *r)
265 {
266  thread_t tl = *(const thread_t *)l;
267  thread_t tr = *(const thread_t *)r;
268  return (int)(tl - tr);
269 }
270 
271 static void
273 {
274  kern_return_t kret;
275  unsigned int i;
276  thread_array_t thread_list;
277  unsigned int new_nbr;
278  unsigned int old_nbr;
279  unsigned int new_ix, old_ix;
280  darwin_inferior *darwin_inf = inf->priv;
281  VEC (darwin_thread_t) *thread_vec;
282 
283  /* Get list of threads. */
284  kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
285  MACH_CHECK_ERROR (kret);
286  if (kret != KERN_SUCCESS)
287  return;
288 
289  /* Sort the list. */
290  if (new_nbr > 1)
291  qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
292 
293  if (darwin_inf->threads)
294  old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
295  else
296  old_nbr = 0;
297 
298  /* Quick check for no changes. */
299  if (old_nbr == new_nbr)
300  {
301  for (i = 0; i < new_nbr; i++)
302  if (thread_list[i]
303  != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
304  break;
305  if (i == new_nbr)
306  {
307  /* Deallocate ports. */
308  for (i = 0; i < new_nbr; i++)
309  {
310  kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
311  MACH_CHECK_ERROR (kret);
312  }
313 
314  /* Deallocate the buffer. */
315  kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
316  new_nbr * sizeof (int));
317  MACH_CHECK_ERROR (kret);
318 
319  return;
320  }
321  }
322 
323  thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
324 
325  for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
326  {
327  thread_t new_id = (new_ix < new_nbr) ?
328  thread_list[new_ix] : THREAD_NULL;
329  darwin_thread_t *old = (old_ix < old_nbr) ?
330  VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
331  thread_t old_id = old ? old->gdb_port : THREAD_NULL;
332 
334  (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
335  new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
336 
337  if (old_id == new_id)
338  {
339  /* Thread still exist. */
340  VEC_safe_push (darwin_thread_t, thread_vec, old);
341  new_ix++;
342  old_ix++;
343 
344  /* Deallocate the port. */
345  kret = mach_port_deallocate (gdb_task, new_id);
346  MACH_CHECK_ERROR (kret);
347 
348  continue;
349  }
350  if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
351  {
352  /* Ignore dead ports.
353  In some weird cases, we might get dead ports. They should
354  correspond to dead thread so they could safely be ignored. */
355  new_ix++;
356  continue;
357  }
358  if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
359  {
360  /* A thread was created. */
361  struct thread_info *tp;
362  struct private_thread_info *pti;
363 
364  pti = XCNEW (struct private_thread_info);
365  pti->gdb_port = new_id;
366  pti->msg_state = DARWIN_RUNNING;
367 
368  /* Add a new thread unless this is the first one ever met. */
369  if (!(old_nbr == 0 && new_ix == 0))
370  tp = add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
371  else
372  {
373  tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));
374  gdb_assert (tp);
375  tp->priv = pti;
376  }
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_notify_it (struct inferior *inf, void *port_ptr)
411 {
412  return inf->priv->notify_port == *(task_t*)port_ptr;
413 }
414 
415 /* Return an inferior by task port. */
416 static struct inferior *
418 {
420 }
421 
422 /* Return an inferior by notification port. */
423 static struct inferior *
425 {
427 }
428 
429 /* Return a thread by port. */
430 static darwin_thread_t *
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
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
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
480 {
483  return 0;
484 }
485 
486 static int
488 {
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:
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);
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 static int
561 darwin_decode_exception_message (mach_msg_header_t *hdr,
562  struct inferior **pinf,
563  darwin_thread_t **pthread)
564 {
565  mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
566  mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
567  NDR_record_t *ndr;
568  integer_t *data;
569  struct inferior *inf;
570  darwin_thread_t *thread;
571  task_t task_port;
572  thread_t thread_port;
573  kern_return_t kret;
574  int i;
575 
576  /* Check message destination. */
577  if (hdr->msgh_local_port != darwin_ex_port)
578  return -1;
579 
580  /* Check message header. */
581  if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
582  return -1;
583 
584  /* Check descriptors. */
585  if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
586  + sizeof (*ndr) + 2 * sizeof (integer_t))
587  || bod->msgh_descriptor_count != 2
588  || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
589  || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
590  || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
591  || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
592  return -1;
593 
594  /* Check data representation. */
595  ndr = (NDR_record_t *)(desc + 2);
596  if (ndr->mig_vers != NDR_PROTOCOL_2_0
597  || ndr->if_vers != NDR_PROTOCOL_2_0
598  || ndr->mig_encoding != NDR_record.mig_encoding
599  || ndr->int_rep != NDR_record.int_rep
600  || ndr->char_rep != NDR_record.char_rep
601  || ndr->float_rep != NDR_record.float_rep)
602  return -1;
603 
604  /* Ok, the hard work. */
605  data = (integer_t *)(ndr + 1);
606 
607  task_port = desc[1].name;
608  thread_port = desc[0].name;
609 
610  /* We got new rights to the task, get rid of it. Do not get rid of thread
611  right, as we will need it to find the thread. */
612  kret = mach_port_deallocate (mach_task_self (), task_port);
613  MACH_CHECK_ERROR (kret);
614 
615  /* Find process by port. */
616  inf = darwin_find_inferior_by_task (task_port);
617  *pinf = inf;
618  if (inf == NULL)
619  {
620  /* Not a known inferior. This could happen if the child fork, as
621  the created process will inherit its exception port.
622  FIXME: should the exception port be restored ? */
623  kern_return_t kret;
624  mig_reply_error_t reply;
625 
626  /* Free thread port (we don't know it). */
627  kret = mach_port_deallocate (mach_task_self (), thread_port);
628  MACH_CHECK_ERROR (kret);
629 
630  darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
631 
632  kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
633  reply.Head.msgh_size, 0,
634  MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
635  MACH_PORT_NULL);
636  MACH_CHECK_ERROR (kret);
637 
638  return 0;
639  }
640 
641  /* Find thread by port. */
642  /* Check for new threads. Do it early so that the port in the exception
643  message can be deallocated. */
645 
646  /* Free the thread port (as gdb knows the thread, it has already has a right
647  for it, so this just decrement a reference counter). */
648  kret = mach_port_deallocate (mach_task_self (), thread_port);
649  MACH_CHECK_ERROR (kret);
650 
651  thread = darwin_find_thread (inf, thread_port);
652  if (thread == NULL)
653  return -1;
654  *pthread = thread;
655 
656  /* The thread should be running. However we have observed cases where a
657  thread got a SIGTTIN message after being stopped. */
658  gdb_assert (thread->msg_state != DARWIN_MESSAGE);
659 
660  /* Finish decoding. */
661  thread->event.header = *hdr;
662  thread->event.thread_port = thread_port;
663  thread->event.task_port = task_port;
664  thread->event.ex_type = data[0];
665  thread->event.data_count = data[1];
666 
667  if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
668  + sizeof (*ndr) + 2 * sizeof (integer_t)
669  + data[1] * sizeof (integer_t)))
670  return -1;
671  for (i = 0; i < data[1]; i++)
672  thread->event.ex_data[i] = data[2 + i];
673 
674  thread->msg_state = DARWIN_MESSAGE;
675 
676  return 0;
677 }
678 
679 static void
680 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
681  integer_t code)
682 {
683  mach_msg_header_t *rh = &reply->Head;
684 
685  rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
686  rh->msgh_remote_port = hdr->msgh_remote_port;
687  rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
688  rh->msgh_local_port = MACH_PORT_NULL;
689  rh->msgh_id = hdr->msgh_id + 100;
690 
691  reply->NDR = NDR_record;
692  reply->RetCode = code;
693 }
694 
695 static void
697 {
698  kern_return_t kret;
699  mig_reply_error_t reply;
700 
701  darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
702 
703  kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
704  reply.Head.msgh_size, 0,
705  MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
706  MACH_PORT_NULL);
707  MACH_CHECK_ERROR (kret);
708 
709  inf->priv->pending_messages--;
710 }
711 
712 static void
714  int step, int nsignal)
715 {
716  kern_return_t kret;
717  int res;
718 
720  (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
721  thread->msg_state, thread->gdb_port, step, nsignal);
722 
723  switch (thread->msg_state)
724  {
725  case DARWIN_MESSAGE:
726  if (thread->event.ex_type == EXC_SOFTWARE
727  && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
728  {
729  /* Either deliver a new signal or cancel the signal received. */
730  res = PTRACE (PT_THUPDATE, inf->pid,
731  (void *)(uintptr_t)thread->gdb_port, nsignal);
732  if (res < 0)
733  inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
734  }
735  else if (nsignal)
736  {
737  /* Note: ptrace is allowed only if the process is stopped.
738  Directly send the signal to the thread. */
739  res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
740  inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
741  thread->gdb_port, nsignal, res);
742  thread->signaled = 1;
743  }
744 
745  /* Set or reset single step. */
746  if (step != thread->single_step)
747  {
748  inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
749  thread->gdb_port, step);
750  darwin_set_sstep (thread->gdb_port, step);
751  thread->single_step = step;
752  }
753 
754  darwin_send_reply (inf, thread);
755  thread->msg_state = DARWIN_RUNNING;
756  break;
757 
758  case DARWIN_RUNNING:
759  break;
760 
761  case DARWIN_STOPPED:
762  kret = thread_resume (thread->gdb_port);
763  MACH_CHECK_ERROR (kret);
764 
765  thread->msg_state = DARWIN_RUNNING;
766  break;
767  }
768 }
769 
770 /* Resume all threads of the inferior. */
771 
772 static void
773 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
774 {
775  darwin_thread_t *thread;
776  int k;
777 
778  for (k = 0;
779  VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
780  k++)
781  darwin_resume_thread (inf, thread, step, nsignal);
782 }
783 
785 {
786  int step;
787  int nsignal;
788 };
789 
790 static int
792 {
793  int step = ((struct resume_inferior_threads_param *)param)->step;
794  int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
795 
796  darwin_resume_inferior_threads (inf, step, nsignal);
797 
798  return 0;
799 }
800 
801 /* Suspend all threads of INF. */
802 
803 static void
805 {
806  darwin_thread_t *thread;
807  kern_return_t kret;
808  int k;
809 
810  for (k = 0;
811  VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
812  k++)
813  switch (thread->msg_state)
814  {
815  case DARWIN_STOPPED:
816  case DARWIN_MESSAGE:
817  break;
818  case DARWIN_RUNNING:
819  kret = thread_suspend (thread->gdb_port);
820  MACH_CHECK_ERROR (kret);
821  thread->msg_state = DARWIN_STOPPED;
822  break;
823  }
824 }
825 
826 static void
827 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
828 {
829  struct target_waitstatus status;
830  int pid;
831 
832  kern_return_t kret;
833  int res;
834  int nsignal;
835  struct inferior *inf;
836 
838  (2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
839  ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
840 
841  if (signal == GDB_SIGNAL_0)
842  nsignal = 0;
843  else
844  nsignal = gdb_signal_to_host (signal);
845 
846  /* Don't try to single step all threads. */
847  if (step)
848  ptid = inferior_ptid;
849 
850  /* minus_one_ptid is RESUME_ALL. */
851  if (ptid_equal (ptid, minus_one_ptid))
852  {
853  struct resume_inferior_threads_param param;
854 
855  param.nsignal = nsignal;
856  param.step = step;
857 
858  /* Resume threads. */
860  /* Resume tasks. */
862  }
863  else
864  {
865  struct inferior *inf = find_inferior_ptid (ptid);
866  long tid = ptid_get_tid (ptid);
867 
868  /* Stop the inferior (should be useless). */
870 
871  if (tid == 0)
872  darwin_resume_inferior_threads (inf, step, nsignal);
873  else
874  {
875  darwin_thread_t *thread;
876 
877  /* Suspend threads of the task. */
879 
880  /* Resume the selected thread. */
881  thread = darwin_find_thread (inf, tid);
882  gdb_assert (thread);
883  darwin_resume_thread (inf, thread, step, nsignal);
884  }
885 
886  /* Resume the task. */
888  }
889 }
890 
891 static void
892 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
893  enum gdb_signal signal)
894 {
895  return darwin_resume (ptid, step, signal);
896 }
897 
898 static ptid_t
899 darwin_decode_message (mach_msg_header_t *hdr,
900  darwin_thread_t **pthread,
901  struct inferior **pinf,
902  struct target_waitstatus *status)
903 {
904  darwin_thread_t *thread;
905  struct inferior *inf;
906 
907  /* Exception message. 2401 == 0x961 is exc. */
908  if (hdr->msgh_id == 2401)
909  {
910  int res;
911 
912  /* Decode message. */
913  res = darwin_decode_exception_message (hdr, &inf, &thread);
914 
915  if (res < 0)
916  {
917  /* Should not happen... */
919  (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
920  /* FIXME: send a failure reply? */
921  status->kind = TARGET_WAITKIND_IGNORE;
922  return minus_one_ptid;
923  }
924  if (inf == NULL)
925  {
926  status->kind = TARGET_WAITKIND_IGNORE;
927  return minus_one_ptid;
928  }
929  *pinf = inf;
930  *pthread = thread;
931  inf->priv->pending_messages++;
932 
933  status->kind = TARGET_WAITKIND_STOPPED;
934  thread->msg_state = DARWIN_MESSAGE;
935 
936  inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
937  thread->gdb_port,
939 
940  switch (thread->event.ex_type)
941  {
942  case EXC_BAD_ACCESS:
943  status->value.sig = GDB_EXC_BAD_ACCESS;
944  break;
945  case EXC_BAD_INSTRUCTION:
946  status->value.sig = GDB_EXC_BAD_INSTRUCTION;
947  break;
948  case EXC_ARITHMETIC:
949  status->value.sig = GDB_EXC_ARITHMETIC;
950  break;
951  case EXC_EMULATION:
952  status->value.sig = GDB_EXC_EMULATION;
953  break;
954  case EXC_SOFTWARE:
955  if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
956  {
957  status->value.sig =
958  gdb_signal_from_host (thread->event.ex_data[1]);
959  inferior_debug (5, _(" (signal %d: %s)\n"),
960  thread->event.ex_data[1],
961  gdb_signal_to_name (status->value.sig));
962 
963  /* If the thread is stopped because it has received a signal
964  that gdb has just sent, continue. */
965  if (thread->signaled)
966  {
967  thread->signaled = 0;
968  darwin_send_reply (inf, thread);
969  thread->msg_state = DARWIN_RUNNING;
970  status->kind = TARGET_WAITKIND_IGNORE;
971  }
972  }
973  else
974  status->value.sig = GDB_EXC_SOFTWARE;
975  break;
976  case EXC_BREAKPOINT:
977  /* Many internal GDB routines expect breakpoints to be reported
978  as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
979  as a spurious signal. */
980  status->value.sig = GDB_SIGNAL_TRAP;
981  break;
982  default:
983  status->value.sig = GDB_SIGNAL_UNKNOWN;
984  break;
985  }
986 
987  return ptid_build (inf->pid, 0, thread->gdb_port);
988  }
989  else if (hdr->msgh_id == 0x48)
990  {
991  /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
992  *pinf = NULL;
993  *pthread = NULL;
994 
995  inf = darwin_find_inferior_by_notify (hdr->msgh_local_port);
996  if (inf != NULL)
997  {
998  if (!inf->priv->no_ptrace)
999  {
1000  pid_t res;
1001  int wstatus;
1002 
1003  res = wait4 (inf->pid, &wstatus, 0, NULL);
1004  if (res < 0 || res != inf->pid)
1005  {
1006  printf_unfiltered (_("wait4: res=%d: %s\n"),
1007  res, safe_strerror (errno));
1008  status->kind = TARGET_WAITKIND_IGNORE;
1009  return minus_one_ptid;
1010  }
1011  if (WIFEXITED (wstatus))
1012  {
1013  status->kind = TARGET_WAITKIND_EXITED;
1014  status->value.integer = WEXITSTATUS (wstatus);
1015  }
1016  else
1017  {
1018  status->kind = TARGET_WAITKIND_SIGNALLED;
1019  status->value.sig = WTERMSIG (wstatus);
1020  }
1021 
1022  inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1023  res, wstatus);
1024 
1025  /* Looks necessary on Leopard and harmless... */
1026  wait4 (inf->pid, &wstatus, 0, NULL);
1027 
1028  return ptid_build (inf->pid, 0, 0);
1029  }
1030  else
1031  {
1032  inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1033  status->kind = TARGET_WAITKIND_EXITED;
1034  status->value.integer = 0; /* Don't know. */
1035  return ptid_build (inf->pid, 0, 0);
1036  }
1037  }
1038  }
1039 
1040  /* Unknown message. */
1041  warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1042  status->kind = TARGET_WAITKIND_IGNORE;
1043  return minus_one_ptid;
1044 }
1045 
1046 static int
1048 {
1049  /* Arrange for a breakpoint to be hit again later. We will handle
1050  the current event, eventually we will resume this thread, and this
1051  breakpoint will trap again.
1052 
1053  If we do not do this, then we run the risk that the user will
1054  delete or disable the breakpoint, but the thread will have already
1055  tripped on it. */
1056 
1057  struct regcache *regcache = get_thread_regcache (ptid);
1058  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1059  CORE_ADDR pc;
1060 
1061  pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1062  if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
1063  {
1064  inferior_debug (4, "cancel_breakpoint for thread 0x%x\n",
1065  ptid_get_tid (ptid));
1066 
1067  /* Back up the PC if necessary. */
1068  if (gdbarch_decr_pc_after_break (gdbarch))
1069  regcache_write_pc (regcache, pc);
1070 
1071  return 1;
1072  }
1073  return 0;
1074 }
1075 
1076 static ptid_t
1078 {
1079  kern_return_t kret;
1080  union
1081  {
1082  mach_msg_header_t hdr;
1083  char data[0x100];
1084  } msgin;
1085  mach_msg_header_t *hdr = &msgin.hdr;
1086  ptid_t res;
1087  darwin_thread_t *thread;
1088  struct inferior *inf;
1089 
1091  (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1092  ptid_get_pid (ptid), ptid_get_tid (ptid));
1093 
1094  /* Handle fake stop events at first. */
1095  if (darwin_inf_fake_stop != NULL)
1096  {
1097  inf = darwin_inf_fake_stop;
1098  darwin_inf_fake_stop = NULL;
1099 
1100  status->kind = TARGET_WAITKIND_STOPPED;
1101  status->value.sig = GDB_SIGNAL_TRAP;
1102  thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1103  thread->msg_state = DARWIN_STOPPED;
1104  return ptid_build (inf->pid, 0, thread->gdb_port);
1105  }
1106 
1107  do
1108  {
1109  /* set_sigint_trap (); */
1110 
1111  /* Wait for a message. */
1112  kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1113  sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1114 
1115  /* clear_sigint_trap (); */
1116 
1117  if (kret == MACH_RCV_INTERRUPTED)
1118  {
1119  status->kind = TARGET_WAITKIND_IGNORE;
1120  return minus_one_ptid;
1121  }
1122 
1123  if (kret != MACH_MSG_SUCCESS)
1124  {
1125  inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1126  status->kind = TARGET_WAITKIND_SPURIOUS;
1127  return minus_one_ptid;
1128  }
1129 
1130  /* Debug: display message. */
1131  if (darwin_debug_flag > 10)
1132  darwin_dump_message (hdr, darwin_debug_flag > 11);
1133 
1134  res = darwin_decode_message (hdr, &thread, &inf, status);
1135  if (ptid_equal (res, minus_one_ptid))
1136  continue;
1137 
1138  /* Early return in case an inferior has exited. */
1139  if (inf == NULL)
1140  return res;
1141  }
1142  while (status->kind == TARGET_WAITKIND_IGNORE);
1143 
1144  /* Stop all tasks. */
1146 
1147  /* Read pending messages. */
1148  while (1)
1149  {
1150  struct target_waitstatus status2;
1151  ptid_t ptid2;
1152 
1153  kret = mach_msg (&msgin.hdr,
1154  MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1155  sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1156 
1157  if (kret == MACH_RCV_TIMED_OUT)
1158  break;
1159  if (kret != MACH_MSG_SUCCESS)
1160  {
1162  (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1163  break;
1164  }
1165 
1166  /* Debug: display message. */
1167  if (darwin_debug_flag > 10)
1168  darwin_dump_message (hdr, darwin_debug_flag > 11);
1169 
1170  ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1171 
1172  if (inf != NULL && thread != NULL
1173  && thread->event.ex_type == EXC_BREAKPOINT)
1174  {
1175  if (thread->single_step
1176  || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1177  {
1178  gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1179  darwin_send_reply (inf, thread);
1180  thread->msg_state = DARWIN_RUNNING;
1181  }
1182  else
1184  (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1185  thread->gdb_port);
1186  }
1187  else
1188  inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1189  }
1190  return res;
1191 }
1192 
1193 static ptid_t
1195  ptid_t ptid, struct target_waitstatus *status, int options)
1196 {
1197  return darwin_wait (ptid, status);
1198 }
1199 
1200 static void
1201 darwin_stop (struct target_ops *self, ptid_t t)
1202 {
1203  struct inferior *inf = current_inferior ();
1204 
1205  /* FIXME: handle in no_ptrace mode. */
1206  gdb_assert (!inf->priv->no_ptrace);
1207  kill (inf->pid, SIGINT);
1208 }
1209 
1210 static void
1212 {
1213  struct inferior *inf = current_inferior ();
1214  kern_return_t kret;
1215  mach_port_t prev;
1216  int i;
1217 
1218  /* Deallocate threads. */
1219  if (inf->priv->threads)
1220  {
1221  int k;
1222  darwin_thread_t *t;
1223  for (k = 0;
1224  VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1225  k++)
1226  {
1227  kret = mach_port_deallocate (gdb_task, t->gdb_port);
1228  MACH_CHECK_ERROR (kret);
1229  }
1230  VEC_free (darwin_thread_t, inf->priv->threads);
1231  inf->priv->threads = NULL;
1232  }
1233 
1234  kret = mach_port_move_member (gdb_task,
1235  inf->priv->notify_port, MACH_PORT_NULL);
1236  MACH_CHECK_ERROR (kret);
1237 
1238  kret = mach_port_request_notification (gdb_task, inf->priv->task,
1239  MACH_NOTIFY_DEAD_NAME, 0,
1240  MACH_PORT_NULL,
1241  MACH_MSG_TYPE_MAKE_SEND_ONCE,
1242  &prev);
1243  /* This can fail if the task is dead. */
1244  inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1245  inf->priv->task, prev, inf->priv->notify_port);
1246 
1247  if (kret == KERN_SUCCESS)
1248  {
1249  kret = mach_port_deallocate (gdb_task, prev);
1250  MACH_CHECK_ERROR (kret);
1251  }
1252 
1253  kret = mach_port_destroy (gdb_task, inf->priv->notify_port);
1254  MACH_CHECK_ERROR (kret);
1255 
1256 
1257  /* Deallocate saved exception ports. */
1258  for (i = 0; i < inf->priv->exception_info.count; i++)
1259  {
1260  kret = mach_port_deallocate
1261  (gdb_task, inf->priv->exception_info.ports[i]);
1262  MACH_CHECK_ERROR (kret);
1263  }
1264  inf->priv->exception_info.count = 0;
1265 
1266  kret = mach_port_deallocate (gdb_task, inf->priv->task);
1267  MACH_CHECK_ERROR (kret);
1268 
1269  xfree (inf->priv);
1270  inf->priv = NULL;
1271 
1273 }
1274 
1275 static void
1277 {
1278  int k;
1279  darwin_thread_t *t;
1280 
1281  for (k = 0;
1282  VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1283  k++)
1284  {
1285  if (t->msg_state == DARWIN_MESSAGE)
1286  darwin_resume_thread (inf, t, 0, 0);
1287  }
1288 }
1289 
1290 static void
1292 {
1293  struct target_waitstatus wstatus;
1294  ptid_t ptid;
1295  kern_return_t kret;
1296  int status;
1297  int res;
1298 
1299  gdb_assert (inf != NULL);
1300 
1302 
1304 
1305  if (inf->priv->no_ptrace)
1306  return;
1307 
1308  res = kill (inf->pid, SIGSTOP);
1309  if (res != 0)
1310  warning (_("cannot kill: %s"), safe_strerror (errno));
1311 
1312  /* Wait until the process is really stopped. */
1313  while (1)
1314  {
1315  ptid = darwin_wait (inferior_ptid, &wstatus);
1316  if (wstatus.kind == TARGET_WAITKIND_STOPPED
1317  && wstatus.value.sig == GDB_SIGNAL_STOP)
1318  break;
1319  }
1320 }
1321 
1322 static kern_return_t
1324 {
1325  kern_return_t kret;
1326 
1327  inf->exception_info.count =
1328  sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1329 
1330  kret = task_get_exception_ports
1331  (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1334  return kret;
1335 }
1336 
1337 static kern_return_t
1339 {
1340  int i;
1341  kern_return_t kret;
1342 
1343  for (i = 0; i < inf->exception_info.count; i++)
1344  {
1345  kret = task_set_exception_ports
1346  (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1347  inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1348  if (kret != KERN_SUCCESS)
1349  return kret;
1350  }
1351 
1352  return KERN_SUCCESS;
1353 }
1354 
1355 static void
1357 {
1358  struct inferior *inf = current_inferior ();
1359  struct target_waitstatus wstatus;
1360  ptid_t ptid;
1361  kern_return_t kret;
1362  int status;
1363  int res;
1364 
1366  return;
1367 
1368  gdb_assert (inf != NULL);
1369 
1370  kret = darwin_restore_exception_ports (inf->priv);
1371  MACH_CHECK_ERROR (kret);
1372 
1374 
1375  res = kill (inf->pid, 9);
1376 
1377  if (res == 0)
1378  {
1379  darwin_resume_inferior (inf);
1380 
1381  ptid = darwin_wait (inferior_ptid, &wstatus);
1382  }
1383  else if (errno != ESRCH)
1384  warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1385  inf->pid, safe_strerror (errno));
1386 
1388 }
1389 
1390 static void
1392 {
1393  kern_return_t kret;
1394  mach_port_t prev_port;
1395  int traps_expected;
1396  mach_port_t prev_not;
1397  exception_mask_t mask;
1398 
1399  inf->priv = XCNEW (darwin_inferior);
1400 
1401  kret = task_for_pid (gdb_task, inf->pid, &inf->priv->task);
1402  if (kret != KERN_SUCCESS)
1403  {
1404  int status;
1405 
1406  if (!inf->attach_flag)
1407  {
1408  kill (inf->pid, 9);
1409  waitpid (inf->pid, &status, 0);
1410  }
1411 
1412  error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1413  " (please check gdb is codesigned - see taskgated(8))"),
1414  inf->pid, mach_error_string (kret), (unsigned long) kret);
1415  }
1416 
1417  inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1418  inf->priv->task, inf->pid);
1419 
1420  if (darwin_ex_port == MACH_PORT_NULL)
1421  {
1422  /* Create a port to get exceptions. */
1423  kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1424  &darwin_ex_port);
1425  if (kret != KERN_SUCCESS)
1426  error (_("Unable to create exception port, mach_port_allocate "
1427  "returned: %d"),
1428  kret);
1429 
1430  kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1431  MACH_MSG_TYPE_MAKE_SEND);
1432  if (kret != KERN_SUCCESS)
1433  error (_("Unable to create exception port, mach_port_insert_right "
1434  "returned: %d"),
1435  kret);
1436 
1437  /* Create a port set and put ex_port in it. */
1438  kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1439  &darwin_port_set);
1440  if (kret != KERN_SUCCESS)
1441  error (_("Unable to create port set, mach_port_allocate "
1442  "returned: %d"),
1443  kret);
1444 
1445  kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
1446  if (kret != KERN_SUCCESS)
1447  error (_("Unable to move exception port into new port set, "
1448  "mach_port_move_member\n"
1449  "returned: %d"),
1450  kret);
1451  }
1452 
1453  /* Create a port to be notified when the child task terminates. */
1454  kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1455  &inf->priv->notify_port);
1456  if (kret != KERN_SUCCESS)
1457  error (_("Unable to create notification port, mach_port_allocate "
1458  "returned: %d"),
1459  kret);
1460 
1461  kret = mach_port_move_member (gdb_task,
1462  inf->priv->notify_port, darwin_port_set);
1463  if (kret != KERN_SUCCESS)
1464  error (_("Unable to move notification port into new port set, "
1465  "mach_port_move_member\n"
1466  "returned: %d"),
1467  kret);
1468 
1469  kret = mach_port_request_notification (gdb_task, inf->priv->task,
1470  MACH_NOTIFY_DEAD_NAME, 0,
1471  inf->priv->notify_port,
1472  MACH_MSG_TYPE_MAKE_SEND_ONCE,
1473  &prev_not);
1474  if (kret != KERN_SUCCESS)
1475  error (_("Termination notification request failed, "
1476  "mach_port_request_notification\n"
1477  "returned: %d"),
1478  kret);
1479  if (prev_not != MACH_PORT_NULL)
1480  {
1481  /* This is unexpected, as there should not be any previously
1482  registered notification request. But this is not a fatal
1483  issue, so just emit a warning. */
1484  warning (_("\
1485 A task termination request was registered before the debugger registered\n\
1486 its own. This is unexpected, but should otherwise not have any actual\n\
1487 impact on the debugging session."));
1488  }
1489 
1490  kret = darwin_save_exception_ports (inf->priv);
1491  if (kret != KERN_SUCCESS)
1492  error (_("Unable to save exception ports, task_get_exception_ports"
1493  "returned: %d"),
1494  kret);
1495 
1496  /* Set exception port. */
1497  if (enable_mach_exceptions)
1498  mask = EXC_MASK_ALL;
1499  else
1500  mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1501  kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
1502  EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1503  if (kret != KERN_SUCCESS)
1504  error (_("Unable to set exception ports, task_set_exception_ports"
1505  "returned: %d"),
1506  kret);
1507 
1508  if (!target_is_pushed (darwin_ops))
1509  push_target (darwin_ops);
1510 }
1511 
1512 static void
1514 {
1515  darwin_thread_t *thread;
1516  ptid_t new_ptid;
1517 
1519 
1520  gdb_assert (inf->priv->threads
1521  && VEC_length (darwin_thread_t, inf->priv->threads) > 0);
1522  thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1523 
1524  /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1525  Fix up. */
1526  new_ptid = ptid_build (inf->pid, 0, thread->gdb_port);
1527  thread_change_ptid (inferior_ptid, new_ptid);
1528  inferior_ptid = new_ptid;
1529 }
1530 
1531 /* The child must synchronize with gdb: gdb must set the exception port
1532  before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1533  FIXME: is there a lighter way ? */
1534 static int ptrace_fds[2];
1535 
1536 static void
1538 {
1539  int res;
1540  char c;
1541 
1542  /* Close write end point. */
1543  close (ptrace_fds[1]);
1544 
1545  /* Wait until gdb is ready. */
1546  res = read (ptrace_fds[0], &c, 1);
1547  if (res != 0)
1548  error (_("unable to read from pipe, read returned: %d"), res);
1549  close (ptrace_fds[0]);
1550 
1551  /* Get rid of privileges. */
1552  setegid (getgid ());
1553 
1554  /* Set TRACEME. */
1555  PTRACE (PT_TRACE_ME, 0, 0, 0);
1556 
1557  /* Redirect signals to exception port. */
1558  PTRACE (PT_SIGEXC, 0, 0, 0);
1559 }
1560 
1561 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1562 static void
1564 {
1565  if (pipe (ptrace_fds) != 0)
1566  {
1567  ptrace_fds[0] = -1;
1568  ptrace_fds[1] = -1;
1569  error (_("unable to create a pipe: %s"), safe_strerror (errno));
1570  }
1571 
1572  mark_fd_no_cloexec (ptrace_fds[0]);
1573  mark_fd_no_cloexec (ptrace_fds[1]);
1574 }
1575 
1576 static void
1578 {
1579  task_t itask;
1580  kern_return_t kret;
1581  mach_port_t prev_port;
1582  int traps_expected;
1583  struct inferior *inf = current_inferior ();
1584 
1585  darwin_attach_pid (inf);
1586 
1587  /* Let's the child run. */
1588  close (ptrace_fds[0]);
1589  close (ptrace_fds[1]);
1590 
1591  unmark_fd_no_cloexec (ptrace_fds[0]);
1592  unmark_fd_no_cloexec (ptrace_fds[1]);
1593 
1595 
1597 }
1598 
1599 static void
1600 darwin_execvp (const char *file, char * const argv[], char * const env[])
1601 {
1602  posix_spawnattr_t attr;
1603  short ps_flags = 0;
1604  int res;
1605 
1606  res = posix_spawnattr_init (&attr);
1607  if (res != 0)
1608  {
1610  (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1611  return;
1612  }
1613 
1614  /* Do like execve: replace the image. */
1615  ps_flags = POSIX_SPAWN_SETEXEC;
1616 
1617  /* Disable ASLR. The constant doesn't look to be available outside the
1618  kernel include files. */
1619 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1620 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1621 #endif
1622  ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1623  res = posix_spawnattr_setflags (&attr, ps_flags);
1624  if (res != 0)
1625  {
1626  fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1627  return;
1628  }
1629 
1630  posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1631 }
1632 
1633 static void
1634 darwin_create_inferior (struct target_ops *ops, char *exec_file,
1635  char *allargs, char **env, int from_tty)
1636 {
1637  /* Do the hard work. */
1638  fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
1640 
1641  /* Return now in case of error. */
1643  return;
1644 }
1645 
1646 
1647 /* Set things up such that the next call to darwin_wait will immediately
1648  return a fake stop event for inferior INF.
1649 
1650  This assumes that the inferior's thread list has been initialized,
1651  as it will suspend the inferior's first thread. */
1652 
1653 static void
1655 {
1656  darwin_thread_t *thread;
1657  kern_return_t kret;
1658 
1659  gdb_assert (darwin_inf_fake_stop == NULL);
1660  darwin_inf_fake_stop = inf;
1661 
1662  /* When detecting a fake pending stop event, darwin_wait returns
1663  an event saying that the first thread is in a DARWIN_STOPPED
1664  state. To make that accurate, we need to suspend that thread
1665  as well. Otherwise, we'll try resuming it when resuming the
1666  inferior, and get a warning because the thread's suspend count
1667  is already zero, making the resume request useless. */
1668  thread = VEC_index (darwin_thread_t, inf->priv->threads, 0);
1669  kret = thread_suspend (thread->gdb_port);
1670  MACH_CHECK_ERROR (kret);
1671 }
1672 
1673 /* Attach to process PID, then initialize for debugging it
1674  and wait for the trace-trap that results from attaching. */
1675 static void
1676 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1677 {
1678  pid_t pid;
1679  pid_t pid2;
1680  int wstatus;
1681  int res;
1682  struct inferior *inf;
1683  kern_return_t kret;
1684 
1685  pid = parse_pid_to_attach (args);
1686 
1687  if (pid == getpid ()) /* Trying to masturbate? */
1688  error (_("I refuse to debug myself!"));
1689 
1690  if (from_tty)
1691  {
1692  char *exec_file = get_exec_file (0);
1693 
1694  if (exec_file)
1695  printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1696  target_pid_to_str (pid_to_ptid (pid)));
1697  else
1698  printf_unfiltered (_("Attaching to %s\n"),
1699  target_pid_to_str (pid_to_ptid (pid)));
1700 
1702  }
1703 
1704  if (pid == 0 || kill (pid, 0) < 0)
1705  error (_("Can't attach to process %d: %s (%d)"),
1706  pid, safe_strerror (errno), errno);
1707 
1708  inferior_ptid = pid_to_ptid (pid);
1709  inf = current_inferior ();
1710  inferior_appeared (inf, pid);
1711  inf->attach_flag = 1;
1712 
1713  /* Always add a main thread. */
1715 
1716  darwin_attach_pid (inf);
1717 
1719 
1721 
1723 
1725 
1726  inf->priv->no_ptrace = 1;
1727 }
1728 
1729 /* Take a program previously attached to and detaches it.
1730  The program resumes execution and will no longer stop
1731  on signals, etc. We'd better not have left any breakpoints
1732  in the program or it'll die when it hits one. For this
1733  to work, it may be necessary for the process to have been
1734  previously attached. It *might* work if the program was
1735  started via fork. */
1736 static void
1737 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1738 {
1739  pid_t pid = ptid_get_pid (inferior_ptid);
1740  struct inferior *inf = current_inferior ();
1741  kern_return_t kret;
1742  int res;
1743 
1744  /* Display message. */
1745  if (from_tty)
1746  {
1747  char *exec_file = get_exec_file (0);
1748  if (exec_file == 0)
1749  exec_file = "";
1750  printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
1751  target_pid_to_str (pid_to_ptid (pid)));
1753  }
1754 
1755  /* If ptrace() is in use, stop the process. */
1756  if (!inf->priv->no_ptrace)
1757  darwin_stop_inferior (inf);
1758 
1759  kret = darwin_restore_exception_ports (inf->priv);
1760  MACH_CHECK_ERROR (kret);
1761 
1762  if (!inf->priv->no_ptrace)
1763  {
1764  res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1765  if (res != 0)
1766  printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1767  inf->pid, safe_strerror (errno), errno);
1768  }
1769 
1771 
1772  /* When using ptrace, we have just performed a PT_DETACH, which
1773  resumes the inferior. On the other hand, when we are not using
1774  ptrace, we need to resume its execution ourselves. */
1775  if (inf->priv->no_ptrace)
1776  darwin_resume_inferior (inf);
1777 
1778  darwin_mourn_inferior (ops);
1779 }
1780 
1781 static void
1783 {
1784 }
1785 
1786 static char *
1788 {
1789  static char buf[80];
1790  long tid = ptid_get_tid (ptid);
1791 
1792  if (tid != 0)
1793  {
1794  snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1795  tid, ptid_get_pid (ptid));
1796  return buf;
1797  }
1798 
1799  return normal_pid_to_str (ptid);
1800 }
1801 
1802 static int
1804 {
1805  return 1;
1806 }
1807 
1808 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1809  copy it to RDADDR in gdb's address space.
1810  If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1811  to ADDR in inferior task's address space.
1812  Return 0 on failure; number of bytes read / writen otherwise. */
1813 static int
1815  gdb_byte *rdaddr, const gdb_byte *wraddr,
1816  ULONGEST length)
1817 {
1818  kern_return_t kret;
1819  mach_vm_address_t offset = addr & (mach_page_size - 1);
1820  mach_vm_address_t low_address = (mach_vm_address_t) (addr - offset);
1821  mach_vm_size_t aligned_length = (mach_vm_size_t) PAGE_ROUND (offset + length);
1822  pointer_t copied;
1823  mach_msg_type_number_t copy_count;
1824  mach_vm_size_t remaining_length;
1825  mach_vm_address_t region_address;
1826  mach_vm_size_t region_length;
1827 
1828  inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
1829  task, core_addr_to_string (addr), pulongest (length));
1830 
1831  /* Get memory from inferior with page aligned addresses. */
1832  kret = mach_vm_read (task, low_address, aligned_length,
1833  &copied, &copy_count);
1834  if (kret != KERN_SUCCESS)
1835  {
1837  (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1838  core_addr_to_string (addr), mach_error_string (kret));
1839  return 0;
1840  }
1841 
1842  if (rdaddr != NULL)
1843  memcpy (rdaddr, (char *)copied + offset, length);
1844 
1845  if (wraddr == NULL)
1846  goto out;
1847 
1848  memcpy ((char *)copied + offset, wraddr, length);
1849 
1850  /* Do writes atomically.
1851  First check for holes and unwritable memory. */
1852  for (region_address = low_address, remaining_length = aligned_length;
1853  region_address < low_address + aligned_length;
1854  region_address += region_length, remaining_length -= region_length)
1855  {
1856  vm_region_submap_short_info_data_64_t info;
1857  mach_vm_address_t region_start = region_address;
1858  mach_msg_type_number_t count;
1859  natural_t region_depth;
1860 
1861  region_depth = 100000;
1862  count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
1863  kret = mach_vm_region_recurse
1864  (task, &region_start, &region_length, &region_depth,
1865  (vm_region_recurse_info_t) &info, &count);
1866 
1867  if (kret != KERN_SUCCESS)
1868  {
1869  inferior_debug (1, _("darwin_read_write_inferior: "
1870  "mach_vm_region_recurse failed at %s: %s\n"),
1871  core_addr_to_string (region_address),
1872  mach_error_string (kret));
1873  goto out;
1874  }
1875 
1877  (9, _("darwin_read_write_inferior: "
1878  "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1879  core_addr_to_string (region_address),
1880  core_addr_to_string (region_start),
1881  core_addr_to_string (region_length));
1882 
1883  /* Check for holes in memory. */
1884  if (region_start > region_address)
1885  {
1886  warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1887  core_addr_to_string (region_address),
1888  core_addr_to_string (region_start),
1889  (unsigned)region_length);
1890  length = 0;
1891  goto out;
1892  }
1893 
1894  /* Adjust the length. */
1895  region_length -= (region_address - region_start);
1896 
1897  if (!(info.max_protection & VM_PROT_WRITE))
1898  {
1899  kret = mach_vm_protect
1900  (task, region_address, region_length,
1901  TRUE, info.max_protection | VM_PROT_WRITE | VM_PROT_COPY);
1902  if (kret != KERN_SUCCESS)
1903  {
1904  warning (_("darwin_read_write_inf: "
1905  "mach_vm_protect max failed at %s: %s"),
1906  core_addr_to_string (region_address),
1907  mach_error_string (kret));
1908  length = 0;
1909  goto out;
1910  }
1911  }
1912 
1913  if (!(info.protection & VM_PROT_WRITE))
1914  {
1915  kret = mach_vm_protect (task, region_address, region_length,
1916  FALSE, info.protection | VM_PROT_WRITE);
1917  if (kret != KERN_SUCCESS)
1918  {
1919  warning (_("darwin_read_write_inf: "
1920  "mach_vm_protect failed at %s (len=0x%lx): %s"),
1921  core_addr_to_string (region_address),
1922  (unsigned long)region_length, mach_error_string (kret));
1923  length = 0;
1924  goto out;
1925  }
1926  }
1927  }
1928 
1929  kret = mach_vm_write (task, low_address, copied, aligned_length);
1930 
1931  if (kret != KERN_SUCCESS)
1932  {
1933  warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1934  mach_error_string (kret));
1935  length = 0;
1936  }
1937 out:
1938  mach_vm_deallocate (mach_task_self (), copied, copy_count);
1939  return length;
1940 }
1941 
1942 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1943  to RDADDR.
1944  Return 0 on failure; number of bytes read / written otherwise. */
1945 
1946 #ifdef TASK_DYLD_INFO_COUNT
1947 /* This is not available in Darwin 9. */
1948 static enum target_xfer_status
1949 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
1950  ULONGEST length, ULONGEST *xfered_len)
1951 {
1952  struct task_dyld_info task_dyld_info;
1953  mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
1954  int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
1955  kern_return_t kret;
1956 
1957  if (addr >= sz)
1958  return TARGET_XFER_EOF;
1959 
1960  kret = task_info (task, TASK_DYLD_INFO, (task_info_t) &task_dyld_info, &count);
1961  MACH_CHECK_ERROR (kret);
1962  if (kret != KERN_SUCCESS)
1963  return TARGET_XFER_E_IO;
1964  /* Truncate. */
1965  if (addr + length > sz)
1966  length = sz - addr;
1967  memcpy (rdaddr, (char *)&task_dyld_info + addr, length);
1968  *xfered_len = (ULONGEST) length;
1969  return TARGET_XFER_OK;
1970 }
1971 #endif
1972 
1973 
1974 
1975 static enum target_xfer_status
1977  enum target_object object, const char *annex,
1978  gdb_byte *readbuf, const gdb_byte *writebuf,
1979  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
1980 {
1981  struct inferior *inf = current_inferior ();
1982 
1984  (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
1985  core_addr_to_string (offset), pulongest (len),
1986  host_address_to_string (readbuf), host_address_to_string (writebuf),
1987  inf->pid);
1988 
1989  switch (object)
1990  {
1991  case TARGET_OBJECT_MEMORY:
1992  {
1993  int l = darwin_read_write_inferior (inf->priv->task, offset,
1994  readbuf, writebuf, len);
1995 
1996  if (l == 0)
1997  return TARGET_XFER_EOF;
1998  else
1999  {
2000  gdb_assert (l > 0);
2001  *xfered_len = (ULONGEST) l;
2002  return TARGET_XFER_OK;
2003  }
2004  }
2005 #ifdef TASK_DYLD_INFO_COUNT
2007  if (writebuf != NULL || readbuf == NULL)
2008  {
2009  /* Support only read. */
2010  return TARGET_XFER_E_IO;
2011  }
2012  return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
2013  xfered_len);
2014 #endif
2015  default:
2016  return TARGET_XFER_E_IO;
2017  }
2018 
2019 }
2020 
2021 static void
2022 set_enable_mach_exceptions (char *args, int from_tty,
2023  struct cmd_list_element *c)
2024 {
2026  {
2027  struct inferior *inf = current_inferior ();
2028  exception_mask_t mask;
2029  kern_return_t kret;
2030 
2031  if (enable_mach_exceptions)
2032  mask = EXC_MASK_ALL;
2033  else
2034  {
2036  mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2037  }
2038  kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
2039  EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2040  MACH_CHECK_ERROR (kret);
2041  }
2042 }
2043 
2044 static char *
2046 {
2047  static char path[PATH_MAX];
2048  int res;
2049 
2050  res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2051  if (res >= 0)
2052  return path;
2053  else
2054  return NULL;
2055 }
2056 
2057 static ptid_t
2058 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2059 {
2060  int i;
2061  darwin_thread_t *t;
2062  int k;
2063  struct inferior *inf = current_inferior ();
2064  kern_return_t kret;
2065  mach_port_name_array_t names;
2066  mach_msg_type_number_t names_count;
2067  mach_port_type_array_t types;
2068  mach_msg_type_number_t types_count;
2069  long res = 0;
2070 
2071  /* First linear search. */
2072  for (k = 0;
2073  VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2074  k++)
2075  if (t->inf_port == lwp)
2076  return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2077 
2078  /* Maybe the port was never extract. Do it now. */
2079 
2080  /* First get inferior port names. */
2081  kret = mach_port_names (inf->priv->task, &names, &names_count, &types,
2082  &types_count);
2083  MACH_CHECK_ERROR (kret);
2084  if (kret != KERN_SUCCESS)
2085  return null_ptid;
2086 
2087  /* For each name, copy the right in the gdb space and then compare with
2088  our view of the inferior threads. We don't forget to deallocate the
2089  right. */
2090  for (i = 0; i < names_count; i++)
2091  {
2092  mach_port_t local_name;
2093  mach_msg_type_name_t local_type;
2094 
2095  /* We just need to know the corresponding name in gdb name space.
2096  So extract and deallocate the right. */
2097  kret = mach_port_extract_right (inf->priv->task, names[i],
2098  MACH_MSG_TYPE_COPY_SEND,
2099  &local_name, &local_type);
2100  if (kret != KERN_SUCCESS)
2101  continue;
2102  mach_port_deallocate (gdb_task, local_name);
2103 
2104  for (k = 0;
2105  VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2106  k++)
2107  if (t->gdb_port == local_name)
2108  {
2109  t->inf_port = names[i];
2110  if (names[i] == lwp)
2111  res = t->gdb_port;
2112  }
2113  }
2114 
2115  vm_deallocate (gdb_task, (vm_address_t) names,
2116  names_count * sizeof (mach_port_t));
2117 
2118  if (res)
2119  return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2120  else
2121  return null_ptid;
2122 }
2123 
2124 static int
2126 {
2127  return 1;
2128 }
2129 
2130 /* -Wmissing-prototypes */
2132 
2133 void
2135 {
2136  kern_return_t kret;
2137 
2138  gdb_task = mach_task_self ();
2139  darwin_host_self = mach_host_self ();
2140 
2141  /* Read page size. */
2142  kret = host_page_size (darwin_host_self, &mach_page_size);
2143  if (kret != KERN_SUCCESS)
2144  {
2145  mach_page_size = 0x1000;
2146  MACH_CHECK_ERROR (kret);
2147  }
2148 
2149  darwin_ops = inf_child_target ();
2150 
2152  darwin_ops->to_attach = darwin_attach;
2153  darwin_ops->to_attach_no_wait = 0;
2154  darwin_ops->to_detach = darwin_detach;
2155  darwin_ops->to_files_info = darwin_files_info;
2156  darwin_ops->to_wait = darwin_wait_to;
2158  darwin_ops->to_kill = darwin_kill_inferior;
2159  darwin_ops->to_stop = darwin_stop;
2160  darwin_ops->to_resume = darwin_resume_to;
2161  darwin_ops->to_thread_alive = darwin_thread_alive;
2162  darwin_ops->to_pid_to_str = darwin_pid_to_str;
2164  darwin_ops->to_load = NULL;
2165  darwin_ops->to_xfer_partial = darwin_xfer_partial;
2168 
2169  darwin_complete_target (darwin_ops);
2170 
2171  add_target (darwin_ops);
2172 
2173  inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
2174  getpid ());
2175 
2177  &darwin_debug_flag, _("\
2178 Set if printing inferior communication debugging statements."), _("\
2179 Show if printing inferior communication debugging statements."), NULL,
2180  NULL, NULL,
2182 
2183  add_setshow_boolean_cmd ("mach-exceptions", class_support,
2184  &enable_mach_exceptions, _("\
2185 Set if mach exceptions are caught."), _("\
2186 Show if mach exceptions are caught."), _("\
2187 When this mode is on, all low level exceptions are reported before being\n\
2188 reported by the kernel."),
2190  &setlist, &showlist);
2191 }
static ptid_t darwin_decode_message(mach_msg_header_t *hdr, darwin_thread_t **pthread, struct inferior **pinf, struct target_waitstatus *status)
Definition: darwin-nat.c:899
void add_target(struct target_ops *t)
Definition: target.c:395
static struct target_ops * darwin_ops
Definition: darwin-nat.c:118
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
static void darwin_dump_message(mach_msg_header_t *hdr, int disp_body)
Definition: darwin-nat.c:494
struct private_thread_info * priv
Definition: gdbthread.h:270
static void darwin_resume_to(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
Definition: darwin-nat.c:892
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:393
static struct inferior * darwin_inf_fake_stop
Definition: darwin-nat.c:140
thread_state_flavor_t flavors[EXC_TYPES_COUNT]
Definition: darwin-nat.h:38
#define PTRACE(CMD, PID, ADDR, SIG)
Definition: darwin-nat.c:83
initialize_file_ftype _initialize_darwin_inferior
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
static void darwin_resume_inferior_threads(struct inferior *inf, int step, int nsignal)
Definition: darwin-nat.c:773
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
Definition: target.h:98
static enum target_xfer_status darwin_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: darwin-nat.c:1976
static int darwin_suspend_inferior_it(struct inferior *inf, void *arg)
Definition: darwin-nat.c:479
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
void delete_thread(ptid_t)
Definition: thread.c:368
void xfree(void *)
Definition: common-utils.c:97
static darwin_thread_t * darwin_find_thread(struct inferior *inf, thread_t thread)
Definition: darwin-nat.c:431
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
static int darwin_read_write_inferior(task_t task, CORE_ADDR addr, gdb_byte *rdaddr, const gdb_byte *wraddr, ULONGEST length)
Definition: darwin-nat.c:1814
void warning(const char *fmt,...)
Definition: errors.c:26
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
struct type ** const(pascal_builtin_types[])
void darwin_set_sstep(thread_t thread, int enable)
tuple inf
Definition: arm-linux.py:13
void push_target(struct target_ops *t)
Definition: target.c:664
static void darwin_reply_to_all_pending_messages(struct inferior *inf)
Definition: darwin-nat.c:1276
struct ui_file * gdb_stdout
Definition: main.c:71
struct thread_info * add_thread_with_info(ptid_t ptid, struct private_thread_info *)
Definition: thread.c:291
int pid
Definition: inferior.h:299
char * args
Definition: inferior.h:320
static int darwin_supports_multi_process(struct target_ops *self)
Definition: darwin-nat.c:2125
exception_mask_t masks[EXC_TYPES_COUNT]
Definition: darwin-nat.h:29
static struct inferior * darwin_find_inferior_by_task(task_t port)
Definition: darwin-nat.c:417
static void darwin_resume_inferior(struct inferior *inf)
Definition: darwin-nat.c:463
exception_behavior_t behaviors[EXC_TYPES_COUNT]
Definition: darwin-nat.h:35
static void darwin_execvp(const char *file, char *const argv[], char *const env[])
Definition: darwin-nat.c:1600
static int find_inferior_task_it(struct inferior *inf, void *port_ptr)
Definition: darwin-nat.c:404
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
static kern_return_t darwin_save_exception_ports(darwin_inferior *inf)
Definition: darwin-nat.c:1323
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:398
#define VEC(T)
Definition: vec.h:398
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
#define _(String)
Definition: gdb_locale.h:40
static void darwin_pre_ptrace(void)
Definition: darwin-nat.c:1563
static void darwin_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: darwin-nat.c:827
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1201
static void darwin_stop_inferior(struct inferior *inf)
Definition: darwin-nat.c:1291
static ptid_t darwin_get_ada_task_ptid(struct target_ops *self, long lwp, long thread)
Definition: darwin-nat.c:2058
static ptid_t darwin_wait(ptid_t ptid, struct target_waitstatus *status)
Definition: darwin-nat.c:1077
mach_port_t darwin_ex_port
Definition: darwin-nat.c:127
mach_port_t ports[EXC_TYPES_COUNT]
Definition: darwin-nat.h:32
PTRACE_TYPE_RET ptrace()
#define MACH_CHECK_ERROR(ret)
Definition: darwin-nat.h:143
int breakpoint_inserted_here_p(struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4256
Definition: ptid.h:35
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
static int find_inferior_notify_it(struct inferior *inf, void *port_ptr)
Definition: darwin-nat.c:410
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
static void darwin_setup_fake_stop_event(struct inferior *inf)
Definition: darwin-nat.c:1654
unsigned char no_ptrace
Definition: darwin-nat.h:119
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
static void darwin_encode_reply(mig_reply_error_t *reply, mach_msg_header_t *hdr, integer_t code)
Definition: darwin-nat.c:680
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition: gdbarch.c:2754
void unmark_fd_no_cloexec(int fd)
Definition: filestuff.c:184
static struct inferior * darwin_find_inferior_by_notify(mach_port_t port)
Definition: darwin-nat.c:424
#define WTERMSIG(w)
Definition: gdb_wait.h:71
unsigned char signaled
Definition: darwin-nat.h:91
void initialize_file_ftype(void)
Definition: defs.h:281
void startup_inferior(int ntraps)
Definition: fork-child.c:414
mach_port_t darwin_host_self
Definition: darwin-nat.c:124
static void darwin_stop(struct target_ops *self, ptid_t)
Definition: darwin-nat.c:1201
static void darwin_init_thread_list(struct inferior *inf)
Definition: darwin-nat.c:1513
enum gdb_signal sig
Definition: waitstatus.h:108
#define WIFEXITED(w)
Definition: gdb_wait.h:44
mach_msg_header_t header
Definition: darwin-nat.h:47
static int darwin_thread_alive(struct target_ops *ops, ptid_t tpid)
Definition: darwin-nat.c:1803
darwin_exception_info exception_info
Definition: darwin-nat.h:113
static int enable_mach_exceptions
Definition: darwin-nat.c:137
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
enum darwin_msg_state msg_state
Definition: darwin-nat.h:85
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:464
mach_msg_type_number_t data_count
Definition: darwin-nat.h:57
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
static void darwin_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: darwin-nat.c:1737
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
#define VEC_length(T, V)
Definition: vec.h:124
union target_waitstatus::@161 value
target_xfer_status
Definition: target.h:219
static char * darwin_pid_to_exec_file(struct target_ops *self, int pid)
Definition: darwin-nat.c:2045
Definition: gdbtypes.h:749
int gdb_signal_to_host(enum gdb_signal)
Definition: signals.c:631
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
mach_port_t task_port
Definition: darwin-nat.h:51
#define VEC_index(T, V, I)
Definition: vec.h:151
static kern_return_t darwin_restore_exception_ports(darwin_inferior *inf)
Definition: darwin-nat.c:1338
char ** argv
Definition: inferior.h:329
Definition: gnu-nat.c:163
void target_mourn_inferior(void)
Definition: target.c:2300
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void thread_change_ptid(ptid_t old_ptid, ptid_t new_ptid)
Definition: thread.c:754
static int darwin_resume_inferior_it(struct inferior *inf, void *arg)
Definition: darwin-nat.c:487
static int darwin_decode_exception_message(mach_msg_header_t *hdr, struct inferior **pinf, darwin_thread_t **pthread)
Definition: darwin-nat.c:561
int fork_inferior(char *exec_file_arg, char *allargs, char **env, void(*traceme_fun)(void), void(*init_trace_fun)(int), void(*pre_trace_fun)(void), char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
Definition: fork-child.c:122
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
unsigned int pending_messages
Definition: darwin-nat.h:116
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
#define VEC_alloc(T, N)
Definition: vec.h:173
#define WEXITSTATUS(w)
Definition: gdb_wait.h:67
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
static const unsigned char info_plist[] __attribute__((section("__TEXT,__info_plist"), used))
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
void inf_child_mourn_inferior(struct target_ops *ops)
Definition: inf-child.c:163
static int cancel_breakpoint(ptid_t ptid)
Definition: darwin-nat.c:1047
target_object
Definition: target.h:136
pthread_t thread_t
char *(* to_pid_to_exec_file)(struct target_ops *, int pid) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:644
int target_is_pushed(struct target_ops *t)
Definition: target.c:775
static void darwin_ptrace_me(void)
Definition: darwin-nat.c:1537
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
static void inferior_debug(int level, const char *fmt,...) ATTRIBUTE_PRINTF(2
Definition: darwin-nat.c:178
int attach_flag
Definition: inferior.h:340
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
void vprintf_unfiltered(const char *format, va_list args)
Definition: utils.c:2345
static void darwin_suspend_inferior_threads(struct inferior *inf)
Definition: darwin-nat.c:804
static void darwin_files_info(struct target_ops *ops)
Definition: darwin-nat.c:1782
void mach_check_error(kern_return_t ret, const char *file, unsigned int line, const char *func)
Definition: darwin-nat.c:192
mach_port_t thread_port
Definition: darwin-nat.h:50
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
struct target_ops * inf_child_target(void)
Definition: inf-child.c:393
static void darwin_attach_pid(struct inferior *inf)
Definition: darwin-nat.c:1391
ptid_t null_ptid
Definition: ptid.c:25
long ptid_get_tid(ptid_t ptid)
Definition: ptid.c:68
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:607
mach_port_t darwin_port_set
Definition: darwin-nat.c:130
static const char * unparse_exception_type(unsigned int i)
Definition: darwin-nat.c:205
static void darwin_mourn_inferior(struct target_ops *ops)
Definition: darwin-nat.c:1211
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:637
static int darwin_resume_inferior_threads_it(struct inferior *inf, void *param)
Definition: darwin-nat.c:791
#define START_INFERIOR_TRAPS_EXPECTED
Definition: inferior.h:265
enum target_waitkind kind
Definition: waitstatus.h:100
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
struct ui_file * gdb_stderr
Definition: main.c:72
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1174
ptid_t inferior_ptid
Definition: infcmd.c:124
struct darwin_exception_msg event
Definition: darwin-nat.h:94
char * safe_strerror(int)
static vm_size_t mach_page_size
Definition: darwin-nat.c:133
unsigned char suspended
Definition: darwin-nat.h:122
#define PT_TRACE_ME
Definition: gdb_ptrace.h:43
int offset
Definition: agent.c:65
int code
Definition: ser-unix.c:684
static void darwin_create_inferior(struct target_ops *ops, char *exec_file, char *allargs, char **env, int from_tty)
Definition: darwin-nat.c:1634
#define VEC_free(T, V)
Definition: vec.h:180
#define qsort
Definition: ada-exp.c:2747
mach_port_t notify_port
Definition: darwin-nat.h:110
void(* to_create_inferior)(struct target_ops *, char *, char *, char **, int)
Definition: target.h:584
unsigned char single_step
Definition: darwin-nat.h:88
int line
Definition: symtab.h:1570
integer_t ex_data[2]
Definition: darwin-nat.h:58
int parse_pid_to_attach(const char *args)
Definition: utils.c:3108
static void darwin_check_new_threads(struct inferior *inf)
Definition: darwin-nat.c:272
#define PAGE_ROUND(x)
Definition: darwin-nat.c:143
struct address_space * get_regcache_aspace(const struct regcache *regcache)
Definition: regcache.c:303
void ** data
Definition: gdbarch.c:139
struct thread_info * thread_list
Definition: thread.c:55
struct inferior * current_inferior(void)
Definition: inferior.c:57
static void darwin_ptrace_him(int pid)
Definition: darwin-nat.c:1577
char * get_exec_file(int err)
Definition: corefile.c:179
unsigned long long ULONGEST
Definition: common-types.h:53
static void ATTRIBUTE_PRINTF(6, 0)
Definition: cli-out.c:229
static task_t gdb_task
Definition: darwin-nat.c:121
static void darwin_send_reply(struct inferior *inf, darwin_thread_t *thread)
Definition: darwin-nat.c:696
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
struct private_inferior * priv
Definition: inferior.h:370
static void darwin_resume_thread(struct inferior *inf, darwin_thread_t *thread, int step, int nsignal)
Definition: darwin-nat.c:713
#define PTRACE_TYPE_ARG3
Definition: config.h:658
exception_type_t ex_type
Definition: darwin-nat.h:54
static ptid_t darwin_wait_to(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: darwin-nat.c:1194
#define _POSIX_SPAWN_DISABLE_ASLR
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
static void darwin_kill_inferior(struct target_ops *ops)
Definition: darwin-nat.c:1356
void(* to_attach)(struct target_ops *ops, const char *, int)
Definition: target.h:457
void mark_fd_no_cloexec(int fd)
Definition: filestuff.c:176
static unsigned int darwin_debug_flag
Definition: darwin-nat.c:146
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
static void darwin_suspend_inferior(struct inferior *inf)
Definition: darwin-nat.c:447
static int darwin_ptrace(const char *name, int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
Definition: darwin-nat.c:247
ptid_t(* to_get_ada_task_ptid)(struct target_ops *, long lwp, long thread) TARGET_DEFAULT_FUNC(default_get_ada_task_ptid)
Definition: target.h:776
mach_msg_type_number_t count
Definition: darwin-nat.h:41
static void set_enable_mach_exceptions(char *args, int from_tty, struct cmd_list_element *c)
Definition: darwin-nat.c:2022
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
ptid_t minus_one_ptid
Definition: ptid.c:26
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void darwin_complete_target(struct target_ops *target)
static int cmp_thread_t(const void *l, const void *r)
Definition: darwin-nat.c:264
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:577
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
int(* to_supports_multi_process)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:812
static void darwin_attach(struct target_ops *ops, const char *args, int from_tty)
Definition: darwin-nat.c:1676
const ULONGEST const LONGEST len
Definition: target.h:309
int to_attach_no_wait
Definition: target.h:657
static char * darwin_pid_to_str(struct target_ops *ops, ptid_t tpid)
Definition: darwin-nat.c:1787