1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2020 Free Software Foundation, Inc.
4 Contributed by AdaCore.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "gdbthread.h"
32 #include "event-top.h"
35 #include "inf-child.h"
37 #include "arch-utils.h"
39 #include "bfd/mach-o.h"
43 #include <sys/ptrace.h>
44 #include <sys/signal.h>
46 #include <sys/types.h>
50 #include <sys/sysctl.h>
53 #include <sys/syscall.h>
56 #include <mach/mach_error.h>
57 #include <mach/mach_vm.h>
58 #include <mach/mach_init.h>
59 #include <mach/vm_map.h>
60 #include <mach/task.h>
61 #include <mach/mach_port.h>
62 #include <mach/thread_act.h>
63 #include <mach/port.h>
65 #include "darwin-nat.h"
66 #include "filenames.h"
67 #include "gdbsupport/filestuff.h"
68 #include "gdbsupport/gdb_unlinker.h"
69 #include "gdbsupport/pathstuff.h"
70 #include "gdbsupport/scoped_fd.h"
71 #include "nat/fork-inferior.h"
74 Darwin kernel is Mach + BSD derived kernel. Note that they share the
75 same memory space and are linked together (ie there is no micro-kernel).
77 Although ptrace(2) is available on Darwin, it is not complete. We have
78 to use Mach calls to read and write memory and to modify registers. We
79 also use Mach to get inferior faults. As we cannot use select(2) or
80 signals with Mach port (the Mach communication channel), signals are
81 reported to gdb as an exception. Furthermore we detect death of the
82 inferior through a Mach notification message. This way we only wait
85 Some Mach documentation is available for Apple xnu source package or
89 #define PTRACE(CMD, PID, ADDR, SIG) \
90 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
92 static void darwin_ptrace_me (void);
94 static void darwin_encode_reply (mig_reply_error_t
*reply
,
95 mach_msg_header_t
*hdr
, integer_t code
);
97 static void darwin_setup_request_notification (struct inferior
*inf
);
98 static void darwin_deallocate_exception_ports (darwin_inferior
*inf
);
99 static void darwin_setup_exceptions (struct inferior
*inf
);
100 static void darwin_deallocate_threads (struct inferior
*inf
);
102 /* Task identifier of gdb. */
103 static task_t gdb_task
;
105 /* A copy of mach_host_self (). */
106 mach_port_t darwin_host_self
;
108 /* Exception port. */
109 mach_port_t darwin_ex_port
;
111 /* Port set, to wait for answer on all ports. */
112 mach_port_t darwin_port_set
;
115 static vm_size_t mach_page_size
;
117 /* If Set, catch all mach exceptions (before they are converted to signals
119 static bool enable_mach_exceptions
;
121 /* Inferior that should report a fake stop event. */
122 static struct inferior
*darwin_inf_fake_stop
;
124 /* If non-NULL, the shell we actually invoke. See maybe_cache_shell
126 static const char *copied_shell
;
128 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
129 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
131 /* This controls output of inferior debugging. */
132 static unsigned int darwin_debug_flag
= 0;
134 /* Create a __TEXT __info_plist section in the executable so that gdb could
135 be signed. This is required to get an authorization for task_for_pid.
137 Once gdb is built, you must codesign it with any system-trusted signing
138 authority. See taskgated(8) for details. */
139 static const unsigned char info_plist
[]
140 __attribute__ ((section ("__TEXT,__info_plist"),used
)) =
141 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
142 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
143 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
144 "<plist version=\"1.0\">\n"
146 " <key>CFBundleIdentifier</key>\n"
147 " <string>org.gnu.gdb</string>\n"
148 " <key>CFBundleName</key>\n"
149 " <string>gdb</string>\n"
150 " <key>CFBundleVersion</key>\n"
151 " <string>1.0</string>\n"
152 " <key>SecTaskAccess</key>\n"
154 " <string>allowed</string>\n"
155 " <string>debug</string>\n"
160 static void inferior_debug (int level
, const char *fmt
, ...)
161 ATTRIBUTE_PRINTF (2, 3);
164 inferior_debug (int level
, const char *fmt
, ...)
168 if (darwin_debug_flag
< level
)
172 printf_unfiltered (_("[%d inferior]: "), getpid ());
173 vprintf_unfiltered (fmt
, ap
);
178 mach_check_error (kern_return_t ret
, const char *file
,
179 unsigned int line
, const char *func
)
181 if (ret
== KERN_SUCCESS
)
184 func
= _("[UNKNOWN]");
186 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
187 file
, line
, func
, mach_error_string (ret
), (unsigned long) ret
);
191 unparse_exception_type (unsigned int i
)
193 static char unknown_exception_buf
[32];
198 return "EXC_BAD_ACCESS";
199 case EXC_BAD_INSTRUCTION
:
200 return "EXC_BAD_INSTRUCTION";
202 return "EXC_ARITHMETIC";
204 return "EXC_EMULATION";
206 return "EXC_SOFTWARE";
208 return "EXC_BREAKPOINT";
210 return "EXC_SYSCALL";
211 case EXC_MACH_SYSCALL
:
212 return "EXC_MACH_SYSCALL";
214 return "EXC_RPC_ALERT";
218 snprintf (unknown_exception_buf
, 32, _("unknown (%d)"), i
);
219 return unknown_exception_buf
;
223 /* Set errno to zero, and then call ptrace with the given arguments.
224 If inferior debugging traces are on, then also print a debug
227 The returned value is the same as the value returned by ptrace,
228 except in the case where that value is -1 but errno is zero.
229 This case is documented to be a non-error situation, so we
230 return zero in that case. */
233 darwin_ptrace (const char *name
,
234 int request
, int pid
, caddr_t arg3
, int arg4
)
239 ret
= ptrace (request
, pid
, arg3
, arg4
);
240 if (ret
== -1 && errno
== 0)
243 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
244 name
, pid
, (unsigned long) arg3
, arg4
, ret
,
245 (ret
!= 0) ? safe_strerror (errno
) : _("no error"));
250 cmp_thread_t (const void *l
, const void *r
)
252 thread_t tl
= *(const thread_t
*)l
;
253 thread_t tr
= *(const thread_t
*)r
;
254 return (int)(tl
- tr
);
258 darwin_nat_target::check_new_threads (inferior
*inf
)
261 thread_array_t thread_list
;
262 unsigned int new_nbr
;
263 unsigned int old_nbr
;
264 unsigned int new_ix
, old_ix
;
265 darwin_inferior
*darwin_inf
= get_darwin_inferior (inf
);
266 std::vector
<darwin_thread_t
*> new_thread_vec
;
268 if (darwin_inf
== nullptr)
271 /* Get list of threads. */
272 kret
= task_threads (darwin_inf
->task
, &thread_list
, &new_nbr
);
273 MACH_CHECK_ERROR (kret
);
274 if (kret
!= KERN_SUCCESS
)
279 qsort (thread_list
, new_nbr
, sizeof (thread_t
), cmp_thread_t
);
281 old_nbr
= darwin_inf
->threads
.size ();
283 /* Quick check for no changes. */
284 if (old_nbr
== new_nbr
)
288 for (i
= 0; i
< new_nbr
; i
++)
289 if (thread_list
[i
] != darwin_inf
->threads
[i
]->gdb_port
)
293 /* Deallocate ports. */
294 for (i
= 0; i
< new_nbr
; i
++)
296 kret
= mach_port_deallocate (mach_task_self (), thread_list
[i
]);
297 MACH_CHECK_ERROR (kret
);
300 /* Deallocate the buffer. */
301 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
302 new_nbr
* sizeof (int));
303 MACH_CHECK_ERROR (kret
);
309 /* Full handling: detect new threads, remove dead threads. */
311 new_thread_vec
.reserve (new_nbr
);
313 for (new_ix
= 0, old_ix
= 0; new_ix
< new_nbr
|| old_ix
< old_nbr
;)
315 thread_t new_id
= (new_ix
< new_nbr
) ? thread_list
[new_ix
] : THREAD_NULL
;
317 = (old_ix
< old_nbr
) ? darwin_inf
->threads
[old_ix
] : NULL
;
318 thread_t old_id
= old
!= NULL
? old
->gdb_port
: THREAD_NULL
;
321 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
322 new_ix
, new_nbr
, old_ix
, old_nbr
, new_id
, old_id
);
324 if (old_id
== new_id
)
326 /* Thread still exist. */
327 new_thread_vec
.push_back (old
);
331 /* Deallocate the port. */
332 kret
= mach_port_deallocate (gdb_task
, new_id
);
333 MACH_CHECK_ERROR (kret
);
337 if (new_ix
< new_nbr
&& new_id
== MACH_PORT_DEAD
)
339 /* Ignore dead ports.
340 In some weird cases, we might get dead ports. They should
341 correspond to dead thread so they could safely be ignored. */
345 if (new_ix
< new_nbr
&& (old_ix
== old_nbr
|| new_id
< old_id
))
347 /* A thread was created. */
348 darwin_thread_info
*pti
= new darwin_thread_info
;
350 pti
->gdb_port
= new_id
;
351 pti
->msg_state
= DARWIN_RUNNING
;
353 /* Add the new thread. */
354 add_thread_with_info (this, ptid_t (inf
->pid
, 0, new_id
), pti
);
355 new_thread_vec
.push_back (pti
);
359 if (old_ix
< old_nbr
&& (new_ix
== new_nbr
|| new_id
> old_id
))
361 /* A thread was removed. */
362 struct thread_info
*thr
363 = find_thread_ptid (this, ptid_t (inf
->pid
, 0, old_id
));
365 kret
= mach_port_deallocate (gdb_task
, old_id
);
366 MACH_CHECK_ERROR (kret
);
370 gdb_assert_not_reached ("unexpected thread case");
373 darwin_inf
->threads
= std::move (new_thread_vec
);
375 /* Deallocate the buffer. */
376 kret
= vm_deallocate (gdb_task
, (vm_address_t
) thread_list
,
377 new_nbr
* sizeof (int));
378 MACH_CHECK_ERROR (kret
);
382 find_inferior_task_it (struct inferior
*inf
, void *port_ptr
)
384 darwin_inferior
*priv
= get_darwin_inferior (inf
);
386 return priv
!= nullptr && priv
->task
== *(task_t
*)port_ptr
;
390 find_inferior_pid_it (struct inferior
*inf
, void *pid_ptr
)
392 return inf
->pid
== *(int *)pid_ptr
;
395 /* Return an inferior by task port. */
396 static struct inferior
*
397 darwin_find_inferior_by_task (task_t port
)
399 return iterate_over_inferiors (&find_inferior_task_it
, &port
);
402 /* Return an inferior by pid port. */
403 static struct inferior
*
404 darwin_find_inferior_by_pid (int pid
)
406 return iterate_over_inferiors (&find_inferior_pid_it
, &pid
);
409 /* Return a thread by port. */
410 static darwin_thread_t
*
411 darwin_find_thread (struct inferior
*inf
, thread_t thread
)
413 darwin_inferior
*priv
= get_darwin_inferior (inf
);
416 for (darwin_thread_t
*t
: priv
->threads
)
418 if (t
->gdb_port
== thread
)
425 /* Suspend (ie stop) an inferior at Mach level. */
428 darwin_suspend_inferior (struct inferior
*inf
)
430 darwin_inferior
*priv
= get_darwin_inferior (inf
);
432 if (priv
!= nullptr && !priv
->suspended
)
436 kret
= task_suspend (priv
->task
);
437 MACH_CHECK_ERROR (kret
);
443 /* Resume an inferior at Mach level. */
446 darwin_resume_inferior (struct inferior
*inf
)
448 darwin_inferior
*priv
= get_darwin_inferior (inf
);
450 if (priv
!= nullptr && priv
->suspended
)
454 kret
= task_resume (priv
->task
);
455 MACH_CHECK_ERROR (kret
);
461 /* Iterator functions. */
464 darwin_resume_inferior_it (struct inferior
*inf
, void *arg
)
466 darwin_resume_inferior (inf
);
471 darwin_dump_message (mach_msg_header_t
*hdr
, int disp_body
)
473 printf_unfiltered (_("message header:\n"));
474 printf_unfiltered (_(" bits: 0x%x\n"), hdr
->msgh_bits
);
475 printf_unfiltered (_(" size: 0x%x\n"), hdr
->msgh_size
);
476 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr
->msgh_remote_port
);
477 printf_unfiltered (_(" local-port: 0x%x\n"), hdr
->msgh_local_port
);
478 printf_unfiltered (_(" reserved: 0x%x\n"), hdr
->msgh_reserved
);
479 printf_unfiltered (_(" id: 0x%x\n"), hdr
->msgh_id
);
483 const unsigned char *data
;
484 const unsigned int *ldata
;
488 data
= (unsigned char *)(hdr
+ 1);
489 size
= hdr
->msgh_size
- sizeof (mach_msg_header_t
);
491 if (hdr
->msgh_bits
& MACH_MSGH_BITS_COMPLEX
)
493 mach_msg_body_t
*bod
= (mach_msg_body_t
*)data
;
494 mach_msg_port_descriptor_t
*desc
=
495 (mach_msg_port_descriptor_t
*)(bod
+ 1);
498 printf_unfiltered (_("body: descriptor_count=%u\n"),
499 bod
->msgh_descriptor_count
);
500 data
+= sizeof (mach_msg_body_t
);
501 size
-= sizeof (mach_msg_body_t
);
502 for (k
= 0; k
< bod
->msgh_descriptor_count
; k
++)
503 switch (desc
[k
].type
)
505 case MACH_MSG_PORT_DESCRIPTOR
:
507 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
508 k
, desc
[k
].type
, desc
[k
].name
, desc
[k
].disposition
);
511 printf_unfiltered (_(" descr %d: type=%u\n"),
515 data
+= bod
->msgh_descriptor_count
516 * sizeof (mach_msg_port_descriptor_t
);
517 size
-= bod
->msgh_descriptor_count
518 * sizeof (mach_msg_port_descriptor_t
);
519 ndr
= (NDR_record_t
*)(desc
+ bod
->msgh_descriptor_count
);
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 printf_unfiltered (_(" data:"));
530 ldata
= (const unsigned int *)data
;
531 for (i
= 0; i
< size
/ sizeof (unsigned int); i
++)
532 printf_unfiltered (" %08x", ldata
[i
]);
533 printf_unfiltered (_("\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 struct resume_inferior_threads_param
896 darwin_resume_inferior_threads_it (struct inferior
*inf
, void *param
)
898 int step
= ((struct resume_inferior_threads_param
*)param
)->step
;
899 int nsignal
= ((struct resume_inferior_threads_param
*)param
)->nsignal
;
901 darwin_resume_inferior_threads (inf
, step
, nsignal
);
906 /* Suspend all threads of INF. */
909 darwin_suspend_inferior_threads (struct inferior
*inf
)
911 darwin_inferior
*priv
= get_darwin_inferior (inf
);
913 for (darwin_thread_t
*thread
: priv
->threads
)
915 switch (thread
->msg_state
)
922 kern_return_t kret
= thread_suspend (thread
->gdb_port
);
923 MACH_CHECK_ERROR (kret
);
924 thread
->msg_state
= DARWIN_STOPPED
;
932 darwin_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
934 struct target_waitstatus status
;
939 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
940 ptid
.pid (), ptid
.tid (), step
, signal
);
942 if (signal
== GDB_SIGNAL_0
)
945 nsignal
= gdb_signal_to_host (signal
);
947 /* Don't try to single step all threads. */
949 ptid
= inferior_ptid
;
951 /* minus_one_ptid is RESUME_ALL. */
952 if (ptid
== minus_one_ptid
)
954 struct resume_inferior_threads_param param
;
956 param
.nsignal
= nsignal
;
959 /* Resume threads. */
960 iterate_over_inferiors (darwin_resume_inferior_threads_it
, ¶m
);
962 iterate_over_inferiors (darwin_resume_inferior_it
, NULL
);
966 inferior
*inf
= find_inferior_ptid (this, ptid
);
967 long tid
= ptid
.tid ();
969 /* Stop the inferior (should be useless). */
970 darwin_suspend_inferior (inf
);
973 darwin_resume_inferior_threads (inf
, step
, nsignal
);
976 darwin_thread_t
*thread
;
978 /* Suspend threads of the task. */
979 darwin_suspend_inferior_threads (inf
);
981 /* Resume the selected thread. */
982 thread
= darwin_find_thread (inf
, tid
);
984 darwin_resume_thread (inf
, thread
, step
, nsignal
);
987 /* Resume the task. */
988 darwin_resume_inferior (inf
);
993 darwin_nat_target::decode_message (mach_msg_header_t
*hdr
,
994 darwin_thread_t
**pthread
,
996 target_waitstatus
*status
)
998 darwin_thread_t
*thread
;
999 struct inferior
*inf
;
1001 /* Exception message. 2401 == 0x961 is exc. */
1002 if (hdr
->msgh_id
== 2401)
1006 /* Decode message. */
1007 res
= decode_exception_message (hdr
, &inf
, &thread
);
1011 /* Should not happen... */
1013 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr
->msgh_id
);
1014 /* FIXME: send a failure reply? */
1015 status
->kind
= TARGET_WAITKIND_IGNORE
;
1016 return minus_one_ptid
;
1020 status
->kind
= TARGET_WAITKIND_IGNORE
;
1021 return minus_one_ptid
;
1026 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1028 priv
->pending_messages
++;
1030 status
->kind
= TARGET_WAITKIND_STOPPED
;
1031 thread
->msg_state
= DARWIN_MESSAGE
;
1033 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1035 unparse_exception_type (thread
->event
.ex_type
));
1037 switch (thread
->event
.ex_type
)
1039 case EXC_BAD_ACCESS
:
1040 status
->value
.sig
= GDB_EXC_BAD_ACCESS
;
1042 case EXC_BAD_INSTRUCTION
:
1043 status
->value
.sig
= GDB_EXC_BAD_INSTRUCTION
;
1045 case EXC_ARITHMETIC
:
1046 status
->value
.sig
= GDB_EXC_ARITHMETIC
;
1049 status
->value
.sig
= GDB_EXC_EMULATION
;
1052 if (thread
->event
.ex_data
[0] == EXC_SOFT_SIGNAL
)
1055 gdb_signal_from_host (thread
->event
.ex_data
[1]);
1056 inferior_debug (5, _(" (signal %d: %s)\n"),
1057 thread
->event
.ex_data
[1],
1058 gdb_signal_to_name (status
->value
.sig
));
1060 /* If the thread is stopped because it has received a signal
1061 that gdb has just sent, continue. */
1062 if (thread
->signaled
)
1064 thread
->signaled
= 0;
1065 darwin_send_reply (inf
, thread
);
1066 thread
->msg_state
= DARWIN_RUNNING
;
1067 status
->kind
= TARGET_WAITKIND_IGNORE
;
1071 status
->value
.sig
= GDB_EXC_SOFTWARE
;
1073 case EXC_BREAKPOINT
:
1074 /* Many internal GDB routines expect breakpoints to be reported
1075 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1076 as a spurious signal. */
1077 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1080 status
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
1084 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1086 else if (hdr
->msgh_id
== 0x48)
1088 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1091 res
= darwin_decode_notify_message (hdr
, &inf
);
1095 /* Should not happen... */
1097 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1104 if (res
< 0 || inf
== NULL
)
1106 status
->kind
= TARGET_WAITKIND_IGNORE
;
1107 return minus_one_ptid
;
1112 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1114 if (!priv
->no_ptrace
)
1119 res_pid
= wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1120 if (res_pid
< 0 || res_pid
!= inf
->pid
)
1122 printf_unfiltered (_("wait4: res=%d: %s\n"),
1123 res_pid
, safe_strerror (errno
));
1124 status
->kind
= TARGET_WAITKIND_IGNORE
;
1125 return minus_one_ptid
;
1127 if (WIFEXITED (wstatus
))
1129 status
->kind
= TARGET_WAITKIND_EXITED
;
1130 status
->value
.integer
= WEXITSTATUS (wstatus
);
1134 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1135 status
->value
.sig
= gdb_signal_from_host (WTERMSIG (wstatus
));
1138 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1141 /* Looks necessary on Leopard and harmless... */
1142 wait4 (inf
->pid
, &wstatus
, 0, NULL
);
1144 inferior_ptid
= ptid_t (inf
->pid
, 0, 0);
1145 return inferior_ptid
;
1149 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf
->pid
);
1150 status
->kind
= TARGET_WAITKIND_EXITED
;
1151 status
->value
.integer
= 0; /* Don't know. */
1152 return ptid_t (inf
->pid
, 0, 0);
1157 /* Unknown message. */
1158 warning (_("darwin: got unknown message, id: 0x%x"), hdr
->msgh_id
);
1159 status
->kind
= TARGET_WAITKIND_IGNORE
;
1160 return minus_one_ptid
;
1164 darwin_nat_target::cancel_breakpoint (ptid_t ptid
)
1166 /* Arrange for a breakpoint to be hit again later. We will handle
1167 the current event, eventually we will resume this thread, and this
1168 breakpoint will trap again.
1170 If we do not do this, then we run the risk that the user will
1171 delete or disable the breakpoint, but the thread will have already
1174 struct regcache
*regcache
= get_thread_regcache (this, ptid
);
1175 struct gdbarch
*gdbarch
= regcache
->arch ();
1178 pc
= regcache_read_pc (regcache
) - gdbarch_decr_pc_after_break (gdbarch
);
1179 if (breakpoint_inserted_here_p (regcache
->aspace (), pc
))
1181 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1182 (unsigned long) ptid
.tid ());
1184 /* Back up the PC if necessary. */
1185 if (gdbarch_decr_pc_after_break (gdbarch
))
1186 regcache_write_pc (regcache
, pc
);
1194 darwin_nat_target::wait_1 (ptid_t ptid
, struct target_waitstatus
*status
)
1199 mach_msg_header_t hdr
;
1202 mach_msg_header_t
*hdr
= &msgin
.hdr
;
1204 darwin_thread_t
*thread
;
1207 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1208 ptid
.pid (), ptid
.tid ());
1210 /* Handle fake stop events at first. */
1211 if (darwin_inf_fake_stop
!= NULL
)
1213 inferior
*inf
= darwin_inf_fake_stop
;
1214 darwin_inf_fake_stop
= NULL
;
1216 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1218 status
->kind
= TARGET_WAITKIND_STOPPED
;
1219 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1220 thread
= priv
->threads
[0];
1221 thread
->msg_state
= DARWIN_STOPPED
;
1222 return ptid_t (inf
->pid
, 0, thread
->gdb_port
);
1227 /* set_sigint_trap (); */
1229 /* Wait for a message. */
1230 kret
= mach_msg (&msgin
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
, 0,
1231 sizeof (msgin
.data
), darwin_port_set
, 0, MACH_PORT_NULL
);
1233 /* clear_sigint_trap (); */
1235 if (kret
== MACH_RCV_INTERRUPTED
)
1237 status
->kind
= TARGET_WAITKIND_IGNORE
;
1238 return minus_one_ptid
;
1241 if (kret
!= MACH_MSG_SUCCESS
)
1243 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret
);
1244 status
->kind
= TARGET_WAITKIND_SPURIOUS
;
1245 return minus_one_ptid
;
1248 /* Debug: display message. */
1249 if (darwin_debug_flag
> 10)
1250 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1253 res
= decode_message (hdr
, &thread
, &inf
, status
);
1254 if (res
== minus_one_ptid
)
1257 /* Early return in case an inferior has exited. */
1261 while (status
->kind
== TARGET_WAITKIND_IGNORE
);
1263 /* Stop all tasks. */
1264 for (inferior
*inf
: all_inferiors (this))
1266 darwin_suspend_inferior (inf
);
1267 check_new_threads (inf
);
1270 /* Read pending messages. */
1273 struct target_waitstatus status2
;
1276 kret
= mach_msg (&msgin
.hdr
,
1277 MACH_RCV_MSG
| MACH_RCV_TIMEOUT
, 0,
1278 sizeof (msgin
.data
), darwin_port_set
, 1, MACH_PORT_NULL
);
1280 if (kret
== MACH_RCV_TIMED_OUT
)
1282 if (kret
!= MACH_MSG_SUCCESS
)
1285 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret
);
1289 /* Debug: display message. */
1290 if (darwin_debug_flag
> 10)
1291 darwin_dump_message (hdr
, darwin_debug_flag
> 11);
1294 ptid2
= decode_message (hdr
, &thread
, &inf
, &status2
);
1296 if (inf
!= NULL
&& thread
!= NULL
1297 && thread
->event
.ex_type
== EXC_BREAKPOINT
)
1299 if (thread
->single_step
1300 || cancel_breakpoint (ptid_t (inf
->pid
, 0, thread
->gdb_port
)))
1302 gdb_assert (thread
->msg_state
== DARWIN_MESSAGE
);
1303 darwin_send_reply (inf
, thread
);
1304 thread
->msg_state
= DARWIN_RUNNING
;
1308 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1312 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1318 darwin_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1321 return wait_1 (ptid
, status
);
1325 darwin_nat_target::interrupt ()
1327 struct inferior
*inf
= current_inferior ();
1328 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1330 /* FIXME: handle in no_ptrace mode. */
1331 gdb_assert (!priv
->no_ptrace
);
1332 ::kill (inf
->pid
, SIGINT
);
1335 /* Deallocate threads port and vector. */
1338 darwin_deallocate_threads (struct inferior
*inf
)
1340 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1342 for (darwin_thread_t
*t
: priv
->threads
)
1344 kern_return_t kret
= mach_port_deallocate (gdb_task
, t
->gdb_port
);
1345 MACH_CHECK_ERROR (kret
);
1348 priv
->threads
.clear ();
1352 darwin_nat_target::mourn_inferior ()
1354 struct inferior
*inf
= current_inferior ();
1355 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1359 /* Deallocate threads. */
1360 darwin_deallocate_threads (inf
);
1362 /* Remove notify_port from darwin_port_set. */
1363 kret
= mach_port_move_member (gdb_task
,
1364 priv
->notify_port
, MACH_PORT_NULL
);
1365 MACH_CHECK_ERROR (kret
);
1367 /* Remove task port dead_name notification. */
1368 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1369 MACH_NOTIFY_DEAD_NAME
, 0,
1371 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1373 /* This can fail if the task is dead. */
1374 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1375 priv
->task
, prev
, priv
->notify_port
);
1377 if (kret
== KERN_SUCCESS
)
1379 kret
= mach_port_deallocate (gdb_task
, prev
);
1380 MACH_CHECK_ERROR (kret
);
1383 /* Destroy notify_port. */
1384 kret
= mach_port_destroy (gdb_task
, priv
->notify_port
);
1385 MACH_CHECK_ERROR (kret
);
1387 /* Deallocate saved exception ports. */
1388 darwin_deallocate_exception_ports (priv
);
1390 /* Deallocate task port. */
1391 kret
= mach_port_deallocate (gdb_task
, priv
->task
);
1392 MACH_CHECK_ERROR (kret
);
1396 inf_child_target::mourn_inferior ();
1400 darwin_reply_to_all_pending_messages (struct inferior
*inf
)
1402 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1404 for (darwin_thread_t
*t
: priv
->threads
)
1406 if (t
->msg_state
== DARWIN_MESSAGE
)
1407 darwin_resume_thread (inf
, t
, 0, 0);
1412 darwin_nat_target::stop_inferior (inferior
*inf
)
1414 struct target_waitstatus wstatus
;
1417 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1419 gdb_assert (inf
!= NULL
);
1421 darwin_suspend_inferior (inf
);
1423 darwin_reply_to_all_pending_messages (inf
);
1425 if (priv
->no_ptrace
)
1428 res
= ::kill (inf
->pid
, SIGSTOP
);
1430 warning (_("cannot kill: %s"), safe_strerror (errno
));
1432 /* Wait until the process is really stopped. */
1435 ptid
= wait_1 (inferior_ptid
, &wstatus
);
1436 if (wstatus
.kind
== TARGET_WAITKIND_STOPPED
1437 && wstatus
.value
.sig
== GDB_SIGNAL_STOP
)
1442 static kern_return_t
1443 darwin_save_exception_ports (darwin_inferior
*inf
)
1447 inf
->exception_info
.count
=
1448 sizeof (inf
->exception_info
.ports
) / sizeof (inf
->exception_info
.ports
[0]);
1450 kret
= task_get_exception_ports
1451 (inf
->task
, EXC_MASK_ALL
, inf
->exception_info
.masks
,
1452 &inf
->exception_info
.count
, inf
->exception_info
.ports
,
1453 inf
->exception_info
.behaviors
, inf
->exception_info
.flavors
);
1457 static kern_return_t
1458 darwin_restore_exception_ports (darwin_inferior
*inf
)
1463 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1465 kret
= task_set_exception_ports
1466 (inf
->task
, inf
->exception_info
.masks
[i
], inf
->exception_info
.ports
[i
],
1467 inf
->exception_info
.behaviors
[i
], inf
->exception_info
.flavors
[i
]);
1468 if (kret
!= KERN_SUCCESS
)
1472 return KERN_SUCCESS
;
1475 /* Deallocate saved exception ports. */
1478 darwin_deallocate_exception_ports (darwin_inferior
*inf
)
1483 for (i
= 0; i
< inf
->exception_info
.count
; i
++)
1485 kret
= mach_port_deallocate (gdb_task
, inf
->exception_info
.ports
[i
]);
1486 MACH_CHECK_ERROR (kret
);
1488 inf
->exception_info
.count
= 0;
1492 darwin_setup_exceptions (struct inferior
*inf
)
1494 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1496 exception_mask_t mask
;
1498 kret
= darwin_save_exception_ports (priv
);
1499 if (kret
!= KERN_SUCCESS
)
1500 error (_("Unable to save exception ports, task_get_exception_ports"
1504 /* Set exception port. */
1505 if (enable_mach_exceptions
)
1506 mask
= EXC_MASK_ALL
;
1508 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
1509 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
1510 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
1511 if (kret
!= KERN_SUCCESS
)
1512 error (_("Unable to set exception ports, task_set_exception_ports"
1518 darwin_nat_target::kill ()
1520 struct inferior
*inf
= current_inferior ();
1521 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1522 struct target_waitstatus wstatus
;
1527 if (inferior_ptid
== null_ptid
)
1530 gdb_assert (inf
!= NULL
);
1532 kret
= darwin_restore_exception_ports (priv
);
1533 MACH_CHECK_ERROR (kret
);
1535 darwin_reply_to_all_pending_messages (inf
);
1537 res
= ::kill (inf
->pid
, 9);
1541 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1542 does not work as expected.
1543 When the kill function is called, the SIGKILL signal is received
1544 by gdb whereas it should have been received by the kernel since
1545 the exception ports have been restored.
1546 This behavior is not the expected one thus gdb does not reply to
1547 the received SIGKILL message. This situation leads to a "busy"
1548 resource from the kernel point of view and the inferior is never
1549 released, causing it to remain as a zombie process, even after
1551 To work around this, we mark all the threads of the inferior as
1552 signaled thus darwin_decode_message function knows that the kill
1553 signal was sent by gdb and will take the appropriate action
1554 (cancel signal and reply to the signal message). */
1555 for (darwin_thread_t
*thread
: priv
->threads
)
1556 thread
->signaled
= 1;
1558 darwin_resume_inferior (inf
);
1560 ptid
= wait_1 (inferior_ptid
, &wstatus
);
1562 else if (errno
!= ESRCH
)
1563 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1564 inf
->pid
, safe_strerror (errno
));
1566 target_mourn_inferior (inferior_ptid
);
1570 darwin_setup_request_notification (struct inferior
*inf
)
1572 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1574 mach_port_t prev_not
;
1576 kret
= mach_port_request_notification (gdb_task
, priv
->task
,
1577 MACH_NOTIFY_DEAD_NAME
, 0,
1579 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1581 if (kret
!= KERN_SUCCESS
)
1582 error (_("Termination notification request failed, "
1583 "mach_port_request_notification\n"
1586 if (prev_not
!= MACH_PORT_NULL
)
1588 /* This is unexpected, as there should not be any previously
1589 registered notification request. But this is not a fatal
1590 issue, so just emit a warning. */
1592 A task termination request was registered before the debugger registered\n\
1593 its own. This is unexpected, but should otherwise not have any actual\n\
1594 impact on the debugging session."));
1599 darwin_attach_pid (struct inferior
*inf
)
1603 darwin_inferior
*priv
= new darwin_inferior
;
1604 inf
->priv
.reset (priv
);
1608 kret
= task_for_pid (gdb_task
, inf
->pid
, &priv
->task
);
1609 if (kret
!= KERN_SUCCESS
)
1613 if (!inf
->attach_flag
)
1616 waitpid (inf
->pid
, &status
, 0);
1620 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1621 " (please check gdb is codesigned - see taskgated(8))"),
1622 inf
->pid
, mach_error_string (kret
), (unsigned long) kret
);
1625 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1626 priv
->task
, inf
->pid
);
1628 if (darwin_ex_port
== MACH_PORT_NULL
)
1630 /* Create a port to get exceptions. */
1631 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1633 if (kret
!= KERN_SUCCESS
)
1634 error (_("Unable to create exception port, mach_port_allocate "
1638 kret
= mach_port_insert_right (gdb_task
, darwin_ex_port
,
1640 MACH_MSG_TYPE_MAKE_SEND
);
1641 if (kret
!= KERN_SUCCESS
)
1642 error (_("Unable to create exception port, mach_port_insert_right "
1646 /* Create a port set and put ex_port in it. */
1647 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_PORT_SET
,
1649 if (kret
!= KERN_SUCCESS
)
1650 error (_("Unable to create port set, mach_port_allocate "
1654 kret
= mach_port_move_member (gdb_task
, darwin_ex_port
,
1656 if (kret
!= KERN_SUCCESS
)
1657 error (_("Unable to move exception port into new port set, "
1658 "mach_port_move_member\n"
1663 /* Create a port to be notified when the child task terminates. */
1664 kret
= mach_port_allocate (gdb_task
, MACH_PORT_RIGHT_RECEIVE
,
1665 &priv
->notify_port
);
1666 if (kret
!= KERN_SUCCESS
)
1667 error (_("Unable to create notification port, mach_port_allocate "
1671 kret
= mach_port_move_member (gdb_task
,
1672 priv
->notify_port
, darwin_port_set
);
1673 if (kret
!= KERN_SUCCESS
)
1674 error (_("Unable to move notification port into new port set, "
1675 "mach_port_move_member\n"
1679 darwin_setup_request_notification (inf
);
1681 darwin_setup_exceptions (inf
);
1683 catch (const gdb_exception
&ex
)
1685 exit_inferior (inf
);
1686 inferior_ptid
= null_ptid
;
1691 target_ops
*darwin_ops
= get_native_target ();
1692 if (!target_is_pushed (darwin_ops
))
1693 push_target (darwin_ops
);
1696 /* Get the thread_info object corresponding to this darwin_thread_info. */
1698 static struct thread_info
*
1699 thread_info_from_private_thread_info (darwin_thread_info
*pti
)
1701 for (struct thread_info
*it
: all_threads ())
1703 darwin_thread_info
*iter_pti
= get_darwin_thread_info (it
);
1705 if (iter_pti
->gdb_port
== pti
->gdb_port
)
1709 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1713 darwin_nat_target::init_thread_list (inferior
*inf
)
1715 check_new_threads (inf
);
1717 darwin_inferior
*priv
= get_darwin_inferior (inf
);
1719 gdb_assert (!priv
->threads
.empty ());
1721 darwin_thread_info
*first_pti
= priv
->threads
.front ();
1722 struct thread_info
*first_thread
1723 = thread_info_from_private_thread_info (first_pti
);
1725 inferior_ptid
= first_thread
->ptid
;
1728 /* The child must synchronize with gdb: gdb must set the exception port
1729 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1730 FIXME: is there a lighter way ? */
1731 static int ptrace_fds
[2];
1734 darwin_ptrace_me (void)
1739 /* Close write end point. */
1740 if (close (ptrace_fds
[1]) < 0)
1741 trace_start_error_with_name ("close");
1743 /* Wait until gdb is ready. */
1744 res
= read (ptrace_fds
[0], &c
, 1);
1746 trace_start_error (_("unable to read from pipe, read returned: %d"), res
);
1748 if (close (ptrace_fds
[0]) < 0)
1749 trace_start_error_with_name ("close");
1751 /* Get rid of privileges. */
1752 if (setegid (getgid ()) < 0)
1753 trace_start_error_with_name ("setegid");
1756 if (PTRACE (PT_TRACE_ME
, 0, 0, 0) < 0)
1757 trace_start_error_with_name ("PTRACE");
1759 /* Redirect signals to exception port. */
1760 if (PTRACE (PT_SIGEXC
, 0, 0, 0) < 0)
1761 trace_start_error_with_name ("PTRACE");
1764 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1766 darwin_pre_ptrace (void)
1768 if (pipe (ptrace_fds
) != 0)
1772 error (_("unable to create a pipe: %s"), safe_strerror (errno
));
1775 mark_fd_no_cloexec (ptrace_fds
[0]);
1776 mark_fd_no_cloexec (ptrace_fds
[1]);
1780 darwin_nat_target::ptrace_him (int pid
)
1782 struct inferior
*inf
= current_inferior ();
1784 darwin_attach_pid (inf
);
1786 /* Let's the child run. */
1787 ::close (ptrace_fds
[0]);
1788 ::close (ptrace_fds
[1]);
1790 unmark_fd_no_cloexec (ptrace_fds
[0]);
1791 unmark_fd_no_cloexec (ptrace_fds
[1]);
1793 init_thread_list (inf
);
1795 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
1799 darwin_execvp (const char *file
, char * const argv
[], char * const env
[])
1801 posix_spawnattr_t attr
;
1805 res
= posix_spawnattr_init (&attr
);
1809 (gdb_stderr
, "Cannot initialize attribute for posix_spawn\n");
1813 /* Do like execve: replace the image. */
1814 ps_flags
= POSIX_SPAWN_SETEXEC
;
1816 /* Disable ASLR. The constant doesn't look to be available outside the
1817 kernel include files. */
1818 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1819 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1821 ps_flags
|= _POSIX_SPAWN_DISABLE_ASLR
;
1822 res
= posix_spawnattr_setflags (&attr
, ps_flags
);
1825 fprintf_unfiltered (gdb_stderr
, "Cannot set posix_spawn flags\n");
1829 posix_spawnp (NULL
, argv
[0], NULL
, &attr
, argv
, env
);
1832 /* Read kernel version, and return TRUE if this host may have System
1833 Integrity Protection (Sierra or later). */
1839 size_t sz
= sizeof (str
);
1842 ret
= sysctlbyname ("kern.osrelease", str
, &sz
, NULL
, 0);
1843 if (ret
== 0 && sz
< sizeof (str
))
1845 unsigned long ver
= strtoul (str
, NULL
, 10);
1852 /* A helper for maybe_cache_shell. This copies the shell to the
1853 cache. It will throw an exception on any failure. */
1856 copy_shell_to_cache (const char *shell
, const std::string
&new_name
)
1858 scoped_fd
from_fd (gdb_open_cloexec (shell
, O_RDONLY
, 0));
1859 if (from_fd
.get () < 0)
1860 error (_("Could not open shell (%s) for reading: %s"),
1861 shell
, safe_strerror (errno
));
1863 std::string new_dir
= ldirname (new_name
.c_str ());
1864 if (!mkdir_recursive (new_dir
.c_str ()))
1865 error (_("Could not make cache directory \"%s\": %s"),
1866 new_dir
.c_str (), safe_strerror (errno
));
1868 gdb::char_vector temp_name
= make_temp_filename (new_name
);
1869 scoped_fd
to_fd (gdb_mkostemp_cloexec (&temp_name
[0]));
1870 gdb::unlinker
unlink_file_on_error (temp_name
.data ());
1872 if (to_fd
.get () < 0)
1873 error (_("Could not open temporary file \"%s\" for writing: %s"),
1874 temp_name
.data (), safe_strerror (errno
));
1876 if (fcopyfile (from_fd
.get (), to_fd
.get (), nullptr,
1877 COPYFILE_STAT
| COPYFILE_DATA
) != 0)
1878 error (_("Could not copy shell to cache as \"%s\": %s"),
1879 temp_name
.data (), safe_strerror (errno
));
1881 /* Be sure that the caching is atomic so that we don't get bad
1882 results from multiple copies of gdb running at the same time. */
1883 if (rename (temp_name
.data (), new_name
.c_str ()) != 0)
1884 error (_("Could not rename shell cache file to \"%s\": %s"),
1885 new_name
.c_str (), safe_strerror (errno
));
1887 unlink_file_on_error
.keep ();
1890 /* If $SHELL is restricted, try to cache a copy. Starting with El
1891 Capitan, macOS introduced System Integrity Protection. Among other
1892 things, this prevents certain executables from being ptrace'd. In
1893 particular, executables in /bin, like most shells, are affected.
1894 To work around this, while preserving command-line glob expansion
1895 and redirections, gdb will cache a copy of the shell. Return true
1896 if all is well -- either the shell is not subject to SIP or it has
1897 been successfully cached. Returns false if something failed. */
1900 maybe_cache_shell ()
1902 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1903 given file is subject to SIP. */
1904 #ifdef SF_RESTRICTED
1906 /* If a check fails we want to revert -- maybe the user deleted the
1907 cache while gdb was running, or something like that. */
1908 copied_shell
= nullptr;
1910 const char *shell
= get_shell ();
1911 if (!IS_ABSOLUTE_PATH (shell
))
1913 warning (_("This version of macOS has System Integrity Protection.\n\
1914 Normally gdb would try to work around this by caching a copy of your shell,\n\
1915 but because your shell (%s) is not an absolute path, this is being skipped."),
1921 if (stat (shell
, &sb
) < 0)
1923 warning (_("This version of macOS has System Integrity Protection.\n\
1924 Normally gdb would try to work around this by caching a copy of your shell,\n\
1925 but because gdb could not stat your shell (%s), this is being skipped.\n\
1926 The error was: %s"),
1927 shell
, safe_strerror (errno
));
1931 if ((sb
.st_flags
& SF_RESTRICTED
) == 0)
1934 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1935 std::string new_name
= get_standard_cache_dir ();
1936 /* There's no need to insert a directory separator here, because
1937 SHELL is known to be absolute. */
1938 new_name
.append (shell
);
1940 /* Maybe it was cached by some earlier gdb. */
1941 if (stat (new_name
.c_str (), &sb
) != 0 || !S_ISREG (sb
.st_mode
))
1945 copy_shell_to_cache (shell
, new_name
);
1947 catch (const gdb_exception_error
&ex
)
1949 warning (_("This version of macOS has System Integrity Protection.\n\
1950 Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1951 caching a copy of your shell. However, this failed:\n\
1953 If you correct the problem, gdb will automatically try again the next time\n\
1954 you \"run\". To prevent these attempts, you can use:\n\
1955 set startup-with-shell off"),
1960 printf_filtered (_("Note: this version of macOS has System Integrity Protection.\n\
1961 Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1962 caching a copy of your shell. The shell used by \"run\" is now:\n\
1967 /* We need to make sure that the new name has the correct lifetime. */
1968 static std::string saved_shell
= std::move (new_name
);
1969 copied_shell
= saved_shell
.c_str ();
1971 #endif /* SF_RESTRICTED */
1977 darwin_nat_target::create_inferior (const char *exec_file
,
1978 const std::string
&allargs
,
1979 char **env
, int from_tty
)
1981 gdb::optional
<scoped_restore_tmpl
<bool>> restore_startup_with_shell
;
1982 darwin_nat_target
*the_target
= this;
1984 if (startup_with_shell
&& may_have_sip ())
1986 if (!maybe_cache_shell ())
1988 warning (_("startup-with-shell is now temporarily disabled"));
1989 restore_startup_with_shell
.emplace (&startup_with_shell
, 0);
1993 /* Do the hard work. */
1994 fork_inferior (exec_file
, allargs
, env
, darwin_ptrace_me
,
1995 [the_target
] (int pid
)
1997 the_target
->ptrace_him (pid
);
1999 darwin_pre_ptrace
, copied_shell
,
2004 /* Set things up such that the next call to darwin_wait will immediately
2005 return a fake stop event for inferior INF.
2007 This assumes that the inferior's thread list has been initialized,
2008 as it will suspend the inferior's first thread. */
2011 darwin_setup_fake_stop_event (struct inferior
*inf
)
2013 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2014 darwin_thread_t
*thread
;
2017 gdb_assert (darwin_inf_fake_stop
== NULL
);
2018 darwin_inf_fake_stop
= inf
;
2020 /* When detecting a fake pending stop event, darwin_wait returns
2021 an event saying that the first thread is in a DARWIN_STOPPED
2022 state. To make that accurate, we need to suspend that thread
2023 as well. Otherwise, we'll try resuming it when resuming the
2024 inferior, and get a warning because the thread's suspend count
2025 is already zero, making the resume request useless. */
2026 thread
= priv
->threads
[0];
2027 kret
= thread_suspend (thread
->gdb_port
);
2028 MACH_CHECK_ERROR (kret
);
2031 /* Attach to process PID, then initialize for debugging it
2032 and wait for the trace-trap that results from attaching. */
2034 darwin_nat_target::attach (const char *args
, int from_tty
)
2037 struct inferior
*inf
;
2039 pid
= parse_pid_to_attach (args
);
2041 if (pid
== getpid ()) /* Trying to masturbate? */
2042 error (_("I refuse to debug myself!"));
2046 const char *exec_file
= get_exec_file (0);
2049 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
2050 target_pid_to_str (ptid_t (pid
)).c_str ());
2052 printf_unfiltered (_("Attaching to %s\n"),
2053 target_pid_to_str (ptid_t (pid
)).c_str ());
2056 if (pid
== 0 || ::kill (pid
, 0) < 0)
2057 error (_("Can't attach to process %d: %s (%d)"),
2058 pid
, safe_strerror (errno
), errno
);
2060 inferior_ptid
= ptid_t (pid
);
2061 inf
= current_inferior ();
2062 inferior_appeared (inf
, pid
);
2063 inf
->attach_flag
= 1;
2065 darwin_attach_pid (inf
);
2067 darwin_suspend_inferior (inf
);
2069 init_thread_list (inf
);
2071 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2073 darwin_check_osabi (priv
, inferior_ptid
.tid ());
2075 darwin_setup_fake_stop_event (inf
);
2077 priv
->no_ptrace
= 1;
2080 /* Take a program previously attached to and detaches it.
2081 The program resumes execution and will no longer stop
2082 on signals, etc. We'd better not have left any breakpoints
2083 in the program or it'll die when it hits one. For this
2084 to work, it may be necessary for the process to have been
2085 previously attached. It *might* work if the program was
2086 started via fork. */
2089 darwin_nat_target::detach (inferior
*inf
, int from_tty
)
2091 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2095 /* Display message. */
2096 target_announce_detach (from_tty
);
2098 /* If ptrace() is in use, stop the process. */
2099 if (!priv
->no_ptrace
)
2100 stop_inferior (inf
);
2102 kret
= darwin_restore_exception_ports (priv
);
2103 MACH_CHECK_ERROR (kret
);
2105 if (!priv
->no_ptrace
)
2107 res
= PTRACE (PT_DETACH
, inf
->pid
, 0, 0);
2109 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
2110 inf
->pid
, safe_strerror (errno
), errno
);
2113 darwin_reply_to_all_pending_messages (inf
);
2115 /* When using ptrace, we have just performed a PT_DETACH, which
2116 resumes the inferior. On the other hand, when we are not using
2117 ptrace, we need to resume its execution ourselves. */
2118 if (priv
->no_ptrace
)
2119 darwin_resume_inferior (inf
);
2125 darwin_nat_target::pid_to_str (ptid_t ptid
)
2127 long tid
= ptid
.tid ();
2130 return string_printf (_("Thread 0x%lx of process %u"),
2133 return normal_pid_to_str (ptid
);
2137 darwin_nat_target::thread_alive (ptid_t ptid
)
2142 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2143 copy it to RDADDR in gdb's address space.
2144 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2145 to ADDR in inferior task's address space.
2146 Return 0 on failure; number of bytes read / written otherwise. */
2149 darwin_read_write_inferior (task_t task
, CORE_ADDR addr
,
2150 gdb_byte
*rdaddr
, const gdb_byte
*wraddr
,
2154 mach_vm_size_t res_length
= 0;
2156 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2157 task
, core_addr_to_string (addr
), pulongest (length
));
2162 mach_vm_size_t count
;
2164 /* According to target.h(to_xfer_partial), one and only one may be
2166 gdb_assert (wraddr
== NULL
);
2168 kret
= mach_vm_read_overwrite (task
, addr
, length
,
2169 (mach_vm_address_t
) rdaddr
, &count
);
2170 if (kret
!= KERN_SUCCESS
)
2173 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2174 core_addr_to_string (addr
), mach_error_string (kret
));
2181 gdb_assert (wraddr
!= NULL
);
2185 mach_vm_address_t offset
= addr
& (mach_page_size
- 1);
2186 mach_vm_address_t region_address
= (mach_vm_address_t
) (addr
- offset
);
2187 mach_vm_size_t aligned_length
=
2188 (mach_vm_size_t
) PAGE_ROUND (offset
+ length
);
2189 vm_region_submap_short_info_data_64_t info
;
2190 mach_msg_type_number_t count
= VM_REGION_SUBMAP_SHORT_INFO_COUNT_64
;
2191 natural_t region_depth
= 1000;
2192 mach_vm_address_t region_start
= region_address
;
2193 mach_vm_size_t region_length
;
2194 mach_vm_size_t write_length
;
2196 /* Read page protection. */
2197 kret
= mach_vm_region_recurse
2198 (task
, ®ion_start
, ®ion_length
, ®ion_depth
,
2199 (vm_region_recurse_info_t
) &info
, &count
);
2201 if (kret
!= KERN_SUCCESS
)
2203 inferior_debug (1, _("darwin_read_write_inferior: "
2204 "mach_vm_region_recurse failed at %s: %s\n"),
2205 core_addr_to_string (region_address
),
2206 mach_error_string (kret
));
2211 (9, _("darwin_read_write_inferior: "
2212 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2213 core_addr_to_string (region_address
),
2214 core_addr_to_string (region_start
),
2215 core_addr_to_string (region_length
));
2217 /* Check for holes in memory. */
2218 if (region_start
> region_address
)
2220 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2221 core_addr_to_string (region_address
),
2222 core_addr_to_string (region_start
),
2223 (unsigned)region_length
);
2227 /* Adjust the length. */
2228 region_length
-= (region_address
- region_start
);
2229 if (region_length
> aligned_length
)
2230 region_length
= aligned_length
;
2232 /* Make the pages RW. */
2233 if (!(info
.protection
& VM_PROT_WRITE
))
2235 vm_prot_t prot
= VM_PROT_READ
| VM_PROT_WRITE
;
2237 kret
= mach_vm_protect (task
, region_address
, region_length
,
2239 if (kret
!= KERN_SUCCESS
)
2241 prot
|= VM_PROT_COPY
;
2242 kret
= mach_vm_protect (task
, region_address
, region_length
,
2245 if (kret
!= KERN_SUCCESS
)
2247 warning (_("darwin_read_write_inferior: "
2248 "mach_vm_protect failed at %s "
2249 "(len=0x%lx, prot=0x%x): %s"),
2250 core_addr_to_string (region_address
),
2251 (unsigned long) region_length
, (unsigned) prot
,
2252 mach_error_string (kret
));
2257 if (offset
+ length
> region_length
)
2258 write_length
= region_length
- offset
;
2260 write_length
= length
;
2263 kret
= mach_vm_write (task
, addr
, (vm_offset_t
) wraddr
, write_length
);
2264 if (kret
!= KERN_SUCCESS
)
2266 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2267 mach_error_string (kret
));
2271 /* Restore page rights. */
2272 if (!(info
.protection
& VM_PROT_WRITE
))
2274 kret
= mach_vm_protect (task
, region_address
, region_length
,
2275 FALSE
, info
.protection
);
2276 if (kret
!= KERN_SUCCESS
)
2278 warning (_("darwin_read_write_inferior: "
2279 "mach_vm_protect restore failed at %s "
2281 core_addr_to_string (region_address
),
2282 (unsigned long) region_length
,
2283 mach_error_string (kret
));
2287 addr
+= write_length
;
2288 wraddr
+= write_length
;
2289 res_length
+= write_length
;
2290 length
-= write_length
;
2296 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2297 to RDADDR (in big endian).
2298 Return 0 on failure; number of bytes read / written otherwise. */
2300 #ifdef TASK_DYLD_INFO_COUNT
2301 /* This is not available in Darwin 9. */
2302 static enum target_xfer_status
2303 darwin_read_dyld_info (task_t task
, CORE_ADDR addr
, gdb_byte
*rdaddr
,
2304 ULONGEST length
, ULONGEST
*xfered_len
)
2306 struct task_dyld_info task_dyld_info
;
2307 mach_msg_type_number_t count
= TASK_DYLD_INFO_COUNT
;
2310 if (addr
!= 0 || length
> sizeof (mach_vm_address_t
))
2311 return TARGET_XFER_EOF
;
2313 kret
= task_info (task
, TASK_DYLD_INFO
,
2314 (task_info_t
) &task_dyld_info
, &count
);
2315 MACH_CHECK_ERROR (kret
);
2316 if (kret
!= KERN_SUCCESS
)
2317 return TARGET_XFER_E_IO
;
2319 store_unsigned_integer (rdaddr
, length
, BFD_ENDIAN_BIG
,
2320 task_dyld_info
.all_image_info_addr
);
2321 *xfered_len
= (ULONGEST
) length
;
2322 return TARGET_XFER_OK
;
2328 enum target_xfer_status
2329 darwin_nat_target::xfer_partial (enum target_object object
, const char *annex
,
2330 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2331 ULONGEST offset
, ULONGEST len
,
2332 ULONGEST
*xfered_len
)
2334 struct inferior
*inf
= current_inferior ();
2335 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2338 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2339 core_addr_to_string (offset
), pulongest (len
),
2340 host_address_to_string (readbuf
), host_address_to_string (writebuf
),
2345 case TARGET_OBJECT_MEMORY
:
2347 int l
= darwin_read_write_inferior (priv
->task
, offset
,
2348 readbuf
, writebuf
, len
);
2351 return TARGET_XFER_EOF
;
2355 *xfered_len
= (ULONGEST
) l
;
2356 return TARGET_XFER_OK
;
2359 #ifdef TASK_DYLD_INFO_COUNT
2360 case TARGET_OBJECT_DARWIN_DYLD_INFO
:
2361 if (writebuf
!= NULL
|| readbuf
== NULL
)
2363 /* Support only read. */
2364 return TARGET_XFER_E_IO
;
2366 return darwin_read_dyld_info (priv
->task
, offset
, readbuf
, len
,
2370 return TARGET_XFER_E_IO
;
2376 set_enable_mach_exceptions (const char *args
, int from_tty
,
2377 struct cmd_list_element
*c
)
2379 if (inferior_ptid
!= null_ptid
)
2381 struct inferior
*inf
= current_inferior ();
2382 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2383 exception_mask_t mask
;
2386 if (enable_mach_exceptions
)
2387 mask
= EXC_MASK_ALL
;
2390 darwin_restore_exception_ports (priv
);
2391 mask
= EXC_MASK_SOFTWARE
| EXC_MASK_BREAKPOINT
;
2393 kret
= task_set_exception_ports (priv
->task
, mask
, darwin_ex_port
,
2394 EXCEPTION_DEFAULT
, THREAD_STATE_NONE
);
2395 MACH_CHECK_ERROR (kret
);
2400 darwin_nat_target::pid_to_exec_file (int pid
)
2402 static char path
[PATH_MAX
];
2405 res
= proc_pidinfo (pid
, PROC_PIDPATHINFO
, 0, path
, PATH_MAX
);
2413 darwin_nat_target::get_ada_task_ptid (long lwp
, long thread
)
2415 struct inferior
*inf
= current_inferior ();
2416 darwin_inferior
*priv
= get_darwin_inferior (inf
);
2418 mach_port_name_array_t names
;
2419 mach_msg_type_number_t names_count
;
2420 mach_port_type_array_t types
;
2421 mach_msg_type_number_t types_count
;
2424 /* First linear search. */
2425 for (darwin_thread_t
*t
: priv
->threads
)
2427 if (t
->inf_port
== lwp
)
2428 return ptid_t (inferior_ptid
.pid (), 0, t
->gdb_port
);
2431 /* Maybe the port was never extract. Do it now. */
2433 /* First get inferior port names. */
2434 kret
= mach_port_names (priv
->task
, &names
, &names_count
, &types
,
2436 MACH_CHECK_ERROR (kret
);
2437 if (kret
!= KERN_SUCCESS
)
2440 /* For each name, copy the right in the gdb space and then compare with
2441 our view of the inferior threads. We don't forget to deallocate the
2443 for (int i
= 0; i
< names_count
; i
++)
2445 mach_port_t local_name
;
2446 mach_msg_type_name_t local_type
;
2448 /* We just need to know the corresponding name in gdb name space.
2449 So extract and deallocate the right. */
2450 kret
= mach_port_extract_right (priv
->task
, names
[i
],
2451 MACH_MSG_TYPE_COPY_SEND
,
2452 &local_name
, &local_type
);
2453 if (kret
!= KERN_SUCCESS
)
2455 mach_port_deallocate (gdb_task
, local_name
);
2457 for (darwin_thread_t
*t
: priv
->threads
)
2459 if (t
->gdb_port
== local_name
)
2461 t
->inf_port
= names
[i
];
2462 if (names
[i
] == lwp
)
2468 vm_deallocate (gdb_task
, (vm_address_t
) names
,
2469 names_count
* sizeof (mach_port_t
));
2472 return ptid_t (inferior_ptid
.pid (), 0, res
);
2478 darwin_nat_target::supports_multi_process ()
2483 void _initialize_darwin_nat ();
2485 _initialize_darwin_nat ()
2489 gdb_task
= mach_task_self ();
2490 darwin_host_self
= mach_host_self ();
2492 /* Read page size. */
2493 kret
= host_page_size (darwin_host_self
, &mach_page_size
);
2494 if (kret
!= KERN_SUCCESS
)
2496 mach_page_size
= 0x1000;
2497 MACH_CHECK_ERROR (kret
);
2500 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2501 (unsigned long) mach_task_self (), getpid ());
2503 add_setshow_zuinteger_cmd ("darwin", class_obscure
,
2504 &darwin_debug_flag
, _("\
2505 Set if printing inferior communication debugging statements."), _("\
2506 Show if printing inferior communication debugging statements."), NULL
,
2508 &setdebuglist
, &showdebuglist
);
2510 add_setshow_boolean_cmd ("mach-exceptions", class_support
,
2511 &enable_mach_exceptions
, _("\
2512 Set if mach exceptions are caught."), _("\
2513 Show if mach exceptions are caught."), _("\
2514 When this mode is on, all low level exceptions are reported before being\n\
2515 reported by the kernel."),
2516 &set_enable_mach_exceptions
, NULL
,
2517 &setlist
, &showlist
);