1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2019 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/>. */
23 /* Standard C includes. */
27 #include <mach/mach_error.h>
28 #include <mach/mach_init.h>
29 #include <mach/mach_port.h>
30 #include <mach/mach_vm.h>
31 #include <mach/port.h>
32 #include <mach/task.h>
33 #include <mach/thread_act.h>
34 #include <mach/vm_map.h>
39 #include <sys/ptrace.h>
40 #include <sys/signal.h>
42 #include <sys/syscall.h>
43 #include <sys/sysctl.h>
44 #include <sys/types.h>
47 /* Local non-gdb includes. */
48 #include "arch-utils.h"
50 #include "bfd/mach-o.h"
51 #include "common/filestuff.h"
52 #include "common/gdb_unlinker.h"
53 #include "common/pathstuff.h"
54 #include "common/scoped_fd.h"
55 #include "darwin-nat.h"
56 #include "event-top.h"
57 #include "filenames.h"
60 #include "gdbthread.h"
61 #include "inf-child.h"
64 #include "nat/fork-inferior.h"
74 Darwin kernel is Mach + BSD derived kernel. Note that they share the
75 same memory space and are linked together (ie there is no micro-kernel).
77 Although ptrace(2) is available on Darwin, it is not complete. We have
78 to use Mach calls to read and write memory and to modify registers. We
79 also use Mach to get inferior faults. As we cannot use select(2) or
80 signals with Mach port (the Mach communication channel), signals are
81 reported to gdb as an exception. Furthermore we detect death of the
82 inferior through a Mach notification message. This way we only wait
85 Some Mach documentation is available for Apple xnu source package or
89 #define PTRACE(CMD, PID, ADDR, SIG) \
90 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
92 static ptid_t
darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
);
94 static void darwin_ptrace_me (void);
96 static void darwin_ptrace_him (int pid
);
98 static void darwin_encode_reply (mig_reply_error_t
*reply
,
99 mach_msg_header_t
*hdr
, integer_t code
);
101 static void darwin_setup_request_notification (struct inferior
*inf
);
102 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
103 static void darwin_setup_exceptions (struct inferior
*inf
);
104 static void darwin_deallocate_threads (struct inferior
*inf
);
106 /* Task identifier of gdb. */
107 static task_t gdb_task
;
109 /* A copy of mach_host_self (). */
110 mach_port_t darwin_host_self
;
112 /* Exception port. */
113 mach_port_t darwin_ex_port
;
115 /* Port set, to wait for answer on all ports. */
116 mach_port_t darwin_port_set
;
119 static vm_size_t mach_page_size
;
121 /* If Set, catch all mach exceptions (before they are converted to signals
123 static int enable_mach_exceptions
;
125 /* Inferior that should report a fake stop event. */
126 static struct inferior
*darwin_inf_fake_stop
;
128 /* If non-NULL, the shell we actually invoke. See maybe_cache_shell
130 static const char *copied_shell
;
132 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
133 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
135 /* This controls output of inferior debugging. */
136 static unsigned int darwin_debug_flag
= 0;
138 /* Create a __TEXT __info_plist section in the executable so that gdb could
139 be signed. This is required to get an authorization for task_for_pid.
141 Once gdb is built, you must codesign it with any system-trusted signing
142 authority. See taskgated(8) for details. */
143 static const unsigned char info_plist
[]
144 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
145 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
146 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
147 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
148 "<plist version=\"1.0\">\n"
150 " <key>CFBundleIdentifier</key>\n"
151 " <string>org.gnu.gdb</string>\n"
152 " <key>CFBundleName</key>\n"
153 " <string>gdb</string>\n"
154 " <key>CFBundleVersion</key>\n"
155 " <string>1.0</string>\n"
156 " <key>SecTaskAccess</key>\n"
158 " <string>allowed</string>\n"
159 " <string>debug</string>\n"
164 static void inferior_debug (int level
, const char *fmt
, ...)
165 ATTRIBUTE_PRINTF (2, 3);
168 inferior_debug (int level
, const char *fmt
, ...)
172 if (darwin_debug_flag
< level
)
176 printf_unfiltered (_("[%d inferior]: "), getpid ());
177 vprintf_unfiltered (fmt
, ap
);
182 mach_check_error (kern_return_t ret
, const char *file
,
183 unsigned int line
, const char *func
)
185 if (ret
== KERN_SUCCESS
)
188 func
= _("[UNKNOWN]");
190 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
191 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
195 unparse_exception_type (unsigned int i
)
197 static char unknown_exception_buf
[32];
202 return "EXC_BAD_ACCESS";
203 case EXC_BAD_INSTRUCTION
:
204 return "EXC_BAD_INSTRUCTION";
206 return "EXC_ARITHMETIC";
208 return "EXC_EMULATION";
210 return "EXC_SOFTWARE";
212 return "EXC_BREAKPOINT";
214 return "EXC_SYSCALL";
215 case EXC_MACH_SYSCALL
:
216 return "EXC_MACH_SYSCALL";
218 return "EXC_RPC_ALERT";
222 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
223 return unknown_exception_buf
;
227 /* Set errno to zero, and then call ptrace with the given arguments.
228 If inferior debugging traces are on, then also print a debug
231 The returned value is the same as the value returned by ptrace,
232 except in the case where that value is -1 but errno is zero.
233 This case is documented to be a non-error situation, so we
234 return zero in that case. */
237 darwin_ptrace (const char *name
,
238 int request
, int pid
, caddr_t arg3
, int arg4
)
243 ret
= ptrace (request
, pid
, arg3
, arg4
);
244 if (ret
== -1 && errno
== 0)
247 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
248 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
249 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
254 cmp_thread_t (const void *l
, const void *r
)
256 thread_t tl
= *(const thread_t
*)l
;
257 thread_t tr
= *(const thread_t
*)r
;
258 return (int)(tl
- tr
);
262 darwin_check_new_threads (struct inferior
*inf
)
265 thread_array_t thread_list
;
266 unsigned int new_nbr
;
267 unsigned int old_nbr
;
268 unsigned int new_ix
, old_ix
;
269 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
270 std::vector
<darwin_thread_t
*> new_thread_vec
;
272 if (darwin_inf
== nullptr)
275 /* Get list of threads. */
276 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
277 MACH_CHECK_ERROR (kret
);
278 if (kret
!= KERN_SUCCESS
)
283 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
285 old_nbr
= darwin_inf
->threads
.size ();
287 /* Quick check for no changes. */
288 if (old_nbr
== new_nbr
)
292 for (i
= 0; i
< new_nbr
; i
++)
293 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
297 /* Deallocate ports. */
298 for (i
= 0; i
< new_nbr
; i
++)
300 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
301 MACH_CHECK_ERROR (kret
);
304 /* Deallocate the buffer. */
305 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
306 new_nbr
* sizeof (int));
307 MACH_CHECK_ERROR (kret
);
313 /* Full handling: detect new threads, remove dead threads. */
315 new_thread_vec
.reserve (new_nbr
);
317 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
319 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
321 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
322 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
325 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
326 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
328 if (old_id
== new_id
)
330 /* Thread still exist. */
331 new_thread_vec
.push_back (old
);
335 /* Deallocate the port. */
336 kret
= mach_port_deallocate (gdb_task
, new_id
);
337 MACH_CHECK_ERROR (kret
);
341 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
343 /* Ignore dead ports.
344 In some weird cases, we might get dead ports. They should
345 correspond to dead thread so they could safely be ignored. */
349 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
351 /* A thread was created. */
352 darwin_thread_info
*pti
= new darwin_thread_info
;
354 pti
->gdb_port
= new_id
;
355 pti
->msg_state
= DARWIN_RUNNING
;
357 /* Add the new thread. */
358 add_thread_with_info (ptid_t (inf
->pid
, 0, new_id
), pti
);
359 new_thread_vec
.push_back (pti
);
363 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
365 /* A thread was removed. */
366 struct thread_info
*thr
367 = find_thread_ptid (ptid_t (inf
->pid
, 0, old_id
));
369 kret
= mach_port_deallocate (gdb_task
, old_id
);
370 MACH_CHECK_ERROR (kret
);
374 gdb_assert_not_reached ("unexpected thread case");
377 darwin_inf
->threads
= std::move (new_thread_vec
);
379 /* Deallocate the buffer. */
380 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
381 new_nbr
* sizeof (int));
382 MACH_CHECK_ERROR (kret
);
386 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
388 darwin_inferior
*priv
= get_darwin_inferior (inf
);
390 return priv
!= nullptr && priv
->task
== *(task_t
*)port_ptr
;
394 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
396 return inf
->pid
== *(int *)pid_ptr
;
399 /* Return an inferior by task port. */
400 static struct inferior
*
401 darwin_find_inferior_by_task (task_t port
)
403 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
406 /* Return an inferior by pid port. */
407 static struct inferior
*
408 darwin_find_inferior_by_pid (int pid
)
410 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
413 /* Return a thread by port. */
414 static darwin_thread_t
*
415 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
417 darwin_inferior
*priv
= get_darwin_inferior (inf
);
420 for (darwin_thread_t
*t
: priv
->threads
)
422 if (t
->gdb_port
== thread
)
429 /* Suspend (ie stop) an inferior at Mach level. */
432 darwin_suspend_inferior (struct inferior
*inf
)
434 darwin_inferior
*priv
= get_darwin_inferior (inf
);
436 if (priv
!= nullptr && !priv
->suspended
)
440 kret
= task_suspend (priv
->task
);
441 MACH_CHECK_ERROR (kret
);
447 /* Resume an inferior at Mach level. */
450 darwin_resume_inferior (struct inferior
*inf
)
452 darwin_inferior
*priv
= get_darwin_inferior (inf
);
454 if (priv
!= nullptr && priv
->suspended
)
458 kret
= task_resume (priv
->task
);
459 MACH_CHECK_ERROR (kret
);
465 /* Iterator functions. */
468 darwin_suspend_inferior_it (struct inferior
*inf
, void *arg
)
470 darwin_suspend_inferior (inf
);
471 darwin_check_new_threads (inf
);
476 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
478 darwin_resume_inferior (inf
);
483 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
485 printf_unfiltered (_("message header:\n"));
486 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
487 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
488 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
489 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
490 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
491 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
495 const unsigned char *data
;
496 const unsigned int *ldata
;
500 data
= (unsigned char *)(hdr
+ 1);
501 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
503 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
505 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
506 mach_msg_port_descriptor_t
*desc
=
507 (mach_msg_port_descriptor_t
*)(bod
+ 1);
510 printf_unfiltered (_("body: descriptor_count=%u\n"),
511 bod
->msgh_descriptor_count
);
512 data
+= sizeof (mach_msg_body_t
);
513 size
-= sizeof (mach_msg_body_t
);
514 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
515 switch (desc
[k
].type
)
517 case MACH_MSG_PORT_DESCRIPTOR
:
519 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
520 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
523 printf_unfiltered (_(" descr %d: type=%u\n"),
527 data
+= bod
->msgh_descriptor_count
528 * sizeof (mach_msg_port_descriptor_t
);
529 size
-= bod
->msgh_descriptor_count
530 * sizeof (mach_msg_port_descriptor_t
);
531 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
533 (_("NDR: mig=%02x if=%02x encod=%02x "
534 "int=%02x char=%02x float=%02x\n"),
535 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
536 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
537 data
+= sizeof (NDR_record_t
);
538 size
-= sizeof (NDR_record_t
);
541 printf_unfiltered (_(" data:"));
542 ldata
= (const unsigned int *)data
;
543 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
544 printf_unfiltered (" %08x", ldata
[i
]);
545 printf_unfiltered (_("\n"));
549 /* Adjust inferior data when a new task was created. */
551 static struct inferior
*
552 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
555 struct inferior
*inf
;
559 /* Find the corresponding pid. */
560 kret
= pid_for_task (task_port
, &task_pid
);
561 if (kret
!= KERN_SUCCESS
)
563 MACH_CHECK_ERROR (kret
);
567 /* Find the inferior for this pid. */
568 inf
= darwin_find_inferior_by_pid (task_pid
);
572 darwin_inferior
*priv
= get_darwin_inferior (inf
);
574 /* Deallocate saved exception ports. */
575 darwin_deallocate_exception_ports (priv
);
577 /* No need to remove dead_name notification, but still... */
578 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
579 MACH_NOTIFY_DEAD_NAME
, 0,
581 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
583 if (kret
!= KERN_INVALID_ARGUMENT
)
584 MACH_CHECK_ERROR (kret
);
586 /* Replace old task port. */
587 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
588 MACH_CHECK_ERROR (kret
);
589 priv
->task
= task_port
;
591 darwin_setup_request_notification (inf
);
592 darwin_setup_exceptions (inf
);
597 /* Check data representation. */
600 darwin_check_message_ndr (NDR_record_t
*ndr
)
602 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
603 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
604 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
605 || ndr
->int_rep
!= NDR_record
.int_rep
606 || ndr
->char_rep
!= NDR_record
.char_rep
607 || ndr
->float_rep
!= NDR_record
.float_rep
)
612 /* Decode an exception message. */
615 darwin_decode_exception_message (mach_msg_header_t
*hdr
,
616 struct inferior
**pinf
,
617 darwin_thread_t
**pthread
)
619 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
620 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
623 struct inferior
*inf
;
624 darwin_thread_t
*thread
;
626 thread_t thread_port
;
630 /* Check message destination. */
631 if (hdr
->msgh_local_port
!= darwin_ex_port
)
634 /* Check message header. */
635 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
638 /* Check descriptors. */
639 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
640 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
641 || bod
->msgh_descriptor_count
!= 2
642 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
643 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
644 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
645 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
648 /* Check data representation. */
649 ndr
= (NDR_record_t
*)(desc
+ 2);
650 if (darwin_check_message_ndr (ndr
) != 0)
653 /* Ok, the hard work. */
654 data
= (integer_t
*)(ndr
+ 1);
656 task_port
= desc
[1].name
;
657 thread_port
= desc
[0].name
;
659 /* Find process by port. */
660 inf
= darwin_find_inferior_by_task (task_port
);
663 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
664 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
666 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
667 as a new Mach task is created when a process exec. */
668 inf
= darwin_find_new_inferior (task_port
, thread_port
);
673 /* Deallocate task_port, unless it was saved. */
674 kret
= mach_port_deallocate (mach_task_self (), task_port
);
675 MACH_CHECK_ERROR (kret
);
680 /* We got new rights to the task, get rid of it. Do not get rid of
681 thread right, as we will need it to find the thread. */
682 kret
= mach_port_deallocate (mach_task_self (), task_port
);
683 MACH_CHECK_ERROR (kret
);
688 /* Not a known inferior. This could happen if the child fork, as
689 the created process will inherit its exception port.
690 FIXME: should the exception port be restored ? */
692 mig_reply_error_t reply
;
695 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
698 /* Free thread port (we don't know it). */
699 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
700 MACH_CHECK_ERROR (kret
);
702 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
704 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
705 reply
.Head
.msgh_size
, 0,
706 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
708 MACH_CHECK_ERROR (kret
);
713 /* Find thread by port. */
714 /* Check for new threads. Do it early so that the port in the exception
715 message can be deallocated. */
716 darwin_check_new_threads (inf
);
718 /* Free the thread port (as gdb knows the thread, it has already has a right
719 for it, so this just decrement a reference counter). */
720 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
721 MACH_CHECK_ERROR (kret
);
723 thread
= darwin_find_thread (inf
, thread_port
);
728 /* The thread should be running. However we have observed cases where a
729 thread got a SIGTTIN message after being stopped. */
730 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
732 /* Finish decoding. */
733 thread
->event
.header
= *hdr
;
734 thread
->event
.thread_port
= thread_port
;
735 thread
->event
.task_port
= task_port
;
736 thread
->event
.ex_type
= data
[0];
737 thread
->event
.data_count
= data
[1];
739 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
740 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
741 + data
[1] * sizeof (integer_t
)))
743 for (i
= 0; i
< data
[1]; i
++)
744 thread
->event
.ex_data
[i
] = data
[2 + i
];
746 thread
->msg_state
= DARWIN_MESSAGE
;
751 /* Decode dead_name notify message. */
754 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
756 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
757 integer_t
*data
= (integer_t
*)(ndr
+ 1);
758 struct inferior
*inf
;
761 /* Check message header. */
762 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
765 /* Check descriptors. */
766 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
769 /* Check data representation. */
770 if (darwin_check_message_ndr (ndr
) != 0)
775 /* Find process by port. */
776 inf
= darwin_find_inferior_by_task (task_port
);
779 /* Check message destination. */
782 darwin_inferior
*priv
= get_darwin_inferior (inf
);
783 if (hdr
->msgh_local_port
!= priv
->notify_port
)
791 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
794 mach_msg_header_t
*rh
= &reply
->Head
;
796 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
797 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
798 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
799 rh
->msgh_local_port
= MACH_PORT_NULL
;
800 rh
->msgh_id
= hdr
->msgh_id
+ 100;
802 reply
->NDR
= NDR_record
;
803 reply
->RetCode
= code
;
807 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
810 mig_reply_error_t reply
;
811 darwin_inferior
*priv
= get_darwin_inferior (inf
);
813 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
815 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
816 reply
.Head
.msgh_size
, 0,
817 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
819 MACH_CHECK_ERROR (kret
);
821 priv
->pending_messages
--;
824 /* Wrapper around the __pthread_kill syscall. We use this instead of the
825 pthread_kill function to be able to send a signal to any kind of thread,
826 including GCD threads. */
829 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
832 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
833 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
839 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
840 int step
, int nsignal
)
843 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
844 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
846 switch (thread
->msg_state
)
849 if (thread
->event
.ex_type
== EXC_SOFTWARE
850 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
852 /* Either deliver a new signal or cancel the signal received. */
853 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
854 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
856 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
860 /* Note: ptrace is allowed only if the process is stopped.
861 Directly send the signal to the thread. */
862 int res
= darwin_pthread_kill (thread
, nsignal
);
863 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
864 thread
->gdb_port
, nsignal
, res
);
865 thread
->signaled
= 1;
868 /* Set or reset single step. */
869 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
870 thread
->gdb_port
, step
);
871 darwin_set_sstep (thread
->gdb_port
, step
);
872 thread
->single_step
= step
;
874 darwin_send_reply (inf
, thread
);
875 thread
->msg_state
= DARWIN_RUNNING
;
882 kern_return_t kret
= thread_resume (thread
->gdb_port
);
883 MACH_CHECK_ERROR (kret
);
885 thread
->msg_state
= DARWIN_RUNNING
;
890 /* Resume all threads of the inferior. */
893 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
895 darwin_inferior
*priv
= get_darwin_inferior (inf
);
898 for (darwin_thread_t
*thread
: priv
->threads
)
899 darwin_resume_thread (inf
, thread
, step
, nsignal
);
902 struct resume_inferior_threads_param
909 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
911 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
912 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
914 darwin_resume_inferior_threads (inf
, step
, nsignal
);
919 /* Suspend all threads of INF. */
922 darwin_suspend_inferior_threads (struct inferior
*inf
)
924 darwin_inferior
*priv
= get_darwin_inferior (inf
);
926 for (darwin_thread_t
*thread
: priv
->threads
)
928 switch (thread
->msg_state
)
935 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
936 MACH_CHECK_ERROR (kret
);
937 thread
->msg_state
= DARWIN_STOPPED
;
945 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
947 struct target_waitstatus status
;
952 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
953 ptid
.pid (), ptid
.tid (), step
, signal
);
955 if (signal
== GDB_SIGNAL_0
)
958 nsignal
= gdb_signal_to_host (signal
);
960 /* Don't try to single step all threads. */
962 ptid
= inferior_ptid
;
964 /* minus_one_ptid is RESUME_ALL. */
965 if (ptid
== minus_one_ptid
)
967 struct resume_inferior_threads_param param
;
969 param
.nsignal
= nsignal
;
972 /* Resume threads. */
973 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
975 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
979 struct inferior
*inf
= find_inferior_ptid (ptid
);
980 long tid
= ptid
.tid ();
982 /* Stop the inferior (should be useless). */
983 darwin_suspend_inferior (inf
);
986 darwin_resume_inferior_threads (inf
, step
, nsignal
);
989 darwin_thread_t
*thread
;
991 /* Suspend threads of the task. */
992 darwin_suspend_inferior_threads (inf
);
994 /* Resume the selected thread. */
995 thread
= darwin_find_thread (inf
, tid
);
997 darwin_resume_thread (inf
, thread
, step
, nsignal
);
1000 /* Resume the task. */
1001 darwin_resume_inferior (inf
);
1006 darwin_decode_message (mach_msg_header_t
*hdr
,
1007 darwin_thread_t
**pthread
,
1008 struct inferior
**pinf
,
1009 struct target_waitstatus
*status
)
1011 darwin_thread_t
*thread
;
1012 struct inferior
*inf
;
1014 /* Exception message. 2401 == 0x961 is exc. */
1015 if (hdr
->msgh_id
== 2401)
1019 /* Decode message. */
1020 res
= darwin_decode_exception_message (hdr
, &inf
, &thread
);
1024 /* Should not happen... */
1026 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1027 /* FIXME: send a failure reply? */
1028 status
->kind
= TARGET_WAITKIND_IGNORE
;
1029 return minus_one_ptid
;
1033 status
->kind
= TARGET_WAITKIND_IGNORE
;
1034 return minus_one_ptid
;
1039 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1041 priv
->pending_messages
++;
1043 status
->kind
= TARGET_WAITKIND_STOPPED
;
1044 thread
->msg_state
= DARWIN_MESSAGE
;
1046 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1048 unparse_exception_type (thread
->event
.ex_type
));
1050 switch (thread
->event
.ex_type
)
1052 case EXC_BAD_ACCESS
:
1053 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1055 case EXC_BAD_INSTRUCTION
:
1056 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1058 case EXC_ARITHMETIC
:
1059 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1062 status
->value
.sig
= GDB_EXC_EMULATION
;
1065 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1068 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1069 inferior_debug (5, _(" (signal %d: %s)\n"),
1070 thread
->event
.ex_data
[1],
1071 gdb_signal_to_name (status
->value
.sig
));
1073 /* If the thread is stopped because it has received a signal
1074 that gdb has just sent, continue. */
1075 if (thread
->signaled
)
1077 thread
->signaled
= 0;
1078 darwin_send_reply (inf
, thread
);
1079 thread
->msg_state
= DARWIN_RUNNING
;
1080 status
->kind
= TARGET_WAITKIND_IGNORE
;
1084 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1086 case EXC_BREAKPOINT
:
1087 /* Many internal GDB routines expect breakpoints to be reported
1088 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1089 as a spurious signal. */
1090 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1093 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1097 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1099 else if (hdr
->msgh_id
== 0x48)
1101 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1104 res
= darwin_decode_notify_message (hdr
, &inf
);
1108 /* Should not happen... */
1110 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1117 if (res
< 0 || inf
== NULL
)
1119 status
->kind
= TARGET_WAITKIND_IGNORE
;
1120 return minus_one_ptid
;
1125 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1127 if (!priv
->no_ptrace
)
1132 res
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1133 if (res
< 0 || res
!= inf
->pid
)
1135 printf_unfiltered (_("wait4: res=%d: %s\n"),
1136 res
, safe_strerror (errno
));
1137 status
->kind
= TARGET_WAITKIND_IGNORE
;
1138 return minus_one_ptid
;
1140 if (WIFEXITED (wstatus
))
1142 status
->kind
= TARGET_WAITKIND_EXITED
;
1143 status
->value
.integer
= WEXITSTATUS (wstatus
);
1147 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1148 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1151 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1154 /* Looks necessary on Leopard and harmless... */
1155 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1157 inferior_ptid
= ptid_t (inf
->pid
, 0, 0);
1158 return inferior_ptid
;
1162 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1163 status
->kind
= TARGET_WAITKIND_EXITED
;
1164 status
->value
.integer
= 0; /* Don't know. */
1165 return ptid_t (inf
->pid
, 0, 0);
1170 /* Unknown message. */
1171 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1172 status
->kind
= TARGET_WAITKIND_IGNORE
;
1173 return minus_one_ptid
;
1177 cancel_breakpoint (ptid_t ptid
)
1179 /* Arrange for a breakpoint to be hit again later. We will handle
1180 the current event, eventually we will resume this thread, and this
1181 breakpoint will trap again.
1183 If we do not do this, then we run the risk that the user will
1184 delete or disable the breakpoint, but the thread will have already
1187 struct regcache
*regcache
= get_thread_regcache (ptid
);
1188 struct gdbarch
*gdbarch
= regcache
->arch ();
1191 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1192 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1194 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1195 (unsigned long) ptid
.tid ());
1197 /* Back up the PC if necessary. */
1198 if (gdbarch_decr_pc_after_break (gdbarch
))
1199 regcache_write_pc (regcache
, pc
);
1207 darwin_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1212 mach_msg_header_t hdr
;
1215 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1217 darwin_thread_t
*thread
;
1218 struct inferior
*inf
;
1221 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1222 ptid
.pid (), ptid
.tid ());
1224 /* Handle fake stop events at first. */
1225 if (darwin_inf_fake_stop
!= NULL
)
1227 inf
= darwin_inf_fake_stop
;
1228 darwin_inf_fake_stop
= NULL
;
1230 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1232 status
->kind
= TARGET_WAITKIND_STOPPED
;
1233 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1234 thread
= priv
->threads
[0];
1235 thread
->msg_state
= DARWIN_STOPPED
;
1236 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1241 /* set_sigint_trap (); */
1243 /* Wait for a message. */
1244 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1245 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1247 /* clear_sigint_trap (); */
1249 if (kret
== MACH_RCV_INTERRUPTED
)
1251 status
->kind
= TARGET_WAITKIND_IGNORE
;
1252 return minus_one_ptid
;
1255 if (kret
!= MACH_MSG_SUCCESS
)
1257 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1258 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1259 return minus_one_ptid
;
1262 /* Debug: display message. */
1263 if (darwin_debug_flag
> 10)
1264 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1266 res
= darwin_decode_message (hdr
, &thread
, &inf
, status
);
1267 if (res
== minus_one_ptid
)
1270 /* Early return in case an inferior has exited. */
1274 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1276 /* Stop all tasks. */
1277 iterate_over_inferiors (darwin_suspend_inferior_it
, NULL
);
1279 /* Read pending messages. */
1282 struct target_waitstatus status2
;
1285 kret
= mach_msg (&msgin
.hdr
,
1286 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1287 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1289 if (kret
== MACH_RCV_TIMED_OUT
)
1291 if (kret
!= MACH_MSG_SUCCESS
)
1294 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1298 /* Debug: display message. */
1299 if (darwin_debug_flag
> 10)
1300 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1302 ptid2
= darwin_decode_message (hdr
, &thread
, &inf
, &status2
);
1304 if (inf
!= NULL
&& thread
!= NULL
1305 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1307 if (thread
->single_step
1308 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1310 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1311 darwin_send_reply (inf
, thread
);
1312 thread
->msg_state
= DARWIN_RUNNING
;
1316 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1320 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1326 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1329 return darwin_wait (ptid
, status
);
1333 darwin_nat_target::interrupt ()
1335 struct inferior
*inf
= current_inferior ();
1336 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1338 /* FIXME: handle in no_ptrace mode. */
1339 gdb_assert (!priv
->no_ptrace
);
1340 ::kill (inf
->pid
, SIGINT
);
1343 /* Deallocate threads port and vector. */
1346 darwin_deallocate_threads (struct inferior
*inf
)
1348 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1350 for (darwin_thread_t
*t
: priv
->threads
)
1352 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1353 MACH_CHECK_ERROR (kret
);
1356 priv
->threads
.clear ();
1360 darwin_nat_target::mourn_inferior ()
1362 struct inferior
*inf
= current_inferior ();
1363 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1367 /* Deallocate threads. */
1368 darwin_deallocate_threads (inf
);
1370 /* Remove notify_port from darwin_port_set. */
1371 kret
= mach_port_move_member (gdb_task
,
1372 priv
->notify_port
, MACH_PORT_NULL
);
1373 MACH_CHECK_ERROR (kret
);
1375 /* Remove task port dead_name notification. */
1376 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1377 MACH_NOTIFY_DEAD_NAME
, 0,
1379 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1381 /* This can fail if the task is dead. */
1382 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1383 priv
->task
, prev
, priv
->notify_port
);
1385 if (kret
== KERN_SUCCESS
)
1387 kret
= mach_port_deallocate (gdb_task
, prev
);
1388 MACH_CHECK_ERROR (kret
);
1391 /* Destroy notify_port. */
1392 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1393 MACH_CHECK_ERROR (kret
);
1395 /* Deallocate saved exception ports. */
1396 darwin_deallocate_exception_ports (priv
);
1398 /* Deallocate task port. */
1399 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1400 MACH_CHECK_ERROR (kret
);
1404 inf_child_target::mourn_inferior ();
1408 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1410 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1412 for (darwin_thread_t
*t
: priv
->threads
)
1414 if (t
->msg_state
== DARWIN_MESSAGE
)
1415 darwin_resume_thread (inf
, t
, 0, 0);
1420 darwin_stop_inferior (struct inferior
*inf
)
1422 struct target_waitstatus wstatus
;
1425 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1427 gdb_assert (inf
!= NULL
);
1429 darwin_suspend_inferior (inf
);
1431 darwin_reply_to_all_pending_messages (inf
);
1433 if (priv
->no_ptrace
)
1436 res
= kill (inf
->pid
, SIGSTOP
);
1438 warning (_("cannot kill: %s"), safe_strerror (errno
));
1440 /* Wait until the process is really stopped. */
1443 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1444 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1445 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1450 static kern_return_t
1451 darwin_save_exception_ports (darwin_inferior
*inf
)
1455 inf
->exception_info
.count
=
1456 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1458 kret
= task_get_exception_ports
1459 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1460 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1461 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1465 static kern_return_t
1466 darwin_restore_exception_ports (darwin_inferior
*inf
)
1471 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1473 kret
= task_set_exception_ports
1474 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1475 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1476 if (kret
!= KERN_SUCCESS
)
1480 return KERN_SUCCESS
;
1483 /* Deallocate saved exception ports. */
1486 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1491 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1493 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1494 MACH_CHECK_ERROR (kret
);
1496 inf
->exception_info
.count
= 0;
1500 darwin_setup_exceptions (struct inferior
*inf
)
1502 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1504 exception_mask_t mask
;
1506 kret
= darwin_save_exception_ports (priv
);
1507 if (kret
!= KERN_SUCCESS
)
1508 error (_("Unable to save exception ports, task_get_exception_ports"
1512 /* Set exception port. */
1513 if (enable_mach_exceptions
)
1514 mask
= EXC_MASK_ALL
;
1516 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1517 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1518 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1519 if (kret
!= KERN_SUCCESS
)
1520 error (_("Unable to set exception ports, task_set_exception_ports"
1526 darwin_nat_target::kill ()
1528 struct inferior
*inf
= current_inferior ();
1529 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1530 struct target_waitstatus wstatus
;
1535 if (inferior_ptid
== null_ptid
)
1538 gdb_assert (inf
!= NULL
);
1540 kret
= darwin_restore_exception_ports (priv
);
1541 MACH_CHECK_ERROR (kret
);
1543 darwin_reply_to_all_pending_messages (inf
);
1545 res
= ::kill (inf
->pid
, 9);
1549 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1550 does not work as expected.
1551 When the kill function is called, the SIGKILL signal is received
1552 by gdb whereas it should have been received by the kernel since
1553 the exception ports have been restored.
1554 This behavior is not the expected one thus gdb does not reply to
1555 the received SIGKILL message. This situation leads to a "busy"
1556 resource from the kernel point of view and the inferior is never
1557 released, causing it to remain as a zombie process, even after
1559 To work around this, we mark all the threads of the inferior as
1560 signaled thus darwin_decode_message function knows that the kill
1561 signal was sent by gdb and will take the appropriate action
1562 (cancel signal and reply to the signal message). */
1563 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1564 for (darwin_thread_t
*thread
: priv
->threads
)
1565 thread
->signaled
= 1;
1567 darwin_resume_inferior (inf
);
1569 ptid
= darwin_wait (inferior_ptid
, &wstatus
);
1571 else if (errno
!= ESRCH
)
1572 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1573 inf
->pid
, safe_strerror (errno
));
1575 target_mourn_inferior (inferior_ptid
);
1579 darwin_setup_request_notification (struct inferior
*inf
)
1581 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1583 mach_port_t prev_not
;
1585 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1586 MACH_NOTIFY_DEAD_NAME
, 0,
1588 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1590 if (kret
!= KERN_SUCCESS
)
1591 error (_("Termination notification request failed, "
1592 "mach_port_request_notification\n"
1595 if (prev_not
!= MACH_PORT_NULL
)
1597 /* This is unexpected, as there should not be any previously
1598 registered notification request. But this is not a fatal
1599 issue, so just emit a warning. */
1601 A task termination request was registered before the debugger registered\n\
1602 its own. This is unexpected, but should otherwise not have any actual\n\
1603 impact on the debugging session."));
1608 darwin_attach_pid (struct inferior
*inf
)
1612 darwin_inferior
*priv
= new darwin_inferior
;
1613 inf
->priv
.reset (priv
);
1617 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1618 if (kret
!= KERN_SUCCESS
)
1622 if (!inf
->attach_flag
)
1625 waitpid (inf
->pid
, &status
, 0);
1629 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1630 " (please check gdb is codesigned - see taskgated(8))"),
1631 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1634 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1635 priv
->task
, inf
->pid
);
1637 if (darwin_ex_port
== MACH_PORT_NULL
)
1639 /* Create a port to get exceptions. */
1640 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1642 if (kret
!= KERN_SUCCESS
)
1643 error (_("Unable to create exception port, mach_port_allocate "
1647 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1649 MACH_MSG_TYPE_MAKE_SEND
);
1650 if (kret
!= KERN_SUCCESS
)
1651 error (_("Unable to create exception port, mach_port_insert_right "
1655 /* Create a port set and put ex_port in it. */
1656 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1658 if (kret
!= KERN_SUCCESS
)
1659 error (_("Unable to create port set, mach_port_allocate "
1663 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1665 if (kret
!= KERN_SUCCESS
)
1666 error (_("Unable to move exception port into new port set, "
1667 "mach_port_move_member\n"
1672 /* Create a port to be notified when the child task terminates. */
1673 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1674 &priv
->notify_port
);
1675 if (kret
!= KERN_SUCCESS
)
1676 error (_("Unable to create notification port, mach_port_allocate "
1680 kret
= mach_port_move_member (gdb_task
,
1681 priv
->notify_port
, darwin_port_set
);
1682 if (kret
!= KERN_SUCCESS
)
1683 error (_("Unable to move notification port into new port set, "
1684 "mach_port_move_member\n"
1688 darwin_setup_request_notification (inf
);
1690 darwin_setup_exceptions (inf
);
1692 CATCH (ex
, RETURN_MASK_ALL
)
1694 exit_inferior (inf
);
1695 inferior_ptid
= null_ptid
;
1697 throw_exception (ex
);
1701 target_ops
*darwin_ops
= get_native_target ();
1702 if (!target_is_pushed (darwin_ops
))
1703 push_target (darwin_ops
);
1706 /* Get the thread_info object corresponding to this darwin_thread_info. */
1708 static struct thread_info
*
1709 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1711 for (struct thread_info
*it
: all_threads ())
1713 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1715 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1719 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1723 darwin_init_thread_list (struct inferior
*inf
)
1725 darwin_check_new_threads (inf
);
1727 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1729 gdb_assert (!priv
->threads
.empty ());
1731 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1732 struct thread_info
*first_thread
1733 = thread_info_from_private_thread_info (first_pti
);
1735 inferior_ptid
= first_thread
->ptid
;
1738 /* The child must synchronize with gdb: gdb must set the exception port
1739 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1740 FIXME: is there a lighter way ? */
1741 static int ptrace_fds
[2];
1744 darwin_ptrace_me (void)
1749 /* Close write end point. */
1750 if (close (ptrace_fds
[1]) < 0)
1751 trace_start_error_with_name ("close");
1753 /* Wait until gdb is ready. */
1754 res
= read (ptrace_fds
[0], &c
, 1);
1756 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1758 if (close (ptrace_fds
[0]) < 0)
1759 trace_start_error_with_name ("close");
1761 /* Get rid of privileges. */
1762 if (setegid (getgid ()) < 0)
1763 trace_start_error_with_name ("setegid");
1766 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1767 trace_start_error_with_name ("PTRACE");
1769 /* Redirect signals to exception port. */
1770 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1771 trace_start_error_with_name ("PTRACE");
1774 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1776 darwin_pre_ptrace (void)
1778 if (pipe (ptrace_fds
) != 0)
1782 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1785 mark_fd_no_cloexec (ptrace_fds
[0]);
1786 mark_fd_no_cloexec (ptrace_fds
[1]);
1790 darwin_ptrace_him (int pid
)
1792 struct inferior
*inf
= current_inferior ();
1794 darwin_attach_pid (inf
);
1796 /* Let's the child run. */
1797 close (ptrace_fds
[0]);
1798 close (ptrace_fds
[1]);
1800 unmark_fd_no_cloexec (ptrace_fds
[0]);
1801 unmark_fd_no_cloexec (ptrace_fds
[1]);
1803 darwin_init_thread_list (inf
);
1805 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1809 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1811 posix_spawnattr_t attr
;
1815 res
= posix_spawnattr_init (&attr
);
1819 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1823 /* Do like execve: replace the image. */
1824 ps_flags
= POSIX_SPAWN_SETEXEC
;
1826 /* Disable ASLR. The constant doesn't look to be available outside the
1827 kernel include files. */
1828 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1829 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1831 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1832 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1835 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1839 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1842 /* Read kernel version, and return TRUE if this host may have System
1843 Integrity Protection (Sierra or later). */
1849 size_t sz
= sizeof (str
);
1852 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1853 if (ret
== 0 && sz
< sizeof (str
))
1855 unsigned long ver
= strtoul (str
, NULL
, 10);
1862 /* A helper for maybe_cache_shell. This copies the shell to the
1863 cache. It will throw an exception on any failure. */
1866 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1868 scoped_fd
from_fd (gdb_open_cloexec (shell
, O_RDONLY
, 0));
1869 if (from_fd
.get () < 0)
1870 error (_("Could not open shell (%s) for reading: %s"),
1871 shell
, safe_strerror (errno
));
1873 std::string new_dir
= ldirname (new_name
.c_str ());
1874 if (!mkdir_recursive (new_dir
.c_str ()))
1875 error (_("Could not make cache directory \"%s\": %s"),
1876 new_dir
.c_str (), safe_strerror (errno
));
1878 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1879 scoped_fd
to_fd (gdb_mkostemp_cloexec (&temp_name
[0]));
1880 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1882 if (to_fd
.get () < 0)
1883 error (_("Could not open temporary file \"%s\" for writing: %s"),
1884 temp_name
.data (), safe_strerror (errno
));
1886 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1887 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1888 error (_("Could not copy shell to cache as \"%s\": %s"),
1889 temp_name
.data (), safe_strerror (errno
));
1891 /* Be sure that the caching is atomic so that we don't get bad
1892 results from multiple copies of gdb running at the same time. */
1893 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1894 error (_("Could not rename shell cache file to \"%s\": %s"),
1895 new_name
.c_str (), safe_strerror (errno
));
1897 unlink_file_on_error
.keep ();
1900 /* If $SHELL is restricted, try to cache a copy. Starting with El
1901 Capitan, macOS introduced System Integrity Protection. Among other
1902 things, this prevents certain executables from being ptrace'd. In
1903 particular, executables in /bin, like most shells, are affected.
1904 To work around this, while preserving command-line glob expansion
1905 and redirections, gdb will cache a copy of the shell. Return true
1906 if all is well -- either the shell is not subject to SIP or it has
1907 been successfully cached. Returns false if something failed. */
1910 maybe_cache_shell ()
1912 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1913 given file is subject to SIP. */
1914 #ifdef SF_RESTRICTED
1916 /* If a check fails we want to revert -- maybe the user deleted the
1917 cache while gdb was running, or something like that. */
1918 copied_shell
= nullptr;
1920 const char *shell
= get_shell ();
1921 if (!IS_ABSOLUTE_PATH (shell
))
1923 warning (_("This version of macOS has System Integrity Protection.\n\
1924 Normally gdb would try to work around this by caching a copy of your shell,\n\
1925 but because your shell (%s) is not an absolute path, this is being skipped."),
1931 if (stat (shell
, &sb
) < 0)
1933 warning (_("This version of macOS has System Integrity Protection.\n\
1934 Normally gdb would try to work around this by caching a copy of your shell,\n\
1935 but because gdb could not stat your shell (%s), this is being skipped.\n\
1936 The error was: %s"),
1937 shell
, safe_strerror (errno
));
1941 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1944 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1945 std::string new_name
= get_standard_cache_dir ();
1946 /* There's no need to insert a directory separator here, because
1947 SHELL is known to be absolute. */
1948 new_name
.append (shell
);
1950 /* Maybe it was cached by some earlier gdb. */
1951 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1955 copy_shell_to_cache (shell
, new_name
);
1957 CATCH (ex
, RETURN_MASK_ERROR
)
1959 warning (_("This version of macOS has System Integrity Protection.\n\
1960 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1961 caching a copy of your shell. However, this failed:\n\
1963 If you correct the problem, gdb will automatically try again the next time\n\
1964 you \"run\". To prevent these attempts, you can use:\n\
1965 set startup-with-shell off"),
1971 printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1972 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1973 caching a copy of your shell. The shell used by \"run\" is now:\n\
1978 /* We need to make sure that the new name has the correct lifetime. */
1979 static std::string saved_shell
= std::move (new_name
);
1980 copied_shell
= saved_shell
.c_str ();
1982 #endif /* SF_RESTRICTED */
1988 darwin_nat_target::create_inferior (const char *exec_file
,
1989 const std::string
&allargs
,
1990 char **env
, int from_tty
)
1992 gdb::optional
<scoped_restore_tmpl
<int>> restore_startup_with_shell
;
1994 if (startup_with_shell
&& may_have_sip ())
1996 if (!maybe_cache_shell ())
1998 warning (_("startup-with-shell is now temporarily disabled"));
1999 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
2003 /* Do the hard work. */
2004 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
2005 darwin_ptrace_him
, darwin_pre_ptrace
, copied_shell
,
2010 /* Set things up such that the next call to darwin_wait will immediately
2011 return a fake stop event for inferior INF.
2013 This assumes that the inferior's thread list has been initialized,
2014 as it will suspend the inferior's first thread. */
2017 darwin_setup_fake_stop_event (struct inferior
*inf
)
2019 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2020 darwin_thread_t
*thread
;
2023 gdb_assert (darwin_inf_fake_stop
== NULL
);
2024 darwin_inf_fake_stop
= inf
;
2026 /* When detecting a fake pending stop event, darwin_wait returns
2027 an event saying that the first thread is in a DARWIN_STOPPED
2028 state. To make that accurate, we need to suspend that thread
2029 as well. Otherwise, we'll try resuming it when resuming the
2030 inferior, and get a warning because the thread's suspend count
2031 is already zero, making the resume request useless. */
2032 thread
= priv
->threads
[0];
2033 kret
= thread_suspend (thread
->gdb_port
);
2034 MACH_CHECK_ERROR (kret
);
2037 /* Attach to process PID, then initialize for debugging it
2038 and wait for the trace-trap that results from attaching. */
2040 darwin_nat_target::attach (const char *args
, int from_tty
)
2043 struct inferior
*inf
;
2045 pid
= parse_pid_to_attach (args
);
2047 if (pid
== getpid ()) /* Trying to masturbate? */
2048 error (_("I refuse to debug myself!"));
2052 char *exec_file
= get_exec_file (0);
2055 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
2056 target_pid_to_str (ptid_t (pid
)).c_str ());
2058 printf_unfiltered (_("Attaching to %s\n"),
2059 target_pid_to_str (ptid_t (pid
)).c_str ());
2062 if (pid
== 0 || ::kill (pid
, 0) < 0)
2063 error (_("Can't attach to process %d: %s (%d)"),
2064 pid
, safe_strerror (errno
), errno
);
2066 inferior_ptid
= ptid_t (pid
);
2067 inf
= current_inferior ();
2068 inferior_appeared (inf
, pid
);
2069 inf
->attach_flag
= 1;
2071 darwin_attach_pid (inf
);
2073 darwin_suspend_inferior (inf
);
2075 darwin_init_thread_list (inf
);
2077 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2079 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2081 darwin_setup_fake_stop_event (inf
);
2083 priv
->no_ptrace
= 1;
2086 /* Take a program previously attached to and detaches it.
2087 The program resumes execution and will no longer stop
2088 on signals, etc. We'd better not have left any breakpoints
2089 in the program or it'll die when it hits one. For this
2090 to work, it may be necessary for the process to have been
2091 previously attached. It *might* work if the program was
2092 started via fork. */
2095 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2097 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2101 /* Display message. */
2102 target_announce_detach (from_tty
);
2104 /* If ptrace() is in use, stop the process. */
2105 if (!priv
->no_ptrace
)
2106 darwin_stop_inferior (inf
);
2108 kret
= darwin_restore_exception_ports (priv
);
2109 MACH_CHECK_ERROR (kret
);
2111 if (!priv
->no_ptrace
)
2113 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2115 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2116 inf
->pid
, safe_strerror (errno
), errno
);
2119 darwin_reply_to_all_pending_messages (inf
);
2121 /* When using ptrace, we have just performed a PT_DETACH, which
2122 resumes the inferior. On the other hand, when we are not using
2123 ptrace, we need to resume its execution ourselves. */
2124 if (priv
->no_ptrace
)
2125 darwin_resume_inferior (inf
);
2131 darwin_nat_target::pid_to_str (ptid_t ptid
)
2133 long tid
= ptid
.tid ();
2136 return string_printf (_("Thread 0x%lx of process %u"),
2139 return normal_pid_to_str (ptid
);
2143 darwin_nat_target::thread_alive (ptid_t ptid
)
2148 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2149 copy it to RDADDR in gdb's address space.
2150 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2151 to ADDR in inferior task's address space.
2152 Return 0 on failure; number of bytes read / writen otherwise. */
2155 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2156 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2160 mach_vm_size_t res_length
= 0;
2162 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2163 task
, core_addr_to_string (addr
), pulongest (length
));
2168 mach_vm_size_t count
;
2170 /* According to target.h(to_xfer_partial), one and only one may be
2172 gdb_assert (wraddr
== NULL
);
2174 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2175 (mach_vm_address_t
) rdaddr
, &count
);
2176 if (kret
!= KERN_SUCCESS
)
2179 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2180 core_addr_to_string (addr
), mach_error_string (kret
));
2187 gdb_assert (wraddr
!= NULL
);
2191 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2192 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2193 mach_vm_size_t aligned_length
=
2194 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2195 vm_region_submap_short_info_data_64_t info
;
2196 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2197 natural_t region_depth
= 1000;
2198 mach_vm_address_t region_start
= region_address
;
2199 mach_vm_size_t region_length
;
2200 mach_vm_size_t write_length
;
2202 /* Read page protection. */
2203 kret
= mach_vm_region_recurse
2204 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2205 (vm_region_recurse_info_t
) &info
, &count
);
2207 if (kret
!= KERN_SUCCESS
)
2209 inferior_debug (1, _("darwin_read_write_inferior: "
2210 "mach_vm_region_recurse failed at %s: %s\n"),
2211 core_addr_to_string (region_address
),
2212 mach_error_string (kret
));
2217 (9, _("darwin_read_write_inferior: "
2218 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2219 core_addr_to_string (region_address
),
2220 core_addr_to_string (region_start
),
2221 core_addr_to_string (region_length
));
2223 /* Check for holes in memory. */
2224 if (region_start
> region_address
)
2226 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2227 core_addr_to_string (region_address
),
2228 core_addr_to_string (region_start
),
2229 (unsigned)region_length
);
2233 /* Adjust the length. */
2234 region_length
-= (region_address
- region_start
);
2235 if (region_length
> aligned_length
)
2236 region_length
= aligned_length
;
2238 /* Make the pages RW. */
2239 if (!(info
.protection
& VM_PROT_WRITE
))
2241 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2243 kret
= mach_vm_protect (task
, region_address
, region_length
,
2245 if (kret
!= KERN_SUCCESS
)
2247 prot
|= VM_PROT_COPY
;
2248 kret
= mach_vm_protect (task
, region_address
, region_length
,
2251 if (kret
!= KERN_SUCCESS
)
2253 warning (_("darwin_read_write_inferior: "
2254 "mach_vm_protect failed at %s "
2255 "(len=0x%lx, prot=0x%x): %s"),
2256 core_addr_to_string (region_address
),
2257 (unsigned long) region_length
, (unsigned) prot
,
2258 mach_error_string (kret
));
2263 if (offset
+ length
> region_length
)
2264 write_length
= region_length
- offset
;
2266 write_length
= length
;
2269 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2270 if (kret
!= KERN_SUCCESS
)
2272 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2273 mach_error_string (kret
));
2277 /* Restore page rights. */
2278 if (!(info
.protection
& VM_PROT_WRITE
))
2280 kret
= mach_vm_protect (task
, region_address
, region_length
,
2281 FALSE
, info
.protection
);
2282 if (kret
!= KERN_SUCCESS
)
2284 warning (_("darwin_read_write_inferior: "
2285 "mach_vm_protect restore failed at %s "
2287 core_addr_to_string (region_address
),
2288 (unsigned long) region_length
,
2289 mach_error_string (kret
));
2293 addr
+= write_length
;
2294 wraddr
+= write_length
;
2295 res_length
+= write_length
;
2296 length
-= write_length
;
2302 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2303 to RDADDR (in big endian).
2304 Return 0 on failure; number of bytes read / written otherwise. */
2306 #ifdef TASK_DYLD_INFO_COUNT
2307 /* This is not available in Darwin 9. */
2308 static enum target_xfer_status
2309 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2310 ULONGEST length
, ULONGEST
*xfered_len
)
2312 struct task_dyld_info task_dyld_info
;
2313 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2316 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2317 return TARGET_XFER_EOF
;
2319 kret
= task_info (task
, TASK_DYLD_INFO
,
2320 (task_info_t
) &task_dyld_info
, &count
);
2321 MACH_CHECK_ERROR (kret
);
2322 if (kret
!= KERN_SUCCESS
)
2323 return TARGET_XFER_E_IO
;
2325 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2326 task_dyld_info
.all_image_info_addr
);
2327 *xfered_len
= (ULONGEST
) length
;
2328 return TARGET_XFER_OK
;
2334 enum target_xfer_status
2335 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2336 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2337 ULONGEST offset
, ULONGEST len
,
2338 ULONGEST
*xfered_len
)
2340 struct inferior
*inf
= current_inferior ();
2341 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2344 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2345 core_addr_to_string (offset
), pulongest (len
),
2346 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2351 case TARGET_OBJECT_MEMORY
:
2353 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2354 readbuf
, writebuf
, len
);
2357 return TARGET_XFER_EOF
;
2361 *xfered_len
= (ULONGEST
) l
;
2362 return TARGET_XFER_OK
;
2365 #ifdef TASK_DYLD_INFO_COUNT
2366 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2367 if (writebuf
!= NULL
|| readbuf
== NULL
)
2369 /* Support only read. */
2370 return TARGET_XFER_E_IO
;
2372 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2376 return TARGET_XFER_E_IO
;
2382 set_enable_mach_exceptions (const char *args
, int from_tty
,
2383 struct cmd_list_element
*c
)
2385 if (inferior_ptid
!= null_ptid
)
2387 struct inferior
*inf
= current_inferior ();
2388 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2389 exception_mask_t mask
;
2392 if (enable_mach_exceptions
)
2393 mask
= EXC_MASK_ALL
;
2396 darwin_restore_exception_ports (priv
);
2397 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2399 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2400 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2401 MACH_CHECK_ERROR (kret
);
2406 darwin_nat_target::pid_to_exec_file (int pid
)
2408 static char path
[PATH_MAX
];
2411 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2419 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2421 struct inferior
*inf
= current_inferior ();
2422 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2424 mach_port_name_array_t names
;
2425 mach_msg_type_number_t names_count
;
2426 mach_port_type_array_t types
;
2427 mach_msg_type_number_t types_count
;
2430 /* First linear search. */
2431 for (darwin_thread_t
*t
: priv
->threads
)
2433 if (t
->inf_port
== lwp
)
2434 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2437 /* Maybe the port was never extract. Do it now. */
2439 /* First get inferior port names. */
2440 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2442 MACH_CHECK_ERROR (kret
);
2443 if (kret
!= KERN_SUCCESS
)
2446 /* For each name, copy the right in the gdb space and then compare with
2447 our view of the inferior threads. We don't forget to deallocate the
2449 for (int i
= 0; i
< names_count
; i
++)
2451 mach_port_t local_name
;
2452 mach_msg_type_name_t local_type
;
2454 /* We just need to know the corresponding name in gdb name space.
2455 So extract and deallocate the right. */
2456 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2457 MACH_MSG_TYPE_COPY_SEND
,
2458 &local_name
, &local_type
);
2459 if (kret
!= KERN_SUCCESS
)
2461 mach_port_deallocate (gdb_task
, local_name
);
2463 for (darwin_thread_t
*t
: priv
->threads
)
2465 if (t
->gdb_port
== local_name
)
2467 t
->inf_port
= names
[i
];
2468 if (names
[i
] == lwp
)
2474 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2475 names_count
* sizeof (mach_port_t
));
2478 return ptid_t (inferior_ptid
.pid (), 0, res
);
2484 darwin_nat_target::supports_multi_process ()
2490 _initialize_darwin_nat ()
2494 gdb_task
= mach_task_self ();
2495 darwin_host_self
= mach_host_self ();
2497 /* Read page size. */
2498 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2499 if (kret
!= KERN_SUCCESS
)
2501 mach_page_size
= 0x1000;
2502 MACH_CHECK_ERROR (kret
);
2505 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2506 (unsigned long) mach_task_self (), getpid ());
2508 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2509 &darwin_debug_flag
, _("\
2510 Set if printing inferior communication debugging statements."), _("\
2511 Show if printing inferior communication debugging statements."), NULL
,
2513 &setdebuglist
, &showdebuglist
);
2515 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2516 &enable_mach_exceptions
, _("\
2517 Set if mach exceptions are caught."), _("\
2518 Show if mach exceptions are caught."), _("\
2519 When this mode is on, all low level exceptions are reported before being\n\
2520 reported by the kernel."),
2521 &set_enable_mach_exceptions
, NULL
,
2522 &setlist
, &showlist
);