1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2022 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 fprintf_unfiltered (gdb_stdlog
, _("[%d inferior]: "), getpid ());
173 vfprintf_unfiltered (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
), 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 fprintf_unfiltered (gdb_stdlog
,
463 _("message header:\n"));
464 fprintf_unfiltered (gdb_stdlog
,
465 _(" bits: 0x%x\n"), hdr
->msgh_bits
);
466 fprintf_unfiltered (gdb_stdlog
,
467 _(" size: 0x%x\n"), hdr
->msgh_size
);
468 fprintf_unfiltered (gdb_stdlog
,
469 _(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
470 fprintf_unfiltered (gdb_stdlog
,
471 _(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
472 fprintf_unfiltered (gdb_stdlog
,
473 _(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
474 fprintf_unfiltered (gdb_stdlog
,
475 _(" id: 0x%x\n"), hdr
->msgh_id
);
479 const unsigned char *data
;
480 const unsigned int *ldata
;
484 data
= (unsigned char *)(hdr
+ 1);
485 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
487 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
489 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
490 mach_msg_port_descriptor_t
*desc
=
491 (mach_msg_port_descriptor_t
*)(bod
+ 1);
494 fprintf_unfiltered (gdb_stdlog
,
495 _("body: descriptor_count=%u\n"),
496 bod
->msgh_descriptor_count
);
497 data
+= sizeof (mach_msg_body_t
);
498 size
-= sizeof (mach_msg_body_t
);
499 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
500 switch (desc
[k
].type
)
502 case MACH_MSG_PORT_DESCRIPTOR
:
505 _(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
506 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
509 fprintf_unfiltered (gdb_stdlog
,
510 _(" descr %d: type=%u\n"),
514 data
+= bod
->msgh_descriptor_count
515 * sizeof (mach_msg_port_descriptor_t
);
516 size
-= bod
->msgh_descriptor_count
517 * sizeof (mach_msg_port_descriptor_t
);
518 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
521 _("NDR: mig=%02x if=%02x encod=%02x "
522 "int=%02x char=%02x float=%02x\n"),
523 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
524 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
525 data
+= sizeof (NDR_record_t
);
526 size
-= sizeof (NDR_record_t
);
529 fprintf_unfiltered (gdb_stdlog
, _(" data:"));
530 ldata
= (const unsigned int *)data
;
531 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
532 fprintf_unfiltered (gdb_stdlog
, " %08x", ldata
[i
]);
533 fprintf_unfiltered (gdb_stdlog
, _("\n"));
537 /* Adjust inferior data when a new task was created. */
539 static struct inferior
*
540 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
543 struct inferior
*inf
;
547 /* Find the corresponding pid. */
548 kret
= pid_for_task (task_port
, &task_pid
);
549 if (kret
!= KERN_SUCCESS
)
551 MACH_CHECK_ERROR (kret
);
555 /* Find the inferior for this pid. */
556 inf
= darwin_find_inferior_by_pid (task_pid
);
560 darwin_inferior
*priv
= get_darwin_inferior (inf
);
562 /* Deallocate saved exception ports. */
563 darwin_deallocate_exception_ports (priv
);
565 /* No need to remove dead_name notification, but still... */
566 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
567 MACH_NOTIFY_DEAD_NAME
, 0,
569 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
571 if (kret
!= KERN_INVALID_ARGUMENT
)
572 MACH_CHECK_ERROR (kret
);
574 /* Replace old task port. */
575 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
576 MACH_CHECK_ERROR (kret
);
577 priv
->task
= task_port
;
579 darwin_setup_request_notification (inf
);
580 darwin_setup_exceptions (inf
);
585 /* Check data representation. */
588 darwin_check_message_ndr (NDR_record_t
*ndr
)
590 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
591 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
592 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
593 || ndr
->int_rep
!= NDR_record
.int_rep
594 || ndr
->char_rep
!= NDR_record
.char_rep
595 || ndr
->float_rep
!= NDR_record
.float_rep
)
600 /* Decode an exception message. */
603 darwin_nat_target::decode_exception_message (mach_msg_header_t
*hdr
,
605 darwin_thread_t
**pthread
)
607 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
608 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
611 struct inferior
*inf
;
612 darwin_thread_t
*thread
;
614 thread_t thread_port
;
618 /* Check message destination. */
619 if (hdr
->msgh_local_port
!= darwin_ex_port
)
622 /* Check message header. */
623 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
626 /* Check descriptors. */
627 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
628 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
629 || bod
->msgh_descriptor_count
!= 2
630 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
631 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
632 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
633 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
636 /* Check data representation. */
637 ndr
= (NDR_record_t
*)(desc
+ 2);
638 if (darwin_check_message_ndr (ndr
) != 0)
641 /* Ok, the hard work. */
642 data
= (integer_t
*)(ndr
+ 1);
644 task_port
= desc
[1].name
;
645 thread_port
= desc
[0].name
;
647 /* Find process by port. */
648 inf
= darwin_find_inferior_by_task (task_port
);
651 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
652 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
654 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
655 as a new Mach task is created when a process exec. */
656 inf
= darwin_find_new_inferior (task_port
, thread_port
);
661 /* Deallocate task_port, unless it was saved. */
662 kret
= mach_port_deallocate (mach_task_self (), task_port
);
663 MACH_CHECK_ERROR (kret
);
668 /* We got new rights to the task, get rid of it. Do not get rid of
669 thread right, as we will need it to find the thread. */
670 kret
= mach_port_deallocate (mach_task_self (), task_port
);
671 MACH_CHECK_ERROR (kret
);
676 /* Not a known inferior. This could happen if the child fork, as
677 the created process will inherit its exception port.
678 FIXME: should the exception port be restored ? */
679 mig_reply_error_t reply
;
682 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
685 /* Free thread port (we don't know it). */
686 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
687 MACH_CHECK_ERROR (kret
);
689 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
691 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
692 reply
.Head
.msgh_size
, 0,
693 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
695 MACH_CHECK_ERROR (kret
);
700 /* Find thread by port. */
701 /* Check for new threads. Do it early so that the port in the exception
702 message can be deallocated. */
703 check_new_threads (inf
);
705 /* Free the thread port (as gdb knows the thread, it has already has a right
706 for it, so this just decrement a reference counter). */
707 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
708 MACH_CHECK_ERROR (kret
);
710 thread
= darwin_find_thread (inf
, thread_port
);
715 /* The thread should be running. However we have observed cases where a
716 thread got a SIGTTIN message after being stopped. */
717 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
719 /* Finish decoding. */
720 thread
->event
.header
= *hdr
;
721 thread
->event
.thread_port
= thread_port
;
722 thread
->event
.task_port
= task_port
;
723 thread
->event
.ex_type
= data
[0];
724 thread
->event
.data_count
= data
[1];
726 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
727 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
728 + data
[1] * sizeof (integer_t
)))
730 for (i
= 0; i
< data
[1]; i
++)
731 thread
->event
.ex_data
[i
] = data
[2 + i
];
733 thread
->msg_state
= DARWIN_MESSAGE
;
738 /* Decode dead_name notify message. */
741 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
743 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
744 integer_t
*data
= (integer_t
*)(ndr
+ 1);
745 struct inferior
*inf
;
748 /* Check message header. */
749 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
752 /* Check descriptors. */
753 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
756 /* Check data representation. */
757 if (darwin_check_message_ndr (ndr
) != 0)
762 /* Find process by port. */
763 inf
= darwin_find_inferior_by_task (task_port
);
766 /* Check message destination. */
769 darwin_inferior
*priv
= get_darwin_inferior (inf
);
770 if (hdr
->msgh_local_port
!= priv
->notify_port
)
778 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
781 mach_msg_header_t
*rh
= &reply
->Head
;
783 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
784 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
785 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
786 rh
->msgh_local_port
= MACH_PORT_NULL
;
787 rh
->msgh_id
= hdr
->msgh_id
+ 100;
789 reply
->NDR
= NDR_record
;
790 reply
->RetCode
= code
;
794 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
797 mig_reply_error_t reply
;
798 darwin_inferior
*priv
= get_darwin_inferior (inf
);
800 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
802 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
803 reply
.Head
.msgh_size
, 0,
804 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
806 MACH_CHECK_ERROR (kret
);
808 priv
->pending_messages
--;
811 /* Wrapper around the __pthread_kill syscall. We use this instead of the
812 pthread_kill function to be able to send a signal to any kind of thread,
813 including GCD threads. */
816 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
819 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
820 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
826 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
827 int step
, int nsignal
)
830 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
831 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
833 switch (thread
->msg_state
)
836 if (thread
->event
.ex_type
== EXC_SOFTWARE
837 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
839 /* Either deliver a new signal or cancel the signal received. */
840 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
841 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
843 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
847 /* Note: ptrace is allowed only if the process is stopped.
848 Directly send the signal to the thread. */
849 int res
= darwin_pthread_kill (thread
, nsignal
);
850 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
851 thread
->gdb_port
, nsignal
, res
);
852 thread
->signaled
= 1;
855 /* Set or reset single step. */
856 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
857 thread
->gdb_port
, step
);
858 darwin_set_sstep (thread
->gdb_port
, step
);
859 thread
->single_step
= step
;
861 darwin_send_reply (inf
, thread
);
862 thread
->msg_state
= DARWIN_RUNNING
;
869 kern_return_t kret
= thread_resume (thread
->gdb_port
);
870 MACH_CHECK_ERROR (kret
);
872 thread
->msg_state
= DARWIN_RUNNING
;
877 /* Resume all threads of the inferior. */
880 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
882 darwin_inferior
*priv
= get_darwin_inferior (inf
);
885 for (darwin_thread_t
*thread
: priv
->threads
)
886 darwin_resume_thread (inf
, thread
, step
, nsignal
);
889 /* Suspend all threads of INF. */
892 darwin_suspend_inferior_threads (struct inferior
*inf
)
894 darwin_inferior
*priv
= get_darwin_inferior (inf
);
896 for (darwin_thread_t
*thread
: priv
->threads
)
898 switch (thread
->msg_state
)
905 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
906 MACH_CHECK_ERROR (kret
);
907 thread
->msg_state
= DARWIN_STOPPED
;
915 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
920 (2, _("darwin_resume: ptid=%s, step=%d, signal=%d\n"),
921 ptid
.to_string ().c_str (), step
, signal
);
923 if (signal
== GDB_SIGNAL_0
)
926 nsignal
= gdb_signal_to_host (signal
);
928 /* Don't try to single step all threads. */
930 ptid
= inferior_ptid
;
932 /* minus_one_ptid is RESUME_ALL. */
933 if (ptid
== minus_one_ptid
)
935 /* Resume threads. */
936 for (inferior
*inf
: all_inferiors ())
937 darwin_resume_inferior_threads (inf
, step
, nsignal
);
940 for (inferior
*inf
: all_inferiors ())
941 darwin_resume_inferior (inf
);
945 inferior
*inf
= find_inferior_ptid (this, ptid
);
946 long tid
= ptid
.tid ();
948 /* Stop the inferior (should be useless). */
949 darwin_suspend_inferior (inf
);
952 darwin_resume_inferior_threads (inf
, step
, nsignal
);
955 darwin_thread_t
*thread
;
957 /* Suspend threads of the task. */
958 darwin_suspend_inferior_threads (inf
);
960 /* Resume the selected thread. */
961 thread
= darwin_find_thread (inf
, tid
);
963 darwin_resume_thread (inf
, thread
, step
, nsignal
);
966 /* Resume the task. */
967 darwin_resume_inferior (inf
);
972 darwin_nat_target::decode_message (mach_msg_header_t
*hdr
,
973 darwin_thread_t
**pthread
,
975 target_waitstatus
*status
)
977 darwin_thread_t
*thread
;
978 struct inferior
*inf
;
980 /* Exception message. 2401 == 0x961 is exc. */
981 if (hdr
->msgh_id
== 2401)
985 /* Decode message. */
986 res
= decode_exception_message (hdr
, &inf
, &thread
);
990 /* Should not happen... */
991 warning (_("darwin_wait: ill-formatted message (id=0x%x)\n"),
993 /* FIXME: send a failure reply? */
994 status
->set_ignore ();
995 return minus_one_ptid
;
999 status
->set_ignore ();
1000 return minus_one_ptid
;
1005 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1007 priv
->pending_messages
++;
1009 thread
->msg_state
= DARWIN_MESSAGE
;
1011 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1013 unparse_exception_type (thread
->event
.ex_type
));
1015 switch (thread
->event
.ex_type
)
1017 case EXC_BAD_ACCESS
:
1018 status
->set_stopped (GDB_EXC_BAD_ACCESS
);
1020 case EXC_BAD_INSTRUCTION
:
1021 status
->set_stopped (GDB_EXC_BAD_INSTRUCTION
);
1023 case EXC_ARITHMETIC
:
1024 status
->set_stopped (GDB_EXC_ARITHMETIC
);
1027 status
->set_stopped (GDB_EXC_EMULATION
);
1030 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1033 (gdb_signal_from_host (thread
->event
.ex_data
[1]));
1034 inferior_debug (5, _(" (signal %d: %s)\n"),
1035 thread
->event
.ex_data
[1],
1036 gdb_signal_to_name (status
->sig ()));
1038 /* If the thread is stopped because it has received a signal
1039 that gdb has just sent, continue. */
1040 if (thread
->signaled
)
1042 thread
->signaled
= 0;
1043 darwin_send_reply (inf
, thread
);
1044 thread
->msg_state
= DARWIN_RUNNING
;
1045 status
->set_ignore ();
1049 status
->set_stopped (GDB_EXC_SOFTWARE
);
1051 case EXC_BREAKPOINT
:
1052 /* Many internal GDB routines expect breakpoints to be reported
1053 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1054 as a spurious signal. */
1055 status
->set_stopped (GDB_SIGNAL_TRAP
);
1058 status
->set_stopped (GDB_SIGNAL_UNKNOWN
);
1062 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1064 else if (hdr
->msgh_id
== 0x48)
1066 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1069 res
= darwin_decode_notify_message (hdr
, &inf
);
1073 /* Should not happen... */
1075 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1082 if (res
< 0 || inf
== NULL
)
1084 status
->set_ignore ();
1085 return minus_one_ptid
;
1090 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1092 if (!priv
->no_ptrace
)
1097 res_pid
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1098 if (res_pid
< 0 || res_pid
!= inf
->pid
)
1100 warning (_("wait4: res=%d: %s\n"),
1101 res_pid
, safe_strerror (errno
));
1102 status
->set_ignore ();
1103 return minus_one_ptid
;
1105 if (WIFEXITED (wstatus
))
1106 status
->set_exited (WEXITSTATUS (wstatus
));
1109 status
->set_signalled
1110 (gdb_signal_from_host (WTERMSIG (wstatus
)));
1113 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1116 /* Looks necessary on Leopard and harmless... */
1117 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1119 return ptid_t (inf
->pid
);
1123 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1124 status
->set_exited (0 /* Don't know. */);
1125 return ptid_t (inf
->pid
, 0, 0);
1130 /* Unknown message. */
1131 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1132 status
->set_ignore ();
1133 return minus_one_ptid
;
1137 darwin_nat_target::cancel_breakpoint (ptid_t ptid
)
1139 /* Arrange for a breakpoint to be hit again later. We will handle
1140 the current event, eventually we will resume this thread, and this
1141 breakpoint will trap again.
1143 If we do not do this, then we run the risk that the user will
1144 delete or disable the breakpoint, but the thread will have already
1147 struct regcache
*regcache
= get_thread_regcache (this, ptid
);
1148 struct gdbarch
*gdbarch
= regcache
->arch ();
1151 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1152 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1154 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1155 (unsigned long) ptid
.tid ());
1157 /* Back up the PC if necessary. */
1158 if (gdbarch_decr_pc_after_break (gdbarch
))
1159 regcache_write_pc (regcache
, pc
);
1167 darwin_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*status
)
1172 mach_msg_header_t hdr
;
1175 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1177 darwin_thread_t
*thread
;
1180 (2, _("darwin_wait: waiting for a message ptid=%s\n"),
1181 ptid
.to_string ().c_str ());
1183 /* Handle fake stop events at first. */
1184 if (darwin_inf_fake_stop
!= NULL
)
1186 inferior
*inf
= darwin_inf_fake_stop
;
1187 darwin_inf_fake_stop
= NULL
;
1189 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1191 status
->set_stopped (GDB_SIGNAL_TRAP
);
1192 thread
= priv
->threads
[0];
1193 thread
->msg_state
= DARWIN_STOPPED
;
1194 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1199 /* set_sigint_trap (); */
1201 /* Wait for a message. */
1202 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1203 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1205 /* clear_sigint_trap (); */
1207 if (kret
== MACH_RCV_INTERRUPTED
)
1209 status
->set_ignore ();
1210 return minus_one_ptid
;
1213 if (kret
!= MACH_MSG_SUCCESS
)
1215 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1216 status
->set_spurious ();
1217 return minus_one_ptid
;
1220 /* Debug: display message. */
1221 if (darwin_debug_flag
> 10)
1222 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1225 res
= decode_message (hdr
, &thread
, &inf
, status
);
1226 if (res
== minus_one_ptid
)
1229 /* Early return in case an inferior has exited. */
1233 while (status
->kind () == TARGET_WAITKIND_IGNORE
);
1235 /* Stop all tasks. */
1236 for (inferior
*inf
: all_inferiors (this))
1238 darwin_suspend_inferior (inf
);
1239 check_new_threads (inf
);
1242 /* Read pending messages. */
1245 struct target_waitstatus status2
;
1248 kret
= mach_msg (&msgin
.hdr
,
1249 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1250 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1252 if (kret
== MACH_RCV_TIMED_OUT
)
1254 if (kret
!= MACH_MSG_SUCCESS
)
1257 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1261 /* Debug: display message. */
1262 if (darwin_debug_flag
> 10)
1263 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1266 ptid2
= decode_message (hdr
, &thread
, &inf
, &status2
);
1268 if (inf
!= NULL
&& thread
!= NULL
1269 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1271 if (thread
->single_step
1272 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1274 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1275 darwin_send_reply (inf
, thread
);
1276 thread
->msg_state
= DARWIN_RUNNING
;
1280 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1284 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1290 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1291 target_wait_flags options
)
1293 return wait_1 (ptid
, status
);
1297 darwin_nat_target::interrupt ()
1299 struct inferior
*inf
= current_inferior ();
1300 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1302 /* FIXME: handle in no_ptrace mode. */
1303 gdb_assert (!priv
->no_ptrace
);
1304 ::kill (inf
->pid
, SIGINT
);
1307 /* Deallocate threads port and vector. */
1310 darwin_deallocate_threads (struct inferior
*inf
)
1312 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1314 for (darwin_thread_t
*t
: priv
->threads
)
1316 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1317 MACH_CHECK_ERROR (kret
);
1320 priv
->threads
.clear ();
1324 darwin_nat_target::mourn_inferior ()
1326 struct inferior
*inf
= current_inferior ();
1327 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1331 /* Deallocate threads. */
1332 darwin_deallocate_threads (inf
);
1334 /* Remove notify_port from darwin_port_set. */
1335 kret
= mach_port_move_member (gdb_task
,
1336 priv
->notify_port
, MACH_PORT_NULL
);
1337 MACH_CHECK_ERROR (kret
);
1339 /* Remove task port dead_name notification. */
1340 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1341 MACH_NOTIFY_DEAD_NAME
, 0,
1343 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1345 /* This can fail if the task is dead. */
1346 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1347 priv
->task
, prev
, priv
->notify_port
);
1349 if (kret
== KERN_SUCCESS
)
1351 kret
= mach_port_deallocate (gdb_task
, prev
);
1352 MACH_CHECK_ERROR (kret
);
1355 /* Destroy notify_port. */
1356 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1357 MACH_CHECK_ERROR (kret
);
1359 /* Deallocate saved exception ports. */
1360 darwin_deallocate_exception_ports (priv
);
1362 /* Deallocate task port. */
1363 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1364 MACH_CHECK_ERROR (kret
);
1368 inf_child_target::mourn_inferior ();
1372 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1374 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1376 for (darwin_thread_t
*t
: priv
->threads
)
1378 if (t
->msg_state
== DARWIN_MESSAGE
)
1379 darwin_resume_thread (inf
, t
, 0, 0);
1384 darwin_nat_target::stop_inferior (inferior
*inf
)
1386 struct target_waitstatus wstatus
;
1389 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1391 gdb_assert (inf
!= NULL
);
1393 darwin_suspend_inferior (inf
);
1395 darwin_reply_to_all_pending_messages (inf
);
1397 if (priv
->no_ptrace
)
1400 res
= ::kill (inf
->pid
, SIGSTOP
);
1402 warning (_("cannot kill: %s"), safe_strerror (errno
));
1404 /* Wait until the process is really stopped. */
1407 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1408 if (wstatus
.kind () == TARGET_WAITKIND_STOPPED
1409 && wstatus
.sig () == GDB_SIGNAL_STOP
)
1414 static kern_return_t
1415 darwin_save_exception_ports (darwin_inferior
*inf
)
1419 inf
->exception_info
.count
=
1420 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1422 kret
= task_get_exception_ports
1423 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1424 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1425 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1429 static kern_return_t
1430 darwin_restore_exception_ports (darwin_inferior
*inf
)
1435 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1437 kret
= task_set_exception_ports
1438 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1439 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1440 if (kret
!= KERN_SUCCESS
)
1444 return KERN_SUCCESS
;
1447 /* Deallocate saved exception ports. */
1450 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1455 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1457 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1458 MACH_CHECK_ERROR (kret
);
1460 inf
->exception_info
.count
= 0;
1464 darwin_setup_exceptions (struct inferior
*inf
)
1466 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1468 exception_mask_t mask
;
1470 kret
= darwin_save_exception_ports (priv
);
1471 if (kret
!= KERN_SUCCESS
)
1472 error (_("Unable to save exception ports, task_get_exception_ports"
1476 /* Set exception port. */
1477 if (enable_mach_exceptions
)
1478 mask
= EXC_MASK_ALL
;
1480 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1481 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1482 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1483 if (kret
!= KERN_SUCCESS
)
1484 error (_("Unable to set exception ports, task_set_exception_ports"
1490 darwin_nat_target::kill ()
1492 struct inferior
*inf
= current_inferior ();
1493 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1494 struct target_waitstatus wstatus
;
1499 if (inferior_ptid
== null_ptid
)
1502 gdb_assert (inf
!= NULL
);
1504 kret
= darwin_restore_exception_ports (priv
);
1505 MACH_CHECK_ERROR (kret
);
1507 darwin_reply_to_all_pending_messages (inf
);
1509 res
= ::kill (inf
->pid
, 9);
1513 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1514 does not work as expected.
1515 When the kill function is called, the SIGKILL signal is received
1516 by gdb whereas it should have been received by the kernel since
1517 the exception ports have been restored.
1518 This behavior is not the expected one thus gdb does not reply to
1519 the received SIGKILL message. This situation leads to a "busy"
1520 resource from the kernel point of view and the inferior is never
1521 released, causing it to remain as a zombie process, even after
1523 To work around this, we mark all the threads of the inferior as
1524 signaled thus darwin_decode_message function knows that the kill
1525 signal was sent by gdb and will take the appropriate action
1526 (cancel signal and reply to the signal message). */
1527 for (darwin_thread_t
*thread
: priv
->threads
)
1528 thread
->signaled
= 1;
1530 darwin_resume_inferior (inf
);
1532 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1534 else if (errno
!= ESRCH
)
1535 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1536 inf
->pid
, safe_strerror (errno
));
1538 target_mourn_inferior (ptid_t (inf
->pid
));
1542 darwin_setup_request_notification (struct inferior
*inf
)
1544 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1546 mach_port_t prev_not
;
1548 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1549 MACH_NOTIFY_DEAD_NAME
, 0,
1551 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1553 if (kret
!= KERN_SUCCESS
)
1554 error (_("Termination notification request failed, "
1555 "mach_port_request_notification\n"
1558 if (prev_not
!= MACH_PORT_NULL
)
1560 /* This is unexpected, as there should not be any previously
1561 registered notification request. But this is not a fatal
1562 issue, so just emit a warning. */
1564 A task termination request was registered before the debugger registered\n\
1565 its own. This is unexpected, but should otherwise not have any actual\n\
1566 impact on the debugging session."));
1571 darwin_attach_pid (struct inferior
*inf
)
1575 darwin_inferior
*priv
= new darwin_inferior
;
1576 inf
->priv
.reset (priv
);
1580 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1581 if (kret
!= KERN_SUCCESS
)
1585 if (!inf
->attach_flag
)
1588 waitpid (inf
->pid
, &status
, 0);
1592 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1593 " (please check gdb is codesigned - see taskgated(8))"),
1594 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1597 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1598 priv
->task
, inf
->pid
);
1600 if (darwin_ex_port
== MACH_PORT_NULL
)
1602 /* Create a port to get exceptions. */
1603 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1605 if (kret
!= KERN_SUCCESS
)
1606 error (_("Unable to create exception port, mach_port_allocate "
1610 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1612 MACH_MSG_TYPE_MAKE_SEND
);
1613 if (kret
!= KERN_SUCCESS
)
1614 error (_("Unable to create exception port, mach_port_insert_right "
1618 /* Create a port set and put ex_port in it. */
1619 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1621 if (kret
!= KERN_SUCCESS
)
1622 error (_("Unable to create port set, mach_port_allocate "
1626 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1628 if (kret
!= KERN_SUCCESS
)
1629 error (_("Unable to move exception port into new port set, "
1630 "mach_port_move_member\n"
1635 /* Create a port to be notified when the child task terminates. */
1636 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1637 &priv
->notify_port
);
1638 if (kret
!= KERN_SUCCESS
)
1639 error (_("Unable to create notification port, mach_port_allocate "
1643 kret
= mach_port_move_member (gdb_task
,
1644 priv
->notify_port
, darwin_port_set
);
1645 if (kret
!= KERN_SUCCESS
)
1646 error (_("Unable to move notification port into new port set, "
1647 "mach_port_move_member\n"
1651 darwin_setup_request_notification (inf
);
1653 darwin_setup_exceptions (inf
);
1655 catch (const gdb_exception
&ex
)
1657 exit_inferior (inf
);
1658 switch_to_no_thread ();
1663 target_ops
*darwin_ops
= get_native_target ();
1664 if (!inf
->target_is_pushed (darwin_ops
))
1665 inf
->push_target (darwin_ops
);
1668 /* Get the thread_info object corresponding to this darwin_thread_info. */
1670 static struct thread_info
*
1671 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1673 for (struct thread_info
*it
: all_threads ())
1675 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1677 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1681 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1685 darwin_nat_target::init_thread_list (inferior
*inf
)
1687 check_new_threads (inf
);
1689 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1691 gdb_assert (!priv
->threads
.empty ());
1693 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1694 struct thread_info
*first_thread
1695 = thread_info_from_private_thread_info (first_pti
);
1697 switch_to_thread (first_thread
);
1700 /* The child must synchronize with gdb: gdb must set the exception port
1701 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1702 FIXME: is there a lighter way ? */
1703 static int ptrace_fds
[2];
1706 darwin_ptrace_me (void)
1711 /* Close write end point. */
1712 if (close (ptrace_fds
[1]) < 0)
1713 trace_start_error_with_name ("close");
1715 /* Wait until gdb is ready. */
1716 res
= read (ptrace_fds
[0], &c
, 1);
1718 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1720 if (close (ptrace_fds
[0]) < 0)
1721 trace_start_error_with_name ("close");
1723 /* Get rid of privileges. */
1724 if (setegid (getgid ()) < 0)
1725 trace_start_error_with_name ("setegid");
1728 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1729 trace_start_error_with_name ("PTRACE");
1731 /* Redirect signals to exception port. */
1732 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1733 trace_start_error_with_name ("PTRACE");
1736 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1738 darwin_pre_ptrace (void)
1740 if (pipe (ptrace_fds
) != 0)
1744 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1747 mark_fd_no_cloexec (ptrace_fds
[0]);
1748 mark_fd_no_cloexec (ptrace_fds
[1]);
1752 darwin_nat_target::ptrace_him (int pid
)
1754 struct inferior
*inf
= current_inferior ();
1756 darwin_attach_pid (inf
);
1758 /* Let's the child run. */
1759 ::close (ptrace_fds
[0]);
1760 ::close (ptrace_fds
[1]);
1762 unmark_fd_no_cloexec (ptrace_fds
[0]);
1763 unmark_fd_no_cloexec (ptrace_fds
[1]);
1765 init_thread_list (inf
);
1767 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1771 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1773 posix_spawnattr_t attr
;
1777 res
= posix_spawnattr_init (&attr
);
1781 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1785 /* Do like execve: replace the image. */
1786 ps_flags
= POSIX_SPAWN_SETEXEC
;
1788 /* Disable ASLR. The constant doesn't look to be available outside the
1789 kernel include files. */
1790 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1791 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1793 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1794 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1797 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1801 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1804 /* Read kernel version, and return TRUE if this host may have System
1805 Integrity Protection (Sierra or later). */
1811 size_t sz
= sizeof (str
);
1814 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1815 if (ret
== 0 && sz
< sizeof (str
))
1817 unsigned long ver
= strtoul (str
, NULL
, 10);
1824 /* A helper for maybe_cache_shell. This copies the shell to the
1825 cache. It will throw an exception on any failure. */
1828 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1830 scoped_fd from_fd
= gdb_open_cloexec (shell
, O_RDONLY
, 0);
1831 if (from_fd
.get () < 0)
1832 error (_("Could not open shell (%s) for reading: %s"),
1833 shell
, safe_strerror (errno
));
1835 std::string new_dir
= ldirname (new_name
.c_str ());
1836 if (!mkdir_recursive (new_dir
.c_str ()))
1837 error (_("Could not make cache directory \"%s\": %s"),
1838 new_dir
.c_str (), safe_strerror (errno
));
1840 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1841 scoped_fd to_fd
= gdb_mkostemp_cloexec (&temp_name
[0]);
1842 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1844 if (to_fd
.get () < 0)
1845 error (_("Could not open temporary file \"%s\" for writing: %s"),
1846 temp_name
.data (), safe_strerror (errno
));
1848 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1849 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1850 error (_("Could not copy shell to cache as \"%s\": %s"),
1851 temp_name
.data (), safe_strerror (errno
));
1853 /* Be sure that the caching is atomic so that we don't get bad
1854 results from multiple copies of gdb running at the same time. */
1855 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1856 error (_("Could not rename shell cache file to \"%s\": %s"),
1857 new_name
.c_str (), safe_strerror (errno
));
1859 unlink_file_on_error
.keep ();
1862 /* If $SHELL is restricted, try to cache a copy. Starting with El
1863 Capitan, macOS introduced System Integrity Protection. Among other
1864 things, this prevents certain executables from being ptrace'd. In
1865 particular, executables in /bin, like most shells, are affected.
1866 To work around this, while preserving command-line glob expansion
1867 and redirections, gdb will cache a copy of the shell. Return true
1868 if all is well -- either the shell is not subject to SIP or it has
1869 been successfully cached. Returns false if something failed. */
1872 maybe_cache_shell ()
1874 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1875 given file is subject to SIP. */
1876 #ifdef SF_RESTRICTED
1878 /* If a check fails we want to revert -- maybe the user deleted the
1879 cache while gdb was running, or something like that. */
1880 copied_shell
= nullptr;
1882 const char *shell
= get_shell ();
1883 if (!IS_ABSOLUTE_PATH (shell
))
1885 warning (_("This version of macOS has System Integrity Protection.\n\
1886 Normally gdb would try to work around this by caching a copy of your shell,\n\
1887 but because your shell (%s) is not an absolute path, this is being skipped."),
1893 if (stat (shell
, &sb
) < 0)
1895 warning (_("This version of macOS has System Integrity Protection.\n\
1896 Normally gdb would try to work around this by caching a copy of your shell,\n\
1897 but because gdb could not stat your shell (%s), this is being skipped.\n\
1898 The error was: %s"),
1899 shell
, safe_strerror (errno
));
1903 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1906 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1907 std::string new_name
= get_standard_cache_dir ();
1908 /* There's no need to insert a directory separator here, because
1909 SHELL is known to be absolute. */
1910 new_name
.append (shell
);
1912 /* Maybe it was cached by some earlier gdb. */
1913 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1917 copy_shell_to_cache (shell
, new_name
);
1919 catch (const gdb_exception_error
&ex
)
1921 warning (_("This version of macOS has System Integrity Protection.\n\
1922 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1923 caching a copy of your shell. However, this failed:\n\
1925 If you correct the problem, gdb will automatically try again the next time\n\
1926 you \"run\". To prevent these attempts, you can use:\n\
1927 set startup-with-shell off"),
1932 printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1933 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1934 caching a copy of your shell. The shell used by \"run\" is now:\n\
1939 /* We need to make sure that the new name has the correct lifetime. */
1940 static std::string saved_shell
= std::move (new_name
);
1941 copied_shell
= saved_shell
.c_str ();
1943 #endif /* SF_RESTRICTED */
1949 darwin_nat_target::create_inferior (const char *exec_file
,
1950 const std::string
&allargs
,
1951 char **env
, int from_tty
)
1953 gdb::optional
<scoped_restore_tmpl
<bool>> restore_startup_with_shell
;
1954 darwin_nat_target
*the_target
= this;
1956 if (startup_with_shell
&& may_have_sip ())
1958 if (!maybe_cache_shell ())
1960 warning (_("startup-with-shell is now temporarily disabled"));
1961 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
1965 /* Do the hard work. */
1966 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1967 [the_target
] (int pid
)
1969 the_target
->ptrace_him (pid
);
1971 darwin_pre_ptrace
, copied_shell
,
1976 /* Set things up such that the next call to darwin_wait will immediately
1977 return a fake stop event for inferior INF.
1979 This assumes that the inferior's thread list has been initialized,
1980 as it will suspend the inferior's first thread. */
1983 darwin_setup_fake_stop_event (struct inferior
*inf
)
1985 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1986 darwin_thread_t
*thread
;
1989 gdb_assert (darwin_inf_fake_stop
== NULL
);
1990 darwin_inf_fake_stop
= inf
;
1992 /* When detecting a fake pending stop event, darwin_wait returns
1993 an event saying that the first thread is in a DARWIN_STOPPED
1994 state. To make that accurate, we need to suspend that thread
1995 as well. Otherwise, we'll try resuming it when resuming the
1996 inferior, and get a warning because the thread's suspend count
1997 is already zero, making the resume request useless. */
1998 thread
= priv
->threads
[0];
1999 kret
= thread_suspend (thread
->gdb_port
);
2000 MACH_CHECK_ERROR (kret
);
2003 /* Attach to process PID, then initialize for debugging it
2004 and wait for the trace-trap that results from attaching. */
2006 darwin_nat_target::attach (const char *args
, int from_tty
)
2009 struct inferior
*inf
;
2011 pid
= parse_pid_to_attach (args
);
2013 if (pid
== getpid ()) /* Trying to masturbate? */
2014 error (_("I refuse to debug myself!"));
2016 target_announce_attach (from_tty
, pid
);
2018 if (pid
== 0 || ::kill (pid
, 0) < 0)
2019 error (_("Can't attach to process %d: %s (%d)"),
2020 pid
, safe_strerror (errno
), errno
);
2022 inf
= current_inferior ();
2023 inferior_appeared (inf
, pid
);
2024 inf
->attach_flag
= 1;
2026 darwin_attach_pid (inf
);
2028 darwin_suspend_inferior (inf
);
2030 init_thread_list (inf
);
2032 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2034 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2036 darwin_setup_fake_stop_event (inf
);
2038 priv
->no_ptrace
= 1;
2041 /* Take a program previously attached to and detaches it.
2042 The program resumes execution and will no longer stop
2043 on signals, etc. We'd better not have left any breakpoints
2044 in the program or it'll die when it hits one. For this
2045 to work, it may be necessary for the process to have been
2046 previously attached. It *might* work if the program was
2047 started via fork. */
2050 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2052 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2056 /* Display message. */
2057 target_announce_detach (from_tty
);
2059 /* If ptrace() is in use, stop the process. */
2060 if (!priv
->no_ptrace
)
2061 stop_inferior (inf
);
2063 kret
= darwin_restore_exception_ports (priv
);
2064 MACH_CHECK_ERROR (kret
);
2066 if (!priv
->no_ptrace
)
2068 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2070 warning (_("Unable to detach from process-id %d: %s (%d)"),
2071 inf
->pid
, safe_strerror (errno
), errno
);
2074 darwin_reply_to_all_pending_messages (inf
);
2076 /* When using ptrace, we have just performed a PT_DETACH, which
2077 resumes the inferior. On the other hand, when we are not using
2078 ptrace, we need to resume its execution ourselves. */
2079 if (priv
->no_ptrace
)
2080 darwin_resume_inferior (inf
);
2086 darwin_nat_target::pid_to_str (ptid_t ptid
)
2088 long tid
= ptid
.tid ();
2091 return string_printf (_("Thread 0x%lx of process %u"),
2094 return normal_pid_to_str (ptid
);
2098 darwin_nat_target::thread_alive (ptid_t ptid
)
2103 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2104 copy it to RDADDR in gdb's address space.
2105 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2106 to ADDR in inferior task's address space.
2107 Return 0 on failure; number of bytes read / written otherwise. */
2110 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2111 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2115 mach_vm_size_t res_length
= 0;
2117 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2118 task
, core_addr_to_string (addr
), pulongest (length
));
2123 mach_vm_size_t count
;
2125 /* According to target.h(to_xfer_partial), one and only one may be
2127 gdb_assert (wraddr
== NULL
);
2129 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2130 (mach_vm_address_t
) rdaddr
, &count
);
2131 if (kret
!= KERN_SUCCESS
)
2134 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2135 core_addr_to_string (addr
), mach_error_string (kret
));
2142 gdb_assert (wraddr
!= NULL
);
2146 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2147 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2148 mach_vm_size_t aligned_length
=
2149 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2150 vm_region_submap_short_info_data_64_t info
;
2151 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2152 natural_t region_depth
= 1000;
2153 mach_vm_address_t region_start
= region_address
;
2154 mach_vm_size_t region_length
;
2155 mach_vm_size_t write_length
;
2157 /* Read page protection. */
2158 kret
= mach_vm_region_recurse
2159 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2160 (vm_region_recurse_info_t
) &info
, &count
);
2162 if (kret
!= KERN_SUCCESS
)
2164 inferior_debug (1, _("darwin_read_write_inferior: "
2165 "mach_vm_region_recurse failed at %s: %s\n"),
2166 core_addr_to_string (region_address
),
2167 mach_error_string (kret
));
2172 (9, _("darwin_read_write_inferior: "
2173 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2174 core_addr_to_string (region_address
),
2175 core_addr_to_string (region_start
),
2176 core_addr_to_string (region_length
));
2178 /* Check for holes in memory. */
2179 if (region_start
> region_address
)
2181 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2182 core_addr_to_string (region_address
),
2183 core_addr_to_string (region_start
),
2184 (unsigned)region_length
);
2188 /* Adjust the length. */
2189 region_length
-= (region_address
- region_start
);
2190 if (region_length
> aligned_length
)
2191 region_length
= aligned_length
;
2193 /* Make the pages RW. */
2194 if (!(info
.protection
& VM_PROT_WRITE
))
2196 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2198 kret
= mach_vm_protect (task
, region_address
, region_length
,
2200 if (kret
!= KERN_SUCCESS
)
2202 prot
|= VM_PROT_COPY
;
2203 kret
= mach_vm_protect (task
, region_address
, region_length
,
2206 if (kret
!= KERN_SUCCESS
)
2208 warning (_("darwin_read_write_inferior: "
2209 "mach_vm_protect failed at %s "
2210 "(len=0x%lx, prot=0x%x): %s"),
2211 core_addr_to_string (region_address
),
2212 (unsigned long) region_length
, (unsigned) prot
,
2213 mach_error_string (kret
));
2218 if (offset
+ length
> region_length
)
2219 write_length
= region_length
- offset
;
2221 write_length
= length
;
2224 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2225 if (kret
!= KERN_SUCCESS
)
2227 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2228 mach_error_string (kret
));
2232 /* Restore page rights. */
2233 if (!(info
.protection
& VM_PROT_WRITE
))
2235 kret
= mach_vm_protect (task
, region_address
, region_length
,
2236 FALSE
, info
.protection
);
2237 if (kret
!= KERN_SUCCESS
)
2239 warning (_("darwin_read_write_inferior: "
2240 "mach_vm_protect restore failed at %s "
2242 core_addr_to_string (region_address
),
2243 (unsigned long) region_length
,
2244 mach_error_string (kret
));
2248 addr
+= write_length
;
2249 wraddr
+= write_length
;
2250 res_length
+= write_length
;
2251 length
-= write_length
;
2257 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2258 to RDADDR (in big endian).
2259 Return 0 on failure; number of bytes read / written otherwise. */
2261 #ifdef TASK_DYLD_INFO_COUNT
2262 /* This is not available in Darwin 9. */
2263 static enum target_xfer_status
2264 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2265 ULONGEST length
, ULONGEST
*xfered_len
)
2267 struct task_dyld_info task_dyld_info
;
2268 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2271 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2272 return TARGET_XFER_EOF
;
2274 kret
= task_info (task
, TASK_DYLD_INFO
,
2275 (task_info_t
) &task_dyld_info
, &count
);
2276 MACH_CHECK_ERROR (kret
);
2277 if (kret
!= KERN_SUCCESS
)
2278 return TARGET_XFER_E_IO
;
2280 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2281 task_dyld_info
.all_image_info_addr
);
2282 *xfered_len
= (ULONGEST
) length
;
2283 return TARGET_XFER_OK
;
2289 enum target_xfer_status
2290 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2291 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2292 ULONGEST offset
, ULONGEST len
,
2293 ULONGEST
*xfered_len
)
2295 struct inferior
*inf
= current_inferior ();
2296 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2299 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2300 core_addr_to_string (offset
), pulongest (len
),
2301 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2306 case TARGET_OBJECT_MEMORY
:
2308 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2309 readbuf
, writebuf
, len
);
2312 return TARGET_XFER_EOF
;
2316 *xfered_len
= (ULONGEST
) l
;
2317 return TARGET_XFER_OK
;
2320 #ifdef TASK_DYLD_INFO_COUNT
2321 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2322 if (writebuf
!= NULL
|| readbuf
== NULL
)
2324 /* Support only read. */
2325 return TARGET_XFER_E_IO
;
2327 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2331 return TARGET_XFER_E_IO
;
2337 set_enable_mach_exceptions (const char *args
, int from_tty
,
2338 struct cmd_list_element
*c
)
2340 if (inferior_ptid
!= null_ptid
)
2342 struct inferior
*inf
= current_inferior ();
2343 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2344 exception_mask_t mask
;
2347 if (enable_mach_exceptions
)
2348 mask
= EXC_MASK_ALL
;
2351 darwin_restore_exception_ports (priv
);
2352 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2354 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2355 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2356 MACH_CHECK_ERROR (kret
);
2361 darwin_nat_target::pid_to_exec_file (int pid
)
2363 static char path
[PATH_MAX
];
2366 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2374 darwin_nat_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
2376 struct inferior
*inf
= current_inferior ();
2377 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2379 mach_port_name_array_t names
;
2380 mach_msg_type_number_t names_count
;
2381 mach_port_type_array_t types
;
2382 mach_msg_type_number_t types_count
;
2385 /* First linear search. */
2386 for (darwin_thread_t
*t
: priv
->threads
)
2388 if (t
->inf_port
== lwp
)
2389 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2392 /* Maybe the port was never extract. Do it now. */
2394 /* First get inferior port names. */
2395 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2397 MACH_CHECK_ERROR (kret
);
2398 if (kret
!= KERN_SUCCESS
)
2401 /* For each name, copy the right in the gdb space and then compare with
2402 our view of the inferior threads. We don't forget to deallocate the
2404 for (int i
= 0; i
< names_count
; i
++)
2406 mach_port_t local_name
;
2407 mach_msg_type_name_t local_type
;
2409 /* We just need to know the corresponding name in gdb name space.
2410 So extract and deallocate the right. */
2411 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2412 MACH_MSG_TYPE_COPY_SEND
,
2413 &local_name
, &local_type
);
2414 if (kret
!= KERN_SUCCESS
)
2416 mach_port_deallocate (gdb_task
, local_name
);
2418 for (darwin_thread_t
*t
: priv
->threads
)
2420 if (t
->gdb_port
== local_name
)
2422 t
->inf_port
= names
[i
];
2423 if (names
[i
] == lwp
)
2429 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2430 names_count
* sizeof (mach_port_t
));
2433 return ptid_t (current_inferior ()->pid
, 0, res
);
2439 darwin_nat_target::supports_multi_process ()
2444 void _initialize_darwin_nat ();
2446 _initialize_darwin_nat ()
2450 gdb_task
= mach_task_self ();
2451 darwin_host_self
= mach_host_self ();
2453 /* Read page size. */
2454 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2455 if (kret
!= KERN_SUCCESS
)
2457 mach_page_size
= 0x1000;
2458 MACH_CHECK_ERROR (kret
);
2461 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2462 (unsigned long) mach_task_self (), getpid ());
2464 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2465 &darwin_debug_flag
, _("\
2466 Set if printing inferior communication debugging statements."), _("\
2467 Show if printing inferior communication debugging statements."), NULL
,
2469 &setdebuglist
, &showdebuglist
);
2471 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2472 &enable_mach_exceptions
, _("\
2473 Set if mach exceptions are caught."), _("\
2474 Show if mach exceptions are caught."), _("\
2475 When this mode is on, all low level exceptions are reported before being\n\
2476 reported by the kernel."),
2477 &set_enable_mach_exceptions
, NULL
,
2478 &setlist
, &showlist
);