1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2023 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 gdb_printf (gdb_stdlog
, _("[%d inferior]: "), getpid ());
173 gdb_vprintf (gdb_stdlog
, 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
),
355 private_thread_info_up (pti
));
356 new_thread_vec
.push_back (pti
);
360 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
362 /* A thread was removed. */
363 struct thread_info
*thr
364 = this->find_thread (ptid_t (inf
->pid
, 0, old_id
));
366 kret
= mach_port_deallocate (gdb_task
, old_id
);
367 MACH_CHECK_ERROR (kret
);
371 gdb_assert_not_reached ("unexpected thread case");
374 darwin_inf
->threads
= std::move (new_thread_vec
);
376 /* Deallocate the buffer. */
377 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
378 new_nbr
* sizeof (int));
379 MACH_CHECK_ERROR (kret
);
382 /* Return an inferior by task port. */
383 static struct inferior
*
384 darwin_find_inferior_by_task (task_t port
)
386 for (inferior
*inf
: all_inferiors ())
388 darwin_inferior
*priv
= get_darwin_inferior (inf
);
390 if (priv
!= nullptr && priv
->task
== port
)
396 /* Return an inferior by pid port. */
397 static struct inferior
*
398 darwin_find_inferior_by_pid (int pid
)
400 for (inferior
*inf
: all_inferiors ())
408 /* Return a thread by port. */
409 static darwin_thread_t
*
410 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
412 darwin_inferior
*priv
= get_darwin_inferior (inf
);
415 for (darwin_thread_t
*t
: priv
->threads
)
417 if (t
->gdb_port
== thread
)
424 /* Suspend (ie stop) an inferior at Mach level. */
427 darwin_suspend_inferior (struct inferior
*inf
)
429 darwin_inferior
*priv
= get_darwin_inferior (inf
);
431 if (priv
!= nullptr && !priv
->suspended
)
435 kret
= task_suspend (priv
->task
);
436 MACH_CHECK_ERROR (kret
);
442 /* Resume an inferior at Mach level. */
445 darwin_resume_inferior (struct inferior
*inf
)
447 darwin_inferior
*priv
= get_darwin_inferior (inf
);
449 if (priv
!= nullptr && priv
->suspended
)
453 kret
= task_resume (priv
->task
);
454 MACH_CHECK_ERROR (kret
);
461 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
463 gdb_printf (gdb_stdlog
,
464 _("message header:\n"));
465 gdb_printf (gdb_stdlog
,
466 _(" bits: 0x%x\n"), hdr
->msgh_bits
);
467 gdb_printf (gdb_stdlog
,
468 _(" size: 0x%x\n"), hdr
->msgh_size
);
469 gdb_printf (gdb_stdlog
,
470 _(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
471 gdb_printf (gdb_stdlog
,
472 _(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
473 gdb_printf (gdb_stdlog
,
474 _(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
475 gdb_printf (gdb_stdlog
,
476 _(" id: 0x%x\n"), hdr
->msgh_id
);
480 const unsigned char *data
;
481 const unsigned int *ldata
;
485 data
= (unsigned char *)(hdr
+ 1);
486 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
488 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
490 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
491 mach_msg_port_descriptor_t
*desc
=
492 (mach_msg_port_descriptor_t
*)(bod
+ 1);
495 gdb_printf (gdb_stdlog
,
496 _("body: descriptor_count=%u\n"),
497 bod
->msgh_descriptor_count
);
498 data
+= sizeof (mach_msg_body_t
);
499 size
-= sizeof (mach_msg_body_t
);
500 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
501 switch (desc
[k
].type
)
503 case MACH_MSG_PORT_DESCRIPTOR
:
506 _(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
507 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
510 gdb_printf (gdb_stdlog
,
511 _(" descr %d: type=%u\n"),
515 data
+= bod
->msgh_descriptor_count
516 * sizeof (mach_msg_port_descriptor_t
);
517 size
-= bod
->msgh_descriptor_count
518 * sizeof (mach_msg_port_descriptor_t
);
519 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
522 _("NDR: mig=%02x if=%02x encod=%02x "
523 "int=%02x char=%02x float=%02x\n"),
524 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
525 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
526 data
+= sizeof (NDR_record_t
);
527 size
-= sizeof (NDR_record_t
);
530 gdb_printf (gdb_stdlog
, _(" data:"));
531 ldata
= (const unsigned int *)data
;
532 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
533 gdb_printf (gdb_stdlog
, " %08x", ldata
[i
]);
534 gdb_printf (gdb_stdlog
, _("\n"));
538 /* Adjust inferior data when a new task was created. */
540 static struct inferior
*
541 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
544 struct inferior
*inf
;
548 /* Find the corresponding pid. */
549 kret
= pid_for_task (task_port
, &task_pid
);
550 if (kret
!= KERN_SUCCESS
)
552 MACH_CHECK_ERROR (kret
);
556 /* Find the inferior for this pid. */
557 inf
= darwin_find_inferior_by_pid (task_pid
);
561 darwin_inferior
*priv
= get_darwin_inferior (inf
);
563 /* Deallocate saved exception ports. */
564 darwin_deallocate_exception_ports (priv
);
566 /* No need to remove dead_name notification, but still... */
567 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
568 MACH_NOTIFY_DEAD_NAME
, 0,
570 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
572 if (kret
!= KERN_INVALID_ARGUMENT
)
573 MACH_CHECK_ERROR (kret
);
575 /* Replace old task port. */
576 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
577 MACH_CHECK_ERROR (kret
);
578 priv
->task
= task_port
;
580 darwin_setup_request_notification (inf
);
581 darwin_setup_exceptions (inf
);
586 /* Check data representation. */
589 darwin_check_message_ndr (NDR_record_t
*ndr
)
591 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
592 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
593 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
594 || ndr
->int_rep
!= NDR_record
.int_rep
595 || ndr
->char_rep
!= NDR_record
.char_rep
596 || ndr
->float_rep
!= NDR_record
.float_rep
)
601 /* Decode an exception message. */
604 darwin_nat_target::decode_exception_message (mach_msg_header_t
*hdr
,
606 darwin_thread_t
**pthread
)
608 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
609 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
612 struct inferior
*inf
;
613 darwin_thread_t
*thread
;
615 thread_t thread_port
;
619 /* Check message destination. */
620 if (hdr
->msgh_local_port
!= darwin_ex_port
)
623 /* Check message header. */
624 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
627 /* Check descriptors. */
628 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
629 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
630 || bod
->msgh_descriptor_count
!= 2
631 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
632 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
633 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
634 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
637 /* Check data representation. */
638 ndr
= (NDR_record_t
*)(desc
+ 2);
639 if (darwin_check_message_ndr (ndr
) != 0)
642 /* Ok, the hard work. */
643 data
= (integer_t
*)(ndr
+ 1);
645 task_port
= desc
[1].name
;
646 thread_port
= desc
[0].name
;
648 /* Find process by port. */
649 inf
= darwin_find_inferior_by_task (task_port
);
652 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
653 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
655 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
656 as a new Mach task is created when a process exec. */
657 inf
= darwin_find_new_inferior (task_port
, thread_port
);
662 /* Deallocate task_port, unless it was saved. */
663 kret
= mach_port_deallocate (mach_task_self (), task_port
);
664 MACH_CHECK_ERROR (kret
);
669 /* We got new rights to the task, get rid of it. Do not get rid of
670 thread right, as we will need it to find the thread. */
671 kret
= mach_port_deallocate (mach_task_self (), task_port
);
672 MACH_CHECK_ERROR (kret
);
677 /* Not a known inferior. This could happen if the child fork, as
678 the created process will inherit its exception port.
679 FIXME: should the exception port be restored ? */
680 mig_reply_error_t reply
;
683 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
686 /* Free thread port (we don't know it). */
687 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
688 MACH_CHECK_ERROR (kret
);
690 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
692 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
693 reply
.Head
.msgh_size
, 0,
694 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
696 MACH_CHECK_ERROR (kret
);
701 /* Find thread by port. */
702 /* Check for new threads. Do it early so that the port in the exception
703 message can be deallocated. */
704 check_new_threads (inf
);
706 /* Free the thread port (as gdb knows the thread, it has already has a right
707 for it, so this just decrement a reference counter). */
708 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
709 MACH_CHECK_ERROR (kret
);
711 thread
= darwin_find_thread (inf
, thread_port
);
716 /* The thread should be running. However we have observed cases where a
717 thread got a SIGTTIN message after being stopped. */
718 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
720 /* Finish decoding. */
721 thread
->event
.header
= *hdr
;
722 thread
->event
.thread_port
= thread_port
;
723 thread
->event
.task_port
= task_port
;
724 thread
->event
.ex_type
= data
[0];
725 thread
->event
.data_count
= data
[1];
727 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
728 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
729 + data
[1] * sizeof (integer_t
)))
731 for (i
= 0; i
< data
[1]; i
++)
732 thread
->event
.ex_data
[i
] = data
[2 + i
];
734 thread
->msg_state
= DARWIN_MESSAGE
;
739 /* Decode dead_name notify message. */
742 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
744 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
745 integer_t
*data
= (integer_t
*)(ndr
+ 1);
746 struct inferior
*inf
;
749 /* Check message header. */
750 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
753 /* Check descriptors. */
754 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
757 /* Check data representation. */
758 if (darwin_check_message_ndr (ndr
) != 0)
763 /* Find process by port. */
764 inf
= darwin_find_inferior_by_task (task_port
);
767 /* Check message destination. */
770 darwin_inferior
*priv
= get_darwin_inferior (inf
);
771 if (hdr
->msgh_local_port
!= priv
->notify_port
)
779 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
782 mach_msg_header_t
*rh
= &reply
->Head
;
784 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
785 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
786 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
787 rh
->msgh_local_port
= MACH_PORT_NULL
;
788 rh
->msgh_id
= hdr
->msgh_id
+ 100;
790 reply
->NDR
= NDR_record
;
791 reply
->RetCode
= code
;
795 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
798 mig_reply_error_t reply
;
799 darwin_inferior
*priv
= get_darwin_inferior (inf
);
801 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
803 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
804 reply
.Head
.msgh_size
, 0,
805 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
807 MACH_CHECK_ERROR (kret
);
809 priv
->pending_messages
--;
812 /* Wrapper around the __pthread_kill syscall. We use this instead of the
813 pthread_kill function to be able to send a signal to any kind of thread,
814 including GCD threads. */
817 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
820 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
821 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
827 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
828 int step
, int nsignal
)
831 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
832 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
834 switch (thread
->msg_state
)
837 if (thread
->event
.ex_type
== EXC_SOFTWARE
838 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
840 /* Either deliver a new signal or cancel the signal received. */
841 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
842 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
844 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
848 /* Note: ptrace is allowed only if the process is stopped.
849 Directly send the signal to the thread. */
850 int res
= darwin_pthread_kill (thread
, nsignal
);
851 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
852 thread
->gdb_port
, nsignal
, res
);
853 thread
->signaled
= 1;
856 /* Set or reset single step. */
857 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
858 thread
->gdb_port
, step
);
859 darwin_set_sstep (thread
->gdb_port
, step
);
860 thread
->single_step
= step
;
862 darwin_send_reply (inf
, thread
);
863 thread
->msg_state
= DARWIN_RUNNING
;
870 kern_return_t kret
= thread_resume (thread
->gdb_port
);
871 MACH_CHECK_ERROR (kret
);
873 thread
->msg_state
= DARWIN_RUNNING
;
878 /* Resume all threads of the inferior. */
881 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
883 darwin_inferior
*priv
= get_darwin_inferior (inf
);
886 for (darwin_thread_t
*thread
: priv
->threads
)
887 darwin_resume_thread (inf
, thread
, step
, nsignal
);
890 /* Suspend all threads of INF. */
893 darwin_suspend_inferior_threads (struct inferior
*inf
)
895 darwin_inferior
*priv
= get_darwin_inferior (inf
);
897 for (darwin_thread_t
*thread
: priv
->threads
)
899 switch (thread
->msg_state
)
906 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
907 MACH_CHECK_ERROR (kret
);
908 thread
->msg_state
= DARWIN_STOPPED
;
916 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
921 (2, _("darwin_resume: ptid=%s, step=%d, signal=%d\n"),
922 ptid
.to_string ().c_str (), step
, signal
);
924 if (signal
== GDB_SIGNAL_0
)
927 nsignal
= gdb_signal_to_host (signal
);
929 /* Don't try to single step all threads. */
931 ptid
= inferior_ptid
;
933 /* minus_one_ptid is RESUME_ALL. */
934 if (ptid
== minus_one_ptid
)
936 /* Resume threads. */
937 for (inferior
*inf
: all_inferiors ())
938 darwin_resume_inferior_threads (inf
, step
, nsignal
);
941 for (inferior
*inf
: all_inferiors ())
942 darwin_resume_inferior (inf
);
946 inferior
*inf
= find_inferior_ptid (this, ptid
);
947 long tid
= ptid
.tid ();
949 /* Stop the inferior (should be useless). */
950 darwin_suspend_inferior (inf
);
953 darwin_resume_inferior_threads (inf
, step
, nsignal
);
956 darwin_thread_t
*thread
;
958 /* Suspend threads of the task. */
959 darwin_suspend_inferior_threads (inf
);
961 /* Resume the selected thread. */
962 thread
= darwin_find_thread (inf
, tid
);
964 darwin_resume_thread (inf
, thread
, step
, nsignal
);
967 /* Resume the task. */
968 darwin_resume_inferior (inf
);
973 darwin_nat_target::decode_message (mach_msg_header_t
*hdr
,
974 darwin_thread_t
**pthread
,
976 target_waitstatus
*status
)
978 darwin_thread_t
*thread
;
979 struct inferior
*inf
;
981 /* Exception message. 2401 == 0x961 is exc. */
982 if (hdr
->msgh_id
== 2401)
986 /* Decode message. */
987 res
= decode_exception_message (hdr
, &inf
, &thread
);
991 /* Should not happen... */
992 warning (_("darwin_wait: ill-formatted message (id=0x%x)\n"),
994 /* FIXME: send a failure reply? */
995 status
->set_ignore ();
996 return minus_one_ptid
;
1000 status
->set_ignore ();
1001 return minus_one_ptid
;
1006 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1008 priv
->pending_messages
++;
1010 thread
->msg_state
= DARWIN_MESSAGE
;
1012 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1014 unparse_exception_type (thread
->event
.ex_type
));
1016 switch (thread
->event
.ex_type
)
1018 case EXC_BAD_ACCESS
:
1019 status
->set_stopped (GDB_EXC_BAD_ACCESS
);
1021 case EXC_BAD_INSTRUCTION
:
1022 status
->set_stopped (GDB_EXC_BAD_INSTRUCTION
);
1024 case EXC_ARITHMETIC
:
1025 status
->set_stopped (GDB_EXC_ARITHMETIC
);
1028 status
->set_stopped (GDB_EXC_EMULATION
);
1031 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1034 (gdb_signal_from_host (thread
->event
.ex_data
[1]));
1035 inferior_debug (5, _(" (signal %d: %s)\n"),
1036 thread
->event
.ex_data
[1],
1037 gdb_signal_to_name (status
->sig ()));
1039 /* If the thread is stopped because it has received a signal
1040 that gdb has just sent, continue. */
1041 if (thread
->signaled
)
1043 thread
->signaled
= 0;
1044 darwin_send_reply (inf
, thread
);
1045 thread
->msg_state
= DARWIN_RUNNING
;
1046 status
->set_ignore ();
1050 status
->set_stopped (GDB_EXC_SOFTWARE
);
1052 case EXC_BREAKPOINT
:
1053 /* Many internal GDB routines expect breakpoints to be reported
1054 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1055 as a spurious signal. */
1056 status
->set_stopped (GDB_SIGNAL_TRAP
);
1059 status
->set_stopped (GDB_SIGNAL_UNKNOWN
);
1063 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1065 else if (hdr
->msgh_id
== 0x48)
1067 /* MACH_NOTIFY_DEAD_NAME: notification for exit *or* WIFSTOPPED. */
1070 res
= darwin_decode_notify_message (hdr
, &inf
);
1074 /* Should not happen... */
1076 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1083 if (res
< 0 || inf
== NULL
)
1085 status
->set_ignore ();
1086 return minus_one_ptid
;
1091 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1093 if (!priv
->no_ptrace
)
1098 res_pid
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1099 if (res_pid
< 0 || res_pid
!= inf
->pid
)
1101 warning (_("wait4: res=%d: %s\n"),
1102 res_pid
, safe_strerror (errno
));
1103 status
->set_ignore ();
1104 return minus_one_ptid
;
1106 if (WIFEXITED (wstatus
))
1108 status
->set_exited (WEXITSTATUS (wstatus
));
1109 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1112 else if (WIFSTOPPED (wstatus
))
1114 /* Ignore stopped state, it will be handled by the next
1116 status
->set_ignore ();
1117 inferior_debug (4, _("darwin_wait: pid %d received WIFSTOPPED\n"),
1119 return minus_one_ptid
;
1121 else if (WIFSIGNALED (wstatus
))
1123 status
->set_signalled
1124 (gdb_signal_from_host (WTERMSIG (wstatus
)));
1125 inferior_debug (4, _("darwin_wait: pid=%d received signal %d\n"),
1126 res_pid
, status
->sig());
1130 status
->set_ignore ();
1131 warning (_("Unexpected wait status after MACH_NOTIFY_DEAD_NAME "
1132 "notification: 0x%x"), wstatus
);
1133 return minus_one_ptid
;
1136 return ptid_t (inf
->pid
);
1140 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1141 status
->set_exited (0 /* Don't know. */);
1142 return ptid_t (inf
->pid
, 0, 0);
1147 /* Unknown message. */
1148 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1149 status
->set_ignore ();
1150 return minus_one_ptid
;
1154 darwin_nat_target::cancel_breakpoint (ptid_t ptid
)
1156 /* Arrange for a breakpoint to be hit again later. We will handle
1157 the current event, eventually we will resume this thread, and this
1158 breakpoint will trap again.
1160 If we do not do this, then we run the risk that the user will
1161 delete or disable the breakpoint, but the thread will have already
1164 struct regcache
*regcache
= get_thread_regcache (this, ptid
);
1165 struct gdbarch
*gdbarch
= regcache
->arch ();
1168 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1169 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1171 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1172 (unsigned long) ptid
.tid ());
1174 /* Back up the PC if necessary. */
1175 if (gdbarch_decr_pc_after_break (gdbarch
))
1176 regcache_write_pc (regcache
, pc
);
1184 darwin_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*status
)
1189 mach_msg_header_t hdr
;
1192 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1194 darwin_thread_t
*thread
;
1197 (2, _("darwin_wait: waiting for a message ptid=%s\n"),
1198 ptid
.to_string ().c_str ());
1200 /* Handle fake stop events at first. */
1201 if (darwin_inf_fake_stop
!= NULL
)
1203 inferior
*inf
= darwin_inf_fake_stop
;
1204 darwin_inf_fake_stop
= NULL
;
1206 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1208 status
->set_stopped (GDB_SIGNAL_TRAP
);
1209 thread
= priv
->threads
[0];
1210 thread
->msg_state
= DARWIN_STOPPED
;
1211 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1216 /* set_sigint_trap (); */
1218 /* Wait for a message. */
1219 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1220 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1222 /* clear_sigint_trap (); */
1224 if (kret
== MACH_RCV_INTERRUPTED
)
1226 status
->set_ignore ();
1227 return minus_one_ptid
;
1230 if (kret
!= MACH_MSG_SUCCESS
)
1232 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1233 status
->set_spurious ();
1234 return minus_one_ptid
;
1237 /* Debug: display message. */
1238 if (darwin_debug_flag
> 10)
1239 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1242 res
= decode_message (hdr
, &thread
, &inf
, status
);
1243 if (res
== minus_one_ptid
)
1246 /* Early return in case an inferior has exited. */
1250 while (status
->kind () == TARGET_WAITKIND_IGNORE
);
1252 /* Stop all tasks. */
1253 for (inferior
*inf
: all_inferiors (this))
1255 darwin_suspend_inferior (inf
);
1256 check_new_threads (inf
);
1259 /* Read pending messages. */
1262 struct target_waitstatus status2
;
1265 kret
= mach_msg (&msgin
.hdr
,
1266 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1267 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1269 if (kret
== MACH_RCV_TIMED_OUT
)
1271 if (kret
!= MACH_MSG_SUCCESS
)
1274 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1278 /* Debug: display message. */
1279 if (darwin_debug_flag
> 10)
1280 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1283 ptid2
= decode_message (hdr
, &thread
, &inf
, &status2
);
1285 if (inf
!= NULL
&& thread
!= NULL
1286 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1288 if (thread
->single_step
1289 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1291 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1292 darwin_send_reply (inf
, thread
);
1293 thread
->msg_state
= DARWIN_RUNNING
;
1297 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1301 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1307 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1308 target_wait_flags options
)
1310 return wait_1 (ptid
, status
);
1314 darwin_nat_target::interrupt ()
1316 struct inferior
*inf
= current_inferior ();
1317 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1319 /* FIXME: handle in no_ptrace mode. */
1320 gdb_assert (!priv
->no_ptrace
);
1321 ::kill (inf
->pid
, SIGINT
);
1324 /* Deallocate threads port and vector. */
1327 darwin_deallocate_threads (struct inferior
*inf
)
1329 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1331 for (darwin_thread_t
*t
: priv
->threads
)
1333 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1334 MACH_CHECK_ERROR (kret
);
1337 priv
->threads
.clear ();
1341 darwin_nat_target::mourn_inferior ()
1343 struct inferior
*inf
= current_inferior ();
1344 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1348 /* Deallocate threads. */
1349 darwin_deallocate_threads (inf
);
1351 /* Remove notify_port from darwin_port_set. */
1352 kret
= mach_port_move_member (gdb_task
,
1353 priv
->notify_port
, MACH_PORT_NULL
);
1354 MACH_CHECK_ERROR (kret
);
1356 /* Remove task port dead_name notification. */
1357 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1358 MACH_NOTIFY_DEAD_NAME
, 0,
1360 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1362 /* This can fail if the task is dead. */
1363 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1364 priv
->task
, prev
, priv
->notify_port
);
1366 if (kret
== KERN_SUCCESS
)
1368 kret
= mach_port_deallocate (gdb_task
, prev
);
1369 MACH_CHECK_ERROR (kret
);
1372 /* Destroy notify_port. */
1373 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1374 MACH_CHECK_ERROR (kret
);
1376 /* Deallocate saved exception ports. */
1377 darwin_deallocate_exception_ports (priv
);
1379 /* Deallocate task port. */
1380 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1381 MACH_CHECK_ERROR (kret
);
1385 inf_child_target::mourn_inferior ();
1389 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1391 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1393 for (darwin_thread_t
*t
: priv
->threads
)
1395 if (t
->msg_state
== DARWIN_MESSAGE
)
1396 darwin_resume_thread (inf
, t
, 0, 0);
1401 darwin_nat_target::stop_inferior (inferior
*inf
)
1403 struct target_waitstatus wstatus
;
1406 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1408 gdb_assert (inf
!= NULL
);
1410 darwin_suspend_inferior (inf
);
1412 darwin_reply_to_all_pending_messages (inf
);
1414 if (priv
->no_ptrace
)
1417 res
= ::kill (inf
->pid
, SIGSTOP
);
1419 warning (_("cannot kill: %s"), safe_strerror (errno
));
1421 /* Wait until the process is really stopped. */
1424 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1425 if (wstatus
.kind () == TARGET_WAITKIND_STOPPED
1426 && wstatus
.sig () == GDB_SIGNAL_STOP
)
1431 static kern_return_t
1432 darwin_save_exception_ports (darwin_inferior
*inf
)
1436 inf
->exception_info
.count
=
1437 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1439 kret
= task_get_exception_ports
1440 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1441 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1442 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1446 static kern_return_t
1447 darwin_restore_exception_ports (darwin_inferior
*inf
)
1452 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1454 kret
= task_set_exception_ports
1455 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1456 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1457 if (kret
!= KERN_SUCCESS
)
1461 return KERN_SUCCESS
;
1464 /* Deallocate saved exception ports. */
1467 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1472 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1474 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1475 MACH_CHECK_ERROR (kret
);
1477 inf
->exception_info
.count
= 0;
1481 darwin_setup_exceptions (struct inferior
*inf
)
1483 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1485 exception_mask_t mask
;
1487 kret
= darwin_save_exception_ports (priv
);
1488 if (kret
!= KERN_SUCCESS
)
1489 error (_("Unable to save exception ports, task_get_exception_ports"
1493 /* Set exception port. */
1494 if (enable_mach_exceptions
)
1495 mask
= EXC_MASK_ALL
;
1497 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1498 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1499 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1500 if (kret
!= KERN_SUCCESS
)
1501 error (_("Unable to set exception ports, task_set_exception_ports"
1507 darwin_nat_target::kill ()
1509 struct inferior
*inf
= current_inferior ();
1510 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1511 struct target_waitstatus wstatus
;
1516 if (inferior_ptid
== null_ptid
)
1519 gdb_assert (inf
!= NULL
);
1521 kret
= darwin_restore_exception_ports (priv
);
1522 MACH_CHECK_ERROR (kret
);
1524 darwin_reply_to_all_pending_messages (inf
);
1526 res
= ::kill (inf
->pid
, 9);
1530 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1531 does not work as expected.
1532 When the kill function is called, the SIGKILL signal is received
1533 by gdb whereas it should have been received by the kernel since
1534 the exception ports have been restored.
1535 This behavior is not the expected one thus gdb does not reply to
1536 the received SIGKILL message. This situation leads to a "busy"
1537 resource from the kernel point of view and the inferior is never
1538 released, causing it to remain as a zombie process, even after
1540 To work around this, we mark all the threads of the inferior as
1541 signaled thus darwin_decode_message function knows that the kill
1542 signal was sent by gdb and will take the appropriate action
1543 (cancel signal and reply to the signal message). */
1544 for (darwin_thread_t
*thread
: priv
->threads
)
1545 thread
->signaled
= 1;
1547 darwin_resume_inferior (inf
);
1549 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1551 else if (errno
!= ESRCH
)
1552 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1553 inf
->pid
, safe_strerror (errno
));
1555 target_mourn_inferior (ptid_t (inf
->pid
));
1559 darwin_setup_request_notification (struct inferior
*inf
)
1561 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1563 mach_port_t prev_not
;
1565 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1566 MACH_NOTIFY_DEAD_NAME
, 0,
1568 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1570 if (kret
!= KERN_SUCCESS
)
1571 error (_("Termination notification request failed, "
1572 "mach_port_request_notification\n"
1575 if (prev_not
!= MACH_PORT_NULL
)
1577 /* This is unexpected, as there should not be any previously
1578 registered notification request. But this is not a fatal
1579 issue, so just emit a warning. */
1581 A task termination request was registered before the debugger registered\n\
1582 its own. This is unexpected, but should otherwise not have any actual\n\
1583 impact on the debugging session."));
1588 darwin_attach_pid (struct inferior
*inf
)
1592 darwin_inferior
*priv
= new darwin_inferior
;
1593 inf
->priv
.reset (priv
);
1597 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1598 if (kret
!= KERN_SUCCESS
)
1602 if (!inf
->attach_flag
)
1605 waitpid (inf
->pid
, &status
, 0);
1609 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1610 " (please check gdb is codesigned - see taskgated(8))"),
1611 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1614 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1615 priv
->task
, inf
->pid
);
1617 if (darwin_ex_port
== MACH_PORT_NULL
)
1619 /* Create a port to get exceptions. */
1620 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1622 if (kret
!= KERN_SUCCESS
)
1623 error (_("Unable to create exception port, mach_port_allocate "
1627 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1629 MACH_MSG_TYPE_MAKE_SEND
);
1630 if (kret
!= KERN_SUCCESS
)
1631 error (_("Unable to create exception port, mach_port_insert_right "
1635 /* Create a port set and put ex_port in it. */
1636 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1638 if (kret
!= KERN_SUCCESS
)
1639 error (_("Unable to create port set, mach_port_allocate "
1643 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1645 if (kret
!= KERN_SUCCESS
)
1646 error (_("Unable to move exception port into new port set, "
1647 "mach_port_move_member\n"
1652 /* Create a port to be notified when the child task terminates. */
1653 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1654 &priv
->notify_port
);
1655 if (kret
!= KERN_SUCCESS
)
1656 error (_("Unable to create notification port, mach_port_allocate "
1660 kret
= mach_port_move_member (gdb_task
,
1661 priv
->notify_port
, darwin_port_set
);
1662 if (kret
!= KERN_SUCCESS
)
1663 error (_("Unable to move notification port into new port set, "
1664 "mach_port_move_member\n"
1668 darwin_setup_request_notification (inf
);
1670 darwin_setup_exceptions (inf
);
1672 catch (const gdb_exception
&ex
)
1674 exit_inferior (inf
);
1675 switch_to_no_thread ();
1680 target_ops
*darwin_ops
= get_native_target ();
1681 if (!inf
->target_is_pushed (darwin_ops
))
1682 inf
->push_target (darwin_ops
);
1685 /* Get the thread_info object corresponding to this darwin_thread_info. */
1687 static struct thread_info
*
1688 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1690 for (struct thread_info
*it
: all_threads ())
1692 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1694 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1698 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1702 darwin_nat_target::init_thread_list (inferior
*inf
)
1704 check_new_threads (inf
);
1706 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1708 gdb_assert (!priv
->threads
.empty ());
1710 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1711 struct thread_info
*first_thread
1712 = thread_info_from_private_thread_info (first_pti
);
1714 switch_to_thread (first_thread
);
1717 /* The child must synchronize with gdb: gdb must set the exception port
1718 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1719 FIXME: is there a lighter way ? */
1720 static int ptrace_fds
[2];
1723 darwin_ptrace_me (void)
1728 /* Close write end point. */
1729 if (close (ptrace_fds
[1]) < 0)
1730 trace_start_error_with_name ("close");
1732 /* Wait until gdb is ready. */
1733 res
= read (ptrace_fds
[0], &c
, 1);
1735 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1737 if (close (ptrace_fds
[0]) < 0)
1738 trace_start_error_with_name ("close");
1740 /* Get rid of privileges. */
1741 if (setegid (getgid ()) < 0)
1742 trace_start_error_with_name ("setegid");
1745 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1746 trace_start_error_with_name ("PTRACE");
1748 /* Redirect signals to exception port. */
1749 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1750 trace_start_error_with_name ("PTRACE");
1753 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1755 darwin_pre_ptrace (void)
1757 if (pipe (ptrace_fds
) != 0)
1761 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1764 mark_fd_no_cloexec (ptrace_fds
[0]);
1765 mark_fd_no_cloexec (ptrace_fds
[1]);
1769 darwin_nat_target::ptrace_him (int pid
)
1771 struct inferior
*inf
= current_inferior ();
1773 darwin_attach_pid (inf
);
1775 /* Let's the child run. */
1776 ::close (ptrace_fds
[0]);
1777 ::close (ptrace_fds
[1]);
1779 unmark_fd_no_cloexec (ptrace_fds
[0]);
1780 unmark_fd_no_cloexec (ptrace_fds
[1]);
1782 init_thread_list (inf
);
1784 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1788 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1790 posix_spawnattr_t attr
;
1794 res
= posix_spawnattr_init (&attr
);
1798 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1802 /* Do like execve: replace the image. */
1803 ps_flags
= POSIX_SPAWN_SETEXEC
;
1805 /* Disable ASLR. The constant doesn't look to be available outside the
1806 kernel include files. */
1807 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1808 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1810 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1811 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1814 gdb_printf (gdb_stderr
, "Cannot set posix_spawn flags\n");
1818 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1821 /* Read kernel version, and return TRUE if this host may have System
1822 Integrity Protection (Sierra or later). */
1828 size_t sz
= sizeof (str
);
1831 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1832 if (ret
== 0 && sz
< sizeof (str
))
1834 unsigned long ver
= strtoul (str
, NULL
, 10);
1841 /* A helper for maybe_cache_shell. This copies the shell to the
1842 cache. It will throw an exception on any failure. */
1845 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1847 scoped_fd from_fd
= gdb_open_cloexec (shell
, O_RDONLY
, 0);
1848 if (from_fd
.get () < 0)
1849 error (_("Could not open shell (%s) for reading: %s"),
1850 shell
, safe_strerror (errno
));
1852 std::string new_dir
= ldirname (new_name
.c_str ());
1853 if (!mkdir_recursive (new_dir
.c_str ()))
1854 error (_("Could not make cache directory \"%s\": %s"),
1855 new_dir
.c_str (), safe_strerror (errno
));
1857 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1858 scoped_fd to_fd
= gdb_mkostemp_cloexec (&temp_name
[0]);
1859 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1861 if (to_fd
.get () < 0)
1862 error (_("Could not open temporary file \"%s\" for writing: %s"),
1863 temp_name
.data (), safe_strerror (errno
));
1865 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1866 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1867 error (_("Could not copy shell to cache as \"%s\": %s"),
1868 temp_name
.data (), safe_strerror (errno
));
1870 /* Be sure that the caching is atomic so that we don't get bad
1871 results from multiple copies of gdb running at the same time. */
1872 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1873 error (_("Could not rename shell cache file to \"%s\": %s"),
1874 new_name
.c_str (), safe_strerror (errno
));
1876 unlink_file_on_error
.keep ();
1879 /* If $SHELL is restricted, try to cache a copy. Starting with El
1880 Capitan, macOS introduced System Integrity Protection. Among other
1881 things, this prevents certain executables from being ptrace'd. In
1882 particular, executables in /bin, like most shells, are affected.
1883 To work around this, while preserving command-line glob expansion
1884 and redirections, gdb will cache a copy of the shell. Return true
1885 if all is well -- either the shell is not subject to SIP or it has
1886 been successfully cached. Returns false if something failed. */
1889 maybe_cache_shell ()
1891 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1892 given file is subject to SIP. */
1893 #ifdef SF_RESTRICTED
1895 /* If a check fails we want to revert -- maybe the user deleted the
1896 cache while gdb was running, or something like that. */
1897 copied_shell
= nullptr;
1899 const char *shell
= get_shell ();
1900 if (!IS_ABSOLUTE_PATH (shell
))
1902 warning (_("This version of macOS has System Integrity Protection.\n\
1903 Normally gdb would try to work around this by caching a copy of your shell,\n\
1904 but because your shell (%s) is not an absolute path, this is being skipped."),
1910 if (stat (shell
, &sb
) < 0)
1912 warning (_("This version of macOS has System Integrity Protection.\n\
1913 Normally gdb would try to work around this by caching a copy of your shell,\n\
1914 but because gdb could not stat your shell (%s), this is being skipped.\n\
1915 The error was: %s"),
1916 shell
, safe_strerror (errno
));
1920 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1923 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1924 std::string new_name
= get_standard_cache_dir ();
1925 /* There's no need to insert a directory separator here, because
1926 SHELL is known to be absolute. */
1927 new_name
.append (shell
);
1929 /* Maybe it was cached by some earlier gdb. */
1930 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1934 copy_shell_to_cache (shell
, new_name
);
1936 catch (const gdb_exception_error
&ex
)
1938 warning (_("This version of macOS has System Integrity Protection.\n\
1939 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1940 caching a copy of your shell. However, this failed:\n\
1942 If you correct the problem, gdb will automatically try again the next time\n\
1943 you \"run\". To prevent these attempts, you can use:\n\
1944 set startup-with-shell off"),
1949 gdb_printf (_("Note: this version of macOS has System Integrity Protection.\n\
1950 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1951 caching a copy of your shell. The shell used by \"run\" is now:\n\
1956 /* We need to make sure that the new name has the correct lifetime. */
1957 static std::string saved_shell
= std::move (new_name
);
1958 copied_shell
= saved_shell
.c_str ();
1960 #endif /* SF_RESTRICTED */
1966 darwin_nat_target::create_inferior (const char *exec_file
,
1967 const std::string
&allargs
,
1968 char **env
, int from_tty
)
1970 gdb::optional
<scoped_restore_tmpl
<bool>> restore_startup_with_shell
;
1971 darwin_nat_target
*the_target
= this;
1973 if (startup_with_shell
&& may_have_sip ())
1975 if (!maybe_cache_shell ())
1977 warning (_("startup-with-shell is now temporarily disabled"));
1978 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
1982 /* Do the hard work. */
1983 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1984 [the_target
] (int pid
)
1986 the_target
->ptrace_him (pid
);
1988 darwin_pre_ptrace
, copied_shell
,
1993 /* Set things up such that the next call to darwin_wait will immediately
1994 return a fake stop event for inferior INF.
1996 This assumes that the inferior's thread list has been initialized,
1997 as it will suspend the inferior's first thread. */
2000 darwin_setup_fake_stop_event (struct inferior
*inf
)
2002 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2003 darwin_thread_t
*thread
;
2006 gdb_assert (darwin_inf_fake_stop
== NULL
);
2007 darwin_inf_fake_stop
= inf
;
2009 /* When detecting a fake pending stop event, darwin_wait returns
2010 an event saying that the first thread is in a DARWIN_STOPPED
2011 state. To make that accurate, we need to suspend that thread
2012 as well. Otherwise, we'll try resuming it when resuming the
2013 inferior, and get a warning because the thread's suspend count
2014 is already zero, making the resume request useless. */
2015 thread
= priv
->threads
[0];
2016 kret
= thread_suspend (thread
->gdb_port
);
2017 MACH_CHECK_ERROR (kret
);
2020 /* Attach to process PID, then initialize for debugging it
2021 and wait for the trace-trap that results from attaching. */
2023 darwin_nat_target::attach (const char *args
, int from_tty
)
2026 struct inferior
*inf
;
2028 pid
= parse_pid_to_attach (args
);
2030 if (pid
== getpid ()) /* Trying to masturbate? */
2031 error (_("I refuse to debug myself!"));
2033 target_announce_attach (from_tty
, pid
);
2035 if (pid
== 0 || ::kill (pid
, 0) < 0)
2036 error (_("Can't attach to process %d: %s (%d)"),
2037 pid
, safe_strerror (errno
), errno
);
2039 inf
= current_inferior ();
2040 inferior_appeared (inf
, pid
);
2041 inf
->attach_flag
= true;
2043 darwin_attach_pid (inf
);
2045 darwin_suspend_inferior (inf
);
2047 init_thread_list (inf
);
2049 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2051 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2053 darwin_setup_fake_stop_event (inf
);
2055 priv
->no_ptrace
= 1;
2058 /* Take a program previously attached to and detaches it.
2059 The program resumes execution and will no longer stop
2060 on signals, etc. We'd better not have left any breakpoints
2061 in the program or it'll die when it hits one. For this
2062 to work, it may be necessary for the process to have been
2063 previously attached. It *might* work if the program was
2064 started via fork. */
2067 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2069 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2073 /* Display message. */
2074 target_announce_detach (from_tty
);
2076 /* If ptrace() is in use, stop the process. */
2077 if (!priv
->no_ptrace
)
2078 stop_inferior (inf
);
2080 kret
= darwin_restore_exception_ports (priv
);
2081 MACH_CHECK_ERROR (kret
);
2083 if (!priv
->no_ptrace
)
2085 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2087 warning (_("Unable to detach from process-id %d: %s (%d)"),
2088 inf
->pid
, safe_strerror (errno
), errno
);
2091 darwin_reply_to_all_pending_messages (inf
);
2093 /* When using ptrace, we have just performed a PT_DETACH, which
2094 resumes the inferior. On the other hand, when we are not using
2095 ptrace, we need to resume its execution ourselves. */
2096 if (priv
->no_ptrace
)
2097 darwin_resume_inferior (inf
);
2103 darwin_nat_target::pid_to_str (ptid_t ptid
)
2105 long tid
= ptid
.tid ();
2108 return string_printf (_("Thread 0x%lx of process %u"),
2111 return normal_pid_to_str (ptid
);
2115 darwin_nat_target::thread_alive (ptid_t ptid
)
2120 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2121 copy it to RDADDR in gdb's address space.
2122 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2123 to ADDR in inferior task's address space.
2124 Return 0 on failure; number of bytes read / written otherwise. */
2127 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2128 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2132 mach_vm_size_t res_length
= 0;
2134 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2135 task
, core_addr_to_string (addr
), pulongest (length
));
2140 mach_vm_size_t count
;
2142 /* According to target.h(to_xfer_partial), one and only one may be
2144 gdb_assert (wraddr
== NULL
);
2146 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2147 (mach_vm_address_t
) rdaddr
, &count
);
2148 if (kret
!= KERN_SUCCESS
)
2151 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2152 core_addr_to_string (addr
), mach_error_string (kret
));
2159 gdb_assert (wraddr
!= NULL
);
2163 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2164 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2165 mach_vm_size_t aligned_length
=
2166 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2167 vm_region_submap_short_info_data_64_t info
;
2168 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2169 natural_t region_depth
= 1000;
2170 mach_vm_address_t region_start
= region_address
;
2171 mach_vm_size_t region_length
;
2172 mach_vm_size_t write_length
;
2174 /* Read page protection. */
2175 kret
= mach_vm_region_recurse
2176 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2177 (vm_region_recurse_info_t
) &info
, &count
);
2179 if (kret
!= KERN_SUCCESS
)
2181 inferior_debug (1, _("darwin_read_write_inferior: "
2182 "mach_vm_region_recurse failed at %s: %s\n"),
2183 core_addr_to_string (region_address
),
2184 mach_error_string (kret
));
2189 (9, _("darwin_read_write_inferior: "
2190 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2191 core_addr_to_string (region_address
),
2192 core_addr_to_string (region_start
),
2193 core_addr_to_string (region_length
));
2195 /* Check for holes in memory. */
2196 if (region_start
> region_address
)
2198 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2199 core_addr_to_string (region_address
),
2200 core_addr_to_string (region_start
),
2201 (unsigned)region_length
);
2205 /* Adjust the length. */
2206 region_length
-= (region_address
- region_start
);
2207 if (region_length
> aligned_length
)
2208 region_length
= aligned_length
;
2210 /* Make the pages RW. */
2211 if (!(info
.protection
& VM_PROT_WRITE
))
2213 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2215 kret
= mach_vm_protect (task
, region_address
, region_length
,
2217 if (kret
!= KERN_SUCCESS
)
2219 prot
|= VM_PROT_COPY
;
2220 kret
= mach_vm_protect (task
, region_address
, region_length
,
2223 if (kret
!= KERN_SUCCESS
)
2225 warning (_("darwin_read_write_inferior: "
2226 "mach_vm_protect failed at %s "
2227 "(len=0x%lx, prot=0x%x): %s"),
2228 core_addr_to_string (region_address
),
2229 (unsigned long) region_length
, (unsigned) prot
,
2230 mach_error_string (kret
));
2235 if (offset
+ length
> region_length
)
2236 write_length
= region_length
- offset
;
2238 write_length
= length
;
2241 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2242 if (kret
!= KERN_SUCCESS
)
2244 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2245 mach_error_string (kret
));
2249 /* Restore page rights. */
2250 if (!(info
.protection
& VM_PROT_WRITE
))
2252 kret
= mach_vm_protect (task
, region_address
, region_length
,
2253 FALSE
, info
.protection
);
2254 if (kret
!= KERN_SUCCESS
)
2256 warning (_("darwin_read_write_inferior: "
2257 "mach_vm_protect restore failed at %s "
2259 core_addr_to_string (region_address
),
2260 (unsigned long) region_length
,
2261 mach_error_string (kret
));
2265 addr
+= write_length
;
2266 wraddr
+= write_length
;
2267 res_length
+= write_length
;
2268 length
-= write_length
;
2274 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2275 to RDADDR (in big endian).
2276 Return 0 on failure; number of bytes read / written otherwise. */
2278 #ifdef TASK_DYLD_INFO_COUNT
2279 /* This is not available in Darwin 9. */
2280 static enum target_xfer_status
2281 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2282 ULONGEST length
, ULONGEST
*xfered_len
)
2284 struct task_dyld_info task_dyld_info
;
2285 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2288 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2289 return TARGET_XFER_EOF
;
2291 kret
= task_info (task
, TASK_DYLD_INFO
,
2292 (task_info_t
) &task_dyld_info
, &count
);
2293 MACH_CHECK_ERROR (kret
);
2294 if (kret
!= KERN_SUCCESS
)
2295 return TARGET_XFER_E_IO
;
2297 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2298 task_dyld_info
.all_image_info_addr
);
2299 *xfered_len
= (ULONGEST
) length
;
2300 return TARGET_XFER_OK
;
2306 enum target_xfer_status
2307 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2308 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2309 ULONGEST offset
, ULONGEST len
,
2310 ULONGEST
*xfered_len
)
2312 struct inferior
*inf
= current_inferior ();
2313 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2316 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2317 core_addr_to_string (offset
), pulongest (len
),
2318 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2323 case TARGET_OBJECT_MEMORY
:
2325 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2326 readbuf
, writebuf
, len
);
2329 return TARGET_XFER_EOF
;
2333 *xfered_len
= (ULONGEST
) l
;
2334 return TARGET_XFER_OK
;
2337 #ifdef TASK_DYLD_INFO_COUNT
2338 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2339 if (writebuf
!= NULL
|| readbuf
== NULL
)
2341 /* Support only read. */
2342 return TARGET_XFER_E_IO
;
2344 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2348 return TARGET_XFER_E_IO
;
2354 set_enable_mach_exceptions (const char *args
, int from_tty
,
2355 struct cmd_list_element
*c
)
2357 if (inferior_ptid
!= null_ptid
)
2359 struct inferior
*inf
= current_inferior ();
2360 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2361 exception_mask_t mask
;
2364 if (enable_mach_exceptions
)
2365 mask
= EXC_MASK_ALL
;
2368 darwin_restore_exception_ports (priv
);
2369 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2371 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2372 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2373 MACH_CHECK_ERROR (kret
);
2378 darwin_nat_target::pid_to_exec_file (int pid
)
2380 static char path
[PATH_MAX
];
2383 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2391 darwin_nat_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
2393 struct inferior
*inf
= current_inferior ();
2394 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2396 mach_port_name_array_t names
;
2397 mach_msg_type_number_t names_count
;
2398 mach_port_type_array_t types
;
2399 mach_msg_type_number_t types_count
;
2402 /* First linear search. */
2403 for (darwin_thread_t
*t
: priv
->threads
)
2405 if (t
->inf_port
== lwp
)
2406 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2409 /* Maybe the port was never extract. Do it now. */
2411 /* First get inferior port names. */
2412 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2414 MACH_CHECK_ERROR (kret
);
2415 if (kret
!= KERN_SUCCESS
)
2418 /* For each name, copy the right in the gdb space and then compare with
2419 our view of the inferior threads. We don't forget to deallocate the
2421 for (int i
= 0; i
< names_count
; i
++)
2423 mach_port_t local_name
;
2424 mach_msg_type_name_t local_type
;
2426 /* We just need to know the corresponding name in gdb name space.
2427 So extract and deallocate the right. */
2428 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2429 MACH_MSG_TYPE_COPY_SEND
,
2430 &local_name
, &local_type
);
2431 if (kret
!= KERN_SUCCESS
)
2433 mach_port_deallocate (gdb_task
, local_name
);
2435 for (darwin_thread_t
*t
: priv
->threads
)
2437 if (t
->gdb_port
== local_name
)
2439 t
->inf_port
= names
[i
];
2440 if (names
[i
] == lwp
)
2446 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2447 names_count
* sizeof (mach_port_t
));
2450 return ptid_t (current_inferior ()->pid
, 0, res
);
2456 darwin_nat_target::supports_multi_process ()
2461 void _initialize_darwin_nat ();
2463 _initialize_darwin_nat ()
2467 gdb_task
= mach_task_self ();
2468 darwin_host_self
= mach_host_self ();
2470 /* Read page size. */
2471 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2472 if (kret
!= KERN_SUCCESS
)
2474 mach_page_size
= 0x1000;
2475 MACH_CHECK_ERROR (kret
);
2478 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2479 (unsigned long) mach_task_self (), getpid ());
2481 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2482 &darwin_debug_flag
, _("\
2483 Set if printing inferior communication debugging statements."), _("\
2484 Show if printing inferior communication debugging statements."), NULL
,
2486 &setdebuglist
, &showdebuglist
);
2488 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2489 &enable_mach_exceptions
, _("\
2490 Set if mach exceptions are caught."), _("\
2491 Show if mach exceptions are caught."), _("\
2492 When this mode is on, all low level exceptions are reported before being\n\
2493 reported by the kernel."),
2494 &set_enable_mach_exceptions
, NULL
,
2495 &setlist
, &showlist
);