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_stop (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"
175 inferior_debug (int level
, const char *fmt
, ...)
179 if (darwin_debug_flag
< level
)
183 printf_unfiltered (_("[%d inferior]: "), getpid ());
184 vprintf_unfiltered (fmt
, ap
);
189 mach_check_error (kern_return_t ret
, const char *file
,
190 unsigned int line
, const char *func
)
192 if (ret
== KERN_SUCCESS
)
195 func
= _("[UNKNOWN]");
197 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
198 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
202 unparse_exception_type (unsigned int i
)
204 static char unknown_exception_buf
[32];
209 return "EXC_BAD_ACCESS";
210 case EXC_BAD_INSTRUCTION
:
211 return "EXC_BAD_INSTRUCTION";
213 return "EXC_ARITHMETIC";
215 return "EXC_EMULATION";
217 return "EXC_SOFTWARE";
219 return "EXC_BREAKPOINT";
221 return "EXC_SYSCALL";
222 case EXC_MACH_SYSCALL
:
223 return "EXC_MACH_SYSCALL";
225 return "EXC_RPC_ALERT";
229 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
230 return unknown_exception_buf
;
234 /* Set errno to zero, and then call ptrace with the given arguments.
235 If inferior debugging traces are on, then also print a debug
238 The returned value is the same as the value returned by ptrace,
239 except in the case where that value is -1 but errno is zero.
240 This case is documented to be a non-error situation, so we
241 return zero in that case. */
244 darwin_ptrace (const char *name
,
245 int request
, int pid
, PTRACE_TYPE_ARG3 arg3
, int arg4
)
250 ret
= ptrace (request
, pid
, (caddr_t
) arg3
, arg4
);
251 if (ret
== -1 && errno
== 0)
254 inferior_debug (4, _("ptrace (%s, %d, 0x%x, %d): %d (%s)\n"),
255 name
, pid
, arg3
, arg4
, ret
,
256 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
261 cmp_thread_t (const void *l
, const void *r
)
263 thread_t tl
= *(const thread_t
*)l
;
264 thread_t tr
= *(const thread_t
*)r
;
265 return (int)(tl
- tr
);
269 darwin_check_new_threads (struct inferior
*inf
)
273 thread_array_t thread_list
;
274 unsigned int new_nbr
;
275 unsigned int old_nbr
;
276 unsigned int new_ix
, old_ix
;
277 darwin_inferior
*darwin_inf
= inf
->private;
278 VEC (darwin_thread_t
) *thread_vec
;
280 /* Get list of threads. */
281 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
282 MACH_CHECK_ERROR (kret
);
283 if (kret
!= KERN_SUCCESS
)
288 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
290 if (darwin_inf
->threads
)
291 old_nbr
= VEC_length (darwin_thread_t
, darwin_inf
->threads
);
295 /* Quick check for no changes. */
296 if (old_nbr
== new_nbr
)
298 for (i
= 0; i
< new_nbr
; i
++)
300 != VEC_index (darwin_thread_t
, darwin_inf
->threads
, i
)->gdb_port
)
304 /* Deallocate ports. */
305 for (i
= 0; i
< new_nbr
; i
++)
307 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
308 MACH_CHECK_ERROR (kret
);
311 /* Deallocate the buffer. */
312 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
313 new_nbr
* sizeof (int));
314 MACH_CHECK_ERROR (kret
);
320 thread_vec
= VEC_alloc (darwin_thread_t
, new_nbr
);
322 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
324 thread_t new_id
= (new_ix
< new_nbr
) ?
325 thread_list
[new_ix
] : THREAD_NULL
;
326 darwin_thread_t
*old
= (old_ix
< old_nbr
) ?
327 VEC_index (darwin_thread_t
, darwin_inf
->threads
, old_ix
) : NULL
;
328 thread_t old_id
= old
? old
->gdb_port
: THREAD_NULL
;
331 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
332 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
334 if (old_id
== new_id
)
336 /* Thread still exist. */
337 VEC_safe_push (darwin_thread_t
, thread_vec
, old
);
341 /* Deallocate the port. */
342 kret
= mach_port_deallocate (gdb_task
, new_id
);
343 MACH_CHECK_ERROR (kret
);
347 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
349 /* Ignore dead ports.
350 In some weird cases, we might get dead ports. They should
351 correspond to dead thread so they could safely be ignored. */
355 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
357 /* A thread was created. */
358 struct thread_info
*tp
;
359 struct private_thread_info
*pti
;
361 pti
= XCNEW (struct private_thread_info
);
362 pti
->gdb_port
= new_id
;
363 pti
->msg_state
= DARWIN_RUNNING
;
365 /* Add a new thread unless this is the first one ever met. */
366 if (!(old_nbr
== 0 && new_ix
== 0))
367 tp
= add_thread_with_info (ptid_build (inf
->pid
, 0, new_id
), pti
);
370 tp
= find_thread_ptid (ptid_build (inf
->pid
, 0, 0));
374 VEC_safe_push (darwin_thread_t
, thread_vec
, pti
);
378 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
380 /* A thread was removed. */
381 delete_thread (ptid_build (inf
->pid
, 0, old_id
));
382 kret
= mach_port_deallocate (gdb_task
, old_id
);
383 MACH_CHECK_ERROR (kret
);
387 gdb_assert_not_reached ("unexpected thread case");
390 if (darwin_inf
->threads
)
391 VEC_free (darwin_thread_t
, darwin_inf
->threads
);
392 darwin_inf
->threads
= thread_vec
;
394 /* Deallocate the buffer. */
395 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
396 new_nbr
* sizeof (int));
397 MACH_CHECK_ERROR (kret
);
401 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
403 return inf
->private->task
== *(task_t
*)port_ptr
;
407 find_inferior_notify_it (struct inferior
*inf
, void *port_ptr
)
409 return inf
->private->notify_port
== *(task_t
*)port_ptr
;
412 /* Return an inferior by task port. */
413 static struct inferior
*
414 darwin_find_inferior_by_task (task_t port
)
416 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
419 /* Return an inferior by notification port. */
420 static struct inferior
*
421 darwin_find_inferior_by_notify (mach_port_t port
)
423 return iterate_over_inferiors (&find_inferior_notify_it
, &port
);
426 /* Return a thread by port. */
427 static darwin_thread_t
*
428 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
434 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
436 if (t
->gdb_port
== thread
)
441 /* Suspend (ie stop) an inferior at Mach level. */
444 darwin_suspend_inferior (struct inferior
*inf
)
446 if (!inf
->private->suspended
)
450 kret
= task_suspend (inf
->private->task
);
451 MACH_CHECK_ERROR (kret
);
453 inf
->private->suspended
= 1;
457 /* Resume an inferior at Mach level. */
460 darwin_resume_inferior (struct inferior
*inf
)
462 if (inf
->private->suspended
)
466 kret
= task_resume (inf
->private->task
);
467 MACH_CHECK_ERROR (kret
);
469 inf
->private->suspended
= 0;
473 /* Iterator functions. */
476 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
478 darwin_suspend_inferior (inf
);
479 darwin_check_new_threads (inf
);
484 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
486 darwin_resume_inferior (inf
);
491 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
493 printf_unfiltered (_("message header:\n"));
494 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
495 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
496 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
497 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
498 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
499 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
503 const unsigned char *data
;
504 const unsigned int *ldata
;
508 data
= (unsigned char *)(hdr
+ 1);
509 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
511 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
513 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
514 mach_msg_port_descriptor_t
*desc
=
515 (mach_msg_port_descriptor_t
*)(bod
+ 1);
518 printf_unfiltered (_("body: descriptor_count=%u\n"),
519 bod
->msgh_descriptor_count
);
520 data
+= sizeof (mach_msg_body_t
);
521 size
-= sizeof (mach_msg_body_t
);
522 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
523 switch (desc
[k
].type
)
525 case MACH_MSG_PORT_DESCRIPTOR
:
527 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
528 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
531 printf_unfiltered (_(" descr %d: type=%u\n"),
535 data
+= bod
->msgh_descriptor_count
536 * sizeof (mach_msg_port_descriptor_t
);
537 size
-= bod
->msgh_descriptor_count
538 * sizeof (mach_msg_port_descriptor_t
);
539 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
541 (_("NDR: mig=%02x if=%02x encod=%02x "
542 "int=%02x char=%02x float=%02x\n"),
543 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
544 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
545 data
+= sizeof (NDR_record_t
);
546 size
-= sizeof (NDR_record_t
);
549 printf_unfiltered (_(" data:"));
550 ldata
= (const unsigned int *)data
;
551 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
552 printf_unfiltered (" %08x", ldata
[i
]);
553 printf_unfiltered (_("\n"));
558 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
559 struct inferior
**pinf
,
560 darwin_thread_t
**pthread
)
562 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
563 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
566 struct inferior
*inf
;
567 darwin_thread_t
*thread
;
569 thread_t thread_port
;
573 /* Check message destination. */
574 if (hdr
->msgh_local_port
!= darwin_ex_port
)
577 /* Check message header. */
578 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
581 /* Check descriptors. */
582 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
583 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
584 || bod
->msgh_descriptor_count
!= 2
585 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
586 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
587 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
588 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
591 /* Check data representation. */
592 ndr
= (NDR_record_t
*)(desc
+ 2);
593 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
594 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
595 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
596 || ndr
->int_rep
!= NDR_record
.int_rep
597 || ndr
->char_rep
!= NDR_record
.char_rep
598 || ndr
->float_rep
!= NDR_record
.float_rep
)
601 /* Ok, the hard work. */
602 data
= (integer_t
*)(ndr
+ 1);
604 task_port
= desc
[1].name
;
605 thread_port
= desc
[0].name
;
607 /* We got new rights to the task, get rid of it. Do not get rid of thread
608 right, as we will need it to find the thread. */
609 kret
= mach_port_deallocate (mach_task_self (), task_port
);
610 MACH_CHECK_ERROR (kret
);
612 /* Find process by port. */
613 inf
= darwin_find_inferior_by_task (task_port
);
617 /* Not a known inferior. This could happen if the child fork, as
618 the created process will inherit its exception port.
619 FIXME: should the exception port be restored ? */
621 mig_reply_error_t reply
;
623 /* Free thread port (we don't know it). */
624 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
625 MACH_CHECK_ERROR (kret
);
627 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
629 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
630 reply
.Head
.msgh_size
, 0,
631 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
633 MACH_CHECK_ERROR (kret
);
638 /* Find thread by port. */
639 /* Check for new threads. Do it early so that the port in the exception
640 message can be deallocated. */
641 darwin_check_new_threads (inf
);
643 /* Free the thread port (as gdb knows the thread, it has already has a right
644 for it, so this just decrement a reference counter). */
645 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
646 MACH_CHECK_ERROR (kret
);
648 thread
= darwin_find_thread (inf
, thread_port
);
653 /* The thread should be running. However we have observed cases where a
654 thread got a SIGTTIN message after being stopped. */
655 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
657 /* Finish decoding. */
658 thread
->event
.header
= *hdr
;
659 thread
->event
.thread_port
= thread_port
;
660 thread
->event
.task_port
= task_port
;
661 thread
->event
.ex_type
= data
[0];
662 thread
->event
.data_count
= data
[1];
664 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
665 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
666 + data
[1] * sizeof (integer_t
)))
668 for (i
= 0; i
< data
[1]; i
++)
669 thread
->event
.ex_data
[i
] = data
[2 + i
];
671 thread
->msg_state
= DARWIN_MESSAGE
;
677 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
680 mach_msg_header_t
*rh
= &reply
->Head
;
682 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
683 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
684 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
685 rh
->msgh_local_port
= MACH_PORT_NULL
;
686 rh
->msgh_id
= hdr
->msgh_id
+ 100;
688 reply
->NDR
= NDR_record
;
689 reply
->RetCode
= code
;
693 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
696 mig_reply_error_t reply
;
698 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
700 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
701 reply
.Head
.msgh_size
, 0,
702 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
704 MACH_CHECK_ERROR (kret
);
706 inf
->private->pending_messages
--;
710 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
711 int step
, int nsignal
)
717 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
718 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
720 switch (thread
->msg_state
)
723 if (thread
->event
.ex_type
== EXC_SOFTWARE
724 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
726 /* Either deliver a new signal or cancel the signal received. */
727 res
= PTRACE (PT_THUPDATE
, inf
->pid
,
728 (void *)(uintptr_t)thread
->gdb_port
, nsignal
);
730 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
734 /* Note: ptrace is allowed only if the process is stopped.
735 Directly send the signal to the thread. */
736 res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
737 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
738 thread
->gdb_port
, nsignal
, res
);
739 thread
->signaled
= 1;
742 /* Set or reset single step. */
743 if (step
!= thread
->single_step
)
745 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
746 thread
->gdb_port
, step
);
747 darwin_set_sstep (thread
->gdb_port
, step
);
748 thread
->single_step
= step
;
751 darwin_send_reply (inf
, thread
);
752 thread
->msg_state
= DARWIN_RUNNING
;
759 kret
= thread_resume (thread
->gdb_port
);
760 MACH_CHECK_ERROR (kret
);
762 thread
->msg_state
= DARWIN_RUNNING
;
767 /* Resume all threads of the inferior. */
770 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
772 darwin_thread_t
*thread
;
776 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, thread
);
778 darwin_resume_thread (inf
, thread
, step
, nsignal
);
781 struct resume_inferior_threads_param
788 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
790 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
791 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
793 darwin_resume_inferior_threads (inf
, step
, nsignal
);
798 /* Suspend all threads of INF. */
801 darwin_suspend_inferior_threads (struct inferior
*inf
)
803 darwin_thread_t
*thread
;
808 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, thread
);
810 switch (thread
->msg_state
)
816 kret
= thread_suspend (thread
->gdb_port
);
817 MACH_CHECK_ERROR (kret
);
818 thread
->msg_state
= DARWIN_STOPPED
;
824 darwin_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
826 struct target_waitstatus status
;
832 struct inferior
*inf
;
835 (2, _("darwin_resume: pid=%d, tid=0x%x, step=%d, signal=%d\n"),
836 ptid_get_pid (ptid
), ptid_get_tid (ptid
), step
, signal
);
838 if (signal
== GDB_SIGNAL_0
)
841 nsignal
= gdb_signal_to_host (signal
);
843 /* Don't try to single step all threads. */
845 ptid
= inferior_ptid
;
847 /* minus_one_ptid is RESUME_ALL. */
848 if (ptid_equal (ptid
, minus_one_ptid
))
850 struct resume_inferior_threads_param param
;
852 param
.nsignal
= nsignal
;
855 /* Resume threads. */
856 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
858 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
862 struct inferior
*inf
= find_inferior_ptid (ptid
);
863 long tid
= ptid_get_tid (ptid
);
865 /* Stop the inferior (should be useless). */
866 darwin_suspend_inferior (inf
);
869 darwin_resume_inferior_threads (inf
, step
, nsignal
);
872 darwin_thread_t
*thread
;
874 /* Suspend threads of the task. */
875 darwin_suspend_inferior_threads (inf
);
877 /* Resume the selected thread. */
878 thread
= darwin_find_thread (inf
, tid
);
880 darwin_resume_thread (inf
, thread
, step
, nsignal
);
883 /* Resume the task. */
884 darwin_resume_inferior (inf
);
889 darwin_resume_to (struct target_ops
*ops
, ptid_t ptid
, int step
,
890 enum gdb_signal signal
)
892 return darwin_resume (ptid
, step
, signal
);
896 darwin_decode_message (mach_msg_header_t
*hdr
,
897 darwin_thread_t
**pthread
,
898 struct inferior
**pinf
,
899 struct target_waitstatus
*status
)
901 darwin_thread_t
*thread
;
902 struct inferior
*inf
;
904 /* Exception message. 2401 == 0x961 is exc. */
905 if (hdr
->msgh_id
== 2401)
909 /* Decode message. */
910 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
914 /* Should not happen... */
916 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
917 /* FIXME: send a failure reply? */
918 status
->kind
= TARGET_WAITKIND_IGNORE
;
919 return minus_one_ptid
;
923 status
->kind
= TARGET_WAITKIND_IGNORE
;
924 return minus_one_ptid
;
928 inf
->private->pending_messages
++;
930 status
->kind
= TARGET_WAITKIND_STOPPED
;
931 thread
->msg_state
= DARWIN_MESSAGE
;
933 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
935 unparse_exception_type (thread
->event
.ex_type
));
937 switch (thread
->event
.ex_type
)
940 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
942 case EXC_BAD_INSTRUCTION
:
943 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
946 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
949 status
->value
.sig
= GDB_EXC_EMULATION
;
952 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
955 gdb_signal_from_host (thread
->event
.ex_data
[1]);
956 inferior_debug (5, _(" (signal %d: %s)\n"),
957 thread
->event
.ex_data
[1],
958 gdb_signal_to_name (status
->value
.sig
));
960 /* If the thread is stopped because it has received a signal
961 that gdb has just sent, continue. */
962 if (thread
->signaled
)
964 thread
->signaled
= 0;
965 darwin_send_reply (inf
, thread
);
966 thread
->msg_state
= DARWIN_RUNNING
;
967 status
->kind
= TARGET_WAITKIND_IGNORE
;
971 status
->value
.sig
= GDB_EXC_SOFTWARE
;
974 /* Many internal GDB routines expect breakpoints to be reported
975 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
976 as a spurious signal. */
977 status
->value
.sig
= GDB_SIGNAL_TRAP
;
980 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
984 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
986 else if (hdr
->msgh_id
== 0x48)
988 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
992 inf
= darwin_find_inferior_by_notify (hdr
->msgh_local_port
);
995 if (!inf
->private->no_ptrace
)
1000 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1001 if (res
< 0 || res
!= inf
->pid
)
1003 printf_unfiltered (_("wait4: res=%d: %s\n"),
1004 res
, safe_strerror (errno
));
1005 status
->kind
= TARGET_WAITKIND_IGNORE
;
1006 return minus_one_ptid
;
1008 if (WIFEXITED (wstatus
))
1010 status
->kind
= TARGET_WAITKIND_EXITED
;
1011 status
->value
.integer
= WEXITSTATUS (wstatus
);
1015 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1016 status
->value
.sig
= WTERMSIG (wstatus
);
1019 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1022 /* Looks necessary on Leopard and harmless... */
1023 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1025 return ptid_build (inf
->pid
, 0, 0);
1029 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1030 status
->kind
= TARGET_WAITKIND_EXITED
;
1031 status
->value
.integer
= 0; /* Don't know. */
1032 return ptid_build (inf
->pid
, 0, 0);
1037 /* Unknown message. */
1038 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1039 status
->kind
= TARGET_WAITKIND_IGNORE
;
1040 return minus_one_ptid
;
1044 cancel_breakpoint (ptid_t ptid
)
1046 /* Arrange for a breakpoint to be hit again later. We will handle
1047 the current event, eventually we will resume this thread, and this
1048 breakpoint will trap again.
1050 If we do not do this, then we run the risk that the user will
1051 delete or disable the breakpoint, but the thread will have already
1054 struct regcache
*regcache
= get_thread_regcache (ptid
);
1055 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1058 pc
= regcache_read_pc (regcache
) - target_decr_pc_after_break (gdbarch
);
1059 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache
), pc
))
1061 inferior_debug (4, "cancel_breakpoint for thread 0x%x\n",
1062 ptid_get_tid (ptid
));
1064 /* Back up the PC if necessary. */
1065 if (target_decr_pc_after_break (gdbarch
))
1066 regcache_write_pc (regcache
, pc
);
1074 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1079 mach_msg_header_t hdr
;
1082 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1084 darwin_thread_t
*thread
;
1085 struct inferior
*inf
;
1088 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1089 ptid_get_pid (ptid
), ptid_get_tid (ptid
));
1091 /* Handle fake stop events at first. */
1092 if (darwin_inf_fake_stop
!= NULL
)
1094 inf
= darwin_inf_fake_stop
;
1095 darwin_inf_fake_stop
= NULL
;
1097 status
->kind
= TARGET_WAITKIND_STOPPED
;
1098 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1099 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1100 thread
->msg_state
= DARWIN_STOPPED
;
1101 return ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1106 /* set_sigint_trap (); */
1108 /* Wait for a message. */
1109 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1110 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1112 /* clear_sigint_trap (); */
1114 if (kret
== MACH_RCV_INTERRUPTED
)
1116 status
->kind
= TARGET_WAITKIND_IGNORE
;
1117 return minus_one_ptid
;
1120 if (kret
!= MACH_MSG_SUCCESS
)
1122 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1123 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1124 return minus_one_ptid
;
1127 /* Debug: display message. */
1128 if (darwin_debug_flag
> 10)
1129 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1131 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1132 if (ptid_equal (res
, minus_one_ptid
))
1135 /* Early return in case an inferior has exited. */
1139 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1141 /* Stop all tasks. */
1142 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1144 /* Read pending messages. */
1147 struct target_waitstatus status2
;
1150 kret
= mach_msg (&msgin
.hdr
,
1151 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1152 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1154 if (kret
== MACH_RCV_TIMED_OUT
)
1156 if (kret
!= MACH_MSG_SUCCESS
)
1159 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1163 /* Debug: display message. */
1164 if (darwin_debug_flag
> 10)
1165 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1167 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1169 if (inf
!= NULL
&& thread
!= NULL
1170 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1172 if (thread
->single_step
1173 || cancel_breakpoint (ptid_build (inf
->pid
, 0, thread
->gdb_port
)))
1175 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1176 darwin_send_reply (inf
, thread
);
1177 thread
->msg_state
= DARWIN_RUNNING
;
1181 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1185 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1191 darwin_wait_to (struct target_ops
*ops
,
1192 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1194 return darwin_wait (ptid
, status
);
1198 darwin_stop (struct target_ops
*self
, ptid_t t
)
1200 struct inferior
*inf
= current_inferior ();
1202 /* FIXME: handle in no_ptrace mode. */
1203 gdb_assert (!inf
->private->no_ptrace
);
1204 kill (inf
->pid
, SIGINT
);
1208 darwin_mourn_inferior (struct target_ops
*ops
)
1210 struct inferior
*inf
= current_inferior ();
1215 /* Deallocate threads. */
1216 if (inf
->private->threads
)
1221 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
1224 kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1225 MACH_CHECK_ERROR (kret
);
1227 VEC_free (darwin_thread_t
, inf
->private->threads
);
1228 inf
->private->threads
= NULL
;
1231 kret
= mach_port_move_member (gdb_task
,
1232 inf
->private->notify_port
, MACH_PORT_NULL
);
1233 MACH_CHECK_ERROR (kret
);
1235 kret
= mach_port_request_notification (gdb_task
, inf
->private->task
,
1236 MACH_NOTIFY_DEAD_NAME
, 0,
1238 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1240 /* This can fail if the task is dead. */
1241 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1242 inf
->private->task
, prev
, inf
->private->notify_port
);
1244 if (kret
== KERN_SUCCESS
)
1246 kret
= mach_port_deallocate (gdb_task
, prev
);
1247 MACH_CHECK_ERROR (kret
);
1250 kret
= mach_port_destroy (gdb_task
, inf
->private->notify_port
);
1251 MACH_CHECK_ERROR (kret
);
1254 /* Deallocate saved exception ports. */
1255 for (i
= 0; i
< inf
->private->exception_info
.count
; i
++)
1257 kret
= mach_port_deallocate
1258 (gdb_task
, inf
->private->exception_info
.ports
[i
]);
1259 MACH_CHECK_ERROR (kret
);
1261 inf
->private->exception_info
.count
= 0;
1263 kret
= mach_port_deallocate (gdb_task
, inf
->private->task
);
1264 MACH_CHECK_ERROR (kret
);
1266 xfree (inf
->private);
1267 inf
->private = NULL
;
1269 inf_child_mourn_inferior (ops
);
1273 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1279 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
1282 if (t
->msg_state
== DARWIN_MESSAGE
)
1283 darwin_resume_thread (inf
, t
, 0, 0);
1288 darwin_stop_inferior (struct inferior
*inf
)
1290 struct target_waitstatus wstatus
;
1296 gdb_assert (inf
!= NULL
);
1298 darwin_suspend_inferior (inf
);
1300 darwin_reply_to_all_pending_messages (inf
);
1302 if (inf
->private->no_ptrace
)
1305 res
= kill (inf
->pid
, SIGSTOP
);
1307 warning (_("cannot kill: %s"), safe_strerror (errno
));
1309 /* Wait until the process is really stopped. */
1312 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1313 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1314 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1319 static kern_return_t
1320 darwin_save_exception_ports (darwin_inferior
*inf
)
1324 inf
->exception_info
.count
=
1325 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1327 kret
= task_get_exception_ports
1328 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1329 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1330 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1334 static kern_return_t
1335 darwin_restore_exception_ports (darwin_inferior
*inf
)
1340 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1342 kret
= task_set_exception_ports
1343 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1344 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1345 if (kret
!= KERN_SUCCESS
)
1349 return KERN_SUCCESS
;
1353 darwin_kill_inferior (struct target_ops
*ops
)
1355 struct inferior
*inf
= current_inferior ();
1356 struct target_waitstatus wstatus
;
1362 if (ptid_equal (inferior_ptid
, null_ptid
))
1365 gdb_assert (inf
!= NULL
);
1367 kret
= darwin_restore_exception_ports (inf
->private);
1368 MACH_CHECK_ERROR (kret
);
1370 darwin_reply_to_all_pending_messages (inf
);
1372 res
= kill (inf
->pid
, 9);
1376 darwin_resume_inferior (inf
);
1378 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1380 else if (errno
!= ESRCH
)
1381 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1382 inf
->pid
, safe_strerror (errno
));
1384 target_mourn_inferior ();
1388 darwin_attach_pid (struct inferior
*inf
)
1391 mach_port_t prev_port
;
1393 mach_port_t prev_not
;
1394 exception_mask_t mask
;
1396 inf
->private = XCNEW (darwin_inferior
);
1398 kret
= task_for_pid (gdb_task
, inf
->pid
, &inf
->private->task
);
1399 if (kret
!= KERN_SUCCESS
)
1403 if (!inf
->attach_flag
)
1406 waitpid (inf
->pid
, &status
, 0);
1409 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1410 " (please check gdb is codesigned - see taskgated(8))"),
1411 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1414 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1415 inf
->private->task
, inf
->pid
);
1417 if (darwin_ex_port
== MACH_PORT_NULL
)
1419 /* Create a port to get exceptions. */
1420 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1422 if (kret
!= KERN_SUCCESS
)
1423 error (_("Unable to create exception port, mach_port_allocate "
1427 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
, darwin_ex_port
,
1428 MACH_MSG_TYPE_MAKE_SEND
);
1429 if (kret
!= KERN_SUCCESS
)
1430 error (_("Unable to create exception port, mach_port_insert_right "
1434 /* Create a port set and put ex_port in it. */
1435 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1437 if (kret
!= KERN_SUCCESS
)
1438 error (_("Unable to create port set, mach_port_allocate "
1442 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
, darwin_port_set
);
1443 if (kret
!= KERN_SUCCESS
)
1444 error (_("Unable to move exception port into new port set, "
1445 "mach_port_move_member\n"
1450 /* Create a port to be notified when the child task terminates. */
1451 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1452 &inf
->private->notify_port
);
1453 if (kret
!= KERN_SUCCESS
)
1454 error (_("Unable to create notification port, mach_port_allocate "
1458 kret
= mach_port_move_member (gdb_task
,
1459 inf
->private->notify_port
, darwin_port_set
);
1460 if (kret
!= KERN_SUCCESS
)
1461 error (_("Unable to move notification port into new port set, "
1462 "mach_port_move_member\n"
1466 kret
= mach_port_request_notification (gdb_task
, inf
->private->task
,
1467 MACH_NOTIFY_DEAD_NAME
, 0,
1468 inf
->private->notify_port
,
1469 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1471 if (kret
!= KERN_SUCCESS
)
1472 error (_("Termination notification request failed, "
1473 "mach_port_request_notification\n"
1476 if (prev_not
!= MACH_PORT_NULL
)
1478 /* This is unexpected, as there should not be any previously
1479 registered notification request. But this is not a fatal
1480 issue, so just emit a warning. */
1482 A task termination request was registered before the debugger registered\n\
1483 its own. This is unexpected, but should otherwise not have any actual\n\
1484 impact on the debugging session."));
1487 kret
= darwin_save_exception_ports (inf
->private);
1488 if (kret
!= KERN_SUCCESS
)
1489 error (_("Unable to save exception ports, task_get_exception_ports"
1493 /* Set exception port. */
1494 if (enable_mach_exceptions
)
1495 mask
= EXC_MASK_ALL
;
1497 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1498 kret
= task_set_exception_ports (inf
->private->task
, mask
, darwin_ex_port
,
1499 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1500 if (kret
!= KERN_SUCCESS
)
1501 error (_("Unable to set exception ports, task_set_exception_ports"
1505 if (!target_is_pushed (darwin_ops
))
1506 push_target (darwin_ops
);
1510 darwin_init_thread_list (struct inferior
*inf
)
1512 darwin_thread_t
*thread
;
1515 darwin_check_new_threads (inf
);
1517 gdb_assert (inf
->private->threads
1518 && VEC_length (darwin_thread_t
, inf
->private->threads
) > 0);
1519 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1521 /* Note: fork_inferior automatically add a thead but it uses a wrong ptid.
1523 new_ptid
= ptid_build (inf
->pid
, 0, thread
->gdb_port
);
1524 thread_change_ptid (inferior_ptid
, new_ptid
);
1525 inferior_ptid
= new_ptid
;
1528 /* The child must synchronize with gdb: gdb must set the exception port
1529 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1530 FIXME: is there a lighter way ? */
1531 static int ptrace_fds
[2];
1534 darwin_ptrace_me (void)
1539 /* Close write end point. */
1540 close (ptrace_fds
[1]);
1542 /* Wait until gdb is ready. */
1543 res
= read (ptrace_fds
[0], &c
, 1);
1545 error (_("unable to read from pipe, read returned: %d"), res
);
1546 close (ptrace_fds
[0]);
1548 /* Get rid of privileges. */
1549 setegid (getgid ());
1552 PTRACE (PT_TRACE_ME
, 0, 0, 0);
1554 /* Redirect signals to exception port. */
1555 PTRACE (PT_SIGEXC
, 0, 0, 0);
1558 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1560 darwin_pre_ptrace (void)
1562 if (pipe (ptrace_fds
) != 0)
1566 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1569 mark_fd_no_cloexec (ptrace_fds
[0]);
1570 mark_fd_no_cloexec (ptrace_fds
[1]);
1574 darwin_ptrace_him (int pid
)
1578 mach_port_t prev_port
;
1580 struct inferior
*inf
= current_inferior ();
1582 darwin_attach_pid (inf
);
1584 /* Let's the child run. */
1585 close (ptrace_fds
[0]);
1586 close (ptrace_fds
[1]);
1588 unmark_fd_no_cloexec (ptrace_fds
[0]);
1589 unmark_fd_no_cloexec (ptrace_fds
[1]);
1591 darwin_init_thread_list (inf
);
1593 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
1597 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1599 posix_spawnattr_t attr
;
1603 res
= posix_spawnattr_init (&attr
);
1607 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1611 /* Do like execve: replace the image. */
1612 ps_flags
= POSIX_SPAWN_SETEXEC
;
1614 /* Disable ASLR. The constant doesn't look to be available outside the
1615 kernel include files. */
1616 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1617 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1619 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1620 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1623 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1627 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1631 darwin_create_inferior (struct target_ops
*ops
, char *exec_file
,
1632 char *allargs
, char **env
, int from_tty
)
1634 /* Do the hard work. */
1635 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
, darwin_ptrace_him
,
1636 darwin_pre_ptrace
, NULL
, darwin_execvp
);
1638 /* Return now in case of error. */
1639 if (ptid_equal (inferior_ptid
, null_ptid
))
1644 /* Set things up such that the next call to darwin_wait will immediately
1645 return a fake stop event for inferior INF.
1647 This assumes that the inferior's thread list has been initialized,
1648 as it will suspend the inferior's first thread. */
1651 darwin_setup_fake_stop_event (struct inferior
*inf
)
1653 darwin_thread_t
*thread
;
1656 gdb_assert (darwin_inf_fake_stop
== NULL
);
1657 darwin_inf_fake_stop
= inf
;
1659 /* When detecting a fake pending stop event, darwin_wait returns
1660 an event saying that the first thread is in a DARWIN_STOPPED
1661 state. To make that accurate, we need to suspend that thread
1662 as well. Otherwise, we'll try resuming it when resuming the
1663 inferior, and get a warning because the thread's suspend count
1664 is already zero, making the resume request useless. */
1665 thread
= VEC_index (darwin_thread_t
, inf
->private->threads
, 0);
1666 kret
= thread_suspend (thread
->gdb_port
);
1667 MACH_CHECK_ERROR (kret
);
1670 /* Attach to process PID, then initialize for debugging it
1671 and wait for the trace-trap that results from attaching. */
1673 darwin_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
1679 struct inferior
*inf
;
1682 pid
= parse_pid_to_attach (args
);
1684 if (pid
== getpid ()) /* Trying to masturbate? */
1685 error (_("I refuse to debug myself!"));
1689 char *exec_file
= get_exec_file (0);
1692 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
1693 target_pid_to_str (pid_to_ptid (pid
)));
1695 printf_unfiltered (_("Attaching to %s\n"),
1696 target_pid_to_str (pid_to_ptid (pid
)));
1698 gdb_flush (gdb_stdout
);
1701 if (pid
== 0 || kill (pid
, 0) < 0)
1702 error (_("Can't attach to process %d: %s (%d)"),
1703 pid
, safe_strerror (errno
), errno
);
1705 inferior_ptid
= pid_to_ptid (pid
);
1706 inf
= current_inferior ();
1707 inferior_appeared (inf
, pid
);
1708 inf
->attach_flag
= 1;
1710 /* Always add a main thread. */
1711 add_thread_silent (inferior_ptid
);
1713 darwin_attach_pid (inf
);
1715 darwin_suspend_inferior (inf
);
1717 darwin_init_thread_list (inf
);
1719 darwin_check_osabi (inf
->private, ptid_get_tid (inferior_ptid
));
1721 darwin_setup_fake_stop_event (inf
);
1723 inf
->private->no_ptrace
= 1;
1726 /* Take a program previously attached to and detaches it.
1727 The program resumes execution and will no longer stop
1728 on signals, etc. We'd better not have left any breakpoints
1729 in the program or it'll die when it hits one. For this
1730 to work, it may be necessary for the process to have been
1731 previously attached. It *might* work if the program was
1732 started via fork. */
1734 darwin_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
1736 pid_t pid
= ptid_get_pid (inferior_ptid
);
1737 struct inferior
*inf
= current_inferior ();
1741 /* Display message. */
1744 char *exec_file
= get_exec_file (0);
1747 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
1748 target_pid_to_str (pid_to_ptid (pid
)));
1749 gdb_flush (gdb_stdout
);
1752 /* If ptrace() is in use, stop the process. */
1753 if (!inf
->private->no_ptrace
)
1754 darwin_stop_inferior (inf
);
1756 kret
= darwin_restore_exception_ports (inf
->private);
1757 MACH_CHECK_ERROR (kret
);
1759 if (!inf
->private->no_ptrace
)
1761 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
1763 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1764 inf
->pid
, safe_strerror (errno
), errno
);
1767 darwin_reply_to_all_pending_messages (inf
);
1769 /* When using ptrace, we have just performed a PT_DETACH, which
1770 resumes the inferior. On the other hand, when we are not using
1771 ptrace, we need to resume its execution ourselves. */
1772 if (inf
->private->no_ptrace
)
1773 darwin_resume_inferior (inf
);
1775 darwin_mourn_inferior (ops
);
1779 darwin_files_info (struct target_ops
*ops
)
1784 darwin_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1786 static char buf
[80];
1787 long tid
= ptid_get_tid (ptid
);
1791 snprintf (buf
, sizeof (buf
), _("Thread 0x%lx of process %u"),
1792 tid
, ptid_get_pid (ptid
));
1796 return normal_pid_to_str (ptid
);
1800 darwin_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1805 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
1806 copy it to RDADDR in gdb's address space.
1807 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
1808 to ADDR in inferior task's address space.
1809 Return 0 on failure; number of bytes read / writen otherwise. */
1811 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
1812 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
1816 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
1817 mach_vm_address_t low_address
= (mach_vm_address_t
) (addr
- offset
);
1818 mach_vm_size_t aligned_length
= (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
1820 mach_msg_type_number_t copy_count
;
1821 mach_vm_size_t remaining_length
;
1822 mach_vm_address_t region_address
;
1823 mach_vm_size_t region_length
;
1825 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
1826 task
, core_addr_to_string (addr
), pulongest (length
));
1828 /* Get memory from inferior with page aligned addresses. */
1829 kret
= mach_vm_read (task
, low_address
, aligned_length
,
1830 &copied
, ©_count
);
1831 if (kret
!= KERN_SUCCESS
)
1834 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
1835 core_addr_to_string (addr
), mach_error_string (kret
));
1840 memcpy (rdaddr
, (char *)copied
+ offset
, length
);
1845 memcpy ((char *)copied
+ offset
, wraddr
, length
);
1847 /* Do writes atomically.
1848 First check for holes and unwritable memory. */
1849 for (region_address
= low_address
, remaining_length
= aligned_length
;
1850 region_address
< low_address
+ aligned_length
;
1851 region_address
+= region_length
, remaining_length
-= region_length
)
1853 vm_region_submap_short_info_data_64_t info
;
1854 mach_vm_address_t region_start
= region_address
;
1855 mach_msg_type_number_t count
;
1856 natural_t region_depth
;
1858 region_depth
= 100000;
1859 count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
1860 kret
= mach_vm_region_recurse
1861 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
1862 (vm_region_recurse_info_t
) &info
, &count
);
1864 if (kret
!= KERN_SUCCESS
)
1866 inferior_debug (1, _("darwin_read_write_inferior: "
1867 "mach_vm_region_recurse failed at %s: %s\n"),
1868 core_addr_to_string (region_address
),
1869 mach_error_string (kret
));
1874 (9, _("darwin_read_write_inferior: "
1875 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
1876 core_addr_to_string (region_address
),
1877 core_addr_to_string (region_start
),
1878 core_addr_to_string (region_length
));
1880 /* Check for holes in memory. */
1881 if (region_start
> region_address
)
1883 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
1884 core_addr_to_string (region_address
),
1885 core_addr_to_string (region_start
),
1886 (unsigned)region_length
);
1891 /* Adjust the length. */
1892 region_length
-= (region_address
- region_start
);
1894 if (!(info
.max_protection
& VM_PROT_WRITE
))
1896 kret
= mach_vm_protect
1897 (task
, region_address
, region_length
,
1898 TRUE
, info
.max_protection
| VM_PROT_WRITE
| VM_PROT_COPY
);
1899 if (kret
!= KERN_SUCCESS
)
1901 warning (_("darwin_read_write_inf: "
1902 "mach_vm_protect max failed at %s: %s"),
1903 core_addr_to_string (region_address
),
1904 mach_error_string (kret
));
1910 if (!(info
.protection
& VM_PROT_WRITE
))
1912 kret
= mach_vm_protect (task
, region_address
, region_length
,
1913 FALSE
, info
.protection
| VM_PROT_WRITE
);
1914 if (kret
!= KERN_SUCCESS
)
1916 warning (_("darwin_read_write_inf: "
1917 "mach_vm_protect failed at %s (len=0x%lx): %s"),
1918 core_addr_to_string (region_address
),
1919 (unsigned long)region_length
, mach_error_string (kret
));
1926 kret
= mach_vm_write (task
, low_address
, copied
, aligned_length
);
1928 if (kret
!= KERN_SUCCESS
)
1930 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
1931 mach_error_string (kret
));
1935 mach_vm_deallocate (mach_task_self (), copied
, copy_count
);
1939 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
1941 Return 0 on failure; number of bytes read / written otherwise. */
1943 #ifdef TASK_DYLD_INFO_COUNT
1944 /* This is not available in Darwin 9. */
1945 static enum target_xfer_status
1946 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
1947 ULONGEST length
, ULONGEST
*xfered_len
)
1949 struct task_dyld_info task_dyld_info
;
1950 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
1951 int sz
= TASK_DYLD_INFO_COUNT
* sizeof (natural_t
);
1955 return TARGET_XFER_EOF
;
1957 kret
= task_info (task
, TASK_DYLD_INFO
, (task_info_t
) &task_dyld_info
, &count
);
1958 MACH_CHECK_ERROR (kret
);
1959 if (kret
!= KERN_SUCCESS
)
1960 return TARGET_XFER_E_IO
;
1962 if (addr
+ length
> sz
)
1964 memcpy (rdaddr
, (char *)&task_dyld_info
+ addr
, length
);
1965 *xfered_len
= (ULONGEST
) length
;
1966 return TARGET_XFER_OK
;
1972 static enum target_xfer_status
1973 darwin_xfer_partial (struct target_ops
*ops
,
1974 enum target_object object
, const char *annex
,
1975 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1976 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1978 struct inferior
*inf
= current_inferior ();
1981 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
1982 core_addr_to_string (offset
), pulongest (len
),
1983 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
1988 case TARGET_OBJECT_MEMORY
:
1990 int l
= darwin_read_write_inferior (inf
->private->task
, offset
,
1991 readbuf
, writebuf
, len
);
1994 return TARGET_XFER_EOF
;
1998 *xfered_len
= (ULONGEST
) l
;
1999 return TARGET_XFER_OK
;
2002 #ifdef TASK_DYLD_INFO_COUNT
2003 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2004 if (writebuf
!= NULL
|| readbuf
== NULL
)
2006 /* Support only read. */
2007 return TARGET_XFER_E_IO
;
2009 return darwin_read_dyld_info (inf
->private->task
, offset
, readbuf
, len
,
2013 return TARGET_XFER_E_IO
;
2019 set_enable_mach_exceptions (char *args
, int from_tty
,
2020 struct cmd_list_element
*c
)
2022 if (!ptid_equal (inferior_ptid
, null_ptid
))
2024 struct inferior
*inf
= current_inferior ();
2025 exception_mask_t mask
;
2028 if (enable_mach_exceptions
)
2029 mask
= EXC_MASK_ALL
;
2032 darwin_restore_exception_ports (inf
->private);
2033 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2035 kret
= task_set_exception_ports (inf
->private->task
, mask
, darwin_ex_port
,
2036 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2037 MACH_CHECK_ERROR (kret
);
2042 darwin_pid_to_exec_file (struct target_ops
*self
, int pid
)
2044 static char path
[PATH_MAX
];
2047 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2055 darwin_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
2060 struct inferior
*inf
= current_inferior ();
2062 mach_port_name_array_t names
;
2063 mach_msg_type_number_t names_count
;
2064 mach_port_type_array_t types
;
2065 mach_msg_type_number_t types_count
;
2068 /* First linear search. */
2070 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2072 if (t
->inf_port
== lwp
)
2073 return ptid_build (ptid_get_pid (inferior_ptid
), 0, t
->gdb_port
);
2075 /* Maybe the port was never extract. Do it now. */
2077 /* First get inferior port names. */
2078 kret
= mach_port_names (inf
->private->task
, &names
, &names_count
, &types
,
2080 MACH_CHECK_ERROR (kret
);
2081 if (kret
!= KERN_SUCCESS
)
2084 /* For each name, copy the right in the gdb space and then compare with
2085 our view of the inferior threads. We don't forget to deallocate the
2087 for (i
= 0; i
< names_count
; i
++)
2089 mach_port_t local_name
;
2090 mach_msg_type_name_t local_type
;
2092 /* We just need to know the corresponding name in gdb name space.
2093 So extract and deallocate the right. */
2094 kret
= mach_port_extract_right (inf
->private->task
, names
[i
],
2095 MACH_MSG_TYPE_COPY_SEND
,
2096 &local_name
, &local_type
);
2097 if (kret
!= KERN_SUCCESS
)
2099 mach_port_deallocate (gdb_task
, local_name
);
2102 VEC_iterate (darwin_thread_t
, inf
->private->threads
, k
, t
);
2104 if (t
->gdb_port
== local_name
)
2106 t
->inf_port
= names
[i
];
2107 if (names
[i
] == lwp
)
2112 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2113 names_count
* sizeof (mach_port_t
));
2116 return ptid_build (ptid_get_pid (inferior_ptid
), 0, res
);
2122 darwin_supports_multi_process (struct target_ops
*self
)
2127 /* -Wmissing-prototypes */
2128 extern initialize_file_ftype _initialize_darwin_inferior
;
2131 _initialize_darwin_inferior (void)
2135 gdb_task
= mach_task_self ();
2136 darwin_host_self
= mach_host_self ();
2138 /* Read page size. */
2139 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2140 if (kret
!= KERN_SUCCESS
)
2142 mach_page_size
= 0x1000;
2143 MACH_CHECK_ERROR (kret
);
2146 darwin_ops
= inf_child_target ();
2148 darwin_ops
->to_create_inferior
= darwin_create_inferior
;
2149 darwin_ops
->to_attach
= darwin_attach
;
2150 darwin_ops
->to_attach_no_wait
= 0;
2151 darwin_ops
->to_detach
= darwin_detach
;
2152 darwin_ops
->to_files_info
= darwin_files_info
;
2153 darwin_ops
->to_wait
= darwin_wait_to
;
2154 darwin_ops
->to_mourn_inferior
= darwin_mourn_inferior
;
2155 darwin_ops
->to_kill
= darwin_kill_inferior
;
2156 darwin_ops
->to_stop
= darwin_stop
;
2157 darwin_ops
->to_resume
= darwin_resume_to
;
2158 darwin_ops
->to_thread_alive
= darwin_thread_alive
;
2159 darwin_ops
->to_pid_to_str
= darwin_pid_to_str
;
2160 darwin_ops
->to_pid_to_exec_file
= darwin_pid_to_exec_file
;
2161 darwin_ops
->to_load
= NULL
;
2162 darwin_ops
->to_xfer_partial
= darwin_xfer_partial
;
2163 darwin_ops
->to_supports_multi_process
= darwin_supports_multi_process
;
2164 darwin_ops
->to_get_ada_task_ptid
= darwin_get_ada_task_ptid
;
2166 darwin_complete_target (darwin_ops
);
2168 add_target (darwin_ops
);
2170 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"), mach_task_self (),
2173 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2174 &darwin_debug_flag
, _("\
2175 Set if printing inferior communication debugging statements."), _("\
2176 Show if printing inferior communication debugging statements."), NULL
,
2178 &setdebuglist
, &showdebuglist
);
2180 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2181 &enable_mach_exceptions
, _("\
2182 Set if mach exceptions are caught."), _("\
2183 Show if mach exceptions are caught."), _("\
2184 When this mode is on, all low level exceptions are reported before being\n\
2185 reported by the kernel."),
2186 &set_enable_mach_exceptions
, NULL
,
2187 &setlist
, &showlist
);