1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2013 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/>.
32 #include "gdbthread.h"
34 #include "event-top.h"
37 #include "exceptions.h"
38 #include "inf-child.h"
40 #include "arch-utils.h"
42 #include "bfd/mach-o.h"
44 #include <sys/ptrace.h>
45 #include <sys/signal.h>
46 #include <machine/setjmp.h>
47 #include <sys/types.h>
52 #include <sys/param.h>
53 #include <sys/sysctl.h>
56 #include <sys/syscall.h>
59 #include <mach/mach_error.h>
60 #include <mach/mach_vm.h>
61 #include <mach/mach_init.h>
62 #include <mach/vm_map.h>
63 #include <mach/task.h>
64 #include <mach/mach_port.h>
65 #include <mach/thread_act.h>
66 #include <mach/port.h>
68 #include "darwin-nat.h"
69 #include "common/filestuff.h"
72 Darwin kernel is Mach + BSD derived kernel. Note that they share the
73 same memory space and are linked together (ie there is no micro-kernel).
75 Although ptrace(2) is available on Darwin, it is not complete. We have
76 to use Mach calls to read and write memory and to modify registers. We
77 also use Mach to get inferior faults. As we cannot use select(2) or
78 signals with Mach port (the Mach communication channel), signals are
79 reported to gdb as an exception. Furthermore we detect death of the
80 inferior through a Mach notification message. This way we only wait
83 Some Mach documentation is available for Apple xnu source package or
87 #define PTRACE(CMD, PID, ADDR, SIG) \
88 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
90 extern boolean_t exc_server (mach_msg_header_t *in, mach_msg_header_t *out);
92 static void darwin_stop (ptid_t);
94 static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
95 enum gdb_signal signal);
96 static void darwin_resume (ptid_t ptid, int step,
97 enum gdb_signal signal);
99 static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
100 struct target_waitstatus *status, int options);
101 static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
103 static void darwin_mourn_inferior (struct target_ops *ops);
105 static void darwin_kill_inferior (struct target_ops *ops);
107 static void darwin_ptrace_me (void);
109 static void darwin_ptrace_him (int pid);
111 static void darwin_create_inferior (struct target_ops *ops, char *exec_file,
112 char *allargs, char **env, int from_tty);
114 static void darwin_files_info (struct target_ops *ops);
116 static char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
118 static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
120 /* Target operations for Darwin. */
121 static struct target_ops *darwin_ops;
123 /* Task identifier of gdb. */
124 static task_t gdb_task;
126 /* A copy of mach_host_self (). */
127 mach_port_t darwin_host_self;
129 /* Exception port. */
130 mach_port_t darwin_ex_port;
133 mach_port_t darwin_port_set;
136 static vm_size_t mach_page_size;
138 /* If Set, catch all mach exceptions (before they are converted to signals
140 static int enable_mach_exceptions;
142 /* Inferior that should report a fake stop event. */
143 static struct inferior *darwin_inf_fake_stop;
145 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
146 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
148 /* This controls output of inferior debugging. */
149 static unsigned int darwin_debug_flag = 0;
151 /* Create a __TEXT __info_plist section in the executable so that gdb could
152 be signed. This is required to get an authorization for task_for_pid.
154 Once gdb is built, you can either:
155 * make it setgid procmod
156 * or codesign it with any system-trusted signing authority.
157 See taskgated(8) for details. */
158 static const unsigned char info_plist[]
159 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
160 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
161 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
162 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
163 "<plist version=\"1.0\">\n"
165 " <key>CFBundleIdentifier</key>\n"
166 " <string>org.gnu.gdb</string>\n"
167 " <key>CFBundleName</key>\n"
168 " <string>gdb</string>\n"
169 " <key>CFBundleVersion</key>\n"
170 " <string>1.0</string>\n"
171 " <key>SecTaskAccess</key>\n"
173 " <string>allowed</string>\n"
174 " <string>debug</string>\n"
180 inferior_debug (int level, const char *fmt, ...)
184 if (darwin_debug_flag < level)
188 printf_unfiltered (_("[%d inferior]: "), getpid ());
189 vprintf_unfiltered (fmt, ap);
194 mach_check_error (kern_return_t ret, const char *file,
195 unsigned int line, const char *func)
197 if (ret == KERN_SUCCESS)
200 func = _("[UNKNOWN]");
202 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
203 file, line, func, mach_error_string (ret), (unsigned long) ret);
207 unparse_exception_type (unsigned int i)
209 static char unknown_exception_buf[32];
214 return "EXC_BAD_ACCESS";
215 case EXC_BAD_INSTRUCTION:
216 return "EXC_BAD_INSTRUCTION";
218 return "EXC_ARITHMETIC";
220 return "EXC_EMULATION";
222 return "EXC_SOFTWARE";
224 return "EXC_BREAKPOINT";
226 return "EXC_SYSCALL";
227 case EXC_MACH_SYSCALL:
228 return "EXC_MACH_SYSCALL";
230 return "EXC_RPC_ALERT";
234 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
235 return unknown_exception_buf;
239 /* Set errno to zero, and then call ptrace with the given arguments.
240 If inferior debugging traces are on, then also print a debug
243 The returned value is the same as the value returned by ptrace,
244 except in the case where that value is -1 but errno is zero.
245 This case is documented to be a non-error situation, so we
246 return zero in that case. */
249 darwin_ptrace (const char *name,
250 int request, int pid, PTRACE_TYPE_ARG3 arg3, int arg4)
255 ret = ptrace (request, pid, (caddr_t) arg3, arg4);
256 if (ret == -1 && errno == 0)
259 inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
260 name, pid, arg3, arg4, ret,
261 (ret != 0) ? safe_strerror (errno) : _("no error"));
266 cmp_thread_t (const void *l, const void *r)
268 thread_t tl = *(const thread_t *)l;
269 thread_t tr = *(const thread_t *)r;
270 return (int)(tl - tr);
274 darwin_check_new_threads (struct inferior *inf)
278 thread_array_t thread_list;
279 unsigned int new_nbr;
280 unsigned int old_nbr;
281 unsigned int new_ix, old_ix;
282 darwin_inferior *darwin_inf = inf->private;
283 VEC (darwin_thread_t) *thread_vec;
285 /* Get list of threads. */
286 kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
287 MACH_CHECK_ERROR (kret);
288 if (kret != KERN_SUCCESS)
293 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
295 if (darwin_inf->threads)
296 old_nbr = VEC_length (darwin_thread_t, darwin_inf->threads);
300 /* Quick check for no changes. */
301 if (old_nbr == new_nbr)
303 for (i = 0; i < new_nbr; i++)
305 != VEC_index (darwin_thread_t, darwin_inf->threads, i)->gdb_port)
309 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
310 new_nbr * sizeof (int));
311 MACH_CHECK_ERROR (kret);
316 thread_vec = VEC_alloc (darwin_thread_t, new_nbr);
318 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
320 thread_t new_id = (new_ix < new_nbr) ?
321 thread_list[new_ix] : THREAD_NULL;
322 darwin_thread_t *old = (old_ix < old_nbr) ?
323 VEC_index (darwin_thread_t, darwin_inf->threads, old_ix) : NULL;
324 thread_t old_id = old ? old->gdb_port : THREAD_NULL;
327 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
328 new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
330 if (old_id == new_id)
332 /* Thread still exist. */
333 VEC_safe_push (darwin_thread_t, thread_vec, old);
337 kret = mach_port_deallocate (gdb_task, old_id);
338 MACH_CHECK_ERROR (kret);
341 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
343 /* Ignore dead ports.
344 In some weird cases, we might get dead ports. They should
345 correspond to dead thread so they could safely be ignored. */
349 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
351 /* A thread was created. */
352 struct thread_info *tp;
353 struct private_thread_info *pti;
355 pti = XZALLOC (struct private_thread_info);
356 pti->gdb_port = new_id;
357 pti->msg_state = DARWIN_RUNNING;
359 /* Add a new thread unless this is the first one ever met. */
360 if (!(old_nbr == 0 && new_ix == 0))
361 tp = add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
364 tp = find_thread_ptid (ptid_build (inf->pid, 0, 0));
368 VEC_safe_push (darwin_thread_t, thread_vec, pti);
372 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
374 /* A thread was removed. */
375 delete_thread (ptid_build (inf->pid, 0, old_id));
376 kret = mach_port_deallocate (gdb_task, old_id);
377 MACH_CHECK_ERROR (kret);
381 gdb_assert_not_reached ("unexpected thread case");
384 if (darwin_inf->threads)
385 VEC_free (darwin_thread_t, darwin_inf->threads);
386 darwin_inf->threads = thread_vec;
388 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
389 new_nbr * sizeof (int));
390 MACH_CHECK_ERROR (kret);
394 find_inferior_task_it (struct inferior *inf, void *port_ptr)
396 return inf->private->task == *(task_t*)port_ptr;
400 find_inferior_notify_it (struct inferior *inf, void *port_ptr)
402 return inf->private->notify_port == *(task_t*)port_ptr;
405 /* Return an inferior by task port. */
406 static struct inferior *
407 darwin_find_inferior_by_task (task_t port)
409 return iterate_over_inferiors (&find_inferior_task_it, &port);
412 /* Return an inferior by notification port. */
413 static struct inferior *
414 darwin_find_inferior_by_notify (mach_port_t port)
416 return iterate_over_inferiors (&find_inferior_notify_it, &port);
419 /* Return a thread by port. */
420 static darwin_thread_t *
421 darwin_find_thread (struct inferior *inf, thread_t thread)
427 VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
429 if (t->gdb_port == thread)
434 /* Suspend (ie stop) an inferior at Mach level. */
437 darwin_suspend_inferior (struct inferior *inf)
439 if (!inf->private->suspended)
443 kret = task_suspend (inf->private->task);
444 MACH_CHECK_ERROR (kret);
446 inf->private->suspended = 1;
450 /* Resume an inferior at Mach level. */
453 darwin_resume_inferior (struct inferior *inf)
455 if (inf->private->suspended)
459 kret = task_resume (inf->private->task);
460 MACH_CHECK_ERROR (kret);
462 inf->private->suspended = 0;
466 /* Iterator functions. */
469 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
471 darwin_suspend_inferior (inf);
472 darwin_check_new_threads (inf);
477 darwin_resume_inferior_it (struct inferior *inf, void *arg)
479 darwin_resume_inferior (inf);
484 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
486 printf_unfiltered (_("message header:\n"));
487 printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
488 printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
489 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
490 printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
491 printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
492 printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
496 const unsigned char *data;
497 const unsigned long *ldata;
501 data = (unsigned char *)(hdr + 1);
502 size = hdr->msgh_size - sizeof (mach_msg_header_t);
504 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
506 mach_msg_body_t *bod = (mach_msg_body_t*)data;
507 mach_msg_port_descriptor_t *desc =
508 (mach_msg_port_descriptor_t *)(bod + 1);
511 printf_unfiltered (_("body: descriptor_count=%u\n"),
512 bod->msgh_descriptor_count);
513 data += sizeof (mach_msg_body_t);
514 size -= sizeof (mach_msg_body_t);
515 for (k = 0; k < bod->msgh_descriptor_count; k++)
516 switch (desc[k].type)
518 case MACH_MSG_PORT_DESCRIPTOR:
520 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
521 k, desc[k].type, desc[k].name, desc[k].disposition);
524 printf_unfiltered (_(" descr %d: type=%u\n"),
528 data += bod->msgh_descriptor_count
529 * sizeof (mach_msg_port_descriptor_t);
530 size -= bod->msgh_descriptor_count
531 * sizeof (mach_msg_port_descriptor_t);
532 ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
534 (_("NDR: mig=%02x if=%02x encod=%02x "
535 "int=%02x char=%02x float=%02x\n"),
536 ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
537 ndr->int_rep, ndr->char_rep, ndr->float_rep);
538 data += sizeof (NDR_record_t);
539 size -= sizeof (NDR_record_t);
542 printf_unfiltered (_(" data:"));
543 ldata = (const unsigned long *)data;
544 for (i = 0; i < size / sizeof (unsigned long); i++)
545 printf_unfiltered (" %08lx", ldata[i]);
546 printf_unfiltered (_("\n"));
551 darwin_decode_exception_message (mach_msg_header_t *hdr,
552 struct inferior **pinf,
553 darwin_thread_t **pthread)
555 mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
556 mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
559 struct inferior *inf;
560 darwin_thread_t *thread;
562 thread_t thread_port;
566 /* Check message identifier. 2401 is exc. */
567 if (hdr->msgh_id != 2401)
570 /* Check message header. */
571 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
574 /* Check descriptors. */
575 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
576 + sizeof (*ndr) + 2 * sizeof (integer_t))
577 || bod->msgh_descriptor_count != 2
578 || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
579 || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
580 || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
581 || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
584 /* Check data representation. */
585 ndr = (NDR_record_t *)(desc + 2);
586 if (ndr->mig_vers != NDR_PROTOCOL_2_0
587 || ndr->if_vers != NDR_PROTOCOL_2_0
588 || ndr->mig_encoding != NDR_record.mig_encoding
589 || ndr->int_rep != NDR_record.int_rep
590 || ndr->char_rep != NDR_record.char_rep
591 || ndr->float_rep != NDR_record.float_rep)
594 /* Ok, the hard work. */
595 data = (integer_t *)(ndr + 1);
597 /* Find process by port. */
598 task_port = desc[1].name;
599 thread_port = desc[0].name;
600 inf = darwin_find_inferior_by_task (task_port);
605 /* Find thread by port. */
606 /* Check for new threads. Do it early so that the port in the exception
607 message can be deallocated. */
608 darwin_check_new_threads (inf);
610 /* We got new rights to the task and the thread. Get rid of them. */
611 kret = mach_port_deallocate (mach_task_self (), task_port);
612 MACH_CHECK_ERROR (kret);
613 kret = mach_port_deallocate (mach_task_self (), thread_port);
614 MACH_CHECK_ERROR (kret);
616 thread = darwin_find_thread (inf, thread_port);
621 /* The thread should be running. However we have observed cases where a thread
622 got a SIGTTIN message after being stopped. */
623 gdb_assert (thread->msg_state != DARWIN_MESSAGE);
625 /* Finish decoding. */
626 thread->event.header = *hdr;
627 thread->event.thread_port = thread_port;
628 thread->event.task_port = task_port;
629 thread->event.ex_type = data[0];
630 thread->event.data_count = data[1];
632 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
633 + sizeof (*ndr) + 2 * sizeof (integer_t)
634 + data[1] * sizeof (integer_t)))
636 for (i = 0; i < data[1]; i++)
637 thread->event.ex_data[i] = data[2 + i];
639 thread->msg_state = DARWIN_MESSAGE;
645 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
648 mach_msg_header_t *rh = &reply->Head;
649 rh->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(hdr->msgh_bits), 0);
650 rh->msgh_remote_port = hdr->msgh_remote_port;
651 rh->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
652 rh->msgh_local_port = MACH_PORT_NULL;
653 rh->msgh_id = hdr->msgh_id + 100;
655 reply->NDR = NDR_record;
656 reply->RetCode = code;
660 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
663 mig_reply_error_t reply;
665 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
667 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
668 reply.Head.msgh_size, 0,
669 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
671 MACH_CHECK_ERROR (kret);
673 inf->private->pending_messages--;
677 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
678 int step, int nsignal)
684 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
685 thread->msg_state, thread->gdb_port, step, nsignal);
687 switch (thread->msg_state)
690 if (thread->event.ex_type == EXC_SOFTWARE
691 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
693 /* Either deliver a new signal or cancel the signal received. */
694 res = PTRACE (PT_THUPDATE, inf->pid,
695 (void *)(uintptr_t)thread->gdb_port, nsignal);
697 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
701 /* Note: ptrace is allowed only if the process is stopped.
702 Directly send the signal to the thread. */
703 res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
704 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
705 thread->gdb_port, nsignal, res);
706 thread->signaled = 1;
709 /* Set or reset single step. */
710 if (step != thread->single_step)
712 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
713 thread->gdb_port, step);
714 darwin_set_sstep (thread->gdb_port, step);
715 thread->single_step = step;
718 darwin_send_reply (inf, thread);
719 thread->msg_state = DARWIN_RUNNING;
726 kret = thread_resume (thread->gdb_port);
727 MACH_CHECK_ERROR (kret);
729 thread->msg_state = DARWIN_RUNNING;
734 /* Resume all threads of the inferior. */
737 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
739 darwin_thread_t *thread;
743 VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
745 darwin_resume_thread (inf, thread, step, nsignal);
748 struct resume_inferior_threads_param
755 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
757 int step = ((struct resume_inferior_threads_param *)param)->step;
758 int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
760 darwin_resume_inferior_threads (inf, step, nsignal);
765 /* Suspend all threads of INF. */
768 darwin_suspend_inferior_threads (struct inferior *inf)
770 darwin_thread_t *thread;
775 VEC_iterate (darwin_thread_t, inf->private->threads, k, thread);
777 switch (thread->msg_state)
783 kret = thread_suspend (thread->gdb_port);
784 MACH_CHECK_ERROR (kret);
785 thread->msg_state = DARWIN_STOPPED;
791 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
793 struct target_waitstatus status;
799 struct inferior *inf;
802 (2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
803 ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
805 if (signal == GDB_SIGNAL_0)
808 nsignal = gdb_signal_to_host (signal);
810 /* Don't try to single step all threads. */
812 ptid = inferior_ptid;
814 /* minus_one_ptid is RESUME_ALL. */
815 if (ptid_equal (ptid, minus_one_ptid))
817 struct resume_inferior_threads_param param;
819 param.nsignal = nsignal;
822 /* Resume threads. */
823 iterate_over_inferiors (darwin_resume_inferior_threads_it, ¶m);
825 iterate_over_inferiors (darwin_resume_inferior_it, NULL);
829 struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
830 long tid = ptid_get_tid (ptid);
832 /* Stop the inferior (should be useless). */
833 darwin_suspend_inferior (inf);
836 darwin_resume_inferior_threads (inf, step, nsignal);
839 darwin_thread_t *thread;
841 /* Suspend threads of the task. */
842 darwin_suspend_inferior_threads (inf);
844 /* Resume the selected thread. */
845 thread = darwin_find_thread (inf, tid);
847 darwin_resume_thread (inf, thread, step, nsignal);
850 /* Resume the task. */
851 darwin_resume_inferior (inf);
856 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
857 enum gdb_signal signal)
859 return darwin_resume (ptid, step, signal);
863 darwin_decode_message (mach_msg_header_t *hdr,
864 darwin_thread_t **pthread,
865 struct inferior **pinf,
866 struct target_waitstatus *status)
868 darwin_thread_t *thread;
869 struct inferior *inf;
871 /* Exception message. */
872 if (hdr->msgh_local_port == darwin_ex_port)
876 /* Decode message. */
877 res = darwin_decode_exception_message (hdr, &inf, &thread);
881 /* Should not happen... */
883 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
884 /* FIXME: send a failure reply? */
885 status->kind = TARGET_WAITKIND_SPURIOUS;
886 return minus_one_ptid;
890 inf->private->pending_messages++;
892 status->kind = TARGET_WAITKIND_STOPPED;
893 thread->msg_state = DARWIN_MESSAGE;
895 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
897 unparse_exception_type (thread->event.ex_type));
899 switch (thread->event.ex_type)
902 status->value.sig = TARGET_EXC_BAD_ACCESS;
904 case EXC_BAD_INSTRUCTION:
905 status->value.sig = TARGET_EXC_BAD_INSTRUCTION;
908 status->value.sig = TARGET_EXC_ARITHMETIC;
911 status->value.sig = TARGET_EXC_EMULATION;
914 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
917 gdb_signal_from_host (thread->event.ex_data[1]);
918 inferior_debug (5, _(" (signal %d: %s)\n"),
919 thread->event.ex_data[1],
920 gdb_signal_to_name (status->value.sig));
922 /* If the thread is stopped because it has received a signal
923 that gdb has just sent, continue. */
924 if (thread->signaled)
926 thread->signaled = 0;
927 darwin_send_reply (inf, thread);
928 thread->msg_state = DARWIN_RUNNING;
929 status->kind = TARGET_WAITKIND_IGNORE;
933 status->value.sig = TARGET_EXC_SOFTWARE;
936 /* Many internal GDB routines expect breakpoints to be reported
937 as GDB_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
938 as a spurious signal. */
939 status->value.sig = GDB_SIGNAL_TRAP;
942 status->value.sig = GDB_SIGNAL_UNKNOWN;
946 return ptid_build (inf->pid, 0, thread->gdb_port);
952 inf = darwin_find_inferior_by_notify (hdr->msgh_local_port);
955 if (!inf->private->no_ptrace)
960 res = wait4 (inf->pid, &wstatus, 0, NULL);
961 if (res < 0 || res != inf->pid)
963 printf_unfiltered (_("wait4: res=%d: %s\n"),
964 res, safe_strerror (errno));
965 status->kind = TARGET_WAITKIND_SPURIOUS;
966 return minus_one_ptid;
968 if (WIFEXITED (wstatus))
970 status->kind = TARGET_WAITKIND_EXITED;
971 status->value.integer = WEXITSTATUS (wstatus);
975 status->kind = TARGET_WAITKIND_SIGNALLED;
976 status->value.sig = WTERMSIG (wstatus);
979 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
982 /* Looks necessary on Leopard and harmless... */
983 wait4 (inf->pid, &wstatus, 0, NULL);
985 return ptid_build (inf->pid, 0, 0);
989 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
990 status->kind = TARGET_WAITKIND_EXITED;
991 status->value.integer = 0; /* Don't know. */
992 return ptid_build (inf->pid, 0, 0);
996 printf_unfiltered (_("Bad local-port: 0x%x\n"), hdr->msgh_local_port);
997 status->kind = TARGET_WAITKIND_SPURIOUS;
998 return minus_one_ptid;
1002 cancel_breakpoint (ptid_t ptid)
1004 /* Arrange for a breakpoint to be hit again later. We will handle
1005 the current event, eventually we will resume this thread, and this
1006 breakpoint will trap again.
1008 If we do not do this, then we run the risk that the user will
1009 delete or disable the breakpoint, but the thread will have already
1012 struct regcache *regcache = get_thread_regcache (ptid);
1013 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1016 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1017 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
1019 inferior_debug (4, "cancel_breakpoint for thread 0x%x\n",
1020 ptid_get_tid (ptid));
1022 /* Back up the PC if necessary. */
1023 if (gdbarch_decr_pc_after_break (gdbarch))
1024 regcache_write_pc (regcache, pc);
1032 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1037 mach_msg_header_t hdr;
1040 mach_msg_header_t *hdr = &msgin.hdr;
1042 darwin_thread_t *thread;
1043 struct inferior *inf;
1046 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1047 ptid_get_pid (ptid), ptid_get_tid (ptid));
1049 /* Handle fake stop events at first. */
1050 if (darwin_inf_fake_stop != NULL)
1052 inf = darwin_inf_fake_stop;
1053 darwin_inf_fake_stop = NULL;
1055 status->kind = TARGET_WAITKIND_STOPPED;
1056 status->value.sig = GDB_SIGNAL_TRAP;
1057 thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
1058 thread->msg_state = DARWIN_STOPPED;
1059 return ptid_build (inf->pid, 0, thread->gdb_port);
1064 /* set_sigint_trap (); */
1066 /* Wait for a message. */
1067 kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1068 sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1070 /* clear_sigint_trap (); */
1072 if (kret == MACH_RCV_INTERRUPTED)
1074 status->kind = TARGET_WAITKIND_IGNORE;
1075 return minus_one_ptid;
1078 if (kret != MACH_MSG_SUCCESS)
1080 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1081 status->kind = TARGET_WAITKIND_SPURIOUS;
1082 return minus_one_ptid;
1085 /* Debug: display message. */
1086 if (darwin_debug_flag > 10)
1087 darwin_dump_message (hdr, darwin_debug_flag > 11);
1089 res = darwin_decode_message (hdr, &thread, &inf, status);
1094 while (status->kind == TARGET_WAITKIND_IGNORE);
1096 /* Stop all tasks. */
1097 iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1099 /* Read pending messages. */
1102 struct target_waitstatus status2;
1105 kret = mach_msg (&msgin.hdr,
1106 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1107 sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1109 if (kret == MACH_RCV_TIMED_OUT)
1111 if (kret != MACH_MSG_SUCCESS)
1114 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1118 ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1120 if (inf != NULL && thread != NULL
1121 && thread->event.ex_type == EXC_BREAKPOINT)
1123 if (thread->single_step
1124 || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1126 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1127 darwin_send_reply (inf, thread);
1128 thread->msg_state = DARWIN_RUNNING;
1132 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1136 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1142 darwin_wait_to (struct target_ops *ops,
1143 ptid_t ptid, struct target_waitstatus *status, int options)
1145 return darwin_wait (ptid, status);
1149 darwin_stop (ptid_t t)
1151 struct inferior *inf = current_inferior ();
1153 /* FIXME: handle in no_ptrace mode. */
1154 gdb_assert (!inf->private->no_ptrace);
1155 kill (inf->pid, SIGINT);
1159 darwin_mourn_inferior (struct target_ops *ops)
1161 struct inferior *inf = current_inferior ();
1166 unpush_target (darwin_ops);
1168 /* Deallocate threads. */
1169 if (inf->private->threads)
1174 VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
1177 kret = mach_port_deallocate (gdb_task, t->gdb_port);
1178 MACH_CHECK_ERROR (kret);
1180 VEC_free (darwin_thread_t, inf->private->threads);
1181 inf->private->threads = NULL;
1184 kret = mach_port_move_member (gdb_task,
1185 inf->private->notify_port, MACH_PORT_NULL);
1186 MACH_CHECK_ERROR (kret);
1188 kret = mach_port_request_notification (gdb_task, inf->private->task,
1189 MACH_NOTIFY_DEAD_NAME, 0,
1191 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1193 /* This can fail if the task is dead. */
1194 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1195 inf->private->task, prev, inf->private->notify_port);
1197 if (kret == KERN_SUCCESS)
1199 kret = mach_port_deallocate (gdb_task, prev);
1200 MACH_CHECK_ERROR (kret);
1203 kret = mach_port_destroy (gdb_task, inf->private->notify_port);
1204 MACH_CHECK_ERROR (kret);
1207 /* Deallocate saved exception ports. */
1208 for (i = 0; i < inf->private->exception_info.count; i++)
1210 kret = mach_port_deallocate
1211 (gdb_task, inf->private->exception_info.ports[i]);
1212 MACH_CHECK_ERROR (kret);
1214 inf->private->exception_info.count = 0;
1216 kret = mach_port_deallocate (gdb_task, inf->private->task);
1217 MACH_CHECK_ERROR (kret);
1219 xfree (inf->private);
1220 inf->private = NULL;
1222 generic_mourn_inferior ();
1226 darwin_reply_to_all_pending_messages (struct inferior *inf)
1232 VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
1235 if (t->msg_state == DARWIN_MESSAGE)
1236 darwin_resume_thread (inf, t, 0, 0);
1241 darwin_stop_inferior (struct inferior *inf)
1243 struct target_waitstatus wstatus;
1249 gdb_assert (inf != NULL);
1251 darwin_suspend_inferior (inf);
1253 darwin_reply_to_all_pending_messages (inf);
1255 if (inf->private->no_ptrace)
1258 res = kill (inf->pid, SIGSTOP);
1260 warning (_("cannot kill: %s"), safe_strerror (errno));
1262 /* Wait until the process is really stopped. */
1265 ptid = darwin_wait (inferior_ptid, &wstatus);
1266 if (wstatus.kind == TARGET_WAITKIND_STOPPED
1267 && wstatus.value.sig == GDB_SIGNAL_STOP)
1272 static kern_return_t
1273 darwin_save_exception_ports (darwin_inferior *inf)
1277 inf->exception_info.count =
1278 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1280 kret = task_get_exception_ports
1281 (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1282 &inf->exception_info.count, inf->exception_info.ports,
1283 inf->exception_info.behaviors, inf->exception_info.flavors);
1287 static kern_return_t
1288 darwin_restore_exception_ports (darwin_inferior *inf)
1293 for (i = 0; i < inf->exception_info.count; i++)
1295 kret = task_set_exception_ports
1296 (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1297 inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1298 if (kret != KERN_SUCCESS)
1302 return KERN_SUCCESS;
1306 darwin_kill_inferior (struct target_ops *ops)
1308 struct inferior *inf = current_inferior ();
1309 struct target_waitstatus wstatus;
1315 if (ptid_equal (inferior_ptid, null_ptid))
1318 gdb_assert (inf != NULL);
1320 kret = darwin_restore_exception_ports (inf->private);
1321 MACH_CHECK_ERROR (kret);
1323 darwin_reply_to_all_pending_messages (inf);
1325 res = kill (inf->pid, 9);
1329 darwin_resume_inferior (inf);
1331 ptid = darwin_wait (inferior_ptid, &wstatus);
1333 else if (errno != ESRCH)
1334 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1335 inf->pid, safe_strerror (errno));
1337 target_mourn_inferior ();
1341 darwin_attach_pid (struct inferior *inf)
1344 mach_port_t prev_port;
1346 mach_port_t prev_not;
1347 exception_mask_t mask;
1349 inf->private = XZALLOC (darwin_inferior);
1351 kret = task_for_pid (gdb_task, inf->pid, &inf->private->task);
1352 if (kret != KERN_SUCCESS)
1356 if (!inf->attach_flag)
1359 waitpid (inf->pid, &status, 0);
1362 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1363 " (please check gdb is codesigned - see taskgated(8))"),
1364 inf->pid, mach_error_string (kret), (unsigned long) kret);
1367 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1368 inf->private->task, inf->pid);
1370 if (darwin_ex_port == MACH_PORT_NULL)
1372 /* Create a port to get exceptions. */
1373 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1375 if (kret != KERN_SUCCESS)
1376 error (_("Unable to create exception port, mach_port_allocate "
1380 kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1381 MACH_MSG_TYPE_MAKE_SEND);
1382 if (kret != KERN_SUCCESS)
1383 error (_("Unable to create exception port, mach_port_insert_right "
1387 /* Create a port set and put ex_port in it. */
1388 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1390 if (kret != KERN_SUCCESS)
1391 error (_("Unable to create port set, mach_port_allocate "
1395 kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
1396 if (kret != KERN_SUCCESS)
1397 error (_("Unable to move exception port into new port set, "
1398 "mach_port_move_member\n"
1403 /* Create a port to be notified when the child task terminates. */
1404 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1405 &inf->private->notify_port);
1406 if (kret != KERN_SUCCESS)
1407 error (_("Unable to create notification port, mach_port_allocate "
1411 kret = mach_port_move_member (gdb_task,
1412 inf->private->notify_port, darwin_port_set);
1413 if (kret != KERN_SUCCESS)
1414 error (_("Unable to move notification port into new port set, "
1415 "mach_port_move_member\n"
1419 kret = mach_port_request_notification (gdb_task, inf->private->task,
1420 MACH_NOTIFY_DEAD_NAME, 0,
1421 inf->private->notify_port,
1422 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1424 if (kret != KERN_SUCCESS)
1425 error (_("Termination notification request failed, "
1426 "mach_port_request_notification\n"
1429 if (prev_not != MACH_PORT_NULL)
1431 /* This is unexpected, as there should not be any previously
1432 registered notification request. But this is not a fatal
1433 issue, so just emit a warning. */
1435 A task termination request was registered before the debugger registered\n\
1436 its own. This is unexpected, but should otherwise not have any actual\n\
1437 impact on the debugging session."));
1440 kret = darwin_save_exception_ports (inf->private);
1441 if (kret != KERN_SUCCESS)
1442 error (_("Unable to save exception ports, task_get_exception_ports"
1446 /* Set exception port. */
1447 if (enable_mach_exceptions)
1448 mask = EXC_MASK_ALL;
1450 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1451 kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
1452 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1453 if (kret != KERN_SUCCESS)
1454 error (_("Unable to set exception ports, task_set_exception_ports"
1458 push_target (darwin_ops);
1462 darwin_init_thread_list (struct inferior *inf)
1464 darwin_thread_t *thread;
1467 darwin_check_new_threads (inf);
1469 gdb_assert (inf->private->threads
1470 && VEC_length (darwin_thread_t, inf->private->threads) > 0);
1471 thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
1473 /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1475 new_ptid = ptid_build (inf->pid, 0, thread->gdb_port);
1476 thread_change_ptid (inferior_ptid, new_ptid);
1477 inferior_ptid = new_ptid;
1480 /* The child must synchronize with gdb: gdb must set the exception port
1481 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1482 FIXME: is there a lighter way ? */
1483 static int ptrace_fds[2];
1486 darwin_ptrace_me (void)
1491 /* Close write end point. */
1492 close (ptrace_fds[1]);
1494 /* Wait until gdb is ready. */
1495 res = read (ptrace_fds[0], &c, 1);
1497 error (_("unable to read from pipe, read returned: %d"), res);
1498 close (ptrace_fds[0]);
1500 /* Get rid of privileges. */
1501 setegid (getgid ());
1504 PTRACE (PT_TRACE_ME, 0, 0, 0);
1506 /* Redirect signals to exception port. */
1507 PTRACE (PT_SIGEXC, 0, 0, 0);
1510 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1512 darwin_pre_ptrace (void)
1514 if (pipe (ptrace_fds) != 0)
1518 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1521 mark_fd_no_cloexec (ptrace_fds[0]);
1522 mark_fd_no_cloexec (ptrace_fds[1]);
1526 darwin_ptrace_him (int pid)
1530 mach_port_t prev_port;
1532 struct inferior *inf = current_inferior ();
1534 darwin_attach_pid (inf);
1536 /* Let's the child run. */
1537 close (ptrace_fds[0]);
1538 close (ptrace_fds[1]);
1540 unmark_fd_no_cloexec (ptrace_fds[0]);
1541 unmark_fd_no_cloexec (ptrace_fds[1]);
1543 darwin_init_thread_list (inf);
1545 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
1549 darwin_execvp (const char *file, char * const argv[], char * const env[])
1551 posix_spawnattr_t attr;
1555 res = posix_spawnattr_init (&attr);
1559 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1563 /* Do like execve: replace the image. */
1564 ps_flags = POSIX_SPAWN_SETEXEC;
1566 /* Disable ASLR. The constant doesn't look to be available outside the
1567 kernel include files. */
1568 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1569 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1571 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1572 res = posix_spawnattr_setflags (&attr, ps_flags);
1575 fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1579 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1583 darwin_create_inferior (struct target_ops *ops, char *exec_file,
1584 char *allargs, char **env, int from_tty)
1586 /* Do the hard work. */
1587 fork_inferior (exec_file, allargs, env, darwin_ptrace_me, darwin_ptrace_him,
1588 darwin_pre_ptrace, NULL, darwin_execvp);
1590 /* Return now in case of error. */
1591 if (ptid_equal (inferior_ptid, null_ptid))
1596 /* Set things up such that the next call to darwin_wait will immediately
1597 return a fake stop event for inferior INF.
1599 This assumes that the inferior's thread list has been initialized,
1600 as it will suspend the inferior's first thread. */
1603 darwin_setup_fake_stop_event (struct inferior *inf)
1605 darwin_thread_t *thread;
1608 gdb_assert (darwin_inf_fake_stop == NULL);
1609 darwin_inf_fake_stop = inf;
1611 /* When detecting a fake pending stop event, darwin_wait returns
1612 an event saying that the first thread is in a DARWIN_STOPPED
1613 state. To make that accurate, we need to suspend that thread
1614 as well. Otherwise, we'll try resuming it when resuming the
1615 inferior, and get a warning because the thread's suspend count
1616 is already zero, making the resume request useless. */
1617 thread = VEC_index (darwin_thread_t, inf->private->threads, 0);
1618 kret = thread_suspend (thread->gdb_port);
1619 MACH_CHECK_ERROR (kret);
1622 /* Attach to process PID, then initialize for debugging it
1623 and wait for the trace-trap that results from attaching. */
1625 darwin_attach (struct target_ops *ops, char *args, int from_tty)
1631 struct inferior *inf;
1634 pid = parse_pid_to_attach (args);
1636 if (pid == getpid ()) /* Trying to masturbate? */
1637 error (_("I refuse to debug myself!"));
1641 char *exec_file = get_exec_file (0);
1644 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1645 target_pid_to_str (pid_to_ptid (pid)));
1647 printf_unfiltered (_("Attaching to %s\n"),
1648 target_pid_to_str (pid_to_ptid (pid)));
1650 gdb_flush (gdb_stdout);
1653 if (pid == 0 || kill (pid, 0) < 0)
1654 error (_("Can't attach to process %d: %s (%d)"),
1655 pid, safe_strerror (errno), errno);
1657 inferior_ptid = pid_to_ptid (pid);
1658 inf = current_inferior ();
1659 inferior_appeared (inf, pid);
1660 inf->attach_flag = 1;
1662 /* Always add a main thread. */
1663 add_thread_silent (inferior_ptid);
1665 darwin_attach_pid (inf);
1667 darwin_suspend_inferior (inf);
1669 darwin_init_thread_list (inf);
1671 darwin_check_osabi (inf->private, ptid_get_tid (inferior_ptid));
1673 darwin_setup_fake_stop_event (inf);
1675 inf->private->no_ptrace = 1;
1678 /* Take a program previously attached to and detaches it.
1679 The program resumes execution and will no longer stop
1680 on signals, etc. We'd better not have left any breakpoints
1681 in the program or it'll die when it hits one. For this
1682 to work, it may be necessary for the process to have been
1683 previously attached. It *might* work if the program was
1684 started via fork. */
1686 darwin_detach (struct target_ops *ops, char *args, int from_tty)
1688 pid_t pid = ptid_get_pid (inferior_ptid);
1689 struct inferior *inf = current_inferior ();
1693 /* Display message. */
1696 char *exec_file = get_exec_file (0);
1699 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
1700 target_pid_to_str (pid_to_ptid (pid)));
1701 gdb_flush (gdb_stdout);
1704 /* If ptrace() is in use, stop the process. */
1705 if (!inf->private->no_ptrace)
1706 darwin_stop_inferior (inf);
1708 kret = darwin_restore_exception_ports (inf->private);
1709 MACH_CHECK_ERROR (kret);
1711 if (!inf->private->no_ptrace)
1713 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1715 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1716 inf->pid, safe_strerror (errno), errno);
1719 darwin_reply_to_all_pending_messages (inf);
1721 /* When using ptrace, we have just performed a PT_DETACH, which
1722 resumes the inferior. On the other hand, when we are not using
1723 ptrace, we need to resume its execution ourselves. */
1724 if (inf->private->no_ptrace)
1725 darwin_resume_inferior (inf);
1727 darwin_mourn_inferior (ops);
1731 darwin_files_info (struct target_ops *ops)
1736 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1738 static char buf[80];
1739 long tid = ptid_get_tid (ptid);
1743 snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1744 tid, ptid_get_pid (ptid));
1748 return normal_pid_to_str (ptid);
1752 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
1757 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1758 copy it to RDADDR in gdb's address space.
1759 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1760 to ADDR in inferior task's address space.
1761 Return 0 on failure; number of bytes read / writen otherwise. */
1763 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
1764 gdb_byte *rdaddr, const gdb_byte *wraddr,
1768 mach_vm_address_t offset = addr & (mach_page_size - 1);
1769 mach_vm_address_t low_address = (mach_vm_address_t) (addr - offset);
1770 mach_vm_size_t aligned_length = (mach_vm_size_t) PAGE_ROUND (offset + length);
1772 mach_msg_type_number_t copy_count;
1773 mach_vm_size_t remaining_length;
1774 mach_vm_address_t region_address;
1775 mach_vm_size_t region_length;
1777 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%d)\n"),
1778 task, core_addr_to_string (addr), length);
1780 /* Get memory from inferior with page aligned addresses. */
1781 kret = mach_vm_read (task, low_address, aligned_length,
1782 &copied, ©_count);
1783 if (kret != KERN_SUCCESS)
1786 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1787 core_addr_to_string (addr), mach_error_string (kret));
1792 memcpy (rdaddr, (char *)copied + offset, length);
1797 memcpy ((char *)copied + offset, wraddr, length);
1799 /* Do writes atomically.
1800 First check for holes and unwritable memory. */
1801 for (region_address = low_address, remaining_length = aligned_length;
1802 region_address < low_address + aligned_length;
1803 region_address += region_length, remaining_length -= region_length)
1805 vm_region_submap_short_info_data_64_t info;
1806 mach_vm_address_t region_start = region_address;
1807 mach_msg_type_number_t count;
1808 natural_t region_depth;
1810 region_depth = 100000;
1811 count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
1812 kret = mach_vm_region_recurse
1813 (task, ®ion_start, ®ion_length, ®ion_depth,
1814 (vm_region_recurse_info_t) &info, &count);
1816 if (kret != KERN_SUCCESS)
1818 inferior_debug (1, _("darwin_read_write_inferior: "
1819 "mach_vm_region_recurse failed at %s: %s\n"),
1820 core_addr_to_string (region_address),
1821 mach_error_string (kret));
1826 (9, _("darwin_read_write_inferior: "
1827 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1828 core_addr_to_string (region_address),
1829 core_addr_to_string (region_start),
1830 core_addr_to_string (region_length));
1832 /* Check for holes in memory. */
1833 if (region_start > region_address)
1835 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1836 core_addr_to_string (region_address),
1837 core_addr_to_string (region_start),
1838 (unsigned)region_length);
1843 /* Adjust the length. */
1844 region_length -= (region_address - region_start);
1846 if (!(info.max_protection & VM_PROT_WRITE))
1848 kret = mach_vm_protect
1849 (task, region_address, region_length,
1850 TRUE, info.max_protection | VM_PROT_WRITE | VM_PROT_COPY);
1851 if (kret != KERN_SUCCESS)
1853 warning (_("darwin_read_write_inf: "
1854 "mach_vm_protect max failed at %s: %s"),
1855 core_addr_to_string (region_address),
1856 mach_error_string (kret));
1862 if (!(info.protection & VM_PROT_WRITE))
1864 kret = mach_vm_protect (task, region_address, region_length,
1865 FALSE, info.protection | VM_PROT_WRITE);
1866 if (kret != KERN_SUCCESS)
1868 warning (_("darwin_read_write_inf: "
1869 "mach_vm_protect failed at %s (len=0x%lx): %s"),
1870 core_addr_to_string (region_address),
1871 (unsigned long)region_length, mach_error_string (kret));
1878 kret = mach_vm_write (task, low_address, copied, aligned_length);
1880 if (kret != KERN_SUCCESS)
1882 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1883 mach_error_string (kret));
1887 mach_vm_deallocate (mach_task_self (), copied, copy_count);
1891 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1893 Return 0 on failure; number of bytes read / written otherwise. */
1895 #ifdef TASK_DYLD_INFO_COUNT
1896 /* This is not available in Darwin 9. */
1898 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
1901 struct task_dyld_info task_dyld_info;
1902 mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
1903 int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
1909 kret = task_info (task, TASK_DYLD_INFO, (task_info_t) &task_dyld_info, &count);
1910 MACH_CHECK_ERROR (kret);
1911 if (kret != KERN_SUCCESS)
1914 if (addr + length > sz)
1916 memcpy (rdaddr, (char *)&task_dyld_info + addr, length);
1922 /* Return 0 on failure, number of bytes handled otherwise. TARGET
1925 darwin_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
1926 struct mem_attrib *attrib, struct target_ops *target)
1928 struct inferior *inf = current_inferior ();
1929 task_t task = inf->private->task;
1931 if (task == MACH_PORT_NULL)
1934 inferior_debug (8, _("darwin_xfer_memory(%s, %d, %c)\n"),
1935 core_addr_to_string (memaddr), len, write ? 'w' : 'r');
1938 return darwin_read_write_inferior (task, memaddr, NULL, myaddr, len);
1940 return darwin_read_write_inferior (task, memaddr, myaddr, NULL, len);
1944 darwin_xfer_partial (struct target_ops *ops,
1945 enum target_object object, const char *annex,
1946 gdb_byte *readbuf, const gdb_byte *writebuf,
1947 ULONGEST offset, LONGEST len)
1949 struct inferior *inf = current_inferior ();
1952 (8, _("darwin_xfer_partial(%s, %d, rbuf=%s, wbuf=%s) pid=%u\n"),
1953 core_addr_to_string (offset), (int)len,
1954 host_address_to_string (readbuf), host_address_to_string (writebuf),
1959 case TARGET_OBJECT_MEMORY:
1960 return darwin_read_write_inferior (inf->private->task, offset,
1961 readbuf, writebuf, len);
1962 #ifdef TASK_DYLD_INFO_COUNT
1963 case TARGET_OBJECT_DARWIN_DYLD_INFO:
1964 if (writebuf != NULL || readbuf == NULL)
1966 /* Support only read. */
1969 return darwin_read_dyld_info (inf->private->task, offset, readbuf, len);
1978 set_enable_mach_exceptions (char *args, int from_tty,
1979 struct cmd_list_element *c)
1981 if (!ptid_equal (inferior_ptid, null_ptid))
1983 struct inferior *inf = current_inferior ();
1984 exception_mask_t mask;
1987 if (enable_mach_exceptions)
1988 mask = EXC_MASK_ALL;
1991 darwin_restore_exception_ports (inf->private);
1992 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1994 kret = task_set_exception_ports (inf->private->task, mask, darwin_ex_port,
1995 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1996 MACH_CHECK_ERROR (kret);
2001 darwin_pid_to_exec_file (int pid)
2006 path = xmalloc (MAXPATHLEN);
2007 make_cleanup (xfree, path);
2009 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, MAXPATHLEN);
2017 darwin_get_ada_task_ptid (long lwp, long thread)
2022 struct inferior *inf = current_inferior ();
2024 mach_port_name_array_t names;
2025 mach_msg_type_number_t names_count;
2026 mach_port_type_array_t types;
2027 mach_msg_type_number_t types_count;
2030 /* First linear search. */
2032 VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
2034 if (t->inf_port == lwp)
2035 return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2037 /* Maybe the port was never extract. Do it now. */
2039 /* First get inferior port names. */
2040 kret = mach_port_names (inf->private->task, &names, &names_count, &types,
2042 MACH_CHECK_ERROR (kret);
2043 if (kret != KERN_SUCCESS)
2046 /* For each name, copy the right in the gdb space and then compare with
2047 our view of the inferior threads. We don't forget to deallocate the
2049 for (i = 0; i < names_count; i++)
2051 mach_port_t local_name;
2052 mach_msg_type_name_t local_type;
2054 /* We just need to know the corresponding name in gdb name space.
2055 So extract and deallocate the right. */
2056 kret = mach_port_extract_right (inf->private->task, names[i],
2057 MACH_MSG_TYPE_COPY_SEND,
2058 &local_name, &local_type);
2059 if (kret != KERN_SUCCESS)
2061 mach_port_deallocate (gdb_task, local_name);
2064 VEC_iterate (darwin_thread_t, inf->private->threads, k, t);
2066 if (t->gdb_port == local_name)
2068 t->inf_port = names[i];
2069 if (names[i] == lwp)
2074 vm_deallocate (gdb_task, (vm_address_t) names,
2075 names_count * sizeof (mach_port_t));
2078 return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2084 darwin_supports_multi_process (void)
2089 /* -Wmissing-prototypes */
2090 extern initialize_file_ftype _initialize_darwin_inferior;
2093 _initialize_darwin_inferior (void)
2097 gdb_task = mach_task_self ();
2098 darwin_host_self = mach_host_self ();
2100 /* Read page size. */
2101 kret = host_page_size (darwin_host_self, &mach_page_size);
2102 if (kret != KERN_SUCCESS)
2104 mach_page_size = 0x1000;
2105 MACH_CHECK_ERROR (kret);
2108 darwin_ops = inf_child_target ();
2110 darwin_ops->to_shortname = "darwin-child";
2111 darwin_ops->to_longname = _("Darwin child process");
2112 darwin_ops->to_doc =
2113 _("Darwin child process (started by the \"run\" command).");
2114 darwin_ops->to_create_inferior = darwin_create_inferior;
2115 darwin_ops->to_attach = darwin_attach;
2116 darwin_ops->to_attach_no_wait = 0;
2117 darwin_ops->to_detach = darwin_detach;
2118 darwin_ops->to_files_info = darwin_files_info;
2119 darwin_ops->to_wait = darwin_wait_to;
2120 darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2121 darwin_ops->to_kill = darwin_kill_inferior;
2122 darwin_ops->to_stop = darwin_stop;
2123 darwin_ops->to_resume = darwin_resume_to;
2124 darwin_ops->to_thread_alive = darwin_thread_alive;
2125 darwin_ops->to_pid_to_str = darwin_pid_to_str;
2126 darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
2127 darwin_ops->to_load = NULL;
2128 darwin_ops->deprecated_xfer_memory = darwin_xfer_memory;
2129 darwin_ops->to_xfer_partial = darwin_xfer_partial;
2130 darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2131 darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
2133 darwin_complete_target (darwin_ops);
2135 add_target (darwin_ops);
2137 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
2140 add_setshow_zuinteger_cmd ("darwin", class_obscure,
2141 &darwin_debug_flag, _("\
2142 Set if printing inferior communication debugging statements."), _("\
2143 Show if printing inferior communication debugging statements."), NULL,
2145 &setdebuglist, &showdebuglist);
2147 add_setshow_boolean_cmd ("mach-exceptions", class_support,
2148 &enable_mach_exceptions, _("\
2149 Set if mach exceptions are caught."), _("\
2150 Show if mach exceptions are caught."), _("\
2151 When this mode is on, all low level exceptions are reported before being\n\
2152 reported by the kernel."),
2153 &set_enable_mach_exceptions, NULL,
2154 &setlist, &showlist);