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 /* Get list of threads. */
263 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
264 MACH_CHECK_ERROR (kret
);
265 if (kret
!= KERN_SUCCESS
)
270 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
272 old_nbr
= darwin_inf
->threads
.size ();
274 /* Quick check for no changes. */
275 if (old_nbr
== new_nbr
)
279 for (i
= 0; i
< new_nbr
; i
++)
280 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
284 /* Deallocate ports. */
285 for (i
= 0; i
< new_nbr
; i
++)
287 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
288 MACH_CHECK_ERROR (kret
);
291 /* Deallocate the buffer. */
292 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
293 new_nbr
* sizeof (int));
294 MACH_CHECK_ERROR (kret
);
300 /* Full handling: detect new threads, remove dead threads. */
302 new_thread_vec
.reserve (new_nbr
);
304 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
306 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
308 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
309 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
312 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
313 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
315 if (old_id
== new_id
)
317 /* Thread still exist. */
318 new_thread_vec
.push_back (old
);
322 /* Deallocate the port. */
323 kret
= mach_port_deallocate (gdb_task
, new_id
);
324 MACH_CHECK_ERROR (kret
);
328 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
330 /* Ignore dead ports.
331 In some weird cases, we might get dead ports. They should
332 correspond to dead thread so they could safely be ignored. */
336 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
338 /* A thread was created. */
339 darwin_thread_info
*pti
= new darwin_thread_info
;
341 pti
->gdb_port
= new_id
;
342 pti
->msg_state
= DARWIN_RUNNING
;
344 /* Add the new thread. */
345 add_thread_with_info (ptid_t (inf
->pid
, 0, new_id
), pti
);
346 new_thread_vec
.push_back (pti
);
350 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
352 /* A thread was removed. */
353 struct thread_info
*thr
354 = find_thread_ptid (ptid_t (inf
->pid
, 0, old_id
));
356 kret
= mach_port_deallocate (gdb_task
, old_id
);
357 MACH_CHECK_ERROR (kret
);
361 gdb_assert_not_reached ("unexpected thread case");
364 darwin_inf
->threads
= std::move (new_thread_vec
);
366 /* Deallocate the buffer. */
367 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
368 new_nbr
* sizeof (int));
369 MACH_CHECK_ERROR (kret
);
373 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
375 darwin_inferior
*priv
= get_darwin_inferior (inf
);
377 return priv
->task
== *(task_t
*)port_ptr
;
381 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
383 return inf
->pid
== *(int *)pid_ptr
;
386 /* Return an inferior by task port. */
387 static struct inferior
*
388 darwin_find_inferior_by_task (task_t port
)
390 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
393 /* Return an inferior by pid port. */
394 static struct inferior
*
395 darwin_find_inferior_by_pid (int pid
)
397 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
400 /* Return a thread by port. */
401 static darwin_thread_t
*
402 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
404 darwin_inferior
*priv
= get_darwin_inferior (inf
);
406 for (darwin_thread_t
*t
: priv
->threads
)
408 if (t
->gdb_port
== thread
)
415 /* Suspend (ie stop) an inferior at Mach level. */
418 darwin_suspend_inferior (struct inferior
*inf
)
420 darwin_inferior
*priv
= get_darwin_inferior (inf
);
422 if (!priv
->suspended
)
426 kret
= task_suspend (priv
->task
);
427 MACH_CHECK_ERROR (kret
);
433 /* Resume an inferior at Mach level. */
436 darwin_resume_inferior (struct inferior
*inf
)
438 darwin_inferior
*priv
= get_darwin_inferior (inf
);
444 kret
= task_resume (priv
->task
);
445 MACH_CHECK_ERROR (kret
);
451 /* Iterator functions. */
454 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
456 darwin_suspend_inferior (inf
);
457 darwin_check_new_threads (inf
);
462 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
464 darwin_resume_inferior (inf
);
469 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
471 printf_unfiltered (_("message header:\n"));
472 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
473 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
474 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
475 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
476 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
477 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
481 const unsigned char *data
;
482 const unsigned int *ldata
;
486 data
= (unsigned char *)(hdr
+ 1);
487 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
489 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
491 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
492 mach_msg_port_descriptor_t
*desc
=
493 (mach_msg_port_descriptor_t
*)(bod
+ 1);
496 printf_unfiltered (_("body: descriptor_count=%u\n"),
497 bod
->msgh_descriptor_count
);
498 data
+= sizeof (mach_msg_body_t
);
499 size
-= sizeof (mach_msg_body_t
);
500 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
501 switch (desc
[k
].type
)
503 case MACH_MSG_PORT_DESCRIPTOR
:
505 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
506 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
509 printf_unfiltered (_(" descr %d: type=%u\n"),
513 data
+= bod
->msgh_descriptor_count
514 * sizeof (mach_msg_port_descriptor_t
);
515 size
-= bod
->msgh_descriptor_count
516 * sizeof (mach_msg_port_descriptor_t
);
517 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
519 (_("NDR: mig=%02x if=%02x encod=%02x "
520 "int=%02x char=%02x float=%02x\n"),
521 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
522 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
523 data
+= sizeof (NDR_record_t
);
524 size
-= sizeof (NDR_record_t
);
527 printf_unfiltered (_(" data:"));
528 ldata
= (const unsigned int *)data
;
529 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
530 printf_unfiltered (" %08x", ldata
[i
]);
531 printf_unfiltered (_("\n"));
535 /* Adjust inferior data when a new task was created. */
537 static struct inferior
*
538 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
541 struct inferior
*inf
;
545 /* Find the corresponding pid. */
546 kret
= pid_for_task (task_port
, &task_pid
);
547 if (kret
!= KERN_SUCCESS
)
549 MACH_CHECK_ERROR (kret
);
553 /* Find the inferior for this pid. */
554 inf
= darwin_find_inferior_by_pid (task_pid
);
558 darwin_inferior
*priv
= get_darwin_inferior (inf
);
560 /* Deallocate saved exception ports. */
561 darwin_deallocate_exception_ports (priv
);
563 /* No need to remove dead_name notification, but still... */
564 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
565 MACH_NOTIFY_DEAD_NAME
, 0,
567 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
569 if (kret
!= KERN_INVALID_ARGUMENT
)
570 MACH_CHECK_ERROR (kret
);
572 /* Replace old task port. */
573 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
574 MACH_CHECK_ERROR (kret
);
575 priv
->task
= task_port
;
577 darwin_setup_request_notification (inf
);
578 darwin_setup_exceptions (inf
);
583 /* Check data representation. */
586 darwin_check_message_ndr (NDR_record_t
*ndr
)
588 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
589 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
590 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
591 || ndr
->int_rep
!= NDR_record
.int_rep
592 || ndr
->char_rep
!= NDR_record
.char_rep
593 || ndr
->float_rep
!= NDR_record
.float_rep
)
598 /* Decode an exception message. */
601 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
602 struct inferior
**pinf
,
603 darwin_thread_t
**pthread
)
605 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
606 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
609 struct inferior
*inf
;
610 darwin_thread_t
*thread
;
612 thread_t thread_port
;
616 /* Check message destination. */
617 if (hdr
->msgh_local_port
!= darwin_ex_port
)
620 /* Check message header. */
621 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
624 /* Check descriptors. */
625 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
626 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
627 || bod
->msgh_descriptor_count
!= 2
628 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
629 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
630 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
631 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
634 /* Check data representation. */
635 ndr
= (NDR_record_t
*)(desc
+ 2);
636 if (darwin_check_message_ndr (ndr
) != 0)
639 /* Ok, the hard work. */
640 data
= (integer_t
*)(ndr
+ 1);
642 task_port
= desc
[1].name
;
643 thread_port
= desc
[0].name
;
645 /* Find process by port. */
646 inf
= darwin_find_inferior_by_task (task_port
);
649 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
650 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
652 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
653 as a new Mach task is created when a process exec. */
654 inf
= darwin_find_new_inferior (task_port
, thread_port
);
659 /* Deallocate task_port, unless it was saved. */
660 kret
= mach_port_deallocate (mach_task_self (), task_port
);
661 MACH_CHECK_ERROR (kret
);
666 /* We got new rights to the task, get rid of it. Do not get rid of
667 thread right, as we will need it to find the thread. */
668 kret
= mach_port_deallocate (mach_task_self (), task_port
);
669 MACH_CHECK_ERROR (kret
);
674 /* Not a known inferior. This could happen if the child fork, as
675 the created process will inherit its exception port.
676 FIXME: should the exception port be restored ? */
678 mig_reply_error_t reply
;
681 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
684 /* Free thread port (we don't know it). */
685 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
686 MACH_CHECK_ERROR (kret
);
688 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
690 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
691 reply
.Head
.msgh_size
, 0,
692 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
694 MACH_CHECK_ERROR (kret
);
699 /* Find thread by port. */
700 /* Check for new threads. Do it early so that the port in the exception
701 message can be deallocated. */
702 darwin_check_new_threads (inf
);
704 /* Free the thread port (as gdb knows the thread, it has already has a right
705 for it, so this just decrement a reference counter). */
706 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
707 MACH_CHECK_ERROR (kret
);
709 thread
= darwin_find_thread (inf
, thread_port
);
714 /* The thread should be running. However we have observed cases where a
715 thread got a SIGTTIN message after being stopped. */
716 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
718 /* Finish decoding. */
719 thread
->event
.header
= *hdr
;
720 thread
->event
.thread_port
= thread_port
;
721 thread
->event
.task_port
= task_port
;
722 thread
->event
.ex_type
= data
[0];
723 thread
->event
.data_count
= data
[1];
725 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
726 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
727 + data
[1] * sizeof (integer_t
)))
729 for (i
= 0; i
< data
[1]; i
++)
730 thread
->event
.ex_data
[i
] = data
[2 + i
];
732 thread
->msg_state
= DARWIN_MESSAGE
;
737 /* Decode dead_name notify message. */
740 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
742 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
743 integer_t
*data
= (integer_t
*)(ndr
+ 1);
744 struct inferior
*inf
;
745 darwin_thread_t
*thread
;
747 thread_t thread_port
;
751 /* Check message header. */
752 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
755 /* Check descriptors. */
756 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
759 /* Check data representation. */
760 if (darwin_check_message_ndr (ndr
) != 0)
765 /* Find process by port. */
766 inf
= darwin_find_inferior_by_task (task_port
);
769 darwin_inferior
*priv
= get_darwin_inferior (inf
);
771 /* Check message destination. */
772 if (inf
!= NULL
&& hdr
->msgh_local_port
!= priv
->notify_port
)
779 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
782 mach_msg_header_t
*rh
= &reply
->Head
;
784 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
785 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
786 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
787 rh
->msgh_local_port
= MACH_PORT_NULL
;
788 rh
->msgh_id
= hdr
->msgh_id
+ 100;
790 reply
->NDR
= NDR_record
;
791 reply
->RetCode
= code
;
795 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
798 mig_reply_error_t reply
;
799 darwin_inferior
*priv
= get_darwin_inferior (inf
);
801 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
803 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
804 reply
.Head
.msgh_size
, 0,
805 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
807 MACH_CHECK_ERROR (kret
);
809 priv
->pending_messages
--;
812 /* Wrapper around the __pthread_kill syscall. We use this instead of the
813 pthread_kill function to be able to send a signal to any kind of thread,
814 including GCD threads. */
817 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
820 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
821 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
827 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
828 int step
, int nsignal
)
831 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
832 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
834 switch (thread
->msg_state
)
837 if (thread
->event
.ex_type
== EXC_SOFTWARE
838 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
840 /* Either deliver a new signal or cancel the signal received. */
841 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
842 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
844 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
848 /* Note: ptrace is allowed only if the process is stopped.
849 Directly send the signal to the thread. */
850 int res
= darwin_pthread_kill (thread
, nsignal
);
851 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
852 thread
->gdb_port
, nsignal
, res
);
853 thread
->signaled
= 1;
856 /* Set or reset single step. */
857 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
858 thread
->gdb_port
, step
);
859 darwin_set_sstep (thread
->gdb_port
, step
);
860 thread
->single_step
= step
;
862 darwin_send_reply (inf
, thread
);
863 thread
->msg_state
= DARWIN_RUNNING
;
870 kern_return_t kret
= thread_resume (thread
->gdb_port
);
871 MACH_CHECK_ERROR (kret
);
873 thread
->msg_state
= DARWIN_RUNNING
;
878 /* Resume all threads of the inferior. */
881 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
883 darwin_inferior
*priv
= get_darwin_inferior (inf
);
885 for (darwin_thread_t
*thread
: priv
->threads
)
886 darwin_resume_thread (inf
, thread
, step
, nsignal
);
889 struct resume_inferior_threads_param
896 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
898 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
899 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
901 darwin_resume_inferior_threads (inf
, step
, nsignal
);
906 /* Suspend all threads of INF. */
909 darwin_suspend_inferior_threads (struct inferior
*inf
)
911 darwin_inferior
*priv
= get_darwin_inferior (inf
);
913 for (darwin_thread_t
*thread
: priv
->threads
)
915 switch (thread
->msg_state
)
922 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
923 MACH_CHECK_ERROR (kret
);
924 thread
->msg_state
= DARWIN_STOPPED
;
932 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
934 struct target_waitstatus status
;
940 struct inferior
*inf
;
943 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
944 ptid
.pid (), ptid
.tid (), step
, signal
);
946 if (signal
== GDB_SIGNAL_0
)
949 nsignal
= gdb_signal_to_host (signal
);
951 /* Don't try to single step all threads. */
953 ptid
= inferior_ptid
;
955 /* minus_one_ptid is RESUME_ALL. */
956 if (ptid
== minus_one_ptid
)
958 struct resume_inferior_threads_param param
;
960 param
.nsignal
= nsignal
;
963 /* Resume threads. */
964 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
966 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
970 struct inferior
*inf
= find_inferior_ptid (ptid
);
971 long tid
= ptid
.tid ();
973 /* Stop the inferior (should be useless). */
974 darwin_suspend_inferior (inf
);
977 darwin_resume_inferior_threads (inf
, step
, nsignal
);
980 darwin_thread_t
*thread
;
982 /* Suspend threads of the task. */
983 darwin_suspend_inferior_threads (inf
);
985 /* Resume the selected thread. */
986 thread
= darwin_find_thread (inf
, tid
);
988 darwin_resume_thread (inf
, thread
, step
, nsignal
);
991 /* Resume the task. */
992 darwin_resume_inferior (inf
);
997 darwin_decode_message (mach_msg_header_t
*hdr
,
998 darwin_thread_t
**pthread
,
999 struct inferior
**pinf
,
1000 struct target_waitstatus
*status
)
1002 darwin_thread_t
*thread
;
1003 struct inferior
*inf
;
1005 /* Exception message. 2401 == 0x961 is exc. */
1006 if (hdr
->msgh_id
== 2401)
1010 /* Decode message. */
1011 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1015 /* Should not happen... */
1017 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1018 /* FIXME: send a failure reply? */
1019 status
->kind
= TARGET_WAITKIND_IGNORE
;
1020 return minus_one_ptid
;
1024 status
->kind
= TARGET_WAITKIND_IGNORE
;
1025 return minus_one_ptid
;
1030 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1032 priv
->pending_messages
++;
1034 status
->kind
= TARGET_WAITKIND_STOPPED
;
1035 thread
->msg_state
= DARWIN_MESSAGE
;
1037 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1039 unparse_exception_type (thread
->event
.ex_type
));
1041 switch (thread
->event
.ex_type
)
1043 case EXC_BAD_ACCESS
:
1044 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1046 case EXC_BAD_INSTRUCTION
:
1047 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1049 case EXC_ARITHMETIC
:
1050 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1053 status
->value
.sig
= GDB_EXC_EMULATION
;
1056 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1059 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1060 inferior_debug (5, _(" (signal %d: %s)\n"),
1061 thread
->event
.ex_data
[1],
1062 gdb_signal_to_name (status
->value
.sig
));
1064 /* If the thread is stopped because it has received a signal
1065 that gdb has just sent, continue. */
1066 if (thread
->signaled
)
1068 thread
->signaled
= 0;
1069 darwin_send_reply (inf
, thread
);
1070 thread
->msg_state
= DARWIN_RUNNING
;
1071 status
->kind
= TARGET_WAITKIND_IGNORE
;
1075 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1077 case EXC_BREAKPOINT
:
1078 /* Many internal GDB routines expect breakpoints to be reported
1079 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1080 as a spurious signal. */
1081 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1084 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1088 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1090 else if (hdr
->msgh_id
== 0x48)
1092 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1095 res
= darwin_decode_notify_message (hdr
, &inf
);
1099 /* Should not happen... */
1101 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1108 if (res
< 0 || inf
== NULL
)
1110 status
->kind
= TARGET_WAITKIND_IGNORE
;
1111 return minus_one_ptid
;
1116 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1118 if (!priv
->no_ptrace
)
1123 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1124 if (res
< 0 || res
!= inf
->pid
)
1126 printf_unfiltered (_("wait4: res=%d: %s\n"),
1127 res
, safe_strerror (errno
));
1128 status
->kind
= TARGET_WAITKIND_IGNORE
;
1129 return minus_one_ptid
;
1131 if (WIFEXITED (wstatus
))
1133 status
->kind
= TARGET_WAITKIND_EXITED
;
1134 status
->value
.integer
= WEXITSTATUS (wstatus
);
1138 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1139 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1142 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1145 /* Looks necessary on Leopard and harmless... */
1146 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1148 inferior_ptid
= ptid_t (inf
->pid
, 0, 0);
1149 return inferior_ptid
;
1153 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1154 status
->kind
= TARGET_WAITKIND_EXITED
;
1155 status
->value
.integer
= 0; /* Don't know. */
1156 return ptid_t (inf
->pid
, 0, 0);
1161 /* Unknown message. */
1162 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1163 status
->kind
= TARGET_WAITKIND_IGNORE
;
1164 return minus_one_ptid
;
1168 cancel_breakpoint (ptid_t ptid
)
1170 /* Arrange for a breakpoint to be hit again later. We will handle
1171 the current event, eventually we will resume this thread, and this
1172 breakpoint will trap again.
1174 If we do not do this, then we run the risk that the user will
1175 delete or disable the breakpoint, but the thread will have already
1178 struct regcache
*regcache
= get_thread_regcache (ptid
);
1179 struct gdbarch
*gdbarch
= regcache
->arch ();
1182 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1183 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1185 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1186 (unsigned long) ptid
.tid ());
1188 /* Back up the PC if necessary. */
1189 if (gdbarch_decr_pc_after_break (gdbarch
))
1190 regcache_write_pc (regcache
, pc
);
1198 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1203 mach_msg_header_t hdr
;
1206 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1208 darwin_thread_t
*thread
;
1209 struct inferior
*inf
;
1212 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1213 ptid
.pid (), ptid
.tid ());
1215 /* Handle fake stop events at first. */
1216 if (darwin_inf_fake_stop
!= NULL
)
1218 inf
= darwin_inf_fake_stop
;
1219 darwin_inf_fake_stop
= NULL
;
1221 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1223 status
->kind
= TARGET_WAITKIND_STOPPED
;
1224 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1225 thread
= priv
->threads
[0];
1226 thread
->msg_state
= DARWIN_STOPPED
;
1227 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1232 /* set_sigint_trap (); */
1234 /* Wait for a message. */
1235 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1236 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1238 /* clear_sigint_trap (); */
1240 if (kret
== MACH_RCV_INTERRUPTED
)
1242 status
->kind
= TARGET_WAITKIND_IGNORE
;
1243 return minus_one_ptid
;
1246 if (kret
!= MACH_MSG_SUCCESS
)
1248 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1249 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1250 return minus_one_ptid
;
1253 /* Debug: display message. */
1254 if (darwin_debug_flag
> 10)
1255 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1257 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1258 if (res
== minus_one_ptid
)
1261 /* Early return in case an inferior has exited. */
1265 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1267 /* Stop all tasks. */
1268 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1270 /* Read pending messages. */
1273 struct target_waitstatus status2
;
1276 kret
= mach_msg (&msgin
.hdr
,
1277 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1278 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1280 if (kret
== MACH_RCV_TIMED_OUT
)
1282 if (kret
!= MACH_MSG_SUCCESS
)
1285 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1289 /* Debug: display message. */
1290 if (darwin_debug_flag
> 10)
1291 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1293 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1295 if (inf
!= NULL
&& thread
!= NULL
1296 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1298 if (thread
->single_step
1299 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1301 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1302 darwin_send_reply (inf
, thread
);
1303 thread
->msg_state
= DARWIN_RUNNING
;
1307 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1311 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1317 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1320 return darwin_wait (ptid
, status
);
1324 darwin_nat_target::interrupt ()
1326 struct inferior
*inf
= current_inferior ();
1327 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1329 /* FIXME: handle in no_ptrace mode. */
1330 gdb_assert (!priv
->no_ptrace
);
1331 ::kill (inf
->pid
, SIGINT
);
1334 /* Deallocate threads port and vector. */
1337 darwin_deallocate_threads (struct inferior
*inf
)
1339 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1341 for (darwin_thread_t
*t
: priv
->threads
)
1343 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1344 MACH_CHECK_ERROR (kret
);
1347 priv
->threads
.clear ();
1351 darwin_nat_target::mourn_inferior ()
1353 struct inferior
*inf
= current_inferior ();
1354 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1359 /* Deallocate threads. */
1360 darwin_deallocate_threads (inf
);
1362 /* Remove notify_port from darwin_port_set. */
1363 kret
= mach_port_move_member (gdb_task
,
1364 priv
->notify_port
, MACH_PORT_NULL
);
1365 MACH_CHECK_ERROR (kret
);
1367 /* Remove task port dead_name notification. */
1368 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1369 MACH_NOTIFY_DEAD_NAME
, 0,
1371 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1373 /* This can fail if the task is dead. */
1374 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1375 priv
->task
, prev
, priv
->notify_port
);
1377 if (kret
== KERN_SUCCESS
)
1379 kret
= mach_port_deallocate (gdb_task
, prev
);
1380 MACH_CHECK_ERROR (kret
);
1383 /* Destroy notify_port. */
1384 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1385 MACH_CHECK_ERROR (kret
);
1387 /* Deallocate saved exception ports. */
1388 darwin_deallocate_exception_ports (priv
);
1390 /* Deallocate task port. */
1391 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1392 MACH_CHECK_ERROR (kret
);
1396 inf_child_target::mourn_inferior ();
1400 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1402 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1404 for (darwin_thread_t
*t
: priv
->threads
)
1406 if (t
->msg_state
== DARWIN_MESSAGE
)
1407 darwin_resume_thread (inf
, t
, 0, 0);
1412 darwin_stop_inferior (struct inferior
*inf
)
1414 struct target_waitstatus wstatus
;
1419 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1421 gdb_assert (inf
!= NULL
);
1423 darwin_suspend_inferior (inf
);
1425 darwin_reply_to_all_pending_messages (inf
);
1427 if (priv
->no_ptrace
)
1430 res
= kill (inf
->pid
, SIGSTOP
);
1432 warning (_("cannot kill: %s"), safe_strerror (errno
));
1434 /* Wait until the process is really stopped. */
1437 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1438 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1439 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1444 static kern_return_t
1445 darwin_save_exception_ports (darwin_inferior
*inf
)
1449 inf
->exception_info
.count
=
1450 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1452 kret
= task_get_exception_ports
1453 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1454 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1455 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1459 static kern_return_t
1460 darwin_restore_exception_ports (darwin_inferior
*inf
)
1465 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1467 kret
= task_set_exception_ports
1468 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1469 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1470 if (kret
!= KERN_SUCCESS
)
1474 return KERN_SUCCESS
;
1477 /* Deallocate saved exception ports. */
1480 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1485 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1487 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1488 MACH_CHECK_ERROR (kret
);
1490 inf
->exception_info
.count
= 0;
1494 darwin_setup_exceptions (struct inferior
*inf
)
1496 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1499 exception_mask_t mask
;
1501 kret
= darwin_save_exception_ports (priv
);
1502 if (kret
!= KERN_SUCCESS
)
1503 error (_("Unable to save exception ports, task_get_exception_ports"
1507 /* Set exception port. */
1508 if (enable_mach_exceptions
)
1509 mask
= EXC_MASK_ALL
;
1511 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1512 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1513 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1514 if (kret
!= KERN_SUCCESS
)
1515 error (_("Unable to set exception ports, task_set_exception_ports"
1521 darwin_nat_target::kill ()
1523 struct inferior
*inf
= current_inferior ();
1524 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1525 struct target_waitstatus wstatus
;
1531 if (inferior_ptid
== null_ptid
)
1534 gdb_assert (inf
!= NULL
);
1536 kret
= darwin_restore_exception_ports (priv
);
1537 MACH_CHECK_ERROR (kret
);
1539 darwin_reply_to_all_pending_messages (inf
);
1541 res
= ::kill (inf
->pid
, 9);
1545 darwin_resume_inferior (inf
);
1547 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1549 else if (errno
!= ESRCH
)
1550 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1551 inf
->pid
, safe_strerror (errno
));
1553 target_mourn_inferior (inferior_ptid
);
1557 darwin_setup_request_notification (struct inferior
*inf
)
1559 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1561 mach_port_t prev_not
;
1563 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1564 MACH_NOTIFY_DEAD_NAME
, 0,
1566 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1568 if (kret
!= KERN_SUCCESS
)
1569 error (_("Termination notification request failed, "
1570 "mach_port_request_notification\n"
1573 if (prev_not
!= MACH_PORT_NULL
)
1575 /* This is unexpected, as there should not be any previously
1576 registered notification request. But this is not a fatal
1577 issue, so just emit a warning. */
1579 A task termination request was registered before the debugger registered\n\
1580 its own. This is unexpected, but should otherwise not have any actual\n\
1581 impact on the debugging session."));
1586 darwin_attach_pid (struct inferior
*inf
)
1589 mach_port_t prev_port
;
1591 mach_port_t prev_not
;
1592 exception_mask_t mask
;
1594 darwin_inferior
*priv
= new darwin_inferior
;
1595 inf
->priv
.reset (priv
);
1599 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1600 if (kret
!= KERN_SUCCESS
)
1604 if (!inf
->attach_flag
)
1607 waitpid (inf
->pid
, &status
, 0);
1611 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1612 " (please check gdb is codesigned - see taskgated(8))"),
1613 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1616 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1617 priv
->task
, inf
->pid
);
1619 if (darwin_ex_port
== MACH_PORT_NULL
)
1621 /* Create a port to get exceptions. */
1622 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1624 if (kret
!= KERN_SUCCESS
)
1625 error (_("Unable to create exception port, mach_port_allocate "
1629 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1631 MACH_MSG_TYPE_MAKE_SEND
);
1632 if (kret
!= KERN_SUCCESS
)
1633 error (_("Unable to create exception port, mach_port_insert_right "
1637 /* Create a port set and put ex_port in it. */
1638 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1640 if (kret
!= KERN_SUCCESS
)
1641 error (_("Unable to create port set, mach_port_allocate "
1645 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1647 if (kret
!= KERN_SUCCESS
)
1648 error (_("Unable to move exception port into new port set, "
1649 "mach_port_move_member\n"
1654 /* Create a port to be notified when the child task terminates. */
1655 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1656 &priv
->notify_port
);
1657 if (kret
!= KERN_SUCCESS
)
1658 error (_("Unable to create notification port, mach_port_allocate "
1662 kret
= mach_port_move_member (gdb_task
,
1663 priv
->notify_port
, darwin_port_set
);
1664 if (kret
!= KERN_SUCCESS
)
1665 error (_("Unable to move notification port into new port set, "
1666 "mach_port_move_member\n"
1670 darwin_setup_request_notification (inf
);
1672 darwin_setup_exceptions (inf
);
1674 CATCH (ex
, RETURN_MASK_ALL
)
1676 exit_inferior (inf
);
1677 inferior_ptid
= null_ptid
;
1679 throw_exception (ex
);
1683 target_ops
*darwin_ops
= get_native_target ();
1684 if (!target_is_pushed (darwin_ops
))
1685 push_target (darwin_ops
);
1688 /* Get the thread_info object corresponding to this darwin_thread_info. */
1690 static struct thread_info
*
1691 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1693 struct thread_info
*it
;
1697 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1699 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1703 gdb_assert (it
!= NULL
);
1709 darwin_init_thread_list (struct inferior
*inf
)
1711 darwin_check_new_threads (inf
);
1713 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1715 gdb_assert (!priv
->threads
.empty ());
1717 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1718 struct thread_info
*first_thread
1719 = thread_info_from_private_thread_info (first_pti
);
1721 inferior_ptid
= first_thread
->ptid
;
1724 /* The child must synchronize with gdb: gdb must set the exception port
1725 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1726 FIXME: is there a lighter way ? */
1727 static int ptrace_fds
[2];
1730 darwin_ptrace_me (void)
1735 /* Close write end point. */
1736 if (close (ptrace_fds
[1]) < 0)
1737 trace_start_error_with_name ("close");
1739 /* Wait until gdb is ready. */
1740 res
= read (ptrace_fds
[0], &c
, 1);
1742 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1744 if (close (ptrace_fds
[0]) < 0)
1745 trace_start_error_with_name ("close");
1747 /* Get rid of privileges. */
1748 if (setegid (getgid ()) < 0)
1749 trace_start_error_with_name ("setegid");
1752 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1753 trace_start_error_with_name ("PTRACE");
1755 /* Redirect signals to exception port. */
1756 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1757 trace_start_error_with_name ("PTRACE");
1760 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1762 darwin_pre_ptrace (void)
1764 if (pipe (ptrace_fds
) != 0)
1768 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1771 mark_fd_no_cloexec (ptrace_fds
[0]);
1772 mark_fd_no_cloexec (ptrace_fds
[1]);
1776 darwin_ptrace_him (int pid
)
1780 mach_port_t prev_port
;
1782 struct inferior
*inf
= current_inferior ();
1784 darwin_attach_pid (inf
);
1786 /* Let's the child run. */
1787 close (ptrace_fds
[0]);
1788 close (ptrace_fds
[1]);
1790 unmark_fd_no_cloexec (ptrace_fds
[0]);
1791 unmark_fd_no_cloexec (ptrace_fds
[1]);
1793 darwin_init_thread_list (inf
);
1795 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1799 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1801 posix_spawnattr_t attr
;
1805 res
= posix_spawnattr_init (&attr
);
1809 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1813 /* Do like execve: replace the image. */
1814 ps_flags
= POSIX_SPAWN_SETEXEC
;
1816 /* Disable ASLR. The constant doesn't look to be available outside the
1817 kernel include files. */
1818 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1819 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1821 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1822 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1825 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1829 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1833 darwin_nat_target::create_inferior (const char *exec_file
,
1834 const std::string
&allargs
,
1835 char **env
, int from_tty
)
1837 /* Do the hard work. */
1838 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1839 darwin_ptrace_him
, darwin_pre_ptrace
, NULL
,
1844 /* Set things up such that the next call to darwin_wait will immediately
1845 return a fake stop event for inferior INF.
1847 This assumes that the inferior's thread list has been initialized,
1848 as it will suspend the inferior's first thread. */
1851 darwin_setup_fake_stop_event (struct inferior
*inf
)
1853 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1854 darwin_thread_t
*thread
;
1857 gdb_assert (darwin_inf_fake_stop
== NULL
);
1858 darwin_inf_fake_stop
= inf
;
1860 /* When detecting a fake pending stop event, darwin_wait returns
1861 an event saying that the first thread is in a DARWIN_STOPPED
1862 state. To make that accurate, we need to suspend that thread
1863 as well. Otherwise, we'll try resuming it when resuming the
1864 inferior, and get a warning because the thread's suspend count
1865 is already zero, making the resume request useless. */
1866 thread
= priv
->threads
[0];
1867 kret
= thread_suspend (thread
->gdb_port
);
1868 MACH_CHECK_ERROR (kret
);
1871 /* Attach to process PID, then initialize for debugging it
1872 and wait for the trace-trap that results from attaching. */
1874 darwin_nat_target::attach (const char *args
, int from_tty
)
1880 struct inferior
*inf
;
1883 pid
= parse_pid_to_attach (args
);
1885 if (pid
== getpid ()) /* Trying to masturbate? */
1886 error (_("I refuse to debug myself!"));
1890 char *exec_file
= get_exec_file (0);
1893 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1894 target_pid_to_str (ptid_t (pid
)));
1896 printf_unfiltered (_("Attaching to %s\n"),
1897 target_pid_to_str (ptid_t (pid
)));
1899 gdb_flush (gdb_stdout
);
1902 if (pid
== 0 || ::kill (pid
, 0) < 0)
1903 error (_("Can't attach to process %d: %s (%d)"),
1904 pid
, safe_strerror (errno
), errno
);
1906 inferior_ptid
= ptid_t (pid
);
1907 inf
= current_inferior ();
1908 inferior_appeared (inf
, pid
);
1909 inf
->attach_flag
= 1;
1911 darwin_attach_pid (inf
);
1913 darwin_suspend_inferior (inf
);
1915 darwin_init_thread_list (inf
);
1917 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1919 darwin_check_osabi (priv
, inferior_ptid
.tid ());
1921 darwin_setup_fake_stop_event (inf
);
1923 priv
->no_ptrace
= 1;
1926 /* Take a program previously attached to and detaches it.
1927 The program resumes execution and will no longer stop
1928 on signals, etc. We'd better not have left any breakpoints
1929 in the program or it'll die when it hits one. For this
1930 to work, it may be necessary for the process to have been
1931 previously attached. It *might* work if the program was
1932 started via fork. */
1935 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
1937 pid_t pid
= inferior_ptid
.pid ();
1938 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1942 /* Display message. */
1943 target_announce_detach (from_tty
);
1945 /* If ptrace() is in use, stop the process. */
1946 if (!priv
->no_ptrace
)
1947 darwin_stop_inferior (inf
);
1949 kret
= darwin_restore_exception_ports (priv
);
1950 MACH_CHECK_ERROR (kret
);
1952 if (!priv
->no_ptrace
)
1954 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1956 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1957 inf
->pid
, safe_strerror (errno
), errno
);
1960 darwin_reply_to_all_pending_messages (inf
);
1962 /* When using ptrace, we have just performed a PT_DETACH, which
1963 resumes the inferior. On the other hand, when we are not using
1964 ptrace, we need to resume its execution ourselves. */
1965 if (priv
->no_ptrace
)
1966 darwin_resume_inferior (inf
);
1972 darwin_nat_target::pid_to_str (ptid_t ptid
)
1974 static char buf
[80];
1975 long tid
= ptid
.tid ();
1979 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1984 return normal_pid_to_str (ptid
);
1988 darwin_nat_target::thread_alive (ptid_t ptid
)
1993 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1994 copy it to RDADDR in gdb's address space.
1995 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1996 to ADDR in inferior task's address space.
1997 Return 0 on failure; number of bytes read / writen otherwise. */
2000 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2001 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2005 mach_vm_size_t res_length
= 0;
2007 mach_msg_type_number_t copy_count
;
2008 mach_vm_size_t remaining_length
;
2009 mach_vm_address_t region_address
;
2010 mach_vm_size_t region_length
;
2012 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2013 task
, core_addr_to_string (addr
), pulongest (length
));
2018 mach_vm_size_t count
;
2020 /* According to target.h(to_xfer_partial), one and only one may be
2022 gdb_assert (wraddr
== NULL
);
2024 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2025 (mach_vm_address_t
) rdaddr
, &count
);
2026 if (kret
!= KERN_SUCCESS
)
2029 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2030 core_addr_to_string (addr
), mach_error_string (kret
));
2037 gdb_assert (wraddr
!= NULL
);
2041 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2042 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2043 mach_vm_size_t aligned_length
=
2044 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2045 vm_region_submap_short_info_data_64_t info
;
2046 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2047 natural_t region_depth
= 1000;
2048 mach_vm_address_t region_start
= region_address
;
2049 mach_vm_size_t region_length
;
2050 mach_vm_size_t write_length
;
2052 /* Read page protection. */
2053 kret
= mach_vm_region_recurse
2054 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2055 (vm_region_recurse_info_t
) &info
, &count
);
2057 if (kret
!= KERN_SUCCESS
)
2059 inferior_debug (1, _("darwin_read_write_inferior: "
2060 "mach_vm_region_recurse failed at %s: %s\n"),
2061 core_addr_to_string (region_address
),
2062 mach_error_string (kret
));
2067 (9, _("darwin_read_write_inferior: "
2068 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2069 core_addr_to_string (region_address
),
2070 core_addr_to_string (region_start
),
2071 core_addr_to_string (region_length
));
2073 /* Check for holes in memory. */
2074 if (region_start
> region_address
)
2076 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2077 core_addr_to_string (region_address
),
2078 core_addr_to_string (region_start
),
2079 (unsigned)region_length
);
2083 /* Adjust the length. */
2084 region_length
-= (region_address
- region_start
);
2085 if (region_length
> aligned_length
)
2086 region_length
= aligned_length
;
2088 /* Make the pages RW. */
2089 if (!(info
.protection
& VM_PROT_WRITE
))
2091 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2093 kret
= mach_vm_protect (task
, region_address
, region_length
,
2095 if (kret
!= KERN_SUCCESS
)
2097 prot
|= VM_PROT_COPY
;
2098 kret
= mach_vm_protect (task
, region_address
, region_length
,
2101 if (kret
!= KERN_SUCCESS
)
2103 warning (_("darwin_read_write_inferior: "
2104 "mach_vm_protect failed at %s "
2105 "(len=0x%lx, prot=0x%x): %s"),
2106 core_addr_to_string (region_address
),
2107 (unsigned long) region_length
, (unsigned) prot
,
2108 mach_error_string (kret
));
2113 if (offset
+ length
> region_length
)
2114 write_length
= region_length
- offset
;
2116 write_length
= length
;
2119 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2120 if (kret
!= KERN_SUCCESS
)
2122 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2123 mach_error_string (kret
));
2127 /* Restore page rights. */
2128 if (!(info
.protection
& VM_PROT_WRITE
))
2130 kret
= mach_vm_protect (task
, region_address
, region_length
,
2131 FALSE
, info
.protection
);
2132 if (kret
!= KERN_SUCCESS
)
2134 warning (_("darwin_read_write_inferior: "
2135 "mach_vm_protect restore failed at %s "
2137 core_addr_to_string (region_address
),
2138 (unsigned long) region_length
,
2139 mach_error_string (kret
));
2143 addr
+= write_length
;
2144 wraddr
+= write_length
;
2145 res_length
+= write_length
;
2146 length
-= write_length
;
2152 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2153 to RDADDR (in big endian).
2154 Return 0 on failure; number of bytes read / written otherwise. */
2156 #ifdef TASK_DYLD_INFO_COUNT
2157 /* This is not available in Darwin 9. */
2158 static enum target_xfer_status
2159 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2160 ULONGEST length
, ULONGEST
*xfered_len
)
2162 struct task_dyld_info task_dyld_info
;
2163 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2164 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2167 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2168 return TARGET_XFER_EOF
;
2170 kret
= task_info (task
, TASK_DYLD_INFO
,
2171 (task_info_t
) &task_dyld_info
, &count
);
2172 MACH_CHECK_ERROR (kret
);
2173 if (kret
!= KERN_SUCCESS
)
2174 return TARGET_XFER_E_IO
;
2176 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2177 task_dyld_info
.all_image_info_addr
);
2178 *xfered_len
= (ULONGEST
) length
;
2179 return TARGET_XFER_OK
;
2185 enum target_xfer_status
2186 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2187 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2188 ULONGEST offset
, ULONGEST len
,
2189 ULONGEST
*xfered_len
)
2191 struct inferior
*inf
= current_inferior ();
2192 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2195 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2196 core_addr_to_string (offset
), pulongest (len
),
2197 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2202 case TARGET_OBJECT_MEMORY
:
2204 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2205 readbuf
, writebuf
, len
);
2208 return TARGET_XFER_EOF
;
2212 *xfered_len
= (ULONGEST
) l
;
2213 return TARGET_XFER_OK
;
2216 #ifdef TASK_DYLD_INFO_COUNT
2217 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2218 if (writebuf
!= NULL
|| readbuf
== NULL
)
2220 /* Support only read. */
2221 return TARGET_XFER_E_IO
;
2223 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2227 return TARGET_XFER_E_IO
;
2233 set_enable_mach_exceptions (const char *args
, int from_tty
,
2234 struct cmd_list_element
*c
)
2236 if (inferior_ptid
!= null_ptid
)
2238 struct inferior
*inf
= current_inferior ();
2239 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2240 exception_mask_t mask
;
2243 if (enable_mach_exceptions
)
2244 mask
= EXC_MASK_ALL
;
2247 darwin_restore_exception_ports (priv
);
2248 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2250 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2251 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2252 MACH_CHECK_ERROR (kret
);
2257 darwin_nat_target::pid_to_exec_file (int pid
)
2259 static char path
[PATH_MAX
];
2262 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2270 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2272 struct inferior
*inf
= current_inferior ();
2273 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2275 mach_port_name_array_t names
;
2276 mach_msg_type_number_t names_count
;
2277 mach_port_type_array_t types
;
2278 mach_msg_type_number_t types_count
;
2281 /* First linear search. */
2282 for (darwin_thread_t
*t
: priv
->threads
)
2284 if (t
->inf_port
== lwp
)
2285 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2288 /* Maybe the port was never extract. Do it now. */
2290 /* First get inferior port names. */
2291 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2293 MACH_CHECK_ERROR (kret
);
2294 if (kret
!= KERN_SUCCESS
)
2297 /* For each name, copy the right in the gdb space and then compare with
2298 our view of the inferior threads. We don't forget to deallocate the
2300 for (int i
= 0; i
< names_count
; i
++)
2302 mach_port_t local_name
;
2303 mach_msg_type_name_t local_type
;
2305 /* We just need to know the corresponding name in gdb name space.
2306 So extract and deallocate the right. */
2307 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2308 MACH_MSG_TYPE_COPY_SEND
,
2309 &local_name
, &local_type
);
2310 if (kret
!= KERN_SUCCESS
)
2312 mach_port_deallocate (gdb_task
, local_name
);
2314 for (darwin_thread_t
*t
: priv
->threads
)
2316 if (t
->gdb_port
== local_name
)
2318 t
->inf_port
= names
[i
];
2319 if (names
[i
] == lwp
)
2325 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2326 names_count
* sizeof (mach_port_t
));
2329 return ptid_t (inferior_ptid
.pid (), 0, res
);
2335 darwin_nat_target::supports_multi_process ()
2341 _initialize_darwin_nat ()
2345 gdb_task
= mach_task_self ();
2346 darwin_host_self
= mach_host_self ();
2348 /* Read page size. */
2349 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2350 if (kret
!= KERN_SUCCESS
)
2352 mach_page_size
= 0x1000;
2353 MACH_CHECK_ERROR (kret
);
2356 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2357 (unsigned long) mach_task_self (), getpid ());
2359 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2360 &darwin_debug_flag
, _("\
2361 Set if printing inferior communication debugging statements."), _("\
2362 Show if printing inferior communication debugging statements."), NULL
,
2364 &setdebuglist
, &showdebuglist
);
2366 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2367 &enable_mach_exceptions
, _("\
2368 Set if mach exceptions are caught."), _("\
2369 Show if mach exceptions are caught."), _("\
2370 When this mode is on, all low level exceptions are reported before being\n\
2371 reported by the kernel."),
2372 &set_enable_mach_exceptions
, NULL
,
2373 &setlist
, &showlist
);