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"
71 Darwin kernel is Mach + BSD derived kernel. Note that they share the
72 same memory space and are linked together (ie there is no micro-kernel).
74 Although ptrace(2) is available on Darwin, it is not complete. We have
75 to use Mach calls to read and write memory and to modify registers. We
76 also use Mach to get inferior faults. As we cannot use select(2) or
77 signals with Mach port (the Mach communication channel), signals are
78 reported to gdb as an exception. Furthermore we detect death of the
79 inferior through a Mach notification message. This way we only wait
82 Some Mach documentation is available for Apple xnu source package or
86 #define PTRACE(CMD, PID, ADDR, SIG) \
87 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
89 extern boolean_t
exc_server (mach_msg_header_t
*in
, mach_msg_header_t
*out
);
91 static void darwin_stop (ptid_t
);
93 static void darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
94 enum gdb_signal signal
);
95 static void darwin_resume (ptid_t ptid
, int step
,
96 enum gdb_signal signal
);
98 static ptid_t
darwin_wait_to (struct target_ops
*ops
, ptid_t ptid
,
99 struct target_waitstatus
*status
, int options
);
100 static ptid_t
darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
);
102 static void darwin_mourn_inferior (struct target_ops
*ops
);
104 static void darwin_kill_inferior (struct target_ops
*ops
);
106 static void darwin_ptrace_me (void);
108 static void darwin_ptrace_him (int pid
);
110 static void darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
111 char *allargs
, char **env
, int from_tty
);
113 static void darwin_files_info (struct target_ops
*ops
);
115 static char *darwin_pid_to_str (struct target_ops
*ops
, ptid_t tpid
);
117 static int darwin_thread_alive (struct target_ops
*ops
, ptid_t tpid
);
119 /* Target operations for Darwin. */
120 static struct target_ops
*darwin_ops
;
122 /* Task identifier of gdb. */
123 static task_t gdb_task
;
125 /* A copy of mach_host_self (). */
126 mach_port_t darwin_host_self
;
128 /* Exception port. */
129 mach_port_t darwin_ex_port
;
132 mach_port_t darwin_port_set
;
135 static vm_size_t mach_page_size
;
137 /* If Set, catch all mach exceptions (before they are converted to signals
139 static int enable_mach_exceptions
;
141 /* Inferior that should report a fake stop event. */
142 static struct inferior
*darwin_inf_fake_stop
;
144 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
145 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
147 /* This controls output of inferior debugging. */
148 static unsigned int darwin_debug_flag
= 0;
150 /* Create a __TEXT __info_plist section in the executable so that gdb could
151 be signed. This is required to get an authorization for task_for_pid.
153 Once gdb is built, you can either:
154 * make it setgid procmod
155 * or codesign it with any system-trusted signing authority.
156 See taskgated(8) for details. */
157 static const unsigned char info_plist
[]
158 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
159 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
160 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
161 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
162 "<plist version=\"1.0\">\n"
164 " <key>CFBundleIdentifier</key>\n"
165 " <string>org.gnu.gdb</string>\n"
166 " <key>CFBundleName</key>\n"
167 " <string>gdb</string>\n"
168 " <key>CFBundleVersion</key>\n"
169 " <string>1.0</string>\n"
170 " <key>SecTaskAccess</key>\n"
172 " <string>allowed</string>\n"
173 " <string>debug</string>\n"
179 inferior_debug (int level
, const char *fmt
, ...)
183 if (darwin_debug_flag
< level
)
187 printf_unfiltered (_("[%d inferior]: "), getpid ());
188 vprintf_unfiltered (fmt
, ap
);
193 mach_check_error (kern_return_t ret
, const char *file
,
194 unsigned int line
, const char *func
)
196 if (ret
== KERN_SUCCESS
)
199 func
= _("[UNKNOWN]");
201 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
202 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
206 unparse_exception_type (unsigned int i
)
208 static char unknown_exception_buf
[32];
213 return "EXC_BAD_ACCESS";
214 case EXC_BAD_INSTRUCTION
:
215 return "EXC_BAD_INSTRUCTION";
217 return "EXC_ARITHMETIC";
219 return "EXC_EMULATION";
221 return "EXC_SOFTWARE";
223 return "EXC_BREAKPOINT";
225 return "EXC_SYSCALL";
226 case EXC_MACH_SYSCALL
:
227 return "EXC_MACH_SYSCALL";
229 return "EXC_RPC_ALERT";
233 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
234 return unknown_exception_buf
;
238 /* Set errno to zero, and then call ptrace with the given arguments.
239 If inferior debugging traces are on, then also print a debug
242 The returned value is the same as the value returned by ptrace,
243 except in the case where that value is -1 but errno is zero.
244 This case is documented to be a non-error situation, so we
245 return zero in that case. */
248 darwin_ptrace (const char *name
,
249 int request
, int pid
, PTRACE_TYPE_ARG3 arg3
, int arg4
)
254 ret
= ptrace (request
, pid
, (caddr_t
) arg3
, arg4
);
255 if (ret
== -1 && errno
== 0)
258 inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
259 name
, pid
, arg3
, arg4
, ret
,
260 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
265 cmp_thread_t (const void *l
, const void *r
)
267 thread_t tl
= *(const thread_t
*)l
;
268 thread_t tr
= *(const thread_t
*)r
;
269 return (int)(tl
- tr
);
273 darwin_check_new_threads (struct inferior
*inf
)
277 thread_array_t thread_list
;
278 unsigned int new_nbr
;
279 unsigned int old_nbr
;
280 unsigned int new_ix
, old_ix
;
281 darwin_inferior
*darwin_inf
= inf
->private;
282 VEC (darwin_thread_t
) *thread_vec
;
284 /* Get list of threads. */
285 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
286 MACH_CHECK_ERROR (kret
);
287 if (kret
!= KERN_SUCCESS
)
292 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
294 if (darwin_inf
->threads
)
295 old_nbr
= VEC_length (darwin_thread_t
, darwin_inf
->threads
);
299 /* Quick check for no changes. */
300 if (old_nbr
== new_nbr
)
302 for (i
= 0; i
< new_nbr
; i
++)
304 != VEC_index (darwin_thread_t
, darwin_inf
->threads
, i
)->gdb_port
)
308 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
309 new_nbr
* sizeof (int));
310 MACH_CHECK_ERROR (kret
);
315 thread_vec
= VEC_alloc (darwin_thread_t
, new_nbr
);
317 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
319 thread_t new_id
= (new_ix
< new_nbr
) ?
320 thread_list
[new_ix
] : THREAD_NULL
;
321 darwin_thread_t
*old
= (old_ix
< old_nbr
) ?
322 VEC_index (darwin_thread_t
, darwin_inf
->threads
, old_ix
) : NULL
;
323 thread_t old_id
= old
? old
->gdb_port
: THREAD_NULL
;
326 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
327 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
329 if (old_id
== new_id
)
331 /* Thread still exist. */
332 VEC_safe_push (darwin_thread_t
, thread_vec
, old
);
336 kret
= mach_port_deallocate (gdb_task
, old_id
);
337 MACH_CHECK_ERROR (kret
);
340 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
342 /* Ignore dead ports.
343 In some weird cases, we might get dead ports. They should
344 correspond to dead thread so they could safely be ignored. */
348 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
350 /* A thread was created. */
351 struct thread_info
*tp
;
352 struct private_thread_info
*pti
;
354 pti
= XZALLOC (struct private_thread_info
);
355 pti
->gdb_port
= new_id
;
356 pti
->msg_state
= DARWIN_RUNNING
;
358 /* Add a new thread unless this is the first one ever met. */
359 if (!(old_nbr
== 0 && new_ix
== 0))
360 tp
= add_thread_with_info (ptid_build (inf
->pid
, 0, new_id
), pti
);
363 tp
= find_thread_ptid (ptid_build (inf
->pid
, 0, 0));
367 VEC_safe_push (darwin_thread_t
, thread_vec
, pti
);
371 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
373 /* A thread was removed. */
374 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
375 kret
= mach_port_deallocate (gdb_task
, old_id
);
376 MACH_CHECK_ERROR (kret
);
380 gdb_assert_not_reached ("unexpected thread case");
383 if (darwin_inf
->threads
)
384 VEC_free (darwin_thread_t
, darwin_inf
->threads
);
385 darwin_inf
->threads
= thread_vec
;
387 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
388 new_nbr
* sizeof (int));
389 MACH_CHECK_ERROR (kret
);
393 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
395 return inf
->private->task
== *(task_t
*)port_ptr
;
399 find_inferior_notify_it (struct inferior
*inf
, void *port_ptr
)
401 return inf
->private->notify_port
== *(task_t
*)port_ptr
;
404 /* Return an inferior by task port. */
405 static struct inferior
*
406 darwin_find_inferior_by_task (task_t port
)
408 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
411 /* Return an inferior by notification port. */
412 static struct inferior
*
413 darwin_find_inferior_by_notify (mach_port_t port
)
415 return iterate_over_inferiors (&find_inferior_notify_it
, &port
);
418 /* Return a thread by port. */
419 static darwin_thread_t
*
420 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
426 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
428 if (t
->gdb_port
== thread
)
433 /* Suspend (ie stop) an inferior at Mach level. */
436 darwin_suspend_inferior (struct inferior
*inf
)
438 if (!inf
->private->suspended
)
442 kret
= task_suspend (inf
->private->task
);
443 MACH_CHECK_ERROR (kret
);
445 inf
->private->suspended
= 1;
449 /* Resume an inferior at Mach level. */
452 darwin_resume_inferior (struct inferior
*inf
)
454 if (inf
->private->suspended
)
458 kret
= task_resume (inf
->private->task
);
459 MACH_CHECK_ERROR (kret
);
461 inf
->private->suspended
= 0;
465 /* Iterator functions. */
468 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
470 darwin_suspend_inferior (inf
);
471 darwin_check_new_threads (inf
);
476 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
478 darwin_resume_inferior (inf
);
483 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
485 printf_unfiltered (_("message header:\n"));
486 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
487 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
488 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
489 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
490 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
491 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
495 const unsigned char *data
;
496 const unsigned long *ldata
;
500 data
= (unsigned char *)(hdr
+ 1);
501 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
503 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
505 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
506 mach_msg_port_descriptor_t
*desc
=
507 (mach_msg_port_descriptor_t
*)(bod
+ 1);
510 printf_unfiltered (_("body: descriptor_count=%u\n"),
511 bod
->msgh_descriptor_count
);
512 data
+= sizeof (mach_msg_body_t
);
513 size
-= sizeof (mach_msg_body_t
);
514 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
515 switch (desc
[k
].type
)
517 case MACH_MSG_PORT_DESCRIPTOR
:
519 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
520 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
523 printf_unfiltered (_(" descr %d: type=%u\n"),
527 data
+= bod
->msgh_descriptor_count
528 * sizeof (mach_msg_port_descriptor_t
);
529 size
-= bod
->msgh_descriptor_count
530 * sizeof (mach_msg_port_descriptor_t
);
531 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
533 (_("NDR: mig=%02x if=%02x encod=%02x "
534 "int=%02x char=%02x float=%02x\n"),
535 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
536 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
537 data
+= sizeof (NDR_record_t
);
538 size
-= sizeof (NDR_record_t
);
541 printf_unfiltered (_(" data:"));
542 ldata
= (const unsigned long *)data
;
543 for (i
= 0; i
< size
/ sizeof (unsigned long); i
++)
544 printf_unfiltered (" %08lx", ldata
[i
]);
545 printf_unfiltered (_("\n"));
550 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
551 struct inferior
**pinf
,
552 darwin_thread_t
**pthread
)
554 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
555 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
558 struct inferior
*inf
;
559 darwin_thread_t
*thread
;
561 thread_t thread_port
;
565 /* Check message identifier. 2401 is exc. */
566 if (hdr
->msgh_id
!= 2401)
569 /* Check message header. */
570 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
573 /* Check descriptors. */
574 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
575 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
576 || bod
->msgh_descriptor_count
!= 2
577 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
578 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
579 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
580 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
583 /* Check data representation. */
584 ndr
= (NDR_record_t
*)(desc
+ 2);
585 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
586 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
587 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
588 || ndr
->int_rep
!= NDR_record
.int_rep
589 || ndr
->char_rep
!= NDR_record
.char_rep
590 || ndr
->float_rep
!= NDR_record
.float_rep
)
593 /* Ok, the hard work. */
594 data
= (integer_t
*)(ndr
+ 1);
596 /* Find process by port. */
597 task_port
= desc
[1].name
;
598 thread_port
= desc
[0].name
;
599 inf
= darwin_find_inferior_by_task (task_port
);
604 /* Find thread by port. */
605 /* Check for new threads. Do it early so that the port in the exception
606 message can be deallocated. */
607 darwin_check_new_threads (inf
);
609 /* We got new rights to the task and the thread. Get rid of them. */
610 kret
= mach_port_deallocate (mach_task_self (), task_port
);
611 MACH_CHECK_ERROR (kret
);
612 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
613 MACH_CHECK_ERROR (kret
);
615 thread
= darwin_find_thread (inf
, thread_port
);
620 /* The thread should be running. However we have observed cases where a thread
621 got a SIGTTIN message after being stopped. */
622 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
624 /* Finish decoding. */
625 thread
->event
.header
= *hdr
;
626 thread
->event
.thread_port
= thread_port
;
627 thread
->event
.task_port
= task_port
;
628 thread
->event
.ex_type
= data
[0];
629 thread
->event
.data_count
= data
[1];
631 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
632 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
633 + data
[1] * sizeof (integer_t
)))
635 for (i
= 0; i
< data
[1]; i
++)
636 thread
->event
.ex_data
[i
] = data
[2 + i
];
638 thread
->msg_state
= DARWIN_MESSAGE
;
644 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
647 mach_msg_header_t
*rh
= &reply
->Head
;
648 rh
->msgh_bits
= MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(hdr
->msgh_bits
), 0);
649 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
650 rh
->msgh_size
= (mach_msg_size_t
)sizeof(mig_reply_error_t
);
651 rh
->msgh_local_port
= MACH_PORT_NULL
;
652 rh
->msgh_id
= hdr
->msgh_id
+ 100;
654 reply
->NDR
= NDR_record
;
655 reply
->RetCode
= code
;
659 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
662 mig_reply_error_t reply
;
664 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
666 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
667 reply
.Head
.msgh_size
, 0,
668 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
670 MACH_CHECK_ERROR (kret
);
672 inf
->private->pending_messages
--;
676 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
677 int step
, int nsignal
)
683 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
684 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
686 switch (thread
->msg_state
)
689 if (thread
->event
.ex_type
== EXC_SOFTWARE
690 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
692 /* Either deliver a new signal or cancel the signal received. */
693 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
694 (void *)(uintptr_t)thread
->gdb_port
, nsignal
);
696 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
700 /* Note: ptrace is allowed only if the process is stopped.
701 Directly send the signal to the thread. */
702 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
703 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
704 thread
->gdb_port
, nsignal
, res
);
705 thread
->signaled
= 1;
708 /* Set or reset single step. */
709 if (step
!= thread
->single_step
)
711 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
712 thread
->gdb_port
, step
);
713 darwin_set_sstep (thread
->gdb_port
, step
);
714 thread
->single_step
= step
;
717 darwin_send_reply (inf
, thread
);
718 thread
->msg_state
= DARWIN_RUNNING
;
725 kret
= thread_resume (thread
->gdb_port
);
726 MACH_CHECK_ERROR (kret
);
728 thread
->msg_state
= DARWIN_RUNNING
;
733 /* Resume all threads of the inferior. */
736 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
738 darwin_thread_t
*thread
;
742 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, thread
);
744 darwin_resume_thread (inf
, thread
, step
, nsignal
);
747 struct resume_inferior_threads_param
754 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
756 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
757 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
759 darwin_resume_inferior_threads (inf
, step
, nsignal
);
764 /* Suspend all threads of INF. */
767 darwin_suspend_inferior_threads (struct inferior
*inf
)
769 darwin_thread_t
*thread
;
774 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, thread
);
776 switch (thread
->msg_state
)
782 kret
= thread_suspend (thread
->gdb_port
);
783 MACH_CHECK_ERROR (kret
);
784 thread
->msg_state
= DARWIN_STOPPED
;
790 darwin_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
792 struct target_waitstatus status
;
798 struct inferior
*inf
;
801 (2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
802 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
804 if (signal
== GDB_SIGNAL_0
)
807 nsignal
= gdb_signal_to_host (signal
);
809 /* Don't try to single step all threads. */
811 ptid
= inferior_ptid
;
813 /* minus_one_ptid is RESUME_ALL. */
814 if (ptid_equal (ptid
, minus_one_ptid
))
816 struct resume_inferior_threads_param param
;
818 param
.nsignal
= nsignal
;
821 /* Resume threads. */
822 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
824 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
828 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (ptid
));
829 long tid
= ptid_get_tid (ptid
);
831 /* Stop the inferior (should be useless). */
832 darwin_suspend_inferior (inf
);
835 darwin_resume_inferior_threads (inf
, step
, nsignal
);
838 darwin_thread_t
*thread
;
840 /* Suspend threads of the task. */
841 darwin_suspend_inferior_threads (inf
);
843 /* Resume the selected thread. */
844 thread
= darwin_find_thread (inf
, tid
);
846 darwin_resume_thread (inf
, thread
, step
, nsignal
);
849 /* Resume the task. */
850 darwin_resume_inferior (inf
);
855 darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
856 enum gdb_signal signal
)
858 return darwin_resume (ptid
, step
, signal
);
862 darwin_decode_message (mach_msg_header_t
*hdr
,
863 darwin_thread_t
**pthread
,
864 struct inferior
**pinf
,
865 struct target_waitstatus
*status
)
867 darwin_thread_t
*thread
;
868 struct inferior
*inf
;
870 /* Exception message. */
871 if (hdr
->msgh_local_port
== darwin_ex_port
)
875 /* Decode message. */
876 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
880 /* Should not happen... */
882 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
883 /* FIXME: send a failure reply? */
884 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
885 return minus_one_ptid
;
889 inf
->private->pending_messages
++;
891 status
->kind
= TARGET_WAITKIND_STOPPED
;
892 thread
->msg_state
= DARWIN_MESSAGE
;
894 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
896 unparse_exception_type (thread
->event
.ex_type
));
898 switch (thread
->event
.ex_type
)
901 status
->value
.sig
= TARGET_EXC_BAD_ACCESS
;
903 case EXC_BAD_INSTRUCTION
:
904 status
->value
.sig
= TARGET_EXC_BAD_INSTRUCTION
;
907 status
->value
.sig
= TARGET_EXC_ARITHMETIC
;
910 status
->value
.sig
= TARGET_EXC_EMULATION
;
913 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
916 gdb_signal_from_host (thread
->event
.ex_data
[1]);
917 inferior_debug (5, _(" (signal %d: %s)\n"),
918 thread
->event
.ex_data
[1],
919 gdb_signal_to_name (status
->value
.sig
));
921 /* If the thread is stopped because it has received a signal
922 that gdb has just sent, continue. */
923 if (thread
->signaled
)
925 thread
->signaled
= 0;
926 darwin_send_reply (inf
, thread
);
927 thread
->msg_state
= DARWIN_RUNNING
;
928 status
->kind
= TARGET_WAITKIND_IGNORE
;
932 status
->value
.sig
= TARGET_EXC_SOFTWARE
;
935 /* Many internal GDB routines expect breakpoints to be reported
936 as GDB_SIGNAL_TRAP, and will report TARGET_EXC_BREAKPOINT
937 as a spurious signal. */
938 status
->value
.sig
= GDB_SIGNAL_TRAP
;
941 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
945 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
951 inf
= darwin_find_inferior_by_notify (hdr
->msgh_local_port
);
954 if (!inf
->private->no_ptrace
)
959 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
960 if (res
< 0 || res
!= inf
->pid
)
962 printf_unfiltered (_("wait4: res=%d: %s\n"),
963 res
, safe_strerror (errno
));
964 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
965 return minus_one_ptid
;
967 if (WIFEXITED (wstatus
))
969 status
->kind
= TARGET_WAITKIND_EXITED
;
970 status
->value
.integer
= WEXITSTATUS (wstatus
);
974 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
975 status
->value
.sig
= WTERMSIG (wstatus
);
978 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
981 /* Looks necessary on Leopard and harmless... */
982 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
984 return ptid_build (inf
->pid
, 0, 0);
988 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
989 status
->kind
= TARGET_WAITKIND_EXITED
;
990 status
->value
.integer
= 0; /* Don't know. */
991 return ptid_build (inf
->pid
, 0, 0);
995 printf_unfiltered (_("Bad local-port: 0x%x\n"), hdr
->msgh_local_port
);
996 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
997 return minus_one_ptid
;
1001 cancel_breakpoint (ptid_t ptid
)
1003 /* Arrange for a breakpoint to be hit again later. We will handle
1004 the current event, eventually we will resume this thread, and this
1005 breakpoint will trap again.
1007 If we do not do this, then we run the risk that the user will
1008 delete or disable the breakpoint, but the thread will have already
1011 struct regcache
*regcache
= get_thread_regcache (ptid
);
1012 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1015 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1016 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
1018 inferior_debug (4, "cancel_breakpoint for thread 0x%x\n",
1019 ptid_get_tid (ptid
));
1021 /* Back up the PC if necessary. */
1022 if (gdbarch_decr_pc_after_break (gdbarch
))
1023 regcache_write_pc (regcache
, pc
);
1031 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1036 mach_msg_header_t hdr
;
1039 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1041 darwin_thread_t
*thread
;
1042 struct inferior
*inf
;
1045 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1046 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1048 /* Handle fake stop events at first. */
1049 if (darwin_inf_fake_stop
!= NULL
)
1051 inf
= darwin_inf_fake_stop
;
1052 darwin_inf_fake_stop
= NULL
;
1054 status
->kind
= TARGET_WAITKIND_STOPPED
;
1055 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1056 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1057 thread
->msg_state
= DARWIN_STOPPED
;
1058 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1063 /* set_sigint_trap (); */
1065 /* Wait for a message. */
1066 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1067 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1069 /* clear_sigint_trap (); */
1071 if (kret
== MACH_RCV_INTERRUPTED
)
1073 status
->kind
= TARGET_WAITKIND_IGNORE
;
1074 return minus_one_ptid
;
1077 if (kret
!= MACH_MSG_SUCCESS
)
1079 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1080 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1081 return minus_one_ptid
;
1084 /* Debug: display message. */
1085 if (darwin_debug_flag
> 10)
1086 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1088 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1093 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1095 /* Stop all tasks. */
1096 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1098 /* Read pending messages. */
1101 struct target_waitstatus status2
;
1104 kret
= mach_msg (&msgin
.hdr
,
1105 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1106 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1108 if (kret
== MACH_RCV_TIMED_OUT
)
1110 if (kret
!= MACH_MSG_SUCCESS
)
1113 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1117 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1119 if (inf
!= NULL
&& thread
!= NULL
1120 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1122 if (thread
->single_step
1123 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1125 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1126 darwin_send_reply (inf
, thread
);
1127 thread
->msg_state
= DARWIN_RUNNING
;
1131 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1135 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1141 darwin_wait_to (struct target_ops
*ops
,
1142 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1144 return darwin_wait (ptid
, status
);
1148 darwin_stop (ptid_t t
)
1150 struct inferior
*inf
= current_inferior ();
1152 /* FIXME: handle in no_ptrace mode. */
1153 gdb_assert (!inf
->private->no_ptrace
);
1154 kill (inf
->pid
, SIGINT
);
1158 darwin_mourn_inferior (struct target_ops
*ops
)
1160 struct inferior
*inf
= current_inferior ();
1165 unpush_target (darwin_ops
);
1167 /* Deallocate threads. */
1168 if (inf
->private->threads
)
1173 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
1176 kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1177 MACH_CHECK_ERROR (kret
);
1179 VEC_free (darwin_thread_t
, inf
->private->threads
);
1180 inf
->private->threads
= NULL
;
1183 kret
= mach_port_move_member (gdb_task
,
1184 inf
->private->notify_port
, MACH_PORT_NULL
);
1185 MACH_CHECK_ERROR (kret
);
1187 kret
= mach_port_request_notification (gdb_task
, inf
->private->task
,
1188 MACH_NOTIFY_DEAD_NAME
, 0,
1190 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1192 /* This can fail if the task is dead. */
1193 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1194 inf
->private->task
, prev
, inf
->private->notify_port
);
1196 if (kret
== KERN_SUCCESS
)
1198 kret
= mach_port_deallocate (gdb_task
, prev
);
1199 MACH_CHECK_ERROR (kret
);
1202 kret
= mach_port_destroy (gdb_task
, inf
->private->notify_port
);
1203 MACH_CHECK_ERROR (kret
);
1206 /* Deallocate saved exception ports. */
1207 for (i
= 0; i
< inf
->private->exception_info
.count
; i
++)
1209 kret
= mach_port_deallocate
1210 (gdb_task
, inf
->private->exception_info
.ports
[i
]);
1211 MACH_CHECK_ERROR (kret
);
1213 inf
->private->exception_info
.count
= 0;
1215 kret
= mach_port_deallocate (gdb_task
, inf
->private->task
);
1216 MACH_CHECK_ERROR (kret
);
1218 xfree (inf
->private);
1219 inf
->private = NULL
;
1221 generic_mourn_inferior ();
1225 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1231 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
1234 if (t
->msg_state
== DARWIN_MESSAGE
)
1235 darwin_resume_thread (inf
, t
, 0, 0);
1240 darwin_stop_inferior (struct inferior
*inf
)
1242 struct target_waitstatus wstatus
;
1248 gdb_assert (inf
!= NULL
);
1250 darwin_suspend_inferior (inf
);
1252 darwin_reply_to_all_pending_messages (inf
);
1254 if (inf
->private->no_ptrace
)
1257 res
= kill (inf
->pid
, SIGSTOP
);
1259 warning (_("cannot kill: %s"), safe_strerror (errno
));
1261 /* Wait until the process is really stopped. */
1264 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1265 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1266 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1271 static kern_return_t
1272 darwin_save_exception_ports (darwin_inferior
*inf
)
1276 inf
->exception_info
.count
=
1277 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1279 kret
= task_get_exception_ports
1280 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1281 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1282 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1286 static kern_return_t
1287 darwin_restore_exception_ports (darwin_inferior
*inf
)
1292 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1294 kret
= task_set_exception_ports
1295 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1296 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1297 if (kret
!= KERN_SUCCESS
)
1301 return KERN_SUCCESS
;
1305 darwin_kill_inferior (struct target_ops
*ops
)
1307 struct inferior
*inf
= current_inferior ();
1308 struct target_waitstatus wstatus
;
1314 if (ptid_equal (inferior_ptid
, null_ptid
))
1317 gdb_assert (inf
!= NULL
);
1319 kret
= darwin_restore_exception_ports (inf
->private);
1320 MACH_CHECK_ERROR (kret
);
1322 darwin_reply_to_all_pending_messages (inf
);
1324 res
= kill (inf
->pid
, 9);
1328 darwin_resume_inferior (inf
);
1330 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1332 else if (errno
!= ESRCH
)
1333 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1334 inf
->pid
, safe_strerror (errno
));
1336 target_mourn_inferior ();
1340 darwin_attach_pid (struct inferior
*inf
)
1343 mach_port_t prev_port
;
1345 mach_port_t prev_not
;
1346 exception_mask_t mask
;
1348 inf
->private = XZALLOC (darwin_inferior
);
1350 kret
= task_for_pid (gdb_task
, inf
->pid
, &inf
->private->task
);
1351 if (kret
!= KERN_SUCCESS
)
1355 if (!inf
->attach_flag
)
1358 waitpid (inf
->pid
, &status
, 0);
1361 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1362 " (please check gdb is codesigned - see taskgated(8))"),
1363 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1366 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1367 inf
->private->task
, inf
->pid
);
1369 if (darwin_ex_port
== MACH_PORT_NULL
)
1371 /* Create a port to get exceptions. */
1372 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1374 if (kret
!= KERN_SUCCESS
)
1375 error (_("Unable to create exception port, mach_port_allocate "
1379 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1380 MACH_MSG_TYPE_MAKE_SEND
);
1381 if (kret
!= KERN_SUCCESS
)
1382 error (_("Unable to create exception port, mach_port_insert_right "
1386 /* Create a port set and put ex_port in it. */
1387 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1389 if (kret
!= KERN_SUCCESS
)
1390 error (_("Unable to create port set, mach_port_allocate "
1394 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1395 if (kret
!= KERN_SUCCESS
)
1396 error (_("Unable to move exception port into new port set, "
1397 "mach_port_move_member\n"
1402 /* Create a port to be notified when the child task terminates. */
1403 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1404 &inf
->private->notify_port
);
1405 if (kret
!= KERN_SUCCESS
)
1406 error (_("Unable to create notification port, mach_port_allocate "
1410 kret
= mach_port_move_member (gdb_task
,
1411 inf
->private->notify_port
, darwin_port_set
);
1412 if (kret
!= KERN_SUCCESS
)
1413 error (_("Unable to move notification port into new port set, "
1414 "mach_port_move_member\n"
1418 kret
= mach_port_request_notification (gdb_task
, inf
->private->task
,
1419 MACH_NOTIFY_DEAD_NAME
, 0,
1420 inf
->private->notify_port
,
1421 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1423 if (kret
!= KERN_SUCCESS
)
1424 error (_("Termination notification request failed, "
1425 "mach_port_request_notification\n"
1428 if (prev_not
!= MACH_PORT_NULL
)
1430 /* This is unexpected, as there should not be any previously
1431 registered notification request. But this is not a fatal
1432 issue, so just emit a warning. */
1434 A task termination request was registered before the debugger registered\n\
1435 its own. This is unexpected, but should otherwise not have any actual\n\
1436 impact on the debugging session."));
1439 kret
= darwin_save_exception_ports (inf
->private);
1440 if (kret
!= KERN_SUCCESS
)
1441 error (_("Unable to save exception ports, task_get_exception_ports"
1445 /* Set exception port. */
1446 if (enable_mach_exceptions
)
1447 mask
= EXC_MASK_ALL
;
1449 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1450 kret
= task_set_exception_ports (inf
->private->task
, mask
, darwin_ex_port
,
1451 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1452 if (kret
!= KERN_SUCCESS
)
1453 error (_("Unable to set exception ports, task_set_exception_ports"
1457 push_target (darwin_ops
);
1461 darwin_init_thread_list (struct inferior
*inf
)
1463 darwin_thread_t
*thread
;
1466 darwin_check_new_threads (inf
);
1468 gdb_assert (inf
->private->threads
1469 && VEC_length (darwin_thread_t
, inf
->private->threads
) > 0);
1470 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1472 /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1474 new_ptid
= ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1475 thread_change_ptid (inferior_ptid
, new_ptid
);
1476 inferior_ptid
= new_ptid
;
1479 /* The child must synchronize with gdb: gdb must set the exception port
1480 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1481 FIXME: is there a lighter way ? */
1482 static int ptrace_fds
[2];
1485 darwin_ptrace_me (void)
1490 /* Close write end point. */
1491 close (ptrace_fds
[1]);
1493 /* Wait until gdb is ready. */
1494 res
= read (ptrace_fds
[0], &c
, 1);
1496 error (_("unable to read from pipe, read returned: %d"), res
);
1497 close (ptrace_fds
[0]);
1499 /* Get rid of privileges. */
1500 setegid (getgid ());
1503 PTRACE (PT_TRACE_ME
, 0, 0, 0);
1505 /* Redirect signals to exception port. */
1506 PTRACE (PT_SIGEXC
, 0, 0, 0);
1509 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1511 darwin_pre_ptrace (void)
1513 if (pipe (ptrace_fds
) != 0)
1517 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1522 darwin_ptrace_him (int pid
)
1526 mach_port_t prev_port
;
1528 struct inferior
*inf
= current_inferior ();
1530 darwin_attach_pid (inf
);
1532 /* Let's the child run. */
1533 close (ptrace_fds
[0]);
1534 close (ptrace_fds
[1]);
1536 darwin_init_thread_list (inf
);
1538 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1542 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1544 posix_spawnattr_t attr
;
1548 res
= posix_spawnattr_init (&attr
);
1552 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1556 /* Do like execve: replace the image. */
1557 ps_flags
= POSIX_SPAWN_SETEXEC
;
1559 /* Disable ASLR. The constant doesn't look to be available outside the
1560 kernel include files. */
1561 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1562 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1564 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1565 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1568 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1572 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1576 darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
1577 char *allargs
, char **env
, int from_tty
)
1579 /* Do the hard work. */
1580 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
, darwin_ptrace_him
,
1581 darwin_pre_ptrace
, NULL
, darwin_execvp
);
1583 /* Return now in case of error. */
1584 if (ptid_equal (inferior_ptid
, null_ptid
))
1589 /* Set things up such that the next call to darwin_wait will immediately
1590 return a fake stop event for inferior INF.
1592 This assumes that the inferior's thread list has been initialized,
1593 as it will suspend the inferior's first thread. */
1596 darwin_setup_fake_stop_event (struct inferior
*inf
)
1598 darwin_thread_t
*thread
;
1601 gdb_assert (darwin_inf_fake_stop
== NULL
);
1602 darwin_inf_fake_stop
= inf
;
1604 /* When detecting a fake pending stop event, darwin_wait returns
1605 an event saying that the first thread is in a DARWIN_STOPPED
1606 state. To make that accurate, we need to suspend that thread
1607 as well. Otherwise, we'll try resuming it when resuming the
1608 inferior, and get a warning because the thread's suspend count
1609 is already zero, making the resume request useless. */
1610 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1611 kret
= thread_suspend (thread
->gdb_port
);
1612 MACH_CHECK_ERROR (kret
);
1615 /* Attach to process PID, then initialize for debugging it
1616 and wait for the trace-trap that results from attaching. */
1618 darwin_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1624 struct inferior
*inf
;
1627 pid
= parse_pid_to_attach (args
);
1629 if (pid
== getpid ()) /* Trying to masturbate? */
1630 error (_("I refuse to debug myself!"));
1634 char *exec_file
= get_exec_file (0);
1637 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1638 target_pid_to_str (pid_to_ptid (pid
)));
1640 printf_unfiltered (_("Attaching to %s\n"),
1641 target_pid_to_str (pid_to_ptid (pid
)));
1643 gdb_flush (gdb_stdout
);
1646 if (pid
== 0 || kill (pid
, 0) < 0)
1647 error (_("Can't attach to process %d: %s (%d)"),
1648 pid
, safe_strerror (errno
), errno
);
1650 inferior_ptid
= pid_to_ptid (pid
);
1651 inf
= current_inferior ();
1652 inferior_appeared (inf
, pid
);
1653 inf
->attach_flag
= 1;
1655 /* Always add a main thread. */
1656 add_thread_silent (inferior_ptid
);
1658 darwin_attach_pid (inf
);
1660 darwin_suspend_inferior (inf
);
1662 darwin_init_thread_list (inf
);
1664 darwin_check_osabi (inf
->private, ptid_get_tid (inferior_ptid
));
1666 darwin_setup_fake_stop_event (inf
);
1668 inf
->private->no_ptrace
= 1;
1671 /* Take a program previously attached to and detaches it.
1672 The program resumes execution and will no longer stop
1673 on signals, etc. We'd better not have left any breakpoints
1674 in the program or it'll die when it hits one. For this
1675 to work, it may be necessary for the process to have been
1676 previously attached. It *might* work if the program was
1677 started via fork. */
1679 darwin_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1681 pid_t pid
= ptid_get_pid (inferior_ptid
);
1682 struct inferior
*inf
= current_inferior ();
1686 /* Display message. */
1689 char *exec_file
= get_exec_file (0);
1692 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
1693 target_pid_to_str (pid_to_ptid (pid
)));
1694 gdb_flush (gdb_stdout
);
1697 /* If ptrace() is in use, stop the process. */
1698 if (!inf
->private->no_ptrace
)
1699 darwin_stop_inferior (inf
);
1701 kret
= darwin_restore_exception_ports (inf
->private);
1702 MACH_CHECK_ERROR (kret
);
1704 if (!inf
->private->no_ptrace
)
1706 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1708 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1709 inf
->pid
, safe_strerror (errno
), errno
);
1712 darwin_reply_to_all_pending_messages (inf
);
1714 /* When using ptrace, we have just performed a PT_DETACH, which
1715 resumes the inferior. On the other hand, when we are not using
1716 ptrace, we need to resume its execution ourselves. */
1717 if (inf
->private->no_ptrace
)
1718 darwin_resume_inferior (inf
);
1720 darwin_mourn_inferior (ops
);
1724 darwin_files_info (struct target_ops
*ops
)
1729 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1731 static char buf
[80];
1732 long tid
= ptid_get_tid (ptid
);
1736 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1737 tid
, ptid_get_pid (ptid
));
1741 return normal_pid_to_str (ptid
);
1745 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1750 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1751 copy it to RDADDR in gdb's address space.
1752 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1753 to ADDR in inferior task's address space.
1754 Return 0 on failure; number of bytes read / writen otherwise. */
1756 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
1757 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
1761 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
1762 mach_vm_address_t low_address
= (mach_vm_address_t
) (addr
- offset
);
1763 mach_vm_size_t aligned_length
= (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
1765 mach_msg_type_number_t copy_count
;
1766 mach_vm_size_t remaining_length
;
1767 mach_vm_address_t region_address
;
1768 mach_vm_size_t region_length
;
1770 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%d)\n"),
1771 task
, core_addr_to_string (addr
), length
);
1773 /* Get memory from inferior with page aligned addresses. */
1774 kret
= mach_vm_read (task
, low_address
, aligned_length
,
1775 &copied
, ©_count
);
1776 if (kret
!= KERN_SUCCESS
)
1779 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1780 core_addr_to_string (addr
), mach_error_string (kret
));
1785 memcpy (rdaddr
, (char *)copied
+ offset
, length
);
1790 memcpy ((char *)copied
+ offset
, wraddr
, length
);
1792 /* Do writes atomically.
1793 First check for holes and unwritable memory. */
1794 for (region_address
= low_address
, remaining_length
= aligned_length
;
1795 region_address
< low_address
+ aligned_length
;
1796 region_address
+= region_length
, remaining_length
-= region_length
)
1798 vm_region_submap_short_info_data_64_t info
;
1799 mach_vm_address_t region_start
= region_address
;
1800 mach_msg_type_number_t count
;
1801 natural_t region_depth
;
1803 region_depth
= 100000;
1804 count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
1805 kret
= mach_vm_region_recurse
1806 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
1807 (vm_region_recurse_info_t
) &info
, &count
);
1809 if (kret
!= KERN_SUCCESS
)
1811 inferior_debug (1, _("darwin_read_write_inferior: "
1812 "mach_vm_region_recurse failed at %s: %s\n"),
1813 core_addr_to_string (region_address
),
1814 mach_error_string (kret
));
1819 (9, _("darwin_read_write_inferior: "
1820 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1821 core_addr_to_string (region_address
),
1822 core_addr_to_string (region_start
),
1823 core_addr_to_string (region_length
));
1825 /* Check for holes in memory. */
1826 if (region_start
> region_address
)
1828 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1829 core_addr_to_string (region_address
),
1830 core_addr_to_string (region_start
),
1831 (unsigned)region_length
);
1836 /* Adjust the length. */
1837 region_length
-= (region_address
- region_start
);
1839 if (!(info
.max_protection
& VM_PROT_WRITE
))
1841 kret
= mach_vm_protect
1842 (task
, region_address
, region_length
,
1843 TRUE
, info
.max_protection
| VM_PROT_WRITE
| VM_PROT_COPY
);
1844 if (kret
!= KERN_SUCCESS
)
1846 warning (_("darwin_read_write_inf: "
1847 "mach_vm_protect max failed at %s: %s"),
1848 core_addr_to_string (region_address
),
1849 mach_error_string (kret
));
1855 if (!(info
.protection
& VM_PROT_WRITE
))
1857 kret
= mach_vm_protect (task
, region_address
, region_length
,
1858 FALSE
, info
.protection
| VM_PROT_WRITE
);
1859 if (kret
!= KERN_SUCCESS
)
1861 warning (_("darwin_read_write_inf: "
1862 "mach_vm_protect failed at %s (len=0x%lx): %s"),
1863 core_addr_to_string (region_address
),
1864 (unsigned long)region_length
, mach_error_string (kret
));
1871 kret
= mach_vm_write (task
, low_address
, copied
, aligned_length
);
1873 if (kret
!= KERN_SUCCESS
)
1875 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1876 mach_error_string (kret
));
1880 mach_vm_deallocate (mach_task_self (), copied
, copy_count
);
1884 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1886 Return 0 on failure; number of bytes read / written otherwise. */
1888 #ifdef TASK_DYLD_INFO_COUNT
1889 /* This is not available in Darwin 9. */
1891 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
1894 struct task_dyld_info task_dyld_info
;
1895 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
1896 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
1902 kret
= task_info (task
, TASK_DYLD_INFO
, (task_info_t
) &task_dyld_info
, &count
);
1903 MACH_CHECK_ERROR (kret
);
1904 if (kret
!= KERN_SUCCESS
)
1907 if (addr
+ length
> sz
)
1909 memcpy (rdaddr
, (char *)&task_dyld_info
+ addr
, length
);
1915 /* Return 0 on failure, number of bytes handled otherwise. TARGET
1918 darwin_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1919 struct mem_attrib
*attrib
, struct target_ops
*target
)
1921 struct inferior
*inf
= current_inferior ();
1922 task_t task
= inf
->private->task
;
1924 if (task
== MACH_PORT_NULL
)
1927 inferior_debug (8, _("darwin_xfer_memory(%s, %d, %c)\n"),
1928 core_addr_to_string (memaddr
), len
, write
? 'w' : 'r');
1931 return darwin_read_write_inferior (task
, memaddr
, NULL
, myaddr
, len
);
1933 return darwin_read_write_inferior (task
, memaddr
, myaddr
, NULL
, len
);
1937 darwin_xfer_partial (struct target_ops
*ops
,
1938 enum target_object object
, const char *annex
,
1939 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1940 ULONGEST offset
, LONGEST len
)
1942 struct inferior
*inf
= current_inferior ();
1945 (8, _("darwin_xfer_partial(%s, %d, rbuf=%s, wbuf=%s) pid=%u\n"),
1946 core_addr_to_string (offset
), (int)len
,
1947 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
1952 case TARGET_OBJECT_MEMORY
:
1953 return darwin_read_write_inferior (inf
->private->task
, offset
,
1954 readbuf
, writebuf
, len
);
1955 #ifdef TASK_DYLD_INFO_COUNT
1956 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
1957 if (writebuf
!= NULL
|| readbuf
== NULL
)
1959 /* Support only read. */
1962 return darwin_read_dyld_info (inf
->private->task
, offset
, readbuf
, len
);
1971 set_enable_mach_exceptions (char *args
, int from_tty
,
1972 struct cmd_list_element
*c
)
1974 if (!ptid_equal (inferior_ptid
, null_ptid
))
1976 struct inferior
*inf
= current_inferior ();
1977 exception_mask_t mask
;
1980 if (enable_mach_exceptions
)
1981 mask
= EXC_MASK_ALL
;
1984 darwin_restore_exception_ports (inf
->private);
1985 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1987 kret
= task_set_exception_ports (inf
->private->task
, mask
, darwin_ex_port
,
1988 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1989 MACH_CHECK_ERROR (kret
);
1994 darwin_pid_to_exec_file (int pid
)
1999 path
= xmalloc (MAXPATHLEN
);
2000 make_cleanup (xfree
, path
);
2002 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, MAXPATHLEN
);
2010 darwin_get_ada_task_ptid (long lwp
, long thread
)
2015 struct inferior
*inf
= current_inferior ();
2017 mach_port_name_array_t names
;
2018 mach_msg_type_number_t names_count
;
2019 mach_port_type_array_t types
;
2020 mach_msg_type_number_t types_count
;
2023 /* First linear search. */
2025 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2027 if (t
->inf_port
== lwp
)
2028 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2030 /* Maybe the port was never extract. Do it now. */
2032 /* First get inferior port names. */
2033 kret
= mach_port_names (inf
->private->task
, &names
, &names_count
, &types
,
2035 MACH_CHECK_ERROR (kret
);
2036 if (kret
!= KERN_SUCCESS
)
2039 /* For each name, copy the right in the gdb space and then compare with
2040 our view of the inferior threads. We don't forget to deallocate the
2042 for (i
= 0; i
< names_count
; i
++)
2044 mach_port_t local_name
;
2045 mach_msg_type_name_t local_type
;
2047 /* We just need to know the corresponding name in gdb name space.
2048 So extract and deallocate the right. */
2049 kret
= mach_port_extract_right (inf
->private->task
, names
[i
],
2050 MACH_MSG_TYPE_COPY_SEND
,
2051 &local_name
, &local_type
);
2052 if (kret
!= KERN_SUCCESS
)
2054 mach_port_deallocate (gdb_task
, local_name
);
2057 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2059 if (t
->gdb_port
== local_name
)
2061 t
->inf_port
= names
[i
];
2062 if (names
[i
] == lwp
)
2067 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2068 names_count
* sizeof (mach_port_t
));
2071 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2077 darwin_supports_multi_process (void)
2082 /* -Wmissing-prototypes */
2083 extern initialize_file_ftype _initialize_darwin_inferior
;
2086 _initialize_darwin_inferior (void)
2090 gdb_task
= mach_task_self ();
2091 darwin_host_self
= mach_host_self ();
2093 /* Read page size. */
2094 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2095 if (kret
!= KERN_SUCCESS
)
2097 mach_page_size
= 0x1000;
2098 MACH_CHECK_ERROR (kret
);
2101 darwin_ops
= inf_child_target ();
2103 darwin_ops
->to_shortname
= "darwin-child";
2104 darwin_ops
->to_longname
= _("Darwin child process");
2105 darwin_ops
->to_doc
=
2106 _("Darwin child process (started by the \"run\" command).");
2107 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2108 darwin_ops
->to_attach
= darwin_attach
;
2109 darwin_ops
->to_attach_no_wait
= 0;
2110 darwin_ops
->to_detach
= darwin_detach
;
2111 darwin_ops
->to_files_info
= darwin_files_info
;
2112 darwin_ops
->to_wait
= darwin_wait_to
;
2113 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2114 darwin_ops
->to_kill
= darwin_kill_inferior
;
2115 darwin_ops
->to_stop
= darwin_stop
;
2116 darwin_ops
->to_resume
= darwin_resume_to
;
2117 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2118 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2119 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2120 darwin_ops
->to_load
= NULL
;
2121 darwin_ops
->deprecated_xfer_memory
= darwin_xfer_memory
;
2122 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2123 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2124 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2126 darwin_complete_target (darwin_ops
);
2128 add_target (darwin_ops
);
2130 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
2133 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2134 &darwin_debug_flag
, _("\
2135 Set if printing inferior communication debugging statements."), _("\
2136 Show if printing inferior communication debugging statements."), NULL
,
2138 &setdebuglist
, &showdebuglist
);
2140 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2141 &enable_mach_exceptions
, _("\
2142 Set if mach exceptions are caught."), _("\
2143 Show if mach exceptions are caught."), _("\
2144 When this mode is on, all low level exceptions are reported before being\n\
2145 reported by the kernel."),
2146 &set_enable_mach_exceptions
, NULL
,
2147 &setlist
, &showlist
);