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_build (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 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
354 kret
= mach_port_deallocate (gdb_task
, old_id
);
355 MACH_CHECK_ERROR (kret
);
359 gdb_assert_not_reached ("unexpected thread case");
362 darwin_inf
->threads
= std::move (new_thread_vec
);
364 /* Deallocate the buffer. */
365 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
366 new_nbr
* sizeof (int));
367 MACH_CHECK_ERROR (kret
);
371 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
373 darwin_inferior
*priv
= get_darwin_inferior (inf
);
375 return priv
->task
== *(task_t
*)port_ptr
;
379 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
381 return inf
->pid
== *(int *)pid_ptr
;
384 /* Return an inferior by task port. */
385 static struct inferior
*
386 darwin_find_inferior_by_task (task_t port
)
388 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
391 /* Return an inferior by pid port. */
392 static struct inferior
*
393 darwin_find_inferior_by_pid (int pid
)
395 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
398 /* Return a thread by port. */
399 static darwin_thread_t
*
400 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
402 darwin_inferior
*priv
= get_darwin_inferior (inf
);
404 for (darwin_thread_t
*t
: priv
->threads
)
406 if (t
->gdb_port
== thread
)
413 /* Suspend (ie stop) an inferior at Mach level. */
416 darwin_suspend_inferior (struct inferior
*inf
)
418 darwin_inferior
*priv
= get_darwin_inferior (inf
);
420 if (!priv
->suspended
)
424 kret
= task_suspend (priv
->task
);
425 MACH_CHECK_ERROR (kret
);
431 /* Resume an inferior at Mach level. */
434 darwin_resume_inferior (struct inferior
*inf
)
436 darwin_inferior
*priv
= get_darwin_inferior (inf
);
442 kret
= task_resume (priv
->task
);
443 MACH_CHECK_ERROR (kret
);
449 /* Iterator functions. */
452 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
454 darwin_suspend_inferior (inf
);
455 darwin_check_new_threads (inf
);
460 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
462 darwin_resume_inferior (inf
);
467 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
469 printf_unfiltered (_("message header:\n"));
470 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
471 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
472 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
473 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
474 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
475 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
479 const unsigned char *data
;
480 const unsigned int *ldata
;
484 data
= (unsigned char *)(hdr
+ 1);
485 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
487 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
489 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
490 mach_msg_port_descriptor_t
*desc
=
491 (mach_msg_port_descriptor_t
*)(bod
+ 1);
494 printf_unfiltered (_("body: descriptor_count=%u\n"),
495 bod
->msgh_descriptor_count
);
496 data
+= sizeof (mach_msg_body_t
);
497 size
-= sizeof (mach_msg_body_t
);
498 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
499 switch (desc
[k
].type
)
501 case MACH_MSG_PORT_DESCRIPTOR
:
503 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
504 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
507 printf_unfiltered (_(" descr %d: type=%u\n"),
511 data
+= bod
->msgh_descriptor_count
512 * sizeof (mach_msg_port_descriptor_t
);
513 size
-= bod
->msgh_descriptor_count
514 * sizeof (mach_msg_port_descriptor_t
);
515 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
517 (_("NDR: mig=%02x if=%02x encod=%02x "
518 "int=%02x char=%02x float=%02x\n"),
519 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
520 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
521 data
+= sizeof (NDR_record_t
);
522 size
-= sizeof (NDR_record_t
);
525 printf_unfiltered (_(" data:"));
526 ldata
= (const unsigned int *)data
;
527 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
528 printf_unfiltered (" %08x", ldata
[i
]);
529 printf_unfiltered (_("\n"));
533 /* Adjust inferior data when a new task was created. */
535 static struct inferior
*
536 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
539 struct inferior
*inf
;
543 /* Find the corresponding pid. */
544 kret
= pid_for_task (task_port
, &task_pid
);
545 if (kret
!= KERN_SUCCESS
)
547 MACH_CHECK_ERROR (kret
);
551 /* Find the inferior for this pid. */
552 inf
= darwin_find_inferior_by_pid (task_pid
);
556 darwin_inferior
*priv
= get_darwin_inferior (inf
);
558 /* Deallocate saved exception ports. */
559 darwin_deallocate_exception_ports (priv
);
561 /* No need to remove dead_name notification, but still... */
562 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
563 MACH_NOTIFY_DEAD_NAME
, 0,
565 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
567 if (kret
!= KERN_INVALID_ARGUMENT
)
568 MACH_CHECK_ERROR (kret
);
570 /* Replace old task port. */
571 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
572 MACH_CHECK_ERROR (kret
);
573 priv
->task
= task_port
;
575 darwin_setup_request_notification (inf
);
576 darwin_setup_exceptions (inf
);
581 /* Check data representation. */
584 darwin_check_message_ndr (NDR_record_t
*ndr
)
586 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
587 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
588 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
589 || ndr
->int_rep
!= NDR_record
.int_rep
590 || ndr
->char_rep
!= NDR_record
.char_rep
591 || ndr
->float_rep
!= NDR_record
.float_rep
)
596 /* Decode an exception message. */
599 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
600 struct inferior
**pinf
,
601 darwin_thread_t
**pthread
)
603 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
604 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
607 struct inferior
*inf
;
608 darwin_thread_t
*thread
;
610 thread_t thread_port
;
614 /* Check message destination. */
615 if (hdr
->msgh_local_port
!= darwin_ex_port
)
618 /* Check message header. */
619 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
622 /* Check descriptors. */
623 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
624 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
625 || bod
->msgh_descriptor_count
!= 2
626 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
627 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
628 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
629 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
632 /* Check data representation. */
633 ndr
= (NDR_record_t
*)(desc
+ 2);
634 if (darwin_check_message_ndr (ndr
) != 0)
637 /* Ok, the hard work. */
638 data
= (integer_t
*)(ndr
+ 1);
640 task_port
= desc
[1].name
;
641 thread_port
= desc
[0].name
;
643 /* Find process by port. */
644 inf
= darwin_find_inferior_by_task (task_port
);
647 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
648 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
650 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
651 as a new Mach task is created when a process exec. */
652 inf
= darwin_find_new_inferior (task_port
, thread_port
);
657 /* Deallocate task_port, unless it was saved. */
658 kret
= mach_port_deallocate (mach_task_self (), task_port
);
659 MACH_CHECK_ERROR (kret
);
664 /* We got new rights to the task, get rid of it. Do not get rid of
665 thread right, as we will need it to find the thread. */
666 kret
= mach_port_deallocate (mach_task_self (), task_port
);
667 MACH_CHECK_ERROR (kret
);
672 /* Not a known inferior. This could happen if the child fork, as
673 the created process will inherit its exception port.
674 FIXME: should the exception port be restored ? */
676 mig_reply_error_t reply
;
679 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
682 /* Free thread port (we don't know it). */
683 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
684 MACH_CHECK_ERROR (kret
);
686 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
688 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
689 reply
.Head
.msgh_size
, 0,
690 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
692 MACH_CHECK_ERROR (kret
);
697 /* Find thread by port. */
698 /* Check for new threads. Do it early so that the port in the exception
699 message can be deallocated. */
700 darwin_check_new_threads (inf
);
702 /* Free the thread port (as gdb knows the thread, it has already has a right
703 for it, so this just decrement a reference counter). */
704 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
705 MACH_CHECK_ERROR (kret
);
707 thread
= darwin_find_thread (inf
, thread_port
);
712 /* The thread should be running. However we have observed cases where a
713 thread got a SIGTTIN message after being stopped. */
714 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
716 /* Finish decoding. */
717 thread
->event
.header
= *hdr
;
718 thread
->event
.thread_port
= thread_port
;
719 thread
->event
.task_port
= task_port
;
720 thread
->event
.ex_type
= data
[0];
721 thread
->event
.data_count
= data
[1];
723 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
724 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
725 + data
[1] * sizeof (integer_t
)))
727 for (i
= 0; i
< data
[1]; i
++)
728 thread
->event
.ex_data
[i
] = data
[2 + i
];
730 thread
->msg_state
= DARWIN_MESSAGE
;
735 /* Decode dead_name notify message. */
738 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
740 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
741 integer_t
*data
= (integer_t
*)(ndr
+ 1);
742 struct inferior
*inf
;
743 darwin_thread_t
*thread
;
745 thread_t thread_port
;
749 /* Check message header. */
750 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
753 /* Check descriptors. */
754 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
757 /* Check data representation. */
758 if (darwin_check_message_ndr (ndr
) != 0)
763 /* Find process by port. */
764 inf
= darwin_find_inferior_by_task (task_port
);
767 darwin_inferior
*priv
= get_darwin_inferior (inf
);
769 /* Check message destination. */
770 if (inf
!= NULL
&& hdr
->msgh_local_port
!= priv
->notify_port
)
777 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
780 mach_msg_header_t
*rh
= &reply
->Head
;
782 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
783 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
784 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
785 rh
->msgh_local_port
= MACH_PORT_NULL
;
786 rh
->msgh_id
= hdr
->msgh_id
+ 100;
788 reply
->NDR
= NDR_record
;
789 reply
->RetCode
= code
;
793 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
796 mig_reply_error_t reply
;
797 darwin_inferior
*priv
= get_darwin_inferior (inf
);
799 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
801 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
802 reply
.Head
.msgh_size
, 0,
803 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
805 MACH_CHECK_ERROR (kret
);
807 priv
->pending_messages
--;
811 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
812 int step
, int nsignal
)
818 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
819 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
821 switch (thread
->msg_state
)
824 if (thread
->event
.ex_type
== EXC_SOFTWARE
825 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
827 /* Either deliver a new signal or cancel the signal received. */
828 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
829 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
831 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
835 /* Note: ptrace is allowed only if the process is stopped.
836 Directly send the signal to the thread. */
837 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
838 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
839 thread
->gdb_port
, nsignal
, res
);
840 thread
->signaled
= 1;
843 /* Set or reset single step. */
844 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
845 thread
->gdb_port
, step
);
846 darwin_set_sstep (thread
->gdb_port
, step
);
847 thread
->single_step
= step
;
849 darwin_send_reply (inf
, thread
);
850 thread
->msg_state
= DARWIN_RUNNING
;
857 kret
= thread_resume (thread
->gdb_port
);
858 MACH_CHECK_ERROR (kret
);
860 thread
->msg_state
= DARWIN_RUNNING
;
865 /* Resume all threads of the inferior. */
868 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
870 darwin_inferior
*priv
= get_darwin_inferior (inf
);
872 for (darwin_thread_t
*thread
: priv
->threads
)
873 darwin_resume_thread (inf
, thread
, step
, nsignal
);
876 struct resume_inferior_threads_param
883 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
885 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
886 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
888 darwin_resume_inferior_threads (inf
, step
, nsignal
);
893 /* Suspend all threads of INF. */
896 darwin_suspend_inferior_threads (struct inferior
*inf
)
898 darwin_inferior
*priv
= get_darwin_inferior (inf
);
900 for (darwin_thread_t
*thread
: priv
->threads
)
902 switch (thread
->msg_state
)
909 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
910 MACH_CHECK_ERROR (kret
);
911 thread
->msg_state
= DARWIN_STOPPED
;
919 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
921 struct target_waitstatus status
;
927 struct inferior
*inf
;
930 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
931 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
933 if (signal
== GDB_SIGNAL_0
)
936 nsignal
= gdb_signal_to_host (signal
);
938 /* Don't try to single step all threads. */
940 ptid
= inferior_ptid
;
942 /* minus_one_ptid is RESUME_ALL. */
943 if (ptid_equal (ptid
, minus_one_ptid
))
945 struct resume_inferior_threads_param param
;
947 param
.nsignal
= nsignal
;
950 /* Resume threads. */
951 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
953 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
957 struct inferior
*inf
= find_inferior_ptid (ptid
);
958 long tid
= ptid_get_tid (ptid
);
960 /* Stop the inferior (should be useless). */
961 darwin_suspend_inferior (inf
);
964 darwin_resume_inferior_threads (inf
, step
, nsignal
);
967 darwin_thread_t
*thread
;
969 /* Suspend threads of the task. */
970 darwin_suspend_inferior_threads (inf
);
972 /* Resume the selected thread. */
973 thread
= darwin_find_thread (inf
, tid
);
975 darwin_resume_thread (inf
, thread
, step
, nsignal
);
978 /* Resume the task. */
979 darwin_resume_inferior (inf
);
984 darwin_decode_message (mach_msg_header_t
*hdr
,
985 darwin_thread_t
**pthread
,
986 struct inferior
**pinf
,
987 struct target_waitstatus
*status
)
989 darwin_thread_t
*thread
;
990 struct inferior
*inf
;
992 /* Exception message. 2401 == 0x961 is exc. */
993 if (hdr
->msgh_id
== 2401)
997 /* Decode message. */
998 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1002 /* Should not happen... */
1004 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1005 /* FIXME: send a failure reply? */
1006 status
->kind
= TARGET_WAITKIND_IGNORE
;
1007 return minus_one_ptid
;
1011 status
->kind
= TARGET_WAITKIND_IGNORE
;
1012 return minus_one_ptid
;
1017 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1019 priv
->pending_messages
++;
1021 status
->kind
= TARGET_WAITKIND_STOPPED
;
1022 thread
->msg_state
= DARWIN_MESSAGE
;
1024 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1026 unparse_exception_type (thread
->event
.ex_type
));
1028 switch (thread
->event
.ex_type
)
1030 case EXC_BAD_ACCESS
:
1031 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1033 case EXC_BAD_INSTRUCTION
:
1034 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1036 case EXC_ARITHMETIC
:
1037 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1040 status
->value
.sig
= GDB_EXC_EMULATION
;
1043 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1046 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1047 inferior_debug (5, _(" (signal %d: %s)\n"),
1048 thread
->event
.ex_data
[1],
1049 gdb_signal_to_name (status
->value
.sig
));
1051 /* If the thread is stopped because it has received a signal
1052 that gdb has just sent, continue. */
1053 if (thread
->signaled
)
1055 thread
->signaled
= 0;
1056 darwin_send_reply (inf
, thread
);
1057 thread
->msg_state
= DARWIN_RUNNING
;
1058 status
->kind
= TARGET_WAITKIND_IGNORE
;
1062 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1064 case EXC_BREAKPOINT
:
1065 /* Many internal GDB routines expect breakpoints to be reported
1066 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1067 as a spurious signal. */
1068 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1071 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1075 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1077 else if (hdr
->msgh_id
== 0x48)
1079 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1082 res
= darwin_decode_notify_message (hdr
, &inf
);
1086 /* Should not happen... */
1088 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1095 if (res
< 0 || inf
== NULL
)
1097 status
->kind
= TARGET_WAITKIND_IGNORE
;
1098 return minus_one_ptid
;
1103 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1105 if (!priv
->no_ptrace
)
1110 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1111 if (res
< 0 || res
!= inf
->pid
)
1113 printf_unfiltered (_("wait4: res=%d: %s\n"),
1114 res
, safe_strerror (errno
));
1115 status
->kind
= TARGET_WAITKIND_IGNORE
;
1116 return minus_one_ptid
;
1118 if (WIFEXITED (wstatus
))
1120 status
->kind
= TARGET_WAITKIND_EXITED
;
1121 status
->value
.integer
= WEXITSTATUS (wstatus
);
1125 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1126 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1129 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1132 /* Looks necessary on Leopard and harmless... */
1133 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1135 inferior_ptid
= ptid_build (inf
->pid
, 0, 0);
1136 return inferior_ptid
;
1140 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1141 status
->kind
= TARGET_WAITKIND_EXITED
;
1142 status
->value
.integer
= 0; /* Don't know. */
1143 return ptid_build (inf
->pid
, 0, 0);
1148 /* Unknown message. */
1149 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1150 status
->kind
= TARGET_WAITKIND_IGNORE
;
1151 return minus_one_ptid
;
1155 cancel_breakpoint (ptid_t ptid
)
1157 /* Arrange for a breakpoint to be hit again later. We will handle
1158 the current event, eventually we will resume this thread, and this
1159 breakpoint will trap again.
1161 If we do not do this, then we run the risk that the user will
1162 delete or disable the breakpoint, but the thread will have already
1165 struct regcache
*regcache
= get_thread_regcache (ptid
);
1166 struct gdbarch
*gdbarch
= regcache
->arch ();
1169 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1170 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1172 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1173 (unsigned long) ptid_get_tid (ptid
));
1175 /* Back up the PC if necessary. */
1176 if (gdbarch_decr_pc_after_break (gdbarch
))
1177 regcache_write_pc (regcache
, pc
);
1185 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1190 mach_msg_header_t hdr
;
1193 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1195 darwin_thread_t
*thread
;
1196 struct inferior
*inf
;
1199 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1200 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1202 /* Handle fake stop events at first. */
1203 if (darwin_inf_fake_stop
!= NULL
)
1205 inf
= darwin_inf_fake_stop
;
1206 darwin_inf_fake_stop
= NULL
;
1208 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1210 status
->kind
= TARGET_WAITKIND_STOPPED
;
1211 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1212 thread
= priv
->threads
[0];
1213 thread
->msg_state
= DARWIN_STOPPED
;
1214 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1219 /* set_sigint_trap (); */
1221 /* Wait for a message. */
1222 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1223 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1225 /* clear_sigint_trap (); */
1227 if (kret
== MACH_RCV_INTERRUPTED
)
1229 status
->kind
= TARGET_WAITKIND_IGNORE
;
1230 return minus_one_ptid
;
1233 if (kret
!= MACH_MSG_SUCCESS
)
1235 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1236 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1237 return minus_one_ptid
;
1240 /* Debug: display message. */
1241 if (darwin_debug_flag
> 10)
1242 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1244 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1245 if (ptid_equal (res
, minus_one_ptid
))
1248 /* Early return in case an inferior has exited. */
1252 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1254 /* Stop all tasks. */
1255 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1257 /* Read pending messages. */
1260 struct target_waitstatus status2
;
1263 kret
= mach_msg (&msgin
.hdr
,
1264 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1265 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1267 if (kret
== MACH_RCV_TIMED_OUT
)
1269 if (kret
!= MACH_MSG_SUCCESS
)
1272 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1276 /* Debug: display message. */
1277 if (darwin_debug_flag
> 10)
1278 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1280 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1282 if (inf
!= NULL
&& thread
!= NULL
1283 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1285 if (thread
->single_step
1286 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1288 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1289 darwin_send_reply (inf
, thread
);
1290 thread
->msg_state
= DARWIN_RUNNING
;
1294 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1298 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1304 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1307 return darwin_wait (ptid
, status
);
1311 darwin_nat_target::interrupt ()
1313 struct inferior
*inf
= current_inferior ();
1314 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1316 /* FIXME: handle in no_ptrace mode. */
1317 gdb_assert (!priv
->no_ptrace
);
1318 ::kill (inf
->pid
, SIGINT
);
1321 /* Deallocate threads port and vector. */
1324 darwin_deallocate_threads (struct inferior
*inf
)
1326 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1328 for (darwin_thread_t
*t
: priv
->threads
)
1330 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1331 MACH_CHECK_ERROR (kret
);
1334 priv
->threads
.clear ();
1338 darwin_nat_target::mourn_inferior ()
1340 struct inferior
*inf
= current_inferior ();
1341 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1346 /* Deallocate threads. */
1347 darwin_deallocate_threads (inf
);
1349 /* Remove notify_port from darwin_port_set. */
1350 kret
= mach_port_move_member (gdb_task
,
1351 priv
->notify_port
, MACH_PORT_NULL
);
1352 MACH_CHECK_ERROR (kret
);
1354 /* Remove task port dead_name notification. */
1355 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1356 MACH_NOTIFY_DEAD_NAME
, 0,
1358 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1360 /* This can fail if the task is dead. */
1361 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1362 priv
->task
, prev
, priv
->notify_port
);
1364 if (kret
== KERN_SUCCESS
)
1366 kret
= mach_port_deallocate (gdb_task
, prev
);
1367 MACH_CHECK_ERROR (kret
);
1370 /* Destroy notify_port. */
1371 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1372 MACH_CHECK_ERROR (kret
);
1374 /* Deallocate saved exception ports. */
1375 darwin_deallocate_exception_ports (priv
);
1377 /* Deallocate task port. */
1378 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1379 MACH_CHECK_ERROR (kret
);
1383 inf_child_target::mourn_inferior ();
1387 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1389 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1391 for (darwin_thread_t
*t
: priv
->threads
)
1393 if (t
->msg_state
== DARWIN_MESSAGE
)
1394 darwin_resume_thread (inf
, t
, 0, 0);
1399 darwin_stop_inferior (struct inferior
*inf
)
1401 struct target_waitstatus wstatus
;
1406 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1408 gdb_assert (inf
!= NULL
);
1410 darwin_suspend_inferior (inf
);
1412 darwin_reply_to_all_pending_messages (inf
);
1414 if (priv
->no_ptrace
)
1417 res
= kill (inf
->pid
, SIGSTOP
);
1419 warning (_("cannot kill: %s"), safe_strerror (errno
));
1421 /* Wait until the process is really stopped. */
1424 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1425 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1426 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1431 static kern_return_t
1432 darwin_save_exception_ports (darwin_inferior
*inf
)
1436 inf
->exception_info
.count
=
1437 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1439 kret
= task_get_exception_ports
1440 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1441 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1442 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1446 static kern_return_t
1447 darwin_restore_exception_ports (darwin_inferior
*inf
)
1452 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1454 kret
= task_set_exception_ports
1455 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1456 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1457 if (kret
!= KERN_SUCCESS
)
1461 return KERN_SUCCESS
;
1464 /* Deallocate saved exception ports. */
1467 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1472 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1474 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1475 MACH_CHECK_ERROR (kret
);
1477 inf
->exception_info
.count
= 0;
1481 darwin_setup_exceptions (struct inferior
*inf
)
1483 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1486 exception_mask_t mask
;
1488 kret
= darwin_save_exception_ports (priv
);
1489 if (kret
!= KERN_SUCCESS
)
1490 error (_("Unable to save exception ports, task_get_exception_ports"
1494 /* Set exception port. */
1495 if (enable_mach_exceptions
)
1496 mask
= EXC_MASK_ALL
;
1498 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1499 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1500 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1501 if (kret
!= KERN_SUCCESS
)
1502 error (_("Unable to set exception ports, task_set_exception_ports"
1508 darwin_nat_target::kill ()
1510 struct inferior
*inf
= current_inferior ();
1511 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1512 struct target_waitstatus wstatus
;
1518 if (ptid_equal (inferior_ptid
, null_ptid
))
1521 gdb_assert (inf
!= NULL
);
1523 kret
= darwin_restore_exception_ports (priv
);
1524 MACH_CHECK_ERROR (kret
);
1526 darwin_reply_to_all_pending_messages (inf
);
1528 res
= ::kill (inf
->pid
, 9);
1532 darwin_resume_inferior (inf
);
1534 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1536 else if (errno
!= ESRCH
)
1537 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1538 inf
->pid
, safe_strerror (errno
));
1540 target_mourn_inferior (inferior_ptid
);
1544 darwin_setup_request_notification (struct inferior
*inf
)
1546 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1548 mach_port_t prev_not
;
1550 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1551 MACH_NOTIFY_DEAD_NAME
, 0,
1553 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1555 if (kret
!= KERN_SUCCESS
)
1556 error (_("Termination notification request failed, "
1557 "mach_port_request_notification\n"
1560 if (prev_not
!= MACH_PORT_NULL
)
1562 /* This is unexpected, as there should not be any previously
1563 registered notification request. But this is not a fatal
1564 issue, so just emit a warning. */
1566 A task termination request was registered before the debugger registered\n\
1567 its own. This is unexpected, but should otherwise not have any actual\n\
1568 impact on the debugging session."));
1573 darwin_attach_pid (struct inferior
*inf
)
1576 mach_port_t prev_port
;
1578 mach_port_t prev_not
;
1579 exception_mask_t mask
;
1581 darwin_inferior
*priv
= new darwin_inferior
;
1582 inf
->priv
.reset (priv
);
1584 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1585 if (kret
!= KERN_SUCCESS
)
1589 if (!inf
->attach_flag
)
1592 waitpid (inf
->pid
, &status
, 0);
1595 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1596 " (please check gdb is codesigned - see taskgated(8))"),
1597 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1600 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1601 priv
->task
, inf
->pid
);
1603 if (darwin_ex_port
== MACH_PORT_NULL
)
1605 /* Create a port to get exceptions. */
1606 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1608 if (kret
!= KERN_SUCCESS
)
1609 error (_("Unable to create exception port, mach_port_allocate "
1613 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1614 MACH_MSG_TYPE_MAKE_SEND
);
1615 if (kret
!= KERN_SUCCESS
)
1616 error (_("Unable to create exception port, mach_port_insert_right "
1620 /* Create a port set and put ex_port in it. */
1621 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1623 if (kret
!= KERN_SUCCESS
)
1624 error (_("Unable to create port set, mach_port_allocate "
1628 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1629 if (kret
!= KERN_SUCCESS
)
1630 error (_("Unable to move exception port into new port set, "
1631 "mach_port_move_member\n"
1636 /* Create a port to be notified when the child task terminates. */
1637 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1638 &priv
->notify_port
);
1639 if (kret
!= KERN_SUCCESS
)
1640 error (_("Unable to create notification port, mach_port_allocate "
1644 kret
= mach_port_move_member (gdb_task
,
1645 priv
->notify_port
, darwin_port_set
);
1646 if (kret
!= KERN_SUCCESS
)
1647 error (_("Unable to move notification port into new port set, "
1648 "mach_port_move_member\n"
1652 darwin_setup_request_notification (inf
);
1654 darwin_setup_exceptions (inf
);
1656 target_ops
*darwin_ops
= get_native_target ();
1657 if (!target_is_pushed (darwin_ops
))
1658 push_target (darwin_ops
);
1661 /* Get the thread_info object corresponding to this darwin_thread_info. */
1663 static struct thread_info
*
1664 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1666 struct thread_info
*it
;
1670 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1672 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1676 gdb_assert (it
!= NULL
);
1682 darwin_init_thread_list (struct inferior
*inf
)
1684 darwin_check_new_threads (inf
);
1686 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1688 gdb_assert (!priv
->threads
.empty ());
1690 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1691 struct thread_info
*first_thread
1692 = thread_info_from_private_thread_info (first_pti
);
1694 inferior_ptid
= first_thread
->ptid
;
1697 /* The child must synchronize with gdb: gdb must set the exception port
1698 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1699 FIXME: is there a lighter way ? */
1700 static int ptrace_fds
[2];
1703 darwin_ptrace_me (void)
1708 /* Close write end point. */
1709 if (close (ptrace_fds
[1]) < 0)
1710 trace_start_error_with_name ("close");
1712 /* Wait until gdb is ready. */
1713 res
= read (ptrace_fds
[0], &c
, 1);
1715 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1717 if (close (ptrace_fds
[0]) < 0)
1718 trace_start_error_with_name ("close");
1720 /* Get rid of privileges. */
1721 if (setegid (getgid ()) < 0)
1722 trace_start_error_with_name ("setegid");
1725 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1726 trace_start_error_with_name ("PTRACE");
1728 /* Redirect signals to exception port. */
1729 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1730 trace_start_error_with_name ("PTRACE");
1733 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1735 darwin_pre_ptrace (void)
1737 if (pipe (ptrace_fds
) != 0)
1741 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1744 mark_fd_no_cloexec (ptrace_fds
[0]);
1745 mark_fd_no_cloexec (ptrace_fds
[1]);
1749 darwin_ptrace_him (int pid
)
1753 mach_port_t prev_port
;
1755 struct inferior
*inf
= current_inferior ();
1757 darwin_attach_pid (inf
);
1759 /* Let's the child run. */
1760 close (ptrace_fds
[0]);
1761 close (ptrace_fds
[1]);
1763 unmark_fd_no_cloexec (ptrace_fds
[0]);
1764 unmark_fd_no_cloexec (ptrace_fds
[1]);
1766 darwin_init_thread_list (inf
);
1768 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1772 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1774 posix_spawnattr_t attr
;
1778 res
= posix_spawnattr_init (&attr
);
1782 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1786 /* Do like execve: replace the image. */
1787 ps_flags
= POSIX_SPAWN_SETEXEC
;
1789 /* Disable ASLR. The constant doesn't look to be available outside the
1790 kernel include files. */
1791 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1792 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1794 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1795 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1798 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1802 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1806 darwin_nat_target::create_inferior (const char *exec_file
,
1807 const std::string
&allargs
,
1808 char **env
, int from_tty
)
1810 /* Do the hard work. */
1811 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1812 darwin_ptrace_him
, darwin_pre_ptrace
, NULL
,
1817 /* Set things up such that the next call to darwin_wait will immediately
1818 return a fake stop event for inferior INF.
1820 This assumes that the inferior's thread list has been initialized,
1821 as it will suspend the inferior's first thread. */
1824 darwin_setup_fake_stop_event (struct inferior
*inf
)
1826 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1827 darwin_thread_t
*thread
;
1830 gdb_assert (darwin_inf_fake_stop
== NULL
);
1831 darwin_inf_fake_stop
= inf
;
1833 /* When detecting a fake pending stop event, darwin_wait returns
1834 an event saying that the first thread is in a DARWIN_STOPPED
1835 state. To make that accurate, we need to suspend that thread
1836 as well. Otherwise, we'll try resuming it when resuming the
1837 inferior, and get a warning because the thread's suspend count
1838 is already zero, making the resume request useless. */
1839 thread
= priv
->threads
[0];
1840 kret
= thread_suspend (thread
->gdb_port
);
1841 MACH_CHECK_ERROR (kret
);
1844 /* Attach to process PID, then initialize for debugging it
1845 and wait for the trace-trap that results from attaching. */
1847 darwin_nat_target::attach (const char *args
, int from_tty
)
1853 struct inferior
*inf
;
1856 pid
= parse_pid_to_attach (args
);
1858 if (pid
== getpid ()) /* Trying to masturbate? */
1859 error (_("I refuse to debug myself!"));
1863 char *exec_file
= get_exec_file (0);
1866 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1867 target_pid_to_str (pid_to_ptid (pid
)));
1869 printf_unfiltered (_("Attaching to %s\n"),
1870 target_pid_to_str (pid_to_ptid (pid
)));
1872 gdb_flush (gdb_stdout
);
1875 if (pid
== 0 || ::kill (pid
, 0) < 0)
1876 error (_("Can't attach to process %d: %s (%d)"),
1877 pid
, safe_strerror (errno
), errno
);
1879 inferior_ptid
= pid_to_ptid (pid
);
1880 inf
= current_inferior ();
1881 inferior_appeared (inf
, pid
);
1882 inf
->attach_flag
= 1;
1884 darwin_attach_pid (inf
);
1886 darwin_suspend_inferior (inf
);
1888 darwin_init_thread_list (inf
);
1890 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1892 darwin_check_osabi (priv
, ptid_get_tid (inferior_ptid
));
1894 darwin_setup_fake_stop_event (inf
);
1896 priv
->no_ptrace
= 1;
1899 /* Take a program previously attached to and detaches it.
1900 The program resumes execution and will no longer stop
1901 on signals, etc. We'd better not have left any breakpoints
1902 in the program or it'll die when it hits one. For this
1903 to work, it may be necessary for the process to have been
1904 previously attached. It *might* work if the program was
1905 started via fork. */
1908 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
1910 pid_t pid
= ptid_get_pid (inferior_ptid
);
1911 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1915 /* Display message. */
1916 target_announce_detach (from_tty
);
1918 /* If ptrace() is in use, stop the process. */
1919 if (!priv
->no_ptrace
)
1920 darwin_stop_inferior (inf
);
1922 kret
= darwin_restore_exception_ports (priv
);
1923 MACH_CHECK_ERROR (kret
);
1925 if (!priv
->no_ptrace
)
1927 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1929 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1930 inf
->pid
, safe_strerror (errno
), errno
);
1933 darwin_reply_to_all_pending_messages (inf
);
1935 /* When using ptrace, we have just performed a PT_DETACH, which
1936 resumes the inferior. On the other hand, when we are not using
1937 ptrace, we need to resume its execution ourselves. */
1938 if (priv
->no_ptrace
)
1939 darwin_resume_inferior (inf
);
1945 darwin_nat_target::pid_to_str (ptid_t ptid
)
1947 static char buf
[80];
1948 long tid
= ptid_get_tid (ptid
);
1952 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1953 tid
, ptid_get_pid (ptid
));
1957 return normal_pid_to_str (ptid
);
1961 darwin_nat_target::thread_alive (ptid_t ptid
)
1966 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1967 copy it to RDADDR in gdb's address space.
1968 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1969 to ADDR in inferior task's address space.
1970 Return 0 on failure; number of bytes read / writen otherwise. */
1973 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
1974 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
1978 mach_vm_size_t res_length
= 0;
1980 mach_msg_type_number_t copy_count
;
1981 mach_vm_size_t remaining_length
;
1982 mach_vm_address_t region_address
;
1983 mach_vm_size_t region_length
;
1985 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
1986 task
, core_addr_to_string (addr
), pulongest (length
));
1991 mach_vm_size_t count
;
1993 /* According to target.h(to_xfer_partial), one and only one may be
1995 gdb_assert (wraddr
== NULL
);
1997 kret
= mach_vm_read_overwrite (task
, addr
, length
,
1998 (mach_vm_address_t
) rdaddr
, &count
);
1999 if (kret
!= KERN_SUCCESS
)
2002 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2003 core_addr_to_string (addr
), mach_error_string (kret
));
2010 gdb_assert (wraddr
!= NULL
);
2014 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2015 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2016 mach_vm_size_t aligned_length
=
2017 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2018 vm_region_submap_short_info_data_64_t info
;
2019 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2020 natural_t region_depth
= 1000;
2021 mach_vm_address_t region_start
= region_address
;
2022 mach_vm_size_t region_length
;
2023 mach_vm_size_t write_length
;
2025 /* Read page protection. */
2026 kret
= mach_vm_region_recurse
2027 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2028 (vm_region_recurse_info_t
) &info
, &count
);
2030 if (kret
!= KERN_SUCCESS
)
2032 inferior_debug (1, _("darwin_read_write_inferior: "
2033 "mach_vm_region_recurse failed at %s: %s\n"),
2034 core_addr_to_string (region_address
),
2035 mach_error_string (kret
));
2040 (9, _("darwin_read_write_inferior: "
2041 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2042 core_addr_to_string (region_address
),
2043 core_addr_to_string (region_start
),
2044 core_addr_to_string (region_length
));
2046 /* Check for holes in memory. */
2047 if (region_start
> region_address
)
2049 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2050 core_addr_to_string (region_address
),
2051 core_addr_to_string (region_start
),
2052 (unsigned)region_length
);
2056 /* Adjust the length. */
2057 region_length
-= (region_address
- region_start
);
2058 if (region_length
> aligned_length
)
2059 region_length
= aligned_length
;
2061 /* Make the pages RW. */
2062 if (!(info
.protection
& VM_PROT_WRITE
))
2064 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2066 kret
= mach_vm_protect (task
, region_address
, region_length
,
2068 if (kret
!= KERN_SUCCESS
)
2070 prot
|= VM_PROT_COPY
;
2071 kret
= mach_vm_protect (task
, region_address
, region_length
,
2074 if (kret
!= KERN_SUCCESS
)
2076 warning (_("darwin_read_write_inferior: "
2077 "mach_vm_protect failed at %s "
2078 "(len=0x%lx, prot=0x%x): %s"),
2079 core_addr_to_string (region_address
),
2080 (unsigned long) region_length
, (unsigned) prot
,
2081 mach_error_string (kret
));
2086 if (offset
+ length
> region_length
)
2087 write_length
= region_length
- offset
;
2089 write_length
= length
;
2092 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2093 if (kret
!= KERN_SUCCESS
)
2095 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2096 mach_error_string (kret
));
2100 /* Restore page rights. */
2101 if (!(info
.protection
& VM_PROT_WRITE
))
2103 kret
= mach_vm_protect (task
, region_address
, region_length
,
2104 FALSE
, info
.protection
);
2105 if (kret
!= KERN_SUCCESS
)
2107 warning (_("darwin_read_write_inferior: "
2108 "mach_vm_protect restore failed at %s "
2110 core_addr_to_string (region_address
),
2111 (unsigned long) region_length
,
2112 mach_error_string (kret
));
2116 addr
+= write_length
;
2117 wraddr
+= write_length
;
2118 res_length
+= write_length
;
2119 length
-= write_length
;
2125 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2126 to RDADDR (in big endian).
2127 Return 0 on failure; number of bytes read / written otherwise. */
2129 #ifdef TASK_DYLD_INFO_COUNT
2130 /* This is not available in Darwin 9. */
2131 static enum target_xfer_status
2132 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2133 ULONGEST length
, ULONGEST
*xfered_len
)
2135 struct task_dyld_info task_dyld_info
;
2136 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2137 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
2140 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2141 return TARGET_XFER_EOF
;
2143 kret
= task_info (task
, TASK_DYLD_INFO
,
2144 (task_info_t
) &task_dyld_info
, &count
);
2145 MACH_CHECK_ERROR (kret
);
2146 if (kret
!= KERN_SUCCESS
)
2147 return TARGET_XFER_E_IO
;
2149 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2150 task_dyld_info
.all_image_info_addr
);
2151 *xfered_len
= (ULONGEST
) length
;
2152 return TARGET_XFER_OK
;
2158 enum target_xfer_status
2159 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2160 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2161 ULONGEST offset
, ULONGEST len
,
2162 ULONGEST
*xfered_len
)
2164 struct inferior
*inf
= current_inferior ();
2165 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2168 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2169 core_addr_to_string (offset
), pulongest (len
),
2170 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2175 case TARGET_OBJECT_MEMORY
:
2177 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2178 readbuf
, writebuf
, len
);
2181 return TARGET_XFER_EOF
;
2185 *xfered_len
= (ULONGEST
) l
;
2186 return TARGET_XFER_OK
;
2189 #ifdef TASK_DYLD_INFO_COUNT
2190 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2191 if (writebuf
!= NULL
|| readbuf
== NULL
)
2193 /* Support only read. */
2194 return TARGET_XFER_E_IO
;
2196 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2200 return TARGET_XFER_E_IO
;
2206 set_enable_mach_exceptions (const char *args
, int from_tty
,
2207 struct cmd_list_element
*c
)
2209 if (!ptid_equal (inferior_ptid
, null_ptid
))
2211 struct inferior
*inf
= current_inferior ();
2212 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2213 exception_mask_t mask
;
2216 if (enable_mach_exceptions
)
2217 mask
= EXC_MASK_ALL
;
2220 darwin_restore_exception_ports (priv
);
2221 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2223 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2224 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2225 MACH_CHECK_ERROR (kret
);
2230 darwin_nat_target::pid_to_exec_file (int pid
)
2232 static char path
[PATH_MAX
];
2235 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2243 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2245 struct inferior
*inf
= current_inferior ();
2246 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2248 mach_port_name_array_t names
;
2249 mach_msg_type_number_t names_count
;
2250 mach_port_type_array_t types
;
2251 mach_msg_type_number_t types_count
;
2254 /* First linear search. */
2255 for (darwin_thread_t
*t
: priv
->threads
)
2257 if (t
->inf_port
== lwp
)
2258 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2261 /* Maybe the port was never extract. Do it now. */
2263 /* First get inferior port names. */
2264 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2266 MACH_CHECK_ERROR (kret
);
2267 if (kret
!= KERN_SUCCESS
)
2270 /* For each name, copy the right in the gdb space and then compare with
2271 our view of the inferior threads. We don't forget to deallocate the
2273 for (int i
= 0; i
< names_count
; i
++)
2275 mach_port_t local_name
;
2276 mach_msg_type_name_t local_type
;
2278 /* We just need to know the corresponding name in gdb name space.
2279 So extract and deallocate the right. */
2280 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2281 MACH_MSG_TYPE_COPY_SEND
,
2282 &local_name
, &local_type
);
2283 if (kret
!= KERN_SUCCESS
)
2285 mach_port_deallocate (gdb_task
, local_name
);
2287 for (darwin_thread_t
*t
: priv
->threads
)
2289 if (t
->gdb_port
== local_name
)
2291 t
->inf_port
= names
[i
];
2292 if (names
[i
] == lwp
)
2298 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2299 names_count
* sizeof (mach_port_t
));
2302 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2308 darwin_nat_target::supports_multi_process ()
2314 _initialize_darwin_nat ()
2318 gdb_task
= mach_task_self ();
2319 darwin_host_self
= mach_host_self ();
2321 /* Read page size. */
2322 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2323 if (kret
!= KERN_SUCCESS
)
2325 mach_page_size
= 0x1000;
2326 MACH_CHECK_ERROR (kret
);
2329 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2330 (unsigned long) mach_task_self (), getpid ());
2332 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2333 &darwin_debug_flag
, _("\
2334 Set if printing inferior communication debugging statements."), _("\
2335 Show if printing inferior communication debugging statements."), NULL
,
2337 &setdebuglist
, &showdebuglist
);
2339 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2340 &enable_mach_exceptions
, _("\
2341 Set if mach exceptions are caught."), _("\
2342 Show if mach exceptions are caught."), _("\
2343 When this mode is on, all low level exceptions are reported before being\n\
2344 reported by the kernel."),
2345 &set_enable_mach_exceptions
, NULL
,
2346 &setlist
, &showlist
);