gdbserver/target.cc

   1 /* Target operations for the remote server for GDB.
   2    Copyright (C) 2002-2024 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   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 "tracepoint.h"
  22 #include "gdbsupport/byte-vector.h"
  23 #include "hostio.h"
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28
  29 process_stratum_target *the_target;
  30
  31 /* See target.h.  */
  32
  33 bool
  34 set_desired_thread ()
  35 {
  36   client_state &cs = get_client_state ();
  37   thread_info *found = find_thread_ptid (cs.general_thread);
  38
  39   if (found == nullptr)
  40     {
  41       process_info *proc = find_process_pid (cs.general_thread.pid ());
  42       if (proc == nullptr)
  43         {
  44           threads_debug_printf
  45             ("did not find thread nor process for general_thread %s",
  46              cs.general_thread.to_string ().c_str ());
  47         }
  48       else
  49         {
  50           threads_debug_printf
  51             ("did not find thread for general_thread %s, but found process",
  52              cs.general_thread.to_string ().c_str ());
  53         }
  54       switch_to_process (proc);
  55     }
  56   else
  57     switch_to_thread (found);
  58
  59   return (current_thread != NULL);
  60 }
  61
  62 /* See target.h.  */
  63
  64 bool
  65 set_desired_process ()
  66 {
  67   client_state &cs = get_client_state ();
  68
  69   process_info *proc = find_process_pid (cs.general_thread.pid ());
  70   if (proc == nullptr)
  71     {
  72       threads_debug_printf
  73         ("did not find process for general_thread %s",
  74          cs.general_thread.to_string ().c_str ());
  75     }
  76   switch_to_process (proc);
  77
  78   return proc != nullptr;
  79 }
  80
  81 /* See target.h.  */
  82
  83 int
  84 read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
  85 {
  86   /* At the time of writing, GDB only sends write packets with LEN==0,
  87      not read packets (see comment in target_write_memory), but it
  88      doesn't hurt to prevent problems if it ever does, or we're
  89      connected to some client other than GDB that does.  */
  90   if (len == 0)
  91     return 0;
  92
  93   int res = the_target->read_memory (memaddr, myaddr, len);
  94   check_mem_read (memaddr, myaddr, len);
  95   return res;
  96 }
  97
  98 /* See target/target.h.  */
  99
 100 int
 101 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 102 {
 103   return read_inferior_memory (memaddr, myaddr, len);
 104 }
 105
 106 /* See target/target.h.  */
 107
 108 int
 109 target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
 110 {
 111   return read_inferior_memory (memaddr, (gdb_byte *) result, sizeof (*result));
 112 }
 113
 114 /* See target/target.h.  */
 115
 116 int
 117 target_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
 118                      ssize_t len)
 119 {
 120   /* GDB may send X packets with LEN==0, for probing packet support.
 121      If we let such a request go through, then buffer.data() below may
 122      return NULL, which may confuse target implementations.  Handle it
 123      here to avoid lower levels having to care about this case.  */
 124   if (len == 0)
 125     return 0;
 126
 127   /* Make a copy of the data because check_mem_write may need to
 128      update it.  */
 129   gdb::byte_vector buffer (myaddr, myaddr + len);
 130   check_mem_write (memaddr, buffer.data (), myaddr, len);
 131   return the_target->write_memory (memaddr, buffer.data (), len);
 132 }
 133
 134 ptid_t
 135 mywait (ptid_t ptid, struct target_waitstatus *ourstatus,
 136         target_wait_flags options, int connected_wait)
 137 {
 138   ptid_t ret;
 139
 140   if (connected_wait)
 141     server_waiting = 1;
 142
 143   ret = target_wait (ptid, ourstatus, options);
 144
 145   /* We don't expose _LOADED events to gdbserver core.  See the
 146      `dlls_changed' global.  */
 147   if (ourstatus->kind () == TARGET_WAITKIND_LOADED)
 148     ourstatus->set_stopped (GDB_SIGNAL_0);
 149
 150   /* If GDB is connected through TCP/serial, then GDBserver will most
 151      probably be running on its own terminal/console, so it's nice to
 152      print there why is GDBserver exiting.  If however, GDB is
 153      connected through stdio, then there's no need to spam the GDB
 154      console with this -- the user will already see the exit through
 155      regular GDB output, in that same terminal.  */
 156   if (!remote_connection_is_stdio ())
 157     {
 158       if (ourstatus->kind () == TARGET_WAITKIND_EXITED)
 159         fprintf (stderr,
 160                  "\nChild exited with status %d\n", ourstatus->exit_status ());
 161       else if (ourstatus->kind () == TARGET_WAITKIND_SIGNALLED)
 162         fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
 163                  gdb_signal_to_host (ourstatus->sig ()),
 164                  gdb_signal_to_name (ourstatus->sig ()));
 165     }
 166
 167   if (connected_wait)
 168     server_waiting = 0;
 169
 170   return ret;
 171 }
 172
 173 /* See target/target.h.  */
 174
 175 void
 176 target_stop_and_wait (ptid_t ptid)
 177 {
 178   struct target_waitstatus status;
 179   bool was_non_stop = non_stop;
 180   struct thread_resume resume_info;
 181
 182   resume_info.thread = ptid;
 183   resume_info.kind = resume_stop;
 184   resume_info.sig = GDB_SIGNAL_0;
 185   the_target->resume (&resume_info, 1);
 186
 187   non_stop = true;
 188   mywait (ptid, &status, 0, 0);
 189   non_stop = was_non_stop;
 190 }
 191
 192 /* See target/target.h.  */
 193
 194 ptid_t
 195 target_wait (ptid_t ptid, struct target_waitstatus *status,
 196              target_wait_flags options)
 197 {
 198   return the_target->wait (ptid, status, options);
 199 }
 200
 201 /* See target/target.h.  */
 202
 203 void
 204 target_mourn_inferior (ptid_t ptid)
 205 {
 206   the_target->mourn (find_process_pid (ptid.pid ()));
 207 }
 208
 209 /* See target/target.h.  */
 210
 211 void
 212 target_continue_no_signal (ptid_t ptid)
 213 {
 214   struct thread_resume resume_info;
 215
 216   resume_info.thread = ptid;
 217   resume_info.kind = resume_continue;
 218   resume_info.sig = GDB_SIGNAL_0;
 219   the_target->resume (&resume_info, 1);
 220 }
 221
 222 /* See target/target.h.  */
 223
 224 void
 225 target_continue (ptid_t ptid, enum gdb_signal signal)
 226 {
 227   struct thread_resume resume_info;
 228
 229   resume_info.thread = ptid;
 230   resume_info.kind = resume_continue;
 231   resume_info.sig = gdb_signal_to_host (signal);
 232   the_target->resume (&resume_info, 1);
 233 }
 234
 235 /* See target/target.h.  */
 236
 237 int
 238 target_supports_multi_process (void)
 239 {
 240   return the_target->supports_multi_process ();
 241 }
 242
 243 void
 244 set_target_ops (process_stratum_target *target)
 245 {
 246   the_target = target;
 247 }
 248
 249 /* Convert pid to printable format.  */
 250
 251 std::string
 252 target_pid_to_str (ptid_t ptid)
 253 {
 254   if (ptid == minus_one_ptid)
 255     return string_printf("<all threads>");
 256   else if (ptid == null_ptid)
 257     return string_printf("<null thread>");
 258   else if (ptid.tid () != 0)
 259     return string_printf("Thread %d.0x%s",
 260                          ptid.pid (),
 261                          phex_nz (ptid.tid (), sizeof (ULONGEST)));
 262   else if (ptid.lwp () != 0)
 263     return string_printf("LWP %d.%ld",
 264                          ptid.pid (), ptid.lwp ());
 265   else
 266     return string_printf("Process %d",
 267                          ptid.pid ());
 268 }
 269
 270 int
 271 kill_inferior (process_info *proc)
 272 {
 273   gdb_agent_about_to_close (proc->pid);
 274
 275   return the_target->kill (proc);
 276 }
 277
 278 /* Define it.  */
 279
 280 target_terminal_state target_terminal::m_terminal_state
 281   = target_terminal_state::is_ours;
 282
 283 /* See target/target.h.  */
 284
 285 void
 286 target_terminal::init ()
 287 {
 288   /* Placeholder needed because of fork_inferior.  Not necessary on
 289      GDBserver.  */
 290 }
 291
 292 /* See target/target.h.  */
 293
 294 void
 295 target_terminal::inferior ()
 296 {
 297   /* Placeholder needed because of fork_inferior.  Not necessary on
 298      GDBserver.  */
 299 }
 300
 301 /* See target/target.h.  */
 302
 303 void
 304 target_terminal::ours ()
 305 {
 306   /* Placeholder needed because of fork_inferior.  Not necessary on
 307      GDBserver.  */
 308 }
 309
 310 /* See target/target.h.  */
 311
 312 void
 313 target_terminal::ours_for_output (void)
 314 {
 315   /* Placeholder.  */
 316 }
 317
 318 /* See target/target.h.  */
 319
 320 void
 321 target_terminal::info (const char *arg, int from_tty)
 322 {
 323   /* Placeholder.  */
 324 }
 325
 326 /* Default implementations of target ops.
 327    See target.h for definitions.  */
 328
 329 void
 330 process_stratum_target::post_create_inferior ()
 331 {
 332   /* Nop.  */
 333 }
 334
 335 void
 336 process_stratum_target::look_up_symbols ()
 337 {
 338   /* Nop.  */
 339 }
 340
 341 bool
 342 process_stratum_target::supports_read_auxv ()
 343 {
 344   return false;
 345 }
 346
 347 int
 348 process_stratum_target::read_auxv (int pid, CORE_ADDR offset,
 349                                    unsigned char *myaddr, unsigned int len)
 350 {
 351   gdb_assert_not_reached ("target op read_auxv not supported");
 352 }
 353
 354 bool
 355 process_stratum_target::supports_z_point_type (char z_type)
 356 {
 357   return false;
 358 }
 359
 360 int
 361 process_stratum_target::insert_point (enum raw_bkpt_type type,
 362                                       CORE_ADDR addr,
 363                                       int size, raw_breakpoint *bp)
 364 {
 365   return 1;
 366 }
 367
 368 int
 369 process_stratum_target::remove_point (enum raw_bkpt_type type,
 370                                       CORE_ADDR addr,
 371                                       int size, raw_breakpoint *bp)
 372 {
 373   return 1;
 374 }
 375
 376 bool
 377 process_stratum_target::stopped_by_sw_breakpoint ()
 378 {
 379   return false;
 380 }
 381
 382 bool
 383 process_stratum_target::supports_stopped_by_sw_breakpoint ()
 384 {
 385   return false;
 386 }
 387
 388 bool
 389 process_stratum_target::stopped_by_hw_breakpoint ()
 390 {
 391   return false;
 392 }
 393
 394 bool
 395 process_stratum_target::supports_stopped_by_hw_breakpoint ()
 396 {
 397   return false;
 398 }
 399
 400 bool
 401 process_stratum_target::supports_hardware_single_step ()
 402 {
 403   return false;
 404 }
 405
 406 bool
 407 process_stratum_target::stopped_by_watchpoint ()
 408 {
 409   return false;
 410 }
 411
 412 CORE_ADDR
 413 process_stratum_target::stopped_data_address ()
 414 {
 415   return 0;
 416 }
 417
 418 bool
 419 process_stratum_target::supports_read_offsets ()
 420 {
 421   return false;
 422 }
 423
 424 bool
 425 process_stratum_target::supports_memory_tagging ()
 426 {
 427   return false;
 428 }
 429
 430 bool
 431 process_stratum_target::fetch_memtags (CORE_ADDR address, size_t len,
 432                                        gdb::byte_vector &tags, int type)
 433 {
 434   gdb_assert_not_reached ("target op fetch_memtags not supported");
 435 }
 436
 437 bool
 438 process_stratum_target::store_memtags (CORE_ADDR address, size_t len,
 439                                        const gdb::byte_vector &tags, int type)
 440 {
 441   gdb_assert_not_reached ("target op store_memtags not supported");
 442 }
 443
 444 int
 445 process_stratum_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data)
 446 {
 447   gdb_assert_not_reached ("target op read_offsets not supported");
 448 }
 449
 450 bool
 451 process_stratum_target::supports_get_tls_address ()
 452 {
 453   return false;
 454 }
 455
 456 int
 457 process_stratum_target::get_tls_address (thread_info *thread,
 458                                          CORE_ADDR offset,
 459                                          CORE_ADDR load_module,
 460                                          CORE_ADDR *address)
 461 {
 462   gdb_assert_not_reached ("target op get_tls_address not supported");
 463 }
 464
 465 bool
 466 process_stratum_target::supports_qxfer_osdata ()
 467 {
 468   return false;
 469 }
 470
 471 int
 472 process_stratum_target::qxfer_osdata (const char *annex,
 473                                       unsigned char *readbuf,
 474                                       unsigned const char *writebuf,
 475                                       CORE_ADDR offset, int len)
 476 {
 477   gdb_assert_not_reached ("target op qxfer_osdata not supported");
 478 }
 479
 480 bool
 481 process_stratum_target::supports_qxfer_siginfo ()
 482 {
 483   return false;
 484 }
 485
 486 int
 487 process_stratum_target::qxfer_siginfo (const char *annex,
 488                                        unsigned char *readbuf,
 489                                        unsigned const char *writebuf,
 490                                        CORE_ADDR offset, int len)
 491 {
 492   gdb_assert_not_reached ("target op qxfer_siginfo not supported");
 493 }
 494
 495 bool
 496 process_stratum_target::supports_non_stop ()
 497 {
 498   return false;
 499 }
 500
 501 bool
 502 process_stratum_target::async (bool enable)
 503 {
 504   return false;
 505 }
 506
 507 int
 508 process_stratum_target::start_non_stop (bool enable)
 509 {
 510   if (enable)
 511     return -1;
 512   else
 513     return 0;
 514 }
 515
 516 bool
 517 process_stratum_target::supports_multi_process ()
 518 {
 519   return false;
 520 }
 521
 522 bool
 523 process_stratum_target::supports_fork_events ()
 524 {
 525   return false;
 526 }
 527
 528 bool
 529 process_stratum_target::supports_vfork_events ()
 530 {
 531   return false;
 532 }
 533
 534 gdb_thread_options
 535 process_stratum_target::supported_thread_options ()
 536 {
 537   return 0;
 538 }
 539
 540 bool
 541 process_stratum_target::supports_exec_events ()
 542 {
 543   return false;
 544 }
 545
 546 void
 547 process_stratum_target::handle_new_gdb_connection ()
 548 {
 549   /* Nop.  */
 550 }
 551
 552 int
 553 process_stratum_target::handle_monitor_command (char *mon)
 554 {
 555   return 0;
 556 }
 557
 558 int
 559 process_stratum_target::core_of_thread (ptid_t ptid)
 560 {
 561   return -1;
 562 }
 563
 564 bool
 565 process_stratum_target::supports_read_loadmap ()
 566 {
 567   return false;
 568 }
 569
 570 int
 571 process_stratum_target::read_loadmap (const char *annex,
 572                                       CORE_ADDR offset,
 573                                       unsigned char *myaddr,
 574                                       unsigned int len)
 575 {
 576   gdb_assert_not_reached ("target op read_loadmap not supported");
 577 }
 578
 579 void
 580 process_stratum_target::process_qsupported
 581   (gdb::array_view<const char * const> features)
 582 {
 583   /* Nop.  */
 584 }
 585
 586 bool
 587 process_stratum_target::supports_tracepoints ()
 588 {
 589   return false;
 590 }
 591
 592 CORE_ADDR
 593 process_stratum_target::read_pc (regcache *regcache)
 594 {
 595   gdb_assert_not_reached ("process_target::read_pc: Unable to find PC");
 596 }
 597
 598 void
 599 process_stratum_target::write_pc (regcache *regcache, CORE_ADDR pc)
 600 {
 601   gdb_assert_not_reached ("process_target::write_pc: Unable to update PC");
 602 }
 603
 604 bool
 605 process_stratum_target::supports_thread_stopped ()
 606 {
 607   return false;
 608 }
 609
 610 bool
 611 process_stratum_target::thread_stopped (thread_info *thread)
 612 {
 613   gdb_assert_not_reached ("target op thread_stopped not supported");
 614 }
 615
 616 bool
 617 process_stratum_target::any_resumed ()
 618 {
 619   return true;
 620 }
 621
 622 bool
 623 process_stratum_target::supports_get_tib_address ()
 624 {
 625   return false;
 626 }
 627
 628 int
 629 process_stratum_target::get_tib_address (ptid_t ptid, CORE_ADDR *address)
 630 {
 631   gdb_assert_not_reached ("target op get_tib_address not supported");
 632 }
 633
 634 void
 635 process_stratum_target::pause_all (bool freeze)
 636 {
 637   /* Nop.  */
 638 }
 639
 640 void
 641 process_stratum_target::unpause_all (bool unfreeze)
 642 {
 643   /* Nop.  */
 644 }
 645
 646 void
 647 process_stratum_target::stabilize_threads ()
 648 {
 649   /* Nop.  */
 650 }
 651
 652 bool
 653 process_stratum_target::supports_fast_tracepoints ()
 654 {
 655   return false;
 656 }
 657
 658 int
 659 process_stratum_target::install_fast_tracepoint_jump_pad
 660   (CORE_ADDR tpoint, CORE_ADDR tpaddr, CORE_ADDR collector,
 661    CORE_ADDR lockaddr, ULONGEST orig_size, CORE_ADDR *jump_entry,
 662    CORE_ADDR *trampoline, ULONGEST *trampoline_size,
 663    unsigned char *jjump_pad_insn, ULONGEST *jjump_pad_insn_size,
 664    CORE_ADDR *adjusted_insn_addr, CORE_ADDR *adjusted_insn_addr_end,
 665    char *err)
 666 {
 667   gdb_assert_not_reached ("target op install_fast_tracepoint_jump_pad "
 668                           "not supported");
 669 }
 670
 671 int
 672 process_stratum_target::get_min_fast_tracepoint_insn_len ()
 673 {
 674   return 0;
 675 }
 676
 677 struct emit_ops *
 678 process_stratum_target::emit_ops ()
 679 {
 680   return nullptr;
 681 }
 682
 683 bool
 684 process_stratum_target::supports_disable_randomization ()
 685 {
 686   return false;
 687 }
 688
 689 bool
 690 process_stratum_target::supports_qxfer_libraries_svr4 ()
 691 {
 692   return false;
 693 }
 694
 695 int
 696 process_stratum_target::qxfer_libraries_svr4 (const char *annex,
 697                                               unsigned char *readbuf,
 698                                               unsigned const char *writebuf,
 699                                               CORE_ADDR offset, int len)
 700 {
 701   gdb_assert_not_reached ("target op qxfer_libraries_svr4 not supported");
 702 }
 703
 704 bool
 705 process_stratum_target::supports_agent ()
 706 {
 707   return false;
 708 }
 709
 710 bool
 711 process_stratum_target::supports_btrace ()
 712 {
 713   return false;
 714 }
 715
 716 btrace_target_info *
 717 process_stratum_target::enable_btrace (thread_info *tp,
 718                                        const btrace_config *conf)
 719 {
 720   error (_("Target does not support branch tracing."));
 721 }
 722
 723 int
 724 process_stratum_target::disable_btrace (btrace_target_info *tinfo)
 725 {
 726   error (_("Target does not support branch tracing."));
 727 }
 728
 729 int
 730 process_stratum_target::read_btrace (btrace_target_info *tinfo,
 731                                      std::string *buffer,
 732                                      enum btrace_read_type type)
 733 {
 734   error (_("Target does not support branch tracing."));
 735 }
 736
 737 int
 738 process_stratum_target::read_btrace_conf (const btrace_target_info *tinfo,
 739                                           std::string *buffer)
 740 {
 741   error (_("Target does not support branch tracing."));
 742 }
 743
 744 bool
 745 process_stratum_target::supports_range_stepping ()
 746 {
 747   return false;
 748 }
 749
 750 bool
 751 process_stratum_target::supports_pid_to_exec_file ()
 752 {
 753   return false;
 754 }
 755
 756 const char *
 757 process_stratum_target::pid_to_exec_file (int pid)
 758 {
 759   gdb_assert_not_reached ("target op pid_to_exec_file not supported");
 760 }
 761
 762 bool
 763 process_stratum_target::supports_multifs ()
 764 {
 765   return false;
 766 }
 767
 768 int
 769 process_stratum_target::multifs_open (int pid, const char *filename,
 770                                       int flags, mode_t mode)
 771 {
 772   return open (filename, flags, mode);
 773 }
 774
 775 int
 776 process_stratum_target::multifs_unlink (int pid, const char *filename)
 777 {
 778   return unlink (filename);
 779 }
 780
 781 ssize_t
 782 process_stratum_target::multifs_readlink (int pid, const char *filename,
 783                                           char *buf, size_t bufsiz)
 784 {
 785   return readlink (filename, buf, bufsiz);
 786 }
 787
 788 int
 789 process_stratum_target::breakpoint_kind_from_pc (CORE_ADDR *pcptr)
 790 {
 791   /* The default behavior is to use the size of a breakpoint as the
 792      kind.  */
 793   int size = 0;
 794   sw_breakpoint_from_kind (0, &size);
 795   return size;
 796 }
 797
 798 int
 799 process_stratum_target::breakpoint_kind_from_current_state (CORE_ADDR *pcptr)
 800 {
 801   return breakpoint_kind_from_pc (pcptr);
 802 }
 803
 804 const char *
 805 process_stratum_target::thread_name (ptid_t thread)
 806 {
 807   return nullptr;
 808 }
 809
 810 bool
 811 process_stratum_target::thread_handle (ptid_t ptid, gdb_byte **handle,
 812                                        int *handle_len)
 813 {
 814   return false;
 815 }
 816
 817 thread_info *
 818 process_stratum_target::thread_pending_parent (thread_info *thread)
 819 {
 820   return nullptr;
 821 }
 822
 823 thread_info *
 824 process_stratum_target::thread_pending_child (thread_info *thread,
 825                                               target_waitkind *kind)
 826 {
 827   return nullptr;
 828 }
 829
 830 bool
 831 process_stratum_target::supports_software_single_step ()
 832 {
 833   return false;
 834 }
 835
 836 bool
 837 process_stratum_target::supports_catch_syscall ()
 838 {
 839   return false;
 840 }
 841
 842 int
 843 process_stratum_target::get_ipa_tdesc_idx ()
 844 {
 845   return 0;
 846 }