GDB (xrefs)

/tmp/gdb-8.1/gdb/darwin-nat.c
Go to the documentation of this file.
1 /* Darwin support for GDB, the GNU debugger.
2 Copyright (C) 2008-2018 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
41 #include <sys/ptrace.h>
42 #include <sys/signal.h>
43 #include <setjmp.h>
44 #include <sys/types.h>
45 #include <unistd.h>
46 #include <signal.h>
47 #include <ctype.h>
48 #include <sys/sysctl.h>
49 #include <sys/proc.h>
50 #include <libproc.h>
51 #include <sys/syscall.h>
52 #include <spawn.h>
53
54 #include <mach/mach_error.h>
55 #include <mach/mach_vm.h>
56 #include <mach/mach_init.h>
57 #include <mach/vm_map.h>
58 #include <mach/task.h>
59 #include <mach/mach_port.h>
60 #include <mach/thread_act.h>
61 #include <mach/port.h>
62
63 #include "darwin-nat.h"
64 #include "common/filestuff.h"
65 #include "nat/fork-inferior.h"
66
67 /* Quick overview.
68 Darwin kernel is Mach + BSD derived kernel. Note that they share the
69 same memory space and are linked together (ie there is no micro-kernel).
70
71 Although ptrace(2) is available on Darwin, it is not complete. We have
72 to use Mach calls to read and write memory and to modify registers. We
73 also use Mach to get inferior faults. As we cannot use select(2) or
74 signals with Mach port (the Mach communication channel), signals are
75 reported to gdb as an exception. Furthermore we detect death of the
76 inferior through a Mach notification message. This way we only wait
77 on Mach ports.
78
79 Some Mach documentation is available for Apple xnu source package or
80 from the web. */
81
82
83 #define PTRACE(CMD, PID, ADDR, SIG) \
84 darwin_ptrace(#CMD, CMD, (PID), (ADDR), (SIG))
85
86 static void darwin_interrupt (struct target_ops *self, ptid_t);
87
88 static void darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
89 enum gdb_signal signal);
90 static void darwin_resume (ptid_t ptid, int step,
91 enum gdb_signal signal);
92
93 static ptid_t darwin_wait_to (struct target_ops *ops, ptid_t ptid,
94 struct target_waitstatus *status, int options);
95 static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
96
97 static void darwin_mourn_inferior (struct target_ops *ops);
98
99 static void darwin_kill_inferior (struct target_ops *ops);
100
101 static void darwin_ptrace_me (void);
102
103 static void darwin_ptrace_him (int pid);
104
105 static void darwin_create_inferior (struct target_ops *ops,
106 const char *exec_file,
107 const std::string &allargs,
108 char **env, int from_tty);
109
110 static void darwin_files_info (struct target_ops *ops);
111
112 static const char *darwin_pid_to_str (struct target_ops *ops, ptid_t tpid);
113
114 static int darwin_thread_alive (struct target_ops *ops, ptid_t tpid);
115
116 static void darwin_encode_reply (mig_reply_error_t *reply,
117 mach_msg_header_t *hdr, integer_t code);
118
119 static void darwin_setup_request_notification (struct inferior *inf);
120 static void darwin_deallocate_exception_ports (darwin_inferior *inf);
121 static void darwin_setup_exceptions (struct inferior *inf);
122 static void darwin_deallocate_threads (struct inferior *inf);
123
124 /* Target operations for Darwin. */
125 static struct target_ops *darwin_ops;
126
127 /* Task identifier of gdb. */
128 static task_t gdb_task;
129
130 /* A copy of mach_host_self (). */
131 mach_port_t darwin_host_self;
132
133 /* Exception port. */
134 mach_port_t darwin_ex_port;
135
136 /* Port set, to wait for answer on all ports. */
137 mach_port_t darwin_port_set;
138
139 /* Page size. */
140 static vm_size_t mach_page_size;
141
142 /* If Set, catch all mach exceptions (before they are converted to signals
143 by the kernel). */
144 static int enable_mach_exceptions;
145
146 /* Inferior that should report a fake stop event. */
147 static struct inferior *darwin_inf_fake_stop;
148
149 #define PAGE_TRUNC(x) ((x) & ~(mach_page_size - 1))
150 #define PAGE_ROUND(x) PAGE_TRUNC((x) + mach_page_size - 1)
151
152 /* This controls output of inferior debugging. */
153 static unsigned int darwin_debug_flag = 0;
154
155 /* Create a __TEXT __info_plist section in the executable so that gdb could
156 be signed. This is required to get an authorization for task_for_pid.
157
158 Once gdb is built, you must codesign it with any system-trusted signing
159 authority. See taskgated(8) for details. */
160 static const unsigned char info_plist[]
161 __attribute__ ((section ("__TEXT,__info_plist"),used)) =
162 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
163 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
164 " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
165 "<plist version=\"1.0\">\n"
166 "<dict>\n"
167 " <key>CFBundleIdentifier</key>\n"
168 " <string>org.gnu.gdb</string>\n"
169 " <key>CFBundleName</key>\n"
170 " <string>gdb</string>\n"
171 " <key>CFBundleVersion</key>\n"
172 " <string>1.0</string>\n"
173 " <key>SecTaskAccess</key>\n"
174 " <array>\n"
175 " <string>allowed</string>\n"
176 " <string>debug</string>\n"
177 " </array>\n"
178 "</dict>\n"
179 "</plist>\n";
180
181 static void inferior_debug (int level, const char *fmt, ...)
182 ATTRIBUTE_PRINTF (2, 3);
183
184 static void
185 inferior_debug (int level, const char *fmt, ...)
186 {
187 va_list ap;
188
189 if (darwin_debug_flag < level)
190 return;
191
192 va_start (ap, fmt);
193 printf_unfiltered (_("[%d inferior]: "), getpid ());
194 vprintf_unfiltered (fmt, ap);
195 va_end (ap);
196 }
197
198 void
199 mach_check_error (kern_return_t ret, const char *file,
200 unsigned int line, const char *func)
201 {
202 if (ret == KERN_SUCCESS)
203 return;
204 if (func == NULL)
205 func = _("[UNKNOWN]");
206
207 warning (_("Mach error at \"%s:%u\" in function \"%s\": %s (0x%lx)"),
208 file, line, func, mach_error_string (ret), (unsigned long) ret);
209 }
210
211 static const char *
212 unparse_exception_type (unsigned int i)
213 {
214 static char unknown_exception_buf[32];
215
216 switch (i)
217 {
218 case EXC_BAD_ACCESS:
219 return "EXC_BAD_ACCESS";
220 case EXC_BAD_INSTRUCTION:
221 return "EXC_BAD_INSTRUCTION";
222 case EXC_ARITHMETIC:
223 return "EXC_ARITHMETIC";
224 case EXC_EMULATION:
225 return "EXC_EMULATION";
226 case EXC_SOFTWARE:
227 return "EXC_SOFTWARE";
228 case EXC_BREAKPOINT:
229 return "EXC_BREAKPOINT";
230 case EXC_SYSCALL:
231 return "EXC_SYSCALL";
232 case EXC_MACH_SYSCALL:
233 return "EXC_MACH_SYSCALL";
234 case EXC_RPC_ALERT:
235 return "EXC_RPC_ALERT";
236 case EXC_CRASH:
237 return "EXC_CRASH";
238 default:
239 snprintf (unknown_exception_buf, 32, _("unknown (%d)"), i);
240 return unknown_exception_buf;
241 }
242 }
243
244 /* Set errno to zero, and then call ptrace with the given arguments.
245 If inferior debugging traces are on, then also print a debug
246 trace.
247
248 The returned value is the same as the value returned by ptrace,
249 except in the case where that value is -1 but errno is zero.
250 This case is documented to be a non-error situation, so we
251 return zero in that case. */
252
253 static int
254 darwin_ptrace (const char *name,
255 int request, int pid, caddr_t arg3, int arg4)
256 {
257 int ret;
258
259 errno = 0;
260 ret = ptrace (request, pid, arg3, arg4);
261 if (ret == -1 && errno == 0)
262 ret = 0;
263
264 inferior_debug (4, _("ptrace (%s, %d, 0x%lx, %d): %d (%s)\n"),
265 name, pid, (unsigned long) arg3, arg4, ret,
266 (ret != 0) ? safe_strerror (errno) : _("no error"));
267 return ret;
268 }
269
270 static int
271 cmp_thread_t (const void *l, const void *r)
272 {
273 thread_t tl = *(const thread_t *)l;
274 thread_t tr = *(const thread_t *)r;
275 return (int)(tl - tr);
276 }
277
278 static void
279 darwin_check_new_threads (struct inferior *inf)
280 {
281 kern_return_t kret;
282 thread_array_t thread_list;
283 unsigned int new_nbr;
284 unsigned int old_nbr;
285 unsigned int new_ix, old_ix;
286 darwin_inferior *darwin_inf = get_darwin_inferior (inf);
287 std::vector<darwin_thread_t *> new_thread_vec;
288
289 /* Get list of threads. */
290 kret = task_threads (darwin_inf->task, &thread_list, &new_nbr);
291 MACH_CHECK_ERROR (kret);
292 if (kret != KERN_SUCCESS)
293 return;
294
295 /* Sort the list. */
296 if (new_nbr > 1)
297 qsort (thread_list, new_nbr, sizeof (thread_t), cmp_thread_t);
298
299 old_nbr = darwin_inf->threads.size ();
300
301 /* Quick check for no changes. */
302 if (old_nbr == new_nbr)
303 {
304 size_t i;
305
306 for (i = 0; i < new_nbr; i++)
307 if (thread_list[i] != darwin_inf->threads[i]->gdb_port)
308 break;
309 if (i == new_nbr)
310 {
311 /* Deallocate ports. */
312 for (i = 0; i < new_nbr; i++)
313 {
314 kret = mach_port_deallocate (mach_task_self (), thread_list[i]);
315 MACH_CHECK_ERROR (kret);
316 }
317
318 /* Deallocate the buffer. */
319 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
320 new_nbr * sizeof (int));
321 MACH_CHECK_ERROR (kret);
322
323 return;
324 }
325 }
326
327 /* Full handling: detect new threads, remove dead threads. */
328
329 new_thread_vec.reserve (new_nbr);
330
331 for (new_ix = 0, old_ix = 0; new_ix < new_nbr || old_ix < old_nbr;)
332 {
333 thread_t new_id = (new_ix < new_nbr) ? thread_list[new_ix] : THREAD_NULL;
334 darwin_thread_t *old
335 = (old_ix < old_nbr) ? darwin_inf->threads[old_ix] : NULL;
336 thread_t old_id = old != NULL ? old->gdb_port : THREAD_NULL;
337
338 inferior_debug
339 (12, _(" new_ix:%d/%d, old_ix:%d/%d, new_id:0x%x old_id:0x%x\n"),
340 new_ix, new_nbr, old_ix, old_nbr, new_id, old_id);
341
342 if (old_id == new_id)
343 {
344 /* Thread still exist. */
345 new_thread_vec.push_back (old);
346 new_ix++;
347 old_ix++;
348
349 /* Deallocate the port. */
350 kret = mach_port_deallocate (gdb_task, new_id);
351 MACH_CHECK_ERROR (kret);
352
353 continue;
354 }
355 if (new_ix < new_nbr && new_id == MACH_PORT_DEAD)
356 {
357 /* Ignore dead ports.
358 In some weird cases, we might get dead ports. They should
359 correspond to dead thread so they could safely be ignored. */
360 new_ix++;
361 continue;
362 }
363 if (new_ix < new_nbr && (old_ix == old_nbr || new_id < old_id))
364 {
365 /* A thread was created. */
366 darwin_thread_info *pti = new darwin_thread_info;
367
368 pti->gdb_port = new_id;
369 pti->msg_state = DARWIN_RUNNING;
370
371 /* Add the new thread. */
372 add_thread_with_info (ptid_build (inf->pid, 0, new_id), pti);
373 new_thread_vec.push_back (pti);
374 new_ix++;
375 continue;
376 }
377 if (old_ix < old_nbr && (new_ix == new_nbr || new_id > old_id))
378 {
379 /* A thread was removed. */
380 delete_thread (ptid_build (inf->pid, 0, old_id));
381 kret = mach_port_deallocate (gdb_task, old_id);
382 MACH_CHECK_ERROR (kret);
383 old_ix++;
384 continue;
385 }
386 gdb_assert_not_reached ("unexpected thread case");
387 }
388
389 darwin_inf->threads = std::move (new_thread_vec);
390
391 /* Deallocate the buffer. */
392 kret = vm_deallocate (gdb_task, (vm_address_t) thread_list,
393 new_nbr * sizeof (int));
394 MACH_CHECK_ERROR (kret);
395 }
396
397 static int
398 find_inferior_task_it (struct inferior *inf, void *port_ptr)
399 {
400 darwin_inferior *priv = get_darwin_inferior (inf);
401
402 return priv->task == *(task_t *)port_ptr;
403 }
404
405 static int
406 find_inferior_pid_it (struct inferior *inf, void *pid_ptr)
407 {
408 return inf->pid == *(int *)pid_ptr;
409 }
410
411 /* Return an inferior by task port. */
412 static struct inferior *
413 darwin_find_inferior_by_task (task_t port)
414 {
415 return iterate_over_inferiors (&find_inferior_task_it, &port);
416 }
417
418 /* Return an inferior by pid port. */
419 static struct inferior *
420 darwin_find_inferior_by_pid (int pid)
421 {
422 return iterate_over_inferiors (&find_inferior_pid_it, &pid);
423 }
424
425 /* Return a thread by port. */
426 static darwin_thread_t *
427 darwin_find_thread (struct inferior *inf, thread_t thread)
428 {
429 darwin_inferior *priv = get_darwin_inferior (inf);
430
431 for (darwin_thread_t *t : priv->threads)
432 {
433 if (t->gdb_port == thread)
434 return t;
435 }
436
437 return NULL;
438 }
439
440 /* Suspend (ie stop) an inferior at Mach level. */
441
442 static void
443 darwin_suspend_inferior (struct inferior *inf)
444 {
445 darwin_inferior *priv = get_darwin_inferior (inf);
446
447 if (!priv->suspended)
448 {
449 kern_return_t kret;
450
451 kret = task_suspend (priv->task);
452 MACH_CHECK_ERROR (kret);
453
454 priv->suspended = 1;
455 }
456 }
457
458 /* Resume an inferior at Mach level. */
459
460 static void
461 darwin_resume_inferior (struct inferior *inf)
462 {
463 darwin_inferior *priv = get_darwin_inferior (inf);
464
465 if (priv->suspended)
466 {
467 kern_return_t kret;
468
469 kret = task_resume (priv->task);
470 MACH_CHECK_ERROR (kret);
471
472 priv->suspended = 0;
473 }
474 }
475
476 /* Iterator functions. */
477
478 static int
479 darwin_suspend_inferior_it (struct inferior *inf, void *arg)
480 {
481 darwin_suspend_inferior (inf);
482 darwin_check_new_threads (inf);
483 return 0;
484 }
485
486 static int
487 darwin_resume_inferior_it (struct inferior *inf, void *arg)
488 {
489 darwin_resume_inferior (inf);
490 return 0;
491 }
492
493 static void
494 darwin_dump_message (mach_msg_header_t *hdr, int disp_body)
495 {
496 printf_unfiltered (_("message header:\n"));
497 printf_unfiltered (_(" bits: 0x%x\n"), hdr->msgh_bits);
498 printf_unfiltered (_(" size: 0x%x\n"), hdr->msgh_size);
499 printf_unfiltered (_(" remote-port: 0x%x\n"), hdr->msgh_remote_port);
500 printf_unfiltered (_(" local-port: 0x%x\n"), hdr->msgh_local_port);
501 printf_unfiltered (_(" reserved: 0x%x\n"), hdr->msgh_reserved);
502 printf_unfiltered (_(" id: 0x%x\n"), hdr->msgh_id);
503
504 if (disp_body)
505 {
506 const unsigned char *data;
507 const unsigned int *ldata;
508 int size;
509 int i;
510
511 data = (unsigned char *)(hdr + 1);
512 size = hdr->msgh_size - sizeof (mach_msg_header_t);
513
514 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
515 {
516 mach_msg_body_t *bod = (mach_msg_body_t*)data;
517 mach_msg_port_descriptor_t *desc =
518 (mach_msg_port_descriptor_t *)(bod + 1);
519 int k;
520 NDR_record_t *ndr;
521 printf_unfiltered (_("body: descriptor_count=%u\n"),
522 bod->msgh_descriptor_count);
523 data += sizeof (mach_msg_body_t);
524 size -= sizeof (mach_msg_body_t);
525 for (k = 0; k < bod->msgh_descriptor_count; k++)
526 switch (desc[k].type)
527 {
528 case MACH_MSG_PORT_DESCRIPTOR:
529 printf_unfiltered
530 (_(" descr %d: type=%u (port) name=0x%x, dispo=%d\n"),
531 k, desc[k].type, desc[k].name, desc[k].disposition);
532 break;
533 default:
534 printf_unfiltered (_(" descr %d: type=%u\n"),
535 k, desc[k].type);
536 break;
537 }
538 data += bod->msgh_descriptor_count
539 * sizeof (mach_msg_port_descriptor_t);
540 size -= bod->msgh_descriptor_count
541 * sizeof (mach_msg_port_descriptor_t);
542 ndr = (NDR_record_t *)(desc + bod->msgh_descriptor_count);
543 printf_unfiltered
544 (_("NDR: mig=%02x if=%02x encod=%02x "
545 "int=%02x char=%02x float=%02x\n"),
546 ndr->mig_vers, ndr->if_vers, ndr->mig_encoding,
547 ndr->int_rep, ndr->char_rep, ndr->float_rep);
548 data += sizeof (NDR_record_t);
549 size -= sizeof (NDR_record_t);
550 }
551
552 printf_unfiltered (_(" data:"));
553 ldata = (const unsigned int *)data;
554 for (i = 0; i < size / sizeof (unsigned int); i++)
555 printf_unfiltered (" %08x", ldata[i]);
556 printf_unfiltered (_("\n"));
557 }
558 }
559
560 /* Adjust inferior data when a new task was created. */
561
562 static struct inferior *
563 darwin_find_new_inferior (task_t task_port, thread_t thread_port)
564 {
565 int task_pid;
566 struct inferior *inf;
567 kern_return_t kret;
568 mach_port_t prev;
569
570 /* Find the corresponding pid. */
571 kret = pid_for_task (task_port, &task_pid);
572 if (kret != KERN_SUCCESS)
573 {
574 MACH_CHECK_ERROR (kret);
575 return NULL;
576 }
577
578 /* Find the inferior for this pid. */
579 inf = darwin_find_inferior_by_pid (task_pid);
580 if (inf == NULL)
581 return NULL;
582
583 darwin_inferior *priv = get_darwin_inferior (inf);
584
585 /* Deallocate saved exception ports. */
586 darwin_deallocate_exception_ports (priv);
587
588 /* No need to remove dead_name notification, but still... */
589 kret = mach_port_request_notification (gdb_task, priv->task,
590 MACH_NOTIFY_DEAD_NAME, 0,
591 MACH_PORT_NULL,
592 MACH_MSG_TYPE_MAKE_SEND_ONCE,
593 &prev);
594 if (kret != KERN_INVALID_ARGUMENT)
595 MACH_CHECK_ERROR (kret);
596
597 /* Replace old task port. */
598 kret = mach_port_deallocate (gdb_task, priv->task);
599 MACH_CHECK_ERROR (kret);
600 priv->task = task_port;
601
602 darwin_setup_request_notification (inf);
603 darwin_setup_exceptions (inf);
604
605 return inf;
606 }
607
608 /* Check data representation. */
609
610 static int
611 darwin_check_message_ndr (NDR_record_t *ndr)
612 {
613 if (ndr->mig_vers != NDR_PROTOCOL_2_0
614 || ndr->if_vers != NDR_PROTOCOL_2_0
615 || ndr->mig_encoding != NDR_record.mig_encoding
616 || ndr->int_rep != NDR_record.int_rep
617 || ndr->char_rep != NDR_record.char_rep
618 || ndr->float_rep != NDR_record.float_rep)
619 return -1;
620 return 0;
621 }
622
623 /* Decode an exception message. */
624
625 static int
626 darwin_decode_exception_message (mach_msg_header_t *hdr,
627 struct inferior **pinf,
628 darwin_thread_t **pthread)
629 {
630 mach_msg_body_t *bod = (mach_msg_body_t*)(hdr + 1);
631 mach_msg_port_descriptor_t *desc = (mach_msg_port_descriptor_t *)(bod + 1);
632 NDR_record_t *ndr;
633 integer_t *data;
634 struct inferior *inf;
635 darwin_thread_t *thread;
636 task_t task_port;
637 thread_t thread_port;
638 kern_return_t kret;
639 int i;
640
641 /* Check message destination. */
642 if (hdr->msgh_local_port != darwin_ex_port)
643 return -1;
644
645 /* Check message header. */
646 if (!(hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX))
647 return -1;
648
649 /* Check descriptors. */
650 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
651 + sizeof (*ndr) + 2 * sizeof (integer_t))
652 || bod->msgh_descriptor_count != 2
653 || desc[0].type != MACH_MSG_PORT_DESCRIPTOR
654 || desc[0].disposition != MACH_MSG_TYPE_MOVE_SEND
655 || desc[1].type != MACH_MSG_PORT_DESCRIPTOR
656 || desc[1].disposition != MACH_MSG_TYPE_MOVE_SEND)
657 return -1;
658
659 /* Check data representation. */
660 ndr = (NDR_record_t *)(desc + 2);
661 if (darwin_check_message_ndr (ndr) != 0)
662 return -1;
663
664 /* Ok, the hard work. */
665 data = (integer_t *)(ndr + 1);
666
667 task_port = desc[1].name;
668 thread_port = desc[0].name;
669
670 /* Find process by port. */
671 inf = darwin_find_inferior_by_task (task_port);
672 *pinf = inf;
673
674 if (inf == NULL && data[0] == EXC_SOFTWARE && data[1] == 2
675 && data[2] == EXC_SOFT_SIGNAL && data[3] == SIGTRAP)
676 {
677 /* Not a known inferior, but a sigtrap. This happens on darwin 16.1.0,
678 as a new Mach task is created when a process exec. */
679 inf = darwin_find_new_inferior (task_port, thread_port);
680 *pinf = inf;
681
682 if (inf == NULL)
683 {
684 /* Deallocate task_port, unless it was saved. */
685 kret = mach_port_deallocate (mach_task_self (), task_port);
686 MACH_CHECK_ERROR (kret);
687 }
688 }
689 else
690 {
691 /* We got new rights to the task, get rid of it. Do not get rid of
692 thread right, as we will need it to find the thread. */
693 kret = mach_port_deallocate (mach_task_self (), task_port);
694 MACH_CHECK_ERROR (kret);
695 }
696
697 if (inf == NULL)
698 {
699 /* Not a known inferior. This could happen if the child fork, as
700 the created process will inherit its exception port.
701 FIXME: should the exception port be restored ? */
702 kern_return_t kret;
703 mig_reply_error_t reply;
704
705 inferior_debug
706 (4, _("darwin_decode_exception_message: unknown task 0x%x\n"),
707 task_port);
708
709 /* Free thread port (we don't know it). */
710 kret = mach_port_deallocate (mach_task_self (), thread_port);
711 MACH_CHECK_ERROR (kret);
712
713 darwin_encode_reply (&reply, hdr, KERN_SUCCESS);
714
715 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
716 reply.Head.msgh_size, 0,
717 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
718 MACH_PORT_NULL);
719 MACH_CHECK_ERROR (kret);
720
721 return 0;
722 }
723
724 /* Find thread by port. */
725 /* Check for new threads. Do it early so that the port in the exception
726 message can be deallocated. */
727 darwin_check_new_threads (inf);
728
729 /* Free the thread port (as gdb knows the thread, it has already has a right
730 for it, so this just decrement a reference counter). */
731 kret = mach_port_deallocate (mach_task_self (), thread_port);
732 MACH_CHECK_ERROR (kret);
733
734 thread = darwin_find_thread (inf, thread_port);
735 if (thread == NULL)
736 return -1;
737 *pthread = thread;
738
739 /* The thread should be running. However we have observed cases where a
740 thread got a SIGTTIN message after being stopped. */
741 gdb_assert (thread->msg_state != DARWIN_MESSAGE);
742
743 /* Finish decoding. */
744 thread->event.header = *hdr;
745 thread->event.thread_port = thread_port;
746 thread->event.task_port = task_port;
747 thread->event.ex_type = data[0];
748 thread->event.data_count = data[1];
749
750 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*bod) + 2 * sizeof (*desc)
751 + sizeof (*ndr) + 2 * sizeof (integer_t)
752 + data[1] * sizeof (integer_t)))
753 return -1;
754 for (i = 0; i < data[1]; i++)
755 thread->event.ex_data[i] = data[2 + i];
756
757 thread->msg_state = DARWIN_MESSAGE;
758
759 return 0;
760 }
761
762 /* Decode dead_name notify message. */
763
764 static int
765 darwin_decode_notify_message (mach_msg_header_t *hdr, struct inferior **pinf)
766 {
767 NDR_record_t *ndr = (NDR_record_t *)(hdr + 1);
768 integer_t *data = (integer_t *)(ndr + 1);
769 struct inferior *inf;
770 darwin_thread_t *thread;
771 task_t task_port;
772 thread_t thread_port;
773 kern_return_t kret;
774 int i;
775
776 /* Check message header. */
777 if (hdr->msgh_bits & MACH_MSGH_BITS_COMPLEX)
778 return -1;
779
780 /* Check descriptors. */
781 if (hdr->msgh_size < (sizeof (*hdr) + sizeof (*ndr) + sizeof (integer_t)))
782 return -2;
783
784 /* Check data representation. */
785 if (darwin_check_message_ndr (ndr) != 0)
786 return -3;
787
788 task_port = data[0];
789
790 /* Find process by port. */
791 inf = darwin_find_inferior_by_task (task_port);
792 *pinf = inf;
793
794 darwin_inferior *priv = get_darwin_inferior (inf);
795
796 /* Check message destination. */
797 if (inf != NULL && hdr->msgh_local_port != priv->notify_port)
798 return -4;
799
800 return 0;
801 }
802
803 static void
804 darwin_encode_reply (mig_reply_error_t *reply, mach_msg_header_t *hdr,
805 integer_t code)
806 {
807 mach_msg_header_t *rh = &reply->Head;
808
809 rh->msgh_bits = MACH_MSGH_BITS (MACH_MSGH_BITS_REMOTE (hdr->msgh_bits), 0);
810 rh->msgh_remote_port = hdr->msgh_remote_port;
811 rh->msgh_size = (mach_msg_size_t) sizeof (mig_reply_error_t);
812 rh->msgh_local_port = MACH_PORT_NULL;
813 rh->msgh_id = hdr->msgh_id + 100;
814
815 reply->NDR = NDR_record;
816 reply->RetCode = code;
817 }
818
819 static void
820 darwin_send_reply (struct inferior *inf, darwin_thread_t *thread)
821 {
822 kern_return_t kret;
823 mig_reply_error_t reply;
824 darwin_inferior *priv = get_darwin_inferior (inf);
825
826 darwin_encode_reply (&reply, &thread->event.header, KERN_SUCCESS);
827
828 kret = mach_msg (&reply.Head, MACH_SEND_MSG | MACH_SEND_INTERRUPT,
829 reply.Head.msgh_size, 0,
830 MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
831 MACH_PORT_NULL);
832 MACH_CHECK_ERROR (kret);
833
834 priv->pending_messages--;
835 }
836
837 static void
838 darwin_resume_thread (struct inferior *inf, darwin_thread_t *thread,
839 int step, int nsignal)
840 {
841 kern_return_t kret;
842 int res;
843
844 inferior_debug
845 (3, _("darwin_resume_thread: state=%d, thread=0x%x, step=%d nsignal=%d\n"),
846 thread->msg_state, thread->gdb_port, step, nsignal);
847
848 switch (thread->msg_state)
849 {
850 case DARWIN_MESSAGE:
851 if (thread->event.ex_type == EXC_SOFTWARE
852 && thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
853 {
854 /* Either deliver a new signal or cancel the signal received. */
855 res = PTRACE (PT_THUPDATE, inf->pid,
856 (caddr_t) (uintptr_t) thread->gdb_port, nsignal);
857 if (res < 0)
858 inferior_debug (1, _("ptrace THUP: res=%d\n"), res);
859 }
860 else if (nsignal)
861 {
862 /* Note: ptrace is allowed only if the process is stopped.
863 Directly send the signal to the thread. */
864 res = syscall (SYS___pthread_kill, thread->gdb_port, nsignal);
865 inferior_debug (4, _("darwin_resume_thread: kill 0x%x %d: %d\n"),
866 thread->gdb_port, nsignal, res);
867 thread->signaled = 1;
868 }
869
870 /* Set or reset single step. */
871 inferior_debug (4, _("darwin_set_sstep (thread=0x%x, enable=%d)\n"),
872 thread->gdb_port, step);
873 darwin_set_sstep (thread->gdb_port, step);
874 thread->single_step = step;
875
876 darwin_send_reply (inf, thread);
877 thread->msg_state = DARWIN_RUNNING;
878 break;
879
880 case DARWIN_RUNNING:
881 break;
882
883 case DARWIN_STOPPED:
884 kret = thread_resume (thread->gdb_port);
885 MACH_CHECK_ERROR (kret);
886
887 thread->msg_state = DARWIN_RUNNING;
888 break;
889 }
890 }
891
892 /* Resume all threads of the inferior. */
893
894 static void
895 darwin_resume_inferior_threads (struct inferior *inf, int step, int nsignal)
896 {
897 darwin_inferior *priv = get_darwin_inferior (inf);
898
899 for (darwin_thread_t *thread : priv->threads)
900 darwin_resume_thread (inf, thread, step, nsignal);
901 }
902
903 struct resume_inferior_threads_param
904 {
905 int step;
906 int nsignal;
907 };
908
909 static int
910 darwin_resume_inferior_threads_it (struct inferior *inf, void *param)
911 {
912 int step = ((struct resume_inferior_threads_param *)param)->step;
913 int nsignal = ((struct resume_inferior_threads_param *)param)->nsignal;
914
915 darwin_resume_inferior_threads (inf, step, nsignal);
916
917 return 0;
918 }
919
920 /* Suspend all threads of INF. */
921
922 static void
923 darwin_suspend_inferior_threads (struct inferior *inf)
924 {
925 darwin_inferior *priv = get_darwin_inferior (inf);
926
927 for (darwin_thread_t *thread : priv->threads)
928 {
929 switch (thread->msg_state)
930 {
931 case DARWIN_STOPPED:
932 case DARWIN_MESSAGE:
933 break;
934 case DARWIN_RUNNING:
935 {
936 kern_return_t kret = thread_suspend (thread->gdb_port);
937 MACH_CHECK_ERROR (kret);
938 thread->msg_state = DARWIN_STOPPED;
939 break;
940 }
941 }
942 }
943 }
944
945 static void
946 darwin_resume (ptid_t ptid, int step, enum gdb_signal signal)
947 {
948 struct target_waitstatus status;
949 int pid;
950
951 kern_return_t kret;
952 int res;
953 int nsignal;
954 struct inferior *inf;
955
956 inferior_debug
957 (2, _("darwin_resume: pid=%d, tid=0x%lx, step=%d, signal=%d\n"),
958 ptid_get_pid (ptid), ptid_get_tid (ptid), step, signal);
959
960 if (signal == GDB_SIGNAL_0)
961 nsignal = 0;
962 else
963 nsignal = gdb_signal_to_host (signal);
964
965 /* Don't try to single step all threads. */
966 if (step)
967 ptid = inferior_ptid;
968
969 /* minus_one_ptid is RESUME_ALL. */
970 if (ptid_equal (ptid, minus_one_ptid))
971 {
972 struct resume_inferior_threads_param param;
973
974 param.nsignal = nsignal;
975 param.step = step;
976
977 /* Resume threads. */
978 iterate_over_inferiors (darwin_resume_inferior_threads_it, &param);
979 /* Resume tasks. */
980 iterate_over_inferiors (darwin_resume_inferior_it, NULL);
981 }
982 else
983 {
984 struct inferior *inf = find_inferior_ptid (ptid);
985 long tid = ptid_get_tid (ptid);
986
987 /* Stop the inferior (should be useless). */
988 darwin_suspend_inferior (inf);
989
990 if (tid == 0)
991 darwin_resume_inferior_threads (inf, step, nsignal);
992 else
993 {
994 darwin_thread_t *thread;
995
996 /* Suspend threads of the task. */
997 darwin_suspend_inferior_threads (inf);
998
999 /* Resume the selected thread. */
1000 thread = darwin_find_thread (inf, tid);
1001 gdb_assert (thread);
1002 darwin_resume_thread (inf, thread, step, nsignal);
1003 }
1004
1005 /* Resume the task. */
1006 darwin_resume_inferior (inf);
1007 }
1008 }
1009
1010 static void
1011 darwin_resume_to (struct target_ops *ops, ptid_t ptid, int step,
1012 enum gdb_signal signal)
1013 {
1014 return darwin_resume (ptid, step, signal);
1015 }
1016
1017 static ptid_t
1018 darwin_decode_message (mach_msg_header_t *hdr,
1019 darwin_thread_t **pthread,
1020 struct inferior **pinf,
1021 struct target_waitstatus *status)
1022 {
1023 darwin_thread_t *thread;
1024 struct inferior *inf;
1025
1026 /* Exception message. 2401 == 0x961 is exc. */
1027 if (hdr->msgh_id == 2401)
1028 {
1029 int res;
1030
1031 /* Decode message. */
1032 res = darwin_decode_exception_message (hdr, &inf, &thread);
1033
1034 if (res < 0)
1035 {
1036 /* Should not happen... */
1037 printf_unfiltered
1038 (_("darwin_wait: ill-formatted message (id=0x%x)\n"), hdr->msgh_id);
1039 /* FIXME: send a failure reply? */
1040 status->kind = TARGET_WAITKIND_IGNORE;
1041 return minus_one_ptid;
1042 }
1043 if (inf == NULL)
1044 {
1045 status->kind = TARGET_WAITKIND_IGNORE;
1046 return minus_one_ptid;
1047 }
1048 *pinf = inf;
1049 *pthread = thread;
1050
1051 darwin_inferior *priv = get_darwin_inferior (inf);
1052
1053 priv->pending_messages++;
1054
1055 status->kind = TARGET_WAITKIND_STOPPED;
1056 thread->msg_state = DARWIN_MESSAGE;
1057
1058 inferior_debug (4, _("darwin_wait: thread=0x%x, got %s\n"),
1059 thread->gdb_port,
1060 unparse_exception_type (thread->event.ex_type));
1061
1062 switch (thread->event.ex_type)
1063 {
1064 case EXC_BAD_ACCESS:
1065 status->value.sig = GDB_EXC_BAD_ACCESS;
1066 break;
1067 case EXC_BAD_INSTRUCTION:
1068 status->value.sig = GDB_EXC_BAD_INSTRUCTION;
1069 break;
1070 case EXC_ARITHMETIC:
1071 status->value.sig = GDB_EXC_ARITHMETIC;
1072 break;
1073 case EXC_EMULATION:
1074 status->value.sig = GDB_EXC_EMULATION;
1075 break;
1076 case EXC_SOFTWARE:
1077 if (thread->event.ex_data[0] == EXC_SOFT_SIGNAL)
1078 {
1079 status->value.sig =
1080 gdb_signal_from_host (thread->event.ex_data[1]);
1081 inferior_debug (5, _(" (signal %d: %s)\n"),
1082 thread->event.ex_data[1],
1083 gdb_signal_to_name (status->value.sig));
1084
1085 /* If the thread is stopped because it has received a signal
1086 that gdb has just sent, continue. */
1087 if (thread->signaled)
1088 {
1089 thread->signaled = 0;
1090 darwin_send_reply (inf, thread);
1091 thread->msg_state = DARWIN_RUNNING;
1092 status->kind = TARGET_WAITKIND_IGNORE;
1093 }
1094 }
1095 else
1096 status->value.sig = GDB_EXC_SOFTWARE;
1097 break;
1098 case EXC_BREAKPOINT:
1099 /* Many internal GDB routines expect breakpoints to be reported
1100 as GDB_SIGNAL_TRAP, and will report GDB_EXC_BREAKPOINT
1101 as a spurious signal. */
1102 status->value.sig = GDB_SIGNAL_TRAP;
1103 break;
1104 default:
1105 status->value.sig = GDB_SIGNAL_UNKNOWN;
1106 break;
1107 }
1108
1109 return ptid_build (inf->pid, 0, thread->gdb_port);
1110 }
1111 else if (hdr->msgh_id == 0x48)
1112 {
1113 /* MACH_NOTIFY_DEAD_NAME: notification for exit. */
1114 int res;
1115
1116 res = darwin_decode_notify_message (hdr, &inf);
1117
1118 if (res < 0)
1119 {
1120 /* Should not happen... */
1121 printf_unfiltered
1122 (_("darwin_wait: ill-formatted message (id=0x%x, res=%d)\n"),
1123 hdr->msgh_id, res);
1124 }
1125
1126 *pinf = NULL;
1127 *pthread = NULL;
1128
1129 if (res < 0 || inf == NULL)
1130 {
1131 status->kind = TARGET_WAITKIND_IGNORE;
1132 return minus_one_ptid;
1133 }
1134
1135 if (inf != NULL)
1136 {
1137 darwin_inferior *priv = get_darwin_inferior (inf);
1138
1139 if (!priv->no_ptrace)
1140 {
1141 pid_t res;
1142 int wstatus;
1143
1144 res = wait4 (inf->pid, &wstatus, 0, NULL);
1145 if (res < 0 || res != inf->pid)
1146 {
1147 printf_unfiltered (_("wait4: res=%d: %s\n"),
1148 res, safe_strerror (errno));
1149 status->kind = TARGET_WAITKIND_IGNORE;
1150 return minus_one_ptid;
1151 }
1152 if (WIFEXITED (wstatus))
1153 {
1154 status->kind = TARGET_WAITKIND_EXITED;
1155 status->value.integer = WEXITSTATUS (wstatus);
1156 }
1157 else
1158 {
1159 status->kind = TARGET_WAITKIND_SIGNALLED;
1160 status->value.sig = gdb_signal_from_host (WTERMSIG (wstatus));
1161 }
1162
1163 inferior_debug (4, _("darwin_wait: pid=%d exit, status=0x%x\n"),
1164 res, wstatus);
1165
1166 /* Looks necessary on Leopard and harmless... */
1167 wait4 (inf->pid, &wstatus, 0, NULL);
1168
1169 inferior_ptid = ptid_build (inf->pid, 0, 0);
1170 return inferior_ptid;
1171 }
1172 else
1173 {
1174 inferior_debug (4, _("darwin_wait: pid=%d\n"), inf->pid);
1175 status->kind = TARGET_WAITKIND_EXITED;
1176 status->value.integer = 0; /* Don't know. */
1177 return ptid_build (inf->pid, 0, 0);
1178 }
1179 }
1180 }
1181
1182 /* Unknown message. */
1183 warning (_("darwin: got unknown message, id: 0x%x"), hdr->msgh_id);
1184 status->kind = TARGET_WAITKIND_IGNORE;
1185 return minus_one_ptid;
1186 }
1187
1188 static int
1189 cancel_breakpoint (ptid_t ptid)
1190 {
1191 /* Arrange for a breakpoint to be hit again later. We will handle
1192 the current event, eventually we will resume this thread, and this
1193 breakpoint will trap again.
1194
1195 If we do not do this, then we run the risk that the user will
1196 delete or disable the breakpoint, but the thread will have already
1197 tripped on it. */
1198
1199 struct regcache *regcache = get_thread_regcache (ptid);
1200 struct gdbarch *gdbarch = regcache->arch ();
1201 CORE_ADDR pc;
1202
1203 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
1204 if (breakpoint_inserted_here_p (regcache->aspace (), pc))
1205 {
1206 inferior_debug (4, "cancel_breakpoint for thread 0x%lx\n",
1207 (unsigned long) ptid_get_tid (ptid));
1208
1209 /* Back up the PC if necessary. */
1210 if (gdbarch_decr_pc_after_break (gdbarch))
1211 regcache_write_pc (regcache, pc);
1212
1213 return 1;
1214 }
1215 return 0;
1216 }
1217
1218 static ptid_t
1219 darwin_wait (ptid_t ptid, struct target_waitstatus *status)
1220 {
1221 kern_return_t kret;
1222 union
1223 {
1224 mach_msg_header_t hdr;
1225 char data[0x100];
1226 } msgin;
1227 mach_msg_header_t *hdr = &msgin.hdr;
1228 ptid_t res;
1229 darwin_thread_t *thread;
1230 struct inferior *inf;
1231
1232 inferior_debug
1233 (2, _("darwin_wait: waiting for a message pid=%d thread=%lx\n"),
1234 ptid_get_pid (ptid), ptid_get_tid (ptid));
1235
1236 /* Handle fake stop events at first. */
1237 if (darwin_inf_fake_stop != NULL)
1238 {
1239 inf = darwin_inf_fake_stop;
1240 darwin_inf_fake_stop = NULL;
1241
1242 darwin_inferior *priv = get_darwin_inferior (inf);
1243
1244 status->kind = TARGET_WAITKIND_STOPPED;
1245 status->value.sig = GDB_SIGNAL_TRAP;
1246 thread = priv->threads[0];
1247 thread->msg_state = DARWIN_STOPPED;
1248 return ptid_build (inf->pid, 0, thread->gdb_port);
1249 }
1250
1251 do
1252 {
1253 /* set_sigint_trap (); */
1254
1255 /* Wait for a message. */
1256 kret = mach_msg (&msgin.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0,
1257 sizeof (msgin.data), darwin_port_set, 0, MACH_PORT_NULL);
1258
1259 /* clear_sigint_trap (); */
1260
1261 if (kret == MACH_RCV_INTERRUPTED)
1262 {
1263 status->kind = TARGET_WAITKIND_IGNORE;
1264 return minus_one_ptid;
1265 }
1266
1267 if (kret != MACH_MSG_SUCCESS)
1268 {
1269 inferior_debug (5, _("mach_msg: ret=0x%x\n"), kret);
1270 status->kind = TARGET_WAITKIND_SPURIOUS;
1271 return minus_one_ptid;
1272 }
1273
1274 /* Debug: display message. */
1275 if (darwin_debug_flag > 10)
1276 darwin_dump_message (hdr, darwin_debug_flag > 11);
1277
1278 res = darwin_decode_message (hdr, &thread, &inf, status);
1279 if (ptid_equal (res, minus_one_ptid))
1280 continue;
1281
1282 /* Early return in case an inferior has exited. */
1283 if (inf == NULL)
1284 return res;
1285 }
1286 while (status->kind == TARGET_WAITKIND_IGNORE);
1287
1288 /* Stop all tasks. */
1289 iterate_over_inferiors (darwin_suspend_inferior_it, NULL);
1290
1291 /* Read pending messages. */
1292 while (1)
1293 {
1294 struct target_waitstatus status2;
1295 ptid_t ptid2;
1296
1297 kret = mach_msg (&msgin.hdr,
1298 MACH_RCV_MSG | MACH_RCV_TIMEOUT, 0,
1299 sizeof (msgin.data), darwin_port_set, 1, MACH_PORT_NULL);
1300
1301 if (kret == MACH_RCV_TIMED_OUT)
1302 break;
1303 if (kret != MACH_MSG_SUCCESS)
1304 {
1305 inferior_debug
1306 (5, _("darwin_wait: mach_msg(pending) ret=0x%x\n"), kret);
1307 break;
1308 }
1309
1310 /* Debug: display message. */
1311 if (darwin_debug_flag > 10)
1312 darwin_dump_message (hdr, darwin_debug_flag > 11);
1313
1314 ptid2 = darwin_decode_message (hdr, &thread, &inf, &status2);
1315
1316 if (inf != NULL && thread != NULL
1317 && thread->event.ex_type == EXC_BREAKPOINT)
1318 {
1319 if (thread->single_step
1320 || cancel_breakpoint (ptid_build (inf->pid, 0, thread->gdb_port)))
1321 {
1322 gdb_assert (thread->msg_state == DARWIN_MESSAGE);
1323 darwin_send_reply (inf, thread);
1324 thread->msg_state = DARWIN_RUNNING;
1325 }
1326 else
1327 inferior_debug
1328 (3, _("darwin_wait: thread 0x%x hit a non-gdb breakpoint\n"),
1329 thread->gdb_port);
1330 }
1331 else
1332 inferior_debug (3, _("darwin_wait: unhandled pending message\n"));
1333 }
1334 return res;
1335 }
1336
1337 static ptid_t
1338 darwin_wait_to (struct target_ops *ops,
1339 ptid_t ptid, struct target_waitstatus *status, int options)
1340 {
1341 return darwin_wait (ptid, status);
1342 }
1343
1344 static void
1345 darwin_interrupt (struct target_ops *self, ptid_t t)
1346 {
1347 struct inferior *inf = current_inferior ();
1348 darwin_inferior *priv = get_darwin_inferior (inf);
1349
1350 /* FIXME: handle in no_ptrace mode. */
1351 gdb_assert (!priv->no_ptrace);
1352 kill (inf->pid, SIGINT);
1353 }
1354
1355 /* Deallocate threads port and vector. */
1356
1357 static void
1358 darwin_deallocate_threads (struct inferior *inf)
1359 {
1360 darwin_inferior *priv = get_darwin_inferior (inf);
1361
1362 for (darwin_thread_t *t : priv->threads)
1363 {
1364 kern_return_t kret = mach_port_deallocate (gdb_task, t->gdb_port);
1365 MACH_CHECK_ERROR (kret);
1366 }
1367
1368 priv->threads.clear ();
1369 }
1370
1371 static void
1372 darwin_mourn_inferior (struct target_ops *ops)
1373 {
1374 struct inferior *inf = current_inferior ();
1375 darwin_inferior *priv = get_darwin_inferior (inf);
1376 kern_return_t kret;
1377 mach_port_t prev;
1378 int i;
1379
1380 /* Deallocate threads. */
1381 darwin_deallocate_threads (inf);
1382
1383 /* Remove notify_port from darwin_port_set. */
1384 kret = mach_port_move_member (gdb_task,
1385 priv->notify_port, MACH_PORT_NULL);
1386 MACH_CHECK_ERROR (kret);
1387
1388 /* Remove task port dead_name notification. */
1389 kret = mach_port_request_notification (gdb_task, priv->task,
1390 MACH_NOTIFY_DEAD_NAME, 0,
1391 MACH_PORT_NULL,
1392 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1393 &prev);
1394 /* This can fail if the task is dead. */
1395 inferior_debug (4, "task=0x%x, prev=0x%x, notify_port=0x%x\n",
1396 priv->task, prev, priv->notify_port);
1397
1398 if (kret == KERN_SUCCESS)
1399 {
1400 kret = mach_port_deallocate (gdb_task, prev);
1401 MACH_CHECK_ERROR (kret);
1402 }
1403
1404 /* Destroy notify_port. */
1405 kret = mach_port_destroy (gdb_task, priv->notify_port);
1406 MACH_CHECK_ERROR (kret);
1407
1408 /* Deallocate saved exception ports. */
1409 darwin_deallocate_exception_ports (priv);
1410
1411 /* Deallocate task port. */
1412 kret = mach_port_deallocate (gdb_task, priv->task);
1413 MACH_CHECK_ERROR (kret);
1414
1415 inf->priv = NULL;
1416
1417 inf_child_mourn_inferior (ops);
1418 }
1419
1420 static void
1421 darwin_reply_to_all_pending_messages (struct inferior *inf)
1422 {
1423 darwin_inferior *priv = get_darwin_inferior (inf);
1424
1425 for (darwin_thread_t *t : priv->threads)
1426 {
1427 if (t->msg_state == DARWIN_MESSAGE)
1428 darwin_resume_thread (inf, t, 0, 0);
1429 }
1430 }
1431
1432 static void
1433 darwin_stop_inferior (struct inferior *inf)
1434 {
1435 struct target_waitstatus wstatus;
1436 ptid_t ptid;
1437 kern_return_t kret;
1438 int status;
1439 int res;
1440 darwin_inferior *priv = get_darwin_inferior (inf);
1441
1442 gdb_assert (inf != NULL);
1443
1444 darwin_suspend_inferior (inf);
1445
1446 darwin_reply_to_all_pending_messages (inf);
1447
1448 if (priv->no_ptrace)
1449 return;
1450
1451 res = kill (inf->pid, SIGSTOP);
1452 if (res != 0)
1453 warning (_("cannot kill: %s"), safe_strerror (errno));
1454
1455 /* Wait until the process is really stopped. */
1456 while (1)
1457 {
1458 ptid = darwin_wait (inferior_ptid, &wstatus);
1459 if (wstatus.kind == TARGET_WAITKIND_STOPPED
1460 && wstatus.value.sig == GDB_SIGNAL_STOP)
1461 break;
1462 }
1463 }
1464
1465 static kern_return_t
1466 darwin_save_exception_ports (darwin_inferior *inf)
1467 {
1468 kern_return_t kret;
1469
1470 inf->exception_info.count =
1471 sizeof (inf->exception_info.ports) / sizeof (inf->exception_info.ports[0]);
1472
1473 kret = task_get_exception_ports
1474 (inf->task, EXC_MASK_ALL, inf->exception_info.masks,
1475 &inf->exception_info.count, inf->exception_info.ports,
1476 inf->exception_info.behaviors, inf->exception_info.flavors);
1477 return kret;
1478 }
1479
1480 static kern_return_t
1481 darwin_restore_exception_ports (darwin_inferior *inf)
1482 {
1483 int i;
1484 kern_return_t kret;
1485
1486 for (i = 0; i < inf->exception_info.count; i++)
1487 {
1488 kret = task_set_exception_ports
1489 (inf->task, inf->exception_info.masks[i], inf->exception_info.ports[i],
1490 inf->exception_info.behaviors[i], inf->exception_info.flavors[i]);
1491 if (kret != KERN_SUCCESS)
1492 return kret;
1493 }
1494
1495 return KERN_SUCCESS;
1496 }
1497
1498 /* Deallocate saved exception ports. */
1499
1500 static void
1501 darwin_deallocate_exception_ports (darwin_inferior *inf)
1502 {
1503 int i;
1504 kern_return_t kret;
1505
1506 for (i = 0; i < inf->exception_info.count; i++)
1507 {
1508 kret = mach_port_deallocate (gdb_task, inf->exception_info.ports[i]);
1509 MACH_CHECK_ERROR (kret);
1510 }
1511 inf->exception_info.count = 0;
1512 }
1513
1514 static void
1515 darwin_setup_exceptions (struct inferior *inf)
1516 {
1517 darwin_inferior *priv = get_darwin_inferior (inf);
1518 kern_return_t kret;
1519 int traps_expected;
1520 exception_mask_t mask;
1521
1522 kret = darwin_save_exception_ports (priv);
1523 if (kret != KERN_SUCCESS)
1524 error (_("Unable to save exception ports, task_get_exception_ports"
1525 "returned: %d"),
1526 kret);
1527
1528 /* Set exception port. */
1529 if (enable_mach_exceptions)
1530 mask = EXC_MASK_ALL;
1531 else
1532 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
1533 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
1534 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
1535 if (kret != KERN_SUCCESS)
1536 error (_("Unable to set exception ports, task_set_exception_ports"
1537 "returned: %d"),
1538 kret);
1539 }
1540
1541 static void
1542 darwin_kill_inferior (struct target_ops *ops)
1543 {
1544 struct inferior *inf = current_inferior ();
1545 darwin_inferior *priv = get_darwin_inferior (inf);
1546 struct target_waitstatus wstatus;
1547 ptid_t ptid;
1548 kern_return_t kret;
1549 int status;
1550 int res;
1551
1552 if (ptid_equal (inferior_ptid, null_ptid))
1553 return;
1554
1555 gdb_assert (inf != NULL);
1556
1557 kret = darwin_restore_exception_ports (priv);
1558 MACH_CHECK_ERROR (kret);
1559
1560 darwin_reply_to_all_pending_messages (inf);
1561
1562 res = kill (inf->pid, 9);
1563
1564 if (res == 0)
1565 {
1566 darwin_resume_inferior (inf);
1567
1568 ptid = darwin_wait (inferior_ptid, &wstatus);
1569 }
1570 else if (errno != ESRCH)
1571 warning (_("Failed to kill inferior: kill (%d, 9) returned [%s]"),
1572 inf->pid, safe_strerror (errno));
1573
1574 target_mourn_inferior (inferior_ptid);
1575 }
1576
1577 static void
1578 darwin_setup_request_notification (struct inferior *inf)
1579 {
1580 darwin_inferior *priv = get_darwin_inferior (inf);
1581 kern_return_t kret;
1582 mach_port_t prev_not;
1583
1584 kret = mach_port_request_notification (gdb_task, priv->task,
1585 MACH_NOTIFY_DEAD_NAME, 0,
1586 priv->notify_port,
1587 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1588 &prev_not);
1589 if (kret != KERN_SUCCESS)
1590 error (_("Termination notification request failed, "
1591 "mach_port_request_notification\n"
1592 "returned: %d"),
1593 kret);
1594 if (prev_not != MACH_PORT_NULL)
1595 {
1596 /* This is unexpected, as there should not be any previously
1597 registered notification request. But this is not a fatal
1598 issue, so just emit a warning. */
1599 warning (_("\
1600 A task termination request was registered before the debugger registered\n\
1601 its own. This is unexpected, but should otherwise not have any actual\n\
1602 impact on the debugging session."));
1603 }
1604 }
1605
1606 static void
1607 darwin_attach_pid (struct inferior *inf)
1608 {
1609 kern_return_t kret;
1610 mach_port_t prev_port;
1611 int traps_expected;
1612 mach_port_t prev_not;
1613 exception_mask_t mask;
1614
1615 darwin_inferior *priv = new darwin_inferior;
1616 inf->priv.reset (priv);
1617
1618 kret = task_for_pid (gdb_task, inf->pid, &priv->task);
1619 if (kret != KERN_SUCCESS)
1620 {
1621 int status;
1622
1623 if (!inf->attach_flag)
1624 {
1625 kill (inf->pid, 9);
1626 waitpid (inf->pid, &status, 0);
1627 }
1628
1629 error (_("Unable to find Mach task port for process-id %d: %s (0x%lx).\n"
1630 " (please check gdb is codesigned - see taskgated(8))"),
1631 inf->pid, mach_error_string (kret), (unsigned long) kret);
1632 }
1633
1634 inferior_debug (2, _("inferior task: 0x%x, pid: %d\n"),
1635 priv->task, inf->pid);
1636
1637 if (darwin_ex_port == MACH_PORT_NULL)
1638 {
1639 /* Create a port to get exceptions. */
1640 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1641 &darwin_ex_port);
1642 if (kret != KERN_SUCCESS)
1643 error (_("Unable to create exception port, mach_port_allocate "
1644 "returned: %d"),
1645 kret);
1646
1647 kret = mach_port_insert_right (gdb_task, darwin_ex_port, darwin_ex_port,
1648 MACH_MSG_TYPE_MAKE_SEND);
1649 if (kret != KERN_SUCCESS)
1650 error (_("Unable to create exception port, mach_port_insert_right "
1651 "returned: %d"),
1652 kret);
1653
1654 /* Create a port set and put ex_port in it. */
1655 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_PORT_SET,
1656 &darwin_port_set);
1657 if (kret != KERN_SUCCESS)
1658 error (_("Unable to create port set, mach_port_allocate "
1659 "returned: %d"),
1660 kret);
1661
1662 kret = mach_port_move_member (gdb_task, darwin_ex_port, darwin_port_set);
1663 if (kret != KERN_SUCCESS)
1664 error (_("Unable to move exception port into new port set, "
1665 "mach_port_move_member\n"
1666 "returned: %d"),
1667 kret);
1668 }
1669
1670 /* Create a port to be notified when the child task terminates. */
1671 kret = mach_port_allocate (gdb_task, MACH_PORT_RIGHT_RECEIVE,
1672 &priv->notify_port);
1673 if (kret != KERN_SUCCESS)
1674 error (_("Unable to create notification port, mach_port_allocate "
1675 "returned: %d"),
1676 kret);
1677
1678 kret = mach_port_move_member (gdb_task,
1679 priv->notify_port, darwin_port_set);
1680 if (kret != KERN_SUCCESS)
1681 error (_("Unable to move notification port into new port set, "
1682 "mach_port_move_member\n"
1683 "returned: %d"),
1684 kret);
1685
1686 darwin_setup_request_notification (inf);
1687
1688 darwin_setup_exceptions (inf);
1689
1690 if (!target_is_pushed (darwin_ops))
1691 push_target (darwin_ops);
1692 }
1693
1694 /* Get the thread_info object corresponding to this darwin_thread_info. */
1695
1696 static struct thread_info *
1697 thread_info_from_private_thread_info (darwin_thread_info *pti)
1698 {
1699 struct thread_info *it;
1700
1701 ALL_THREADS (it)
1702 {
1703 darwin_thread_info *iter_pti = get_darwin_thread_info (it);
1704
1705 if (iter_pti->gdb_port == pti->gdb_port)
1706 break;
1707 }
1708
1709 gdb_assert (it != NULL);
1710
1711 return it;
1712 }
1713
1714 static void
1715 darwin_init_thread_list (struct inferior *inf)
1716 {
1717 darwin_check_new_threads (inf);
1718
1719 darwin_inferior *priv = get_darwin_inferior (inf);
1720
1721 gdb_assert (!priv->threads.empty ());
1722
1723 darwin_thread_info *first_pti = priv->threads.front ();
1724 struct thread_info *first_thread
1725 = thread_info_from_private_thread_info (first_pti);
1726
1727 inferior_ptid = first_thread->ptid;
1728 }
1729
1730 /* The child must synchronize with gdb: gdb must set the exception port
1731 before the child call PTRACE_SIGEXC. We use a pipe to achieve this.
1732 FIXME: is there a lighter way ? */
1733 static int ptrace_fds[2];
1734
1735 static void
1736 darwin_ptrace_me (void)
1737 {
1738 int res;
1739 char c;
1740
1741 /* Close write end point. */
1742 if (close (ptrace_fds[1]) < 0)
1743 trace_start_error_with_name ("close");
1744
1745 /* Wait until gdb is ready. */
1746 res = read (ptrace_fds[0], &c, 1);
1747 if (res != 0)
1748 trace_start_error (_("unable to read from pipe, read returned: %d"), res);
1749
1750 if (close (ptrace_fds[0]) < 0)
1751 trace_start_error_with_name ("close");
1752
1753 /* Get rid of privileges. */
1754 if (setegid (getgid ()) < 0)
1755 trace_start_error_with_name ("setegid");
1756
1757 /* Set TRACEME. */
1758 if (PTRACE (PT_TRACE_ME, 0, 0, 0) < 0)
1759 trace_start_error_with_name ("PTRACE");
1760
1761 /* Redirect signals to exception port. */
1762 if (PTRACE (PT_SIGEXC, 0, 0, 0) < 0)
1763 trace_start_error_with_name ("PTRACE");
1764 }
1765
1766 /* Dummy function to be sure fork_inferior uses fork(2) and not vfork(2). */
1767 static void
1768 darwin_pre_ptrace (void)
1769 {
1770 if (pipe (ptrace_fds) != 0)
1771 {
1772 ptrace_fds[0] = -1;
1773 ptrace_fds[1] = -1;
1774 error (_("unable to create a pipe: %s"), safe_strerror (errno));
1775 }
1776
1777 mark_fd_no_cloexec (ptrace_fds[0]);
1778 mark_fd_no_cloexec (ptrace_fds[1]);
1779 }
1780
1781 static void
1782 darwin_ptrace_him (int pid)
1783 {
1784 task_t itask;
1785 kern_return_t kret;
1786 mach_port_t prev_port;
1787 int traps_expected;
1788 struct inferior *inf = current_inferior ();
1789
1790 darwin_attach_pid (inf);
1791
1792 /* Let's the child run. */
1793 close (ptrace_fds[0]);
1794 close (ptrace_fds[1]);
1795
1796 unmark_fd_no_cloexec (ptrace_fds[0]);
1797 unmark_fd_no_cloexec (ptrace_fds[1]);
1798
1799 darwin_init_thread_list (inf);
1800
1801 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
1802 }
1803
1804 static void
1805 darwin_execvp (const char *file, char * const argv[], char * const env[])
1806 {
1807 posix_spawnattr_t attr;
1808 short ps_flags = 0;
1809 int res;
1810
1811 res = posix_spawnattr_init (&attr);
1812 if (res != 0)
1813 {
1814 fprintf_unfiltered
1815 (gdb_stderr, "Cannot initialize attribute for posix_spawn\n");
1816 return;
1817 }
1818
1819 /* Do like execve: replace the image. */
1820 ps_flags = POSIX_SPAWN_SETEXEC;
1821
1822 /* Disable ASLR. The constant doesn't look to be available outside the
1823 kernel include files. */
1824 #ifndef _POSIX_SPAWN_DISABLE_ASLR
1825 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
1826 #endif
1827 ps_flags |= _POSIX_SPAWN_DISABLE_ASLR;
1828 res = posix_spawnattr_setflags (&attr, ps_flags);
1829 if (res != 0)
1830 {
1831 fprintf_unfiltered (gdb_stderr, "Cannot set posix_spawn flags\n");
1832 return;
1833 }
1834
1835 posix_spawnp (NULL, argv[0], NULL, &attr, argv, env);
1836 }
1837
1838 static void
1839 darwin_create_inferior (struct target_ops *ops,
1840 const char *exec_file,
1841 const std::string &allargs,
1842 char **env, int from_tty)
1843 {
1844 /* Do the hard work. */
1845 fork_inferior (exec_file, allargs, env, darwin_ptrace_me,
1846 darwin_ptrace_him, darwin_pre_ptrace, NULL,
1847 darwin_execvp);
1848 }
1849
1850
1851 /* Set things up such that the next call to darwin_wait will immediately
1852 return a fake stop event for inferior INF.
1853
1854 This assumes that the inferior's thread list has been initialized,
1855 as it will suspend the inferior's first thread. */
1856
1857 static void
1858 darwin_setup_fake_stop_event (struct inferior *inf)
1859 {
1860 darwin_inferior *priv = get_darwin_inferior (inf);
1861 darwin_thread_t *thread;
1862 kern_return_t kret;
1863
1864 gdb_assert (darwin_inf_fake_stop == NULL);
1865 darwin_inf_fake_stop = inf;
1866
1867 /* When detecting a fake pending stop event, darwin_wait returns
1868 an event saying that the first thread is in a DARWIN_STOPPED
1869 state. To make that accurate, we need to suspend that thread
1870 as well. Otherwise, we'll try resuming it when resuming the
1871 inferior, and get a warning because the thread's suspend count
1872 is already zero, making the resume request useless. */
1873 thread = priv->threads[0];
1874 kret = thread_suspend (thread->gdb_port);
1875 MACH_CHECK_ERROR (kret);
1876 }
1877
1878 /* Attach to process PID, then initialize for debugging it
1879 and wait for the trace-trap that results from attaching. */
1880 static void
1881 darwin_attach (struct target_ops *ops, const char *args, int from_tty)
1882 {
1883 pid_t pid;
1884 pid_t pid2;
1885 int wstatus;
1886 int res;
1887 struct inferior *inf;
1888 kern_return_t kret;
1889
1890 pid = parse_pid_to_attach (args);
1891
1892 if (pid == getpid ()) /* Trying to masturbate? */
1893 error (_("I refuse to debug myself!"));
1894
1895 if (from_tty)
1896 {
1897 char *exec_file = get_exec_file (0);
1898
1899 if (exec_file)
1900 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
1901 target_pid_to_str (pid_to_ptid (pid)));
1902 else
1903 printf_unfiltered (_("Attaching to %s\n"),
1904 target_pid_to_str (pid_to_ptid (pid)));
1905
1906 gdb_flush (gdb_stdout);
1907 }
1908
1909 if (pid == 0 || kill (pid, 0) < 0)
1910 error (_("Can't attach to process %d: %s (%d)"),
1911 pid, safe_strerror (errno), errno);
1912
1913 inferior_ptid = pid_to_ptid (pid);
1914 inf = current_inferior ();
1915 inferior_appeared (inf, pid);
1916 inf->attach_flag = 1;
1917
1918 darwin_attach_pid (inf);
1919
1920 darwin_suspend_inferior (inf);
1921
1922 darwin_init_thread_list (inf);
1923
1924 darwin_inferior *priv = get_darwin_inferior (inf);
1925
1926 darwin_check_osabi (priv, ptid_get_tid (inferior_ptid));
1927
1928 darwin_setup_fake_stop_event (inf);
1929
1930 priv->no_ptrace = 1;
1931 }
1932
1933 /* Take a program previously attached to and detaches it.
1934 The program resumes execution and will no longer stop
1935 on signals, etc. We'd better not have left any breakpoints
1936 in the program or it'll die when it hits one. For this
1937 to work, it may be necessary for the process to have been
1938 previously attached. It *might* work if the program was
1939 started via fork. */
1940 static void
1941 darwin_detach (struct target_ops *ops, const char *args, int from_tty)
1942 {
1943 pid_t pid = ptid_get_pid (inferior_ptid);
1944 struct inferior *inf = current_inferior ();
1945 darwin_inferior *priv = get_darwin_inferior (inf);
1946 kern_return_t kret;
1947 int res;
1948
1949 /* Display message. */
1950 target_announce_detach (from_tty);
1951
1952 /* If ptrace() is in use, stop the process. */
1953 if (!priv->no_ptrace)
1954 darwin_stop_inferior (inf);
1955
1956 kret = darwin_restore_exception_ports (priv);
1957 MACH_CHECK_ERROR (kret);
1958
1959 if (!priv->no_ptrace)
1960 {
1961 res = PTRACE (PT_DETACH, inf->pid, 0, 0);
1962 if (res != 0)
1963 printf_unfiltered (_("Unable to detach from process-id %d: %s (%d)"),
1964 inf->pid, safe_strerror (errno), errno);
1965 }
1966
1967 darwin_reply_to_all_pending_messages (inf);
1968
1969 /* When using ptrace, we have just performed a PT_DETACH, which
1970 resumes the inferior. On the other hand, when we are not using
1971 ptrace, we need to resume its execution ourselves. */
1972 if (priv->no_ptrace)
1973 darwin_resume_inferior (inf);
1974
1975 darwin_mourn_inferior (ops);
1976 }
1977
1978 static void
1979 darwin_files_info (struct target_ops *ops)
1980 {
1981 }
1982
1983 static const char *
1984 darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
1985 {
1986 static char buf[80];
1987 long tid = ptid_get_tid (ptid);
1988
1989 if (tid != 0)
1990 {
1991 snprintf (buf, sizeof (buf), _("Thread 0x%lx of process %u"),
1992 tid, ptid_get_pid (ptid));
1993 return buf;
1994 }
1995
1996 return normal_pid_to_str (ptid);
1997 }
1998
1999 static int
2000 darwin_thread_alive (struct target_ops *ops, ptid_t ptid)
2001 {
2002 return 1;
2003 }
2004
2005 /* If RDADDR is not NULL, read inferior task's LEN bytes from ADDR and
2006 copy it to RDADDR in gdb's address space.
2007 If WRADDR is not NULL, write gdb's LEN bytes from WRADDR and copy it
2008 to ADDR in inferior task's address space.
2009 Return 0 on failure; number of bytes read / writen otherwise. */
2010
2011 static int
2012 darwin_read_write_inferior (task_t task, CORE_ADDR addr,
2013 gdb_byte *rdaddr, const gdb_byte *wraddr,
2014 ULONGEST length)
2015 {
2016 kern_return_t kret;
2017 mach_vm_size_t res_length = 0;
2018 pointer_t copied;
2019 mach_msg_type_number_t copy_count;
2020 mach_vm_size_t remaining_length;
2021 mach_vm_address_t region_address;
2022 mach_vm_size_t region_length;
2023
2024 inferior_debug (8, _("darwin_read_write_inferior(task=0x%x, %s, len=%s)\n"),
2025 task, core_addr_to_string (addr), pulongest (length));
2026
2027 /* First read. */
2028 if (rdaddr != NULL)
2029 {
2030 mach_vm_size_t count;
2031
2032 /* According to target.h(to_xfer_partial), one and only one may be
2033 non-null. */
2034 gdb_assert (wraddr == NULL);
2035
2036 kret = mach_vm_read_overwrite (task, addr, length,
2037 (mach_vm_address_t) rdaddr, &count);
2038 if (kret != KERN_SUCCESS)
2039 {
2040 inferior_debug
2041 (1, _("darwin_read_write_inferior: mach_vm_read failed at %s: %s"),
2042 core_addr_to_string (addr), mach_error_string (kret));
2043 return 0;
2044 }
2045 return count;
2046 }
2047
2048 /* See above. */
2049 gdb_assert (wraddr != NULL);
2050
2051 while (length != 0)
2052 {
2053 mach_vm_address_t offset = addr & (mach_page_size - 1);
2054 mach_vm_address_t region_address = (mach_vm_address_t) (addr - offset);
2055 mach_vm_size_t aligned_length =
2056 (mach_vm_size_t) PAGE_ROUND (offset + length);
2057 vm_region_submap_short_info_data_64_t info;
2058 mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
2059 natural_t region_depth = 1000;
2060 mach_vm_address_t region_start = region_address;
2061 mach_vm_size_t region_length;
2062 mach_vm_size_t write_length;
2063
2064 /* Read page protection. */
2065 kret = mach_vm_region_recurse
2066 (task, &region_start, &region_length, &region_depth,
2067 (vm_region_recurse_info_t) &info, &count);
2068
2069 if (kret != KERN_SUCCESS)
2070 {
2071 inferior_debug (1, _("darwin_read_write_inferior: "
2072 "mach_vm_region_recurse failed at %s: %s\n"),
2073 core_addr_to_string (region_address),
2074 mach_error_string (kret));
2075 return res_length;
2076 }
2077
2078 inferior_debug
2079 (9, _("darwin_read_write_inferior: "
2080 "mach_vm_region_recurse addr=%s, start=%s, len=%s\n"),
2081 core_addr_to_string (region_address),
2082 core_addr_to_string (region_start),
2083 core_addr_to_string (region_length));
2084
2085 /* Check for holes in memory. */
2086 if (region_start > region_address)
2087 {
2088 warning (_("No memory at %s (vs %s+0x%x). Nothing written"),
2089 core_addr_to_string (region_address),
2090 core_addr_to_string (region_start),
2091 (unsigned)region_length);
2092 return res_length;
2093 }
2094
2095 /* Adjust the length. */
2096 region_length -= (region_address - region_start);
2097 if (region_length > aligned_length)
2098 region_length = aligned_length;
2099
2100 /* Make the pages RW. */
2101 if (!(info.protection & VM_PROT_WRITE))
2102 {
2103 vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
2104
2105 kret = mach_vm_protect (task, region_address, region_length,
2106 FALSE, prot);
2107 if (kret != KERN_SUCCESS)
2108 {
2109 prot |= VM_PROT_COPY;
2110 kret = mach_vm_protect (task, region_address, region_length,
2111 FALSE, prot);
2112 }
2113 if (kret != KERN_SUCCESS)
2114 {
2115 warning (_("darwin_read_write_inferior: "
2116 "mach_vm_protect failed at %s "
2117 "(len=0x%lx, prot=0x%x): %s"),
2118 core_addr_to_string (region_address),
2119 (unsigned long) region_length, (unsigned) prot,
2120 mach_error_string (kret));
2121 return res_length;
2122 }
2123 }
2124
2125 if (offset + length > region_length)
2126 write_length = region_length - offset;
2127 else
2128 write_length = length;
2129
2130 /* Write. */
2131 kret = mach_vm_write (task, addr, (vm_offset_t) wraddr, write_length);
2132 if (kret != KERN_SUCCESS)
2133 {
2134 warning (_("darwin_read_write_inferior: mach_vm_write failed: %s"),
2135 mach_error_string (kret));
2136 return res_length;
2137 }
2138
2139 /* Restore page rights. */
2140 if (!(info.protection & VM_PROT_WRITE))
2141 {
2142 kret = mach_vm_protect (task, region_address, region_length,
2143 FALSE, info.protection);
2144 if (kret != KERN_SUCCESS)
2145 {
2146 warning (_("darwin_read_write_inferior: "
2147 "mach_vm_protect restore failed at %s "
2148 "(len=0x%lx): %s"),
2149 core_addr_to_string (region_address),
2150 (unsigned long) region_length,
2151 mach_error_string (kret));
2152 }
2153 }
2154
2155 addr += write_length;
2156 wraddr += write_length;
2157 res_length += write_length;
2158 length -= write_length;
2159 }
2160
2161 return res_length;
2162 }
2163
2164 /* Read LENGTH bytes at offset ADDR of task_dyld_info for TASK, and copy them
2165 to RDADDR (in big endian).
2166 Return 0 on failure; number of bytes read / written otherwise. */
2167
2168 #ifdef TASK_DYLD_INFO_COUNT
2169 /* This is not available in Darwin 9. */
2170 static enum target_xfer_status
2171 darwin_read_dyld_info (task_t task, CORE_ADDR addr, gdb_byte *rdaddr,
2172 ULONGEST length, ULONGEST *xfered_len)
2173 {
2174 struct task_dyld_info task_dyld_info;
2175 mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
2176 int sz = TASK_DYLD_INFO_COUNT * sizeof (natural_t);
2177 kern_return_t kret;
2178
2179 if (addr != 0 || length > sizeof (mach_vm_address_t))
2180 return TARGET_XFER_EOF;
2181
2182 kret = task_info (task, TASK_DYLD_INFO,
2183 (task_info_t) &task_dyld_info, &count);
2184 MACH_CHECK_ERROR (kret);
2185 if (kret != KERN_SUCCESS)
2186 return TARGET_XFER_E_IO;
2187
2188 store_unsigned_integer (rdaddr, length, BFD_ENDIAN_BIG,
2189 task_dyld_info.all_image_info_addr);
2190 *xfered_len = (ULONGEST) length;
2191 return TARGET_XFER_OK;
2192 }
2193 #endif
2194
2195
2196
2197 static enum target_xfer_status
2198 darwin_xfer_partial (struct target_ops *ops,
2199 enum target_object object, const char *annex,
2200 gdb_byte *readbuf, const gdb_byte *writebuf,
2201 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
2202 {
2203 struct inferior *inf = current_inferior ();
2204 darwin_inferior *priv = get_darwin_inferior (inf);
2205
2206 inferior_debug
2207 (8, _("darwin_xfer_partial(%s, %s, rbuf=%s, wbuf=%s) pid=%u\n"),
2208 core_addr_to_string (offset), pulongest (len),
2209 host_address_to_string (readbuf), host_address_to_string (writebuf),
2210 inf->pid);
2211
2212 switch (object)
2213 {
2214 case TARGET_OBJECT_MEMORY:
2215 {
2216 int l = darwin_read_write_inferior (priv->task, offset,
2217 readbuf, writebuf, len);
2218
2219 if (l == 0)
2220 return TARGET_XFER_EOF;
2221 else
2222 {
2223 gdb_assert (l > 0);
2224 *xfered_len = (ULONGEST) l;
2225 return TARGET_XFER_OK;
2226 }
2227 }
2228 #ifdef TASK_DYLD_INFO_COUNT
2229 case TARGET_OBJECT_DARWIN_DYLD_INFO:
2230 if (writebuf != NULL || readbuf == NULL)
2231 {
2232 /* Support only read. */
2233 return TARGET_XFER_E_IO;
2234 }
2235 return darwin_read_dyld_info (priv->task, offset, readbuf, len,
2236 xfered_len);
2237 #endif
2238 default:
2239 return TARGET_XFER_E_IO;
2240 }
2241
2242 }
2243
2244 static void
2245 set_enable_mach_exceptions (const char *args, int from_tty,
2246 struct cmd_list_element *c)
2247 {
2248 if (!ptid_equal (inferior_ptid, null_ptid))
2249 {
2250 struct inferior *inf = current_inferior ();
2251 darwin_inferior *priv = get_darwin_inferior (inf);
2252 exception_mask_t mask;
2253 kern_return_t kret;
2254
2255 if (enable_mach_exceptions)
2256 mask = EXC_MASK_ALL;
2257 else
2258 {
2259 darwin_restore_exception_ports (priv);
2260 mask = EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT;
2261 }
2262 kret = task_set_exception_ports (priv->task, mask, darwin_ex_port,
2263 EXCEPTION_DEFAULT, THREAD_STATE_NONE);
2264 MACH_CHECK_ERROR (kret);
2265 }
2266 }
2267
2268 static char *
2269 darwin_pid_to_exec_file (struct target_ops *self, int pid)
2270 {
2271 static char path[PATH_MAX];
2272 int res;
2273
2274 res = proc_pidinfo (pid, PROC_PIDPATHINFO, 0, path, PATH_MAX);
2275 if (res >= 0)
2276 return path;
2277 else
2278 return NULL;
2279 }
2280
2281 static ptid_t
2282 darwin_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
2283 {
2284 struct inferior *inf = current_inferior ();
2285 darwin_inferior *priv = get_darwin_inferior (inf);
2286 kern_return_t kret;
2287 mach_port_name_array_t names;
2288 mach_msg_type_number_t names_count;
2289 mach_port_type_array_t types;
2290 mach_msg_type_number_t types_count;
2291 long res = 0;
2292
2293 /* First linear search. */
2294 for (darwin_thread_t *t : priv->threads)
2295 {
2296 if (t->inf_port == lwp)
2297 return ptid_build (ptid_get_pid (inferior_ptid), 0, t->gdb_port);
2298 }
2299
2300 /* Maybe the port was never extract. Do it now. */
2301
2302 /* First get inferior port names. */
2303 kret = mach_port_names (priv->task, &names, &names_count, &types,
2304 &types_count);
2305 MACH_CHECK_ERROR (kret);
2306 if (kret != KERN_SUCCESS)
2307 return null_ptid;
2308
2309 /* For each name, copy the right in the gdb space and then compare with
2310 our view of the inferior threads. We don't forget to deallocate the
2311 right. */
2312 for (int i = 0; i < names_count; i++)
2313 {
2314 mach_port_t local_name;
2315 mach_msg_type_name_t local_type;
2316
2317 /* We just need to know the corresponding name in gdb name space.
2318 So extract and deallocate the right. */
2319 kret = mach_port_extract_right (priv->task, names[i],
2320 MACH_MSG_TYPE_COPY_SEND,
2321 &local_name, &local_type);
2322 if (kret != KERN_SUCCESS)
2323 continue;
2324 mach_port_deallocate (gdb_task, local_name);
2325
2326 for (darwin_thread_t *t : priv->threads)
2327 {
2328 if (t->gdb_port == local_name)
2329 {
2330 t->inf_port = names[i];
2331 if (names[i] == lwp)
2332 res = t->gdb_port;
2333 }
2334 }
2335 }
2336
2337 vm_deallocate (gdb_task, (vm_address_t) names,
2338 names_count * sizeof (mach_port_t));
2339
2340 if (res)
2341 return ptid_build (ptid_get_pid (inferior_ptid), 0, res);
2342 else
2343 return null_ptid;
2344 }
2345
2346 static int
2347 darwin_supports_multi_process (struct target_ops *self)
2348 {
2349 return 1;
2350 }
2351
2352 void
2353 _initialize_darwin_inferior (void)
2354 {
2355 kern_return_t kret;
2356
2357 gdb_task = mach_task_self ();
2358 darwin_host_self = mach_host_self ();
2359
2360 /* Read page size. */
2361 kret = host_page_size (darwin_host_self, &mach_page_size);
2362 if (kret != KERN_SUCCESS)
2363 {
2364 mach_page_size = 0x1000;
2365 MACH_CHECK_ERROR (kret);
2366 }
2367
2368 darwin_ops = inf_child_target ();
2369
2370 darwin_ops->to_create_inferior = darwin_create_inferior;
2371 darwin_ops->to_attach = darwin_attach;
2372 darwin_ops->to_attach_no_wait = 0;
2373 darwin_ops->to_detach = darwin_detach;
2374 darwin_ops->to_files_info = darwin_files_info;
2375 darwin_ops->to_wait = darwin_wait_to;
2376 darwin_ops->to_mourn_inferior = darwin_mourn_inferior;
2377 darwin_ops->to_kill = darwin_kill_inferior;
2378 darwin_ops->to_interrupt = darwin_interrupt;
2379 darwin_ops->to_resume = darwin_resume_to;
2380 darwin_ops->to_thread_alive = darwin_thread_alive;
2381 darwin_ops->to_pid_to_str = darwin_pid_to_str;
2382 darwin_ops->to_pid_to_exec_file = darwin_pid_to_exec_file;
2383 darwin_ops->to_load = NULL;
2384 darwin_ops->to_xfer_partial = darwin_xfer_partial;
2385 darwin_ops->to_supports_multi_process = darwin_supports_multi_process;
2386 darwin_ops->to_get_ada_task_ptid = darwin_get_ada_task_ptid;
2387
2388 darwin_complete_target (darwin_ops);
2389
2390 add_target (darwin_ops);
2391
2392 inferior_debug (2, _("GDB task: 0x%lx, pid: %d\n"),
2393 (unsigned long) mach_task_self (), getpid ());
2394
2395 add_setshow_zuinteger_cmd ("darwin", class_obscure,
2396 &darwin_debug_flag, _("\
2397 Set if printing inferior communication debugging statements."), _("\
2398 Show if printing inferior communication debugging statements."), NULL,
2399 NULL, NULL,
2400 &setdebuglist, &showdebuglist);
2401
2402 add_setshow_boolean_cmd ("mach-exceptions", class_support,
2403 &enable_mach_exceptions, _("\
2404 Set if mach exceptions are caught."), _("\
2405 Show if mach exceptions are caught."), _("\
2406 When this mode is on, all low level exceptions are reported before being\n\
2407 reported by the kernel."),
2408 &set_enable_mach_exceptions, NULL,
2409 &setlist, &showlist);
2410 }
darwin_setup_request_notification
static void darwin_setup_request_notification(struct inferior *inf)
Definition: darwin-nat.c:1578
gdbarch
Definition: gdbarch.c:127
top.h
string
const char * string
Definition: signals.c:50
darwin_decode_message
static ptid_t darwin_decode_message(mach_msg_header_t *hdr, darwin_thread_t **pthread, struct inferior **pinf, struct target_waitstatus *status)
Definition: darwin-nat.c:1018
add_target
void add_target(struct target_ops *t)
Definition: target.c:395
darwin_ops
static struct target_ops * darwin_ops
Definition: darwin-nat.c:125
read
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
darwin_dump_message
static void darwin_dump_message(mach_msg_header_t *hdr, int disp_body)
Definition: darwin-nat.c:494
darwin_thread_info
Definition: darwin-nat.h:73
breakpoint_inserted_here_p
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4092
darwin_create_inferior
static void darwin_create_inferior(struct target_ops *ops, const char *exec_file, const std::string &allargs, char **env, int from_tty)
Definition: darwin-nat.c:1839
darwin_inferior::notify_port
mach_port_t notify_port
Definition: darwin-nat.h:112
resume_inferior_threads_param
Definition: darwin-nat.c:903
selftests::ptid::tid
static constexpr ptid_t tid
Definition: ptid-selftests.c:43
darwin_resume_to
static void darwin_resume_to(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
Definition: darwin-nat.c:1011
darwin_inf_fake_stop
static struct inferior * darwin_inf_fake_stop
Definition: darwin-nat.c:147
darwin_thread_info::signaled
unsigned char signaled
Definition: darwin-nat.h:91
PTRACE
#define PTRACE(CMD, PID, ADDR, SIG)
Definition: darwin-nat.c:83
darwin_resume_inferior_threads
static void darwin_resume_inferior_threads(struct inferior *inf, int step, int nsignal)
Definition: darwin-nat.c:895
target_waitstatus
Definition: waitstatus.h:104
target_announce_detach
void target_announce_detach(int from_tty)
Definition: target.c:3177
darwin_thread_info::event
struct darwin_exception_msg event
Definition: darwin-nat.h:94
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
syscall
Definition: target.h:105
darwin_xfer_partial
static enum target_xfer_status darwin_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: darwin-nat.c:2198
darwin_suspend_inferior_it
static int darwin_suspend_inferior_it(struct inferior *inf, void *arg)
Definition: darwin-nat.c:479
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
delete_thread
void delete_thread(ptid_t)
Definition: thread.c:476
pid
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:1824
class_support
Definition: command.h:42
darwin_find_thread
static darwin_thread_t * darwin_find_thread(struct inferior *inf, thread_t thread)
Definition: darwin-nat.c:427
cmd_list_element
Definition: cli-decode.h:46
func
void(* func)(char *)
Definition: remote-fileio.c:1104
darwin_read_write_inferior
static int darwin_read_write_inferior(task_t task, CORE_ADDR addr, gdb_byte *rdaddr, const gdb_byte *wraddr, ULONGEST length)
Definition: darwin-nat.c:2012
warning
void warning(const char *fmt,...)
Definition: errors.c:26
darwin_set_sstep
void darwin_set_sstep(thread_t thread, int enable)
Definition: i386-darwin-nat.c:576
push_target
void push_target(struct target_ops *t)
Definition: target.c:642
darwin_thread_info::msg_state
enum darwin_msg_state msg_state
Definition: darwin-nat.h:85
get_exec_file
char * get_exec_file(int err)
Definition: corefile.c:167
darwin_reply_to_all_pending_messages
static void darwin_reply_to_all_pending_messages(struct inferior *inf)
Definition: darwin-nat.c:1421
add_thread_with_info
struct thread_info * add_thread_with_info(ptid_t ptid, struct private_thread_info *)
Definition: thread.c:319
inferior
Definition: inferior.h:310
target_ops::to_pid_to_str
const char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:630
target_waitstatus::value
union target_waitstatus::@174 value
darwin_interrupt
static void darwin_interrupt(struct target_ops *self, ptid_t)
Definition: darwin-nat.c:1345
darwin_supports_multi_process
static int darwin_supports_multi_process(struct target_ops *self)
Definition: darwin-nat.c:2347
darwin_find_inferior_by_task
static struct inferior * darwin_find_inferior_by_task(task_t port)
Definition: darwin-nat.c:413
darwin_resume_inferior
static void darwin_resume_inferior(struct inferior *inf)
Definition: darwin-nat.c:461
darwin_thread_info::inf_port
thread_t inf_port
Definition: darwin-nat.h:80
darwin_execvp
static void darwin_execvp(const char *file, char *const argv[], char *const env[])
Definition: darwin-nat.c:1805
find_inferior_task_it
static int find_inferior_task_it(struct inferior *inf, void *port_ptr)
Definition: darwin-nat.c:398
find_inferior_ptid
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:321
darwin_save_exception_ports
static kern_return_t darwin_save_exception_ports(darwin_inferior *inf)
Definition: darwin-nat.c:1466
iterate_over_inferiors
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:346
_
#define _(String)
Definition: gdb_locale.h:35
darwin_pre_ptrace
static void darwin_pre_ptrace(void)
Definition: darwin-nat.c:1768
darwin_resume
static void darwin_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: darwin-nat.c:946
defs.h
regcache_write_pc
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1256
inf::task
struct proc * task
Definition: gnu-nat.c:178
darwin_stop_inferior
static void darwin_stop_inferior(struct inferior *inf)
Definition: darwin-nat.c:1433
darwin_get_ada_task_ptid
static ptid_t darwin_get_ada_task_ptid(struct target_ops *self, long lwp, long thread)
Definition: darwin-nat.c:2282
darwin_wait
static ptid_t darwin_wait(ptid_t ptid, struct target_waitstatus *status)
Definition: darwin-nat.c:1219
arm-linux.inf
inf
Definition: arm-linux.py:13
darwin_ex_port
mach_port_t darwin_ex_port
Definition: darwin-nat.c:134
ptrace
PTRACE_TYPE_RET ptrace()
MACH_CHECK_ERROR
#define MACH_CHECK_ERROR(ret)
Definition: darwin-nat.h:152
objfiles.h
host_address_to_string
#define host_address_to_string(ADDR)
Definition: print-utils.h:75
arch-utils.h
darwin_inferior::task
task_t task
Definition: darwin-nat.h:108
ptid_build
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
target_ops::to_files_info
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:464
darwin_check_message_ndr
static int darwin_check_message_ndr(NDR_record_t *ndr)
Definition: darwin-nat.c:611
darwin_setup_fake_stop_event
static void darwin_setup_fake_stop_event(struct inferior *inf)
Definition: darwin-nat.c:1858
add_setshow_zuinteger_cmd
void 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_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
normal_pid_to_str
const char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3234
symtab.h
TARGET_WAITKIND_SIGNALLED
Definition: waitstatus.h:39
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
darwin_inferior
Definition: darwin-nat.h:105
darwin_encode_reply
static void darwin_encode_reply(mig_reply_error_t *reply, mach_msg_header_t *hdr, integer_t code)
Definition: darwin-nat.c:804
gdbarch_decr_pc_after_break
CORE_ADDR gdbarch_decr_pc_after_break(struct gdbarch *gdbarch)
Definition: gdbarch.c:2970
DARWIN_STOPPED
Definition: darwin-nat.h:67
thread_info_from_private_thread_info
static struct thread_info * thread_info_from_private_thread_info(darwin_thread_info *pti)
Definition: darwin-nat.c:1697
ptrace_fds
static int ptrace_fds[2]
Definition: darwin-nat.c:1733
unmark_fd_no_cloexec
void unmark_fd_no_cloexec(int fd)
Definition: filestuff.c:184
find_inferior_pid_it
static int find_inferior_pid_it(struct inferior *inf, void *pid_ptr)
Definition: darwin-nat.c:406
darwin_find_inferior_by_pid
static struct inferior * darwin_find_inferior_by_pid(int pid)
Definition: darwin-nat.c:420
resume_inferior_threads_param::step
int step
Definition: darwin-nat.c:905
_initialize_darwin_inferior
void _initialize_darwin_inferior(void)
Definition: darwin-nat.c:2353
WTERMSIG
#define WTERMSIG(w)
Definition: gdb_wait.h:71
resume_inferior_threads_param::nsignal
int nsignal
Definition: darwin-nat.c:906
darwin_deallocate_exception_ports
static void darwin_deallocate_exception_ports(darwin_inferior *inf)
Definition: darwin-nat.c:1501
darwin_host_self
mach_port_t darwin_host_self
Definition: darwin-nat.c:131
target_ops
Definition: target.h:412
darwin_init_thread_list
static void darwin_init_thread_list(struct inferior *inf)
Definition: darwin-nat.c:1715
TARGET_OBJECT_MEMORY
Definition: target.h:139
target_waitstatus::sig
enum gdb_signal sig
Definition: waitstatus.h:114
WIFEXITED
#define WIFEXITED(w)
Definition: gdb_wait.h:44
regcache.h
darwin_exception_msg::header
mach_msg_header_t header
Definition: darwin-nat.h:47
ptid_get_tid
long ptid_get_tid(const ptid_t &ptid)
Definition: ptid.c:63
darwin_thread_alive
static int darwin_thread_alive(struct target_ops *ops, ptid_t tpid)
Definition: darwin-nat.c:2000
ptid_t
Definition: ptid.h:35
enable_mach_exceptions
static int enable_mach_exceptions
Definition: darwin-nat.c:144
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
target_ops::to_resume
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:447
darwin_exception_msg::data_count
mach_msg_type_number_t data_count
Definition: darwin-nat.h:57
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
inf-loop.h
darwin_detach
static void darwin_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: darwin-nat.c:1941
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
darwin_inferior::threads
std::vector< darwin_thread_t * > threads
Definition: darwin-nat.h:127
gdbthread.h
inferior.h
TARGET_XFER_OK
Definition: target.h:209
target_xfer_status
target_xfer_status
Definition: target.h:206
pulongest
char * pulongest(ULONGEST u)
Definition: print-utils.c:129
darwin_pid_to_exec_file
static char * darwin_pid_to_exec_file(struct target_ops *self, int pid)
Definition: darwin-nat.c:2269
type
Definition: gdbtypes.h:749
ATTRIBUTE_PRINTF
#define ATTRIBUTE_PRINTF
Definition: common-defs.h:70
gdb_signal_to_host
int gdb_signal_to_host(enum gdb_signal)
Definition: signals.c:639
get_darwin_inferior
static darwin_inferior * get_darwin_inferior(inferior *inf)
Definition: darwin-nat.h:133
gdb_signal_from_host
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
darwin_exception_msg::task_port
mach_port_t task_port
Definition: darwin-nat.h:51
darwin_thread_info::single_step
unsigned char single_step
Definition: darwin-nat.h:88
darwin_deallocate_threads
static void darwin_deallocate_threads(struct inferior *inf)
Definition: darwin-nat.c:1358
darwin_restore_exception_ports
static kern_return_t darwin_restore_exception_ports(darwin_inferior *inf)
Definition: darwin-nat.c:1481
inf
Definition: gnu-nat.c:174
trace_start_error
void trace_start_error(const char *fmt,...)
Definition: fork-inferior.c:597
target_mourn_inferior
void target_mourn_inferior(ptid_t ptid)
Definition: target.c:2298
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
darwin_resume_inferior_it
static int darwin_resume_inferior_it(struct inferior *inf, void *arg)
Definition: darwin-nat.c:487
darwin_decode_exception_message
static int darwin_decode_exception_message(mach_msg_header_t *hdr, struct inferior **pinf, darwin_thread_t **pthread)
Definition: darwin-nat.c:626
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
gdb_signal_to_name
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
target_ops::to_xfer_partial
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:739
WEXITSTATUS
#define WEXITSTATUS(w)
Definition: gdb_wait.h:67
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
__attribute__
static const unsigned char info_plist [] __attribute__((section("__TEXT,__info_plist"), used))
target_ops::to_detach
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:443
inf_child_mourn_inferior
void inf_child_mourn_inferior(struct target_ops *ops)
Definition: inf-child.c:163
gdb_startup_inferior
ptid_t gdb_startup_inferior(pid_t pid, int num_traps)
Definition: fork-child.c:134
get_darwin_thread_info
static darwin_thread_info * get_darwin_thread_info(class thread_info *thread)
Definition: darwin-nat.h:99
cancel_breakpoint
static int cancel_breakpoint(ptid_t ptid)
Definition: darwin-nat.c:1189
target_object
target_object
Definition: target.h:132
thread_t
pthread_t thread_t
Definition: glibc_thread_db.h:242
regcache::aspace
const address_space * aspace() const
Definition: regcache.h:257
target_ops::to_pid_to_exec_file
char *(* to_pid_to_exec_file)(struct target_ops *, int pid) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:650
target_is_pushed
int target_is_pushed(struct target_ops *t)
Definition: target.c:767
darwin_ptrace_me
static void darwin_ptrace_me(void)
Definition: darwin-nat.c:1736
inferior_debug
static void inferior_debug(int level, const char *fmt,...) ATTRIBUTE_PRINTF(2
Definition: darwin-nat.c:185
ALL_THREADS
#define ALL_THREADS(T)
Definition: gdbthread.h:478
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
darwin_setup_exceptions
static void darwin_setup_exceptions(struct inferior *inf)
Definition: darwin-nat.c:1515
DARWIN_MESSAGE
Definition: darwin-nat.h:70
darwin_ptrace
static int darwin_ptrace(const char *name, int request, int pid, caddr_t arg3, int arg4)
Definition: darwin-nat.c:254
vprintf_unfiltered
void vprintf_unfiltered(const char *format, va_list args)
Definition: utils.c:2002
darwin_suspend_inferior_threads
static void darwin_suspend_inferior_threads(struct inferior *inf)
Definition: darwin-nat.c:923
darwin_inferior::no_ptrace
bool no_ptrace
Definition: darwin-nat.h:121
darwin_files_info
static void darwin_files_info(struct target_ops *ops)
Definition: darwin-nat.c:1979
event-top.h
mach_check_error
void mach_check_error(kern_return_t ret, const char *file, unsigned int line, const char *func)
Definition: darwin-nat.c:199
darwin_exception_msg::thread_port
mach_port_t thread_port
Definition: darwin-nat.h:50
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
inf_child_target
struct target_ops * inf_child_target(void)
Definition: inf-child.c:393
darwin_attach_pid
static void darwin_attach_pid(struct inferior *inf)
Definition: darwin-nat.c:1607
fork-inferior.h
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
target_ops::to_mourn_inferior
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:606
trace_start_error_with_name
void trace_start_error_with_name(const char *string)
Definition: fork-inferior.c:613
darwin_port_set
mach_port_t darwin_port_set
Definition: darwin-nat.c:137
unparse_exception_type
static const char * unparse_exception_type(unsigned int i)
Definition: darwin-nat.c:212
thread_info::priv
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:354
inferior::priv
std::unique_ptr< private_inferior > priv
Definition: inferior.h:411
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
darwin_mourn_inferior
static void darwin_mourn_inferior(struct target_ops *ops)
Definition: darwin-nat.c:1372
gdbcore.h
TARGET_XFER_EOF
Definition: target.h:212
inf::pid
pid_t pid
Definition: gnu-nat.c:187
TARGET_OBJECT_DARWIN_DYLD_INFO
Definition: target.h:189
fork_inferior
pid_t fork_inferior(const char *exec_file_arg, const std::string &allargs, char **env, void(*traceme_fun)(), void(*init_trace_fun)(int), void(*pre_trace_fun)(), const char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
Definition: fork-inferior.c:287
darwin_resume_inferior_threads_it
static int darwin_resume_inferior_threads_it(struct inferior *inf, void *param)
Definition: darwin-nat.c:910
darwin_decode_notify_message
static int darwin_decode_notify_message(mach_msg_header_t *hdr, struct inferior **pinf)
Definition: darwin-nat.c:765
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
target_ops::to_kill
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:570
TARGET_WAITKIND_SPURIOUS
Definition: waitstatus.h:77
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2194
mach_page_size
static vm_size_t mach_page_size
Definition: darwin-nat.c:140
PT_TRACE_ME
#define PT_TRACE_ME
Definition: gdb_ptrace.h:43
offset
int offset
Definition: agent.c:65
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
code
int code
Definition: ser-unix.c:239
TARGET_WAITKIND_EXITED
Definition: waitstatus.h:31
selftests::ptid::lwp
static constexpr ptid_t lwp
Definition: ptid-selftests.c:42
qsort
#define qsort
Definition: ada-exp.c:2694
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
darwin_exception_msg::ex_data
integer_t ex_data[2]
Definition: darwin-nat.h:58
parse_pid_to_attach
int parse_pid_to_attach(const char *args)
Definition: utils.c:3139
DARWIN_RUNNING
Definition: darwin-nat.h:64
target.h
darwin_check_new_threads
static void darwin_check_new_threads(struct inferior *inf)
Definition: darwin-nat.c:279
PAGE_ROUND
#define PAGE_ROUND(x)
Definition: darwin-nat.c:150
set_enable_mach_exceptions
static void set_enable_mach_exceptions(const char *args, int from_tty, struct cmd_list_element *c)
Definition: darwin-nat.c:2245
value.h
darwin_thread_info::gdb_port
thread_t gdb_port
Definition: darwin-nat.h:76
gdbarch::data
void ** data
Definition: gdbarch.c:148
thread_list
struct thread_info * thread_list
Definition: thread.c:53
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
START_INFERIOR_TRAPS_EXPECTED
#define START_INFERIOR_TRAPS_EXPECTED
Definition: fork-inferior.h:29
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
darwin_ptrace_him
static void darwin_ptrace_him(int pid)
Definition: darwin-nat.c:1782
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
regcache
Definition: regcache.h:232
gdb_task
static task_t gdb_task
Definition: darwin-nat.c:128
inf-child.h
darwin_send_reply
static void darwin_send_reply(struct inferior *inf, darwin_thread_t *thread)
Definition: darwin-nat.c:820
darwin_check_osabi
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
Definition: i386-darwin-nat.c:470
core_addr_to_string
const char * core_addr_to_string(const CORE_ADDR addr)
Definition: print-utils.c:295
target_ops::to_interrupt
void(* to_interrupt)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:643
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
darwin_pid_to_str
static const char * darwin_pid_to_str(struct target_ops *ops, ptid_t tpid)
Definition: darwin-nat.c:1984
darwin_resume_thread
static void darwin_resume_thread(struct inferior *inf, darwin_thread_t *thread, int step, int nsignal)
Definition: darwin-nat.c:838
inferior::args
char * args
Definition: inferior.h:352
darwin_exception_msg::ex_type
exception_type_t ex_type
Definition: darwin-nat.h:54
darwin_wait_to
static ptid_t darwin_wait_to(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: darwin-nat.c:1338
target_ops::to_create_inferior
void(* to_create_inferior)(struct target_ops *, const char *, const std::string &, char **, int)
Definition: target.h:579
_POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR
gdb.argv
argv
Definition: __init__.py:63
target_ops::to_thread_alive
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:626
darwin_kill_inferior
static void darwin_kill_inferior(struct target_ops *ops)
Definition: darwin-nat.c:1542
target_ops::to_attach
void(* to_attach)(struct target_ops *ops, const char *, int)
Definition: target.h:440
mark_fd_no_cloexec
void mark_fd_no_cloexec(int fd)
Definition: filestuff.c:176
darwin_debug_flag
static unsigned int darwin_debug_flag
Definition: darwin-nat.c:153
filestuff.h
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
regcache::ptid
ptid_t ptid() const
Definition: regcache.h:325
darwin_suspend_inferior
static void darwin_suspend_inferior(struct inferior *inf)
Definition: darwin-nat.c:443
TARGET_WAITKIND_IGNORE
Definition: waitstatus.h:88
target_ops::to_wait
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_FUNC(default_target_wait)
Definition: target.h:453
class_obscure
Definition: command.h:43
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
target_ops::to_get_ada_task_ptid
ptid_t(* to_get_ada_task_ptid)(struct target_ops *, long lwp, long thread) TARGET_DEFAULT_FUNC(default_get_ada_task_ptid)
Definition: target.h:797
gdbcmd.h
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
minus_one_ptid
ptid_t minus_one_ptid
Definition: ptid.c:26
darwin-nat.h
TARGET_XFER_E_IO
Definition: target.h:220
darwin_complete_target
void darwin_complete_target(struct target_ops *target)
Definition: i386-darwin-nat.c:631
darwin_find_new_inferior
static struct inferior * darwin_find_new_inferior(task_t task_port, thread_t thread_port)
Definition: darwin-nat.c:563
cmp_thread_t
static int cmp_thread_t(const void *l, const void *r)
Definition: darwin-nat.c:271
inferior_appeared
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:268
target_ops::to_load
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:572
target_ops::to_supports_multi_process
int(* to_supports_multi_process)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:833
symfile.h
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
darwin_attach
static void darwin_attach(struct target_ops *ops, const char *args, int from_tty)
Definition: darwin-nat.c:1881
target_ops::to_attach_no_wait
int to_attach_no_wait
Definition: target.h:663