1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2020 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
43 #include <sys/ptrace.h>
44 #include <sys/signal.h>
46 #include <sys/types.h>
50 #include <sys/sysctl.h>
53 #include <sys/syscall.h>
56 #include <mach/mach_error.h>
57 #include <mach/mach_vm.h>
58 #include <mach/mach_init.h>
59 #include <mach/vm_map.h>
60 #include <mach/task.h>
61 #include <mach/mach_port.h>
62 #include <mach/thread_act.h>
63 #include <mach/port.h>
65 #include "darwin-nat.h"
66 #include "filenames.h"
67 #include "gdbsupport/filestuff.h"
68 #include "gdbsupport/gdb_unlinker.h"
69 #include "gdbsupport/pathstuff.h"
70 #include "gdbsupport/scoped_fd.h"
71 #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 void darwin_ptrace_me (void);
94 static void darwin_encode_reply (mig_reply_error_t
*reply
,
95 mach_msg_header_t
*hdr
, integer_t code
);
97 static void darwin_setup_request_notification (struct inferior
*inf
);
98 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
99 static void darwin_setup_exceptions (struct inferior
*inf
);
100 static void darwin_deallocate_threads (struct inferior
*inf
);
102 /* Task identifier of gdb. */
103 static task_t gdb_task
;
105 /* A copy of mach_host_self (). */
106 mach_port_t darwin_host_self
;
108 /* Exception port. */
109 mach_port_t darwin_ex_port
;
111 /* Port set, to wait for answer on all ports. */
112 mach_port_t darwin_port_set
;
115 static vm_size_t mach_page_size
;
117 /* If Set, catch all mach exceptions (before they are converted to signals
119 static bool enable_mach_exceptions
;
121 /* Inferior that should report a fake stop event. */
122 static struct inferior
*darwin_inf_fake_stop
;
124 /* If non-NULL, the shell we actually invoke. See maybe_cache_shell
126 static const char *copied_shell
;
128 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
129 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
131 /* This controls output of inferior debugging. */
132 static unsigned int darwin_debug_flag
= 0;
134 /* Create a __TEXT __info_plist section in the executable so that gdb could
135 be signed. This is required to get an authorization for task_for_pid.
137 Once gdb is built, you must codesign it with any system-trusted signing
138 authority. See taskgated(8) for details. */
139 static const unsigned char info_plist
[]
140 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
141 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
142 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
143 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
144 "<plist version=\"1.0\">\n"
146 " <key>CFBundleIdentifier</key>\n"
147 " <string>org.gnu.gdb</string>\n"
148 " <key>CFBundleName</key>\n"
149 " <string>gdb</string>\n"
150 " <key>CFBundleVersion</key>\n"
151 " <string>1.0</string>\n"
152 " <key>SecTaskAccess</key>\n"
154 " <string>allowed</string>\n"
155 " <string>debug</string>\n"
160 static void inferior_debug (int level
, const char *fmt
, ...)
161 ATTRIBUTE_PRINTF (2, 3);
164 inferior_debug (int level
, const char *fmt
, ...)
168 if (darwin_debug_flag
< level
)
172 printf_unfiltered (_("[%d inferior]: "), getpid ());
173 vprintf_unfiltered (fmt
, ap
);
178 mach_check_error (kern_return_t ret
, const char *file
,
179 unsigned int line
, const char *func
)
181 if (ret
== KERN_SUCCESS
)
184 func
= _("[UNKNOWN]");
186 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
187 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
191 unparse_exception_type (unsigned int i
)
193 static char unknown_exception_buf
[32];
198 return "EXC_BAD_ACCESS";
199 case EXC_BAD_INSTRUCTION
:
200 return "EXC_BAD_INSTRUCTION";
202 return "EXC_ARITHMETIC";
204 return "EXC_EMULATION";
206 return "EXC_SOFTWARE";
208 return "EXC_BREAKPOINT";
210 return "EXC_SYSCALL";
211 case EXC_MACH_SYSCALL
:
212 return "EXC_MACH_SYSCALL";
214 return "EXC_RPC_ALERT";
218 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
219 return unknown_exception_buf
;
223 /* Set errno to zero, and then call ptrace with the given arguments.
224 If inferior debugging traces are on, then also print a debug
227 The returned value is the same as the value returned by ptrace,
228 except in the case where that value is -1 but errno is zero.
229 This case is documented to be a non-error situation, so we
230 return zero in that case. */
233 darwin_ptrace (const char *name
,
234 int request
, int pid
, caddr_t arg3
, int arg4
)
239 ret
= ptrace (request
, pid
, arg3
, arg4
);
240 if (ret
== -1 && errno
== 0)
243 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
244 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
245 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
250 cmp_thread_t (const void *l
, const void *r
)
252 thread_t tl
= *(const thread_t
*)l
;
253 thread_t tr
= *(const thread_t
*)r
;
254 return (int)(tl
- tr
);
258 darwin_nat_target::check_new_threads (inferior
*inf
)
261 thread_array_t thread_list
;
262 unsigned int new_nbr
;
263 unsigned int old_nbr
;
264 unsigned int new_ix
, old_ix
;
265 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
266 std::vector
<darwin_thread_t
*> new_thread_vec
;
268 if (darwin_inf
== nullptr)
271 /* Get list of threads. */
272 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
273 MACH_CHECK_ERROR (kret
);
274 if (kret
!= KERN_SUCCESS
)
279 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
281 old_nbr
= darwin_inf
->threads
.size ();
283 /* Quick check for no changes. */
284 if (old_nbr
== new_nbr
)
288 for (i
= 0; i
< new_nbr
; i
++)
289 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
293 /* Deallocate ports. */
294 for (i
= 0; i
< new_nbr
; i
++)
296 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
297 MACH_CHECK_ERROR (kret
);
300 /* Deallocate the buffer. */
301 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
302 new_nbr
* sizeof (int));
303 MACH_CHECK_ERROR (kret
);
309 /* Full handling: detect new threads, remove dead threads. */
311 new_thread_vec
.reserve (new_nbr
);
313 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
315 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
317 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
318 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
321 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
322 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
324 if (old_id
== new_id
)
326 /* Thread still exist. */
327 new_thread_vec
.push_back (old
);
331 /* Deallocate the port. */
332 kret
= mach_port_deallocate (gdb_task
, new_id
);
333 MACH_CHECK_ERROR (kret
);
337 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
339 /* Ignore dead ports.
340 In some weird cases, we might get dead ports. They should
341 correspond to dead thread so they could safely be ignored. */
345 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
347 /* A thread was created. */
348 darwin_thread_info
*pti
= new darwin_thread_info
;
350 pti
->gdb_port
= new_id
;
351 pti
->msg_state
= DARWIN_RUNNING
;
353 /* Add the new thread. */
354 add_thread_with_info (this, ptid_t (inf
->pid
, 0, new_id
), pti
);
355 new_thread_vec
.push_back (pti
);
359 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
361 /* A thread was removed. */
362 struct thread_info
*thr
363 = find_thread_ptid (this, ptid_t (inf
->pid
, 0, old_id
));
365 kret
= mach_port_deallocate (gdb_task
, old_id
);
366 MACH_CHECK_ERROR (kret
);
370 gdb_assert_not_reached ("unexpected thread case");
373 darwin_inf
->threads
= std::move (new_thread_vec
);
375 /* Deallocate the buffer. */
376 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
377 new_nbr
* sizeof (int));
378 MACH_CHECK_ERROR (kret
);
381 /* Return an inferior by task port. */
382 static struct inferior
*
383 darwin_find_inferior_by_task (task_t port
)
385 for (inferior
*inf
: all_inferiors ())
387 darwin_inferior
*priv
= get_darwin_inferior (inf
);
389 if (priv
!= nullptr && priv
->task
== port
)
395 /* Return an inferior by pid port. */
396 static struct inferior
*
397 darwin_find_inferior_by_pid (int pid
)
399 for (inferior
*inf
: all_inferiors ())
407 /* Return a thread by port. */
408 static darwin_thread_t
*
409 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
411 darwin_inferior
*priv
= get_darwin_inferior (inf
);
414 for (darwin_thread_t
*t
: priv
->threads
)
416 if (t
->gdb_port
== thread
)
423 /* Suspend (ie stop) an inferior at Mach level. */
426 darwin_suspend_inferior (struct inferior
*inf
)
428 darwin_inferior
*priv
= get_darwin_inferior (inf
);
430 if (priv
!= nullptr && !priv
->suspended
)
434 kret
= task_suspend (priv
->task
);
435 MACH_CHECK_ERROR (kret
);
441 /* Resume an inferior at Mach level. */
444 darwin_resume_inferior (struct inferior
*inf
)
446 darwin_inferior
*priv
= get_darwin_inferior (inf
);
448 if (priv
!= nullptr && priv
->suspended
)
452 kret
= task_resume (priv
->task
);
453 MACH_CHECK_ERROR (kret
);
460 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
462 printf_unfiltered (_("message header:\n"));
463 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
464 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
465 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
466 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
467 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
468 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
472 const unsigned char *data
;
473 const unsigned int *ldata
;
477 data
= (unsigned char *)(hdr
+ 1);
478 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
480 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
482 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
483 mach_msg_port_descriptor_t
*desc
=
484 (mach_msg_port_descriptor_t
*)(bod
+ 1);
487 printf_unfiltered (_("body: descriptor_count=%u\n"),
488 bod
->msgh_descriptor_count
);
489 data
+= sizeof (mach_msg_body_t
);
490 size
-= sizeof (mach_msg_body_t
);
491 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
492 switch (desc
[k
].type
)
494 case MACH_MSG_PORT_DESCRIPTOR
:
496 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
497 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
500 printf_unfiltered (_(" descr %d: type=%u\n"),
504 data
+= bod
->msgh_descriptor_count
505 * sizeof (mach_msg_port_descriptor_t
);
506 size
-= bod
->msgh_descriptor_count
507 * sizeof (mach_msg_port_descriptor_t
);
508 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
510 (_("NDR: mig=%02x if=%02x encod=%02x "
511 "int=%02x char=%02x float=%02x\n"),
512 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
513 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
514 data
+= sizeof (NDR_record_t
);
515 size
-= sizeof (NDR_record_t
);
518 printf_unfiltered (_(" data:"));
519 ldata
= (const unsigned int *)data
;
520 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
521 printf_unfiltered (" %08x", ldata
[i
]);
522 printf_unfiltered (_("\n"));
526 /* Adjust inferior data when a new task was created. */
528 static struct inferior
*
529 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
532 struct inferior
*inf
;
536 /* Find the corresponding pid. */
537 kret
= pid_for_task (task_port
, &task_pid
);
538 if (kret
!= KERN_SUCCESS
)
540 MACH_CHECK_ERROR (kret
);
544 /* Find the inferior for this pid. */
545 inf
= darwin_find_inferior_by_pid (task_pid
);
549 darwin_inferior
*priv
= get_darwin_inferior (inf
);
551 /* Deallocate saved exception ports. */
552 darwin_deallocate_exception_ports (priv
);
554 /* No need to remove dead_name notification, but still... */
555 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
556 MACH_NOTIFY_DEAD_NAME
, 0,
558 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
560 if (kret
!= KERN_INVALID_ARGUMENT
)
561 MACH_CHECK_ERROR (kret
);
563 /* Replace old task port. */
564 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
565 MACH_CHECK_ERROR (kret
);
566 priv
->task
= task_port
;
568 darwin_setup_request_notification (inf
);
569 darwin_setup_exceptions (inf
);
574 /* Check data representation. */
577 darwin_check_message_ndr (NDR_record_t
*ndr
)
579 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
580 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
581 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
582 || ndr
->int_rep
!= NDR_record
.int_rep
583 || ndr
->char_rep
!= NDR_record
.char_rep
584 || ndr
->float_rep
!= NDR_record
.float_rep
)
589 /* Decode an exception message. */
592 darwin_nat_target::decode_exception_message (mach_msg_header_t
*hdr
,
594 darwin_thread_t
**pthread
)
596 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
597 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
600 struct inferior
*inf
;
601 darwin_thread_t
*thread
;
603 thread_t thread_port
;
607 /* Check message destination. */
608 if (hdr
->msgh_local_port
!= darwin_ex_port
)
611 /* Check message header. */
612 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
615 /* Check descriptors. */
616 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
617 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
618 || bod
->msgh_descriptor_count
!= 2
619 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
620 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
621 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
622 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
625 /* Check data representation. */
626 ndr
= (NDR_record_t
*)(desc
+ 2);
627 if (darwin_check_message_ndr (ndr
) != 0)
630 /* Ok, the hard work. */
631 data
= (integer_t
*)(ndr
+ 1);
633 task_port
= desc
[1].name
;
634 thread_port
= desc
[0].name
;
636 /* Find process by port. */
637 inf
= darwin_find_inferior_by_task (task_port
);
640 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
641 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
643 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
644 as a new Mach task is created when a process exec. */
645 inf
= darwin_find_new_inferior (task_port
, thread_port
);
650 /* Deallocate task_port, unless it was saved. */
651 kret
= mach_port_deallocate (mach_task_self (), task_port
);
652 MACH_CHECK_ERROR (kret
);
657 /* We got new rights to the task, get rid of it. Do not get rid of
658 thread right, as we will need it to find the thread. */
659 kret
= mach_port_deallocate (mach_task_self (), task_port
);
660 MACH_CHECK_ERROR (kret
);
665 /* Not a known inferior. This could happen if the child fork, as
666 the created process will inherit its exception port.
667 FIXME: should the exception port be restored ? */
668 mig_reply_error_t reply
;
671 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
674 /* Free thread port (we don't know it). */
675 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
676 MACH_CHECK_ERROR (kret
);
678 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
680 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
681 reply
.Head
.msgh_size
, 0,
682 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
684 MACH_CHECK_ERROR (kret
);
689 /* Find thread by port. */
690 /* Check for new threads. Do it early so that the port in the exception
691 message can be deallocated. */
692 check_new_threads (inf
);
694 /* Free the thread port (as gdb knows the thread, it has already has a right
695 for it, so this just decrement a reference counter). */
696 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
697 MACH_CHECK_ERROR (kret
);
699 thread
= darwin_find_thread (inf
, thread_port
);
704 /* The thread should be running. However we have observed cases where a
705 thread got a SIGTTIN message after being stopped. */
706 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
708 /* Finish decoding. */
709 thread
->event
.header
= *hdr
;
710 thread
->event
.thread_port
= thread_port
;
711 thread
->event
.task_port
= task_port
;
712 thread
->event
.ex_type
= data
[0];
713 thread
->event
.data_count
= data
[1];
715 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
716 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
717 + data
[1] * sizeof (integer_t
)))
719 for (i
= 0; i
< data
[1]; i
++)
720 thread
->event
.ex_data
[i
] = data
[2 + i
];
722 thread
->msg_state
= DARWIN_MESSAGE
;
727 /* Decode dead_name notify message. */
730 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
732 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
733 integer_t
*data
= (integer_t
*)(ndr
+ 1);
734 struct inferior
*inf
;
737 /* Check message header. */
738 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
741 /* Check descriptors. */
742 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
745 /* Check data representation. */
746 if (darwin_check_message_ndr (ndr
) != 0)
751 /* Find process by port. */
752 inf
= darwin_find_inferior_by_task (task_port
);
755 /* Check message destination. */
758 darwin_inferior
*priv
= get_darwin_inferior (inf
);
759 if (hdr
->msgh_local_port
!= priv
->notify_port
)
767 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
770 mach_msg_header_t
*rh
= &reply
->Head
;
772 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
773 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
774 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
775 rh
->msgh_local_port
= MACH_PORT_NULL
;
776 rh
->msgh_id
= hdr
->msgh_id
+ 100;
778 reply
->NDR
= NDR_record
;
779 reply
->RetCode
= code
;
783 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
786 mig_reply_error_t reply
;
787 darwin_inferior
*priv
= get_darwin_inferior (inf
);
789 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
791 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
792 reply
.Head
.msgh_size
, 0,
793 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
795 MACH_CHECK_ERROR (kret
);
797 priv
->pending_messages
--;
800 /* Wrapper around the __pthread_kill syscall. We use this instead of the
801 pthread_kill function to be able to send a signal to any kind of thread,
802 including GCD threads. */
805 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
808 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
809 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
815 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
816 int step
, int nsignal
)
819 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
820 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
822 switch (thread
->msg_state
)
825 if (thread
->event
.ex_type
== EXC_SOFTWARE
826 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
828 /* Either deliver a new signal or cancel the signal received. */
829 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
830 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
832 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
836 /* Note: ptrace is allowed only if the process is stopped.
837 Directly send the signal to the thread. */
838 int res
= darwin_pthread_kill (thread
, nsignal
);
839 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
840 thread
->gdb_port
, nsignal
, res
);
841 thread
->signaled
= 1;
844 /* Set or reset single step. */
845 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
846 thread
->gdb_port
, step
);
847 darwin_set_sstep (thread
->gdb_port
, step
);
848 thread
->single_step
= step
;
850 darwin_send_reply (inf
, thread
);
851 thread
->msg_state
= DARWIN_RUNNING
;
858 kern_return_t kret
= thread_resume (thread
->gdb_port
);
859 MACH_CHECK_ERROR (kret
);
861 thread
->msg_state
= DARWIN_RUNNING
;
866 /* Resume all threads of the inferior. */
869 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
871 darwin_inferior
*priv
= get_darwin_inferior (inf
);
874 for (darwin_thread_t
*thread
: priv
->threads
)
875 darwin_resume_thread (inf
, thread
, step
, nsignal
);
878 /* Suspend all threads of INF. */
881 darwin_suspend_inferior_threads (struct inferior
*inf
)
883 darwin_inferior
*priv
= get_darwin_inferior (inf
);
885 for (darwin_thread_t
*thread
: priv
->threads
)
887 switch (thread
->msg_state
)
894 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
895 MACH_CHECK_ERROR (kret
);
896 thread
->msg_state
= DARWIN_STOPPED
;
904 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
906 struct target_waitstatus status
;
911 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
912 ptid
.pid (), ptid
.tid (), step
, signal
);
914 if (signal
== GDB_SIGNAL_0
)
917 nsignal
= gdb_signal_to_host (signal
);
919 /* Don't try to single step all threads. */
921 ptid
= inferior_ptid
;
923 /* minus_one_ptid is RESUME_ALL. */
924 if (ptid
== minus_one_ptid
)
926 /* Resume threads. */
927 for (inferior
*inf
: all_inferiors ())
928 darwin_resume_inferior_threads (inf
, step
, nsignal
);
931 for (inferior
*inf
: all_inferiors ())
932 darwin_resume_inferior (inf
);
936 inferior
*inf
= find_inferior_ptid (this, ptid
);
937 long tid
= ptid
.tid ();
939 /* Stop the inferior (should be useless). */
940 darwin_suspend_inferior (inf
);
943 darwin_resume_inferior_threads (inf
, step
, nsignal
);
946 darwin_thread_t
*thread
;
948 /* Suspend threads of the task. */
949 darwin_suspend_inferior_threads (inf
);
951 /* Resume the selected thread. */
952 thread
= darwin_find_thread (inf
, tid
);
954 darwin_resume_thread (inf
, thread
, step
, nsignal
);
957 /* Resume the task. */
958 darwin_resume_inferior (inf
);
963 darwin_nat_target::decode_message (mach_msg_header_t
*hdr
,
964 darwin_thread_t
**pthread
,
966 target_waitstatus
*status
)
968 darwin_thread_t
*thread
;
969 struct inferior
*inf
;
971 /* Exception message. 2401 == 0x961 is exc. */
972 if (hdr
->msgh_id
== 2401)
976 /* Decode message. */
977 res
= decode_exception_message (hdr
, &inf
, &thread
);
981 /* Should not happen... */
983 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
984 /* FIXME: send a failure reply? */
985 status
->kind
= TARGET_WAITKIND_IGNORE
;
986 return minus_one_ptid
;
990 status
->kind
= TARGET_WAITKIND_IGNORE
;
991 return minus_one_ptid
;
996 darwin_inferior
*priv
= get_darwin_inferior (inf
);
998 priv
->pending_messages
++;
1000 status
->kind
= TARGET_WAITKIND_STOPPED
;
1001 thread
->msg_state
= DARWIN_MESSAGE
;
1003 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1005 unparse_exception_type (thread
->event
.ex_type
));
1007 switch (thread
->event
.ex_type
)
1009 case EXC_BAD_ACCESS
:
1010 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1012 case EXC_BAD_INSTRUCTION
:
1013 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1015 case EXC_ARITHMETIC
:
1016 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1019 status
->value
.sig
= GDB_EXC_EMULATION
;
1022 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1025 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1026 inferior_debug (5, _(" (signal %d: %s)\n"),
1027 thread
->event
.ex_data
[1],
1028 gdb_signal_to_name (status
->value
.sig
));
1030 /* If the thread is stopped because it has received a signal
1031 that gdb has just sent, continue. */
1032 if (thread
->signaled
)
1034 thread
->signaled
= 0;
1035 darwin_send_reply (inf
, thread
);
1036 thread
->msg_state
= DARWIN_RUNNING
;
1037 status
->kind
= TARGET_WAITKIND_IGNORE
;
1041 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1043 case EXC_BREAKPOINT
:
1044 /* Many internal GDB routines expect breakpoints to be reported
1045 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1046 as a spurious signal. */
1047 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1050 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1054 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1056 else if (hdr
->msgh_id
== 0x48)
1058 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1061 res
= darwin_decode_notify_message (hdr
, &inf
);
1065 /* Should not happen... */
1067 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1074 if (res
< 0 || inf
== NULL
)
1076 status
->kind
= TARGET_WAITKIND_IGNORE
;
1077 return minus_one_ptid
;
1082 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1084 if (!priv
->no_ptrace
)
1089 res_pid
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1090 if (res_pid
< 0 || res_pid
!= inf
->pid
)
1092 printf_unfiltered (_("wait4: res=%d: %s\n"),
1093 res_pid
, safe_strerror (errno
));
1094 status
->kind
= TARGET_WAITKIND_IGNORE
;
1095 return minus_one_ptid
;
1097 if (WIFEXITED (wstatus
))
1099 status
->kind
= TARGET_WAITKIND_EXITED
;
1100 status
->value
.integer
= WEXITSTATUS (wstatus
);
1104 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1105 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1108 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1111 /* Looks necessary on Leopard and harmless... */
1112 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1114 inferior_ptid
= ptid_t (inf
->pid
, 0, 0);
1115 return inferior_ptid
;
1119 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1120 status
->kind
= TARGET_WAITKIND_EXITED
;
1121 status
->value
.integer
= 0; /* Don't know. */
1122 return ptid_t (inf
->pid
, 0, 0);
1127 /* Unknown message. */
1128 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1129 status
->kind
= TARGET_WAITKIND_IGNORE
;
1130 return minus_one_ptid
;
1134 darwin_nat_target::cancel_breakpoint (ptid_t ptid
)
1136 /* Arrange for a breakpoint to be hit again later. We will handle
1137 the current event, eventually we will resume this thread, and this
1138 breakpoint will trap again.
1140 If we do not do this, then we run the risk that the user will
1141 delete or disable the breakpoint, but the thread will have already
1144 struct regcache
*regcache
= get_thread_regcache (this, ptid
);
1145 struct gdbarch
*gdbarch
= regcache
->arch ();
1148 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1149 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1151 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1152 (unsigned long) ptid
.tid ());
1154 /* Back up the PC if necessary. */
1155 if (gdbarch_decr_pc_after_break (gdbarch
))
1156 regcache_write_pc (regcache
, pc
);
1164 darwin_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*status
)
1169 mach_msg_header_t hdr
;
1172 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1174 darwin_thread_t
*thread
;
1177 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1178 ptid
.pid (), ptid
.tid ());
1180 /* Handle fake stop events at first. */
1181 if (darwin_inf_fake_stop
!= NULL
)
1183 inferior
*inf
= darwin_inf_fake_stop
;
1184 darwin_inf_fake_stop
= NULL
;
1186 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1188 status
->kind
= TARGET_WAITKIND_STOPPED
;
1189 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1190 thread
= priv
->threads
[0];
1191 thread
->msg_state
= DARWIN_STOPPED
;
1192 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1197 /* set_sigint_trap (); */
1199 /* Wait for a message. */
1200 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1201 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1203 /* clear_sigint_trap (); */
1205 if (kret
== MACH_RCV_INTERRUPTED
)
1207 status
->kind
= TARGET_WAITKIND_IGNORE
;
1208 return minus_one_ptid
;
1211 if (kret
!= MACH_MSG_SUCCESS
)
1213 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1214 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1215 return minus_one_ptid
;
1218 /* Debug: display message. */
1219 if (darwin_debug_flag
> 10)
1220 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1223 res
= decode_message (hdr
, &thread
, &inf
, status
);
1224 if (res
== minus_one_ptid
)
1227 /* Early return in case an inferior has exited. */
1231 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1233 /* Stop all tasks. */
1234 for (inferior
*inf
: all_inferiors (this))
1236 darwin_suspend_inferior (inf
);
1237 check_new_threads (inf
);
1240 /* Read pending messages. */
1243 struct target_waitstatus status2
;
1246 kret
= mach_msg (&msgin
.hdr
,
1247 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1248 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1250 if (kret
== MACH_RCV_TIMED_OUT
)
1252 if (kret
!= MACH_MSG_SUCCESS
)
1255 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1259 /* Debug: display message. */
1260 if (darwin_debug_flag
> 10)
1261 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1264 ptid2
= decode_message (hdr
, &thread
, &inf
, &status2
);
1266 if (inf
!= NULL
&& thread
!= NULL
1267 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1269 if (thread
->single_step
1270 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1272 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1273 darwin_send_reply (inf
, thread
);
1274 thread
->msg_state
= DARWIN_RUNNING
;
1278 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1282 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1288 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1291 return wait_1 (ptid
, status
);
1295 darwin_nat_target::interrupt ()
1297 struct inferior
*inf
= current_inferior ();
1298 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1300 /* FIXME: handle in no_ptrace mode. */
1301 gdb_assert (!priv
->no_ptrace
);
1302 ::kill (inf
->pid
, SIGINT
);
1305 /* Deallocate threads port and vector. */
1308 darwin_deallocate_threads (struct inferior
*inf
)
1310 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1312 for (darwin_thread_t
*t
: priv
->threads
)
1314 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1315 MACH_CHECK_ERROR (kret
);
1318 priv
->threads
.clear ();
1322 darwin_nat_target::mourn_inferior ()
1324 struct inferior
*inf
= current_inferior ();
1325 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1329 /* Deallocate threads. */
1330 darwin_deallocate_threads (inf
);
1332 /* Remove notify_port from darwin_port_set. */
1333 kret
= mach_port_move_member (gdb_task
,
1334 priv
->notify_port
, MACH_PORT_NULL
);
1335 MACH_CHECK_ERROR (kret
);
1337 /* Remove task port dead_name notification. */
1338 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1339 MACH_NOTIFY_DEAD_NAME
, 0,
1341 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1343 /* This can fail if the task is dead. */
1344 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1345 priv
->task
, prev
, priv
->notify_port
);
1347 if (kret
== KERN_SUCCESS
)
1349 kret
= mach_port_deallocate (gdb_task
, prev
);
1350 MACH_CHECK_ERROR (kret
);
1353 /* Destroy notify_port. */
1354 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1355 MACH_CHECK_ERROR (kret
);
1357 /* Deallocate saved exception ports. */
1358 darwin_deallocate_exception_ports (priv
);
1360 /* Deallocate task port. */
1361 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1362 MACH_CHECK_ERROR (kret
);
1366 inf_child_target::mourn_inferior ();
1370 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1372 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1374 for (darwin_thread_t
*t
: priv
->threads
)
1376 if (t
->msg_state
== DARWIN_MESSAGE
)
1377 darwin_resume_thread (inf
, t
, 0, 0);
1382 darwin_nat_target::stop_inferior (inferior
*inf
)
1384 struct target_waitstatus wstatus
;
1387 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1389 gdb_assert (inf
!= NULL
);
1391 darwin_suspend_inferior (inf
);
1393 darwin_reply_to_all_pending_messages (inf
);
1395 if (priv
->no_ptrace
)
1398 res
= ::kill (inf
->pid
, SIGSTOP
);
1400 warning (_("cannot kill: %s"), safe_strerror (errno
));
1402 /* Wait until the process is really stopped. */
1405 ptid
= wait_1 (inferior_ptid
, &wstatus
);
1406 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1407 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1412 static kern_return_t
1413 darwin_save_exception_ports (darwin_inferior
*inf
)
1417 inf
->exception_info
.count
=
1418 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1420 kret
= task_get_exception_ports
1421 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1422 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1423 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1427 static kern_return_t
1428 darwin_restore_exception_ports (darwin_inferior
*inf
)
1433 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1435 kret
= task_set_exception_ports
1436 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1437 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1438 if (kret
!= KERN_SUCCESS
)
1442 return KERN_SUCCESS
;
1445 /* Deallocate saved exception ports. */
1448 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1453 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1455 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1456 MACH_CHECK_ERROR (kret
);
1458 inf
->exception_info
.count
= 0;
1462 darwin_setup_exceptions (struct inferior
*inf
)
1464 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1466 exception_mask_t mask
;
1468 kret
= darwin_save_exception_ports (priv
);
1469 if (kret
!= KERN_SUCCESS
)
1470 error (_("Unable to save exception ports, task_get_exception_ports"
1474 /* Set exception port. */
1475 if (enable_mach_exceptions
)
1476 mask
= EXC_MASK_ALL
;
1478 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1479 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1480 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1481 if (kret
!= KERN_SUCCESS
)
1482 error (_("Unable to set exception ports, task_set_exception_ports"
1488 darwin_nat_target::kill ()
1490 struct inferior
*inf
= current_inferior ();
1491 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1492 struct target_waitstatus wstatus
;
1497 if (inferior_ptid
== null_ptid
)
1500 gdb_assert (inf
!= NULL
);
1502 kret
= darwin_restore_exception_ports (priv
);
1503 MACH_CHECK_ERROR (kret
);
1505 darwin_reply_to_all_pending_messages (inf
);
1507 res
= ::kill (inf
->pid
, 9);
1511 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1512 does not work as expected.
1513 When the kill function is called, the SIGKILL signal is received
1514 by gdb whereas it should have been received by the kernel since
1515 the exception ports have been restored.
1516 This behavior is not the expected one thus gdb does not reply to
1517 the received SIGKILL message. This situation leads to a "busy"
1518 resource from the kernel point of view and the inferior is never
1519 released, causing it to remain as a zombie process, even after
1521 To work around this, we mark all the threads of the inferior as
1522 signaled thus darwin_decode_message function knows that the kill
1523 signal was sent by gdb and will take the appropriate action
1524 (cancel signal and reply to the signal message). */
1525 for (darwin_thread_t
*thread
: priv
->threads
)
1526 thread
->signaled
= 1;
1528 darwin_resume_inferior (inf
);
1530 ptid
= wait_1 (inferior_ptid
, &wstatus
);
1532 else if (errno
!= ESRCH
)
1533 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1534 inf
->pid
, safe_strerror (errno
));
1536 target_mourn_inferior (inferior_ptid
);
1540 darwin_setup_request_notification (struct inferior
*inf
)
1542 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1544 mach_port_t prev_not
;
1546 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1547 MACH_NOTIFY_DEAD_NAME
, 0,
1549 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1551 if (kret
!= KERN_SUCCESS
)
1552 error (_("Termination notification request failed, "
1553 "mach_port_request_notification\n"
1556 if (prev_not
!= MACH_PORT_NULL
)
1558 /* This is unexpected, as there should not be any previously
1559 registered notification request. But this is not a fatal
1560 issue, so just emit a warning. */
1562 A task termination request was registered before the debugger registered\n\
1563 its own. This is unexpected, but should otherwise not have any actual\n\
1564 impact on the debugging session."));
1569 darwin_attach_pid (struct inferior
*inf
)
1573 darwin_inferior
*priv
= new darwin_inferior
;
1574 inf
->priv
.reset (priv
);
1578 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1579 if (kret
!= KERN_SUCCESS
)
1583 if (!inf
->attach_flag
)
1586 waitpid (inf
->pid
, &status
, 0);
1590 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1591 " (please check gdb is codesigned - see taskgated(8))"),
1592 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1595 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1596 priv
->task
, inf
->pid
);
1598 if (darwin_ex_port
== MACH_PORT_NULL
)
1600 /* Create a port to get exceptions. */
1601 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1603 if (kret
!= KERN_SUCCESS
)
1604 error (_("Unable to create exception port, mach_port_allocate "
1608 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1610 MACH_MSG_TYPE_MAKE_SEND
);
1611 if (kret
!= KERN_SUCCESS
)
1612 error (_("Unable to create exception port, mach_port_insert_right "
1616 /* Create a port set and put ex_port in it. */
1617 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1619 if (kret
!= KERN_SUCCESS
)
1620 error (_("Unable to create port set, mach_port_allocate "
1624 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1626 if (kret
!= KERN_SUCCESS
)
1627 error (_("Unable to move exception port into new port set, "
1628 "mach_port_move_member\n"
1633 /* Create a port to be notified when the child task terminates. */
1634 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1635 &priv
->notify_port
);
1636 if (kret
!= KERN_SUCCESS
)
1637 error (_("Unable to create notification port, mach_port_allocate "
1641 kret
= mach_port_move_member (gdb_task
,
1642 priv
->notify_port
, darwin_port_set
);
1643 if (kret
!= KERN_SUCCESS
)
1644 error (_("Unable to move notification port into new port set, "
1645 "mach_port_move_member\n"
1649 darwin_setup_request_notification (inf
);
1651 darwin_setup_exceptions (inf
);
1653 catch (const gdb_exception
&ex
)
1655 exit_inferior (inf
);
1656 inferior_ptid
= null_ptid
;
1661 target_ops
*darwin_ops
= get_native_target ();
1662 if (!target_is_pushed (darwin_ops
))
1663 push_target (darwin_ops
);
1666 /* Get the thread_info object corresponding to this darwin_thread_info. */
1668 static struct thread_info
*
1669 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1671 for (struct thread_info
*it
: all_threads ())
1673 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1675 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1679 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1683 darwin_nat_target::init_thread_list (inferior
*inf
)
1685 check_new_threads (inf
);
1687 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1689 gdb_assert (!priv
->threads
.empty ());
1691 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1692 struct thread_info
*first_thread
1693 = thread_info_from_private_thread_info (first_pti
);
1695 inferior_ptid
= first_thread
->ptid
;
1698 /* The child must synchronize with gdb: gdb must set the exception port
1699 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1700 FIXME: is there a lighter way ? */
1701 static int ptrace_fds
[2];
1704 darwin_ptrace_me (void)
1709 /* Close write end point. */
1710 if (close (ptrace_fds
[1]) < 0)
1711 trace_start_error_with_name ("close");
1713 /* Wait until gdb is ready. */
1714 res
= read (ptrace_fds
[0], &c
, 1);
1716 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1718 if (close (ptrace_fds
[0]) < 0)
1719 trace_start_error_with_name ("close");
1721 /* Get rid of privileges. */
1722 if (setegid (getgid ()) < 0)
1723 trace_start_error_with_name ("setegid");
1726 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1727 trace_start_error_with_name ("PTRACE");
1729 /* Redirect signals to exception port. */
1730 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1731 trace_start_error_with_name ("PTRACE");
1734 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1736 darwin_pre_ptrace (void)
1738 if (pipe (ptrace_fds
) != 0)
1742 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1745 mark_fd_no_cloexec (ptrace_fds
[0]);
1746 mark_fd_no_cloexec (ptrace_fds
[1]);
1750 darwin_nat_target::ptrace_him (int pid
)
1752 struct inferior
*inf
= current_inferior ();
1754 darwin_attach_pid (inf
);
1756 /* Let's the child run. */
1757 ::close (ptrace_fds
[0]);
1758 ::close (ptrace_fds
[1]);
1760 unmark_fd_no_cloexec (ptrace_fds
[0]);
1761 unmark_fd_no_cloexec (ptrace_fds
[1]);
1763 init_thread_list (inf
);
1765 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1769 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1771 posix_spawnattr_t attr
;
1775 res
= posix_spawnattr_init (&attr
);
1779 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1783 /* Do like execve: replace the image. */
1784 ps_flags
= POSIX_SPAWN_SETEXEC
;
1786 /* Disable ASLR. The constant doesn't look to be available outside the
1787 kernel include files. */
1788 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1789 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1791 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1792 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1795 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1799 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1802 /* Read kernel version, and return TRUE if this host may have System
1803 Integrity Protection (Sierra or later). */
1809 size_t sz
= sizeof (str
);
1812 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1813 if (ret
== 0 && sz
< sizeof (str
))
1815 unsigned long ver
= strtoul (str
, NULL
, 10);
1822 /* A helper for maybe_cache_shell. This copies the shell to the
1823 cache. It will throw an exception on any failure. */
1826 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1828 scoped_fd
from_fd (gdb_open_cloexec (shell
, O_RDONLY
, 0));
1829 if (from_fd
.get () < 0)
1830 error (_("Could not open shell (%s) for reading: %s"),
1831 shell
, safe_strerror (errno
));
1833 std::string new_dir
= ldirname (new_name
.c_str ());
1834 if (!mkdir_recursive (new_dir
.c_str ()))
1835 error (_("Could not make cache directory \"%s\": %s"),
1836 new_dir
.c_str (), safe_strerror (errno
));
1838 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1839 scoped_fd
to_fd (gdb_mkostemp_cloexec (&temp_name
[0]));
1840 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1842 if (to_fd
.get () < 0)
1843 error (_("Could not open temporary file \"%s\" for writing: %s"),
1844 temp_name
.data (), safe_strerror (errno
));
1846 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1847 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1848 error (_("Could not copy shell to cache as \"%s\": %s"),
1849 temp_name
.data (), safe_strerror (errno
));
1851 /* Be sure that the caching is atomic so that we don't get bad
1852 results from multiple copies of gdb running at the same time. */
1853 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1854 error (_("Could not rename shell cache file to \"%s\": %s"),
1855 new_name
.c_str (), safe_strerror (errno
));
1857 unlink_file_on_error
.keep ();
1860 /* If $SHELL is restricted, try to cache a copy. Starting with El
1861 Capitan, macOS introduced System Integrity Protection. Among other
1862 things, this prevents certain executables from being ptrace'd. In
1863 particular, executables in /bin, like most shells, are affected.
1864 To work around this, while preserving command-line glob expansion
1865 and redirections, gdb will cache a copy of the shell. Return true
1866 if all is well -- either the shell is not subject to SIP or it has
1867 been successfully cached. Returns false if something failed. */
1870 maybe_cache_shell ()
1872 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1873 given file is subject to SIP. */
1874 #ifdef SF_RESTRICTED
1876 /* If a check fails we want to revert -- maybe the user deleted the
1877 cache while gdb was running, or something like that. */
1878 copied_shell
= nullptr;
1880 const char *shell
= get_shell ();
1881 if (!IS_ABSOLUTE_PATH (shell
))
1883 warning (_("This version of macOS has System Integrity Protection.\n\
1884 Normally gdb would try to work around this by caching a copy of your shell,\n\
1885 but because your shell (%s) is not an absolute path, this is being skipped."),
1891 if (stat (shell
, &sb
) < 0)
1893 warning (_("This version of macOS has System Integrity Protection.\n\
1894 Normally gdb would try to work around this by caching a copy of your shell,\n\
1895 but because gdb could not stat your shell (%s), this is being skipped.\n\
1896 The error was: %s"),
1897 shell
, safe_strerror (errno
));
1901 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1904 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1905 std::string new_name
= get_standard_cache_dir ();
1906 /* There's no need to insert a directory separator here, because
1907 SHELL is known to be absolute. */
1908 new_name
.append (shell
);
1910 /* Maybe it was cached by some earlier gdb. */
1911 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1915 copy_shell_to_cache (shell
, new_name
);
1917 catch (const gdb_exception_error
&ex
)
1919 warning (_("This version of macOS has System Integrity Protection.\n\
1920 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1921 caching a copy of your shell. However, this failed:\n\
1923 If you correct the problem, gdb will automatically try again the next time\n\
1924 you \"run\". To prevent these attempts, you can use:\n\
1925 set startup-with-shell off"),
1930 printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1931 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1932 caching a copy of your shell. The shell used by \"run\" is now:\n\
1937 /* We need to make sure that the new name has the correct lifetime. */
1938 static std::string saved_shell
= std::move (new_name
);
1939 copied_shell
= saved_shell
.c_str ();
1941 #endif /* SF_RESTRICTED */
1947 darwin_nat_target::create_inferior (const char *exec_file
,
1948 const std::string
&allargs
,
1949 char **env
, int from_tty
)
1951 gdb::optional
<scoped_restore_tmpl
<bool>> restore_startup_with_shell
;
1952 darwin_nat_target
*the_target
= this;
1954 if (startup_with_shell
&& may_have_sip ())
1956 if (!maybe_cache_shell ())
1958 warning (_("startup-with-shell is now temporarily disabled"));
1959 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
1963 /* Do the hard work. */
1964 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1965 [the_target
] (int pid
)
1967 the_target
->ptrace_him (pid
);
1969 darwin_pre_ptrace
, copied_shell
,
1974 /* Set things up such that the next call to darwin_wait will immediately
1975 return a fake stop event for inferior INF.
1977 This assumes that the inferior's thread list has been initialized,
1978 as it will suspend the inferior's first thread. */
1981 darwin_setup_fake_stop_event (struct inferior
*inf
)
1983 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1984 darwin_thread_t
*thread
;
1987 gdb_assert (darwin_inf_fake_stop
== NULL
);
1988 darwin_inf_fake_stop
= inf
;
1990 /* When detecting a fake pending stop event, darwin_wait returns
1991 an event saying that the first thread is in a DARWIN_STOPPED
1992 state. To make that accurate, we need to suspend that thread
1993 as well. Otherwise, we'll try resuming it when resuming the
1994 inferior, and get a warning because the thread's suspend count
1995 is already zero, making the resume request useless. */
1996 thread
= priv
->threads
[0];
1997 kret
= thread_suspend (thread
->gdb_port
);
1998 MACH_CHECK_ERROR (kret
);
2001 /* Attach to process PID, then initialize for debugging it
2002 and wait for the trace-trap that results from attaching. */
2004 darwin_nat_target::attach (const char *args
, int from_tty
)
2007 struct inferior
*inf
;
2009 pid
= parse_pid_to_attach (args
);
2011 if (pid
== getpid ()) /* Trying to masturbate? */
2012 error (_("I refuse to debug myself!"));
2016 const char *exec_file
= get_exec_file (0);
2019 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
2020 target_pid_to_str (ptid_t (pid
)).c_str ());
2022 printf_unfiltered (_("Attaching to %s\n"),
2023 target_pid_to_str (ptid_t (pid
)).c_str ());
2026 if (pid
== 0 || ::kill (pid
, 0) < 0)
2027 error (_("Can't attach to process %d: %s (%d)"),
2028 pid
, safe_strerror (errno
), errno
);
2030 inferior_ptid
= ptid_t (pid
);
2031 inf
= current_inferior ();
2032 inferior_appeared (inf
, pid
);
2033 inf
->attach_flag
= 1;
2035 darwin_attach_pid (inf
);
2037 darwin_suspend_inferior (inf
);
2039 init_thread_list (inf
);
2041 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2043 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2045 darwin_setup_fake_stop_event (inf
);
2047 priv
->no_ptrace
= 1;
2050 /* Take a program previously attached to and detaches it.
2051 The program resumes execution and will no longer stop
2052 on signals, etc. We'd better not have left any breakpoints
2053 in the program or it'll die when it hits one. For this
2054 to work, it may be necessary for the process to have been
2055 previously attached. It *might* work if the program was
2056 started via fork. */
2059 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2061 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2065 /* Display message. */
2066 target_announce_detach (from_tty
);
2068 /* If ptrace() is in use, stop the process. */
2069 if (!priv
->no_ptrace
)
2070 stop_inferior (inf
);
2072 kret
= darwin_restore_exception_ports (priv
);
2073 MACH_CHECK_ERROR (kret
);
2075 if (!priv
->no_ptrace
)
2077 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2079 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2080 inf
->pid
, safe_strerror (errno
), errno
);
2083 darwin_reply_to_all_pending_messages (inf
);
2085 /* When using ptrace, we have just performed a PT_DETACH, which
2086 resumes the inferior. On the other hand, when we are not using
2087 ptrace, we need to resume its execution ourselves. */
2088 if (priv
->no_ptrace
)
2089 darwin_resume_inferior (inf
);
2095 darwin_nat_target::pid_to_str (ptid_t ptid
)
2097 long tid
= ptid
.tid ();
2100 return string_printf (_("Thread 0x%lx of process %u"),
2103 return normal_pid_to_str (ptid
);
2107 darwin_nat_target::thread_alive (ptid_t ptid
)
2112 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2113 copy it to RDADDR in gdb's address space.
2114 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2115 to ADDR in inferior task's address space.
2116 Return 0 on failure; number of bytes read / written otherwise. */
2119 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2120 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2124 mach_vm_size_t res_length
= 0;
2126 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2127 task
, core_addr_to_string (addr
), pulongest (length
));
2132 mach_vm_size_t count
;
2134 /* According to target.h(to_xfer_partial), one and only one may be
2136 gdb_assert (wraddr
== NULL
);
2138 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2139 (mach_vm_address_t
) rdaddr
, &count
);
2140 if (kret
!= KERN_SUCCESS
)
2143 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2144 core_addr_to_string (addr
), mach_error_string (kret
));
2151 gdb_assert (wraddr
!= NULL
);
2155 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2156 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2157 mach_vm_size_t aligned_length
=
2158 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2159 vm_region_submap_short_info_data_64_t info
;
2160 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2161 natural_t region_depth
= 1000;
2162 mach_vm_address_t region_start
= region_address
;
2163 mach_vm_size_t region_length
;
2164 mach_vm_size_t write_length
;
2166 /* Read page protection. */
2167 kret
= mach_vm_region_recurse
2168 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2169 (vm_region_recurse_info_t
) &info
, &count
);
2171 if (kret
!= KERN_SUCCESS
)
2173 inferior_debug (1, _("darwin_read_write_inferior: "
2174 "mach_vm_region_recurse failed at %s: %s\n"),
2175 core_addr_to_string (region_address
),
2176 mach_error_string (kret
));
2181 (9, _("darwin_read_write_inferior: "
2182 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2183 core_addr_to_string (region_address
),
2184 core_addr_to_string (region_start
),
2185 core_addr_to_string (region_length
));
2187 /* Check for holes in memory. */
2188 if (region_start
> region_address
)
2190 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2191 core_addr_to_string (region_address
),
2192 core_addr_to_string (region_start
),
2193 (unsigned)region_length
);
2197 /* Adjust the length. */
2198 region_length
-= (region_address
- region_start
);
2199 if (region_length
> aligned_length
)
2200 region_length
= aligned_length
;
2202 /* Make the pages RW. */
2203 if (!(info
.protection
& VM_PROT_WRITE
))
2205 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2207 kret
= mach_vm_protect (task
, region_address
, region_length
,
2209 if (kret
!= KERN_SUCCESS
)
2211 prot
|= VM_PROT_COPY
;
2212 kret
= mach_vm_protect (task
, region_address
, region_length
,
2215 if (kret
!= KERN_SUCCESS
)
2217 warning (_("darwin_read_write_inferior: "
2218 "mach_vm_protect failed at %s "
2219 "(len=0x%lx, prot=0x%x): %s"),
2220 core_addr_to_string (region_address
),
2221 (unsigned long) region_length
, (unsigned) prot
,
2222 mach_error_string (kret
));
2227 if (offset
+ length
> region_length
)
2228 write_length
= region_length
- offset
;
2230 write_length
= length
;
2233 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2234 if (kret
!= KERN_SUCCESS
)
2236 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2237 mach_error_string (kret
));
2241 /* Restore page rights. */
2242 if (!(info
.protection
& VM_PROT_WRITE
))
2244 kret
= mach_vm_protect (task
, region_address
, region_length
,
2245 FALSE
, info
.protection
);
2246 if (kret
!= KERN_SUCCESS
)
2248 warning (_("darwin_read_write_inferior: "
2249 "mach_vm_protect restore failed at %s "
2251 core_addr_to_string (region_address
),
2252 (unsigned long) region_length
,
2253 mach_error_string (kret
));
2257 addr
+= write_length
;
2258 wraddr
+= write_length
;
2259 res_length
+= write_length
;
2260 length
-= write_length
;
2266 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2267 to RDADDR (in big endian).
2268 Return 0 on failure; number of bytes read / written otherwise. */
2270 #ifdef TASK_DYLD_INFO_COUNT
2271 /* This is not available in Darwin 9. */
2272 static enum target_xfer_status
2273 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2274 ULONGEST length
, ULONGEST
*xfered_len
)
2276 struct task_dyld_info task_dyld_info
;
2277 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2280 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2281 return TARGET_XFER_EOF
;
2283 kret
= task_info (task
, TASK_DYLD_INFO
,
2284 (task_info_t
) &task_dyld_info
, &count
);
2285 MACH_CHECK_ERROR (kret
);
2286 if (kret
!= KERN_SUCCESS
)
2287 return TARGET_XFER_E_IO
;
2289 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2290 task_dyld_info
.all_image_info_addr
);
2291 *xfered_len
= (ULONGEST
) length
;
2292 return TARGET_XFER_OK
;
2298 enum target_xfer_status
2299 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2300 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2301 ULONGEST offset
, ULONGEST len
,
2302 ULONGEST
*xfered_len
)
2304 struct inferior
*inf
= current_inferior ();
2305 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2308 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2309 core_addr_to_string (offset
), pulongest (len
),
2310 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2315 case TARGET_OBJECT_MEMORY
:
2317 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2318 readbuf
, writebuf
, len
);
2321 return TARGET_XFER_EOF
;
2325 *xfered_len
= (ULONGEST
) l
;
2326 return TARGET_XFER_OK
;
2329 #ifdef TASK_DYLD_INFO_COUNT
2330 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2331 if (writebuf
!= NULL
|| readbuf
== NULL
)
2333 /* Support only read. */
2334 return TARGET_XFER_E_IO
;
2336 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2340 return TARGET_XFER_E_IO
;
2346 set_enable_mach_exceptions (const char *args
, int from_tty
,
2347 struct cmd_list_element
*c
)
2349 if (inferior_ptid
!= null_ptid
)
2351 struct inferior
*inf
= current_inferior ();
2352 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2353 exception_mask_t mask
;
2356 if (enable_mach_exceptions
)
2357 mask
= EXC_MASK_ALL
;
2360 darwin_restore_exception_ports (priv
);
2361 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2363 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2364 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2365 MACH_CHECK_ERROR (kret
);
2370 darwin_nat_target::pid_to_exec_file (int pid
)
2372 static char path
[PATH_MAX
];
2375 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2383 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2385 struct inferior
*inf
= current_inferior ();
2386 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2388 mach_port_name_array_t names
;
2389 mach_msg_type_number_t names_count
;
2390 mach_port_type_array_t types
;
2391 mach_msg_type_number_t types_count
;
2394 /* First linear search. */
2395 for (darwin_thread_t
*t
: priv
->threads
)
2397 if (t
->inf_port
== lwp
)
2398 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2401 /* Maybe the port was never extract. Do it now. */
2403 /* First get inferior port names. */
2404 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2406 MACH_CHECK_ERROR (kret
);
2407 if (kret
!= KERN_SUCCESS
)
2410 /* For each name, copy the right in the gdb space and then compare with
2411 our view of the inferior threads. We don't forget to deallocate the
2413 for (int i
= 0; i
< names_count
; i
++)
2415 mach_port_t local_name
;
2416 mach_msg_type_name_t local_type
;
2418 /* We just need to know the corresponding name in gdb name space.
2419 So extract and deallocate the right. */
2420 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2421 MACH_MSG_TYPE_COPY_SEND
,
2422 &local_name
, &local_type
);
2423 if (kret
!= KERN_SUCCESS
)
2425 mach_port_deallocate (gdb_task
, local_name
);
2427 for (darwin_thread_t
*t
: priv
->threads
)
2429 if (t
->gdb_port
== local_name
)
2431 t
->inf_port
= names
[i
];
2432 if (names
[i
] == lwp
)
2438 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2439 names_count
* sizeof (mach_port_t
));
2442 return ptid_t (inferior_ptid
.pid (), 0, res
);
2448 darwin_nat_target::supports_multi_process ()
2453 void _initialize_darwin_nat ();
2455 _initialize_darwin_nat ()
2459 gdb_task
= mach_task_self ();
2460 darwin_host_self
= mach_host_self ();
2462 /* Read page size. */
2463 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2464 if (kret
!= KERN_SUCCESS
)
2466 mach_page_size
= 0x1000;
2467 MACH_CHECK_ERROR (kret
);
2470 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2471 (unsigned long) mach_task_self (), getpid ());
2473 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2474 &darwin_debug_flag
, _("\
2475 Set if printing inferior communication debugging statements."), _("\
2476 Show if printing inferior communication debugging statements."), NULL
,
2478 &setdebuglist
, &showdebuglist
);
2480 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2481 &enable_mach_exceptions
, _("\
2482 Set if mach exceptions are caught."), _("\
2483 Show if mach exceptions are caught."), _("\
2484 When this mode is on, all low level exceptions are reported before being\n\
2485 reported by the kernel."),
2486 &set_enable_mach_exceptions
, NULL
,
2487 &setlist
, &showlist
);