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