GDB (xrefs)
Loading...
Searching...
No Matches
darwin-nat.c
Go to the documentation of this file.
1/* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2023 Free Software Foundation, Inc.
3
4 Contributed by AdaCore.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21#include "defs.h"
22#include "top.h"
23#include "inferior.h"
24#include "target.h"
25#include "symfile.h"
26#include "symtab.h"
27#include "objfiles.h"
28#include "gdbcmd.h"
29#include "gdbcore.h"
30#include "gdbthread.h"
31#include "regcache.h"
32#include "event-top.h"
33#include "inf-loop.h"
34#include <sys/stat.h>
35#include "inf-child.h"
36#include "value.h"
37#include "arch-utils.h"
38#include "bfd.h"
39#include "bfd/mach-o.h"
40#include "gdbarch.h"
41
42#include <copyfile.h>
43#include <sys/ptrace.h>
44#include <sys/signal.h>
45#include <setjmp.h>
46#include <sys/types.h>
47#include <unistd.h>
48#include <signal.h>
49#include <ctype.h>
50#include <sys/sysctl.h>
51#include <sys/proc.h>
52#include <libproc.h>
53#include <sys/syscall.h>
54#include <spawn.h>
55
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>
64
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"
72
73/* Quick overview.
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).
76
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
83 on Mach ports.
84
85 Some Mach documentation is available for Apple xnu source package or
86 from the web. */
87
88
89#define PTRACE(CMD, PID, ADDR, SIG) \
90 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
91
92static void darwin_ptrace_me (void);
93
94static void darwin_encode_reply (mig_reply_error_t *reply,
95 mach_msg_header_t *hdr, integer_t code);
96
99static void darwin_setup_exceptions (struct inferior *inf);
100static void darwin_deallocate_threads (struct inferior *inf);
101
102/* Task identifier of gdb. */
103static task_t gdb_task;
104
105/* A copy of mach_host_self (). */
107
108/* Exception port. */
109mach_port_t darwin_ex_port;
110
111/* Port set, to wait for answer on all ports. */
112mach_port_t darwin_port_set;
113
114/* Page size. */
115static vm_size_t mach_page_size;
116
117/* If Set, catch all mach exceptions (before they are converted to signals
118 by the kernel). */
120
121/* Inferior that should report a fake stop event. */
123
124/* If non-NULL, the shell we actually invoke. See maybe_cache_shell
125 for details. */
126static const char *copied_shell;
127
128#define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
129#define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
130
131/* This controls output of inferior debugging. */
132static unsigned int darwin_debug_flag = 0;
133
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.
136
137 Once gdb is built, you must codesign it with any system-trusted signing
138 authority. See taskgated(8) for details. */
139static 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"
145 "<dict>\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"
153 " <array>\n"
154 " <string>allowed</string>\n"
155 " <string>debug</string>\n"
156 " </array>\n"
157 "</dict>\n"
158 "</plist>\n";
159
160static void inferior_debug (int level, const char *fmt, ...)
161 ATTRIBUTE_PRINTF (2, 3);
162
163static void
164inferior_debug (int level, const char *fmt, ...)
165{
166 va_list ap;
167
168 if (darwin_debug_flag < level)
169 return;
170
171 va_start (ap, fmt);
172 gdb_printf (gdb_stdlog, _("[%d inferior]: "), getpid ());
173 gdb_vprintf (gdb_stdlog, fmt, ap);
174 va_end (ap);
175}
176
177void
178mach_check_error (kern_return_t ret, const char *file,
179 unsigned int line, const char *func)
180{
181 if (ret == KERN_SUCCESS)
182 return;
183 if (func == NULL)
184 func = _("[UNKNOWN]");
185
186 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
187 file, line, func, mach_error_string (ret), (unsigned long) ret);
188}
189
190static const char *
192{
193 static char unknown_exception_buf[32];
194
195 switch (i)
196 {
197 case EXC_BAD_ACCESS:
198 return "EXC_BAD_ACCESS";
199 case EXC_BAD_INSTRUCTION:
200 return "EXC_BAD_INSTRUCTION";
201 case EXC_ARITHMETIC:
202 return "EXC_ARITHMETIC";
203 case EXC_EMULATION:
204 return "EXC_EMULATION";
205 case EXC_SOFTWARE:
206 return "EXC_SOFTWARE";
207 case EXC_BREAKPOINT:
208 return "EXC_BREAKPOINT";
209 case EXC_SYSCALL:
210 return "EXC_SYSCALL";
211 case EXC_MACH_SYSCALL:
212 return "EXC_MACH_SYSCALL";
213 case EXC_RPC_ALERT:
214 return "EXC_RPC_ALERT";
215 case EXC_CRASH:
216 return "EXC_CRASH";
217 default:
218 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
219 return unknown_exception_buf;
220 }
221}
222
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
225 trace.
226
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. */
231
232static int
233darwin_ptrace (const char *name,
234 int request, int pid, caddr_t arg3, int arg4)
235{
236 int ret;
237
238 errno = 0;
239 ret = ptrace (request, pid, arg3, arg4);
240 if (ret == -1 && errno == 0)
241 ret = 0;
242
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"));
246 return ret;
247}
248
249static int
250cmp_thread_t (const void *l, const void *r)
251{
252 thread_t tl = *(const thread_t *)l;
253 thread_t tr = *(const thread_t *)r;
254 return (int)(tl - tr);
255}
256
257void
259{
260 kern_return_t kret;
261 thread_array_t thread_list;
262 unsigned int new_nbr;
263 unsigned int old_nbr;
264 unsigned int new_ix, old_ix;
266 std::vector<darwin_thread_t *> new_thread_vec;
267
268 if (darwin_inf == nullptr)
269 return;
270
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)
275 return;
276
277 /* Sort the list. */
278 if (new_nbr > 1)
279 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
280
281 old_nbr = darwin_inf->threads.size ();
282
283 /* Quick check for no changes. */
284 if (old_nbr == new_nbr)
285 {
286 size_t i;
287
288 for (i = 0; i < new_nbr; i++)
289 if (thread_list[i] != darwin_inf->threads[i]->gdb_port)
290 break;
291 if (i == new_nbr)
292 {
293 /* Deallocate ports. */
294 for (i = 0; i < new_nbr; i++)
295 {
296 kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
297 MACH_CHECK_ERROR (kret);
298 }
299
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);
304
305 return;
306 }
307 }
308
309 /* Full handling: detect new threads, remove dead threads. */
310
311 new_thread_vec.reserve (new_nbr);
312
313 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
314 {
315 thread_t new_id = (new_ix < new_nbr) ? thread_list[new_ix] : THREAD_NULL;
316 darwin_thread_t *old
317 = (old_ix < old_nbr) ? darwin_inf->threads[old_ix] : NULL;
318 thread_t old_id = old != NULL ? old->gdb_port : THREAD_NULL;
319
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);
323
324 if (old_id == new_id)
325 {
326 /* Thread still exist. */
327 new_thread_vec.push_back (old);
328 new_ix++;
329 old_ix++;
330
331 /* Deallocate the port. */
332 kret = mach_port_deallocate (gdb_task, new_id);
333 MACH_CHECK_ERROR (kret);
334
335 continue;
336 }
337 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
338 {
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. */
342 new_ix++;
343 continue;
344 }
345 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
346 {
347 /* A thread was created. */
349
350 pti->gdb_port = new_id;
352
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);
356 new_ix++;
357 continue;
358 }
359 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
360 {
361 /* A thread was removed. */
362 struct thread_info *thr
363 = find_thread_ptid (this, ptid_t (inf->pid, 0, old_id));
364 delete_thread (thr);
365 kret = mach_port_deallocate (gdb_task, old_id);
366 MACH_CHECK_ERROR (kret);
367 old_ix++;
368 continue;
369 }
370 gdb_assert_not_reached ("unexpected thread case");
371 }
372
373 darwin_inf->threads = std::move (new_thread_vec);
374
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);
379}
380
381/* Return an inferior by task port. */
382static struct inferior *
384{
385 for (inferior *inf : all_inferiors ())
386 {
388
389 if (priv != nullptr && priv->task == port)
390 return inf;
391 }
392 return nullptr;
393}
394
395/* Return an inferior by pid port. */
396static struct inferior *
398{
399 for (inferior *inf : all_inferiors ())
400 {
401 if (inf->pid == pid)
402 return inf;
403 }
404 return nullptr;
405}
406
407/* Return a thread by port. */
408static darwin_thread_t *
410{
412
413 if (priv != nullptr)
414 for (darwin_thread_t *t : priv->threads)
415 {
416 if (t->gdb_port == thread)
417 return t;
418 }
419
420 return NULL;
421}
422
423/* Suspend (ie stop) an inferior at Mach level. */
424
425static void
427{
429
430 if (priv != nullptr && !priv->suspended)
431 {
432 kern_return_t kret;
433
434 kret = task_suspend (priv->task);
435 MACH_CHECK_ERROR (kret);
436
437 priv->suspended = 1;
438 }
439}
440
441/* Resume an inferior at Mach level. */
442
443static void
445{
447
448 if (priv != nullptr && priv->suspended)
449 {
450 kern_return_t kret;
451
452 kret = task_resume (priv->task);
453 MACH_CHECK_ERROR (kret);
454
455 priv->suspended = 0;
456 }
457}
458
459static void
460darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
461{
463 _("message header:\n"));
465 _(" bits: 0x%x\n"), hdr->msgh_bits);
467 _(" size: 0x%x\n"), hdr->msgh_size);
469 _(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
471 _(" local-port: 0x%x\n"), hdr->msgh_local_port);
473 _(" reserved: 0x%x\n"), hdr->msgh_reserved);
475 _(" id: 0x%x\n"), hdr->msgh_id);
476
477 if (disp_body)
478 {
479 const unsigned char *data;
480 const unsigned int *ldata;
481 int size;
482 int i;
483
484 data = (unsigned char *)(hdr + 1);
485 size = hdr->msgh_size - sizeof (mach_msg_header_t);
486
487 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
488 {
489 mach_msg_body_t *bod = (mach_msg_body_t*)data;
490 mach_msg_port_descriptor_t *desc =
491 (mach_msg_port_descriptor_t *)(bod + 1);
492 int k;
493 NDR_record_t *ndr;
495 _("body: descriptor_count=%u\n"),
496 bod->msgh_descriptor_count);
497 data += sizeof (mach_msg_body_t);
498 size -= sizeof (mach_msg_body_t);
499 for (k = 0; k < bod->msgh_descriptor_count; k++)
500 switch (desc[k].type)
501 {
502 case MACH_MSG_PORT_DESCRIPTOR:
504 (gdb_stdlog,
505 _(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
506 k, desc[k].type, desc[k].name, desc[k].disposition);
507 break;
508 default:
510 _(" descr %d: type=%u\n"),
511 k, desc[k].type);
512 break;
513 }
514 data += bod->msgh_descriptor_count
515 * sizeof (mach_msg_port_descriptor_t);
516 size -= bod->msgh_descriptor_count
517 * sizeof (mach_msg_port_descriptor_t);
518 ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
520 (gdb_stdlog,
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);
527 }
528
529 gdb_printf (gdb_stdlog, _(" data:"));
530 ldata = (const unsigned int *)data;
531 for (i = 0; i < size / sizeof (unsigned int); i++)
532 gdb_printf (gdb_stdlog, " %08x", ldata[i]);
533 gdb_printf (gdb_stdlog, _("\n"));
534 }
535}
536
537/* Adjust inferior data when a new task was created. */
538
539static struct inferior *
540darwin_find_new_inferior (task_t task_port, thread_t thread_port)
541{
542 int task_pid;
543 struct inferior *inf;
544 kern_return_t kret;
545 mach_port_t prev;
546
547 /* Find the corresponding pid. */
548 kret = pid_for_task (task_port, &task_pid);
549 if (kret != KERN_SUCCESS)
550 {
551 MACH_CHECK_ERROR (kret);
552 return NULL;
553 }
554
555 /* Find the inferior for this pid. */
556 inf = darwin_find_inferior_by_pid (task_pid);
557 if (inf == NULL)
558 return NULL;
559
561
562 /* Deallocate saved exception ports. */
564
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,
568 MACH_PORT_NULL,
569 MACH_MSG_TYPE_MAKE_SEND_ONCE,
570 &prev);
571 if (kret != KERN_INVALID_ARGUMENT)
572 MACH_CHECK_ERROR (kret);
573
574 /* Replace old task port. */
575 kret = mach_port_deallocate (gdb_task, priv->task);
576 MACH_CHECK_ERROR (kret);
577 priv->task = task_port;
578
581
582 return inf;
583}
584
585/* Check data representation. */
586
587static int
588darwin_check_message_ndr (NDR_record_t *ndr)
589{
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)
596 return -1;
597 return 0;
598}
599
600/* Decode an exception message. */
601
602int
604 inferior **pinf,
605 darwin_thread_t **pthread)
606{
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);
609 NDR_record_t *ndr;
610 integer_t *data;
611 struct inferior *inf;
612 darwin_thread_t *thread;
613 task_t task_port;
614 thread_t thread_port;
615 kern_return_t kret;
616 int i;
617
618 /* Check message destination. */
619 if (hdr->msgh_local_port != darwin_ex_port)
620 return -1;
621
622 /* Check message header. */
623 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
624 return -1;
625
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)
634 return -1;
635
636 /* Check data representation. */
637 ndr = (NDR_record_t *)(desc + 2);
638 if (darwin_check_message_ndr (ndr) != 0)
639 return -1;
640
641 /* Ok, the hard work. */
642 data = (integer_t *)(ndr + 1);
643
644 task_port = desc[1].name;
645 thread_port = desc[0].name;
646
647 /* Find process by port. */
648 inf = darwin_find_inferior_by_task (task_port);
649 *pinf = inf;
650
651 if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
652 && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
653 {
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);
657 *pinf = inf;
658
659 if (inf == NULL)
660 {
661 /* Deallocate task_port, unless it was saved. */
662 kret = mach_port_deallocate (mach_task_self (), task_port);
663 MACH_CHECK_ERROR (kret);
664 }
665 }
666 else
667 {
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);
672 }
673
674 if (inf == NULL)
675 {
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;
680
682 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
683 task_port);
684
685 /* Free thread port (we don't know it). */
686 kret = mach_port_deallocate (mach_task_self (), thread_port);
687 MACH_CHECK_ERROR (kret);
688
689 darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
690
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,
694 MACH_PORT_NULL);
695 MACH_CHECK_ERROR (kret);
696
697 return 0;
698 }
699
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. */
704
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);
709
710 thread = darwin_find_thread (inf, thread_port);
711 if (thread == NULL)
712 return -1;
713 *pthread = thread;
714
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);
718
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];
725
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)))
729 return -1;
730 for (i = 0; i < data[1]; i++)
731 thread->event.ex_data[i] = data[2 + i];
732
733 thread->msg_state = DARWIN_MESSAGE;
734
735 return 0;
736}
737
738/* Decode dead_name notify message. */
739
740static int
741darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
742{
743 NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
744 integer_t *data = (integer_t *)(ndr + 1);
745 struct inferior *inf;
746 task_t task_port;
747
748 /* Check message header. */
749 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
750 return -1;
751
752 /* Check descriptors. */
753 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
754 return -2;
755
756 /* Check data representation. */
757 if (darwin_check_message_ndr (ndr) != 0)
758 return -3;
759
760 task_port = data[0];
761
762 /* Find process by port. */
763 inf = darwin_find_inferior_by_task (task_port);
764 *pinf = inf;
765
766 /* Check message destination. */
767 if (inf != NULL)
768 {
770 if (hdr->msgh_local_port != priv->notify_port)
771 return -4;
772 }
773
774 return 0;
775}
776
777static void
778darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
779 integer_t code)
780{
781 mach_msg_header_t *rh = &reply->Head;
782
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;
788
789 reply->NDR = NDR_record;
790 reply->RetCode = code;
791}
792
793static void
795{
796 kern_return_t kret;
797 mig_reply_error_t reply;
799
800 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
801
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,
805 MACH_PORT_NULL);
806 MACH_CHECK_ERROR (kret);
807
808 priv->pending_messages--;
809}
810
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. */
814
815static int
817{
818 DIAGNOSTIC_PUSH;
819 DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS;
820 int res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
821 DIAGNOSTIC_POP;
822 return res;
823}
824
825static void
827 int step, int nsignal)
828{
830 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
831 thread->msg_state, thread->gdb_port, step, nsignal);
832
833 switch (thread->msg_state)
834 {
835 case DARWIN_MESSAGE:
836 if (thread->event.ex_type == EXC_SOFTWARE
837 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
838 {
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);
842 if (res < 0)
843 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
844 }
845 else if (nsignal)
846 {
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;
853 }
854
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;
860
861 darwin_send_reply (inf, thread);
862 thread->msg_state = DARWIN_RUNNING;
863 break;
864
865 case DARWIN_RUNNING:
866 break;
867
868 case DARWIN_STOPPED:
869 kern_return_t kret = thread_resume (thread->gdb_port);
870 MACH_CHECK_ERROR (kret);
871
872 thread->msg_state = DARWIN_RUNNING;
873 break;
874 }
875}
876
877/* Resume all threads of the inferior. */
878
879static void
880darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
881{
883
884 if (priv != nullptr)
885 for (darwin_thread_t *thread : priv->threads)
886 darwin_resume_thread (inf, thread, step, nsignal);
887}
888
889/* Suspend all threads of INF. */
890
891static void
893{
895
896 for (darwin_thread_t *thread : priv->threads)
897 {
898 switch (thread->msg_state)
899 {
900 case DARWIN_STOPPED:
901 case DARWIN_MESSAGE:
902 break;
903 case DARWIN_RUNNING:
904 {
905 kern_return_t kret = thread_suspend (thread->gdb_port);
906 MACH_CHECK_ERROR (kret);
907 thread->msg_state = DARWIN_STOPPED;
908 break;
909 }
910 }
911 }
912}
913
914void
915darwin_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
916{
917 int nsignal;
918
920 (2, _("darwin_resume: ptid=%s, step=%d, signal=%d\n"),
921 ptid.to_string ().c_str (), step, signal);
922
923 if (signal == GDB_SIGNAL_0)
924 nsignal = 0;
925 else
926 nsignal = gdb_signal_to_host (signal);
927
928 /* Don't try to single step all threads. */
929 if (step)
930 ptid = inferior_ptid;
931
932 /* minus_one_ptid is RESUME_ALL. */
933 if (ptid == minus_one_ptid)
934 {
935 /* Resume threads. */
936 for (inferior *inf : all_inferiors ())
937 darwin_resume_inferior_threads (inf, step, nsignal);
938
939 /* Resume tasks. */
940 for (inferior *inf : all_inferiors ())
942 }
943 else
944 {
945 inferior *inf = find_inferior_ptid (this, ptid);
946 long tid = ptid.tid ();
947
948 /* Stop the inferior (should be useless). */
950
951 if (tid == 0)
952 darwin_resume_inferior_threads (inf, step, nsignal);
953 else
954 {
955 darwin_thread_t *thread;
956
957 /* Suspend threads of the task. */
959
960 /* Resume the selected thread. */
961 thread = darwin_find_thread (inf, tid);
962 gdb_assert (thread);
963 darwin_resume_thread (inf, thread, step, nsignal);
964 }
965
966 /* Resume the task. */
968 }
969}
970
971ptid_t
972darwin_nat_target::decode_message (mach_msg_header_t *hdr,
973 darwin_thread_t **pthread,
974 inferior **pinf,
976{
977 darwin_thread_t *thread;
978 struct inferior *inf;
979
980 /* Exception message. 2401 == 0x961 is exc. */
981 if (hdr->msgh_id == 2401)
982 {
983 int res;
984
985 /* Decode message. */
986 res = decode_exception_message (hdr, &inf, &thread);
987
988 if (res < 0)
989 {
990 /* Should not happen... */
991 warning (_("darwin_wait: ill-formatted message (id=0x%x)\n"),
992 hdr->msgh_id);
993 /* FIXME: send a failure reply? */
994 status->set_ignore ();
995 return minus_one_ptid;
996 }
997 if (inf == NULL)
998 {
999 status->set_ignore ();
1000 return minus_one_ptid;
1001 }
1002 *pinf = inf;
1003 *pthread = thread;
1004
1006
1007 priv->pending_messages++;
1008
1009 thread->msg_state = DARWIN_MESSAGE;
1010
1011 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1012 thread->gdb_port,
1013 unparse_exception_type (thread->event.ex_type));
1014
1015 switch (thread->event.ex_type)
1016 {
1017 case EXC_BAD_ACCESS:
1018 status->set_stopped (GDB_EXC_BAD_ACCESS);
1019 break;
1020 case EXC_BAD_INSTRUCTION:
1021 status->set_stopped (GDB_EXC_BAD_INSTRUCTION);
1022 break;
1023 case EXC_ARITHMETIC:
1024 status->set_stopped (GDB_EXC_ARITHMETIC);
1025 break;
1026 case EXC_EMULATION:
1027 status->set_stopped (GDB_EXC_EMULATION);
1028 break;
1029 case EXC_SOFTWARE:
1030 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1031 {
1032 status->set_stopped
1033 (gdb_signal_from_host (thread->event.ex_data[1]));
1034 inferior_debug (5, _(" (signal %d: %s)\n"),
1035 thread->event.ex_data[1],
1036 gdb_signal_to_name (status->sig ()));
1037
1038 /* If the thread is stopped because it has received a signal
1039 that gdb has just sent, continue. */
1040 if (thread->signaled)
1041 {
1042 thread->signaled = 0;
1043 darwin_send_reply (inf, thread);
1044 thread->msg_state = DARWIN_RUNNING;
1045 status->set_ignore ();
1046 }
1047 }
1048 else
1049 status->set_stopped (GDB_EXC_SOFTWARE);
1050 break;
1051 case EXC_BREAKPOINT:
1052 /* Many internal GDB routines expect breakpoints to be reported
1053 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1054 as a spurious signal. */
1055 status->set_stopped (GDB_SIGNAL_TRAP);
1056 break;
1057 default:
1058 status->set_stopped (GDB_SIGNAL_UNKNOWN);
1059 break;
1060 }
1061
1062 return ptid_t (inf->pid, 0, thread->gdb_port);
1063 }
1064 else if (hdr->msgh_id == 0x48)
1065 {
1066 /* MACH_NOTIFY_DEAD_NAME: notification for exit *or* WIFSTOPPED. */
1067 int res;
1068
1069 res = darwin_decode_notify_message (hdr, &inf);
1070
1071 if (res < 0)
1072 {
1073 /* Should not happen... */
1074 warning
1075 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1076 hdr->msgh_id, res);
1077 }
1078
1079 *pinf = NULL;
1080 *pthread = NULL;
1081
1082 if (res < 0 || inf == NULL)
1083 {
1084 status->set_ignore ();
1085 return minus_one_ptid;
1086 }
1087
1088 if (inf != NULL)
1089 {
1091
1092 if (!priv->no_ptrace)
1093 {
1094 pid_t res_pid;
1095 int wstatus;
1096
1097 res_pid = wait4 (inf->pid, &wstatus, 0, NULL);
1098 if (res_pid < 0 || res_pid != inf->pid)
1099 {
1100 warning (_("wait4: res=%d: %s\n"),
1101 res_pid, safe_strerror (errno));
1102 status->set_ignore ();
1103 return minus_one_ptid;
1104 }
1105 if (WIFEXITED (wstatus))
1106 {
1107 status->set_exited (WEXITSTATUS (wstatus));
1108 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1109 res_pid, wstatus);
1110 }
1111 else if (WIFSTOPPED (wstatus))
1112 {
1113 /* Ignore stopped state, it will be handled by the next
1114 exception. */
1115 status->set_ignore ();
1116 inferior_debug (4, _("darwin_wait: pid %d received WIFSTOPPED\n"),
1117 res_pid);
1118 return minus_one_ptid;
1119 }
1120 else if (WIFSIGNALED (wstatus))
1121 {
1122 status->set_signalled
1123 (gdb_signal_from_host (WTERMSIG (wstatus)));
1124 inferior_debug (4, _("darwin_wait: pid=%d received signal %d\n"),
1125 res_pid, status->sig());
1126 }
1127 else
1128 {
1129 status->set_ignore ();
1130 warning (_("Unexpected wait status after MACH_NOTIFY_DEAD_NAME "
1131 "notification: 0x%x"), wstatus);
1132 return minus_one_ptid;
1133 }
1134
1135 return ptid_t (inf->pid);
1136 }
1137 else
1138 {
1139 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1140 status->set_exited (0 /* Don't know. */);
1141 return ptid_t (inf->pid, 0, 0);
1142 }
1143 }
1144 }
1145
1146 /* Unknown message. */
1147 warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1148 status->set_ignore ();
1149 return minus_one_ptid;
1150}
1151
1152int
1154{
1155 /* Arrange for a breakpoint to be hit again later. We will handle
1156 the current event, eventually we will resume this thread, and this
1157 breakpoint will trap again.
1158
1159 If we do not do this, then we run the risk that the user will
1160 delete or disable the breakpoint, but the thread will have already
1161 tripped on it. */
1162
1163 struct regcache *regcache = get_thread_regcache (this, ptid);
1164 struct gdbarch *gdbarch = regcache->arch ();
1165 CORE_ADDR pc;
1166
1169 {
1170 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1171 (unsigned long) ptid.tid ());
1172
1173 /* Back up the PC if necessary. */
1176
1177 return 1;
1178 }
1179 return 0;
1180}
1181
1182ptid_t
1184{
1185 kern_return_t kret;
1186 union
1187 {
1188 mach_msg_header_t hdr;
1189 char data[0x100];
1190 } msgin;
1191 mach_msg_header_t *hdr = &msgin.hdr;
1192 ptid_t res;
1193 darwin_thread_t *thread;
1194
1196 (2, _("darwin_wait: waiting for a message ptid=%s\n"),
1197 ptid.to_string ().c_str ());
1198
1199 /* Handle fake stop events at first. */
1200 if (darwin_inf_fake_stop != NULL)
1201 {
1203 darwin_inf_fake_stop = NULL;
1204
1206
1207 status->set_stopped (GDB_SIGNAL_TRAP);
1208 thread = priv->threads[0];
1209 thread->msg_state = DARWIN_STOPPED;
1210 return ptid_t (inf->pid, 0, thread->gdb_port);
1211 }
1212
1213 do
1214 {
1215 /* set_sigint_trap (); */
1216
1217 /* Wait for a message. */
1218 kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1219 sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1220
1221 /* clear_sigint_trap (); */
1222
1223 if (kret == MACH_RCV_INTERRUPTED)
1224 {
1225 status->set_ignore ();
1226 return minus_one_ptid;
1227 }
1228
1229 if (kret != MACH_MSG_SUCCESS)
1230 {
1231 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1232 status->set_spurious ();
1233 return minus_one_ptid;
1234 }
1235
1236 /* Debug: display message. */
1237 if (darwin_debug_flag > 10)
1239
1240 inferior *inf;
1241 res = decode_message (hdr, &thread, &inf, status);
1242 if (res == minus_one_ptid)
1243 continue;
1244
1245 /* Early return in case an inferior has exited. */
1246 if (inf == NULL)
1247 return res;
1248 }
1249 while (status->kind () == TARGET_WAITKIND_IGNORE);
1250
1251 /* Stop all tasks. */
1252 for (inferior *inf : all_inferiors (this))
1253 {
1256 }
1257
1258 /* Read pending messages. */
1259 while (1)
1260 {
1261 struct target_waitstatus status2;
1262 ptid_t ptid2;
1263
1264 kret = mach_msg (&msgin.hdr,
1265 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1266 sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1267
1268 if (kret == MACH_RCV_TIMED_OUT)
1269 break;
1270 if (kret != MACH_MSG_SUCCESS)
1271 {
1273 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1274 break;
1275 }
1276
1277 /* Debug: display message. */
1278 if (darwin_debug_flag > 10)
1280
1281 inferior *inf;
1282 ptid2 = decode_message (hdr, &thread, &inf, &status2);
1283
1284 if (inf != NULL && thread != NULL
1285 && thread->event.ex_type == EXC_BREAKPOINT)
1286 {
1287 if (thread->single_step
1288 || cancel_breakpoint (ptid_t (inf->pid, 0, thread->gdb_port)))
1289 {
1290 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1291 darwin_send_reply (inf, thread);
1292 thread->msg_state = DARWIN_RUNNING;
1293 }
1294 else
1296 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1297 thread->gdb_port);
1298 }
1299 else
1300 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1301 }
1302 return res;
1303}
1304
1305ptid_t
1307 target_wait_flags options)
1308{
1309 return wait_1 (ptid, status);
1310}
1311
1312void
1314{
1315 struct inferior *inf = current_inferior ();
1317
1318 /* FIXME: handle in no_ptrace mode. */
1319 gdb_assert (!priv->no_ptrace);
1320 ::kill (inf->pid, SIGINT);
1321}
1322
1323/* Deallocate threads port and vector. */
1324
1325static void
1327{
1329
1330 for (darwin_thread_t *t : priv->threads)
1331 {
1332 kern_return_t kret = mach_port_deallocate (gdb_task, t->gdb_port);
1333 MACH_CHECK_ERROR (kret);
1334 }
1335
1336 priv->threads.clear ();
1337}
1338
1339void
1341{
1342 struct inferior *inf = current_inferior ();
1344 kern_return_t kret;
1345 mach_port_t prev;
1346
1347 /* Deallocate threads. */
1349
1350 /* Remove notify_port from darwin_port_set. */
1351 kret = mach_port_move_member (gdb_task,
1352 priv->notify_port, MACH_PORT_NULL);
1353 MACH_CHECK_ERROR (kret);
1354
1355 /* Remove task port dead_name notification. */
1356 kret = mach_port_request_notification (gdb_task, priv->task,
1357 MACH_NOTIFY_DEAD_NAME, 0,
1358 MACH_PORT_NULL,
1359 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1360 &prev);
1361 /* This can fail if the task is dead. */
1362 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1363 priv->task, prev, priv->notify_port);
1364
1365 if (kret == KERN_SUCCESS)
1366 {
1367 kret = mach_port_deallocate (gdb_task, prev);
1368 MACH_CHECK_ERROR (kret);
1369 }
1370
1371 /* Destroy notify_port. */
1372 kret = mach_port_destroy (gdb_task, priv->notify_port);
1373 MACH_CHECK_ERROR (kret);
1374
1375 /* Deallocate saved exception ports. */
1377
1378 /* Deallocate task port. */
1379 kret = mach_port_deallocate (gdb_task, priv->task);
1380 MACH_CHECK_ERROR (kret);
1381
1382 inf->priv = NULL;
1383
1385}
1386
1387static void
1389{
1391
1392 for (darwin_thread_t *t : priv->threads)
1393 {
1394 if (t->msg_state == DARWIN_MESSAGE)
1395 darwin_resume_thread (inf, t, 0, 0);
1396 }
1397}
1398
1399void
1401{
1402 struct target_waitstatus wstatus;
1403 ptid_t ptid;
1404 int res;
1406
1407 gdb_assert (inf != NULL);
1408
1410
1412
1413 if (priv->no_ptrace)
1414 return;
1415
1416 res = ::kill (inf->pid, SIGSTOP);
1417 if (res != 0)
1418 warning (_("cannot kill: %s"), safe_strerror (errno));
1419
1420 /* Wait until the process is really stopped. */
1421 while (1)
1422 {
1423 ptid = wait_1 (ptid_t (inf->pid), &wstatus);
1424 if (wstatus.kind () == TARGET_WAITKIND_STOPPED
1425 && wstatus.sig () == GDB_SIGNAL_STOP)
1426 break;
1427 }
1428}
1429
1430static kern_return_t
1432{
1433 kern_return_t kret;
1434
1435 inf->exception_info.count =
1436 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1437
1438 kret = task_get_exception_ports
1439 (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1440 &inf->exception_info.count, inf->exception_info.ports,
1441 inf->exception_info.behaviors, inf->exception_info.flavors);
1442 return kret;
1443}
1444
1445static kern_return_t
1447{
1448 int i;
1449 kern_return_t kret;
1450
1451 for (i = 0; i < inf->exception_info.count; i++)
1452 {
1453 kret = task_set_exception_ports
1454 (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1455 inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1456 if (kret != KERN_SUCCESS)
1457 return kret;
1458 }
1459
1460 return KERN_SUCCESS;
1461}
1462
1463/* Deallocate saved exception ports. */
1464
1465static void
1467{
1468 int i;
1469 kern_return_t kret;
1470
1471 for (i = 0; i < inf->exception_info.count; i++)
1472 {
1473 kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1474 MACH_CHECK_ERROR (kret);
1475 }
1476 inf->exception_info.count = 0;
1477}
1478
1479static void
1481{
1483 kern_return_t kret;
1484 exception_mask_t mask;
1485
1486 kret = darwin_save_exception_ports (priv);
1487 if (kret != KERN_SUCCESS)
1488 error (_("Unable to save exception ports, task_get_exception_ports"
1489 "returned: %d"),
1490 kret);
1491
1492 /* Set exception port. */
1494 mask = EXC_MASK_ALL;
1495 else
1496 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1497 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
1498 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1499 if (kret != KERN_SUCCESS)
1500 error (_("Unable to set exception ports, task_set_exception_ports"
1501 "returned: %d"),
1502 kret);
1503}
1504
1505void
1507{
1508 struct inferior *inf = current_inferior ();
1510 struct target_waitstatus wstatus;
1511 ptid_t ptid;
1512 kern_return_t kret;
1513 int res;
1514
1515 if (inferior_ptid == null_ptid)
1516 return;
1517
1518 gdb_assert (inf != NULL);
1519
1520 kret = darwin_restore_exception_ports (priv);
1521 MACH_CHECK_ERROR (kret);
1522
1524
1525 res = ::kill (inf->pid, 9);
1526
1527 if (res == 0)
1528 {
1529 /* On MacOS version Sierra, the darwin_restore_exception_ports call
1530 does not work as expected.
1531 When the kill function is called, the SIGKILL signal is received
1532 by gdb whereas it should have been received by the kernel since
1533 the exception ports have been restored.
1534 This behavior is not the expected one thus gdb does not reply to
1535 the received SIGKILL message. This situation leads to a "busy"
1536 resource from the kernel point of view and the inferior is never
1537 released, causing it to remain as a zombie process, even after
1538 GDB exits.
1539 To work around this, we mark all the threads of the inferior as
1540 signaled thus darwin_decode_message function knows that the kill
1541 signal was sent by gdb and will take the appropriate action
1542 (cancel signal and reply to the signal message). */
1543 for (darwin_thread_t *thread : priv->threads)
1544 thread->signaled = 1;
1545
1547
1548 ptid = wait_1 (ptid_t (inf->pid), &wstatus);
1549 }
1550 else if (errno != ESRCH)
1551 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1552 inf->pid, safe_strerror (errno));
1553
1554 target_mourn_inferior (ptid_t (inf->pid));
1555}
1556
1557static void
1559{
1561 kern_return_t kret;
1562 mach_port_t prev_not;
1563
1564 kret = mach_port_request_notification (gdb_task, priv->task,
1565 MACH_NOTIFY_DEAD_NAME, 0,
1566 priv->notify_port,
1567 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1568 &prev_not);
1569 if (kret != KERN_SUCCESS)
1570 error (_("Termination notification request failed, "
1571 "mach_port_request_notification\n"
1572 "returned: %d"),
1573 kret);
1574 if (prev_not != MACH_PORT_NULL)
1575 {
1576 /* This is unexpected, as there should not be any previously
1577 registered notification request. But this is not a fatal
1578 issue, so just emit a warning. */
1579 warning (_("\
1580A task termination request was registered before the debugger registered\n\
1581its own. This is unexpected, but should otherwise not have any actual\n\
1582impact on the debugging session."));
1583 }
1584}
1585
1586static void
1588{
1589 kern_return_t kret;
1590
1591 darwin_inferior *priv = new darwin_inferior;
1592 inf->priv.reset (priv);
1593
1594 try
1595 {
1596 kret = task_for_pid (gdb_task, inf->pid, &priv->task);
1597 if (kret != KERN_SUCCESS)
1598 {
1599 int status;
1600
1601 if (!inf->attach_flag)
1602 {
1603 kill (inf->pid, 9);
1604 waitpid (inf->pid, &status, 0);
1605 }
1606
1607 error
1608 (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1609 " (please check gdb is codesigned - see taskgated(8))"),
1610 inf->pid, mach_error_string (kret), (unsigned long) kret);
1611 }
1612
1613 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1614 priv->task, inf->pid);
1615
1616 if (darwin_ex_port == MACH_PORT_NULL)
1617 {
1618 /* Create a port to get exceptions. */
1619 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1621 if (kret != KERN_SUCCESS)
1622 error (_("Unable to create exception port, mach_port_allocate "
1623 "returned: %d"),
1624 kret);
1625
1626 kret = mach_port_insert_right (gdb_task, darwin_ex_port,
1628 MACH_MSG_TYPE_MAKE_SEND);
1629 if (kret != KERN_SUCCESS)
1630 error (_("Unable to create exception port, mach_port_insert_right "
1631 "returned: %d"),
1632 kret);
1633
1634 /* Create a port set and put ex_port in it. */
1635 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1637 if (kret != KERN_SUCCESS)
1638 error (_("Unable to create port set, mach_port_allocate "
1639 "returned: %d"),
1640 kret);
1641
1642 kret = mach_port_move_member (gdb_task, darwin_ex_port,
1644 if (kret != KERN_SUCCESS)
1645 error (_("Unable to move exception port into new port set, "
1646 "mach_port_move_member\n"
1647 "returned: %d"),
1648 kret);
1649 }
1650
1651 /* Create a port to be notified when the child task terminates. */
1652 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1653 &priv->notify_port);
1654 if (kret != KERN_SUCCESS)
1655 error (_("Unable to create notification port, mach_port_allocate "
1656 "returned: %d"),
1657 kret);
1658
1659 kret = mach_port_move_member (gdb_task,
1661 if (kret != KERN_SUCCESS)
1662 error (_("Unable to move notification port into new port set, "
1663 "mach_port_move_member\n"
1664 "returned: %d"),
1665 kret);
1666
1668
1670 }
1671 catch (const gdb_exception &ex)
1672 {
1675
1676 throw;
1677 }
1678
1679 target_ops *darwin_ops = get_native_target ();
1680 if (!inf->target_is_pushed (darwin_ops))
1681 inf->push_target (darwin_ops);
1682}
1683
1684/* Get the thread_info object corresponding to this darwin_thread_info. */
1685
1686static struct thread_info *
1688{
1689 for (struct thread_info *it : all_threads ())
1690 {
1692
1693 if (iter_pti->gdb_port == pti->gdb_port)
1694 return it;
1695 }
1696
1697 gdb_assert_not_reached ("did not find gdb thread for darwin thread");
1698}
1699
1700void
1702{
1704
1706
1707 gdb_assert (!priv->threads.empty ());
1708
1709 darwin_thread_info *first_pti = priv->threads.front ();
1710 struct thread_info *first_thread
1712
1713 switch_to_thread (first_thread);
1714}
1715
1716/* The child must synchronize with gdb: gdb must set the exception port
1717 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1718 FIXME: is there a lighter way ? */
1719static int ptrace_fds[2];
1720
1721static void
1723{
1724 int res;
1725 char c;
1726
1727 /* Close write end point. */
1728 if (close (ptrace_fds[1]) < 0)
1730
1731 /* Wait until gdb is ready. */
1732 res = read (ptrace_fds[0], &c, 1);
1733 if (res != 0)
1734 trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1735
1736 if (close (ptrace_fds[0]) < 0)
1738
1739 /* Get rid of privileges. */
1740 if (setegid (getgid ()) < 0)
1741 trace_start_error_with_name ("setegid");
1742
1743 /* Set TRACEME. */
1744 if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1745 trace_start_error_with_name ("PTRACE");
1746
1747 /* Redirect signals to exception port. */
1748 if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1749 trace_start_error_with_name ("PTRACE");
1750}
1751
1752/* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1753static void
1755{
1756 if (pipe (ptrace_fds) != 0)
1757 {
1758 ptrace_fds[0] = -1;
1759 ptrace_fds[1] = -1;
1760 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1761 }
1762
1763 mark_fd_no_cloexec (ptrace_fds[0]);
1764 mark_fd_no_cloexec (ptrace_fds[1]);
1765}
1766
1767void
1769{
1770 struct inferior *inf = current_inferior ();
1771
1773
1774 /* Let's the child run. */
1775 ::close (ptrace_fds[0]);
1776 ::close (ptrace_fds[1]);
1777
1778 unmark_fd_no_cloexec (ptrace_fds[0]);
1779 unmark_fd_no_cloexec (ptrace_fds[1]);
1780
1782
1784}
1785
1786static void
1787darwin_execvp (const char *file, char * const argv[], char * const env[])
1788{
1789 posix_spawnattr_t attr;
1790 short ps_flags = 0;
1791 int res;
1792
1793 res = posix_spawnattr_init (&attr);
1794 if (res != 0)
1795 {
1797 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1798 return;
1799 }
1800
1801 /* Do like execve: replace the image. */
1802 ps_flags = POSIX_SPAWN_SETEXEC;
1803
1804 /* Disable ASLR. The constant doesn't look to be available outside the
1805 kernel include files. */
1806#ifndef _POSIX_SPAWN_DISABLE_ASLR
1807#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1808#endif
1809 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1810 res = posix_spawnattr_setflags (&attr, ps_flags);
1811 if (res != 0)
1812 {
1813 gdb_printf (gdb_stderr, "Cannot set posix_spawn flags\n");
1814 return;
1815 }
1816
1817 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1818}
1819
1820/* Read kernel version, and return TRUE if this host may have System
1821 Integrity Protection (Sierra or later). */
1822
1823static bool
1825{
1826 char str[16];
1827 size_t sz = sizeof (str);
1828 int ret;
1829
1830 ret = sysctlbyname ("kern.osrelease", str, &sz, NULL, 0);
1831 if (ret == 0 && sz < sizeof (str))
1832 {
1833 unsigned long ver = strtoul (str, NULL, 10);
1834 if (ver >= 16)
1835 return true;
1836 }
1837 return false;
1838}
1839
1840/* A helper for maybe_cache_shell. This copies the shell to the
1841 cache. It will throw an exception on any failure. */
1842
1843static void
1844copy_shell_to_cache (const char *shell, const std::string &new_name)
1845{
1846 scoped_fd from_fd = gdb_open_cloexec (shell, O_RDONLY, 0);
1847 if (from_fd.get () < 0)
1848 error (_("Could not open shell (%s) for reading: %s"),
1849 shell, safe_strerror (errno));
1850
1851 std::string new_dir = ldirname (new_name.c_str ());
1852 if (!mkdir_recursive (new_dir.c_str ()))
1853 error (_("Could not make cache directory \"%s\": %s"),
1854 new_dir.c_str (), safe_strerror (errno));
1855
1856 gdb::char_vector temp_name = make_temp_filename (new_name);
1857 scoped_fd to_fd = gdb_mkostemp_cloexec (&temp_name[0]);
1858 gdb::unlinker unlink_file_on_error (temp_name.data ());
1859
1860 if (to_fd.get () < 0)
1861 error (_("Could not open temporary file \"%s\" for writing: %s"),
1862 temp_name.data (), safe_strerror (errno));
1863
1864 if (fcopyfile (from_fd.get (), to_fd.get (), nullptr,
1865 COPYFILE_STAT | COPYFILE_DATA) != 0)
1866 error (_("Could not copy shell to cache as \"%s\": %s"),
1867 temp_name.data (), safe_strerror (errno));
1868
1869 /* Be sure that the caching is atomic so that we don't get bad
1870 results from multiple copies of gdb running at the same time. */
1871 if (rename (temp_name.data (), new_name.c_str ()) != 0)
1872 error (_("Could not rename shell cache file to \"%s\": %s"),
1873 new_name.c_str (), safe_strerror (errno));
1874
1875 unlink_file_on_error.keep ();
1876}
1877
1878/* If $SHELL is restricted, try to cache a copy. Starting with El
1879 Capitan, macOS introduced System Integrity Protection. Among other
1880 things, this prevents certain executables from being ptrace'd. In
1881 particular, executables in /bin, like most shells, are affected.
1882 To work around this, while preserving command-line glob expansion
1883 and redirections, gdb will cache a copy of the shell. Return true
1884 if all is well -- either the shell is not subject to SIP or it has
1885 been successfully cached. Returns false if something failed. */
1886
1887static bool
1889{
1890 /* SF_RESTRICTED is defined in sys/stat.h and lets us determine if a
1891 given file is subject to SIP. */
1892#ifdef SF_RESTRICTED
1893
1894 /* If a check fails we want to revert -- maybe the user deleted the
1895 cache while gdb was running, or something like that. */
1896 copied_shell = nullptr;
1897
1898 const char *shell = get_shell ();
1899 if (!IS_ABSOLUTE_PATH (shell))
1900 {
1901 warning (_("This version of macOS has System Integrity Protection.\n\
1902Normally gdb would try to work around this by caching a copy of your shell,\n\
1903but because your shell (%s) is not an absolute path, this is being skipped."),
1904 shell);
1905 return false;
1906 }
1907
1908 struct stat sb;
1909 if (stat (shell, &sb) < 0)
1910 {
1911 warning (_("This version of macOS has System Integrity Protection.\n\
1912Normally gdb would try to work around this by caching a copy of your shell,\n\
1913but because gdb could not stat your shell (%s), this is being skipped.\n\
1914The error was: %s"),
1915 shell, safe_strerror (errno));
1916 return false;
1917 }
1918
1919 if ((sb.st_flags & SF_RESTRICTED) == 0)
1920 return true;
1921
1922 /* Put the copy somewhere like ~/Library/Caches/gdb/bin/sh. */
1923 std::string new_name = get_standard_cache_dir ();
1924 /* There's no need to insert a directory separator here, because
1925 SHELL is known to be absolute. */
1926 new_name.append (shell);
1927
1928 /* Maybe it was cached by some earlier gdb. */
1929 if (stat (new_name.c_str (), &sb) != 0 || !S_ISREG (sb.st_mode))
1930 {
1931 try
1932 {
1933 copy_shell_to_cache (shell, new_name);
1934 }
1935 catch (const gdb_exception_error &ex)
1936 {
1937 warning (_("This version of macOS has System Integrity Protection.\n\
1938Because `startup-with-shell' is enabled, gdb tried to work around SIP by\n\
1939caching a copy of your shell. However, this failed:\n\
1940%s\n\
1941If you correct the problem, gdb will automatically try again the next time\n\
1942you \"run\". To prevent these attempts, you can use:\n\
1943 set startup-with-shell off"),
1944 ex.what ());
1945 return false;
1946 }
1947
1948 gdb_printf (_("Note: this version of macOS has System Integrity Protection.\n\
1949Because `startup-with-shell' is enabled, gdb has worked around this by\n\
1950caching a copy of your shell. The shell used by \"run\" is now:\n\
1951 %s\n"),
1952 new_name.c_str ());
1953 }
1954
1955 /* We need to make sure that the new name has the correct lifetime. */
1956 static std::string saved_shell = std::move (new_name);
1957 copied_shell = saved_shell.c_str ();
1958
1959#endif /* SF_RESTRICTED */
1960
1961 return true;
1962}
1963
1964void
1966 const std::string &allargs,
1967 char **env, int from_tty)
1968{
1969 gdb::optional<scoped_restore_tmpl<bool>> restore_startup_with_shell;
1970 darwin_nat_target *the_target = this;
1971
1972 if (startup_with_shell && may_have_sip ())
1973 {
1974 if (!maybe_cache_shell ())
1975 {
1976 warning (_("startup-with-shell is now temporarily disabled"));
1977 restore_startup_with_shell.emplace (&startup_with_shell, 0);
1978 }
1979 }
1980
1981 /* Do the hard work. */
1982 fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1983 [the_target] (int pid)
1984 {
1985 the_target->ptrace_him (pid);
1986 },
1989}
1990
1991
1992/* Set things up such that the next call to darwin_wait will immediately
1993 return a fake stop event for inferior INF.
1994
1995 This assumes that the inferior's thread list has been initialized,
1996 as it will suspend the inferior's first thread. */
1997
1998static void
2000{
2002 darwin_thread_t *thread;
2003 kern_return_t kret;
2004
2005 gdb_assert (darwin_inf_fake_stop == NULL);
2007
2008 /* When detecting a fake pending stop event, darwin_wait returns
2009 an event saying that the first thread is in a DARWIN_STOPPED
2010 state. To make that accurate, we need to suspend that thread
2011 as well. Otherwise, we'll try resuming it when resuming the
2012 inferior, and get a warning because the thread's suspend count
2013 is already zero, making the resume request useless. */
2014 thread = priv->threads[0];
2015 kret = thread_suspend (thread->gdb_port);
2016 MACH_CHECK_ERROR (kret);
2017}
2018
2019/* Attach to process PID, then initialize for debugging it
2020 and wait for the trace-trap that results from attaching. */
2021void
2022darwin_nat_target::attach (const char *args, int from_tty)
2023{
2024 pid_t pid;
2025 struct inferior *inf;
2026
2027 pid = parse_pid_to_attach (args);
2028
2029 if (pid == getpid ()) /* Trying to masturbate? */
2030 error (_("I refuse to debug myself!"));
2031
2032 target_announce_attach (from_tty, pid);
2033
2034 if (pid == 0 || ::kill (pid, 0) < 0)
2035 error (_("Can't attach to process %d: %s (%d)"),
2036 pid, safe_strerror (errno), errno);
2037
2038 inf = current_inferior ();
2040 inf->attach_flag = true;
2041
2043
2045
2047
2049
2050 darwin_check_osabi (priv, inferior_ptid.tid ());
2051
2053
2054 priv->no_ptrace = 1;
2055}
2056
2057/* Take a program previously attached to and detaches it.
2058 The program resumes execution and will no longer stop
2059 on signals, etc. We'd better not have left any breakpoints
2060 in the program or it'll die when it hits one. For this
2061 to work, it may be necessary for the process to have been
2062 previously attached. It *might* work if the program was
2063 started via fork. */
2064
2065void
2067{
2069 kern_return_t kret;
2070 int res;
2071
2072 /* Display message. */
2073 target_announce_detach (from_tty);
2074
2075 /* If ptrace() is in use, stop the process. */
2076 if (!priv->no_ptrace)
2078
2079 kret = darwin_restore_exception_ports (priv);
2080 MACH_CHECK_ERROR (kret);
2081
2082 if (!priv->no_ptrace)
2083 {
2084 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
2085 if (res != 0)
2086 warning (_("Unable to detach from process-id %d: %s (%d)"),
2087 inf->pid, safe_strerror (errno), errno);
2088 }
2089
2091
2092 /* When using ptrace, we have just performed a PT_DETACH, which
2093 resumes the inferior. On the other hand, when we are not using
2094 ptrace, we need to resume its execution ourselves. */
2095 if (priv->no_ptrace)
2097
2098 mourn_inferior ();
2099}
2100
2101std::string
2103{
2104 long tid = ptid.tid ();
2105
2106 if (tid != 0)
2107 return string_printf (_("Thread 0x%lx of process %u"),
2108 tid, ptid.pid ());
2109
2110 return normal_pid_to_str (ptid);
2111}
2112
2113bool
2115{
2116 return true;
2117}
2118
2119/* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2120 copy it to RDADDR in gdb's address space.
2121 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2122 to ADDR in inferior task's address space.
2123 Return 0 on failure; number of bytes read / written otherwise. */
2124
2125static int
2126darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2127 gdb_byte *rdaddr, const gdb_byte *wraddr,
2128 ULONGEST length)
2129{
2130 kern_return_t kret;
2131 mach_vm_size_t res_length = 0;
2132
2133 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2134 task, core_addr_to_string (addr), pulongest (length));
2135
2136 /* First read. */
2137 if (rdaddr != NULL)
2138 {
2139 mach_vm_size_t count;
2140
2141 /* According to target.h(to_xfer_partial), one and only one may be
2142 non-null. */
2143 gdb_assert (wraddr == NULL);
2144
2145 kret = mach_vm_read_overwrite (task, addr, length,
2146 (mach_vm_address_t) rdaddr, &count);
2147 if (kret != KERN_SUCCESS)
2148 {
2150 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2151 core_addr_to_string (addr), mach_error_string (kret));
2152 return 0;
2153 }
2154 return count;
2155 }
2156
2157 /* See above. */
2158 gdb_assert (wraddr != NULL);
2159
2160 while (length != 0)
2161 {
2162 mach_vm_address_t offset = addr & (mach_page_size - 1);
2163 mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2164 mach_vm_size_t aligned_length =
2165 (mach_vm_size_t) PAGE_ROUND (offset + length);
2166 vm_region_submap_short_info_data_64_t info;
2167 mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2168 natural_t region_depth = 1000;
2169 mach_vm_address_t region_start = region_address;
2170 mach_vm_size_t region_length;
2171 mach_vm_size_t write_length;
2172
2173 /* Read page protection. */
2174 kret = mach_vm_region_recurse
2175 (task, &region_start, &region_length, &region_depth,
2176 (vm_region_recurse_info_t) &info, &count);
2177
2178 if (kret != KERN_SUCCESS)
2179 {
2180 inferior_debug (1, _("darwin_read_write_inferior: "
2181 "mach_vm_region_recurse failed at %s: %s\n"),
2182 core_addr_to_string (region_address),
2183 mach_error_string (kret));
2184 return res_length;
2185 }
2186
2188 (9, _("darwin_read_write_inferior: "
2189 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2190 core_addr_to_string (region_address),
2191 core_addr_to_string (region_start),
2192 core_addr_to_string (region_length));
2193
2194 /* Check for holes in memory. */
2195 if (region_start > region_address)
2196 {
2197 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2198 core_addr_to_string (region_address),
2199 core_addr_to_string (region_start),
2200 (unsigned)region_length);
2201 return res_length;
2202 }
2203
2204 /* Adjust the length. */
2205 region_length -= (region_address - region_start);
2206 if (region_length > aligned_length)
2207 region_length = aligned_length;
2208
2209 /* Make the pages RW. */
2210 if (!(info.protection & VM_PROT_WRITE))
2211 {
2212 vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2213
2214 kret = mach_vm_protect (task, region_address, region_length,
2215 FALSE, prot);
2216 if (kret != KERN_SUCCESS)
2217 {
2218 prot |= VM_PROT_COPY;
2219 kret = mach_vm_protect (task, region_address, region_length,
2220 FALSE, prot);
2221 }
2222 if (kret != KERN_SUCCESS)
2223 {
2224 warning (_("darwin_read_write_inferior: "
2225 "mach_vm_protect failed at %s "
2226 "(len=0x%lx, prot=0x%x): %s"),
2227 core_addr_to_string (region_address),
2228 (unsigned long) region_length, (unsigned) prot,
2229 mach_error_string (kret));
2230 return res_length;
2231 }
2232 }
2233
2234 if (offset + length > region_length)
2235 write_length = region_length - offset;
2236 else
2237 write_length = length;
2238
2239 /* Write. */
2240 kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2241 if (kret != KERN_SUCCESS)
2242 {
2243 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2244 mach_error_string (kret));
2245 return res_length;
2246 }
2247
2248 /* Restore page rights. */
2249 if (!(info.protection & VM_PROT_WRITE))
2250 {
2251 kret = mach_vm_protect (task, region_address, region_length,
2252 FALSE, info.protection);
2253 if (kret != KERN_SUCCESS)
2254 {
2255 warning (_("darwin_read_write_inferior: "
2256 "mach_vm_protect restore failed at %s "
2257 "(len=0x%lx): %s"),
2258 core_addr_to_string (region_address),
2259 (unsigned long) region_length,
2260 mach_error_string (kret));
2261 }
2262 }
2263
2264 addr += write_length;
2265 wraddr += write_length;
2266 res_length += write_length;
2267 length -= write_length;
2268 }
2269
2270 return res_length;
2271}
2272
2273/* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2274 to RDADDR (in big endian).
2275 Return 0 on failure; number of bytes read / written otherwise. */
2276
2277#ifdef TASK_DYLD_INFO_COUNT
2278/* This is not available in Darwin 9. */
2279static enum target_xfer_status
2280darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2281 ULONGEST length, ULONGEST *xfered_len)
2282{
2283 struct task_dyld_info task_dyld_info;
2284 mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2285 kern_return_t kret;
2286
2287 if (addr != 0 || length > sizeof (mach_vm_address_t))
2288 return TARGET_XFER_EOF;
2289
2290 kret = task_info (task, TASK_DYLD_INFO,
2291 (task_info_t) &task_dyld_info, &count);
2292 MACH_CHECK_ERROR (kret);
2293 if (kret != KERN_SUCCESS)
2294 return TARGET_XFER_E_IO;
2295
2296 store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2297 task_dyld_info.all_image_info_addr);
2298 *xfered_len = (ULONGEST) length;
2299 return TARGET_XFER_OK;
2300}
2301#endif
2302
2303
2304
2306darwin_nat_target::xfer_partial (enum target_object object, const char *annex,
2307 gdb_byte *readbuf, const gdb_byte *writebuf,
2308 ULONGEST offset, ULONGEST len,
2309 ULONGEST *xfered_len)
2310{
2311 struct inferior *inf = current_inferior ();
2313
2315 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2316 core_addr_to_string (offset), pulongest (len),
2317 host_address_to_string (readbuf), host_address_to_string (writebuf),
2318 inf->pid);
2319
2320 switch (object)
2321 {
2323 {
2324 int l = darwin_read_write_inferior (priv->task, offset,
2325 readbuf, writebuf, len);
2326
2327 if (l == 0)
2328 return TARGET_XFER_EOF;
2329 else
2330 {
2331 gdb_assert (l > 0);
2332 *xfered_len = (ULONGEST) l;
2333 return TARGET_XFER_OK;
2334 }
2335 }
2336#ifdef TASK_DYLD_INFO_COUNT
2338 if (writebuf != NULL || readbuf == NULL)
2339 {
2340 /* Support only read. */
2341 return TARGET_XFER_E_IO;
2342 }
2343 return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2344 xfered_len);
2345#endif
2346 default:
2347 return TARGET_XFER_E_IO;
2348 }
2349
2350}
2351
2352static void
2353set_enable_mach_exceptions (const char *args, int from_tty,
2354 struct cmd_list_element *c)
2355{
2356 if (inferior_ptid != null_ptid)
2357 {
2358 struct inferior *inf = current_inferior ();
2360 exception_mask_t mask;
2361 kern_return_t kret;
2362
2364 mask = EXC_MASK_ALL;
2365 else
2366 {
2368 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2369 }
2370 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2371 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2372 MACH_CHECK_ERROR (kret);
2373 }
2374}
2375
2376const char *
2378{
2379 static char path[PATH_MAX];
2380 int res;
2381
2382 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2383 if (res >= 0)
2384 return path;
2385 else
2386 return NULL;
2387}
2388
2389ptid_t
2390darwin_nat_target::get_ada_task_ptid (long lwp, ULONGEST thread)
2391{
2392 struct inferior *inf = current_inferior ();
2394 kern_return_t kret;
2395 mach_port_name_array_t names;
2396 mach_msg_type_number_t names_count;
2397 mach_port_type_array_t types;
2398 mach_msg_type_number_t types_count;
2399 long res = 0;
2400
2401 /* First linear search. */
2402 for (darwin_thread_t *t : priv->threads)
2403 {
2404 if (t->inf_port == lwp)
2405 return ptid_t (inferior_ptid.pid (), 0, t->gdb_port);
2406 }
2407
2408 /* Maybe the port was never extract. Do it now. */
2409
2410 /* First get inferior port names. */
2411 kret = mach_port_names (priv->task, &names, &names_count, &types,
2412 &types_count);
2413 MACH_CHECK_ERROR (kret);
2414 if (kret != KERN_SUCCESS)
2415 return null_ptid;
2416
2417 /* For each name, copy the right in the gdb space and then compare with
2418 our view of the inferior threads. We don't forget to deallocate the
2419 right. */
2420 for (int i = 0; i < names_count; i++)
2421 {
2422 mach_port_t local_name;
2423 mach_msg_type_name_t local_type;
2424
2425 /* We just need to know the corresponding name in gdb name space.
2426 So extract and deallocate the right. */
2427 kret = mach_port_extract_right (priv->task, names[i],
2428 MACH_MSG_TYPE_COPY_SEND,
2429 &local_name, &local_type);
2430 if (kret != KERN_SUCCESS)
2431 continue;
2432 mach_port_deallocate (gdb_task, local_name);
2433
2434 for (darwin_thread_t *t : priv->threads)
2435 {
2436 if (t->gdb_port == local_name)
2437 {
2438 t->inf_port = names[i];
2439 if (names[i] == lwp)
2440 res = t->gdb_port;
2441 }
2442 }
2443 }
2444
2445 vm_deallocate (gdb_task, (vm_address_t) names,
2446 names_count * sizeof (mach_port_t));
2447
2448 if (res)
2449 return ptid_t (current_inferior ()->pid, 0, res);
2450 else
2451 return null_ptid;
2452}
2453
2454bool
2456{
2457 return true;
2458}
2459
2461void
2463{
2464 kern_return_t kret;
2465
2466 gdb_task = mach_task_self ();
2467 darwin_host_self = mach_host_self ();
2468
2469 /* Read page size. */
2470 kret = host_page_size (darwin_host_self, &mach_page_size);
2471 if (kret != KERN_SUCCESS)
2472 {
2473 mach_page_size = 0x1000;
2474 MACH_CHECK_ERROR (kret);
2475 }
2476
2477 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2478 (unsigned long) mach_task_self (), getpid ());
2479
2481 &darwin_debug_flag, _("\
2482Set if printing inferior communication debugging statements."), _("\
2483Show if printing inferior communication debugging statements."), NULL,
2484 NULL, NULL,
2486
2487 add_setshow_boolean_cmd ("mach-exceptions", class_support,
2489Set if mach exceptions are caught."), _("\
2490Show if mach exceptions are caught."), _("\
2491When this mode is on, all low level exceptions are reported before being\n\
2492reported by the kernel."),
2494 &setlist, &showlist);
2495}
const char *const name
#define qsort
Definition ada-exp.c:3060
int code
Definition ada-lex.l:688
long __attribute__((__aligned__(4)))
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
void resume(ptid_t, int, enum gdb_signal) override
Definition darwin-nat.c:915
ptid_t get_ada_task_ptid(long lwp, ULONGEST thread) override
void init_thread_list(inferior *inf)
void ptrace_him(int pid)
void detach(inferior *, int) override
ptid_t wait_1(ptid_t, struct target_waitstatus *)
const char * pid_to_exec_file(int pid) override
void kill() override
void stop_inferior(inferior *inf)
int cancel_breakpoint(ptid_t ptid)
void mourn_inferior() override
bool thread_alive(ptid_t ptid) override
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
bool supports_multi_process() override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
ptid_t decode_message(mach_msg_header_t *hdr, darwin_thread_t **pthread, inferior **pinf, target_waitstatus *status)
Definition darwin-nat.c:972
void check_new_threads(inferior *inf)
Definition darwin-nat.c:258
int decode_exception_message(mach_msg_header_t *hdr, inferior **pinf, darwin_thread_t **pthread)
Definition darwin-nat.c:603
void attach(const char *, int) override
std::string pid_to_str(ptid_t) override
void interrupt() override
void create_inferior(const char *exec_file, const std::string &allargs, char **env, int from_tty) override
void mourn_inferior() override
Definition inf-child.c:190
void close() override
Definition inf-child.c:183
std::unique_ptr< private_inferior > priv
Definition inferior.h:600
const std::string & args() const
Definition inferior.h:498
gdbarch * arch() const
Definition regcache.c:230
const address_space * aspace() const
Definition regcache.h:342
struct cmd_list_element * showlist
Definition cli-cmds.c:125
struct cmd_list_element * setlist
Definition cli-cmds.c:117
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:163
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
@ class_obscure
Definition command.h:64
@ class_support
Definition command.h:58
static struct inferior * darwin_find_new_inferior(task_t task_port, thread_t thread_port)
Definition darwin-nat.c:540
static void darwin_setup_exceptions(struct inferior *inf)
static void darwin_reply_to_all_pending_messages(struct inferior *inf)
#define PTRACE(CMD, PID, ADDR, SIG)
Definition darwin-nat.c:89
mach_port_t darwin_host_self
Definition darwin-nat.c:106
static int darwin_ptrace(const char *name, int request, int pid, caddr_t arg3, int arg4)
Definition darwin-nat.c:233
#define PAGE_ROUND(x)
Definition darwin-nat.c:129
static bool maybe_cache_shell()
static void inferior_debug(int level, const char *fmt,...) ATTRIBUTE_PRINTF(2
Definition darwin-nat.c:164
static struct inferior * darwin_inf_fake_stop
Definition darwin-nat.c:122
#define _POSIX_SPAWN_DISABLE_ASLR
static vm_size_t mach_page_size
Definition darwin-nat.c:115
static const char * copied_shell
Definition darwin-nat.c:126
static int cmp_thread_t(const void *l, const void *r)
Definition darwin-nat.c:250
static struct inferior * darwin_find_inferior_by_task(task_t port)
Definition darwin-nat.c:383
static void set_enable_mach_exceptions(const char *args, int from_tty, struct cmd_list_element *c)
static void darwin_resume_inferior_threads(struct inferior *inf, int step, int nsignal)
Definition darwin-nat.c:880
static int darwin_pthread_kill(darwin_thread_t *thread, int nsignal)
Definition darwin-nat.c:816
static void darwin_deallocate_threads(struct inferior *inf)
mach_port_t darwin_ex_port
Definition darwin-nat.c:109
static void darwin_deallocate_exception_ports(darwin_inferior *inf)
static void darwin_send_reply(struct inferior *inf, darwin_thread_t *thread)
Definition darwin-nat.c:794
static void darwin_resume_thread(struct inferior *inf, darwin_thread_t *thread, int step, int nsignal)
Definition darwin-nat.c:826
void mach_check_error(kern_return_t ret, const char *file, unsigned int line, const char *func)
Definition darwin-nat.c:178
static void darwin_ptrace_me(void)
void _initialize_darwin_nat()
static void darwin_suspend_inferior(struct inferior *inf)
Definition darwin-nat.c:426
static task_t gdb_task
Definition darwin-nat.c:103
static const char * unparse_exception_type(unsigned int i)
Definition darwin-nat.c:191
static darwin_thread_t * darwin_find_thread(struct inferior *inf, thread_t thread)
Definition darwin-nat.c:409
static void copy_shell_to_cache(const char *shell, const std::string &new_name)
static struct inferior * darwin_find_inferior_by_pid(int pid)
Definition darwin-nat.c:397
static void darwin_pre_ptrace(void)
static void darwin_execvp(const char *file, char *const argv[], char *const env[])
static bool enable_mach_exceptions
Definition darwin-nat.c:119
static struct thread_info * thread_info_from_private_thread_info(darwin_thread_info *pti)
static void darwin_setup_fake_stop_event(struct inferior *inf)
static void darwin_resume_inferior(struct inferior *inf)
Definition darwin-nat.c:444
mach_port_t darwin_port_set
Definition darwin-nat.c:112
static int darwin_check_message_ndr(NDR_record_t *ndr)
Definition darwin-nat.c:588
static kern_return_t darwin_restore_exception_ports(darwin_inferior *inf)
static void darwin_setup_request_notification(struct inferior *inf)
static bool may_have_sip()
static void darwin_dump_message(mach_msg_header_t *hdr, int disp_body)
Definition darwin-nat.c:460
static kern_return_t darwin_save_exception_ports(darwin_inferior *inf)
static void darwin_suspend_inferior_threads(struct inferior *inf)
Definition darwin-nat.c:892
static unsigned int darwin_debug_flag
Definition darwin-nat.c:132
static int ptrace_fds[2]
static void darwin_encode_reply(mig_reply_error_t *reply, mach_msg_header_t *hdr, integer_t code)
Definition darwin-nat.c:778
static int darwin_read_write_inferior(task_t task, CORE_ADDR addr, gdb_byte *rdaddr, const gdb_byte *wraddr, ULONGEST length)
static void darwin_attach_pid(struct inferior *inf)
static int darwin_decode_notify_message(mach_msg_header_t *hdr, struct inferior **pinf)
Definition darwin-nat.c:741
@ DARWIN_MESSAGE
Definition darwin-nat.h:49
@ DARWIN_RUNNING
Definition darwin-nat.h:43
@ DARWIN_STOPPED
Definition darwin-nat.h:46
mach_port_t darwin_ex_port
Definition darwin-nat.c:109
static darwin_inferior * get_darwin_inferior(inferior *inf)
Definition darwin-nat.h:189
void darwin_set_sstep(thread_t thread, int enable)
#define MACH_CHECK_ERROR(ret)
Definition darwin-nat.h:203
mach_port_t darwin_port_set
Definition darwin-nat.c:112
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
static darwin_thread_info * get_darwin_thread_info(class thread_info *thread)
Definition darwin-nat.h:155
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:561
ssize_t read(int fd, void *buf, size_t count)
ptid_t gdb_startup_inferior(pid_t pid, int num_traps)
Definition fork-child.c:124
void trace_start_error_with_name(const char *string)
void trace_start_error(const char *fmt,...)
pid_t fork_inferior(const char *exec_file_arg, const std::string &allargs, char **env, void(*traceme_fun)(), gdb::function_view< void(int)> init_trace_fun, void(*pre_trace_fun)(), const char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
#define START_INFERIOR_TRAPS_EXPECTED
static void ATTRIBUTE_PRINTF(1, 0)
Definition gdb_bfd.c:1150
#define PT_TRACE_ME
Definition gdb_ptrace.h:43
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition gdbarch.c:2838
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition gdbthread.h:732
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
Definition thread.c:528
void delete_thread(struct thread_info *thread)
Definition thread.c:483
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1335
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info *)
Definition thread.c:288
void switch_to_no_thread()
Definition thread.c:1320
void init_thread_list(void)
Definition thread.c:233
pthread_t thread_t
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1792
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1791
size_t size
Definition go32-nat.c:241
ptid_t inferior_ptid
Definition infcmd.c:91
void inferior_appeared(struct inferior *inf, int pid)
Definition inferior.c:322
void exit_inferior(inferior *inf)
Definition inferior.c:294
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
Definition inferior.c:365
struct inferior * current_inferior(void)
Definition inferior.c:54
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:758
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition regcache.c:1324
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition regcache.c:1368
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:397
void(* func)(remote_target *remote, char *)
std::vector< darwin_thread_t * > threads
Definition darwin-nat.h:183
mach_port_t notify_port
Definition darwin-nat.h:168
unsigned int pending_messages
Definition darwin-nat.h:174
enum darwin_msg_state msg_state
Definition darwin-nat.h:64
Definition gnu-nat.c:154
pid_t pid
Definition gnu-nat.c:166
struct proc * task
Definition gnu-nat.c:157
enum gdb_signal sig
Definition waitstatus.h:414
target_waitkind kind() const
Definition waitstatus.h:345
void target_announce_detach(int from_tty)
Definition target.c:3601
target_ops * get_native_target()
Definition target.c:2865
void target_announce_attach(int from_tty, int pid)
Definition target.c:3622
std::string normal_pid_to_str(ptid_t ptid)
Definition target.c:3672
void target_mourn_inferior(ptid_t ptid)
Definition target.c:2737
target_xfer_status
Definition target.h:214
@ TARGET_XFER_E_IO
Definition target.h:227
@ TARGET_XFER_EOF
Definition target.h:219
@ TARGET_XFER_OK
Definition target.h:216
target_object
Definition target.h:138
@ TARGET_OBJECT_DARWIN_DYLD_INFO
Definition target.h:192
@ TARGET_OBJECT_MEMORY
Definition target.h:142
std::string ldirname(const char *filename)
Definition utils.c:3254
void gdb_vprintf(struct ui_file *stream, const char *format, va_list args)
Definition utils.c:1853
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
int parse_pid_to_attach(const char *args)
Definition utils.c:3279
#define gdb_stderr
Definition utils.h:193
#define gdb_stdlog
Definition utils.h:196
@ TARGET_WAITKIND_STOPPED
Definition waitstatus.h:36
@ TARGET_WAITKIND_IGNORE
Definition waitstatus.h:89