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/>. */
31 #include "gdbthread.h"
33 #include "event-top.h"
36 #include "exceptions.h"
37 #include "inf-child.h"
39 #include "arch-utils.h"
41 #include "bfd/mach-o.h"
43 #include <sys/ptrace.h>
44 #include <sys/signal.h>
45 #include <machine/setjmp.h>
46 #include <sys/types.h>
51 #include <sys/param.h>
52 #include <sys/sysctl.h>
55 #include <sys/syscall.h>
58 #include <mach/mach_error.h>
59 #include <mach/mach_vm.h>
60 #include <mach/mach_init.h>
61 #include <mach/vm_map.h>
62 #include <mach/task.h>
63 #include <mach/mach_port.h>
64 #include <mach/thread_act.h>
65 #include <mach/port.h>
67 #include "darwin-nat.h"
68 #include "common/filestuff.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
));
1520 mark_fd_no_cloexec (ptrace_fds
[0]);
1521 mark_fd_no_cloexec (ptrace_fds
[1]);
1525 darwin_ptrace_him (int pid
)
1529 mach_port_t prev_port
;
1531 struct inferior
*inf
= current_inferior ();
1533 darwin_attach_pid (inf
);
1535 /* Let's the child run. */
1536 close (ptrace_fds
[0]);
1537 close (ptrace_fds
[1]);
1539 unmark_fd_no_cloexec (ptrace_fds
[0]);
1540 unmark_fd_no_cloexec (ptrace_fds
[1]);
1542 darwin_init_thread_list (inf
);
1544 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1548 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1550 posix_spawnattr_t attr
;
1554 res
= posix_spawnattr_init (&attr
);
1558 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1562 /* Do like execve: replace the image. */
1563 ps_flags
= POSIX_SPAWN_SETEXEC
;
1565 /* Disable ASLR. The constant doesn't look to be available outside the
1566 kernel include files. */
1567 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1568 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1570 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1571 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1574 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1578 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1582 darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
1583 char *allargs
, char **env
, int from_tty
)
1585 /* Do the hard work. */
1586 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
, darwin_ptrace_him
,
1587 darwin_pre_ptrace
, NULL
, darwin_execvp
);
1589 /* Return now in case of error. */
1590 if (ptid_equal (inferior_ptid
, null_ptid
))
1595 /* Set things up such that the next call to darwin_wait will immediately
1596 return a fake stop event for inferior INF.
1598 This assumes that the inferior's thread list has been initialized,
1599 as it will suspend the inferior's first thread. */
1602 darwin_setup_fake_stop_event (struct inferior
*inf
)
1604 darwin_thread_t
*thread
;
1607 gdb_assert (darwin_inf_fake_stop
== NULL
);
1608 darwin_inf_fake_stop
= inf
;
1610 /* When detecting a fake pending stop event, darwin_wait returns
1611 an event saying that the first thread is in a DARWIN_STOPPED
1612 state. To make that accurate, we need to suspend that thread
1613 as well. Otherwise, we'll try resuming it when resuming the
1614 inferior, and get a warning because the thread's suspend count
1615 is already zero, making the resume request useless. */
1616 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1617 kret
= thread_suspend (thread
->gdb_port
);
1618 MACH_CHECK_ERROR (kret
);
1621 /* Attach to process PID, then initialize for debugging it
1622 and wait for the trace-trap that results from attaching. */
1624 darwin_attach (struct target_ops
*ops
, char *args
, int from_tty
)
1630 struct inferior
*inf
;
1633 pid
= parse_pid_to_attach (args
);
1635 if (pid
== getpid ()) /* Trying to masturbate? */
1636 error (_("I refuse to debug myself!"));
1640 char *exec_file
= get_exec_file (0);
1643 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1644 target_pid_to_str (pid_to_ptid (pid
)));
1646 printf_unfiltered (_("Attaching to %s\n"),
1647 target_pid_to_str (pid_to_ptid (pid
)));
1649 gdb_flush (gdb_stdout
);
1652 if (pid
== 0 || kill (pid
, 0) < 0)
1653 error (_("Can't attach to process %d: %s (%d)"),
1654 pid
, safe_strerror (errno
), errno
);
1656 inferior_ptid
= pid_to_ptid (pid
);
1657 inf
= current_inferior ();
1658 inferior_appeared (inf
, pid
);
1659 inf
->attach_flag
= 1;
1661 /* Always add a main thread. */
1662 add_thread_silent (inferior_ptid
);
1664 darwin_attach_pid (inf
);
1666 darwin_suspend_inferior (inf
);
1668 darwin_init_thread_list (inf
);
1670 darwin_check_osabi (inf
->private, ptid_get_tid (inferior_ptid
));
1672 darwin_setup_fake_stop_event (inf
);
1674 inf
->private->no_ptrace
= 1;
1677 /* Take a program previously attached to and detaches it.
1678 The program resumes execution and will no longer stop
1679 on signals, etc. We'd better not have left any breakpoints
1680 in the program or it'll die when it hits one. For this
1681 to work, it may be necessary for the process to have been
1682 previously attached. It *might* work if the program was
1683 started via fork. */
1685 darwin_detach (struct target_ops
*ops
, char *args
, int from_tty
)
1687 pid_t pid
= ptid_get_pid (inferior_ptid
);
1688 struct inferior
*inf
= current_inferior ();
1692 /* Display message. */
1695 char *exec_file
= get_exec_file (0);
1698 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
1699 target_pid_to_str (pid_to_ptid (pid
)));
1700 gdb_flush (gdb_stdout
);
1703 /* If ptrace() is in use, stop the process. */
1704 if (!inf
->private->no_ptrace
)
1705 darwin_stop_inferior (inf
);
1707 kret
= darwin_restore_exception_ports (inf
->private);
1708 MACH_CHECK_ERROR (kret
);
1710 if (!inf
->private->no_ptrace
)
1712 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1714 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1715 inf
->pid
, safe_strerror (errno
), errno
);
1718 darwin_reply_to_all_pending_messages (inf
);
1720 /* When using ptrace, we have just performed a PT_DETACH, which
1721 resumes the inferior. On the other hand, when we are not using
1722 ptrace, we need to resume its execution ourselves. */
1723 if (inf
->private->no_ptrace
)
1724 darwin_resume_inferior (inf
);
1726 darwin_mourn_inferior (ops
);
1730 darwin_files_info (struct target_ops
*ops
)
1735 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1737 static char buf
[80];
1738 long tid
= ptid_get_tid (ptid
);
1742 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1743 tid
, ptid_get_pid (ptid
));
1747 return normal_pid_to_str (ptid
);
1751 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1756 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1757 copy it to RDADDR in gdb's address space.
1758 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1759 to ADDR in inferior task's address space.
1760 Return 0 on failure; number of bytes read / writen otherwise. */
1762 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
1763 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
1767 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
1768 mach_vm_address_t low_address
= (mach_vm_address_t
) (addr
- offset
);
1769 mach_vm_size_t aligned_length
= (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
1771 mach_msg_type_number_t copy_count
;
1772 mach_vm_size_t remaining_length
;
1773 mach_vm_address_t region_address
;
1774 mach_vm_size_t region_length
;
1776 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%d)\n"),
1777 task
, core_addr_to_string (addr
), length
);
1779 /* Get memory from inferior with page aligned addresses. */
1780 kret
= mach_vm_read (task
, low_address
, aligned_length
,
1781 &copied
, ©_count
);
1782 if (kret
!= KERN_SUCCESS
)
1785 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1786 core_addr_to_string (addr
), mach_error_string (kret
));
1791 memcpy (rdaddr
, (char *)copied
+ offset
, length
);
1796 memcpy ((char *)copied
+ offset
, wraddr
, length
);
1798 /* Do writes atomically.
1799 First check for holes and unwritable memory. */
1800 for (region_address
= low_address
, remaining_length
= aligned_length
;
1801 region_address
< low_address
+ aligned_length
;
1802 region_address
+= region_length
, remaining_length
-= region_length
)
1804 vm_region_submap_short_info_data_64_t info
;
1805 mach_vm_address_t region_start
= region_address
;
1806 mach_msg_type_number_t count
;
1807 natural_t region_depth
;
1809 region_depth
= 100000;
1810 count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
1811 kret
= mach_vm_region_recurse
1812 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
1813 (vm_region_recurse_info_t
) &info
, &count
);
1815 if (kret
!= KERN_SUCCESS
)
1817 inferior_debug (1, _("darwin_read_write_inferior: "
1818 "mach_vm_region_recurse failed at %s: %s\n"),
1819 core_addr_to_string (region_address
),
1820 mach_error_string (kret
));
1825 (9, _("darwin_read_write_inferior: "
1826 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1827 core_addr_to_string (region_address
),
1828 core_addr_to_string (region_start
),
1829 core_addr_to_string (region_length
));
1831 /* Check for holes in memory. */
1832 if (region_start
> region_address
)
1834 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1835 core_addr_to_string (region_address
),
1836 core_addr_to_string (region_start
),
1837 (unsigned)region_length
);
1842 /* Adjust the length. */
1843 region_length
-= (region_address
- region_start
);
1845 if (!(info
.max_protection
& VM_PROT_WRITE
))
1847 kret
= mach_vm_protect
1848 (task
, region_address
, region_length
,
1849 TRUE
, info
.max_protection
| VM_PROT_WRITE
| VM_PROT_COPY
);
1850 if (kret
!= KERN_SUCCESS
)
1852 warning (_("darwin_read_write_inf: "
1853 "mach_vm_protect max failed at %s: %s"),
1854 core_addr_to_string (region_address
),
1855 mach_error_string (kret
));
1861 if (!(info
.protection
& VM_PROT_WRITE
))
1863 kret
= mach_vm_protect (task
, region_address
, region_length
,
1864 FALSE
, info
.protection
| VM_PROT_WRITE
);
1865 if (kret
!= KERN_SUCCESS
)
1867 warning (_("darwin_read_write_inf: "
1868 "mach_vm_protect failed at %s (len=0x%lx): %s"),
1869 core_addr_to_string (region_address
),
1870 (unsigned long)region_length
, mach_error_string (kret
));
1877 kret
= mach_vm_write (task
, low_address
, copied
, aligned_length
);
1879 if (kret
!= KERN_SUCCESS
)
1881 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1882 mach_error_string (kret
));
1886 mach_vm_deallocate (mach_task_self (), copied
, copy_count
);
1890 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1892 Return 0 on failure; number of bytes read / written otherwise. */
1894 #ifdef TASK_DYLD_INFO_COUNT
1895 /* This is not available in Darwin 9. */
1897 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
1900 struct task_dyld_info task_dyld_info
;
1901 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
1902 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
1908 kret
= task_info (task
, TASK_DYLD_INFO
, (task_info_t
) &task_dyld_info
, &count
);
1909 MACH_CHECK_ERROR (kret
);
1910 if (kret
!= KERN_SUCCESS
)
1913 if (addr
+ length
> sz
)
1915 memcpy (rdaddr
, (char *)&task_dyld_info
+ addr
, length
);
1921 /* Return 0 on failure, number of bytes handled otherwise. TARGET
1924 darwin_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1925 struct mem_attrib
*attrib
, struct target_ops
*target
)
1927 struct inferior
*inf
= current_inferior ();
1928 task_t task
= inf
->private->task
;
1930 if (task
== MACH_PORT_NULL
)
1933 inferior_debug (8, _("darwin_xfer_memory(%s, %d, %c)\n"),
1934 core_addr_to_string (memaddr
), len
, write
? 'w' : 'r');
1937 return darwin_read_write_inferior (task
, memaddr
, NULL
, myaddr
, len
);
1939 return darwin_read_write_inferior (task
, memaddr
, myaddr
, NULL
, len
);
1943 darwin_xfer_partial (struct target_ops
*ops
,
1944 enum target_object object
, const char *annex
,
1945 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1946 ULONGEST offset
, LONGEST len
)
1948 struct inferior
*inf
= current_inferior ();
1951 (8, _("darwin_xfer_partial(%s, %d, rbuf=%s, wbuf=%s) pid=%u\n"),
1952 core_addr_to_string (offset
), (int)len
,
1953 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
1958 case TARGET_OBJECT_MEMORY
:
1959 return darwin_read_write_inferior (inf
->private->task
, offset
,
1960 readbuf
, writebuf
, len
);
1961 #ifdef TASK_DYLD_INFO_COUNT
1962 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
1963 if (writebuf
!= NULL
|| readbuf
== NULL
)
1965 /* Support only read. */
1968 return darwin_read_dyld_info (inf
->private->task
, offset
, readbuf
, len
);
1977 set_enable_mach_exceptions (char *args
, int from_tty
,
1978 struct cmd_list_element
*c
)
1980 if (!ptid_equal (inferior_ptid
, null_ptid
))
1982 struct inferior
*inf
= current_inferior ();
1983 exception_mask_t mask
;
1986 if (enable_mach_exceptions
)
1987 mask
= EXC_MASK_ALL
;
1990 darwin_restore_exception_ports (inf
->private);
1991 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1993 kret
= task_set_exception_ports (inf
->private->task
, mask
, darwin_ex_port
,
1994 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1995 MACH_CHECK_ERROR (kret
);
2000 darwin_pid_to_exec_file (int pid
)
2005 path
= xmalloc (MAXPATHLEN
);
2006 make_cleanup (xfree
, path
);
2008 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, MAXPATHLEN
);
2016 darwin_get_ada_task_ptid (long lwp
, long thread
)
2021 struct inferior
*inf
= current_inferior ();
2023 mach_port_name_array_t names
;
2024 mach_msg_type_number_t names_count
;
2025 mach_port_type_array_t types
;
2026 mach_msg_type_number_t types_count
;
2029 /* First linear search. */
2031 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2033 if (t
->inf_port
== lwp
)
2034 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2036 /* Maybe the port was never extract. Do it now. */
2038 /* First get inferior port names. */
2039 kret
= mach_port_names (inf
->private->task
, &names
, &names_count
, &types
,
2041 MACH_CHECK_ERROR (kret
);
2042 if (kret
!= KERN_SUCCESS
)
2045 /* For each name, copy the right in the gdb space and then compare with
2046 our view of the inferior threads. We don't forget to deallocate the
2048 for (i
= 0; i
< names_count
; i
++)
2050 mach_port_t local_name
;
2051 mach_msg_type_name_t local_type
;
2053 /* We just need to know the corresponding name in gdb name space.
2054 So extract and deallocate the right. */
2055 kret
= mach_port_extract_right (inf
->private->task
, names
[i
],
2056 MACH_MSG_TYPE_COPY_SEND
,
2057 &local_name
, &local_type
);
2058 if (kret
!= KERN_SUCCESS
)
2060 mach_port_deallocate (gdb_task
, local_name
);
2063 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2065 if (t
->gdb_port
== local_name
)
2067 t
->inf_port
= names
[i
];
2068 if (names
[i
] == lwp
)
2073 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2074 names_count
* sizeof (mach_port_t
));
2077 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2083 darwin_supports_multi_process (void)
2088 /* -Wmissing-prototypes */
2089 extern initialize_file_ftype _initialize_darwin_inferior
;
2092 _initialize_darwin_inferior (void)
2096 gdb_task
= mach_task_self ();
2097 darwin_host_self
= mach_host_self ();
2099 /* Read page size. */
2100 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2101 if (kret
!= KERN_SUCCESS
)
2103 mach_page_size
= 0x1000;
2104 MACH_CHECK_ERROR (kret
);
2107 darwin_ops
= inf_child_target ();
2109 darwin_ops
->to_shortname
= "darwin-child";
2110 darwin_ops
->to_longname
= _("Darwin child process");
2111 darwin_ops
->to_doc
=
2112 _("Darwin child process (started by the \"run\" command).");
2113 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2114 darwin_ops
->to_attach
= darwin_attach
;
2115 darwin_ops
->to_attach_no_wait
= 0;
2116 darwin_ops
->to_detach
= darwin_detach
;
2117 darwin_ops
->to_files_info
= darwin_files_info
;
2118 darwin_ops
->to_wait
= darwin_wait_to
;
2119 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2120 darwin_ops
->to_kill
= darwin_kill_inferior
;
2121 darwin_ops
->to_stop
= darwin_stop
;
2122 darwin_ops
->to_resume
= darwin_resume_to
;
2123 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2124 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2125 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2126 darwin_ops
->to_load
= NULL
;
2127 darwin_ops
->deprecated_xfer_memory
= darwin_xfer_memory
;
2128 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2129 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2130 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2132 darwin_complete_target (darwin_ops
);
2134 add_target (darwin_ops
);
2136 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
2139 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2140 &darwin_debug_flag
, _("\
2141 Set if printing inferior communication debugging statements."), _("\
2142 Show if printing inferior communication debugging statements."), NULL
,
2144 &setdebuglist
, &showdebuglist
);
2146 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2147 &enable_mach_exceptions
, _("\
2148 Set if mach exceptions are caught."), _("\
2149 Show if mach exceptions are caught."), _("\
2150 When this mode is on, all low level exceptions are reported before being\n\
2151 reported by the kernel."),
2152 &set_enable_mach_exceptions
, NULL
,
2153 &setlist
, &showlist
);