1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2017 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
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.
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.
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/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
41 #include <sys/ptrace.h>
42 #include <sys/signal.h>
44 #include <sys/types.h>
48 #include <sys/sysctl.h>
51 #include <sys/syscall.h>
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>
63 #include "darwin-nat.h"
64 #include "common/filestuff.h"
65 #include "nat/fork-inferior.h"
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).
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
79 Some Mach documentation is available for Apple xnu source package or
83 #define PTRACE(CMD, PID, ADDR, SIG) \
84 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
86 static void darwin_interrupt (struct target_ops *self, ptid_t);
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);
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);
97 static void darwin_mourn_inferior (struct target_ops *ops);
99 static void darwin_kill_inferior (struct target_ops *ops);
101 static void darwin_ptrace_me (void);
103 static void darwin_ptrace_him (int pid);
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);
110 static void darwin_files_info (struct target_ops *ops);
112 static const char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
114 static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
116 static void darwin_encode_reply (mig_reply_error_t *reply,
117 mach_msg_header_t *hdr, integer_t code);
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);
124 /* Target operations for Darwin. */
125 static struct target_ops *darwin_ops;
127 /* Task identifier of gdb. */
128 static task_t gdb_task;
130 /* A copy of mach_host_self (). */
131 mach_port_t darwin_host_self;
133 /* Exception port. */
134 mach_port_t darwin_ex_port;
136 /* Port set, to wait for answer on all ports. */
137 mach_port_t darwin_port_set;
140 static vm_size_t mach_page_size;
142 /* If Set, catch all mach exceptions (before they are converted to signals
144 static int enable_mach_exceptions;
146 /* Inferior that should report a fake stop event. */
147 static struct inferior *darwin_inf_fake_stop;
149 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
150 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
152 /* This controls output of inferior debugging. */
153 static unsigned int darwin_debug_flag = 0;
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.
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"
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"
175 " <string>allowed</string>\n"
176 " <string>debug</string>\n"
181 static void inferior_debug (int level, const char *fmt, ...)
182 ATTRIBUTE_PRINTF (2, 3);
185 inferior_debug (int level, const char *fmt, ...)
189 if (darwin_debug_flag < level)
193 printf_unfiltered (_("[%d inferior]: "), getpid ());
194 vprintf_unfiltered (fmt, ap);
199 mach_check_error (kern_return_t ret, const char *file,
200 unsigned int line, const char *func)
202 if (ret == KERN_SUCCESS)
205 func = _("[UNKNOWN]");
207 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
208 file, line, func, mach_error_string (ret), (unsigned long) ret);
212 unparse_exception_type (unsigned int i)
214 static char unknown_exception_buf[32];
219 return "EXC_BAD_ACCESS";
220 case EXC_BAD_INSTRUCTION:
221 return "EXC_BAD_INSTRUCTION";
223 return "EXC_ARITHMETIC";
225 return "EXC_EMULATION";
227 return "EXC_SOFTWARE";
229 return "EXC_BREAKPOINT";
231 return "EXC_SYSCALL";
232 case EXC_MACH_SYSCALL:
233 return "EXC_MACH_SYSCALL";
235 return "EXC_RPC_ALERT";
239 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
240 return unknown_exception_buf;
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
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. */
254 darwin_ptrace (const char *name,
255 int request, int pid, caddr_t arg3, int arg4)
260 ret = ptrace (request, pid, arg3, arg4);
261 if (ret == -1 && errno == 0)
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"));
271 cmp_thread_t (const void *l, const void *r)
273 thread_t tl = *(const thread_t *)l;
274 thread_t tr = *(const thread_t *)r;
275 return (int)(tl - tr);
279 darwin_check_new_threads (struct inferior *inf)
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;
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)
298 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
300 if (darwin_inf->threads)
301 old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
305 /* Quick check for no changes. */
306 if (old_nbr == new_nbr)
308 for (i = 0; i < new_nbr; i++)
310 != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
314 /* Deallocate ports. */
315 for (i = 0; i < new_nbr; i++)
317 kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
318 MACH_CHECK_ERROR (kret);
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);
330 /* Full handling: detect new threads, remove dead threads. */
331 thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
333 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
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;
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);
345 if (old_id == new_id)
347 /* Thread still exist. */
348 VEC_safe_push (darwin_thread_t, thread_vec, old);
352 /* Deallocate the port. */
353 kret = mach_port_deallocate (gdb_task, new_id);
354 MACH_CHECK_ERROR (kret);
358 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
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. */
366 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
368 /* A thread was created. */
369 struct private_thread_info *pti;
371 pti = XCNEW (struct private_thread_info);
372 pti->gdb_port = new_id;
373 pti->msg_state = DARWIN_RUNNING;
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);
381 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
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);
390 gdb_assert_not_reached ("unexpected thread case");
393 if (darwin_inf->threads)
394 VEC_free (darwin_thread_t, darwin_inf->threads);
395 darwin_inf->threads = thread_vec;
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);
404 find_inferior_task_it (struct inferior *inf, void *port_ptr)
406 return inf->priv->task == *(task_t *)port_ptr;
410 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
412 return inf->pid == *(int *)pid_ptr;
415 /* Return an inferior by task port. */
416 static struct inferior *
417 darwin_find_inferior_by_task (task_t port)
419 return iterate_over_inferiors (&find_inferior_task_it, &port);
422 /* Return an inferior by pid port. */
423 static struct inferior *
424 darwin_find_inferior_by_pid (int pid)
426 return iterate_over_inferiors (&find_inferior_pid_it, &pid);
429 /* Return a thread by port. */
430 static darwin_thread_t *
431 darwin_find_thread (struct inferior *inf, thread_t thread)
437 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
439 if (t->gdb_port == thread)
444 /* Suspend (ie stop) an inferior at Mach level. */
447 darwin_suspend_inferior (struct inferior *inf)
449 if (!inf->priv->suspended)
453 kret = task_suspend (inf->priv->task);
454 MACH_CHECK_ERROR (kret);
456 inf->priv->suspended = 1;
460 /* Resume an inferior at Mach level. */
463 darwin_resume_inferior (struct inferior *inf)
465 if (inf->priv->suspended)
469 kret = task_resume (inf->priv->task);
470 MACH_CHECK_ERROR (kret);
472 inf->priv->suspended = 0;
476 /* Iterator functions. */
479 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
481 darwin_suspend_inferior (inf);
482 darwin_check_new_threads (inf);
487 darwin_resume_inferior_it (struct inferior *inf, void *arg)
489 darwin_resume_inferior (inf);
494 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
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);
506 const unsigned char *data;
507 const unsigned int *ldata;
511 data = (unsigned char *)(hdr + 1);
512 size = hdr->msgh_size - sizeof (mach_msg_header_t);
514 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
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);
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)
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);
534 printf_unfiltered (_(" descr %d: type=%u\n"),
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);
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"));
560 /* Adjust inferior data when a new task was created. */
562 static struct inferior *
563 darwin_find_new_inferior (task_t task_port, thread_t thread_port)
566 struct inferior *inf;
570 /* Find the corresponding pid. */
571 kret = pid_for_task (task_port, &task_pid);
572 if (kret != KERN_SUCCESS)
574 MACH_CHECK_ERROR (kret);
578 /* Find the inferior for this pid. */
579 inf = darwin_find_inferior_by_pid (task_pid);
583 /* Deallocate saved exception ports. */
584 darwin_deallocate_exception_ports (inf->priv);
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,
590 MACH_MSG_TYPE_MAKE_SEND_ONCE,
592 if (kret != KERN_INVALID_ARGUMENT)
593 MACH_CHECK_ERROR (kret);
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;
600 darwin_setup_request_notification (inf);
601 darwin_setup_exceptions (inf);
606 /* Check data representation. */
609 darwin_check_message_ndr (NDR_record_t *ndr)
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)
621 /* Decode an exception message. */
624 darwin_decode_exception_message (mach_msg_header_t *hdr,
625 struct inferior **pinf,
626 darwin_thread_t **pthread)
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);
632 struct inferior *inf;
633 darwin_thread_t *thread;
635 thread_t thread_port;
639 /* Check message destination. */
640 if (hdr->msgh_local_port != darwin_ex_port)
643 /* Check message header. */
644 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
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)
657 /* Check data representation. */
658 ndr = (NDR_record_t *)(desc + 2);
659 if (darwin_check_message_ndr (ndr) != 0)
662 /* Ok, the hard work. */
663 data = (integer_t *)(ndr + 1);
665 task_port = desc[1].name;
666 thread_port = desc[0].name;
668 /* Find process by port. */
669 inf = darwin_find_inferior_by_task (task_port);
672 if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
673 && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
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);
682 /* Deallocate task_port, unless it was saved. */
683 kret = mach_port_deallocate (mach_task_self (), task_port);
684 MACH_CHECK_ERROR (kret);
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);
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 ? */
701 mig_reply_error_t reply;
704 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
707 /* Free thread port (we don't know it). */
708 kret = mach_port_deallocate (mach_task_self (), thread_port);
709 MACH_CHECK_ERROR (kret);
711 darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
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,
717 MACH_CHECK_ERROR (kret);
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);
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);
732 thread = darwin_find_thread (inf, thread_port);
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);
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];
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)))
752 for (i = 0; i < data[1]; i++)
753 thread->event.ex_data[i] = data[2 + i];
755 thread->msg_state = DARWIN_MESSAGE;
760 /* Decode dead_name notify message. */
763 darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
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;
770 thread_t thread_port;
774 /* Check message header. */
775 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
778 /* Check descriptors. */
779 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
782 /* Check data representation. */
783 if (darwin_check_message_ndr (ndr) != 0)
788 /* Find process by port. */
789 inf = darwin_find_inferior_by_task (task_port);
792 /* Check message destination. */
793 if (inf != NULL && hdr->msgh_local_port != inf->priv->notify_port)
800 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
803 mach_msg_header_t *rh = &reply->Head;
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;
811 reply->NDR = NDR_record;
812 reply->RetCode = code;
816 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
819 mig_reply_error_t reply;
821 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
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,
827 MACH_CHECK_ERROR (kret);
829 inf->priv->pending_messages--;
833 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
834 int step, int nsignal)
840 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
841 thread->msg_state, thread->gdb_port, step, nsignal);
843 switch (thread->msg_state)
846 if (thread->event.ex_type == EXC_SOFTWARE
847 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
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);
853 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
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;
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;
871 darwin_send_reply (inf, thread);
872 thread->msg_state = DARWIN_RUNNING;
879 kret = thread_resume (thread->gdb_port);
880 MACH_CHECK_ERROR (kret);
882 thread->msg_state = DARWIN_RUNNING;
887 /* Resume all threads of the inferior. */
890 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
892 darwin_thread_t *thread;
896 VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
898 darwin_resume_thread (inf, thread, step, nsignal);
901 struct resume_inferior_threads_param
908 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
910 int step = ((struct resume_inferior_threads_param *)param)->step;
911 int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
913 darwin_resume_inferior_threads (inf, step, nsignal);
918 /* Suspend all threads of INF. */
921 darwin_suspend_inferior_threads (struct inferior *inf)
923 darwin_thread_t *thread;
928 VEC_iterate (darwin_thread_t, inf->priv->threads, k, thread);
930 switch (thread->msg_state)
936 kret = thread_suspend (thread->gdb_port);
937 MACH_CHECK_ERROR (kret);
938 thread->msg_state = DARWIN_STOPPED;
944 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
946 struct target_waitstatus status;
952 struct inferior *inf;
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);
958 if (signal == GDB_SIGNAL_0)
961 nsignal = gdb_signal_to_host (signal);
963 /* Don't try to single step all threads. */
965 ptid = inferior_ptid;
967 /* minus_one_ptid is RESUME_ALL. */
968 if (ptid_equal (ptid, minus_one_ptid))
970 struct resume_inferior_threads_param param;
972 param.nsignal = nsignal;
975 /* Resume threads. */
976 iterate_over_inferiors (darwin_resume_inferior_threads_it, ¶m);
978 iterate_over_inferiors (darwin_resume_inferior_it, NULL);
982 struct inferior *inf = find_inferior_ptid (ptid);
983 long tid = ptid_get_tid (ptid);
985 /* Stop the inferior (should be useless). */
986 darwin_suspend_inferior (inf);
989 darwin_resume_inferior_threads (inf, step, nsignal);
992 darwin_thread_t *thread;
994 /* Suspend threads of the task. */
995 darwin_suspend_inferior_threads (inf);
997 /* Resume the selected thread. */
998 thread = darwin_find_thread (inf, tid);
1000 darwin_resume_thread (inf, thread, step, nsignal);
1003 /* Resume the task. */
1004 darwin_resume_inferior (inf);
1009 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
1010 enum gdb_signal signal)
1012 return darwin_resume (ptid, step, signal);
1016 darwin_decode_message (mach_msg_header_t *hdr,
1017 darwin_thread_t **pthread,
1018 struct inferior **pinf,
1019 struct target_waitstatus *status)
1021 darwin_thread_t *thread;
1022 struct inferior *inf;
1024 /* Exception message. 2401 == 0x961 is exc. */
1025 if (hdr->msgh_id == 2401)
1029 /* Decode message. */
1030 res = darwin_decode_exception_message (hdr, &inf, &thread);
1034 /* Should not happen... */
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;
1043 status->kind = TARGET_WAITKIND_IGNORE;
1044 return minus_one_ptid;
1048 inf->priv->pending_messages++;
1050 status->kind = TARGET_WAITKIND_STOPPED;
1051 thread->msg_state = DARWIN_MESSAGE;
1053 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1055 unparse_exception_type (thread->event.ex_type));
1057 switch (thread->event.ex_type)
1059 case EXC_BAD_ACCESS:
1060 status->value.sig = GDB_EXC_BAD_ACCESS;
1062 case EXC_BAD_INSTRUCTION:
1063 status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1065 case EXC_ARITHMETIC:
1066 status->value.sig = GDB_EXC_ARITHMETIC;
1069 status->value.sig = GDB_EXC_EMULATION;
1072 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
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));
1080 /* If the thread is stopped because it has received a signal
1081 that gdb has just sent, continue. */
1082 if (thread->signaled)
1084 thread->signaled = 0;
1085 darwin_send_reply (inf, thread);
1086 thread->msg_state = DARWIN_RUNNING;
1087 status->kind = TARGET_WAITKIND_IGNORE;
1091 status->value.sig = GDB_EXC_SOFTWARE;
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;
1100 status->value.sig = GDB_SIGNAL_UNKNOWN;
1104 return ptid_build (inf->pid, 0, thread->gdb_port);
1106 else if (hdr->msgh_id == 0x48)
1108 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1111 res = darwin_decode_notify_message (hdr, &inf);
1115 /* Should not happen... */
1117 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1124 if (res < 0 || inf == NULL)
1126 status->kind = TARGET_WAITKIND_IGNORE;
1127 return minus_one_ptid;
1132 if (!inf->priv->no_ptrace)
1137 res = wait4 (inf->pid, &wstatus, 0, NULL);
1138 if (res < 0 || res != inf->pid)
1140 printf_unfiltered (_("wait4: res=%d: %s\n"),
1141 res, safe_strerror (errno));
1142 status->kind = TARGET_WAITKIND_IGNORE;
1143 return minus_one_ptid;
1145 if (WIFEXITED (wstatus))
1147 status->kind = TARGET_WAITKIND_EXITED;
1148 status->value.integer = WEXITSTATUS (wstatus);
1152 status->kind = TARGET_WAITKIND_SIGNALLED;
1153 status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1156 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1159 /* Looks necessary on Leopard and harmless... */
1160 wait4 (inf->pid, &wstatus, 0, NULL);
1162 inferior_ptid = ptid_build (inf->pid, 0, 0);
1163 return inferior_ptid;
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);
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;
1182 cancel_breakpoint (ptid_t ptid)
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.
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
1192 struct regcache *regcache = get_thread_regcache (ptid);
1193 struct gdbarch *gdbarch = regcache->arch ();
1196 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1197 if (breakpoint_inserted_here_p (regcache->aspace (), pc))
1199 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1200 (unsigned long) ptid_get_tid (ptid));
1202 /* Back up the PC if necessary. */
1203 if (gdbarch_decr_pc_after_break (gdbarch))
1204 regcache_write_pc (regcache, pc);
1212 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1217 mach_msg_header_t hdr;
1220 mach_msg_header_t *hdr = &msgin.hdr;
1222 darwin_thread_t *thread;
1223 struct inferior *inf;
1226 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1227 ptid_get_pid (ptid), ptid_get_tid (ptid));
1229 /* Handle fake stop events at first. */
1230 if (darwin_inf_fake_stop != NULL)
1232 inf = darwin_inf_fake_stop;
1233 darwin_inf_fake_stop = NULL;
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);
1244 /* set_sigint_trap (); */
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);
1250 /* clear_sigint_trap (); */
1252 if (kret == MACH_RCV_INTERRUPTED)
1254 status->kind = TARGET_WAITKIND_IGNORE;
1255 return minus_one_ptid;
1258 if (kret != MACH_MSG_SUCCESS)
1260 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1261 status->kind = TARGET_WAITKIND_SPURIOUS;
1262 return minus_one_ptid;
1265 /* Debug: display message. */
1266 if (darwin_debug_flag > 10)
1267 darwin_dump_message (hdr, darwin_debug_flag > 11);
1269 res = darwin_decode_message (hdr, &thread, &inf, status);
1270 if (ptid_equal (res, minus_one_ptid))
1273 /* Early return in case an inferior has exited. */
1277 while (status->kind == TARGET_WAITKIND_IGNORE);
1279 /* Stop all tasks. */
1280 iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1282 /* Read pending messages. */
1285 struct target_waitstatus status2;
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);
1292 if (kret == MACH_RCV_TIMED_OUT)
1294 if (kret != MACH_MSG_SUCCESS)
1297 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1301 /* Debug: display message. */
1302 if (darwin_debug_flag > 10)
1303 darwin_dump_message (hdr, darwin_debug_flag > 11);
1305 ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1307 if (inf != NULL && thread != NULL
1308 && thread->event.ex_type == EXC_BREAKPOINT)
1310 if (thread->single_step
1311 || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1313 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1314 darwin_send_reply (inf, thread);
1315 thread->msg_state = DARWIN_RUNNING;
1319 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1323 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1329 darwin_wait_to (struct target_ops *ops,
1330 ptid_t ptid, struct target_waitstatus *status, int options)
1332 return darwin_wait (ptid, status);
1336 darwin_interrupt (struct target_ops *self, ptid_t t)
1338 struct inferior *inf = current_inferior ();
1340 /* FIXME: handle in no_ptrace mode. */
1341 gdb_assert (!inf->priv->no_ptrace);
1342 kill (inf->pid, SIGINT);
1345 /* Deallocate threads port and vector. */
1348 darwin_deallocate_threads (struct inferior *inf)
1350 if (inf->priv->threads)
1356 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1359 kret = mach_port_deallocate (gdb_task, t->gdb_port);
1360 MACH_CHECK_ERROR (kret);
1362 VEC_free (darwin_thread_t, inf->priv->threads);
1363 inf->priv->threads = NULL;
1368 darwin_mourn_inferior (struct target_ops *ops)
1370 struct inferior *inf = current_inferior ();
1375 /* Deallocate threads. */
1376 darwin_deallocate_threads (inf);
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);
1383 /* Remove task port dead_name notification. */
1384 kret = mach_port_request_notification (gdb_task, inf->priv->task,
1385 MACH_NOTIFY_DEAD_NAME, 0,
1387 MACH_MSG_TYPE_MAKE_SEND_ONCE,
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);
1393 if (kret == KERN_SUCCESS)
1395 kret = mach_port_deallocate (gdb_task, prev);
1396 MACH_CHECK_ERROR (kret);
1399 /* Destroy notify_port. */
1400 kret = mach_port_destroy (gdb_task, inf->priv->notify_port);
1401 MACH_CHECK_ERROR (kret);
1403 /* Deallocate saved exception ports. */
1404 darwin_deallocate_exception_ports (inf->priv);
1406 /* Deallocate task port. */
1407 kret = mach_port_deallocate (gdb_task, inf->priv->task);
1408 MACH_CHECK_ERROR (kret);
1413 inf_child_mourn_inferior (ops);
1417 darwin_reply_to_all_pending_messages (struct inferior *inf)
1423 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
1426 if (t->msg_state == DARWIN_MESSAGE)
1427 darwin_resume_thread (inf, t, 0, 0);
1432 darwin_stop_inferior (struct inferior *inf)
1434 struct target_waitstatus wstatus;
1440 gdb_assert (inf != NULL);
1442 darwin_suspend_inferior (inf);
1444 darwin_reply_to_all_pending_messages (inf);
1446 if (inf->priv->no_ptrace)
1449 res = kill (inf->pid, SIGSTOP);
1451 warning (_("cannot kill: %s"), safe_strerror (errno));
1453 /* Wait until the process is really stopped. */
1456 ptid = darwin_wait (inferior_ptid, &wstatus);
1457 if (wstatus.kind == TARGET_WAITKIND_STOPPED
1458 && wstatus.value.sig == GDB_SIGNAL_STOP)
1463 static kern_return_t
1464 darwin_save_exception_ports (darwin_inferior *inf)
1468 inf->exception_info.count =
1469 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
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);
1478 static kern_return_t
1479 darwin_restore_exception_ports (darwin_inferior *inf)
1484 for (i = 0; i < inf->exception_info.count; i++)
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)
1493 return KERN_SUCCESS;
1496 /* Deallocate saved exception ports. */
1499 darwin_deallocate_exception_ports (darwin_inferior *inf)
1504 for (i = 0; i < inf->exception_info.count; i++)
1506 kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1507 MACH_CHECK_ERROR (kret);
1509 inf->exception_info.count = 0;
1513 darwin_setup_exceptions (struct inferior *inf)
1517 exception_mask_t mask;
1519 kret = darwin_save_exception_ports (inf->priv);
1520 if (kret != KERN_SUCCESS)
1521 error (_("Unable to save exception ports, task_get_exception_ports"
1525 /* Set exception port. */
1526 if (enable_mach_exceptions)
1527 mask = EXC_MASK_ALL;
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"
1539 darwin_kill_inferior (struct target_ops *ops)
1541 struct inferior *inf = current_inferior ();
1542 struct target_waitstatus wstatus;
1548 if (ptid_equal (inferior_ptid, null_ptid))
1551 gdb_assert (inf != NULL);
1553 kret = darwin_restore_exception_ports (inf->priv);
1554 MACH_CHECK_ERROR (kret);
1556 darwin_reply_to_all_pending_messages (inf);
1558 res = kill (inf->pid, 9);
1562 darwin_resume_inferior (inf);
1564 ptid = darwin_wait (inferior_ptid, &wstatus);
1566 else if (errno != ESRCH)
1567 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1568 inf->pid, safe_strerror (errno));
1570 target_mourn_inferior (inferior_ptid);
1574 darwin_setup_request_notification (struct inferior *inf)
1577 mach_port_t prev_not;
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,
1584 if (kret != KERN_SUCCESS)
1585 error (_("Termination notification request failed, "
1586 "mach_port_request_notification\n"
1589 if (prev_not != MACH_PORT_NULL)
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. */
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."));
1602 darwin_attach_pid (struct inferior *inf)
1605 mach_port_t prev_port;
1607 mach_port_t prev_not;
1608 exception_mask_t mask;
1610 inf->priv = XCNEW (darwin_inferior);
1612 kret = task_for_pid (gdb_task, inf->pid, &inf->priv->task);
1613 if (kret != KERN_SUCCESS)
1617 if (!inf->attach_flag)
1620 waitpid (inf->pid, &status, 0);
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);
1628 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1629 inf->priv->task, inf->pid);
1631 if (darwin_ex_port == MACH_PORT_NULL)
1633 /* Create a port to get exceptions. */
1634 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1636 if (kret != KERN_SUCCESS)
1637 error (_("Unable to create exception port, mach_port_allocate "
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 "
1648 /* Create a port set and put ex_port in it. */
1649 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1651 if (kret != KERN_SUCCESS)
1652 error (_("Unable to create port set, mach_port_allocate "
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"
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 "
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"
1680 darwin_setup_request_notification (inf);
1682 darwin_setup_exceptions (inf);
1684 if (!target_is_pushed (darwin_ops))
1685 push_target (darwin_ops);
1688 /* Get the thread_info object corresponding to this private_thread_info. */
1690 static struct thread_info *
1691 thread_info_from_private_thread_info (private_thread_info *pti)
1693 struct thread_info *it;
1697 if (it->priv->gdb_port == pti->gdb_port)
1701 gdb_assert (it != NULL);
1707 darwin_init_thread_list (struct inferior *inf)
1709 darwin_check_new_threads (inf);
1711 gdb_assert (inf->priv->threads != NULL);
1712 gdb_assert (VEC_length (darwin_thread_t, inf->priv->threads) > 0);
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);
1719 inferior_ptid = first_thread->ptid;
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];
1728 darwin_ptrace_me (void)
1733 /* Close write end point. */
1734 if (close (ptrace_fds[1]) < 0)
1735 trace_start_error_with_name ("close");
1737 /* Wait until gdb is ready. */
1738 res = read (ptrace_fds[0], &c, 1);
1740 trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1742 if (close (ptrace_fds[0]) < 0)
1743 trace_start_error_with_name ("close");
1745 /* Get rid of privileges. */
1746 if (setegid (getgid ()) < 0)
1747 trace_start_error_with_name ("setegid");
1750 if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1751 trace_start_error_with_name ("PTRACE");
1753 /* Redirect signals to exception port. */
1754 if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1755 trace_start_error_with_name ("PTRACE");
1758 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1760 darwin_pre_ptrace (void)
1762 if (pipe (ptrace_fds) != 0)
1766 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1769 mark_fd_no_cloexec (ptrace_fds[0]);
1770 mark_fd_no_cloexec (ptrace_fds[1]);
1774 darwin_ptrace_him (int pid)
1778 mach_port_t prev_port;
1780 struct inferior *inf = current_inferior ();
1782 darwin_attach_pid (inf);
1784 /* Let's the child run. */
1785 close (ptrace_fds[0]);
1786 close (ptrace_fds[1]);
1788 unmark_fd_no_cloexec (ptrace_fds[0]);
1789 unmark_fd_no_cloexec (ptrace_fds[1]);
1791 darwin_init_thread_list (inf);
1793 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1797 darwin_execvp (const char *file, char * const argv[], char * const env[])
1799 posix_spawnattr_t attr;
1803 res = posix_spawnattr_init (&attr);
1807 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1811 /* Do like execve: replace the image. */
1812 ps_flags = POSIX_SPAWN_SETEXEC;
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
1819 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1820 res = posix_spawnattr_setflags (&attr, ps_flags);
1823 fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1827 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1831 darwin_create_inferior (struct target_ops *ops,
1832 const char *exec_file,
1833 const std::string &allargs,
1834 char **env, int from_tty)
1836 /* Do the hard work. */
1837 fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1838 darwin_ptrace_him, darwin_pre_ptrace, NULL,
1843 /* Set things up such that the next call to darwin_wait will immediately
1844 return a fake stop event for inferior INF.
1846 This assumes that the inferior's thread list has been initialized,
1847 as it will suspend the inferior's first thread. */
1850 darwin_setup_fake_stop_event (struct inferior *inf)
1852 darwin_thread_t *thread;
1855 gdb_assert (darwin_inf_fake_stop == NULL);
1856 darwin_inf_fake_stop = inf;
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);
1869 /* Attach to process PID, then initialize for debugging it
1870 and wait for the trace-trap that results from attaching. */
1872 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1878 struct inferior *inf;
1881 pid = parse_pid_to_attach (args);
1883 if (pid == getpid ()) /* Trying to masturbate? */
1884 error (_("I refuse to debug myself!"));
1888 char *exec_file = get_exec_file (0);
1891 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1892 target_pid_to_str (pid_to_ptid (pid)));
1894 printf_unfiltered (_("Attaching to %s\n"),
1895 target_pid_to_str (pid_to_ptid (pid)));
1897 gdb_flush (gdb_stdout);
1900 if (pid == 0 || kill (pid, 0) < 0)
1901 error (_("Can't attach to process %d: %s (%d)"),
1902 pid, safe_strerror (errno), errno);
1904 inferior_ptid = pid_to_ptid (pid);
1905 inf = current_inferior ();
1906 inferior_appeared (inf, pid);
1907 inf->attach_flag = 1;
1909 darwin_attach_pid (inf);
1911 darwin_suspend_inferior (inf);
1913 darwin_init_thread_list (inf);
1915 darwin_check_osabi (inf->priv, ptid_get_tid (inferior_ptid));
1917 darwin_setup_fake_stop_event (inf);
1919 inf->priv->no_ptrace = 1;
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. */
1930 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1932 pid_t pid = ptid_get_pid (inferior_ptid);
1933 struct inferior *inf = current_inferior ();
1937 /* Display message. */
1938 target_announce_detach (from_tty);
1940 /* If ptrace() is in use, stop the process. */
1941 if (!inf->priv->no_ptrace)
1942 darwin_stop_inferior (inf);
1944 kret = darwin_restore_exception_ports (inf->priv);
1945 MACH_CHECK_ERROR (kret);
1947 if (!inf->priv->no_ptrace)
1949 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1951 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1952 inf->pid, safe_strerror (errno), errno);
1955 darwin_reply_to_all_pending_messages (inf);
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);
1963 darwin_mourn_inferior (ops);
1967 darwin_files_info (struct target_ops *ops)
1972 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1974 static char buf[80];
1975 long tid = ptid_get_tid (ptid);
1979 snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1980 tid, ptid_get_pid (ptid));
1984 return normal_pid_to_str (ptid);
1988 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
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. */
2000 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2001 gdb_byte *rdaddr, const gdb_byte *wraddr,
2005 mach_vm_size_t res_length = 0;
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;
2012 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2013 task, core_addr_to_string (addr), pulongest (length));
2018 mach_vm_size_t count;
2020 /* According to target.h(to_xfer_partial), one and only one may be
2022 gdb_assert (wraddr == NULL);
2024 kret = mach_vm_read_overwrite (task, addr, length,
2025 (mach_vm_address_t) rdaddr, &count);
2026 if (kret != KERN_SUCCESS)
2029 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2030 core_addr_to_string (addr), mach_error_string (kret));
2037 gdb_assert (wraddr != NULL);
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;
2052 /* Read page protection. */
2053 kret = mach_vm_region_recurse
2054 (task, ®ion_start, ®ion_length, ®ion_depth,
2055 (vm_region_recurse_info_t) &info, &count);
2057 if (kret != KERN_SUCCESS)
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));
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));
2073 /* Check for holes in memory. */
2074 if (region_start > region_address)
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);
2083 /* Adjust the length. */
2084 region_length -= (region_address - region_start);
2085 if (region_length > aligned_length)
2086 region_length = aligned_length;
2088 /* Make the pages RW. */
2089 if (!(info.protection & VM_PROT_WRITE))
2091 vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2093 kret = mach_vm_protect (task, region_address, region_length,
2095 if (kret != KERN_SUCCESS)
2097 prot |= VM_PROT_COPY;
2098 kret = mach_vm_protect (task, region_address, region_length,
2101 if (kret != KERN_SUCCESS)
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));
2113 if (offset + length > region_length)
2114 write_length = region_length - offset;
2116 write_length = length;
2119 kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2120 if (kret != KERN_SUCCESS)
2122 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2123 mach_error_string (kret));
2127 /* Restore page rights. */
2128 if (!(info.protection & VM_PROT_WRITE))
2130 kret = mach_vm_protect (task, region_address, region_length,
2131 FALSE, info.protection);
2132 if (kret != KERN_SUCCESS)
2134 warning (_("darwin_read_write_inferior: "
2135 "mach_vm_protect restore failed at %s "
2137 core_addr_to_string (region_address),
2138 (unsigned long) region_length,
2139 mach_error_string (kret));
2143 addr += write_length;
2144 wraddr += write_length;
2145 res_length += write_length;
2146 length -= write_length;
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. */
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)
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);
2167 if (addr != 0 || length > sizeof (mach_vm_address_t))
2168 return TARGET_XFER_EOF;
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;
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;
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)
2191 struct inferior *inf = current_inferior ();
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),
2201 case TARGET_OBJECT_MEMORY:
2203 int l = darwin_read_write_inferior (inf->priv->task, offset,
2204 readbuf, writebuf, len);
2207 return TARGET_XFER_EOF;
2211 *xfered_len = (ULONGEST) l;
2212 return TARGET_XFER_OK;
2215 #ifdef TASK_DYLD_INFO_COUNT
2216 case TARGET_OBJECT_DARWIN_DYLD_INFO:
2217 if (writebuf != NULL || readbuf == NULL)
2219 /* Support only read. */
2220 return TARGET_XFER_E_IO;
2222 return darwin_read_dyld_info (inf->priv->task, offset, readbuf, len,
2226 return TARGET_XFER_E_IO;
2232 set_enable_mach_exceptions (char *args, int from_tty,
2233 struct cmd_list_element *c)
2235 if (!ptid_equal (inferior_ptid, null_ptid))
2237 struct inferior *inf = current_inferior ();
2238 exception_mask_t mask;
2241 if (enable_mach_exceptions)
2242 mask = EXC_MASK_ALL;
2245 darwin_restore_exception_ports (inf->priv);
2246 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2248 kret = task_set_exception_ports (inf->priv->task, mask, darwin_ex_port,
2249 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2250 MACH_CHECK_ERROR (kret);
2255 darwin_pid_to_exec_file (struct target_ops *self, int pid)
2257 static char path[PATH_MAX];
2260 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2268 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2273 struct inferior *inf = current_inferior ();
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;
2281 /* First linear search. */
2283 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2285 if (t->inf_port == lwp)
2286 return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2288 /* Maybe the port was never extract. Do it now. */
2290 /* First get inferior port names. */
2291 kret = mach_port_names (inf->priv->task, &names, &names_count, &types,
2293 MACH_CHECK_ERROR (kret);
2294 if (kret != KERN_SUCCESS)
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
2300 for (i = 0; i < names_count; i++)
2302 mach_port_t local_name;
2303 mach_msg_type_name_t local_type;
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)
2312 mach_port_deallocate (gdb_task, local_name);
2315 VEC_iterate (darwin_thread_t, inf->priv->threads, k, t);
2317 if (t->gdb_port == local_name)
2319 t->inf_port = names[i];
2320 if (names[i] == lwp)
2325 vm_deallocate (gdb_task, (vm_address_t) names,
2326 names_count * sizeof (mach_port_t));
2329 return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2335 darwin_supports_multi_process (struct target_ops *self)
2341 _initialize_darwin_inferior (void)
2345 gdb_task = mach_task_self ();
2346 darwin_host_self = mach_host_self ();
2348 /* Read page size. */
2349 kret = host_page_size (darwin_host_self, &mach_page_size);
2350 if (kret != KERN_SUCCESS)
2352 mach_page_size = 0x1000;
2353 MACH_CHECK_ERROR (kret);
2356 darwin_ops = inf_child_target ();
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;
2376 darwin_complete_target (darwin_ops);
2378 add_target (darwin_ops);
2380 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2381 (unsigned long) mach_task_self (), getpid ());
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,
2388 &setdebuglist, &showdebuglist);
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);