1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2018 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
41 #include <sys/ptrace.h>
42 #include <sys/signal.h>
44 #include <sys/types.h>
48 #include <sys/sysctl.h>
51 #include <sys/syscall.h>
54 #include <mach/mach_error.h>
55 #include <mach/mach_vm.h>
56 #include <mach/mach_init.h>
57 #include <mach/vm_map.h>
58 #include <mach/task.h>
59 #include <mach/mach_port.h>
60 #include <mach/thread_act.h>
61 #include <mach/port.h>
63 #include "darwin-nat.h"
64 #include "common/filestuff.h"
65 #include "nat/fork-inferior.h"
68 Darwin kernel is Mach + BSD derived kernel. Note that they share the
69 same memory space and are linked together (ie there is no micro-kernel).
71 Although ptrace(2) is available on Darwin, it is not complete. We have
72 to use Mach calls to read and write memory and to modify registers. We
73 also use Mach to get inferior faults. As we cannot use select(2) or
74 signals with Mach port (the Mach communication channel), signals are
75 reported to gdb as an exception. Furthermore we detect death of the
76 inferior through a Mach notification message. This way we only wait
79 Some Mach documentation is available for Apple xnu source package or
83 #define PTRACE(CMD, PID, ADDR, SIG) \
84 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
86 static ptid_t
darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
);
88 static void darwin_ptrace_me (void);
90 static void darwin_ptrace_him (int pid
);
92 static void darwin_encode_reply (mig_reply_error_t
*reply
,
93 mach_msg_header_t
*hdr
, integer_t code
);
95 static void darwin_setup_request_notification (struct inferior
*inf
);
96 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
97 static void darwin_setup_exceptions (struct inferior
*inf
);
98 static void darwin_deallocate_threads (struct inferior
*inf
);
100 /* Task identifier of gdb. */
101 static task_t gdb_task
;
103 /* A copy of mach_host_self (). */
104 mach_port_t darwin_host_self
;
106 /* Exception port. */
107 mach_port_t darwin_ex_port
;
109 /* Port set, to wait for answer on all ports. */
110 mach_port_t darwin_port_set
;
113 static vm_size_t mach_page_size
;
115 /* If Set, catch all mach exceptions (before they are converted to signals
117 static int enable_mach_exceptions
;
119 /* Inferior that should report a fake stop event. */
120 static struct inferior
*darwin_inf_fake_stop
;
122 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
123 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
125 /* This controls output of inferior debugging. */
126 static unsigned int darwin_debug_flag
= 0;
128 /* Create a __TEXT __info_plist section in the executable so that gdb could
129 be signed. This is required to get an authorization for task_for_pid.
131 Once gdb is built, you must codesign it with any system-trusted signing
132 authority. See taskgated(8) for details. */
133 static const unsigned char info_plist
[]
134 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
135 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
136 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
137 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
138 "<plist version=\"1.0\">\n"
140 " <key>CFBundleIdentifier</key>\n"
141 " <string>org.gnu.gdb</string>\n"
142 " <key>CFBundleName</key>\n"
143 " <string>gdb</string>\n"
144 " <key>CFBundleVersion</key>\n"
145 " <string>1.0</string>\n"
146 " <key>SecTaskAccess</key>\n"
148 " <string>allowed</string>\n"
149 " <string>debug</string>\n"
154 static void inferior_debug (int level
, const char *fmt
, ...)
155 ATTRIBUTE_PRINTF (2, 3);
158 inferior_debug (int level
, const char *fmt
, ...)
162 if (darwin_debug_flag
< level
)
166 printf_unfiltered (_("[%d inferior]: "), getpid ());
167 vprintf_unfiltered (fmt
, ap
);
172 mach_check_error (kern_return_t ret
, const char *file
,
173 unsigned int line
, const char *func
)
175 if (ret
== KERN_SUCCESS
)
178 func
= _("[UNKNOWN]");
180 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
181 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
185 unparse_exception_type (unsigned int i
)
187 static char unknown_exception_buf
[32];
192 return "EXC_BAD_ACCESS";
193 case EXC_BAD_INSTRUCTION
:
194 return "EXC_BAD_INSTRUCTION";
196 return "EXC_ARITHMETIC";
198 return "EXC_EMULATION";
200 return "EXC_SOFTWARE";
202 return "EXC_BREAKPOINT";
204 return "EXC_SYSCALL";
205 case EXC_MACH_SYSCALL
:
206 return "EXC_MACH_SYSCALL";
208 return "EXC_RPC_ALERT";
212 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
213 return unknown_exception_buf
;
217 /* Set errno to zero, and then call ptrace with the given arguments.
218 If inferior debugging traces are on, then also print a debug
221 The returned value is the same as the value returned by ptrace,
222 except in the case where that value is -1 but errno is zero.
223 This case is documented to be a non-error situation, so we
224 return zero in that case. */
227 darwin_ptrace (const char *name
,
228 int request
, int pid
, caddr_t arg3
, int arg4
)
233 ret
= ptrace (request
, pid
, arg3
, arg4
);
234 if (ret
== -1 && errno
== 0)
237 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
238 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
239 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
244 cmp_thread_t (const void *l
, const void *r
)
246 thread_t tl
= *(const thread_t
*)l
;
247 thread_t tr
= *(const thread_t
*)r
;
248 return (int)(tl
- tr
);
252 darwin_check_new_threads (struct inferior
*inf
)
255 thread_array_t thread_list
;
256 unsigned int new_nbr
;
257 unsigned int old_nbr
;
258 unsigned int new_ix
, old_ix
;
259 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
260 std::vector
<darwin_thread_t
*> new_thread_vec
;
262 if (darwin_inf
== nullptr)
265 /* Get list of threads. */
266 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
267 MACH_CHECK_ERROR (kret
);
268 if (kret
!= KERN_SUCCESS
)
273 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
275 old_nbr
= darwin_inf
->threads
.size ();
277 /* Quick check for no changes. */
278 if (old_nbr
== new_nbr
)
282 for (i
= 0; i
< new_nbr
; i
++)
283 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
287 /* Deallocate ports. */
288 for (i
= 0; i
< new_nbr
; i
++)
290 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
291 MACH_CHECK_ERROR (kret
);
294 /* Deallocate the buffer. */
295 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
296 new_nbr
* sizeof (int));
297 MACH_CHECK_ERROR (kret
);
303 /* Full handling: detect new threads, remove dead threads. */
305 new_thread_vec
.reserve (new_nbr
);
307 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
309 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
311 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
312 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
315 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
316 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
318 if (old_id
== new_id
)
320 /* Thread still exist. */
321 new_thread_vec
.push_back (old
);
325 /* Deallocate the port. */
326 kret
= mach_port_deallocate (gdb_task
, new_id
);
327 MACH_CHECK_ERROR (kret
);
331 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
333 /* Ignore dead ports.
334 In some weird cases, we might get dead ports. They should
335 correspond to dead thread so they could safely be ignored. */
339 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
341 /* A thread was created. */
342 darwin_thread_info
*pti
= new darwin_thread_info
;
344 pti
->gdb_port
= new_id
;
345 pti
->msg_state
= DARWIN_RUNNING
;
347 /* Add the new thread. */
348 add_thread_with_info (ptid_t (inf
->pid
, 0, new_id
), pti
);
349 new_thread_vec
.push_back (pti
);
353 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
355 /* A thread was removed. */
356 struct thread_info
*thr
357 = find_thread_ptid (ptid_t (inf
->pid
, 0, old_id
));
359 kret
= mach_port_deallocate (gdb_task
, old_id
);
360 MACH_CHECK_ERROR (kret
);
364 gdb_assert_not_reached ("unexpected thread case");
367 darwin_inf
->threads
= std::move (new_thread_vec
);
369 /* Deallocate the buffer. */
370 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
371 new_nbr
* sizeof (int));
372 MACH_CHECK_ERROR (kret
);
376 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
378 darwin_inferior
*priv
= get_darwin_inferior (inf
);
380 return priv
!= nullptr && priv
->task
== *(task_t
*)port_ptr
;
384 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
386 return inf
->pid
== *(int *)pid_ptr
;
389 /* Return an inferior by task port. */
390 static struct inferior
*
391 darwin_find_inferior_by_task (task_t port
)
393 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
396 /* Return an inferior by pid port. */
397 static struct inferior
*
398 darwin_find_inferior_by_pid (int pid
)
400 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
403 /* Return a thread by port. */
404 static darwin_thread_t
*
405 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
407 darwin_inferior
*priv
= get_darwin_inferior (inf
);
410 for (darwin_thread_t
*t
: priv
->threads
)
412 if (t
->gdb_port
== thread
)
419 /* Suspend (ie stop) an inferior at Mach level. */
422 darwin_suspend_inferior (struct inferior
*inf
)
424 darwin_inferior
*priv
= get_darwin_inferior (inf
);
426 if (priv
!= nullptr && !priv
->suspended
)
430 kret
= task_suspend (priv
->task
);
431 MACH_CHECK_ERROR (kret
);
437 /* Resume an inferior at Mach level. */
440 darwin_resume_inferior (struct inferior
*inf
)
442 darwin_inferior
*priv
= get_darwin_inferior (inf
);
444 if (priv
!= nullptr && priv
->suspended
)
448 kret
= task_resume (priv
->task
);
449 MACH_CHECK_ERROR (kret
);
455 /* Iterator functions. */
458 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
460 darwin_suspend_inferior (inf
);
461 darwin_check_new_threads (inf
);
466 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
468 darwin_resume_inferior (inf
);
473 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
475 printf_unfiltered (_("message header:\n"));
476 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
477 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
478 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
479 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
480 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
481 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
485 const unsigned char *data
;
486 const unsigned int *ldata
;
490 data
= (unsigned char *)(hdr
+ 1);
491 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
493 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
495 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
496 mach_msg_port_descriptor_t
*desc
=
497 (mach_msg_port_descriptor_t
*)(bod
+ 1);
500 printf_unfiltered (_("body: descriptor_count=%u\n"),
501 bod
->msgh_descriptor_count
);
502 data
+= sizeof (mach_msg_body_t
);
503 size
-= sizeof (mach_msg_body_t
);
504 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
505 switch (desc
[k
].type
)
507 case MACH_MSG_PORT_DESCRIPTOR
:
509 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
510 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
513 printf_unfiltered (_(" descr %d: type=%u\n"),
517 data
+= bod
->msgh_descriptor_count
518 * sizeof (mach_msg_port_descriptor_t
);
519 size
-= bod
->msgh_descriptor_count
520 * sizeof (mach_msg_port_descriptor_t
);
521 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
523 (_("NDR: mig=%02x if=%02x encod=%02x "
524 "int=%02x char=%02x float=%02x\n"),
525 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
526 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
527 data
+= sizeof (NDR_record_t
);
528 size
-= sizeof (NDR_record_t
);
531 printf_unfiltered (_(" data:"));
532 ldata
= (const unsigned int *)data
;
533 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
534 printf_unfiltered (" %08x", ldata
[i
]);
535 printf_unfiltered (_("\n"));
539 /* Adjust inferior data when a new task was created. */
541 static struct inferior
*
542 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
545 struct inferior
*inf
;
549 /* Find the corresponding pid. */
550 kret
= pid_for_task (task_port
, &task_pid
);
551 if (kret
!= KERN_SUCCESS
)
553 MACH_CHECK_ERROR (kret
);
557 /* Find the inferior for this pid. */
558 inf
= darwin_find_inferior_by_pid (task_pid
);
562 darwin_inferior
*priv
= get_darwin_inferior (inf
);
564 /* Deallocate saved exception ports. */
565 darwin_deallocate_exception_ports (priv
);
567 /* No need to remove dead_name notification, but still... */
568 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
569 MACH_NOTIFY_DEAD_NAME
, 0,
571 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
573 if (kret
!= KERN_INVALID_ARGUMENT
)
574 MACH_CHECK_ERROR (kret
);
576 /* Replace old task port. */
577 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
578 MACH_CHECK_ERROR (kret
);
579 priv
->task
= task_port
;
581 darwin_setup_request_notification (inf
);
582 darwin_setup_exceptions (inf
);
587 /* Check data representation. */
590 darwin_check_message_ndr (NDR_record_t
*ndr
)
592 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
593 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
594 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
595 || ndr
->int_rep
!= NDR_record
.int_rep
596 || ndr
->char_rep
!= NDR_record
.char_rep
597 || ndr
->float_rep
!= NDR_record
.float_rep
)
602 /* Decode an exception message. */
605 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
606 struct inferior
**pinf
,
607 darwin_thread_t
**pthread
)
609 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
610 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
613 struct inferior
*inf
;
614 darwin_thread_t
*thread
;
616 thread_t thread_port
;
620 /* Check message destination. */
621 if (hdr
->msgh_local_port
!= darwin_ex_port
)
624 /* Check message header. */
625 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
628 /* Check descriptors. */
629 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
630 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
631 || bod
->msgh_descriptor_count
!= 2
632 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
633 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
634 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
635 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
638 /* Check data representation. */
639 ndr
= (NDR_record_t
*)(desc
+ 2);
640 if (darwin_check_message_ndr (ndr
) != 0)
643 /* Ok, the hard work. */
644 data
= (integer_t
*)(ndr
+ 1);
646 task_port
= desc
[1].name
;
647 thread_port
= desc
[0].name
;
649 /* Find process by port. */
650 inf
= darwin_find_inferior_by_task (task_port
);
653 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
654 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
656 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
657 as a new Mach task is created when a process exec. */
658 inf
= darwin_find_new_inferior (task_port
, thread_port
);
663 /* Deallocate task_port, unless it was saved. */
664 kret
= mach_port_deallocate (mach_task_self (), task_port
);
665 MACH_CHECK_ERROR (kret
);
670 /* We got new rights to the task, get rid of it. Do not get rid of
671 thread right, as we will need it to find the thread. */
672 kret
= mach_port_deallocate (mach_task_self (), task_port
);
673 MACH_CHECK_ERROR (kret
);
678 /* Not a known inferior. This could happen if the child fork, as
679 the created process will inherit its exception port.
680 FIXME: should the exception port be restored ? */
682 mig_reply_error_t reply
;
685 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
688 /* Free thread port (we don't know it). */
689 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
690 MACH_CHECK_ERROR (kret
);
692 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
694 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
695 reply
.Head
.msgh_size
, 0,
696 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
698 MACH_CHECK_ERROR (kret
);
703 /* Find thread by port. */
704 /* Check for new threads. Do it early so that the port in the exception
705 message can be deallocated. */
706 darwin_check_new_threads (inf
);
708 /* Free the thread port (as gdb knows the thread, it has already has a right
709 for it, so this just decrement a reference counter). */
710 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
711 MACH_CHECK_ERROR (kret
);
713 thread
= darwin_find_thread (inf
, thread_port
);
718 /* The thread should be running. However we have observed cases where a
719 thread got a SIGTTIN message after being stopped. */
720 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
722 /* Finish decoding. */
723 thread
->event
.header
= *hdr
;
724 thread
->event
.thread_port
= thread_port
;
725 thread
->event
.task_port
= task_port
;
726 thread
->event
.ex_type
= data
[0];
727 thread
->event
.data_count
= data
[1];
729 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
730 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
731 + data
[1] * sizeof (integer_t
)))
733 for (i
= 0; i
< data
[1]; i
++)
734 thread
->event
.ex_data
[i
] = data
[2 + i
];
736 thread
->msg_state
= DARWIN_MESSAGE
;
741 /* Decode dead_name notify message. */
744 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
746 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
747 integer_t
*data
= (integer_t
*)(ndr
+ 1);
748 struct inferior
*inf
;
749 darwin_thread_t
*thread
;
751 thread_t thread_port
;
755 /* Check message header. */
756 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
759 /* Check descriptors. */
760 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
763 /* Check data representation. */
764 if (darwin_check_message_ndr (ndr
) != 0)
769 /* Find process by port. */
770 inf
= darwin_find_inferior_by_task (task_port
);
773 /* Check message destination. */
776 darwin_inferior
*priv
= get_darwin_inferior (inf
);
777 if (hdr
->msgh_local_port
!= priv
->notify_port
)
785 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
788 mach_msg_header_t
*rh
= &reply
->Head
;
790 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
791 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
792 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
793 rh
->msgh_local_port
= MACH_PORT_NULL
;
794 rh
->msgh_id
= hdr
->msgh_id
+ 100;
796 reply
->NDR
= NDR_record
;
797 reply
->RetCode
= code
;
801 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
804 mig_reply_error_t reply
;
805 darwin_inferior
*priv
= get_darwin_inferior (inf
);
807 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
809 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
810 reply
.Head
.msgh_size
, 0,
811 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
813 MACH_CHECK_ERROR (kret
);
815 priv
->pending_messages
--;
818 /* Wrapper around the __pthread_kill syscall. We use this instead of the
819 pthread_kill function to be able to send a signal to any kind of thread,
820 including GCD threads. */
823 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
826 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
827 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
833 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
834 int step
, int nsignal
)
837 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
838 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
840 switch (thread
->msg_state
)
843 if (thread
->event
.ex_type
== EXC_SOFTWARE
844 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
846 /* Either deliver a new signal or cancel the signal received. */
847 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
848 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
850 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
854 /* Note: ptrace is allowed only if the process is stopped.
855 Directly send the signal to the thread. */
856 int res
= darwin_pthread_kill (thread
, nsignal
);
857 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
858 thread
->gdb_port
, nsignal
, res
);
859 thread
->signaled
= 1;
862 /* Set or reset single step. */
863 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
864 thread
->gdb_port
, step
);
865 darwin_set_sstep (thread
->gdb_port
, step
);
866 thread
->single_step
= step
;
868 darwin_send_reply (inf
, thread
);
869 thread
->msg_state
= DARWIN_RUNNING
;
876 kern_return_t kret
= thread_resume (thread
->gdb_port
);
877 MACH_CHECK_ERROR (kret
);
879 thread
->msg_state
= DARWIN_RUNNING
;
884 /* Resume all threads of the inferior. */
887 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
889 darwin_inferior
*priv
= get_darwin_inferior (inf
);
892 for (darwin_thread_t
*thread
: priv
->threads
)
893 darwin_resume_thread (inf
, thread
, step
, nsignal
);
896 struct resume_inferior_threads_param
903 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
905 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
906 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
908 darwin_resume_inferior_threads (inf
, step
, nsignal
);
913 /* Suspend all threads of INF. */
916 darwin_suspend_inferior_threads (struct inferior
*inf
)
918 darwin_inferior
*priv
= get_darwin_inferior (inf
);
920 for (darwin_thread_t
*thread
: priv
->threads
)
922 switch (thread
->msg_state
)
929 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
930 MACH_CHECK_ERROR (kret
);
931 thread
->msg_state
= DARWIN_STOPPED
;
939 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
941 struct target_waitstatus status
;
947 struct inferior
*inf
;
950 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
951 ptid
.pid (), ptid
.tid (), step
, signal
);
953 if (signal
== GDB_SIGNAL_0
)
956 nsignal
= gdb_signal_to_host (signal
);
958 /* Don't try to single step all threads. */
960 ptid
= inferior_ptid
;
962 /* minus_one_ptid is RESUME_ALL. */
963 if (ptid
== minus_one_ptid
)
965 struct resume_inferior_threads_param param
;
967 param
.nsignal
= nsignal
;
970 /* Resume threads. */
971 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
973 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
977 struct inferior
*inf
= find_inferior_ptid (ptid
);
978 long tid
= ptid
.tid ();
980 /* Stop the inferior (should be useless). */
981 darwin_suspend_inferior (inf
);
984 darwin_resume_inferior_threads (inf
, step
, nsignal
);
987 darwin_thread_t
*thread
;
989 /* Suspend threads of the task. */
990 darwin_suspend_inferior_threads (inf
);
992 /* Resume the selected thread. */
993 thread
= darwin_find_thread (inf
, tid
);
995 darwin_resume_thread (inf
, thread
, step
, nsignal
);
998 /* Resume the task. */
999 darwin_resume_inferior (inf
);
1004 darwin_decode_message (mach_msg_header_t
*hdr
,
1005 darwin_thread_t
**pthread
,
1006 struct inferior
**pinf
,
1007 struct target_waitstatus
*status
)
1009 darwin_thread_t
*thread
;
1010 struct inferior
*inf
;
1012 /* Exception message. 2401 == 0x961 is exc. */
1013 if (hdr
->msgh_id
== 2401)
1017 /* Decode message. */
1018 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1022 /* Should not happen... */
1024 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1025 /* FIXME: send a failure reply? */
1026 status
->kind
= TARGET_WAITKIND_IGNORE
;
1027 return minus_one_ptid
;
1031 status
->kind
= TARGET_WAITKIND_IGNORE
;
1032 return minus_one_ptid
;
1037 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1039 priv
->pending_messages
++;
1041 status
->kind
= TARGET_WAITKIND_STOPPED
;
1042 thread
->msg_state
= DARWIN_MESSAGE
;
1044 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1046 unparse_exception_type (thread
->event
.ex_type
));
1048 switch (thread
->event
.ex_type
)
1050 case EXC_BAD_ACCESS
:
1051 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1053 case EXC_BAD_INSTRUCTION
:
1054 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1056 case EXC_ARITHMETIC
:
1057 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1060 status
->value
.sig
= GDB_EXC_EMULATION
;
1063 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1066 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1067 inferior_debug (5, _(" (signal %d: %s)\n"),
1068 thread
->event
.ex_data
[1],
1069 gdb_signal_to_name (status
->value
.sig
));
1071 /* If the thread is stopped because it has received a signal
1072 that gdb has just sent, continue. */
1073 if (thread
->signaled
)
1075 thread
->signaled
= 0;
1076 darwin_send_reply (inf
, thread
);
1077 thread
->msg_state
= DARWIN_RUNNING
;
1078 status
->kind
= TARGET_WAITKIND_IGNORE
;
1082 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1084 case EXC_BREAKPOINT
:
1085 /* Many internal GDB routines expect breakpoints to be reported
1086 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1087 as a spurious signal. */
1088 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1091 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1095 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1097 else if (hdr
->msgh_id
== 0x48)
1099 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1102 res
= darwin_decode_notify_message (hdr
, &inf
);
1106 /* Should not happen... */
1108 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1115 if (res
< 0 || inf
== NULL
)
1117 status
->kind
= TARGET_WAITKIND_IGNORE
;
1118 return minus_one_ptid
;
1123 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1125 if (!priv
->no_ptrace
)
1130 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1131 if (res
< 0 || res
!= inf
->pid
)
1133 printf_unfiltered (_("wait4: res=%d: %s\n"),
1134 res
, safe_strerror (errno
));
1135 status
->kind
= TARGET_WAITKIND_IGNORE
;
1136 return minus_one_ptid
;
1138 if (WIFEXITED (wstatus
))
1140 status
->kind
= TARGET_WAITKIND_EXITED
;
1141 status
->value
.integer
= WEXITSTATUS (wstatus
);
1145 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1146 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1149 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1152 /* Looks necessary on Leopard and harmless... */
1153 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1155 inferior_ptid
= ptid_t (inf
->pid
, 0, 0);
1156 return inferior_ptid
;
1160 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1161 status
->kind
= TARGET_WAITKIND_EXITED
;
1162 status
->value
.integer
= 0; /* Don't know. */
1163 return ptid_t (inf
->pid
, 0, 0);
1168 /* Unknown message. */
1169 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1170 status
->kind
= TARGET_WAITKIND_IGNORE
;
1171 return minus_one_ptid
;
1175 cancel_breakpoint (ptid_t ptid
)
1177 /* Arrange for a breakpoint to be hit again later. We will handle
1178 the current event, eventually we will resume this thread, and this
1179 breakpoint will trap again.
1181 If we do not do this, then we run the risk that the user will
1182 delete or disable the breakpoint, but the thread will have already
1185 struct regcache
*regcache
= get_thread_regcache (ptid
);
1186 struct gdbarch
*gdbarch
= regcache
->arch ();
1189 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1190 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1192 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1193 (unsigned long) ptid
.tid ());
1195 /* Back up the PC if necessary. */
1196 if (gdbarch_decr_pc_after_break (gdbarch
))
1197 regcache_write_pc (regcache
, pc
);
1205 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1210 mach_msg_header_t hdr
;
1213 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1215 darwin_thread_t
*thread
;
1216 struct inferior
*inf
;
1219 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1220 ptid
.pid (), ptid
.tid ());
1222 /* Handle fake stop events at first. */
1223 if (darwin_inf_fake_stop
!= NULL
)
1225 inf
= darwin_inf_fake_stop
;
1226 darwin_inf_fake_stop
= NULL
;
1228 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1230 status
->kind
= TARGET_WAITKIND_STOPPED
;
1231 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1232 thread
= priv
->threads
[0];
1233 thread
->msg_state
= DARWIN_STOPPED
;
1234 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1239 /* set_sigint_trap (); */
1241 /* Wait for a message. */
1242 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1243 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1245 /* clear_sigint_trap (); */
1247 if (kret
== MACH_RCV_INTERRUPTED
)
1249 status
->kind
= TARGET_WAITKIND_IGNORE
;
1250 return minus_one_ptid
;
1253 if (kret
!= MACH_MSG_SUCCESS
)
1255 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1256 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1257 return minus_one_ptid
;
1260 /* Debug: display message. */
1261 if (darwin_debug_flag
> 10)
1262 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1264 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1265 if (res
== minus_one_ptid
)
1268 /* Early return in case an inferior has exited. */
1272 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1274 /* Stop all tasks. */
1275 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1277 /* Read pending messages. */
1280 struct target_waitstatus status2
;
1283 kret
= mach_msg (&msgin
.hdr
,
1284 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1285 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1287 if (kret
== MACH_RCV_TIMED_OUT
)
1289 if (kret
!= MACH_MSG_SUCCESS
)
1292 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1296 /* Debug: display message. */
1297 if (darwin_debug_flag
> 10)
1298 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1300 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1302 if (inf
!= NULL
&& thread
!= NULL
1303 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1305 if (thread
->single_step
1306 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1308 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1309 darwin_send_reply (inf
, thread
);
1310 thread
->msg_state
= DARWIN_RUNNING
;
1314 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1318 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1324 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1327 return darwin_wait (ptid
, status
);
1331 darwin_nat_target::interrupt ()
1333 struct inferior
*inf
= current_inferior ();
1334 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1336 /* FIXME: handle in no_ptrace mode. */
1337 gdb_assert (!priv
->no_ptrace
);
1338 ::kill (inf
->pid
, SIGINT
);
1341 /* Deallocate threads port and vector. */
1344 darwin_deallocate_threads (struct inferior
*inf
)
1346 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1348 for (darwin_thread_t
*t
: priv
->threads
)
1350 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1351 MACH_CHECK_ERROR (kret
);
1354 priv
->threads
.clear ();
1358 darwin_nat_target::mourn_inferior ()
1360 struct inferior
*inf
= current_inferior ();
1361 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1366 /* Deallocate threads. */
1367 darwin_deallocate_threads (inf
);
1369 /* Remove notify_port from darwin_port_set. */
1370 kret
= mach_port_move_member (gdb_task
,
1371 priv
->notify_port
, MACH_PORT_NULL
);
1372 MACH_CHECK_ERROR (kret
);
1374 /* Remove task port dead_name notification. */
1375 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1376 MACH_NOTIFY_DEAD_NAME
, 0,
1378 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1380 /* This can fail if the task is dead. */
1381 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1382 priv
->task
, prev
, priv
->notify_port
);
1384 if (kret
== KERN_SUCCESS
)
1386 kret
= mach_port_deallocate (gdb_task
, prev
);
1387 MACH_CHECK_ERROR (kret
);
1390 /* Destroy notify_port. */
1391 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1392 MACH_CHECK_ERROR (kret
);
1394 /* Deallocate saved exception ports. */
1395 darwin_deallocate_exception_ports (priv
);
1397 /* Deallocate task port. */
1398 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1399 MACH_CHECK_ERROR (kret
);
1403 inf_child_target::mourn_inferior ();
1407 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1409 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1411 for (darwin_thread_t
*t
: priv
->threads
)
1413 if (t
->msg_state
== DARWIN_MESSAGE
)
1414 darwin_resume_thread (inf
, t
, 0, 0);
1419 darwin_stop_inferior (struct inferior
*inf
)
1421 struct target_waitstatus wstatus
;
1426 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1428 gdb_assert (inf
!= NULL
);
1430 darwin_suspend_inferior (inf
);
1432 darwin_reply_to_all_pending_messages (inf
);
1434 if (priv
->no_ptrace
)
1437 res
= kill (inf
->pid
, SIGSTOP
);
1439 warning (_("cannot kill: %s"), safe_strerror (errno
));
1441 /* Wait until the process is really stopped. */
1444 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1445 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1446 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1451 static kern_return_t
1452 darwin_save_exception_ports (darwin_inferior
*inf
)
1456 inf
->exception_info
.count
=
1457 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1459 kret
= task_get_exception_ports
1460 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1461 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1462 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1466 static kern_return_t
1467 darwin_restore_exception_ports (darwin_inferior
*inf
)
1472 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1474 kret
= task_set_exception_ports
1475 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1476 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1477 if (kret
!= KERN_SUCCESS
)
1481 return KERN_SUCCESS
;
1484 /* Deallocate saved exception ports. */
1487 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1492 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1494 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1495 MACH_CHECK_ERROR (kret
);
1497 inf
->exception_info
.count
= 0;
1501 darwin_setup_exceptions (struct inferior
*inf
)
1503 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1506 exception_mask_t mask
;
1508 kret
= darwin_save_exception_ports (priv
);
1509 if (kret
!= KERN_SUCCESS
)
1510 error (_("Unable to save exception ports, task_get_exception_ports"
1514 /* Set exception port. */
1515 if (enable_mach_exceptions
)
1516 mask
= EXC_MASK_ALL
;
1518 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1519 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1520 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1521 if (kret
!= KERN_SUCCESS
)
1522 error (_("Unable to set exception ports, task_set_exception_ports"
1528 darwin_nat_target::kill ()
1530 struct inferior
*inf
= current_inferior ();
1531 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1532 struct target_waitstatus wstatus
;
1538 if (inferior_ptid
== null_ptid
)
1541 gdb_assert (inf
!= NULL
);
1543 kret
= darwin_restore_exception_ports (priv
);
1544 MACH_CHECK_ERROR (kret
);
1546 darwin_reply_to_all_pending_messages (inf
);
1548 res
= ::kill (inf
->pid
, 9);
1552 darwin_resume_inferior (inf
);
1554 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1556 else if (errno
!= ESRCH
)
1557 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1558 inf
->pid
, safe_strerror (errno
));
1560 target_mourn_inferior (inferior_ptid
);
1564 darwin_setup_request_notification (struct inferior
*inf
)
1566 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1568 mach_port_t prev_not
;
1570 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1571 MACH_NOTIFY_DEAD_NAME
, 0,
1573 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1575 if (kret
!= KERN_SUCCESS
)
1576 error (_("Termination notification request failed, "
1577 "mach_port_request_notification\n"
1580 if (prev_not
!= MACH_PORT_NULL
)
1582 /* This is unexpected, as there should not be any previously
1583 registered notification request. But this is not a fatal
1584 issue, so just emit a warning. */
1586 A task termination request was registered before the debugger registered\n\
1587 its own. This is unexpected, but should otherwise not have any actual\n\
1588 impact on the debugging session."));
1593 darwin_attach_pid (struct inferior
*inf
)
1596 mach_port_t prev_port
;
1598 mach_port_t prev_not
;
1599 exception_mask_t mask
;
1601 darwin_inferior
*priv
= new darwin_inferior
;
1602 inf
->priv
.reset (priv
);
1606 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1607 if (kret
!= KERN_SUCCESS
)
1611 if (!inf
->attach_flag
)
1614 waitpid (inf
->pid
, &status
, 0);
1618 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1619 " (please check gdb is codesigned - see taskgated(8))"),
1620 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1623 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1624 priv
->task
, inf
->pid
);
1626 if (darwin_ex_port
== MACH_PORT_NULL
)
1628 /* Create a port to get exceptions. */
1629 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1631 if (kret
!= KERN_SUCCESS
)
1632 error (_("Unable to create exception port, mach_port_allocate "
1636 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1638 MACH_MSG_TYPE_MAKE_SEND
);
1639 if (kret
!= KERN_SUCCESS
)
1640 error (_("Unable to create exception port, mach_port_insert_right "
1644 /* Create a port set and put ex_port in it. */
1645 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1647 if (kret
!= KERN_SUCCESS
)
1648 error (_("Unable to create port set, mach_port_allocate "
1652 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1654 if (kret
!= KERN_SUCCESS
)
1655 error (_("Unable to move exception port into new port set, "
1656 "mach_port_move_member\n"
1661 /* Create a port to be notified when the child task terminates. */
1662 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1663 &priv
->notify_port
);
1664 if (kret
!= KERN_SUCCESS
)
1665 error (_("Unable to create notification port, mach_port_allocate "
1669 kret
= mach_port_move_member (gdb_task
,
1670 priv
->notify_port
, darwin_port_set
);
1671 if (kret
!= KERN_SUCCESS
)
1672 error (_("Unable to move notification port into new port set, "
1673 "mach_port_move_member\n"
1677 darwin_setup_request_notification (inf
);
1679 darwin_setup_exceptions (inf
);
1681 CATCH (ex
, RETURN_MASK_ALL
)
1683 exit_inferior (inf
);
1684 inferior_ptid
= null_ptid
;
1686 throw_exception (ex
);
1690 target_ops
*darwin_ops
= get_native_target ();
1691 if (!target_is_pushed (darwin_ops
))
1692 push_target (darwin_ops
);
1695 /* Get the thread_info object corresponding to this darwin_thread_info. */
1697 static struct thread_info
*
1698 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1700 struct thread_info
*it
;
1704 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1706 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1710 gdb_assert (it
!= NULL
);
1716 darwin_init_thread_list (struct inferior
*inf
)
1718 darwin_check_new_threads (inf
);
1720 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1722 gdb_assert (!priv
->threads
.empty ());
1724 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1725 struct thread_info
*first_thread
1726 = thread_info_from_private_thread_info (first_pti
);
1728 inferior_ptid
= first_thread
->ptid
;
1731 /* The child must synchronize with gdb: gdb must set the exception port
1732 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1733 FIXME: is there a lighter way ? */
1734 static int ptrace_fds
[2];
1737 darwin_ptrace_me (void)
1742 /* Close write end point. */
1743 if (close (ptrace_fds
[1]) < 0)
1744 trace_start_error_with_name ("close");
1746 /* Wait until gdb is ready. */
1747 res
= read (ptrace_fds
[0], &c
, 1);
1749 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1751 if (close (ptrace_fds
[0]) < 0)
1752 trace_start_error_with_name ("close");
1754 /* Get rid of privileges. */
1755 if (setegid (getgid ()) < 0)
1756 trace_start_error_with_name ("setegid");
1759 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1760 trace_start_error_with_name ("PTRACE");
1762 /* Redirect signals to exception port. */
1763 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1764 trace_start_error_with_name ("PTRACE");
1767 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1769 darwin_pre_ptrace (void)
1771 if (pipe (ptrace_fds
) != 0)
1775 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1778 mark_fd_no_cloexec (ptrace_fds
[0]);
1779 mark_fd_no_cloexec (ptrace_fds
[1]);
1783 darwin_ptrace_him (int pid
)
1787 mach_port_t prev_port
;
1789 struct inferior
*inf
= current_inferior ();
1791 darwin_attach_pid (inf
);
1793 /* Let's the child run. */
1794 close (ptrace_fds
[0]);
1795 close (ptrace_fds
[1]);
1797 unmark_fd_no_cloexec (ptrace_fds
[0]);
1798 unmark_fd_no_cloexec (ptrace_fds
[1]);
1800 darwin_init_thread_list (inf
);
1802 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1806 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1808 posix_spawnattr_t attr
;
1812 res
= posix_spawnattr_init (&attr
);
1816 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1820 /* Do like execve: replace the image. */
1821 ps_flags
= POSIX_SPAWN_SETEXEC
;
1823 /* Disable ASLR. The constant doesn't look to be available outside the
1824 kernel include files. */
1825 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1826 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1828 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1829 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1832 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1836 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1840 darwin_nat_target::create_inferior (const char *exec_file
,
1841 const std::string
&allargs
,
1842 char **env
, int from_tty
)
1844 /* Do the hard work. */
1845 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1846 darwin_ptrace_him
, darwin_pre_ptrace
, NULL
,
1851 /* Set things up such that the next call to darwin_wait will immediately
1852 return a fake stop event for inferior INF.
1854 This assumes that the inferior's thread list has been initialized,
1855 as it will suspend the inferior's first thread. */
1858 darwin_setup_fake_stop_event (struct inferior
*inf
)
1860 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1861 darwin_thread_t
*thread
;
1864 gdb_assert (darwin_inf_fake_stop
== NULL
);
1865 darwin_inf_fake_stop
= inf
;
1867 /* When detecting a fake pending stop event, darwin_wait returns
1868 an event saying that the first thread is in a DARWIN_STOPPED
1869 state. To make that accurate, we need to suspend that thread
1870 as well. Otherwise, we'll try resuming it when resuming the
1871 inferior, and get a warning because the thread's suspend count
1872 is already zero, making the resume request useless. */
1873 thread
= priv
->threads
[0];
1874 kret
= thread_suspend (thread
->gdb_port
);
1875 MACH_CHECK_ERROR (kret
);
1878 /* Attach to process PID, then initialize for debugging it
1879 and wait for the trace-trap that results from attaching. */
1881 darwin_nat_target::attach (const char *args
, int from_tty
)
1887 struct inferior
*inf
;
1890 pid
= parse_pid_to_attach (args
);
1892 if (pid
== getpid ()) /* Trying to masturbate? */
1893 error (_("I refuse to debug myself!"));
1897 char *exec_file
= get_exec_file (0);
1900 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1901 target_pid_to_str (ptid_t (pid
)));
1903 printf_unfiltered (_("Attaching to %s\n"),
1904 target_pid_to_str (ptid_t (pid
)));
1906 gdb_flush (gdb_stdout
);
1909 if (pid
== 0 || ::kill (pid
, 0) < 0)
1910 error (_("Can't attach to process %d: %s (%d)"),
1911 pid
, safe_strerror (errno
), errno
);
1913 inferior_ptid
= ptid_t (pid
);
1914 inf
= current_inferior ();
1915 inferior_appeared (inf
, pid
);
1916 inf
->attach_flag
= 1;
1918 darwin_attach_pid (inf
);
1920 darwin_suspend_inferior (inf
);
1922 darwin_init_thread_list (inf
);
1924 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1926 darwin_check_osabi (priv
, inferior_ptid
.tid ());
1928 darwin_setup_fake_stop_event (inf
);
1930 priv
->no_ptrace
= 1;
1933 /* Take a program previously attached to and detaches it.
1934 The program resumes execution and will no longer stop
1935 on signals, etc. We'd better not have left any breakpoints
1936 in the program or it'll die when it hits one. For this
1937 to work, it may be necessary for the process to have been
1938 previously attached. It *might* work if the program was
1939 started via fork. */
1942 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
1944 pid_t pid
= inferior_ptid
.pid ();
1945 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1949 /* Display message. */
1950 target_announce_detach (from_tty
);
1952 /* If ptrace() is in use, stop the process. */
1953 if (!priv
->no_ptrace
)
1954 darwin_stop_inferior (inf
);
1956 kret
= darwin_restore_exception_ports (priv
);
1957 MACH_CHECK_ERROR (kret
);
1959 if (!priv
->no_ptrace
)
1961 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1963 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1964 inf
->pid
, safe_strerror (errno
), errno
);
1967 darwin_reply_to_all_pending_messages (inf
);
1969 /* When using ptrace, we have just performed a PT_DETACH, which
1970 resumes the inferior. On the other hand, when we are not using
1971 ptrace, we need to resume its execution ourselves. */
1972 if (priv
->no_ptrace
)
1973 darwin_resume_inferior (inf
);
1979 darwin_nat_target::pid_to_str (ptid_t ptid
)
1981 static char buf
[80];
1982 long tid
= ptid
.tid ();
1986 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1991 return normal_pid_to_str (ptid
);
1995 darwin_nat_target::thread_alive (ptid_t ptid
)
2000 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2001 copy it to RDADDR in gdb's address space.
2002 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2003 to ADDR in inferior task's address space.
2004 Return 0 on failure; number of bytes read / writen otherwise. */
2007 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2008 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2012 mach_vm_size_t res_length
= 0;
2014 mach_msg_type_number_t copy_count
;
2015 mach_vm_size_t remaining_length
;
2016 mach_vm_address_t region_address
;
2017 mach_vm_size_t region_length
;
2019 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2020 task
, core_addr_to_string (addr
), pulongest (length
));
2025 mach_vm_size_t count
;
2027 /* According to target.h(to_xfer_partial), one and only one may be
2029 gdb_assert (wraddr
== NULL
);
2031 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2032 (mach_vm_address_t
) rdaddr
, &count
);
2033 if (kret
!= KERN_SUCCESS
)
2036 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2037 core_addr_to_string (addr
), mach_error_string (kret
));
2044 gdb_assert (wraddr
!= NULL
);
2048 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2049 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2050 mach_vm_size_t aligned_length
=
2051 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2052 vm_region_submap_short_info_data_64_t info
;
2053 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2054 natural_t region_depth
= 1000;
2055 mach_vm_address_t region_start
= region_address
;
2056 mach_vm_size_t region_length
;
2057 mach_vm_size_t write_length
;
2059 /* Read page protection. */
2060 kret
= mach_vm_region_recurse
2061 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2062 (vm_region_recurse_info_t
) &info
, &count
);
2064 if (kret
!= KERN_SUCCESS
)
2066 inferior_debug (1, _("darwin_read_write_inferior: "
2067 "mach_vm_region_recurse failed at %s: %s\n"),
2068 core_addr_to_string (region_address
),
2069 mach_error_string (kret
));
2074 (9, _("darwin_read_write_inferior: "
2075 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2076 core_addr_to_string (region_address
),
2077 core_addr_to_string (region_start
),
2078 core_addr_to_string (region_length
));
2080 /* Check for holes in memory. */
2081 if (region_start
> region_address
)
2083 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2084 core_addr_to_string (region_address
),
2085 core_addr_to_string (region_start
),
2086 (unsigned)region_length
);
2090 /* Adjust the length. */
2091 region_length
-= (region_address
- region_start
);
2092 if (region_length
> aligned_length
)
2093 region_length
= aligned_length
;
2095 /* Make the pages RW. */
2096 if (!(info
.protection
& VM_PROT_WRITE
))
2098 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2100 kret
= mach_vm_protect (task
, region_address
, region_length
,
2102 if (kret
!= KERN_SUCCESS
)
2104 prot
|= VM_PROT_COPY
;
2105 kret
= mach_vm_protect (task
, region_address
, region_length
,
2108 if (kret
!= KERN_SUCCESS
)
2110 warning (_("darwin_read_write_inferior: "
2111 "mach_vm_protect failed at %s "
2112 "(len=0x%lx, prot=0x%x): %s"),
2113 core_addr_to_string (region_address
),
2114 (unsigned long) region_length
, (unsigned) prot
,
2115 mach_error_string (kret
));
2120 if (offset
+ length
> region_length
)
2121 write_length
= region_length
- offset
;
2123 write_length
= length
;
2126 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2127 if (kret
!= KERN_SUCCESS
)
2129 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2130 mach_error_string (kret
));
2134 /* Restore page rights. */
2135 if (!(info
.protection
& VM_PROT_WRITE
))
2137 kret
= mach_vm_protect (task
, region_address
, region_length
,
2138 FALSE
, info
.protection
);
2139 if (kret
!= KERN_SUCCESS
)
2141 warning (_("darwin_read_write_inferior: "
2142 "mach_vm_protect restore failed at %s "
2144 core_addr_to_string (region_address
),
2145 (unsigned long) region_length
,
2146 mach_error_string (kret
));
2150 addr
+= write_length
;
2151 wraddr
+= write_length
;
2152 res_length
+= write_length
;
2153 length
-= write_length
;
2159 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2160 to RDADDR (in big endian).
2161 Return 0 on failure; number of bytes read / written otherwise. */
2163 #ifdef TASK_DYLD_INFO_COUNT
2164 /* This is not available in Darwin 9. */
2165 static enum target_xfer_status
2166 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2167 ULONGEST length
, ULONGEST
*xfered_len
)
2169 struct task_dyld_info task_dyld_info
;
2170 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2171 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2174 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2175 return TARGET_XFER_EOF
;
2177 kret
= task_info (task
, TASK_DYLD_INFO
,
2178 (task_info_t
) &task_dyld_info
, &count
);
2179 MACH_CHECK_ERROR (kret
);
2180 if (kret
!= KERN_SUCCESS
)
2181 return TARGET_XFER_E_IO
;
2183 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2184 task_dyld_info
.all_image_info_addr
);
2185 *xfered_len
= (ULONGEST
) length
;
2186 return TARGET_XFER_OK
;
2192 enum target_xfer_status
2193 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2194 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2195 ULONGEST offset
, ULONGEST len
,
2196 ULONGEST
*xfered_len
)
2198 struct inferior
*inf
= current_inferior ();
2199 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2202 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2203 core_addr_to_string (offset
), pulongest (len
),
2204 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2209 case TARGET_OBJECT_MEMORY
:
2211 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2212 readbuf
, writebuf
, len
);
2215 return TARGET_XFER_EOF
;
2219 *xfered_len
= (ULONGEST
) l
;
2220 return TARGET_XFER_OK
;
2223 #ifdef TASK_DYLD_INFO_COUNT
2224 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2225 if (writebuf
!= NULL
|| readbuf
== NULL
)
2227 /* Support only read. */
2228 return TARGET_XFER_E_IO
;
2230 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2234 return TARGET_XFER_E_IO
;
2240 set_enable_mach_exceptions (const char *args
, int from_tty
,
2241 struct cmd_list_element
*c
)
2243 if (inferior_ptid
!= null_ptid
)
2245 struct inferior
*inf
= current_inferior ();
2246 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2247 exception_mask_t mask
;
2250 if (enable_mach_exceptions
)
2251 mask
= EXC_MASK_ALL
;
2254 darwin_restore_exception_ports (priv
);
2255 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2257 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2258 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2259 MACH_CHECK_ERROR (kret
);
2264 darwin_nat_target::pid_to_exec_file (int pid
)
2266 static char path
[PATH_MAX
];
2269 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2277 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2279 struct inferior
*inf
= current_inferior ();
2280 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2282 mach_port_name_array_t names
;
2283 mach_msg_type_number_t names_count
;
2284 mach_port_type_array_t types
;
2285 mach_msg_type_number_t types_count
;
2288 /* First linear search. */
2289 for (darwin_thread_t
*t
: priv
->threads
)
2291 if (t
->inf_port
== lwp
)
2292 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2295 /* Maybe the port was never extract. Do it now. */
2297 /* First get inferior port names. */
2298 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2300 MACH_CHECK_ERROR (kret
);
2301 if (kret
!= KERN_SUCCESS
)
2304 /* For each name, copy the right in the gdb space and then compare with
2305 our view of the inferior threads. We don't forget to deallocate the
2307 for (int i
= 0; i
< names_count
; i
++)
2309 mach_port_t local_name
;
2310 mach_msg_type_name_t local_type
;
2312 /* We just need to know the corresponding name in gdb name space.
2313 So extract and deallocate the right. */
2314 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2315 MACH_MSG_TYPE_COPY_SEND
,
2316 &local_name
, &local_type
);
2317 if (kret
!= KERN_SUCCESS
)
2319 mach_port_deallocate (gdb_task
, local_name
);
2321 for (darwin_thread_t
*t
: priv
->threads
)
2323 if (t
->gdb_port
== local_name
)
2325 t
->inf_port
= names
[i
];
2326 if (names
[i
] == lwp
)
2332 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2333 names_count
* sizeof (mach_port_t
));
2336 return ptid_t (inferior_ptid
.pid (), 0, res
);
2342 darwin_nat_target::supports_multi_process ()
2348 _initialize_darwin_nat ()
2352 gdb_task
= mach_task_self ();
2353 darwin_host_self
= mach_host_self ();
2355 /* Read page size. */
2356 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2357 if (kret
!= KERN_SUCCESS
)
2359 mach_page_size
= 0x1000;
2360 MACH_CHECK_ERROR (kret
);
2363 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2364 (unsigned long) mach_task_self (), getpid ());
2366 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2367 &darwin_debug_flag
, _("\
2368 Set if printing inferior communication debugging statements."), _("\
2369 Show if printing inferior communication debugging statements."), NULL
,
2371 &setdebuglist
, &showdebuglist
);
2373 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2374 &enable_mach_exceptions
, _("\
2375 Set if mach exceptions are caught."), _("\
2376 Show if mach exceptions are caught."), _("\
2377 When this mode is on, all low level exceptions are reported before being\n\
2378 reported by the kernel."),
2379 &set_enable_mach_exceptions
, NULL
,
2380 &setlist
, &showlist
);