1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2018 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 ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
88 static void darwin_ptrace_me (void);
90 static void darwin_ptrace_him (int pid);
92 static void darwin_encode_reply (mig_reply_error_t *reply,
93 mach_msg_header_t *hdr, integer_t code);
95 static void darwin_setup_request_notification (struct inferior *inf);
96 static void darwin_deallocate_exception_ports (darwin_inferior *inf);
97 static void darwin_setup_exceptions (struct inferior *inf);
98 static void darwin_deallocate_threads (struct inferior *inf);
100 /* Task identifier of gdb. */
101 static task_t gdb_task;
103 /* A copy of mach_host_self (). */
104 mach_port_t darwin_host_self;
106 /* Exception port. */
107 mach_port_t darwin_ex_port;
109 /* Port set, to wait for answer on all ports. */
110 mach_port_t darwin_port_set;
113 static vm_size_t mach_page_size;
115 /* If Set, catch all mach exceptions (before they are converted to signals
117 static int enable_mach_exceptions;
119 /* Inferior that should report a fake stop event. */
120 static struct inferior *darwin_inf_fake_stop;
122 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
123 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
125 /* This controls output of inferior debugging. */
126 static unsigned int darwin_debug_flag = 0;
128 /* Create a __TEXT __info_plist section in the executable so that gdb could
129 be signed. This is required to get an authorization for task_for_pid.
131 Once gdb is built, you must codesign it with any system-trusted signing
132 authority. See taskgated(8) for details. */
133 static const unsigned char info_plist[]
134 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
135 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
136 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
137 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
138 "<plist version=\"1.0\">\n"
140 " <key>CFBundleIdentifier</key>\n"
141 " <string>org.gnu.gdb</string>\n"
142 " <key>CFBundleName</key>\n"
143 " <string>gdb</string>\n"
144 " <key>CFBundleVersion</key>\n"
145 " <string>1.0</string>\n"
146 " <key>SecTaskAccess</key>\n"
148 " <string>allowed</string>\n"
149 " <string>debug</string>\n"
154 static void inferior_debug (int level, const char *fmt, ...)
155 ATTRIBUTE_PRINTF (2, 3);
158 inferior_debug (int level, const char *fmt, ...)
162 if (darwin_debug_flag < level)
166 printf_unfiltered (_("[%d inferior]: "), getpid ());
167 vprintf_unfiltered (fmt, ap);
172 mach_check_error (kern_return_t ret, const char *file,
173 unsigned int line, const char *func)
175 if (ret == KERN_SUCCESS)
178 func = _("[UNKNOWN]");
180 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
181 file, line, func, mach_error_string (ret), (unsigned long) ret);
185 unparse_exception_type (unsigned int i)
187 static char unknown_exception_buf[32];
192 return "EXC_BAD_ACCESS";
193 case EXC_BAD_INSTRUCTION:
194 return "EXC_BAD_INSTRUCTION";
196 return "EXC_ARITHMETIC";
198 return "EXC_EMULATION";
200 return "EXC_SOFTWARE";
202 return "EXC_BREAKPOINT";
204 return "EXC_SYSCALL";
205 case EXC_MACH_SYSCALL:
206 return "EXC_MACH_SYSCALL";
208 return "EXC_RPC_ALERT";
212 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
213 return unknown_exception_buf;
217 /* Set errno to zero, and then call ptrace with the given arguments.
218 If inferior debugging traces are on, then also print a debug
221 The returned value is the same as the value returned by ptrace,
222 except in the case where that value is -1 but errno is zero.
223 This case is documented to be a non-error situation, so we
224 return zero in that case. */
227 darwin_ptrace (const char *name,
228 int request, int pid, caddr_t arg3, int arg4)
233 ret = ptrace (request, pid, arg3, arg4);
234 if (ret == -1 && errno == 0)
237 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
238 name, pid, (unsigned long) arg3, arg4, ret,
239 (ret != 0) ? safe_strerror (errno) : _("no error"));
244 cmp_thread_t (const void *l, const void *r)
246 thread_t tl = *(const thread_t *)l;
247 thread_t tr = *(const thread_t *)r;
248 return (int)(tl - tr);
252 darwin_check_new_threads (struct inferior *inf)
255 thread_array_t thread_list;
256 unsigned int new_nbr;
257 unsigned int old_nbr;
258 unsigned int new_ix, old_ix;
259 darwin_inferior *darwin_inf = get_darwin_inferior (inf);
260 std::vector<darwin_thread_t *> new_thread_vec;
262 if (darwin_inf == nullptr)
265 /* Get list of threads. */
266 kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
267 MACH_CHECK_ERROR (kret);
268 if (kret != KERN_SUCCESS)
273 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
275 old_nbr = darwin_inf->threads.size ();
277 /* Quick check for no changes. */
278 if (old_nbr == new_nbr)
282 for (i = 0; i < new_nbr; i++)
283 if (thread_list[i] != darwin_inf->threads[i]->gdb_port)
287 /* Deallocate ports. */
288 for (i = 0; i < new_nbr; i++)
290 kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
291 MACH_CHECK_ERROR (kret);
294 /* Deallocate the buffer. */
295 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
296 new_nbr * sizeof (int));
297 MACH_CHECK_ERROR (kret);
303 /* Full handling: detect new threads, remove dead threads. */
305 new_thread_vec.reserve (new_nbr);
307 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
309 thread_t new_id = (new_ix < new_nbr) ? thread_list[new_ix] : THREAD_NULL;
311 = (old_ix < old_nbr) ? darwin_inf->threads[old_ix] : NULL;
312 thread_t old_id = old != NULL ? old->gdb_port : THREAD_NULL;
315 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
316 new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
318 if (old_id == new_id)
320 /* Thread still exist. */
321 new_thread_vec.push_back (old);
325 /* Deallocate the port. */
326 kret = mach_port_deallocate (gdb_task, new_id);
327 MACH_CHECK_ERROR (kret);
331 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
333 /* Ignore dead ports.
334 In some weird cases, we might get dead ports. They should
335 correspond to dead thread so they could safely be ignored. */
339 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
341 /* A thread was created. */
342 darwin_thread_info *pti = new darwin_thread_info;
344 pti->gdb_port = new_id;
345 pti->msg_state = DARWIN_RUNNING;
347 /* Add the new thread. */
348 add_thread_with_info (ptid_t (inf->pid, 0, new_id), pti);
349 new_thread_vec.push_back (pti);
353 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
355 /* A thread was removed. */
356 struct thread_info *thr
357 = find_thread_ptid (ptid_t (inf->pid, 0, old_id));
359 kret = mach_port_deallocate (gdb_task, old_id);
360 MACH_CHECK_ERROR (kret);
364 gdb_assert_not_reached ("unexpected thread case");
367 darwin_inf->threads = std::move (new_thread_vec);
369 /* Deallocate the buffer. */
370 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
371 new_nbr * sizeof (int));
372 MACH_CHECK_ERROR (kret);
376 find_inferior_task_it (struct inferior *inf, void *port_ptr)
378 darwin_inferior *priv = get_darwin_inferior (inf);
380 return priv != nullptr && priv->task == *(task_t *)port_ptr;
384 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
386 return inf->pid == *(int *)pid_ptr;
389 /* Return an inferior by task port. */
390 static struct inferior *
391 darwin_find_inferior_by_task (task_t port)
393 return iterate_over_inferiors (&find_inferior_task_it, &port);
396 /* Return an inferior by pid port. */
397 static struct inferior *
398 darwin_find_inferior_by_pid (int pid)
400 return iterate_over_inferiors (&find_inferior_pid_it, &pid);
403 /* Return a thread by port. */
404 static darwin_thread_t *
405 darwin_find_thread (struct inferior *inf, thread_t thread)
407 darwin_inferior *priv = get_darwin_inferior (inf);
410 for (darwin_thread_t *t : priv->threads)
412 if (t->gdb_port == thread)
419 /* Suspend (ie stop) an inferior at Mach level. */
422 darwin_suspend_inferior (struct inferior *inf)
424 darwin_inferior *priv = get_darwin_inferior (inf);
426 if (priv != nullptr && !priv->suspended)
430 kret = task_suspend (priv->task);
431 MACH_CHECK_ERROR (kret);
437 /* Resume an inferior at Mach level. */
440 darwin_resume_inferior (struct inferior *inf)
442 darwin_inferior *priv = get_darwin_inferior (inf);
444 if (priv != nullptr && priv->suspended)
448 kret = task_resume (priv->task);
449 MACH_CHECK_ERROR (kret);
455 /* Iterator functions. */
458 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
460 darwin_suspend_inferior (inf);
461 darwin_check_new_threads (inf);
466 darwin_resume_inferior_it (struct inferior *inf, void *arg)
468 darwin_resume_inferior (inf);
473 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
475 printf_unfiltered (_("message header:\n"));
476 printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
477 printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
478 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
479 printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
480 printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
481 printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
485 const unsigned char *data;
486 const unsigned int *ldata;
490 data = (unsigned char *)(hdr + 1);
491 size = hdr->msgh_size - sizeof (mach_msg_header_t);
493 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
495 mach_msg_body_t *bod = (mach_msg_body_t*)data;
496 mach_msg_port_descriptor_t *desc =
497 (mach_msg_port_descriptor_t *)(bod + 1);
500 printf_unfiltered (_("body: descriptor_count=%u\n"),
501 bod->msgh_descriptor_count);
502 data += sizeof (mach_msg_body_t);
503 size -= sizeof (mach_msg_body_t);
504 for (k = 0; k < bod->msgh_descriptor_count; k++)
505 switch (desc[k].type)
507 case MACH_MSG_PORT_DESCRIPTOR:
509 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
510 k, desc[k].type, desc[k].name, desc[k].disposition);
513 printf_unfiltered (_(" descr %d: type=%u\n"),
517 data += bod->msgh_descriptor_count
518 * sizeof (mach_msg_port_descriptor_t);
519 size -= bod->msgh_descriptor_count
520 * sizeof (mach_msg_port_descriptor_t);
521 ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
523 (_("NDR: mig=%02x if=%02x encod=%02x "
524 "int=%02x char=%02x float=%02x\n"),
525 ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
526 ndr->int_rep, ndr->char_rep, ndr->float_rep);
527 data += sizeof (NDR_record_t);
528 size -= sizeof (NDR_record_t);
531 printf_unfiltered (_(" data:"));
532 ldata = (const unsigned int *)data;
533 for (i = 0; i < size / sizeof (unsigned int); i++)
534 printf_unfiltered (" %08x", ldata[i]);
535 printf_unfiltered (_("\n"));
539 /* Adjust inferior data when a new task was created. */
541 static struct inferior *
542 darwin_find_new_inferior (task_t task_port, thread_t thread_port)
545 struct inferior *inf;
549 /* Find the corresponding pid. */
550 kret = pid_for_task (task_port, &task_pid);
551 if (kret != KERN_SUCCESS)
553 MACH_CHECK_ERROR (kret);
557 /* Find the inferior for this pid. */
558 inf = darwin_find_inferior_by_pid (task_pid);
562 darwin_inferior *priv = get_darwin_inferior (inf);
564 /* Deallocate saved exception ports. */
565 darwin_deallocate_exception_ports (priv);
567 /* No need to remove dead_name notification, but still... */
568 kret = mach_port_request_notification (gdb_task, priv->task,
569 MACH_NOTIFY_DEAD_NAME, 0,
571 MACH_MSG_TYPE_MAKE_SEND_ONCE,
573 if (kret != KERN_INVALID_ARGUMENT)
574 MACH_CHECK_ERROR (kret);
576 /* Replace old task port. */
577 kret = mach_port_deallocate (gdb_task, priv->task);
578 MACH_CHECK_ERROR (kret);
579 priv->task = task_port;
581 darwin_setup_request_notification (inf);
582 darwin_setup_exceptions (inf);
587 /* Check data representation. */
590 darwin_check_message_ndr (NDR_record_t *ndr)
592 if (ndr->mig_vers != NDR_PROTOCOL_2_0
593 || ndr->if_vers != NDR_PROTOCOL_2_0
594 || ndr->mig_encoding != NDR_record.mig_encoding
595 || ndr->int_rep != NDR_record.int_rep
596 || ndr->char_rep != NDR_record.char_rep
597 || ndr->float_rep != NDR_record.float_rep)
602 /* Decode an exception message. */
605 darwin_decode_exception_message (mach_msg_header_t *hdr,
606 struct inferior **pinf,
607 darwin_thread_t **pthread)
609 mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
610 mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
613 struct inferior *inf;
614 darwin_thread_t *thread;
616 thread_t thread_port;
620 /* Check message destination. */
621 if (hdr->msgh_local_port != darwin_ex_port)
624 /* Check message header. */
625 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
628 /* Check descriptors. */
629 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
630 + sizeof (*ndr) + 2 * sizeof (integer_t))
631 || bod->msgh_descriptor_count != 2
632 || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
633 || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
634 || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
635 || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
638 /* Check data representation. */
639 ndr = (NDR_record_t *)(desc + 2);
640 if (darwin_check_message_ndr (ndr) != 0)
643 /* Ok, the hard work. */
644 data = (integer_t *)(ndr + 1);
646 task_port = desc[1].name;
647 thread_port = desc[0].name;
649 /* Find process by port. */
650 inf = darwin_find_inferior_by_task (task_port);
653 if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
654 && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
656 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
657 as a new Mach task is created when a process exec. */
658 inf = darwin_find_new_inferior (task_port, thread_port);
663 /* Deallocate task_port, unless it was saved. */
664 kret = mach_port_deallocate (mach_task_self (), task_port);
665 MACH_CHECK_ERROR (kret);
670 /* We got new rights to the task, get rid of it. Do not get rid of
671 thread right, as we will need it to find the thread. */
672 kret = mach_port_deallocate (mach_task_self (), task_port);
673 MACH_CHECK_ERROR (kret);
678 /* Not a known inferior. This could happen if the child fork, as
679 the created process will inherit its exception port.
680 FIXME: should the exception port be restored ? */
682 mig_reply_error_t reply;
685 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
688 /* Free thread port (we don't know it). */
689 kret = mach_port_deallocate (mach_task_self (), thread_port);
690 MACH_CHECK_ERROR (kret);
692 darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
694 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
695 reply.Head.msgh_size, 0,
696 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
698 MACH_CHECK_ERROR (kret);
703 /* Find thread by port. */
704 /* Check for new threads. Do it early so that the port in the exception
705 message can be deallocated. */
706 darwin_check_new_threads (inf);
708 /* Free the thread port (as gdb knows the thread, it has already has a right
709 for it, so this just decrement a reference counter). */
710 kret = mach_port_deallocate (mach_task_self (), thread_port);
711 MACH_CHECK_ERROR (kret);
713 thread = darwin_find_thread (inf, thread_port);
718 /* The thread should be running. However we have observed cases where a
719 thread got a SIGTTIN message after being stopped. */
720 gdb_assert (thread->msg_state != DARWIN_MESSAGE);
722 /* Finish decoding. */
723 thread->event.header = *hdr;
724 thread->event.thread_port = thread_port;
725 thread->event.task_port = task_port;
726 thread->event.ex_type = data[0];
727 thread->event.data_count = data[1];
729 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
730 + sizeof (*ndr) + 2 * sizeof (integer_t)
731 + data[1] * sizeof (integer_t)))
733 for (i = 0; i < data[1]; i++)
734 thread->event.ex_data[i] = data[2 + i];
736 thread->msg_state = DARWIN_MESSAGE;
741 /* Decode dead_name notify message. */
744 darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
746 NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
747 integer_t *data = (integer_t *)(ndr + 1);
748 struct inferior *inf;
751 /* Check message header. */
752 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
755 /* Check descriptors. */
756 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
759 /* Check data representation. */
760 if (darwin_check_message_ndr (ndr) != 0)
765 /* Find process by port. */
766 inf = darwin_find_inferior_by_task (task_port);
769 /* Check message destination. */
772 darwin_inferior *priv = get_darwin_inferior (inf);
773 if (hdr->msgh_local_port != priv->notify_port)
781 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
784 mach_msg_header_t *rh = &reply->Head;
786 rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
787 rh->msgh_remote_port = hdr->msgh_remote_port;
788 rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
789 rh->msgh_local_port = MACH_PORT_NULL;
790 rh->msgh_id = hdr->msgh_id + 100;
792 reply->NDR = NDR_record;
793 reply->RetCode = code;
797 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
800 mig_reply_error_t reply;
801 darwin_inferior *priv = get_darwin_inferior (inf);
803 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
805 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
806 reply.Head.msgh_size, 0,
807 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
809 MACH_CHECK_ERROR (kret);
811 priv->pending_messages--;
814 /* Wrapper around the __pthread_kill syscall. We use this instead of the
815 pthread_kill function to be able to send a signal to any kind of thread,
816 including GCD threads. */
819 darwin_pthread_kill (darwin_thread_t *thread, int nsignal)
822 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS;
823 int res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
829 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
830 int step, int nsignal)
833 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
834 thread->msg_state, thread->gdb_port, step, nsignal);
836 switch (thread->msg_state)
839 if (thread->event.ex_type == EXC_SOFTWARE
840 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
842 /* Either deliver a new signal or cancel the signal received. */
843 int res = PTRACE (PT_THUPDATE, inf->pid,
844 (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
846 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
850 /* Note: ptrace is allowed only if the process is stopped.
851 Directly send the signal to the thread. */
852 int res = darwin_pthread_kill (thread, nsignal);
853 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
854 thread->gdb_port, nsignal, res);
855 thread->signaled = 1;
858 /* Set or reset single step. */
859 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
860 thread->gdb_port, step);
861 darwin_set_sstep (thread->gdb_port, step);
862 thread->single_step = step;
864 darwin_send_reply (inf, thread);
865 thread->msg_state = DARWIN_RUNNING;
872 kern_return_t kret = thread_resume (thread->gdb_port);
873 MACH_CHECK_ERROR (kret);
875 thread->msg_state = DARWIN_RUNNING;
880 /* Resume all threads of the inferior. */
883 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
885 darwin_inferior *priv = get_darwin_inferior (inf);
888 for (darwin_thread_t *thread : priv->threads)
889 darwin_resume_thread (inf, thread, step, nsignal);
892 struct resume_inferior_threads_param
899 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
901 int step = ((struct resume_inferior_threads_param *)param)->step;
902 int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
904 darwin_resume_inferior_threads (inf, step, nsignal);
909 /* Suspend all threads of INF. */
912 darwin_suspend_inferior_threads (struct inferior *inf)
914 darwin_inferior *priv = get_darwin_inferior (inf);
916 for (darwin_thread_t *thread : priv->threads)
918 switch (thread->msg_state)
925 kern_return_t kret = thread_suspend (thread->gdb_port);
926 MACH_CHECK_ERROR (kret);
927 thread->msg_state = DARWIN_STOPPED;
935 darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
937 struct target_waitstatus status;
942 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
943 ptid.pid (), ptid.tid (), step, signal);
945 if (signal == GDB_SIGNAL_0)
948 nsignal = gdb_signal_to_host (signal);
950 /* Don't try to single step all threads. */
952 ptid = inferior_ptid;
954 /* minus_one_ptid is RESUME_ALL. */
955 if (ptid == minus_one_ptid)
957 struct resume_inferior_threads_param param;
959 param.nsignal = nsignal;
962 /* Resume threads. */
963 iterate_over_inferiors (darwin_resume_inferior_threads_it, ¶m);
965 iterate_over_inferiors (darwin_resume_inferior_it, NULL);
969 struct inferior *inf = find_inferior_ptid (ptid);
970 long tid = ptid.tid ();
972 /* Stop the inferior (should be useless). */
973 darwin_suspend_inferior (inf);
976 darwin_resume_inferior_threads (inf, step, nsignal);
979 darwin_thread_t *thread;
981 /* Suspend threads of the task. */
982 darwin_suspend_inferior_threads (inf);
984 /* Resume the selected thread. */
985 thread = darwin_find_thread (inf, tid);
987 darwin_resume_thread (inf, thread, step, nsignal);
990 /* Resume the task. */
991 darwin_resume_inferior (inf);
996 darwin_decode_message (mach_msg_header_t *hdr,
997 darwin_thread_t **pthread,
998 struct inferior **pinf,
999 struct target_waitstatus *status)
1001 darwin_thread_t *thread;
1002 struct inferior *inf;
1004 /* Exception message. 2401 == 0x961 is exc. */
1005 if (hdr->msgh_id == 2401)
1009 /* Decode message. */
1010 res = darwin_decode_exception_message (hdr, &inf, &thread);
1014 /* Should not happen... */
1016 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
1017 /* FIXME: send a failure reply? */
1018 status->kind = TARGET_WAITKIND_IGNORE;
1019 return minus_one_ptid;
1023 status->kind = TARGET_WAITKIND_IGNORE;
1024 return minus_one_ptid;
1029 darwin_inferior *priv = get_darwin_inferior (inf);
1031 priv->pending_messages++;
1033 status->kind = TARGET_WAITKIND_STOPPED;
1034 thread->msg_state = DARWIN_MESSAGE;
1036 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1038 unparse_exception_type (thread->event.ex_type));
1040 switch (thread->event.ex_type)
1042 case EXC_BAD_ACCESS:
1043 status->value.sig = GDB_EXC_BAD_ACCESS;
1045 case EXC_BAD_INSTRUCTION:
1046 status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1048 case EXC_ARITHMETIC:
1049 status->value.sig = GDB_EXC_ARITHMETIC;
1052 status->value.sig = GDB_EXC_EMULATION;
1055 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1058 gdb_signal_from_host (thread->event.ex_data[1]);
1059 inferior_debug (5, _(" (signal %d: %s)\n"),
1060 thread->event.ex_data[1],
1061 gdb_signal_to_name (status->value.sig));
1063 /* If the thread is stopped because it has received a signal
1064 that gdb has just sent, continue. */
1065 if (thread->signaled)
1067 thread->signaled = 0;
1068 darwin_send_reply (inf, thread);
1069 thread->msg_state = DARWIN_RUNNING;
1070 status->kind = TARGET_WAITKIND_IGNORE;
1074 status->value.sig = GDB_EXC_SOFTWARE;
1076 case EXC_BREAKPOINT:
1077 /* Many internal GDB routines expect breakpoints to be reported
1078 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1079 as a spurious signal. */
1080 status->value.sig = GDB_SIGNAL_TRAP;
1083 status->value.sig = GDB_SIGNAL_UNKNOWN;
1087 return ptid_t (inf->pid, 0, thread->gdb_port);
1089 else if (hdr->msgh_id == 0x48)
1091 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1094 res = darwin_decode_notify_message (hdr, &inf);
1098 /* Should not happen... */
1100 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1107 if (res < 0 || inf == NULL)
1109 status->kind = TARGET_WAITKIND_IGNORE;
1110 return minus_one_ptid;
1115 darwin_inferior *priv = get_darwin_inferior (inf);
1117 if (!priv->no_ptrace)
1122 res = wait4 (inf->pid, &wstatus, 0, NULL);
1123 if (res < 0 || res != inf->pid)
1125 printf_unfiltered (_("wait4: res=%d: %s\n"),
1126 res, safe_strerror (errno));
1127 status->kind = TARGET_WAITKIND_IGNORE;
1128 return minus_one_ptid;
1130 if (WIFEXITED (wstatus))
1132 status->kind = TARGET_WAITKIND_EXITED;
1133 status->value.integer = WEXITSTATUS (wstatus);
1137 status->kind = TARGET_WAITKIND_SIGNALLED;
1138 status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1141 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1144 /* Looks necessary on Leopard and harmless... */
1145 wait4 (inf->pid, &wstatus, 0, NULL);
1147 inferior_ptid = ptid_t (inf->pid, 0, 0);
1148 return inferior_ptid;
1152 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1153 status->kind = TARGET_WAITKIND_EXITED;
1154 status->value.integer = 0; /* Don't know. */
1155 return ptid_t (inf->pid, 0, 0);
1160 /* Unknown message. */
1161 warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1162 status->kind = TARGET_WAITKIND_IGNORE;
1163 return minus_one_ptid;
1167 cancel_breakpoint (ptid_t ptid)
1169 /* Arrange for a breakpoint to be hit again later. We will handle
1170 the current event, eventually we will resume this thread, and this
1171 breakpoint will trap again.
1173 If we do not do this, then we run the risk that the user will
1174 delete or disable the breakpoint, but the thread will have already
1177 struct regcache *regcache = get_thread_regcache (ptid);
1178 struct gdbarch *gdbarch = regcache->arch ();
1181 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1182 if (breakpoint_inserted_here_p (regcache->aspace (), pc))
1184 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1185 (unsigned long) ptid.tid ());
1187 /* Back up the PC if necessary. */
1188 if (gdbarch_decr_pc_after_break (gdbarch))
1189 regcache_write_pc (regcache, pc);
1197 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1202 mach_msg_header_t hdr;
1205 mach_msg_header_t *hdr = &msgin.hdr;
1207 darwin_thread_t *thread;
1208 struct inferior *inf;
1211 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1212 ptid.pid (), ptid.tid ());
1214 /* Handle fake stop events at first. */
1215 if (darwin_inf_fake_stop != NULL)
1217 inf = darwin_inf_fake_stop;
1218 darwin_inf_fake_stop = NULL;
1220 darwin_inferior *priv = get_darwin_inferior (inf);
1222 status->kind = TARGET_WAITKIND_STOPPED;
1223 status->value.sig = GDB_SIGNAL_TRAP;
1224 thread = priv->threads[0];
1225 thread->msg_state = DARWIN_STOPPED;
1226 return ptid_t (inf->pid, 0, thread->gdb_port);
1231 /* set_sigint_trap (); */
1233 /* Wait for a message. */
1234 kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1235 sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1237 /* clear_sigint_trap (); */
1239 if (kret == MACH_RCV_INTERRUPTED)
1241 status->kind = TARGET_WAITKIND_IGNORE;
1242 return minus_one_ptid;
1245 if (kret != MACH_MSG_SUCCESS)
1247 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1248 status->kind = TARGET_WAITKIND_SPURIOUS;
1249 return minus_one_ptid;
1252 /* Debug: display message. */
1253 if (darwin_debug_flag > 10)
1254 darwin_dump_message (hdr, darwin_debug_flag > 11);
1256 res = darwin_decode_message (hdr, &thread, &inf, status);
1257 if (res == minus_one_ptid)
1260 /* Early return in case an inferior has exited. */
1264 while (status->kind == TARGET_WAITKIND_IGNORE);
1266 /* Stop all tasks. */
1267 iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1269 /* Read pending messages. */
1272 struct target_waitstatus status2;
1275 kret = mach_msg (&msgin.hdr,
1276 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1277 sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1279 if (kret == MACH_RCV_TIMED_OUT)
1281 if (kret != MACH_MSG_SUCCESS)
1284 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1288 /* Debug: display message. */
1289 if (darwin_debug_flag > 10)
1290 darwin_dump_message (hdr, darwin_debug_flag > 11);
1292 ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1294 if (inf != NULL && thread != NULL
1295 && thread->event.ex_type == EXC_BREAKPOINT)
1297 if (thread->single_step
1298 || cancel_breakpoint (ptid_t (inf->pid, 0, thread->gdb_port)))
1300 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1301 darwin_send_reply (inf, thread);
1302 thread->msg_state = DARWIN_RUNNING;
1306 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1310 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1316 darwin_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
1319 return darwin_wait (ptid, status);
1323 darwin_nat_target::interrupt ()
1325 struct inferior *inf = current_inferior ();
1326 darwin_inferior *priv = get_darwin_inferior (inf);
1328 /* FIXME: handle in no_ptrace mode. */
1329 gdb_assert (!priv->no_ptrace);
1330 ::kill (inf->pid, SIGINT);
1333 /* Deallocate threads port and vector. */
1336 darwin_deallocate_threads (struct inferior *inf)
1338 darwin_inferior *priv = get_darwin_inferior (inf);
1340 for (darwin_thread_t *t : priv->threads)
1342 kern_return_t kret = mach_port_deallocate (gdb_task, t->gdb_port);
1343 MACH_CHECK_ERROR (kret);
1346 priv->threads.clear ();
1350 darwin_nat_target::mourn_inferior ()
1352 struct inferior *inf = current_inferior ();
1353 darwin_inferior *priv = get_darwin_inferior (inf);
1357 /* Deallocate threads. */
1358 darwin_deallocate_threads (inf);
1360 /* Remove notify_port from darwin_port_set. */
1361 kret = mach_port_move_member (gdb_task,
1362 priv->notify_port, MACH_PORT_NULL);
1363 MACH_CHECK_ERROR (kret);
1365 /* Remove task port dead_name notification. */
1366 kret = mach_port_request_notification (gdb_task, priv->task,
1367 MACH_NOTIFY_DEAD_NAME, 0,
1369 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1371 /* This can fail if the task is dead. */
1372 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1373 priv->task, prev, priv->notify_port);
1375 if (kret == KERN_SUCCESS)
1377 kret = mach_port_deallocate (gdb_task, prev);
1378 MACH_CHECK_ERROR (kret);
1381 /* Destroy notify_port. */
1382 kret = mach_port_destroy (gdb_task, priv->notify_port);
1383 MACH_CHECK_ERROR (kret);
1385 /* Deallocate saved exception ports. */
1386 darwin_deallocate_exception_ports (priv);
1388 /* Deallocate task port. */
1389 kret = mach_port_deallocate (gdb_task, priv->task);
1390 MACH_CHECK_ERROR (kret);
1394 inf_child_target::mourn_inferior ();
1398 darwin_reply_to_all_pending_messages (struct inferior *inf)
1400 darwin_inferior *priv = get_darwin_inferior (inf);
1402 for (darwin_thread_t *t : priv->threads)
1404 if (t->msg_state == DARWIN_MESSAGE)
1405 darwin_resume_thread (inf, t, 0, 0);
1410 darwin_stop_inferior (struct inferior *inf)
1412 struct target_waitstatus wstatus;
1415 darwin_inferior *priv = get_darwin_inferior (inf);
1417 gdb_assert (inf != NULL);
1419 darwin_suspend_inferior (inf);
1421 darwin_reply_to_all_pending_messages (inf);
1423 if (priv->no_ptrace)
1426 res = kill (inf->pid, SIGSTOP);
1428 warning (_("cannot kill: %s"), safe_strerror (errno));
1430 /* Wait until the process is really stopped. */
1433 ptid = darwin_wait (inferior_ptid, &wstatus);
1434 if (wstatus.kind == TARGET_WAITKIND_STOPPED
1435 && wstatus.value.sig == GDB_SIGNAL_STOP)
1440 static kern_return_t
1441 darwin_save_exception_ports (darwin_inferior *inf)
1445 inf->exception_info.count =
1446 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1448 kret = task_get_exception_ports
1449 (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1450 &inf->exception_info.count, inf->exception_info.ports,
1451 inf->exception_info.behaviors, inf->exception_info.flavors);
1455 static kern_return_t
1456 darwin_restore_exception_ports (darwin_inferior *inf)
1461 for (i = 0; i < inf->exception_info.count; i++)
1463 kret = task_set_exception_ports
1464 (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1465 inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1466 if (kret != KERN_SUCCESS)
1470 return KERN_SUCCESS;
1473 /* Deallocate saved exception ports. */
1476 darwin_deallocate_exception_ports (darwin_inferior *inf)
1481 for (i = 0; i < inf->exception_info.count; i++)
1483 kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1484 MACH_CHECK_ERROR (kret);
1486 inf->exception_info.count = 0;
1490 darwin_setup_exceptions (struct inferior *inf)
1492 darwin_inferior *priv = get_darwin_inferior (inf);
1494 exception_mask_t mask;
1496 kret = darwin_save_exception_ports (priv);
1497 if (kret != KERN_SUCCESS)
1498 error (_("Unable to save exception ports, task_get_exception_ports"
1502 /* Set exception port. */
1503 if (enable_mach_exceptions)
1504 mask = EXC_MASK_ALL;
1506 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1507 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
1508 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1509 if (kret != KERN_SUCCESS)
1510 error (_("Unable to set exception ports, task_set_exception_ports"
1516 darwin_nat_target::kill ()
1518 struct inferior *inf = current_inferior ();
1519 darwin_inferior *priv = get_darwin_inferior (inf);
1520 struct target_waitstatus wstatus;
1525 if (inferior_ptid == null_ptid)
1528 gdb_assert (inf != NULL);
1530 kret = darwin_restore_exception_ports (priv);
1531 MACH_CHECK_ERROR (kret);
1533 darwin_reply_to_all_pending_messages (inf);
1535 res = ::kill (inf->pid, 9);
1539 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1540 does not work as expected.
1541 When the kill function is called, the SIGKILL signal is received
1542 by gdb whereas it should have been received by the kernel since
1543 the exception ports have been restored.
1544 This behavior is not the expected one thus gdb does not reply to
1545 the received SIGKILL message. This situation leads to a "busy"
1546 resource from the kernel point of view and the inferior is never
1547 released, causing it to remain as a zombie process, even after
1549 To work around this, we mark all the threads of the inferior as
1550 signaled thus darwin_decode_message function knows that the kill
1551 signal was sent by gdb and will take the appropriate action
1552 (cancel signal and reply to the signal message). */
1553 darwin_inferior *priv = get_darwin_inferior (inf);
1554 for (darwin_thread_t *thread : priv->threads)
1555 thread->signaled = 1;
1557 darwin_resume_inferior (inf);
1559 ptid = darwin_wait (inferior_ptid, &wstatus);
1561 else if (errno != ESRCH)
1562 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1563 inf->pid, safe_strerror (errno));
1565 target_mourn_inferior (inferior_ptid);
1569 darwin_setup_request_notification (struct inferior *inf)
1571 darwin_inferior *priv = get_darwin_inferior (inf);
1573 mach_port_t prev_not;
1575 kret = mach_port_request_notification (gdb_task, priv->task,
1576 MACH_NOTIFY_DEAD_NAME, 0,
1578 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1580 if (kret != KERN_SUCCESS)
1581 error (_("Termination notification request failed, "
1582 "mach_port_request_notification\n"
1585 if (prev_not != MACH_PORT_NULL)
1587 /* This is unexpected, as there should not be any previously
1588 registered notification request. But this is not a fatal
1589 issue, so just emit a warning. */
1591 A task termination request was registered before the debugger registered\n\
1592 its own. This is unexpected, but should otherwise not have any actual\n\
1593 impact on the debugging session."));
1598 darwin_attach_pid (struct inferior *inf)
1602 darwin_inferior *priv = new darwin_inferior;
1603 inf->priv.reset (priv);
1607 kret = task_for_pid (gdb_task, inf->pid, &priv->task);
1608 if (kret != KERN_SUCCESS)
1612 if (!inf->attach_flag)
1615 waitpid (inf->pid, &status, 0);
1619 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1620 " (please check gdb is codesigned - see taskgated(8))"),
1621 inf->pid, mach_error_string (kret), (unsigned long) kret);
1624 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1625 priv->task, inf->pid);
1627 if (darwin_ex_port == MACH_PORT_NULL)
1629 /* Create a port to get exceptions. */
1630 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1632 if (kret != KERN_SUCCESS)
1633 error (_("Unable to create exception port, mach_port_allocate "
1637 kret = mach_port_insert_right (gdb_task, darwin_ex_port,
1639 MACH_MSG_TYPE_MAKE_SEND);
1640 if (kret != KERN_SUCCESS)
1641 error (_("Unable to create exception port, mach_port_insert_right "
1645 /* Create a port set and put ex_port in it. */
1646 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1648 if (kret != KERN_SUCCESS)
1649 error (_("Unable to create port set, mach_port_allocate "
1653 kret = mach_port_move_member (gdb_task, darwin_ex_port,
1655 if (kret != KERN_SUCCESS)
1656 error (_("Unable to move exception port into new port set, "
1657 "mach_port_move_member\n"
1662 /* Create a port to be notified when the child task terminates. */
1663 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1664 &priv->notify_port);
1665 if (kret != KERN_SUCCESS)
1666 error (_("Unable to create notification port, mach_port_allocate "
1670 kret = mach_port_move_member (gdb_task,
1671 priv->notify_port, darwin_port_set);
1672 if (kret != KERN_SUCCESS)
1673 error (_("Unable to move notification port into new port set, "
1674 "mach_port_move_member\n"
1678 darwin_setup_request_notification (inf);
1680 darwin_setup_exceptions (inf);
1682 CATCH (ex, RETURN_MASK_ALL)
1684 exit_inferior (inf);
1685 inferior_ptid = null_ptid;
1687 throw_exception (ex);
1691 target_ops *darwin_ops = get_native_target ();
1692 if (!target_is_pushed (darwin_ops))
1693 push_target (darwin_ops);
1696 /* Get the thread_info object corresponding to this darwin_thread_info. */
1698 static struct thread_info *
1699 thread_info_from_private_thread_info (darwin_thread_info *pti)
1701 struct thread_info *it;
1705 darwin_thread_info *iter_pti = get_darwin_thread_info (it);
1707 if (iter_pti->gdb_port == pti->gdb_port)
1711 gdb_assert (it != NULL);
1717 darwin_init_thread_list (struct inferior *inf)
1719 darwin_check_new_threads (inf);
1721 darwin_inferior *priv = get_darwin_inferior (inf);
1723 gdb_assert (!priv->threads.empty ());
1725 darwin_thread_info *first_pti = priv->threads.front ();
1726 struct thread_info *first_thread
1727 = thread_info_from_private_thread_info (first_pti);
1729 inferior_ptid = first_thread->ptid;
1732 /* The child must synchronize with gdb: gdb must set the exception port
1733 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1734 FIXME: is there a lighter way ? */
1735 static int ptrace_fds[2];
1738 darwin_ptrace_me (void)
1743 /* Close write end point. */
1744 if (close (ptrace_fds[1]) < 0)
1745 trace_start_error_with_name ("close");
1747 /* Wait until gdb is ready. */
1748 res = read (ptrace_fds[0], &c, 1);
1750 trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1752 if (close (ptrace_fds[0]) < 0)
1753 trace_start_error_with_name ("close");
1755 /* Get rid of privileges. */
1756 if (setegid (getgid ()) < 0)
1757 trace_start_error_with_name ("setegid");
1760 if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1761 trace_start_error_with_name ("PTRACE");
1763 /* Redirect signals to exception port. */
1764 if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1765 trace_start_error_with_name ("PTRACE");
1768 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1770 darwin_pre_ptrace (void)
1772 if (pipe (ptrace_fds) != 0)
1776 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1779 mark_fd_no_cloexec (ptrace_fds[0]);
1780 mark_fd_no_cloexec (ptrace_fds[1]);
1784 darwin_ptrace_him (int pid)
1786 struct inferior *inf = current_inferior ();
1788 darwin_attach_pid (inf);
1790 /* Let's the child run. */
1791 close (ptrace_fds[0]);
1792 close (ptrace_fds[1]);
1794 unmark_fd_no_cloexec (ptrace_fds[0]);
1795 unmark_fd_no_cloexec (ptrace_fds[1]);
1797 darwin_init_thread_list (inf);
1799 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1803 darwin_execvp (const char *file, char * const argv[], char * const env[])
1805 posix_spawnattr_t attr;
1809 res = posix_spawnattr_init (&attr);
1813 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1817 /* Do like execve: replace the image. */
1818 ps_flags = POSIX_SPAWN_SETEXEC;
1820 /* Disable ASLR. The constant doesn't look to be available outside the
1821 kernel include files. */
1822 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1823 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1825 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1826 res = posix_spawnattr_setflags (&attr, ps_flags);
1829 fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1833 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1836 /* Read kernel version, and return TRUE on Sierra or later. */
1839 should_disable_startup_with_shell ()
1842 size_t sz = sizeof (str);
1845 ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
1846 if (ret == 0 && sz < sizeof (str))
1848 unsigned long ver = strtoul (str, NULL, 10);
1856 darwin_nat_target::create_inferior (const char *exec_file,
1857 const std::string &allargs,
1858 char **env, int from_tty)
1860 gdb::optional<scoped_restore_tmpl<int>> restore_startup_with_shell;
1862 if (startup_with_shell && should_disable_startup_with_shell ())
1864 warning (_("startup-with-shell not supported on this macOS version,"
1866 restore_startup_with_shell.emplace (&startup_with_shell, 0);
1869 /* Do the hard work. */
1870 fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1871 darwin_ptrace_him, darwin_pre_ptrace, NULL,
1876 /* Set things up such that the next call to darwin_wait will immediately
1877 return a fake stop event for inferior INF.
1879 This assumes that the inferior's thread list has been initialized,
1880 as it will suspend the inferior's first thread. */
1883 darwin_setup_fake_stop_event (struct inferior *inf)
1885 darwin_inferior *priv = get_darwin_inferior (inf);
1886 darwin_thread_t *thread;
1889 gdb_assert (darwin_inf_fake_stop == NULL);
1890 darwin_inf_fake_stop = inf;
1892 /* When detecting a fake pending stop event, darwin_wait returns
1893 an event saying that the first thread is in a DARWIN_STOPPED
1894 state. To make that accurate, we need to suspend that thread
1895 as well. Otherwise, we'll try resuming it when resuming the
1896 inferior, and get a warning because the thread's suspend count
1897 is already zero, making the resume request useless. */
1898 thread = priv->threads[0];
1899 kret = thread_suspend (thread->gdb_port);
1900 MACH_CHECK_ERROR (kret);
1903 /* Attach to process PID, then initialize for debugging it
1904 and wait for the trace-trap that results from attaching. */
1906 darwin_nat_target::attach (const char *args, int from_tty)
1909 struct inferior *inf;
1911 pid = parse_pid_to_attach (args);
1913 if (pid == getpid ()) /* Trying to masturbate? */
1914 error (_("I refuse to debug myself!"));
1918 char *exec_file = get_exec_file (0);
1921 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1922 target_pid_to_str (ptid_t (pid)));
1924 printf_unfiltered (_("Attaching to %s\n"),
1925 target_pid_to_str (ptid_t (pid)));
1927 gdb_flush (gdb_stdout);
1930 if (pid == 0 || ::kill (pid, 0) < 0)
1931 error (_("Can't attach to process %d: %s (%d)"),
1932 pid, safe_strerror (errno), errno);
1934 inferior_ptid = ptid_t (pid);
1935 inf = current_inferior ();
1936 inferior_appeared (inf, pid);
1937 inf->attach_flag = 1;
1939 darwin_attach_pid (inf);
1941 darwin_suspend_inferior (inf);
1943 darwin_init_thread_list (inf);
1945 darwin_inferior *priv = get_darwin_inferior (inf);
1947 darwin_check_osabi (priv, inferior_ptid.tid ());
1949 darwin_setup_fake_stop_event (inf);
1951 priv->no_ptrace = 1;
1954 /* Take a program previously attached to and detaches it.
1955 The program resumes execution and will no longer stop
1956 on signals, etc. We'd better not have left any breakpoints
1957 in the program or it'll die when it hits one. For this
1958 to work, it may be necessary for the process to have been
1959 previously attached. It *might* work if the program was
1960 started via fork. */
1963 darwin_nat_target::detach (inferior *inf, int from_tty)
1965 darwin_inferior *priv = get_darwin_inferior (inf);
1969 /* Display message. */
1970 target_announce_detach (from_tty);
1972 /* If ptrace() is in use, stop the process. */
1973 if (!priv->no_ptrace)
1974 darwin_stop_inferior (inf);
1976 kret = darwin_restore_exception_ports (priv);
1977 MACH_CHECK_ERROR (kret);
1979 if (!priv->no_ptrace)
1981 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1983 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1984 inf->pid, safe_strerror (errno), errno);
1987 darwin_reply_to_all_pending_messages (inf);
1989 /* When using ptrace, we have just performed a PT_DETACH, which
1990 resumes the inferior. On the other hand, when we are not using
1991 ptrace, we need to resume its execution ourselves. */
1992 if (priv->no_ptrace)
1993 darwin_resume_inferior (inf);
1999 darwin_nat_target::pid_to_str (ptid_t ptid)
2001 static char buf[80];
2002 long tid = ptid.tid ();
2006 snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
2011 return normal_pid_to_str (ptid);
2015 darwin_nat_target::thread_alive (ptid_t ptid)
2020 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2021 copy it to RDADDR in gdb's address space.
2022 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2023 to ADDR in inferior task's address space.
2024 Return 0 on failure; number of bytes read / writen otherwise. */
2027 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2028 gdb_byte *rdaddr, const gdb_byte *wraddr,
2032 mach_vm_size_t res_length = 0;
2034 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2035 task, core_addr_to_string (addr), pulongest (length));
2040 mach_vm_size_t count;
2042 /* According to target.h(to_xfer_partial), one and only one may be
2044 gdb_assert (wraddr == NULL);
2046 kret = mach_vm_read_overwrite (task, addr, length,
2047 (mach_vm_address_t) rdaddr, &count);
2048 if (kret != KERN_SUCCESS)
2051 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2052 core_addr_to_string (addr), mach_error_string (kret));
2059 gdb_assert (wraddr != NULL);
2063 mach_vm_address_t offset = addr & (mach_page_size - 1);
2064 mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2065 mach_vm_size_t aligned_length =
2066 (mach_vm_size_t) PAGE_ROUND (offset + length);
2067 vm_region_submap_short_info_data_64_t info;
2068 mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2069 natural_t region_depth = 1000;
2070 mach_vm_address_t region_start = region_address;
2071 mach_vm_size_t region_length;
2072 mach_vm_size_t write_length;
2074 /* Read page protection. */
2075 kret = mach_vm_region_recurse
2076 (task, ®ion_start, ®ion_length, ®ion_depth,
2077 (vm_region_recurse_info_t) &info, &count);
2079 if (kret != KERN_SUCCESS)
2081 inferior_debug (1, _("darwin_read_write_inferior: "
2082 "mach_vm_region_recurse failed at %s: %s\n"),
2083 core_addr_to_string (region_address),
2084 mach_error_string (kret));
2089 (9, _("darwin_read_write_inferior: "
2090 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2091 core_addr_to_string (region_address),
2092 core_addr_to_string (region_start),
2093 core_addr_to_string (region_length));
2095 /* Check for holes in memory. */
2096 if (region_start > region_address)
2098 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2099 core_addr_to_string (region_address),
2100 core_addr_to_string (region_start),
2101 (unsigned)region_length);
2105 /* Adjust the length. */
2106 region_length -= (region_address - region_start);
2107 if (region_length > aligned_length)
2108 region_length = aligned_length;
2110 /* Make the pages RW. */
2111 if (!(info.protection & VM_PROT_WRITE))
2113 vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2115 kret = mach_vm_protect (task, region_address, region_length,
2117 if (kret != KERN_SUCCESS)
2119 prot |= VM_PROT_COPY;
2120 kret = mach_vm_protect (task, region_address, region_length,
2123 if (kret != KERN_SUCCESS)
2125 warning (_("darwin_read_write_inferior: "
2126 "mach_vm_protect failed at %s "
2127 "(len=0x%lx, prot=0x%x): %s"),
2128 core_addr_to_string (region_address),
2129 (unsigned long) region_length, (unsigned) prot,
2130 mach_error_string (kret));
2135 if (offset + length > region_length)
2136 write_length = region_length - offset;
2138 write_length = length;
2141 kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2142 if (kret != KERN_SUCCESS)
2144 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2145 mach_error_string (kret));
2149 /* Restore page rights. */
2150 if (!(info.protection & VM_PROT_WRITE))
2152 kret = mach_vm_protect (task, region_address, region_length,
2153 FALSE, info.protection);
2154 if (kret != KERN_SUCCESS)
2156 warning (_("darwin_read_write_inferior: "
2157 "mach_vm_protect restore failed at %s "
2159 core_addr_to_string (region_address),
2160 (unsigned long) region_length,
2161 mach_error_string (kret));
2165 addr += write_length;
2166 wraddr += write_length;
2167 res_length += write_length;
2168 length -= write_length;
2174 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2175 to RDADDR (in big endian).
2176 Return 0 on failure; number of bytes read / written otherwise. */
2178 #ifdef TASK_DYLD_INFO_COUNT
2179 /* This is not available in Darwin 9. */
2180 static enum target_xfer_status
2181 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2182 ULONGEST length, ULONGEST *xfered_len)
2184 struct task_dyld_info task_dyld_info;
2185 mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2188 if (addr != 0 || length > sizeof (mach_vm_address_t))
2189 return TARGET_XFER_EOF;
2191 kret = task_info (task, TASK_DYLD_INFO,
2192 (task_info_t) &task_dyld_info, &count);
2193 MACH_CHECK_ERROR (kret);
2194 if (kret != KERN_SUCCESS)
2195 return TARGET_XFER_E_IO;
2197 store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2198 task_dyld_info.all_image_info_addr);
2199 *xfered_len = (ULONGEST) length;
2200 return TARGET_XFER_OK;
2206 enum target_xfer_status
2207 darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
2208 gdb_byte *readbuf, const gdb_byte *writebuf,
2209 ULONGEST offset, ULONGEST len,
2210 ULONGEST *xfered_len)
2212 struct inferior *inf = current_inferior ();
2213 darwin_inferior *priv = get_darwin_inferior (inf);
2216 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2217 core_addr_to_string (offset), pulongest (len),
2218 host_address_to_string (readbuf), host_address_to_string (writebuf),
2223 case TARGET_OBJECT_MEMORY:
2225 int l = darwin_read_write_inferior (priv->task, offset,
2226 readbuf, writebuf, len);
2229 return TARGET_XFER_EOF;
2233 *xfered_len = (ULONGEST) l;
2234 return TARGET_XFER_OK;
2237 #ifdef TASK_DYLD_INFO_COUNT
2238 case TARGET_OBJECT_DARWIN_DYLD_INFO:
2239 if (writebuf != NULL || readbuf == NULL)
2241 /* Support only read. */
2242 return TARGET_XFER_E_IO;
2244 return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2248 return TARGET_XFER_E_IO;
2254 set_enable_mach_exceptions (const char *args, int from_tty,
2255 struct cmd_list_element *c)
2257 if (inferior_ptid != null_ptid)
2259 struct inferior *inf = current_inferior ();
2260 darwin_inferior *priv = get_darwin_inferior (inf);
2261 exception_mask_t mask;
2264 if (enable_mach_exceptions)
2265 mask = EXC_MASK_ALL;
2268 darwin_restore_exception_ports (priv);
2269 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2271 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2272 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2273 MACH_CHECK_ERROR (kret);
2278 darwin_nat_target::pid_to_exec_file (int pid)
2280 static char path[PATH_MAX];
2283 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2291 darwin_nat_target::get_ada_task_ptid (long lwp, long thread)
2293 struct inferior *inf = current_inferior ();
2294 darwin_inferior *priv = get_darwin_inferior (inf);
2296 mach_port_name_array_t names;
2297 mach_msg_type_number_t names_count;
2298 mach_port_type_array_t types;
2299 mach_msg_type_number_t types_count;
2302 /* First linear search. */
2303 for (darwin_thread_t *t : priv->threads)
2305 if (t->inf_port == lwp)
2306 return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
2309 /* Maybe the port was never extract. Do it now. */
2311 /* First get inferior port names. */
2312 kret = mach_port_names (priv->task, &names, &names_count, &types,
2314 MACH_CHECK_ERROR (kret);
2315 if (kret != KERN_SUCCESS)
2318 /* For each name, copy the right in the gdb space and then compare with
2319 our view of the inferior threads. We don't forget to deallocate the
2321 for (int i = 0; i < names_count; i++)
2323 mach_port_t local_name;
2324 mach_msg_type_name_t local_type;
2326 /* We just need to know the corresponding name in gdb name space.
2327 So extract and deallocate the right. */
2328 kret = mach_port_extract_right (priv->task, names[i],
2329 MACH_MSG_TYPE_COPY_SEND,
2330 &local_name, &local_type);
2331 if (kret != KERN_SUCCESS)
2333 mach_port_deallocate (gdb_task, local_name);
2335 for (darwin_thread_t *t : priv->threads)
2337 if (t->gdb_port == local_name)
2339 t->inf_port = names[i];
2340 if (names[i] == lwp)
2346 vm_deallocate (gdb_task, (vm_address_t) names,
2347 names_count * sizeof (mach_port_t));
2350 return ptid_t (inferior_ptid.pid (), 0, res);
2356 darwin_nat_target::supports_multi_process ()
2362 _initialize_darwin_nat ()
2366 gdb_task = mach_task_self ();
2367 darwin_host_self = mach_host_self ();
2369 /* Read page size. */
2370 kret = host_page_size (darwin_host_self, &mach_page_size);
2371 if (kret != KERN_SUCCESS)
2373 mach_page_size = 0x1000;
2374 MACH_CHECK_ERROR (kret);
2377 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2378 (unsigned long) mach_task_self (), getpid ());
2380 add_setshow_zuinteger_cmd ("darwin", class_obscure,
2381 &darwin_debug_flag, _("\
2382 Set if printing inferior communication debugging statements."), _("\
2383 Show if printing inferior communication debugging statements."), NULL,
2385 &setdebuglist, &showdebuglist);
2387 add_setshow_boolean_cmd ("mach-exceptions", class_support,
2388 &enable_mach_exceptions, _("\
2389 Set if mach exceptions are caught."), _("\
2390 Show if mach exceptions are caught."), _("\
2391 When this mode is on, all low level exceptions are reported before being\n\
2392 reported by the kernel."),
2393 &set_enable_mach_exceptions, NULL,
2394 &setlist, &showlist);