1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2021 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
43 #include <sys/ptrace.h>
44 #include <sys/signal.h>
46 #include <sys/types.h>
50 #include <sys/sysctl.h>
53 #include <sys/syscall.h>
56 #include <mach/mach_error.h>
57 #include <mach/mach_vm.h>
58 #include <mach/mach_init.h>
59 #include <mach/vm_map.h>
60 #include <mach/task.h>
61 #include <mach/mach_port.h>
62 #include <mach/thread_act.h>
63 #include <mach/port.h>
65 #include "darwin-nat.h"
66 #include "filenames.h"
67 #include "gdbsupport/filestuff.h"
68 #include "gdbsupport/gdb_unlinker.h"
69 #include "gdbsupport/pathstuff.h"
70 #include "gdbsupport/scoped_fd.h"
71 #include "nat/fork-inferior.h"
74 Darwin kernel is Mach + BSD derived kernel. Note that they share the
75 same memory space and are linked together (ie there is no micro-kernel).
77 Although ptrace(2) is available on Darwin, it is not complete. We have
78 to use Mach calls to read and write memory and to modify registers. We
79 also use Mach to get inferior faults. As we cannot use select(2) or
80 signals with Mach port (the Mach communication channel), signals are
81 reported to gdb as an exception. Furthermore we detect death of the
82 inferior through a Mach notification message. This way we only wait
85 Some Mach documentation is available for Apple xnu source package or
89 #define PTRACE(CMD, PID, ADDR, SIG) \
90 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
92 static void darwin_ptrace_me (void);
94 static void darwin_encode_reply (mig_reply_error_t
*reply
,
95 mach_msg_header_t
*hdr
, integer_t code
);
97 static void darwin_setup_request_notification (struct inferior
*inf
);
98 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
99 static void darwin_setup_exceptions (struct inferior
*inf
);
100 static void darwin_deallocate_threads (struct inferior
*inf
);
102 /* Task identifier of gdb. */
103 static task_t gdb_task
;
105 /* A copy of mach_host_self (). */
106 mach_port_t darwin_host_self
;
108 /* Exception port. */
109 mach_port_t darwin_ex_port
;
111 /* Port set, to wait for answer on all ports. */
112 mach_port_t darwin_port_set
;
115 static vm_size_t mach_page_size
;
117 /* If Set, catch all mach exceptions (before they are converted to signals
119 static bool enable_mach_exceptions
;
121 /* Inferior that should report a fake stop event. */
122 static struct inferior
*darwin_inf_fake_stop
;
124 /* If non-NULL, the shell we actually invoke. See maybe_cache_shell
126 static const char *copied_shell
;
128 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
129 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
131 /* This controls output of inferior debugging. */
132 static unsigned int darwin_debug_flag
= 0;
134 /* Create a __TEXT __info_plist section in the executable so that gdb could
135 be signed. This is required to get an authorization for task_for_pid.
137 Once gdb is built, you must codesign it with any system-trusted signing
138 authority. See taskgated(8) for details. */
139 static const unsigned char info_plist
[]
140 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
141 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
142 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
143 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
144 "<plist version=\"1.0\">\n"
146 " <key>CFBundleIdentifier</key>\n"
147 " <string>org.gnu.gdb</string>\n"
148 " <key>CFBundleName</key>\n"
149 " <string>gdb</string>\n"
150 " <key>CFBundleVersion</key>\n"
151 " <string>1.0</string>\n"
152 " <key>SecTaskAccess</key>\n"
154 " <string>allowed</string>\n"
155 " <string>debug</string>\n"
160 static void inferior_debug (int level
, const char *fmt
, ...)
161 ATTRIBUTE_PRINTF (2, 3);
164 inferior_debug (int level
, const char *fmt
, ...)
168 if (darwin_debug_flag
< level
)
172 printf_unfiltered (_("[%d inferior]: "), getpid ());
173 vprintf_unfiltered (fmt
, ap
);
178 mach_check_error (kern_return_t ret
, const char *file
,
179 unsigned int line
, const char *func
)
181 if (ret
== KERN_SUCCESS
)
184 func
= _("[UNKNOWN]");
186 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
187 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
191 unparse_exception_type (unsigned int i
)
193 static char unknown_exception_buf
[32];
198 return "EXC_BAD_ACCESS";
199 case EXC_BAD_INSTRUCTION
:
200 return "EXC_BAD_INSTRUCTION";
202 return "EXC_ARITHMETIC";
204 return "EXC_EMULATION";
206 return "EXC_SOFTWARE";
208 return "EXC_BREAKPOINT";
210 return "EXC_SYSCALL";
211 case EXC_MACH_SYSCALL
:
212 return "EXC_MACH_SYSCALL";
214 return "EXC_RPC_ALERT";
218 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
219 return unknown_exception_buf
;
223 /* Set errno to zero, and then call ptrace with the given arguments.
224 If inferior debugging traces are on, then also print a debug
227 The returned value is the same as the value returned by ptrace,
228 except in the case where that value is -1 but errno is zero.
229 This case is documented to be a non-error situation, so we
230 return zero in that case. */
233 darwin_ptrace (const char *name
,
234 int request
, int pid
, caddr_t arg3
, int arg4
)
239 ret
= ptrace (request
, pid
, arg3
, arg4
);
240 if (ret
== -1 && errno
== 0)
243 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
244 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
245 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
250 cmp_thread_t (const void *l
, const void *r
)
252 thread_t tl
= *(const thread_t
*)l
;
253 thread_t tr
= *(const thread_t
*)r
;
254 return (int)(tl
- tr
);
258 darwin_nat_target::check_new_threads (inferior
*inf
)
261 thread_array_t thread_list
;
262 unsigned int new_nbr
;
263 unsigned int old_nbr
;
264 unsigned int new_ix
, old_ix
;
265 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
266 std::vector
<darwin_thread_t
*> new_thread_vec
;
268 if (darwin_inf
== nullptr)
271 /* Get list of threads. */
272 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
273 MACH_CHECK_ERROR (kret
);
274 if (kret
!= KERN_SUCCESS
)
279 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
281 old_nbr
= darwin_inf
->threads
.size ();
283 /* Quick check for no changes. */
284 if (old_nbr
== new_nbr
)
288 for (i
= 0; i
< new_nbr
; i
++)
289 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
293 /* Deallocate ports. */
294 for (i
= 0; i
< new_nbr
; i
++)
296 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
297 MACH_CHECK_ERROR (kret
);
300 /* Deallocate the buffer. */
301 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
302 new_nbr
* sizeof (int));
303 MACH_CHECK_ERROR (kret
);
309 /* Full handling: detect new threads, remove dead threads. */
311 new_thread_vec
.reserve (new_nbr
);
313 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
315 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
317 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
318 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
321 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
322 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
324 if (old_id
== new_id
)
326 /* Thread still exist. */
327 new_thread_vec
.push_back (old
);
331 /* Deallocate the port. */
332 kret
= mach_port_deallocate (gdb_task
, new_id
);
333 MACH_CHECK_ERROR (kret
);
337 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
339 /* Ignore dead ports.
340 In some weird cases, we might get dead ports. They should
341 correspond to dead thread so they could safely be ignored. */
345 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
347 /* A thread was created. */
348 darwin_thread_info
*pti
= new darwin_thread_info
;
350 pti
->gdb_port
= new_id
;
351 pti
->msg_state
= DARWIN_RUNNING
;
353 /* Add the new thread. */
354 add_thread_with_info (this, ptid_t (inf
->pid
, 0, new_id
), pti
);
355 new_thread_vec
.push_back (pti
);
359 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
361 /* A thread was removed. */
362 struct thread_info
*thr
363 = find_thread_ptid (this, ptid_t (inf
->pid
, 0, old_id
));
365 kret
= mach_port_deallocate (gdb_task
, old_id
);
366 MACH_CHECK_ERROR (kret
);
370 gdb_assert_not_reached ("unexpected thread case");
373 darwin_inf
->threads
= std::move (new_thread_vec
);
375 /* Deallocate the buffer. */
376 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
377 new_nbr
* sizeof (int));
378 MACH_CHECK_ERROR (kret
);
381 /* Return an inferior by task port. */
382 static struct inferior
*
383 darwin_find_inferior_by_task (task_t port
)
385 for (inferior
*inf
: all_inferiors ())
387 darwin_inferior
*priv
= get_darwin_inferior (inf
);
389 if (priv
!= nullptr && priv
->task
== port
)
395 /* Return an inferior by pid port. */
396 static struct inferior
*
397 darwin_find_inferior_by_pid (int pid
)
399 for (inferior
*inf
: all_inferiors ())
407 /* Return a thread by port. */
408 static darwin_thread_t
*
409 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
411 darwin_inferior
*priv
= get_darwin_inferior (inf
);
414 for (darwin_thread_t
*t
: priv
->threads
)
416 if (t
->gdb_port
== thread
)
423 /* Suspend (ie stop) an inferior at Mach level. */
426 darwin_suspend_inferior (struct inferior
*inf
)
428 darwin_inferior
*priv
= get_darwin_inferior (inf
);
430 if (priv
!= nullptr && !priv
->suspended
)
434 kret
= task_suspend (priv
->task
);
435 MACH_CHECK_ERROR (kret
);
441 /* Resume an inferior at Mach level. */
444 darwin_resume_inferior (struct inferior
*inf
)
446 darwin_inferior
*priv
= get_darwin_inferior (inf
);
448 if (priv
!= nullptr && priv
->suspended
)
452 kret
= task_resume (priv
->task
);
453 MACH_CHECK_ERROR (kret
);
460 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
462 printf_unfiltered (_("message header:\n"));
463 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
464 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
465 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
466 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
467 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
468 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
472 const unsigned char *data
;
473 const unsigned int *ldata
;
477 data
= (unsigned char *)(hdr
+ 1);
478 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
480 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
482 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
483 mach_msg_port_descriptor_t
*desc
=
484 (mach_msg_port_descriptor_t
*)(bod
+ 1);
487 printf_unfiltered (_("body: descriptor_count=%u\n"),
488 bod
->msgh_descriptor_count
);
489 data
+= sizeof (mach_msg_body_t
);
490 size
-= sizeof (mach_msg_body_t
);
491 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
492 switch (desc
[k
].type
)
494 case MACH_MSG_PORT_DESCRIPTOR
:
496 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
497 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
500 printf_unfiltered (_(" descr %d: type=%u\n"),
504 data
+= bod
->msgh_descriptor_count
505 * sizeof (mach_msg_port_descriptor_t
);
506 size
-= bod
->msgh_descriptor_count
507 * sizeof (mach_msg_port_descriptor_t
);
508 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
510 (_("NDR: mig=%02x if=%02x encod=%02x "
511 "int=%02x char=%02x float=%02x\n"),
512 ndr
->mig_vers
, ndr
->if_vers
, ndr
->mig_encoding
,
513 ndr
->int_rep
, ndr
->char_rep
, ndr
->float_rep
);
514 data
+= sizeof (NDR_record_t
);
515 size
-= sizeof (NDR_record_t
);
518 printf_unfiltered (_(" data:"));
519 ldata
= (const unsigned int *)data
;
520 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
521 printf_unfiltered (" %08x", ldata
[i
]);
522 printf_unfiltered (_("\n"));
526 /* Adjust inferior data when a new task was created. */
528 static struct inferior
*
529 darwin_find_new_inferior (task_t task_port
, thread_t thread_port
)
532 struct inferior
*inf
;
536 /* Find the corresponding pid. */
537 kret
= pid_for_task (task_port
, &task_pid
);
538 if (kret
!= KERN_SUCCESS
)
540 MACH_CHECK_ERROR (kret
);
544 /* Find the inferior for this pid. */
545 inf
= darwin_find_inferior_by_pid (task_pid
);
549 darwin_inferior
*priv
= get_darwin_inferior (inf
);
551 /* Deallocate saved exception ports. */
552 darwin_deallocate_exception_ports (priv
);
554 /* No need to remove dead_name notification, but still... */
555 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
556 MACH_NOTIFY_DEAD_NAME
, 0,
558 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
560 if (kret
!= KERN_INVALID_ARGUMENT
)
561 MACH_CHECK_ERROR (kret
);
563 /* Replace old task port. */
564 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
565 MACH_CHECK_ERROR (kret
);
566 priv
->task
= task_port
;
568 darwin_setup_request_notification (inf
);
569 darwin_setup_exceptions (inf
);
574 /* Check data representation. */
577 darwin_check_message_ndr (NDR_record_t
*ndr
)
579 if (ndr
->mig_vers
!= NDR_PROTOCOL_2_0
580 || ndr
->if_vers
!= NDR_PROTOCOL_2_0
581 || ndr
->mig_encoding
!= NDR_record
.mig_encoding
582 || ndr
->int_rep
!= NDR_record
.int_rep
583 || ndr
->char_rep
!= NDR_record
.char_rep
584 || ndr
->float_rep
!= NDR_record
.float_rep
)
589 /* Decode an exception message. */
592 darwin_nat_target::decode_exception_message (mach_msg_header_t
*hdr
,
594 darwin_thread_t
**pthread
)
596 mach_msg_body_t
*bod
= (mach_msg_body_t
*)(hdr
+ 1);
597 mach_msg_port_descriptor_t
*desc
= (mach_msg_port_descriptor_t
*)(bod
+ 1);
600 struct inferior
*inf
;
601 darwin_thread_t
*thread
;
603 thread_t thread_port
;
607 /* Check message destination. */
608 if (hdr
->msgh_local_port
!= darwin_ex_port
)
611 /* Check message header. */
612 if (!(hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
))
615 /* Check descriptors. */
616 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
617 + sizeof (*ndr
) + 2 * sizeof (integer_t
))
618 || bod
->msgh_descriptor_count
!= 2
619 || desc
[0].type
!= MACH_MSG_PORT_DESCRIPTOR
620 || desc
[0].disposition
!= MACH_MSG_TYPE_MOVE_SEND
621 || desc
[1].type
!= MACH_MSG_PORT_DESCRIPTOR
622 || desc
[1].disposition
!= MACH_MSG_TYPE_MOVE_SEND
)
625 /* Check data representation. */
626 ndr
= (NDR_record_t
*)(desc
+ 2);
627 if (darwin_check_message_ndr (ndr
) != 0)
630 /* Ok, the hard work. */
631 data
= (integer_t
*)(ndr
+ 1);
633 task_port
= desc
[1].name
;
634 thread_port
= desc
[0].name
;
636 /* Find process by port. */
637 inf
= darwin_find_inferior_by_task (task_port
);
640 if (inf
== NULL
&& data
[0] == EXC_SOFTWARE
&& data
[1] == 2
641 && data
[2] == EXC_SOFT_SIGNAL
&& data
[3] == SIGTRAP
)
643 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
644 as a new Mach task is created when a process exec. */
645 inf
= darwin_find_new_inferior (task_port
, thread_port
);
650 /* Deallocate task_port, unless it was saved. */
651 kret
= mach_port_deallocate (mach_task_self (), task_port
);
652 MACH_CHECK_ERROR (kret
);
657 /* We got new rights to the task, get rid of it. Do not get rid of
658 thread right, as we will need it to find the thread. */
659 kret
= mach_port_deallocate (mach_task_self (), task_port
);
660 MACH_CHECK_ERROR (kret
);
665 /* Not a known inferior. This could happen if the child fork, as
666 the created process will inherit its exception port.
667 FIXME: should the exception port be restored ? */
668 mig_reply_error_t reply
;
671 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
674 /* Free thread port (we don't know it). */
675 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
676 MACH_CHECK_ERROR (kret
);
678 darwin_encode_reply (&reply
, hdr
, KERN_SUCCESS
);
680 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
681 reply
.Head
.msgh_size
, 0,
682 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
684 MACH_CHECK_ERROR (kret
);
689 /* Find thread by port. */
690 /* Check for new threads. Do it early so that the port in the exception
691 message can be deallocated. */
692 check_new_threads (inf
);
694 /* Free the thread port (as gdb knows the thread, it has already has a right
695 for it, so this just decrement a reference counter). */
696 kret
= mach_port_deallocate (mach_task_self (), thread_port
);
697 MACH_CHECK_ERROR (kret
);
699 thread
= darwin_find_thread (inf
, thread_port
);
704 /* The thread should be running. However we have observed cases where a
705 thread got a SIGTTIN message after being stopped. */
706 gdb_assert (thread
->msg_state
!= DARWIN_MESSAGE
);
708 /* Finish decoding. */
709 thread
->event
.header
= *hdr
;
710 thread
->event
.thread_port
= thread_port
;
711 thread
->event
.task_port
= task_port
;
712 thread
->event
.ex_type
= data
[0];
713 thread
->event
.data_count
= data
[1];
715 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*bod
) + 2 * sizeof (*desc
)
716 + sizeof (*ndr
) + 2 * sizeof (integer_t
)
717 + data
[1] * sizeof (integer_t
)))
719 for (i
= 0; i
< data
[1]; i
++)
720 thread
->event
.ex_data
[i
] = data
[2 + i
];
722 thread
->msg_state
= DARWIN_MESSAGE
;
727 /* Decode dead_name notify message. */
730 darwin_decode_notify_message (mach_msg_header_t
*hdr
, struct inferior
**pinf
)
732 NDR_record_t
*ndr
= (NDR_record_t
*)(hdr
+ 1);
733 integer_t
*data
= (integer_t
*)(ndr
+ 1);
734 struct inferior
*inf
;
737 /* Check message header. */
738 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
741 /* Check descriptors. */
742 if (hdr
->msgh_size
< (sizeof (*hdr
) + sizeof (*ndr
) + sizeof (integer_t
)))
745 /* Check data representation. */
746 if (darwin_check_message_ndr (ndr
) != 0)
751 /* Find process by port. */
752 inf
= darwin_find_inferior_by_task (task_port
);
755 /* Check message destination. */
758 darwin_inferior
*priv
= get_darwin_inferior (inf
);
759 if (hdr
->msgh_local_port
!= priv
->notify_port
)
767 darwin_encode_reply (mig_reply_error_t
*reply
, mach_msg_header_t
*hdr
,
770 mach_msg_header_t
*rh
= &reply
->Head
;
772 rh
->msgh_bits
= MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr
->msgh_bits
), 0);
773 rh
->msgh_remote_port
= hdr
->msgh_remote_port
;
774 rh
->msgh_size
= (mach_msg_size_t
) sizeof (mig_reply_error_t
);
775 rh
->msgh_local_port
= MACH_PORT_NULL
;
776 rh
->msgh_id
= hdr
->msgh_id
+ 100;
778 reply
->NDR
= NDR_record
;
779 reply
->RetCode
= code
;
783 darwin_send_reply (struct inferior
*inf
, darwin_thread_t
*thread
)
786 mig_reply_error_t reply
;
787 darwin_inferior
*priv
= get_darwin_inferior (inf
);
789 darwin_encode_reply (&reply
, &thread
->event
.header
, KERN_SUCCESS
);
791 kret
= mach_msg (&reply
.Head
, MACH_SEND_MSG
| MACH_SEND_INTERRUPT
,
792 reply
.Head
.msgh_size
, 0,
793 MACH_PORT_NULL
, MACH_MSG_TIMEOUT_NONE
,
795 MACH_CHECK_ERROR (kret
);
797 priv
->pending_messages
--;
800 /* Wrapper around the __pthread_kill syscall. We use this instead of the
801 pthread_kill function to be able to send a signal to any kind of thread,
802 including GCD threads. */
805 darwin_pthread_kill (darwin_thread_t
*thread
, int nsignal
)
808 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
;
809 int res
= syscall (SYS___pthread_kill
, thread
->gdb_port
, nsignal
);
815 darwin_resume_thread (struct inferior
*inf
, darwin_thread_t
*thread
,
816 int step
, int nsignal
)
819 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
820 thread
->msg_state
, thread
->gdb_port
, step
, nsignal
);
822 switch (thread
->msg_state
)
825 if (thread
->event
.ex_type
== EXC_SOFTWARE
826 && thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
828 /* Either deliver a new signal or cancel the signal received. */
829 int res
= PTRACE (PT_THUPDATE
, inf
->pid
,
830 (caddr_t
) (uintptr_t) thread
->gdb_port
, nsignal
);
832 inferior_debug (1, _("ptrace THUP: res=%d\n"), res
);
836 /* Note: ptrace is allowed only if the process is stopped.
837 Directly send the signal to the thread. */
838 int res
= darwin_pthread_kill (thread
, nsignal
);
839 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
840 thread
->gdb_port
, nsignal
, res
);
841 thread
->signaled
= 1;
844 /* Set or reset single step. */
845 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
846 thread
->gdb_port
, step
);
847 darwin_set_sstep (thread
->gdb_port
, step
);
848 thread
->single_step
= step
;
850 darwin_send_reply (inf
, thread
);
851 thread
->msg_state
= DARWIN_RUNNING
;
858 kern_return_t kret
= thread_resume (thread
->gdb_port
);
859 MACH_CHECK_ERROR (kret
);
861 thread
->msg_state
= DARWIN_RUNNING
;
866 /* Resume all threads of the inferior. */
869 darwin_resume_inferior_threads (struct inferior
*inf
, int step
, int nsignal
)
871 darwin_inferior
*priv
= get_darwin_inferior (inf
);
874 for (darwin_thread_t
*thread
: priv
->threads
)
875 darwin_resume_thread (inf
, thread
, step
, nsignal
);
878 /* Suspend all threads of INF. */
881 darwin_suspend_inferior_threads (struct inferior
*inf
)
883 darwin_inferior
*priv
= get_darwin_inferior (inf
);
885 for (darwin_thread_t
*thread
: priv
->threads
)
887 switch (thread
->msg_state
)
894 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
895 MACH_CHECK_ERROR (kret
);
896 thread
->msg_state
= DARWIN_STOPPED
;
904 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
909 (2, _("darwin_resume: ptid=%s, step=%d, signal=%d\n"),
910 ptid
.to_string ().c_str (), step
, signal
);
912 if (signal
== GDB_SIGNAL_0
)
915 nsignal
= gdb_signal_to_host (signal
);
917 /* Don't try to single step all threads. */
919 ptid
= inferior_ptid
;
921 /* minus_one_ptid is RESUME_ALL. */
922 if (ptid
== minus_one_ptid
)
924 /* Resume threads. */
925 for (inferior
*inf
: all_inferiors ())
926 darwin_resume_inferior_threads (inf
, step
, nsignal
);
929 for (inferior
*inf
: all_inferiors ())
930 darwin_resume_inferior (inf
);
934 inferior
*inf
= find_inferior_ptid (this, ptid
);
935 long tid
= ptid
.tid ();
937 /* Stop the inferior (should be useless). */
938 darwin_suspend_inferior (inf
);
941 darwin_resume_inferior_threads (inf
, step
, nsignal
);
944 darwin_thread_t
*thread
;
946 /* Suspend threads of the task. */
947 darwin_suspend_inferior_threads (inf
);
949 /* Resume the selected thread. */
950 thread
= darwin_find_thread (inf
, tid
);
952 darwin_resume_thread (inf
, thread
, step
, nsignal
);
955 /* Resume the task. */
956 darwin_resume_inferior (inf
);
961 darwin_nat_target::decode_message (mach_msg_header_t
*hdr
,
962 darwin_thread_t
**pthread
,
964 target_waitstatus
*status
)
966 darwin_thread_t
*thread
;
967 struct inferior
*inf
;
969 /* Exception message. 2401 == 0x961 is exc. */
970 if (hdr
->msgh_id
== 2401)
974 /* Decode message. */
975 res
= decode_exception_message (hdr
, &inf
, &thread
);
979 /* Should not happen... */
981 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
982 /* FIXME: send a failure reply? */
983 status
->set_ignore ();
984 return minus_one_ptid
;
988 status
->set_ignore ();
989 return minus_one_ptid
;
994 darwin_inferior
*priv
= get_darwin_inferior (inf
);
996 priv
->pending_messages
++;
998 thread
->msg_state
= DARWIN_MESSAGE
;
1000 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1002 unparse_exception_type (thread
->event
.ex_type
));
1004 switch (thread
->event
.ex_type
)
1006 case EXC_BAD_ACCESS
:
1007 status
->set_stopped (GDB_EXC_BAD_ACCESS
);
1009 case EXC_BAD_INSTRUCTION
:
1010 status
->set_stopped (GDB_EXC_BAD_INSTRUCTION
);
1012 case EXC_ARITHMETIC
:
1013 status
->set_stopped (GDB_EXC_ARITHMETIC
);
1016 status
->set_stopped (GDB_EXC_EMULATION
);
1019 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1022 (gdb_signal_from_host (thread
->event
.ex_data
[1]));
1023 inferior_debug (5, _(" (signal %d: %s)\n"),
1024 thread
->event
.ex_data
[1],
1025 gdb_signal_to_name (status
->sig ()));
1027 /* If the thread is stopped because it has received a signal
1028 that gdb has just sent, continue. */
1029 if (thread
->signaled
)
1031 thread
->signaled
= 0;
1032 darwin_send_reply (inf
, thread
);
1033 thread
->msg_state
= DARWIN_RUNNING
;
1034 status
->set_ignore ();
1038 status
->set_stopped (GDB_EXC_SOFTWARE
);
1040 case EXC_BREAKPOINT
:
1041 /* Many internal GDB routines expect breakpoints to be reported
1042 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1043 as a spurious signal. */
1044 status
->set_stopped (GDB_SIGNAL_TRAP
);
1047 status
->set_stopped (GDB_SIGNAL_UNKNOWN
);
1051 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1053 else if (hdr
->msgh_id
== 0x48)
1055 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1058 res
= darwin_decode_notify_message (hdr
, &inf
);
1062 /* Should not happen... */
1064 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1071 if (res
< 0 || inf
== NULL
)
1073 status
->set_ignore ();
1074 return minus_one_ptid
;
1079 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1081 if (!priv
->no_ptrace
)
1086 res_pid
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1087 if (res_pid
< 0 || res_pid
!= inf
->pid
)
1089 printf_unfiltered (_("wait4: res=%d: %s\n"),
1090 res_pid
, safe_strerror (errno
));
1091 status
->set_ignore ();
1092 return minus_one_ptid
;
1094 if (WIFEXITED (wstatus
))
1095 status
->set_exited (WEXITSTATUS (wstatus
));
1098 status
->set_signalled
1099 (gdb_signal_from_host (WTERMSIG (wstatus
)));
1102 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1105 /* Looks necessary on Leopard and harmless... */
1106 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1108 return ptid_t (inf
->pid
);
1112 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1113 status
->set_exited (0 /* Don't know. */);
1114 return ptid_t (inf
->pid
, 0, 0);
1119 /* Unknown message. */
1120 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1121 status
->set_ignore ();
1122 return minus_one_ptid
;
1126 darwin_nat_target::cancel_breakpoint (ptid_t ptid
)
1128 /* Arrange for a breakpoint to be hit again later. We will handle
1129 the current event, eventually we will resume this thread, and this
1130 breakpoint will trap again.
1132 If we do not do this, then we run the risk that the user will
1133 delete or disable the breakpoint, but the thread will have already
1136 struct regcache
*regcache
= get_thread_regcache (this, ptid
);
1137 struct gdbarch
*gdbarch
= regcache
->arch ();
1140 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1141 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1143 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1144 (unsigned long) ptid
.tid ());
1146 /* Back up the PC if necessary. */
1147 if (gdbarch_decr_pc_after_break (gdbarch
))
1148 regcache_write_pc (regcache
, pc
);
1156 darwin_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*status
)
1161 mach_msg_header_t hdr
;
1164 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1166 darwin_thread_t
*thread
;
1169 (2, _("darwin_wait: waiting for a message ptid=%s\n"),
1170 ptid
.to_string ().c_str ());
1172 /* Handle fake stop events at first. */
1173 if (darwin_inf_fake_stop
!= NULL
)
1175 inferior
*inf
= darwin_inf_fake_stop
;
1176 darwin_inf_fake_stop
= NULL
;
1178 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1180 status
->set_stopped (GDB_SIGNAL_TRAP
);
1181 thread
= priv
->threads
[0];
1182 thread
->msg_state
= DARWIN_STOPPED
;
1183 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1188 /* set_sigint_trap (); */
1190 /* Wait for a message. */
1191 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1192 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1194 /* clear_sigint_trap (); */
1196 if (kret
== MACH_RCV_INTERRUPTED
)
1198 status
->set_ignore ();
1199 return minus_one_ptid
;
1202 if (kret
!= MACH_MSG_SUCCESS
)
1204 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1205 status
->set_spurious ();
1206 return minus_one_ptid
;
1209 /* Debug: display message. */
1210 if (darwin_debug_flag
> 10)
1211 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1214 res
= decode_message (hdr
, &thread
, &inf
, status
);
1215 if (res
== minus_one_ptid
)
1218 /* Early return in case an inferior has exited. */
1222 while (status
->kind () == TARGET_WAITKIND_IGNORE
);
1224 /* Stop all tasks. */
1225 for (inferior
*inf
: all_inferiors (this))
1227 darwin_suspend_inferior (inf
);
1228 check_new_threads (inf
);
1231 /* Read pending messages. */
1234 struct target_waitstatus status2
;
1237 kret
= mach_msg (&msgin
.hdr
,
1238 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1239 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1241 if (kret
== MACH_RCV_TIMED_OUT
)
1243 if (kret
!= MACH_MSG_SUCCESS
)
1246 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1250 /* Debug: display message. */
1251 if (darwin_debug_flag
> 10)
1252 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1255 ptid2
= decode_message (hdr
, &thread
, &inf
, &status2
);
1257 if (inf
!= NULL
&& thread
!= NULL
1258 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1260 if (thread
->single_step
1261 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1263 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1264 darwin_send_reply (inf
, thread
);
1265 thread
->msg_state
= DARWIN_RUNNING
;
1269 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1273 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1279 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1280 target_wait_flags options
)
1282 return wait_1 (ptid
, status
);
1286 darwin_nat_target::interrupt ()
1288 struct inferior
*inf
= current_inferior ();
1289 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1291 /* FIXME: handle in no_ptrace mode. */
1292 gdb_assert (!priv
->no_ptrace
);
1293 ::kill (inf
->pid
, SIGINT
);
1296 /* Deallocate threads port and vector. */
1299 darwin_deallocate_threads (struct inferior
*inf
)
1301 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1303 for (darwin_thread_t
*t
: priv
->threads
)
1305 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1306 MACH_CHECK_ERROR (kret
);
1309 priv
->threads
.clear ();
1313 darwin_nat_target::mourn_inferior ()
1315 struct inferior
*inf
= current_inferior ();
1316 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1320 /* Deallocate threads. */
1321 darwin_deallocate_threads (inf
);
1323 /* Remove notify_port from darwin_port_set. */
1324 kret
= mach_port_move_member (gdb_task
,
1325 priv
->notify_port
, MACH_PORT_NULL
);
1326 MACH_CHECK_ERROR (kret
);
1328 /* Remove task port dead_name notification. */
1329 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1330 MACH_NOTIFY_DEAD_NAME
, 0,
1332 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1334 /* This can fail if the task is dead. */
1335 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1336 priv
->task
, prev
, priv
->notify_port
);
1338 if (kret
== KERN_SUCCESS
)
1340 kret
= mach_port_deallocate (gdb_task
, prev
);
1341 MACH_CHECK_ERROR (kret
);
1344 /* Destroy notify_port. */
1345 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1346 MACH_CHECK_ERROR (kret
);
1348 /* Deallocate saved exception ports. */
1349 darwin_deallocate_exception_ports (priv
);
1351 /* Deallocate task port. */
1352 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1353 MACH_CHECK_ERROR (kret
);
1357 inf_child_target::mourn_inferior ();
1361 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1363 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1365 for (darwin_thread_t
*t
: priv
->threads
)
1367 if (t
->msg_state
== DARWIN_MESSAGE
)
1368 darwin_resume_thread (inf
, t
, 0, 0);
1373 darwin_nat_target::stop_inferior (inferior
*inf
)
1375 struct target_waitstatus wstatus
;
1378 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1380 gdb_assert (inf
!= NULL
);
1382 darwin_suspend_inferior (inf
);
1384 darwin_reply_to_all_pending_messages (inf
);
1386 if (priv
->no_ptrace
)
1389 res
= ::kill (inf
->pid
, SIGSTOP
);
1391 warning (_("cannot kill: %s"), safe_strerror (errno
));
1393 /* Wait until the process is really stopped. */
1396 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1397 if (wstatus
.kind () == TARGET_WAITKIND_STOPPED
1398 && wstatus
.sig () == GDB_SIGNAL_STOP
)
1403 static kern_return_t
1404 darwin_save_exception_ports (darwin_inferior
*inf
)
1408 inf
->exception_info
.count
=
1409 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1411 kret
= task_get_exception_ports
1412 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1413 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1414 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1418 static kern_return_t
1419 darwin_restore_exception_ports (darwin_inferior
*inf
)
1424 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1426 kret
= task_set_exception_ports
1427 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1428 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1429 if (kret
!= KERN_SUCCESS
)
1433 return KERN_SUCCESS
;
1436 /* Deallocate saved exception ports. */
1439 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1444 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1446 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1447 MACH_CHECK_ERROR (kret
);
1449 inf
->exception_info
.count
= 0;
1453 darwin_setup_exceptions (struct inferior
*inf
)
1455 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1457 exception_mask_t mask
;
1459 kret
= darwin_save_exception_ports (priv
);
1460 if (kret
!= KERN_SUCCESS
)
1461 error (_("Unable to save exception ports, task_get_exception_ports"
1465 /* Set exception port. */
1466 if (enable_mach_exceptions
)
1467 mask
= EXC_MASK_ALL
;
1469 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1470 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1471 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1472 if (kret
!= KERN_SUCCESS
)
1473 error (_("Unable to set exception ports, task_set_exception_ports"
1479 darwin_nat_target::kill ()
1481 struct inferior
*inf
= current_inferior ();
1482 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1483 struct target_waitstatus wstatus
;
1488 if (inferior_ptid
== null_ptid
)
1491 gdb_assert (inf
!= NULL
);
1493 kret
= darwin_restore_exception_ports (priv
);
1494 MACH_CHECK_ERROR (kret
);
1496 darwin_reply_to_all_pending_messages (inf
);
1498 res
= ::kill (inf
->pid
, 9);
1502 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1503 does not work as expected.
1504 When the kill function is called, the SIGKILL signal is received
1505 by gdb whereas it should have been received by the kernel since
1506 the exception ports have been restored.
1507 This behavior is not the expected one thus gdb does not reply to
1508 the received SIGKILL message. This situation leads to a "busy"
1509 resource from the kernel point of view and the inferior is never
1510 released, causing it to remain as a zombie process, even after
1512 To work around this, we mark all the threads of the inferior as
1513 signaled thus darwin_decode_message function knows that the kill
1514 signal was sent by gdb and will take the appropriate action
1515 (cancel signal and reply to the signal message). */
1516 for (darwin_thread_t
*thread
: priv
->threads
)
1517 thread
->signaled
= 1;
1519 darwin_resume_inferior (inf
);
1521 ptid
= wait_1 (ptid_t (inf
->pid
), &wstatus
);
1523 else if (errno
!= ESRCH
)
1524 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1525 inf
->pid
, safe_strerror (errno
));
1527 target_mourn_inferior (ptid_t (inf
->pid
));
1531 darwin_setup_request_notification (struct inferior
*inf
)
1533 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1535 mach_port_t prev_not
;
1537 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1538 MACH_NOTIFY_DEAD_NAME
, 0,
1540 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1542 if (kret
!= KERN_SUCCESS
)
1543 error (_("Termination notification request failed, "
1544 "mach_port_request_notification\n"
1547 if (prev_not
!= MACH_PORT_NULL
)
1549 /* This is unexpected, as there should not be any previously
1550 registered notification request. But this is not a fatal
1551 issue, so just emit a warning. */
1553 A task termination request was registered before the debugger registered\n\
1554 its own. This is unexpected, but should otherwise not have any actual\n\
1555 impact on the debugging session."));
1560 darwin_attach_pid (struct inferior
*inf
)
1564 darwin_inferior
*priv
= new darwin_inferior
;
1565 inf
->priv
.reset (priv
);
1569 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1570 if (kret
!= KERN_SUCCESS
)
1574 if (!inf
->attach_flag
)
1577 waitpid (inf
->pid
, &status
, 0);
1581 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1582 " (please check gdb is codesigned - see taskgated(8))"),
1583 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1586 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1587 priv
->task
, inf
->pid
);
1589 if (darwin_ex_port
== MACH_PORT_NULL
)
1591 /* Create a port to get exceptions. */
1592 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1594 if (kret
!= KERN_SUCCESS
)
1595 error (_("Unable to create exception port, mach_port_allocate "
1599 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1601 MACH_MSG_TYPE_MAKE_SEND
);
1602 if (kret
!= KERN_SUCCESS
)
1603 error (_("Unable to create exception port, mach_port_insert_right "
1607 /* Create a port set and put ex_port in it. */
1608 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1610 if (kret
!= KERN_SUCCESS
)
1611 error (_("Unable to create port set, mach_port_allocate "
1615 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1617 if (kret
!= KERN_SUCCESS
)
1618 error (_("Unable to move exception port into new port set, "
1619 "mach_port_move_member\n"
1624 /* Create a port to be notified when the child task terminates. */
1625 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1626 &priv
->notify_port
);
1627 if (kret
!= KERN_SUCCESS
)
1628 error (_("Unable to create notification port, mach_port_allocate "
1632 kret
= mach_port_move_member (gdb_task
,
1633 priv
->notify_port
, darwin_port_set
);
1634 if (kret
!= KERN_SUCCESS
)
1635 error (_("Unable to move notification port into new port set, "
1636 "mach_port_move_member\n"
1640 darwin_setup_request_notification (inf
);
1642 darwin_setup_exceptions (inf
);
1644 catch (const gdb_exception
&ex
)
1646 exit_inferior (inf
);
1647 switch_to_no_thread ();
1652 target_ops
*darwin_ops
= get_native_target ();
1653 if (!inf
->target_is_pushed (darwin_ops
))
1654 inf
->push_target (darwin_ops
);
1657 /* Get the thread_info object corresponding to this darwin_thread_info. */
1659 static struct thread_info
*
1660 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1662 for (struct thread_info
*it
: all_threads ())
1664 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1666 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1670 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1674 darwin_nat_target::init_thread_list (inferior
*inf
)
1676 check_new_threads (inf
);
1678 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1680 gdb_assert (!priv
->threads
.empty ());
1682 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1683 struct thread_info
*first_thread
1684 = thread_info_from_private_thread_info (first_pti
);
1686 switch_to_thread (first_thread
);
1689 /* The child must synchronize with gdb: gdb must set the exception port
1690 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1691 FIXME: is there a lighter way ? */
1692 static int ptrace_fds
[2];
1695 darwin_ptrace_me (void)
1700 /* Close write end point. */
1701 if (close (ptrace_fds
[1]) < 0)
1702 trace_start_error_with_name ("close");
1704 /* Wait until gdb is ready. */
1705 res
= read (ptrace_fds
[0], &c
, 1);
1707 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1709 if (close (ptrace_fds
[0]) < 0)
1710 trace_start_error_with_name ("close");
1712 /* Get rid of privileges. */
1713 if (setegid (getgid ()) < 0)
1714 trace_start_error_with_name ("setegid");
1717 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1718 trace_start_error_with_name ("PTRACE");
1720 /* Redirect signals to exception port. */
1721 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1722 trace_start_error_with_name ("PTRACE");
1725 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1727 darwin_pre_ptrace (void)
1729 if (pipe (ptrace_fds
) != 0)
1733 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1736 mark_fd_no_cloexec (ptrace_fds
[0]);
1737 mark_fd_no_cloexec (ptrace_fds
[1]);
1741 darwin_nat_target::ptrace_him (int pid
)
1743 struct inferior
*inf
= current_inferior ();
1745 darwin_attach_pid (inf
);
1747 /* Let's the child run. */
1748 ::close (ptrace_fds
[0]);
1749 ::close (ptrace_fds
[1]);
1751 unmark_fd_no_cloexec (ptrace_fds
[0]);
1752 unmark_fd_no_cloexec (ptrace_fds
[1]);
1754 init_thread_list (inf
);
1756 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1760 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1762 posix_spawnattr_t attr
;
1766 res
= posix_spawnattr_init (&attr
);
1770 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1774 /* Do like execve: replace the image. */
1775 ps_flags
= POSIX_SPAWN_SETEXEC
;
1777 /* Disable ASLR. The constant doesn't look to be available outside the
1778 kernel include files. */
1779 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1780 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1782 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1783 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1786 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1790 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1793 /* Read kernel version, and return TRUE if this host may have System
1794 Integrity Protection (Sierra or later). */
1800 size_t sz
= sizeof (str
);
1803 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1804 if (ret
== 0 && sz
< sizeof (str
))
1806 unsigned long ver
= strtoul (str
, NULL
, 10);
1813 /* A helper for maybe_cache_shell. This copies the shell to the
1814 cache. It will throw an exception on any failure. */
1817 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1819 scoped_fd from_fd
= gdb_open_cloexec (shell
, O_RDONLY
, 0);
1820 if (from_fd
.get () < 0)
1821 error (_("Could not open shell (%s) for reading: %s"),
1822 shell
, safe_strerror (errno
));
1824 std::string new_dir
= ldirname (new_name
.c_str ());
1825 if (!mkdir_recursive (new_dir
.c_str ()))
1826 error (_("Could not make cache directory \"%s\": %s"),
1827 new_dir
.c_str (), safe_strerror (errno
));
1829 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1830 scoped_fd to_fd
= gdb_mkostemp_cloexec (&temp_name
[0]);
1831 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1833 if (to_fd
.get () < 0)
1834 error (_("Could not open temporary file \"%s\" for writing: %s"),
1835 temp_name
.data (), safe_strerror (errno
));
1837 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1838 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1839 error (_("Could not copy shell to cache as \"%s\": %s"),
1840 temp_name
.data (), safe_strerror (errno
));
1842 /* Be sure that the caching is atomic so that we don't get bad
1843 results from multiple copies of gdb running at the same time. */
1844 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1845 error (_("Could not rename shell cache file to \"%s\": %s"),
1846 new_name
.c_str (), safe_strerror (errno
));
1848 unlink_file_on_error
.keep ();
1851 /* If $SHELL is restricted, try to cache a copy. Starting with El
1852 Capitan, macOS introduced System Integrity Protection. Among other
1853 things, this prevents certain executables from being ptrace'd. In
1854 particular, executables in /bin, like most shells, are affected.
1855 To work around this, while preserving command-line glob expansion
1856 and redirections, gdb will cache a copy of the shell. Return true
1857 if all is well -- either the shell is not subject to SIP or it has
1858 been successfully cached. Returns false if something failed. */
1861 maybe_cache_shell ()
1863 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1864 given file is subject to SIP. */
1865 #ifdef SF_RESTRICTED
1867 /* If a check fails we want to revert -- maybe the user deleted the
1868 cache while gdb was running, or something like that. */
1869 copied_shell
= nullptr;
1871 const char *shell
= get_shell ();
1872 if (!IS_ABSOLUTE_PATH (shell
))
1874 warning (_("This version of macOS has System Integrity Protection.\n\
1875 Normally gdb would try to work around this by caching a copy of your shell,\n\
1876 but because your shell (%s) is not an absolute path, this is being skipped."),
1882 if (stat (shell
, &sb
) < 0)
1884 warning (_("This version of macOS has System Integrity Protection.\n\
1885 Normally gdb would try to work around this by caching a copy of your shell,\n\
1886 but because gdb could not stat your shell (%s), this is being skipped.\n\
1887 The error was: %s"),
1888 shell
, safe_strerror (errno
));
1892 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1895 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1896 std::string new_name
= get_standard_cache_dir ();
1897 /* There's no need to insert a directory separator here, because
1898 SHELL is known to be absolute. */
1899 new_name
.append (shell
);
1901 /* Maybe it was cached by some earlier gdb. */
1902 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1906 copy_shell_to_cache (shell
, new_name
);
1908 catch (const gdb_exception_error
&ex
)
1910 warning (_("This version of macOS has System Integrity Protection.\n\
1911 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1912 caching a copy of your shell. However, this failed:\n\
1914 If you correct the problem, gdb will automatically try again the next time\n\
1915 you \"run\". To prevent these attempts, you can use:\n\
1916 set startup-with-shell off"),
1921 printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1922 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1923 caching a copy of your shell. The shell used by \"run\" is now:\n\
1928 /* We need to make sure that the new name has the correct lifetime. */
1929 static std::string saved_shell
= std::move (new_name
);
1930 copied_shell
= saved_shell
.c_str ();
1932 #endif /* SF_RESTRICTED */
1938 darwin_nat_target::create_inferior (const char *exec_file
,
1939 const std::string
&allargs
,
1940 char **env
, int from_tty
)
1942 gdb::optional
<scoped_restore_tmpl
<bool>> restore_startup_with_shell
;
1943 darwin_nat_target
*the_target
= this;
1945 if (startup_with_shell
&& may_have_sip ())
1947 if (!maybe_cache_shell ())
1949 warning (_("startup-with-shell is now temporarily disabled"));
1950 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
1954 /* Do the hard work. */
1955 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1956 [the_target
] (int pid
)
1958 the_target
->ptrace_him (pid
);
1960 darwin_pre_ptrace
, copied_shell
,
1965 /* Set things up such that the next call to darwin_wait will immediately
1966 return a fake stop event for inferior INF.
1968 This assumes that the inferior's thread list has been initialized,
1969 as it will suspend the inferior's first thread. */
1972 darwin_setup_fake_stop_event (struct inferior
*inf
)
1974 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1975 darwin_thread_t
*thread
;
1978 gdb_assert (darwin_inf_fake_stop
== NULL
);
1979 darwin_inf_fake_stop
= inf
;
1981 /* When detecting a fake pending stop event, darwin_wait returns
1982 an event saying that the first thread is in a DARWIN_STOPPED
1983 state. To make that accurate, we need to suspend that thread
1984 as well. Otherwise, we'll try resuming it when resuming the
1985 inferior, and get a warning because the thread's suspend count
1986 is already zero, making the resume request useless. */
1987 thread
= priv
->threads
[0];
1988 kret
= thread_suspend (thread
->gdb_port
);
1989 MACH_CHECK_ERROR (kret
);
1992 /* Attach to process PID, then initialize for debugging it
1993 and wait for the trace-trap that results from attaching. */
1995 darwin_nat_target::attach (const char *args
, int from_tty
)
1998 struct inferior
*inf
;
2000 pid
= parse_pid_to_attach (args
);
2002 if (pid
== getpid ()) /* Trying to masturbate? */
2003 error (_("I refuse to debug myself!"));
2007 const char *exec_file
= get_exec_file (0);
2010 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
2011 target_pid_to_str (ptid_t (pid
)).c_str ());
2013 printf_unfiltered (_("Attaching to %s\n"),
2014 target_pid_to_str (ptid_t (pid
)).c_str ());
2017 if (pid
== 0 || ::kill (pid
, 0) < 0)
2018 error (_("Can't attach to process %d: %s (%d)"),
2019 pid
, safe_strerror (errno
), errno
);
2021 inf
= current_inferior ();
2022 inferior_appeared (inf
, pid
);
2023 inf
->attach_flag
= 1;
2025 darwin_attach_pid (inf
);
2027 darwin_suspend_inferior (inf
);
2029 init_thread_list (inf
);
2031 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2033 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2035 darwin_setup_fake_stop_event (inf
);
2037 priv
->no_ptrace
= 1;
2040 /* Take a program previously attached to and detaches it.
2041 The program resumes execution and will no longer stop
2042 on signals, etc. We'd better not have left any breakpoints
2043 in the program or it'll die when it hits one. For this
2044 to work, it may be necessary for the process to have been
2045 previously attached. It *might* work if the program was
2046 started via fork. */
2049 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2051 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2055 /* Display message. */
2056 target_announce_detach (from_tty
);
2058 /* If ptrace() is in use, stop the process. */
2059 if (!priv
->no_ptrace
)
2060 stop_inferior (inf
);
2062 kret
= darwin_restore_exception_ports (priv
);
2063 MACH_CHECK_ERROR (kret
);
2065 if (!priv
->no_ptrace
)
2067 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2069 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2070 inf
->pid
, safe_strerror (errno
), errno
);
2073 darwin_reply_to_all_pending_messages (inf
);
2075 /* When using ptrace, we have just performed a PT_DETACH, which
2076 resumes the inferior. On the other hand, when we are not using
2077 ptrace, we need to resume its execution ourselves. */
2078 if (priv
->no_ptrace
)
2079 darwin_resume_inferior (inf
);
2085 darwin_nat_target::pid_to_str (ptid_t ptid
)
2087 long tid
= ptid
.tid ();
2090 return string_printf (_("Thread 0x%lx of process %u"),
2093 return normal_pid_to_str (ptid
);
2097 darwin_nat_target::thread_alive (ptid_t ptid
)
2102 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2103 copy it to RDADDR in gdb's address space.
2104 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2105 to ADDR in inferior task's address space.
2106 Return 0 on failure; number of bytes read / written otherwise. */
2109 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2110 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2114 mach_vm_size_t res_length
= 0;
2116 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2117 task
, core_addr_to_string (addr
), pulongest (length
));
2122 mach_vm_size_t count
;
2124 /* According to target.h(to_xfer_partial), one and only one may be
2126 gdb_assert (wraddr
== NULL
);
2128 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2129 (mach_vm_address_t
) rdaddr
, &count
);
2130 if (kret
!= KERN_SUCCESS
)
2133 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2134 core_addr_to_string (addr
), mach_error_string (kret
));
2141 gdb_assert (wraddr
!= NULL
);
2145 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2146 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2147 mach_vm_size_t aligned_length
=
2148 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2149 vm_region_submap_short_info_data_64_t info
;
2150 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2151 natural_t region_depth
= 1000;
2152 mach_vm_address_t region_start
= region_address
;
2153 mach_vm_size_t region_length
;
2154 mach_vm_size_t write_length
;
2156 /* Read page protection. */
2157 kret
= mach_vm_region_recurse
2158 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2159 (vm_region_recurse_info_t
) &info
, &count
);
2161 if (kret
!= KERN_SUCCESS
)
2163 inferior_debug (1, _("darwin_read_write_inferior: "
2164 "mach_vm_region_recurse failed at %s: %s\n"),
2165 core_addr_to_string (region_address
),
2166 mach_error_string (kret
));
2171 (9, _("darwin_read_write_inferior: "
2172 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2173 core_addr_to_string (region_address
),
2174 core_addr_to_string (region_start
),
2175 core_addr_to_string (region_length
));
2177 /* Check for holes in memory. */
2178 if (region_start
> region_address
)
2180 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2181 core_addr_to_string (region_address
),
2182 core_addr_to_string (region_start
),
2183 (unsigned)region_length
);
2187 /* Adjust the length. */
2188 region_length
-= (region_address
- region_start
);
2189 if (region_length
> aligned_length
)
2190 region_length
= aligned_length
;
2192 /* Make the pages RW. */
2193 if (!(info
.protection
& VM_PROT_WRITE
))
2195 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2197 kret
= mach_vm_protect (task
, region_address
, region_length
,
2199 if (kret
!= KERN_SUCCESS
)
2201 prot
|= VM_PROT_COPY
;
2202 kret
= mach_vm_protect (task
, region_address
, region_length
,
2205 if (kret
!= KERN_SUCCESS
)
2207 warning (_("darwin_read_write_inferior: "
2208 "mach_vm_protect failed at %s "
2209 "(len=0x%lx, prot=0x%x): %s"),
2210 core_addr_to_string (region_address
),
2211 (unsigned long) region_length
, (unsigned) prot
,
2212 mach_error_string (kret
));
2217 if (offset
+ length
> region_length
)
2218 write_length
= region_length
- offset
;
2220 write_length
= length
;
2223 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2224 if (kret
!= KERN_SUCCESS
)
2226 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2227 mach_error_string (kret
));
2231 /* Restore page rights. */
2232 if (!(info
.protection
& VM_PROT_WRITE
))
2234 kret
= mach_vm_protect (task
, region_address
, region_length
,
2235 FALSE
, info
.protection
);
2236 if (kret
!= KERN_SUCCESS
)
2238 warning (_("darwin_read_write_inferior: "
2239 "mach_vm_protect restore failed at %s "
2241 core_addr_to_string (region_address
),
2242 (unsigned long) region_length
,
2243 mach_error_string (kret
));
2247 addr
+= write_length
;
2248 wraddr
+= write_length
;
2249 res_length
+= write_length
;
2250 length
-= write_length
;
2256 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2257 to RDADDR (in big endian).
2258 Return 0 on failure; number of bytes read / written otherwise. */
2260 #ifdef TASK_DYLD_INFO_COUNT
2261 /* This is not available in Darwin 9. */
2262 static enum target_xfer_status
2263 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2264 ULONGEST length
, ULONGEST
*xfered_len
)
2266 struct task_dyld_info task_dyld_info
;
2267 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2270 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2271 return TARGET_XFER_EOF
;
2273 kret
= task_info (task
, TASK_DYLD_INFO
,
2274 (task_info_t
) &task_dyld_info
, &count
);
2275 MACH_CHECK_ERROR (kret
);
2276 if (kret
!= KERN_SUCCESS
)
2277 return TARGET_XFER_E_IO
;
2279 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2280 task_dyld_info
.all_image_info_addr
);
2281 *xfered_len
= (ULONGEST
) length
;
2282 return TARGET_XFER_OK
;
2288 enum target_xfer_status
2289 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2290 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2291 ULONGEST offset
, ULONGEST len
,
2292 ULONGEST
*xfered_len
)
2294 struct inferior
*inf
= current_inferior ();
2295 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2298 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2299 core_addr_to_string (offset
), pulongest (len
),
2300 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2305 case TARGET_OBJECT_MEMORY
:
2307 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2308 readbuf
, writebuf
, len
);
2311 return TARGET_XFER_EOF
;
2315 *xfered_len
= (ULONGEST
) l
;
2316 return TARGET_XFER_OK
;
2319 #ifdef TASK_DYLD_INFO_COUNT
2320 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2321 if (writebuf
!= NULL
|| readbuf
== NULL
)
2323 /* Support only read. */
2324 return TARGET_XFER_E_IO
;
2326 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2330 return TARGET_XFER_E_IO
;
2336 set_enable_mach_exceptions (const char *args
, int from_tty
,
2337 struct cmd_list_element
*c
)
2339 if (inferior_ptid
!= null_ptid
)
2341 struct inferior
*inf
= current_inferior ();
2342 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2343 exception_mask_t mask
;
2346 if (enable_mach_exceptions
)
2347 mask
= EXC_MASK_ALL
;
2350 darwin_restore_exception_ports (priv
);
2351 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2353 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2354 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2355 MACH_CHECK_ERROR (kret
);
2360 darwin_nat_target::pid_to_exec_file (int pid
)
2362 static char path
[PATH_MAX
];
2365 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2373 darwin_nat_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
2375 struct inferior
*inf
= current_inferior ();
2376 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2378 mach_port_name_array_t names
;
2379 mach_msg_type_number_t names_count
;
2380 mach_port_type_array_t types
;
2381 mach_msg_type_number_t types_count
;
2384 /* First linear search. */
2385 for (darwin_thread_t
*t
: priv
->threads
)
2387 if (t
->inf_port
== lwp
)
2388 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2391 /* Maybe the port was never extract. Do it now. */
2393 /* First get inferior port names. */
2394 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2396 MACH_CHECK_ERROR (kret
);
2397 if (kret
!= KERN_SUCCESS
)
2400 /* For each name, copy the right in the gdb space and then compare with
2401 our view of the inferior threads. We don't forget to deallocate the
2403 for (int i
= 0; i
< names_count
; i
++)
2405 mach_port_t local_name
;
2406 mach_msg_type_name_t local_type
;
2408 /* We just need to know the corresponding name in gdb name space.
2409 So extract and deallocate the right. */
2410 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2411 MACH_MSG_TYPE_COPY_SEND
,
2412 &local_name
, &local_type
);
2413 if (kret
!= KERN_SUCCESS
)
2415 mach_port_deallocate (gdb_task
, local_name
);
2417 for (darwin_thread_t
*t
: priv
->threads
)
2419 if (t
->gdb_port
== local_name
)
2421 t
->inf_port
= names
[i
];
2422 if (names
[i
] == lwp
)
2428 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2429 names_count
* sizeof (mach_port_t
));
2432 return ptid_t (current_inferior ()->pid
, 0, res
);
2438 darwin_nat_target::supports_multi_process ()
2443 void _initialize_darwin_nat ();
2445 _initialize_darwin_nat ()
2449 gdb_task
= mach_task_self ();
2450 darwin_host_self
= mach_host_self ();
2452 /* Read page size. */
2453 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2454 if (kret
!= KERN_SUCCESS
)
2456 mach_page_size
= 0x1000;
2457 MACH_CHECK_ERROR (kret
);
2460 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2461 (unsigned long) mach_task_self (), getpid ());
2463 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2464 &darwin_debug_flag
, _("\
2465 Set if printing inferior communication debugging statements."), _("\
2466 Show if printing inferior communication debugging statements."), NULL
,
2468 &setdebuglist
, &showdebuglist
);
2470 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2471 &enable_mach_exceptions
, _("\
2472 Set if mach exceptions are caught."), _("\
2473 Show if mach exceptions are caught."), _("\
2474 When this mode is on, all low level exceptions are reported before being\n\
2475 reported by the kernel."),
2476 &set_enable_mach_exceptions
, NULL
,
2477 &setlist
, &showlist
);