1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2015 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "gdbthread.h"
33 #include "event-top.h"
36 #include "inf-child.h"
38 #include "arch-utils.h"
40 #include "bfd/mach-o.h"
42 #include <sys/ptrace.h>
43 #include <sys/signal.h>
45 #include <sys/types.h>
49 #include <sys/sysctl.h>
52 #include <sys/syscall.h>
55 #include <mach/mach_error.h>
56 #include <mach/mach_vm.h>
57 #include <mach/mach_init.h>
58 #include <mach/vm_map.h>
59 #include <mach/task.h>
60 #include <mach/mach_port.h>
61 #include <mach/thread_act.h>
62 #include <mach/port.h>
64 #include "darwin-nat.h"
65 #include "common/filestuff.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 void darwin_interrupt (struct target_ops
*self
, ptid_t
);
88 static void darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
89 enum gdb_signal signal
);
90 static void darwin_resume (ptid_t ptid
, int step
,
91 enum gdb_signal signal
);
93 static ptid_t
darwin_wait_to (struct target_ops
*ops
, ptid_t ptid
,
94 struct target_waitstatus
*status
, int options
);
95 static ptid_t
darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
);
97 static void darwin_mourn_inferior (struct target_ops
*ops
);
99 static void darwin_kill_inferior (struct target_ops
*ops
);
101 static void darwin_ptrace_me (void);
103 static void darwin_ptrace_him (int pid
);
105 static void darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
106 char *allargs
, char **env
, int from_tty
);
108 static void darwin_files_info (struct target_ops
*ops
);
110 static char *darwin_pid_to_str (struct target_ops
*ops
, ptid_t tpid
);
112 static int darwin_thread_alive (struct target_ops
*ops
, ptid_t tpid
);
114 static void darwin_encode_reply (mig_reply_error_t
*reply
,
115 mach_msg_header_t
*hdr
, integer_t code
);
117 /* Target operations for Darwin. */
118 static struct target_ops
*darwin_ops
;
120 /* Task identifier of gdb. */
121 static task_t gdb_task
;
123 /* A copy of mach_host_self (). */
124 mach_port_t darwin_host_self
;
126 /* Exception port. */
127 mach_port_t darwin_ex_port
;
129 /* Port set, to wait for answer on all ports. */
130 mach_port_t darwin_port_set
;
133 static vm_size_t mach_page_size
;
135 /* If Set, catch all mach exceptions (before they are converted to signals
137 static int enable_mach_exceptions
;
139 /* Inferior that should report a fake stop event. */
140 static struct inferior
*darwin_inf_fake_stop
;
142 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
143 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
145 /* This controls output of inferior debugging. */
146 static unsigned int darwin_debug_flag
= 0;
148 /* Create a __TEXT __info_plist section in the executable so that gdb could
149 be signed. This is required to get an authorization for task_for_pid.
151 Once gdb is built, you must codesign it with any system-trusted signing
152 authority. See taskgated(8) for details. */
153 static const unsigned char info_plist
[]
154 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
155 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
156 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
157 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
158 "<plist version=\"1.0\">\n"
160 " <key>CFBundleIdentifier</key>\n"
161 " <string>org.gnu.gdb</string>\n"
162 " <key>CFBundleName</key>\n"
163 " <string>gdb</string>\n"
164 " <key>CFBundleVersion</key>\n"
165 " <string>1.0</string>\n"
166 " <key>SecTaskAccess</key>\n"
168 " <string>allowed</string>\n"
169 " <string>debug</string>\n"
174 static void inferior_debug (int level
, const char *fmt
, ...)
175 ATTRIBUTE_PRINTF (2, 3);
178 inferior_debug (int level
, const char *fmt
, ...)
182 if (darwin_debug_flag
< level
)
186 printf_unfiltered (_("[%d inferior]: "), getpid ());
187 vprintf_unfiltered (fmt
, ap
);
192 mach_check_error (kern_return_t ret
, const char *file
,
193 unsigned int line
, const char *func
)
195 if (ret
== KERN_SUCCESS
)
198 func
= _("[UNKNOWN]");
200 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
201 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
205 unparse_exception_type (unsigned int i
)
207 static char unknown_exception_buf
[32];
212 return "EXC_BAD_ACCESS";
213 case EXC_BAD_INSTRUCTION
:
214 return "EXC_BAD_INSTRUCTION";
216 return "EXC_ARITHMETIC";
218 return "EXC_EMULATION";
220 return "EXC_SOFTWARE";
222 return "EXC_BREAKPOINT";
224 return "EXC_SYSCALL";
225 case EXC_MACH_SYSCALL
:
226 return "EXC_MACH_SYSCALL";
228 return "EXC_RPC_ALERT";
232 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
233 return unknown_exception_buf
;
237 /* Set errno to zero, and then call ptrace with the given arguments.
238 If inferior debugging traces are on, then also print a debug
241 The returned value is the same as the value returned by ptrace,
242 except in the case where that value is -1 but errno is zero.
243 This case is documented to be a non-error situation, so we
244 return zero in that case. */
247 darwin_ptrace (const char *name
,
248 int request
, int pid
, PTRACE_TYPE_ARG3 arg3
, int arg4
)
253 ret
= ptrace (request
, pid
, (caddr_t
) arg3
, arg4
);
254 if (ret
== -1 && errno
== 0)
257 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
258 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
259 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
264 cmp_thread_t (const void *l
, const void *r
)
266 thread_t tl
= *(const thread_t
*)l
;
267 thread_t tr
= *(const thread_t
*)r
;
268 return (int)(tl
- tr
);
272 darwin_check_new_threads (struct inferior
*inf
)
276 thread_array_t thread_list
;
277 unsigned int new_nbr
;
278 unsigned int old_nbr
;
279 unsigned int new_ix
, old_ix
;
280 darwin_inferior
*darwin_inf
= inf
->priv
;
281 VEC (darwin_thread_t
) *thread_vec
;
283 /* Get list of threads. */
284 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
285 MACH_CHECK_ERROR (kret
);
286 if (kret
!= KERN_SUCCESS
)
291 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
293 if (darwin_inf
->threads
)
294 old_nbr
= VEC_length (darwin_thread_t
, darwin_inf
->threads
);
298 /* Quick check for no changes. */
299 if (old_nbr
== new_nbr
)
301 for (i
= 0; i
< new_nbr
; i
++)
303 != VEC_index (darwin_thread_t
, darwin_inf
->threads
, i
)->gdb_port
)
307 /* Deallocate ports. */
308 for (i
= 0; i
< new_nbr
; i
++)
310 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
311 MACH_CHECK_ERROR (kret
);
314 /* Deallocate the buffer. */
315 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
316 new_nbr
* sizeof (int));
317 MACH_CHECK_ERROR (kret
);
323 thread_vec
= VEC_alloc (darwin_thread_t
, new_nbr
);
325 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
327 thread_t new_id
= (new_ix
< new_nbr
) ?
328 thread_list
[new_ix
] : THREAD_NULL
;
329 darwin_thread_t
*old
= (old_ix
< old_nbr
) ?
330 VEC_index (darwin_thread_t
, darwin_inf
->threads
, old_ix
) : NULL
;
331 thread_t old_id
= old
? old
->gdb_port
: THREAD_NULL
;
334 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
335 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
337 if (old_id
== new_id
)
339 /* Thread still exist. */
340 VEC_safe_push (darwin_thread_t
, thread_vec
, old
);
344 /* Deallocate the port. */
345 kret
= mach_port_deallocate (gdb_task
, new_id
);
346 MACH_CHECK_ERROR (kret
);
350 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
352 /* Ignore dead ports.
353 In some weird cases, we might get dead ports. They should
354 correspond to dead thread so they could safely be ignored. */
358 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
360 /* A thread was created. */
361 struct thread_info
*tp
;
362 struct private_thread_info
*pti
;
364 pti
= XCNEW (struct private_thread_info
);
365 pti
->gdb_port
= new_id
;
366 pti
->msg_state
= DARWIN_RUNNING
;
368 /* Add a new thread unless this is the first one ever met. */
369 if (!(old_nbr
== 0 && new_ix
== 0))
370 tp
= add_thread_with_info (ptid_build (inf
->pid
, 0, new_id
), pti
);
373 tp
= find_thread_ptid (ptid_build (inf
->pid
, 0, 0));
377 VEC_safe_push (darwin_thread_t
, thread_vec
, pti
);
381 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
383 /* A thread was removed. */
384 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
385 kret
= mach_port_deallocate (gdb_task
, old_id
);
386 MACH_CHECK_ERROR (kret
);
390 gdb_assert_not_reached ("unexpected thread case");
393 if (darwin_inf
->threads
)
394 VEC_free (darwin_thread_t
, darwin_inf
->threads
);
395 darwin_inf
->threads
= thread_vec
;
397 /* Deallocate the buffer. */
398 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
399 new_nbr
* sizeof (int));
400 MACH_CHECK_ERROR (kret
);
404 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
406 return inf
->priv
->task
== *(task_t
*)port_ptr
;
410 find_inferior_notify_it (struct inferior
*inf
, void *port_ptr
)
412 return inf
->priv
->notify_port
== *(task_t
*)port_ptr
;
415 /* Return an inferior by task port. */
416 static struct inferior
*
417 darwin_find_inferior_by_task (task_t port
)
419 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
422 /* Return an inferior by notification port. */
423 static struct inferior
*
424 darwin_find_inferior_by_notify (mach_port_t port
)
426 return iterate_over_inferiors (&find_inferior_notify_it
, &port
);
429 /* Return a thread by port. */
430 static darwin_thread_t
*
431 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
437 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
439 if (t
->gdb_port
== thread
)
444 /* Suspend (ie stop) an inferior at Mach level. */
447 darwin_suspend_inferior (struct inferior
*inf
)
449 if (!inf
->priv
->suspended
)
453 kret
= task_suspend (inf
->priv
->task
);
454 MACH_CHECK_ERROR (kret
);
456 inf
->priv
->suspended
= 1;
460 /* Resume an inferior at Mach level. */
463 darwin_resume_inferior (struct inferior
*inf
)
465 if (inf
->priv
->suspended
)
469 kret
= task_resume (inf
->priv
->task
);
470 MACH_CHECK_ERROR (kret
);
472 inf
->priv
->suspended
= 0;
476 /* Iterator functions. */
479 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
481 darwin_suspend_inferior (inf
);
482 darwin_check_new_threads (inf
);
487 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
489 darwin_resume_inferior (inf
);
494 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
496 printf_unfiltered (_("message header:\n"));
497 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
498 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
499 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
500 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
501 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
502 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
506 const unsigned char *data
;
507 const unsigned int *ldata
;
511 data
= (unsigned char *)(hdr
+ 1);
512 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
514 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
516 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
517 mach_msg_port_descriptor_t
*desc
=
518 (mach_msg_port_descriptor_t
*)(bod
+ 1);
521 printf_unfiltered (_("body: descriptor_count=%u\n"),
522 bod
->msgh_descriptor_count
);
523 data
+= sizeof (mach_msg_body_t
);
524 size
-= sizeof (mach_msg_body_t
);
525 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
526 switch (desc
[k
].type
)
528 case MACH_MSG_PORT_DESCRIPTOR
:
530 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
531 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
534 printf_unfiltered (_(" descr %d: type=%u\n"),
538 data
+= bod
->msgh_descriptor_count
539 * sizeof (mach_msg_port_descriptor_t
);
540 size
-= bod
->msgh_descriptor_count
541 * sizeof (mach_msg_port_descriptor_t
);
542 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
544 (_("NDR: mig=%02x if=%02x encod=%02x "
545 "int=%02x char=%02x float=%02x\n"),
546 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
547 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
548 data
+= sizeof (NDR_record_t
);
549 size
-= sizeof (NDR_record_t
);
552 printf_unfiltered (_(" data:"));
553 ldata
= (const unsigned int *)data
;
554 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
555 printf_unfiltered (" %08x", ldata
[i
]);
556 printf_unfiltered (_("\n"));
561 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
562 struct inferior
**pinf
,
563 darwin_thread_t
**pthread
)
565 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
566 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
569 struct inferior
*inf
;
570 darwin_thread_t
*thread
;
572 thread_t thread_port
;
576 /* Check message destination. */
577 if (hdr
->msgh_local_port
!= darwin_ex_port
)
580 /* Check message header. */
581 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
584 /* Check descriptors. */
585 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
586 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
587 || bod
->msgh_descriptor_count
!= 2
588 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
589 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
590 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
591 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
594 /* Check data representation. */
595 ndr
= (NDR_record_t
*)(desc
+ 2);
596 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
597 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
598 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
599 || ndr
->int_rep
!= NDR_record
.int_rep
600 || ndr
->char_rep
!= NDR_record
.char_rep
601 || ndr
->float_rep
!= NDR_record
.float_rep
)
604 /* Ok, the hard work. */
605 data
= (integer_t
*)(ndr
+ 1);
607 task_port
= desc
[1].name
;
608 thread_port
= desc
[0].name
;
610 /* We got new rights to the task, get rid of it. Do not get rid of thread
611 right, as we will need it to find the thread. */
612 kret
= mach_port_deallocate (mach_task_self (), task_port
);
613 MACH_CHECK_ERROR (kret
);
615 /* Find process by port. */
616 inf
= darwin_find_inferior_by_task (task_port
);
620 /* Not a known inferior. This could happen if the child fork, as
621 the created process will inherit its exception port.
622 FIXME: should the exception port be restored ? */
624 mig_reply_error_t reply
;
626 /* Free thread port (we don't know it). */
627 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
628 MACH_CHECK_ERROR (kret
);
630 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
632 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
633 reply
.Head
.msgh_size
, 0,
634 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
636 MACH_CHECK_ERROR (kret
);
641 /* Find thread by port. */
642 /* Check for new threads. Do it early so that the port in the exception
643 message can be deallocated. */
644 darwin_check_new_threads (inf
);
646 /* Free the thread port (as gdb knows the thread, it has already has a right
647 for it, so this just decrement a reference counter). */
648 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
649 MACH_CHECK_ERROR (kret
);
651 thread
= darwin_find_thread (inf
, thread_port
);
656 /* The thread should be running. However we have observed cases where a
657 thread got a SIGTTIN message after being stopped. */
658 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
660 /* Finish decoding. */
661 thread
->event
.header
= *hdr
;
662 thread
->event
.thread_port
= thread_port
;
663 thread
->event
.task_port
= task_port
;
664 thread
->event
.ex_type
= data
[0];
665 thread
->event
.data_count
= data
[1];
667 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
668 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
669 + data
[1] * sizeof (integer_t
)))
671 for (i
= 0; i
< data
[1]; i
++)
672 thread
->event
.ex_data
[i
] = data
[2 + i
];
674 thread
->msg_state
= DARWIN_MESSAGE
;
680 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
683 mach_msg_header_t
*rh
= &reply
->Head
;
685 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
686 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
687 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
688 rh
->msgh_local_port
= MACH_PORT_NULL
;
689 rh
->msgh_id
= hdr
->msgh_id
+ 100;
691 reply
->NDR
= NDR_record
;
692 reply
->RetCode
= code
;
696 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
699 mig_reply_error_t reply
;
701 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
703 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
704 reply
.Head
.msgh_size
, 0,
705 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
707 MACH_CHECK_ERROR (kret
);
709 inf
->priv
->pending_messages
--;
713 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
714 int step
, int nsignal
)
720 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
721 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
723 switch (thread
->msg_state
)
726 if (thread
->event
.ex_type
== EXC_SOFTWARE
727 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
729 /* Either deliver a new signal or cancel the signal received. */
730 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
731 (void *)(uintptr_t)thread
->gdb_port
, nsignal
);
733 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
737 /* Note: ptrace is allowed only if the process is stopped.
738 Directly send the signal to the thread. */
739 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
740 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
741 thread
->gdb_port
, nsignal
, res
);
742 thread
->signaled
= 1;
745 /* Set or reset single step. */
746 if (step
!= thread
->single_step
)
748 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
749 thread
->gdb_port
, step
);
750 darwin_set_sstep (thread
->gdb_port
, step
);
751 thread
->single_step
= step
;
754 darwin_send_reply (inf
, thread
);
755 thread
->msg_state
= DARWIN_RUNNING
;
762 kret
= thread_resume (thread
->gdb_port
);
763 MACH_CHECK_ERROR (kret
);
765 thread
->msg_state
= DARWIN_RUNNING
;
770 /* Resume all threads of the inferior. */
773 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
775 darwin_thread_t
*thread
;
779 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, thread
);
781 darwin_resume_thread (inf
, thread
, step
, nsignal
);
784 struct resume_inferior_threads_param
791 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
793 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
794 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
796 darwin_resume_inferior_threads (inf
, step
, nsignal
);
801 /* Suspend all threads of INF. */
804 darwin_suspend_inferior_threads (struct inferior
*inf
)
806 darwin_thread_t
*thread
;
811 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, thread
);
813 switch (thread
->msg_state
)
819 kret
= thread_suspend (thread
->gdb_port
);
820 MACH_CHECK_ERROR (kret
);
821 thread
->msg_state
= DARWIN_STOPPED
;
827 darwin_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
829 struct target_waitstatus status
;
835 struct inferior
*inf
;
838 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
839 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
841 if (signal
== GDB_SIGNAL_0
)
844 nsignal
= gdb_signal_to_host (signal
);
846 /* Don't try to single step all threads. */
848 ptid
= inferior_ptid
;
850 /* minus_one_ptid is RESUME_ALL. */
851 if (ptid_equal (ptid
, minus_one_ptid
))
853 struct resume_inferior_threads_param param
;
855 param
.nsignal
= nsignal
;
858 /* Resume threads. */
859 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
861 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
865 struct inferior
*inf
= find_inferior_ptid (ptid
);
866 long tid
= ptid_get_tid (ptid
);
868 /* Stop the inferior (should be useless). */
869 darwin_suspend_inferior (inf
);
872 darwin_resume_inferior_threads (inf
, step
, nsignal
);
875 darwin_thread_t
*thread
;
877 /* Suspend threads of the task. */
878 darwin_suspend_inferior_threads (inf
);
880 /* Resume the selected thread. */
881 thread
= darwin_find_thread (inf
, tid
);
883 darwin_resume_thread (inf
, thread
, step
, nsignal
);
886 /* Resume the task. */
887 darwin_resume_inferior (inf
);
892 darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
893 enum gdb_signal signal
)
895 return darwin_resume (ptid
, step
, signal
);
899 darwin_decode_message (mach_msg_header_t
*hdr
,
900 darwin_thread_t
**pthread
,
901 struct inferior
**pinf
,
902 struct target_waitstatus
*status
)
904 darwin_thread_t
*thread
;
905 struct inferior
*inf
;
907 /* Exception message. 2401 == 0x961 is exc. */
908 if (hdr
->msgh_id
== 2401)
912 /* Decode message. */
913 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
917 /* Should not happen... */
919 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
920 /* FIXME: send a failure reply? */
921 status
->kind
= TARGET_WAITKIND_IGNORE
;
922 return minus_one_ptid
;
926 status
->kind
= TARGET_WAITKIND_IGNORE
;
927 return minus_one_ptid
;
931 inf
->priv
->pending_messages
++;
933 status
->kind
= TARGET_WAITKIND_STOPPED
;
934 thread
->msg_state
= DARWIN_MESSAGE
;
936 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
938 unparse_exception_type (thread
->event
.ex_type
));
940 switch (thread
->event
.ex_type
)
943 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
945 case EXC_BAD_INSTRUCTION
:
946 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
949 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
952 status
->value
.sig
= GDB_EXC_EMULATION
;
955 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
958 gdb_signal_from_host (thread
->event
.ex_data
[1]);
959 inferior_debug (5, _(" (signal %d: %s)\n"),
960 thread
->event
.ex_data
[1],
961 gdb_signal_to_name (status
->value
.sig
));
963 /* If the thread is stopped because it has received a signal
964 that gdb has just sent, continue. */
965 if (thread
->signaled
)
967 thread
->signaled
= 0;
968 darwin_send_reply (inf
, thread
);
969 thread
->msg_state
= DARWIN_RUNNING
;
970 status
->kind
= TARGET_WAITKIND_IGNORE
;
974 status
->value
.sig
= GDB_EXC_SOFTWARE
;
977 /* Many internal GDB routines expect breakpoints to be reported
978 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
979 as a spurious signal. */
980 status
->value
.sig
= GDB_SIGNAL_TRAP
;
983 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
987 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
989 else if (hdr
->msgh_id
== 0x48)
991 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
995 inf
= darwin_find_inferior_by_notify (hdr
->msgh_local_port
);
998 if (!inf
->priv
->no_ptrace
)
1003 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1004 if (res
< 0 || res
!= inf
->pid
)
1006 printf_unfiltered (_("wait4: res=%d: %s\n"),
1007 res
, safe_strerror (errno
));
1008 status
->kind
= TARGET_WAITKIND_IGNORE
;
1009 return minus_one_ptid
;
1011 if (WIFEXITED (wstatus
))
1013 status
->kind
= TARGET_WAITKIND_EXITED
;
1014 status
->value
.integer
= WEXITSTATUS (wstatus
);
1018 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1019 status
->value
.sig
= WTERMSIG (wstatus
);
1022 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1025 /* Looks necessary on Leopard and harmless... */
1026 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1028 return ptid_build (inf
->pid
, 0, 0);
1032 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1033 status
->kind
= TARGET_WAITKIND_EXITED
;
1034 status
->value
.integer
= 0; /* Don't know. */
1035 return ptid_build (inf
->pid
, 0, 0);
1040 /* Unknown message. */
1041 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1042 status
->kind
= TARGET_WAITKIND_IGNORE
;
1043 return minus_one_ptid
;
1047 cancel_breakpoint (ptid_t ptid
)
1049 /* Arrange for a breakpoint to be hit again later. We will handle
1050 the current event, eventually we will resume this thread, and this
1051 breakpoint will trap again.
1053 If we do not do this, then we run the risk that the user will
1054 delete or disable the breakpoint, but the thread will have already
1057 struct regcache
*regcache
= get_thread_regcache (ptid
);
1058 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1061 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1062 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
1064 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1065 (unsigned long) ptid_get_tid (ptid
));
1067 /* Back up the PC if necessary. */
1068 if (gdbarch_decr_pc_after_break (gdbarch
))
1069 regcache_write_pc (regcache
, pc
);
1077 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1082 mach_msg_header_t hdr
;
1085 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1087 darwin_thread_t
*thread
;
1088 struct inferior
*inf
;
1091 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1092 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1094 /* Handle fake stop events at first. */
1095 if (darwin_inf_fake_stop
!= NULL
)
1097 inf
= darwin_inf_fake_stop
;
1098 darwin_inf_fake_stop
= NULL
;
1100 status
->kind
= TARGET_WAITKIND_STOPPED
;
1101 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1102 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1103 thread
->msg_state
= DARWIN_STOPPED
;
1104 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1109 /* set_sigint_trap (); */
1111 /* Wait for a message. */
1112 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1113 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1115 /* clear_sigint_trap (); */
1117 if (kret
== MACH_RCV_INTERRUPTED
)
1119 status
->kind
= TARGET_WAITKIND_IGNORE
;
1120 return minus_one_ptid
;
1123 if (kret
!= MACH_MSG_SUCCESS
)
1125 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1126 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1127 return minus_one_ptid
;
1130 /* Debug: display message. */
1131 if (darwin_debug_flag
> 10)
1132 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1134 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1135 if (ptid_equal (res
, minus_one_ptid
))
1138 /* Early return in case an inferior has exited. */
1142 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1144 /* Stop all tasks. */
1145 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1147 /* Read pending messages. */
1150 struct target_waitstatus status2
;
1153 kret
= mach_msg (&msgin
.hdr
,
1154 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1155 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1157 if (kret
== MACH_RCV_TIMED_OUT
)
1159 if (kret
!= MACH_MSG_SUCCESS
)
1162 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1166 /* Debug: display message. */
1167 if (darwin_debug_flag
> 10)
1168 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1170 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1172 if (inf
!= NULL
&& thread
!= NULL
1173 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1175 if (thread
->single_step
1176 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1178 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1179 darwin_send_reply (inf
, thread
);
1180 thread
->msg_state
= DARWIN_RUNNING
;
1184 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1188 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1194 darwin_wait_to (struct target_ops
*ops
,
1195 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1197 return darwin_wait (ptid
, status
);
1201 darwin_interrupt (struct target_ops
*self
, ptid_t t
)
1203 struct inferior
*inf
= current_inferior ();
1205 /* FIXME: handle in no_ptrace mode. */
1206 gdb_assert (!inf
->priv
->no_ptrace
);
1207 kill (inf
->pid
, SIGINT
);
1211 darwin_mourn_inferior (struct target_ops
*ops
)
1213 struct inferior
*inf
= current_inferior ();
1218 /* Deallocate threads. */
1219 if (inf
->priv
->threads
)
1224 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
1227 kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1228 MACH_CHECK_ERROR (kret
);
1230 VEC_free (darwin_thread_t
, inf
->priv
->threads
);
1231 inf
->priv
->threads
= NULL
;
1234 kret
= mach_port_move_member (gdb_task
,
1235 inf
->priv
->notify_port
, MACH_PORT_NULL
);
1236 MACH_CHECK_ERROR (kret
);
1238 kret
= mach_port_request_notification (gdb_task
, inf
->priv
->task
,
1239 MACH_NOTIFY_DEAD_NAME
, 0,
1241 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1243 /* This can fail if the task is dead. */
1244 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1245 inf
->priv
->task
, prev
, inf
->priv
->notify_port
);
1247 if (kret
== KERN_SUCCESS
)
1249 kret
= mach_port_deallocate (gdb_task
, prev
);
1250 MACH_CHECK_ERROR (kret
);
1253 kret
= mach_port_destroy (gdb_task
, inf
->priv
->notify_port
);
1254 MACH_CHECK_ERROR (kret
);
1257 /* Deallocate saved exception ports. */
1258 for (i
= 0; i
< inf
->priv
->exception_info
.count
; i
++)
1260 kret
= mach_port_deallocate
1261 (gdb_task
, inf
->priv
->exception_info
.ports
[i
]);
1262 MACH_CHECK_ERROR (kret
);
1264 inf
->priv
->exception_info
.count
= 0;
1266 kret
= mach_port_deallocate (gdb_task
, inf
->priv
->task
);
1267 MACH_CHECK_ERROR (kret
);
1272 inf_child_mourn_inferior (ops
);
1276 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1282 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
1285 if (t
->msg_state
== DARWIN_MESSAGE
)
1286 darwin_resume_thread (inf
, t
, 0, 0);
1291 darwin_stop_inferior (struct inferior
*inf
)
1293 struct target_waitstatus wstatus
;
1299 gdb_assert (inf
!= NULL
);
1301 darwin_suspend_inferior (inf
);
1303 darwin_reply_to_all_pending_messages (inf
);
1305 if (inf
->priv
->no_ptrace
)
1308 res
= kill (inf
->pid
, SIGSTOP
);
1310 warning (_("cannot kill: %s"), safe_strerror (errno
));
1312 /* Wait until the process is really stopped. */
1315 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1316 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1317 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1322 static kern_return_t
1323 darwin_save_exception_ports (darwin_inferior
*inf
)
1327 inf
->exception_info
.count
=
1328 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1330 kret
= task_get_exception_ports
1331 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1332 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1333 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1337 static kern_return_t
1338 darwin_restore_exception_ports (darwin_inferior
*inf
)
1343 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1345 kret
= task_set_exception_ports
1346 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1347 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1348 if (kret
!= KERN_SUCCESS
)
1352 return KERN_SUCCESS
;
1356 darwin_kill_inferior (struct target_ops
*ops
)
1358 struct inferior
*inf
= current_inferior ();
1359 struct target_waitstatus wstatus
;
1365 if (ptid_equal (inferior_ptid
, null_ptid
))
1368 gdb_assert (inf
!= NULL
);
1370 kret
= darwin_restore_exception_ports (inf
->priv
);
1371 MACH_CHECK_ERROR (kret
);
1373 darwin_reply_to_all_pending_messages (inf
);
1375 res
= kill (inf
->pid
, 9);
1379 darwin_resume_inferior (inf
);
1381 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1383 else if (errno
!= ESRCH
)
1384 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1385 inf
->pid
, safe_strerror (errno
));
1387 target_mourn_inferior ();
1391 darwin_attach_pid (struct inferior
*inf
)
1394 mach_port_t prev_port
;
1396 mach_port_t prev_not
;
1397 exception_mask_t mask
;
1399 inf
->priv
= XCNEW (darwin_inferior
);
1401 kret
= task_for_pid (gdb_task
, inf
->pid
, &inf
->priv
->task
);
1402 if (kret
!= KERN_SUCCESS
)
1406 if (!inf
->attach_flag
)
1409 waitpid (inf
->pid
, &status
, 0);
1412 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1413 " (please check gdb is codesigned - see taskgated(8))"),
1414 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1417 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1418 inf
->priv
->task
, inf
->pid
);
1420 if (darwin_ex_port
== MACH_PORT_NULL
)
1422 /* Create a port to get exceptions. */
1423 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1425 if (kret
!= KERN_SUCCESS
)
1426 error (_("Unable to create exception port, mach_port_allocate "
1430 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1431 MACH_MSG_TYPE_MAKE_SEND
);
1432 if (kret
!= KERN_SUCCESS
)
1433 error (_("Unable to create exception port, mach_port_insert_right "
1437 /* Create a port set and put ex_port in it. */
1438 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1440 if (kret
!= KERN_SUCCESS
)
1441 error (_("Unable to create port set, mach_port_allocate "
1445 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1446 if (kret
!= KERN_SUCCESS
)
1447 error (_("Unable to move exception port into new port set, "
1448 "mach_port_move_member\n"
1453 /* Create a port to be notified when the child task terminates. */
1454 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1455 &inf
->priv
->notify_port
);
1456 if (kret
!= KERN_SUCCESS
)
1457 error (_("Unable to create notification port, mach_port_allocate "
1461 kret
= mach_port_move_member (gdb_task
,
1462 inf
->priv
->notify_port
, darwin_port_set
);
1463 if (kret
!= KERN_SUCCESS
)
1464 error (_("Unable to move notification port into new port set, "
1465 "mach_port_move_member\n"
1469 kret
= mach_port_request_notification (gdb_task
, inf
->priv
->task
,
1470 MACH_NOTIFY_DEAD_NAME
, 0,
1471 inf
->priv
->notify_port
,
1472 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1474 if (kret
!= KERN_SUCCESS
)
1475 error (_("Termination notification request failed, "
1476 "mach_port_request_notification\n"
1479 if (prev_not
!= MACH_PORT_NULL
)
1481 /* This is unexpected, as there should not be any previously
1482 registered notification request. But this is not a fatal
1483 issue, so just emit a warning. */
1485 A task termination request was registered before the debugger registered\n\
1486 its own. This is unexpected, but should otherwise not have any actual\n\
1487 impact on the debugging session."));
1490 kret
= darwin_save_exception_ports (inf
->priv
);
1491 if (kret
!= KERN_SUCCESS
)
1492 error (_("Unable to save exception ports, task_get_exception_ports"
1496 /* Set exception port. */
1497 if (enable_mach_exceptions
)
1498 mask
= EXC_MASK_ALL
;
1500 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1501 kret
= task_set_exception_ports (inf
->priv
->task
, mask
, darwin_ex_port
,
1502 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1503 if (kret
!= KERN_SUCCESS
)
1504 error (_("Unable to set exception ports, task_set_exception_ports"
1508 if (!target_is_pushed (darwin_ops
))
1509 push_target (darwin_ops
);
1513 darwin_init_thread_list (struct inferior
*inf
)
1515 darwin_thread_t
*thread
;
1518 darwin_check_new_threads (inf
);
1520 gdb_assert (inf
->priv
->threads
1521 && VEC_length (darwin_thread_t
, inf
->priv
->threads
) > 0);
1522 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1524 /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1526 new_ptid
= ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1527 thread_change_ptid (inferior_ptid
, new_ptid
);
1528 inferior_ptid
= new_ptid
;
1531 /* The child must synchronize with gdb: gdb must set the exception port
1532 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1533 FIXME: is there a lighter way ? */
1534 static int ptrace_fds
[2];
1537 darwin_ptrace_me (void)
1542 /* Close write end point. */
1543 close (ptrace_fds
[1]);
1545 /* Wait until gdb is ready. */
1546 res
= read (ptrace_fds
[0], &c
, 1);
1548 error (_("unable to read from pipe, read returned: %d"), res
);
1549 close (ptrace_fds
[0]);
1551 /* Get rid of privileges. */
1552 setegid (getgid ());
1555 PTRACE (PT_TRACE_ME
, 0, 0, 0);
1557 /* Redirect signals to exception port. */
1558 PTRACE (PT_SIGEXC
, 0, 0, 0);
1561 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1563 darwin_pre_ptrace (void)
1565 if (pipe (ptrace_fds
) != 0)
1569 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1572 mark_fd_no_cloexec (ptrace_fds
[0]);
1573 mark_fd_no_cloexec (ptrace_fds
[1]);
1577 darwin_ptrace_him (int pid
)
1581 mach_port_t prev_port
;
1583 struct inferior
*inf
= current_inferior ();
1585 darwin_attach_pid (inf
);
1587 /* Let's the child run. */
1588 close (ptrace_fds
[0]);
1589 close (ptrace_fds
[1]);
1591 unmark_fd_no_cloexec (ptrace_fds
[0]);
1592 unmark_fd_no_cloexec (ptrace_fds
[1]);
1594 darwin_init_thread_list (inf
);
1596 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1600 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1602 posix_spawnattr_t attr
;
1606 res
= posix_spawnattr_init (&attr
);
1610 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1614 /* Do like execve: replace the image. */
1615 ps_flags
= POSIX_SPAWN_SETEXEC
;
1617 /* Disable ASLR. The constant doesn't look to be available outside the
1618 kernel include files. */
1619 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1620 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1622 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1623 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1626 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1630 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1634 darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
1635 char *allargs
, char **env
, int from_tty
)
1637 /* Do the hard work. */
1638 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
, darwin_ptrace_him
,
1639 darwin_pre_ptrace
, NULL
, darwin_execvp
);
1641 /* Return now in case of error. */
1642 if (ptid_equal (inferior_ptid
, null_ptid
))
1647 /* Set things up such that the next call to darwin_wait will immediately
1648 return a fake stop event for inferior INF.
1650 This assumes that the inferior's thread list has been initialized,
1651 as it will suspend the inferior's first thread. */
1654 darwin_setup_fake_stop_event (struct inferior
*inf
)
1656 darwin_thread_t
*thread
;
1659 gdb_assert (darwin_inf_fake_stop
== NULL
);
1660 darwin_inf_fake_stop
= inf
;
1662 /* When detecting a fake pending stop event, darwin_wait returns
1663 an event saying that the first thread is in a DARWIN_STOPPED
1664 state. To make that accurate, we need to suspend that thread
1665 as well. Otherwise, we'll try resuming it when resuming the
1666 inferior, and get a warning because the thread's suspend count
1667 is already zero, making the resume request useless. */
1668 thread
= VEC_index (darwin_thread_t
, inf
->priv
->threads
, 0);
1669 kret
= thread_suspend (thread
->gdb_port
);
1670 MACH_CHECK_ERROR (kret
);
1673 /* Attach to process PID, then initialize for debugging it
1674 and wait for the trace-trap that results from attaching. */
1676 darwin_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1682 struct inferior
*inf
;
1685 pid
= parse_pid_to_attach (args
);
1687 if (pid
== getpid ()) /* Trying to masturbate? */
1688 error (_("I refuse to debug myself!"));
1692 char *exec_file
= get_exec_file (0);
1695 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1696 target_pid_to_str (pid_to_ptid (pid
)));
1698 printf_unfiltered (_("Attaching to %s\n"),
1699 target_pid_to_str (pid_to_ptid (pid
)));
1701 gdb_flush (gdb_stdout
);
1704 if (pid
== 0 || kill (pid
, 0) < 0)
1705 error (_("Can't attach to process %d: %s (%d)"),
1706 pid
, safe_strerror (errno
), errno
);
1708 inferior_ptid
= pid_to_ptid (pid
);
1709 inf
= current_inferior ();
1710 inferior_appeared (inf
, pid
);
1711 inf
->attach_flag
= 1;
1713 /* Always add a main thread. */
1714 add_thread_silent (inferior_ptid
);
1716 darwin_attach_pid (inf
);
1718 darwin_suspend_inferior (inf
);
1720 darwin_init_thread_list (inf
);
1722 darwin_check_osabi (inf
->priv
, ptid_get_tid (inferior_ptid
));
1724 darwin_setup_fake_stop_event (inf
);
1726 inf
->priv
->no_ptrace
= 1;
1729 /* Take a program previously attached to and detaches it.
1730 The program resumes execution and will no longer stop
1731 on signals, etc. We'd better not have left any breakpoints
1732 in the program or it'll die when it hits one. For this
1733 to work, it may be necessary for the process to have been
1734 previously attached. It *might* work if the program was
1735 started via fork. */
1737 darwin_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1739 pid_t pid
= ptid_get_pid (inferior_ptid
);
1740 struct inferior
*inf
= current_inferior ();
1744 /* Display message. */
1747 char *exec_file
= get_exec_file (0);
1750 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
1751 target_pid_to_str (pid_to_ptid (pid
)));
1752 gdb_flush (gdb_stdout
);
1755 /* If ptrace() is in use, stop the process. */
1756 if (!inf
->priv
->no_ptrace
)
1757 darwin_stop_inferior (inf
);
1759 kret
= darwin_restore_exception_ports (inf
->priv
);
1760 MACH_CHECK_ERROR (kret
);
1762 if (!inf
->priv
->no_ptrace
)
1764 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1766 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1767 inf
->pid
, safe_strerror (errno
), errno
);
1770 darwin_reply_to_all_pending_messages (inf
);
1772 /* When using ptrace, we have just performed a PT_DETACH, which
1773 resumes the inferior. On the other hand, when we are not using
1774 ptrace, we need to resume its execution ourselves. */
1775 if (inf
->priv
->no_ptrace
)
1776 darwin_resume_inferior (inf
);
1778 darwin_mourn_inferior (ops
);
1782 darwin_files_info (struct target_ops
*ops
)
1787 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1789 static char buf
[80];
1790 long tid
= ptid_get_tid (ptid
);
1794 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1795 tid
, ptid_get_pid (ptid
));
1799 return normal_pid_to_str (ptid
);
1803 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1808 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1809 copy it to RDADDR in gdb's address space.
1810 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1811 to ADDR in inferior task's address space.
1812 Return 0 on failure; number of bytes read / writen otherwise. */
1815 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
1816 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
1820 mach_vm_size_t res_length
= 0;
1822 mach_msg_type_number_t copy_count
;
1823 mach_vm_size_t remaining_length
;
1824 mach_vm_address_t region_address
;
1825 mach_vm_size_t region_length
;
1827 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
1828 task
, core_addr_to_string (addr
), pulongest (length
));
1833 mach_vm_size_t count
;
1835 /* According to target.h(to_xfer_partial), one and only one may be
1837 gdb_assert (wraddr
== NULL
);
1839 kret
= mach_vm_read_overwrite (task
, addr
, length
,
1840 (mach_vm_address_t
) rdaddr
, &count
);
1841 if (kret
!= KERN_SUCCESS
)
1844 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1845 core_addr_to_string (addr
), mach_error_string (kret
));
1852 gdb_assert (wraddr
!= NULL
);
1856 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
1857 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
1858 mach_vm_size_t aligned_length
=
1859 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
1860 vm_region_submap_short_info_data_64_t info
;
1861 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
1862 natural_t region_depth
= 1000;
1863 mach_vm_address_t region_start
= region_address
;
1864 mach_vm_size_t region_length
;
1865 mach_vm_size_t write_length
;
1867 /* Read page protection. */
1868 kret
= mach_vm_region_recurse
1869 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
1870 (vm_region_recurse_info_t
) &info
, &count
);
1872 if (kret
!= KERN_SUCCESS
)
1874 inferior_debug (1, _("darwin_read_write_inferior: "
1875 "mach_vm_region_recurse failed at %s: %s\n"),
1876 core_addr_to_string (region_address
),
1877 mach_error_string (kret
));
1882 (9, _("darwin_read_write_inferior: "
1883 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1884 core_addr_to_string (region_address
),
1885 core_addr_to_string (region_start
),
1886 core_addr_to_string (region_length
));
1888 /* Check for holes in memory. */
1889 if (region_start
> region_address
)
1891 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1892 core_addr_to_string (region_address
),
1893 core_addr_to_string (region_start
),
1894 (unsigned)region_length
);
1898 /* Adjust the length. */
1899 region_length
-= (region_address
- region_start
);
1900 if (region_length
> aligned_length
)
1901 region_length
= aligned_length
;
1903 /* Make the pages RW. */
1904 if (!(info
.protection
& VM_PROT_WRITE
))
1906 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
1908 kret
= mach_vm_protect (task
, region_address
, region_length
,
1910 if (kret
!= KERN_SUCCESS
)
1912 prot
|= VM_PROT_COPY
;
1913 kret
= mach_vm_protect (task
, region_address
, region_length
,
1916 if (kret
!= KERN_SUCCESS
)
1918 warning (_("darwin_read_write_inferior: "
1919 "mach_vm_protect failed at %s "
1920 "(len=0x%lx, prot=0x%x): %s"),
1921 core_addr_to_string (region_address
),
1922 (unsigned long) region_length
, (unsigned) prot
,
1923 mach_error_string (kret
));
1928 if (offset
+ length
> region_length
)
1929 write_length
= region_length
- offset
;
1931 write_length
= length
;
1934 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
1935 if (kret
!= KERN_SUCCESS
)
1937 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1938 mach_error_string (kret
));
1942 /* Restore page rights. */
1943 if (!(info
.protection
& VM_PROT_WRITE
))
1945 kret
= mach_vm_protect (task
, region_address
, region_length
,
1946 FALSE
, info
.protection
);
1947 if (kret
!= KERN_SUCCESS
)
1949 warning (_("darwin_read_write_inferior: "
1950 "mach_vm_protect restore failed at %s "
1952 core_addr_to_string (region_address
),
1953 (unsigned long) region_length
,
1954 mach_error_string (kret
));
1958 addr
+= write_length
;
1959 wraddr
+= write_length
;
1960 res_length
+= write_length
;
1961 length
-= write_length
;
1967 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1968 to RDADDR (in big endian).
1969 Return 0 on failure; number of bytes read / written otherwise. */
1971 #ifdef TASK_DYLD_INFO_COUNT
1972 /* This is not available in Darwin 9. */
1973 static enum target_xfer_status
1974 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
1975 ULONGEST length
, ULONGEST
*xfered_len
)
1977 struct task_dyld_info task_dyld_info
;
1978 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
1979 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
1982 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
1983 return TARGET_XFER_EOF
;
1985 kret
= task_info (task
, TASK_DYLD_INFO
,
1986 (task_info_t
) &task_dyld_info
, &count
);
1987 MACH_CHECK_ERROR (kret
);
1988 if (kret
!= KERN_SUCCESS
)
1989 return TARGET_XFER_E_IO
;
1991 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
1992 task_dyld_info
.all_image_info_addr
);
1993 *xfered_len
= (ULONGEST
) length
;
1994 return TARGET_XFER_OK
;
2000 static enum target_xfer_status
2001 darwin_xfer_partial (struct target_ops
*ops
,
2002 enum target_object object
, const char *annex
,
2003 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2004 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
2006 struct inferior
*inf
= current_inferior ();
2009 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2010 core_addr_to_string (offset
), pulongest (len
),
2011 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2016 case TARGET_OBJECT_MEMORY
:
2018 int l
= darwin_read_write_inferior (inf
->priv
->task
, offset
,
2019 readbuf
, writebuf
, len
);
2022 return TARGET_XFER_EOF
;
2026 *xfered_len
= (ULONGEST
) l
;
2027 return TARGET_XFER_OK
;
2030 #ifdef TASK_DYLD_INFO_COUNT
2031 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2032 if (writebuf
!= NULL
|| readbuf
== NULL
)
2034 /* Support only read. */
2035 return TARGET_XFER_E_IO
;
2037 return darwin_read_dyld_info (inf
->priv
->task
, offset
, readbuf
, len
,
2041 return TARGET_XFER_E_IO
;
2047 set_enable_mach_exceptions (char *args
, int from_tty
,
2048 struct cmd_list_element
*c
)
2050 if (!ptid_equal (inferior_ptid
, null_ptid
))
2052 struct inferior
*inf
= current_inferior ();
2053 exception_mask_t mask
;
2056 if (enable_mach_exceptions
)
2057 mask
= EXC_MASK_ALL
;
2060 darwin_restore_exception_ports (inf
->priv
);
2061 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2063 kret
= task_set_exception_ports (inf
->priv
->task
, mask
, darwin_ex_port
,
2064 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2065 MACH_CHECK_ERROR (kret
);
2070 darwin_pid_to_exec_file (struct target_ops
*self
, int pid
)
2072 static char path
[PATH_MAX
];
2075 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2083 darwin_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2088 struct inferior
*inf
= current_inferior ();
2090 mach_port_name_array_t names
;
2091 mach_msg_type_number_t names_count
;
2092 mach_port_type_array_t types
;
2093 mach_msg_type_number_t types_count
;
2096 /* First linear search. */
2098 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2100 if (t
->inf_port
== lwp
)
2101 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2103 /* Maybe the port was never extract. Do it now. */
2105 /* First get inferior port names. */
2106 kret
= mach_port_names (inf
->priv
->task
, &names
, &names_count
, &types
,
2108 MACH_CHECK_ERROR (kret
);
2109 if (kret
!= KERN_SUCCESS
)
2112 /* For each name, copy the right in the gdb space and then compare with
2113 our view of the inferior threads. We don't forget to deallocate the
2115 for (i
= 0; i
< names_count
; i
++)
2117 mach_port_t local_name
;
2118 mach_msg_type_name_t local_type
;
2120 /* We just need to know the corresponding name in gdb name space.
2121 So extract and deallocate the right. */
2122 kret
= mach_port_extract_right (inf
->priv
->task
, names
[i
],
2123 MACH_MSG_TYPE_COPY_SEND
,
2124 &local_name
, &local_type
);
2125 if (kret
!= KERN_SUCCESS
)
2127 mach_port_deallocate (gdb_task
, local_name
);
2130 VEC_iterate (darwin_thread_t
, inf
->priv
->threads
, k
, t
);
2132 if (t
->gdb_port
== local_name
)
2134 t
->inf_port
= names
[i
];
2135 if (names
[i
] == lwp
)
2140 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2141 names_count
* sizeof (mach_port_t
));
2144 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2150 darwin_supports_multi_process (struct target_ops
*self
)
2155 /* -Wmissing-prototypes */
2156 extern initialize_file_ftype _initialize_darwin_inferior
;
2159 _initialize_darwin_inferior (void)
2163 gdb_task
= mach_task_self ();
2164 darwin_host_self
= mach_host_self ();
2166 /* Read page size. */
2167 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2168 if (kret
!= KERN_SUCCESS
)
2170 mach_page_size
= 0x1000;
2171 MACH_CHECK_ERROR (kret
);
2174 darwin_ops
= inf_child_target ();
2176 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2177 darwin_ops
->to_attach
= darwin_attach
;
2178 darwin_ops
->to_attach_no_wait
= 0;
2179 darwin_ops
->to_detach
= darwin_detach
;
2180 darwin_ops
->to_files_info
= darwin_files_info
;
2181 darwin_ops
->to_wait
= darwin_wait_to
;
2182 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2183 darwin_ops
->to_kill
= darwin_kill_inferior
;
2184 darwin_ops
->to_interrupt
= darwin_interrupt
;
2185 darwin_ops
->to_resume
= darwin_resume_to
;
2186 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2187 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2188 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2189 darwin_ops
->to_load
= NULL
;
2190 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2191 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2192 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2194 darwin_complete_target (darwin_ops
);
2196 add_target (darwin_ops
);
2198 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2199 (unsigned long) mach_task_self (), getpid ());
2201 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2202 &darwin_debug_flag
, _("\
2203 Set if printing inferior communication debugging statements."), _("\
2204 Show if printing inferior communication debugging statements."), NULL
,
2206 &setdebuglist
, &showdebuglist
);
2208 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2209 &enable_mach_exceptions
, _("\
2210 Set if mach exceptions are caught."), _("\
2211 Show if mach exceptions are caught."), _("\
2212 When this mode is on, all low level exceptions are reported before being\n\
2213 reported by the kernel."),
2214 &set_enable_mach_exceptions
, NULL
,
2215 &setlist
, &showlist
);