gdb/ravenscar-thread.c

   1 /* Ada Ravenscar thread support.
   2
   3    Copyright (C) 2004-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcore.h"
  22 #include "gdbthread.h"
  23 #include "ada-lang.h"
  24 #include "target.h"
  25 #include "inferior.h"
  26 #include "command.h"
  27 #include "ravenscar-thread.h"
  28 #include "observable.h"
  29 #include "gdbcmd.h"
  30 #include "top.h"
  31 #include "regcache.h"
  32 #include "objfiles.h"
  33
  34 /* This module provides support for "Ravenscar" tasks (Ada) when
  35    debugging on bare-metal targets.
  36
  37    The typical situation is when debugging a bare-metal target over
  38    the remote protocol. In that situation, the system does not know
  39    about high-level concepts such as threads, only about some code
  40    running on one or more CPUs. And since the remote protocol does not
  41    provide any handling for CPUs, the de facto standard for handling
  42    them is to have one thread per CPU, where the thread's ptid has
  43    its lwp field set to the CPU number (eg: 1 for the first CPU,
  44    2 for the second one, etc).  This module will make that assumption.
  45
  46    This module then creates and maintains the list of threads based
  47    on the list of Ada tasks, with one thread per Ada task. The convention
  48    is that threads corresponding to the CPUs (see assumption above)
  49    have a ptid_t of the form (PID, LWP, 0), while threads corresponding
  50    to our Ada tasks have a ptid_t of the form (PID, 0, TID) where TID
  51    is the Ada task's ID as extracted from Ada runtime information.
  52
  53    Switching to a given Ada task (or its underlying thread) is performed
  54    by fetching the registers of that task from the memory area where
  55    the registers were saved.  For any of the other operations, the
  56    operation is performed by first finding the CPU on which the task
  57    is running, switching to its corresponding ptid, and then performing
  58    the operation on that ptid using the target beneath us.  */
  59
  60 /* If non-null, ravenscar task support is enabled.  */
  61 static int ravenscar_task_support = 1;
  62
  63 static const char running_thread_name[] = "__gnat_running_thread_table";
  64
  65 static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
  66 static const char first_task_name[] = "system__tasking__debug__first_task";
  67
  68 static const char ravenscar_runtime_initializer[]
  69   = "system__bb__threads__initialize";
  70
  71 static const target_info ravenscar_target_info = {
  72   "ravenscar",
  73   N_("Ravenscar tasks."),
  74   N_("Ravenscar tasks support.")
  75 };
  76
  77 struct ravenscar_thread_target final : public target_ops
  78 {
  79   ravenscar_thread_target ()
  80   {
  81     update_inferior_ptid ();
  82   }
  83
  84   const target_info &info () const override
  85   { return ravenscar_target_info; }
  86
  87   strata stratum () const override { return thread_stratum; }
  88
  89   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
  90   void resume (ptid_t, int, enum gdb_signal) override;
  91
  92   void fetch_registers (struct regcache *, int) override;
  93   void store_registers (struct regcache *, int) override;
  94
  95   void prepare_to_store (struct regcache *) override;
  96
  97   bool stopped_by_sw_breakpoint () override;
  98
  99   bool stopped_by_hw_breakpoint () override;
 100
 101   bool stopped_by_watchpoint () override;
 102
 103   bool stopped_data_address (CORE_ADDR *) override;
 104
 105   bool thread_alive (ptid_t ptid) override;
 106
 107   int core_of_thread (ptid_t ptid) override;
 108
 109   void update_thread_list () override;
 110
 111   const char *extra_thread_info (struct thread_info *) override;
 112
 113   const char *pid_to_str (ptid_t) override;
 114
 115   ptid_t get_ada_task_ptid (long lwp, long thread) override;
 116
 117   void mourn_inferior () override;
 118
 119   void close () override
 120   {
 121     delete this;
 122   }
 123
 124 private:
 125
 126   /* PTID of the last thread that received an event.
 127      This can be useful to determine the associated task that received
 128      the event, to make it the current task.  */
 129   ptid_t m_base_ptid = null_ptid;
 130
 131   void update_inferior_ptid ();
 132   ptid_t active_task (int cpu);
 133   bool task_is_currently_active (ptid_t ptid);
 134   bool runtime_initialized ();
 135 };
 136
 137 /* Return true iff PTID corresponds to a ravenscar task.  */
 138
 139 static bool
 140 is_ravenscar_task (ptid_t ptid)
 141 {
 142   /* By construction, ravenscar tasks have their LWP set to zero.
 143      Also make sure that the TID is nonzero, as some remotes, when
 144      asked for the list of threads, will return the first thread
 145      as having its TID set to zero.  For instance, TSIM version
 146      2.0.48 for LEON3 sends 'm0' as a reply to the 'qfThreadInfo'
 147      query, which the remote protocol layer then treats as a thread
 148      whose TID is 0.  This is obviously not a ravenscar task.  */
 149   return ptid.lwp () == 0 && ptid.tid () != 0;
 150 }
 151
 152 /* Given PTID, which can be either a ravenscar task or a CPU thread,
 153    return which CPU that ptid is running on.
 154
 155    This assume that PTID is a valid ptid_t.  Otherwise, a gdb_assert
 156    will be triggered.  */
 157
 158 static int
 159 ravenscar_get_thread_base_cpu (ptid_t ptid)
 160 {
 161   int base_cpu;
 162
 163   if (is_ravenscar_task (ptid))
 164     {
 165       struct ada_task_info *task_info = ada_get_task_info_from_ptid (ptid);
 166
 167       gdb_assert (task_info != NULL);
 168       base_cpu = task_info->base_cpu;
 169     }
 170   else
 171     {
 172       /* We assume that the LWP of the PTID is equal to the CPU number.  */
 173       base_cpu = ptid.lwp ();
 174     }
 175
 176   return base_cpu;
 177 }
 178
 179 /* Given a ravenscar task (identified by its ptid_t PTID), return true
 180    if this task is the currently active task on the cpu that task is
 181    running on.
 182
 183    In other words, this function determine which CPU this task is
 184    currently running on, and then return nonzero if the CPU in question
 185    is executing the code for that task.  If that's the case, then
 186    that task's registers are in the CPU bank.  Otherwise, the task
 187    is currently suspended, and its registers have been saved in memory.  */
 188
 189 bool
 190 ravenscar_thread_target::task_is_currently_active (ptid_t ptid)
 191 {
 192   ptid_t active_task_ptid
 193     = active_task (ravenscar_get_thread_base_cpu (ptid));
 194
 195   return ptid == active_task_ptid;
 196 }
 197
 198 /* Return the CPU thread (as a ptid_t) on which the given ravenscar
 199    task is running.
 200
 201    This is the thread that corresponds to the CPU on which the task
 202    is running.  */
 203
 204 static ptid_t
 205 get_base_thread_from_ravenscar_task (ptid_t ptid)
 206 {
 207   int base_cpu;
 208
 209   if (!is_ravenscar_task (ptid))
 210     return ptid;
 211
 212   base_cpu = ravenscar_get_thread_base_cpu (ptid);
 213   return ptid_t (ptid.pid (), base_cpu, 0);
 214 }
 215
 216 /* Fetch the ravenscar running thread from target memory and
 217    update inferior_ptid accordingly.  */
 218
 219 void
 220 ravenscar_thread_target::update_inferior_ptid ()
 221 {
 222   int base_cpu;
 223
 224   m_base_ptid = inferior_ptid;
 225
 226   gdb_assert (!is_ravenscar_task (inferior_ptid));
 227   base_cpu = ravenscar_get_thread_base_cpu (m_base_ptid);
 228
 229   /* If the runtime has not been initialized yet, the inferior_ptid is
 230      the only ptid that there is.  */
 231   if (!runtime_initialized ())
 232     return;
 233
 234   /* Make sure we set m_base_ptid before calling active_task
 235      as the latter relies on it.  */
 236   inferior_ptid = active_task (base_cpu);
 237   gdb_assert (inferior_ptid != null_ptid);
 238
 239   /* The running thread may not have been added to
 240      system.tasking.debug's list yet; so ravenscar_update_thread_list
 241      may not always add it to the thread list.  Add it here.  */
 242   if (!find_thread_ptid (inferior_ptid))
 243     add_thread (inferior_ptid);
 244 }
 245
 246 /* The Ravenscar Runtime exports a symbol which contains the ID of
 247    the thread that is currently running.  Try to locate that symbol
 248    and return its associated minimal symbol.
 249    Return NULL if not found.  */
 250
 251 static struct bound_minimal_symbol
 252 get_running_thread_msymbol ()
 253 {
 254   struct bound_minimal_symbol msym;
 255
 256   msym = lookup_minimal_symbol (running_thread_name, NULL, NULL);
 257   if (!msym.minsym)
 258     /* Older versions of the GNAT runtime were using a different
 259        (less ideal) name for the symbol where the active thread ID
 260        is stored.  If we couldn't find the symbol using the latest
 261        name, then try the old one.  */
 262     msym = lookup_minimal_symbol ("running_thread", NULL, NULL);
 263
 264   return msym;
 265 }
 266
 267 /* Return True if the Ada Ravenscar run-time can be found in the
 268    application.  */
 269
 270 static bool
 271 has_ravenscar_runtime ()
 272 {
 273   struct bound_minimal_symbol msym_ravenscar_runtime_initializer
 274     = lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL);
 275   struct bound_minimal_symbol msym_known_tasks
 276     = lookup_minimal_symbol (known_tasks_name, NULL, NULL);
 277   struct bound_minimal_symbol msym_first_task
 278     = lookup_minimal_symbol (first_task_name, NULL, NULL);
 279   struct bound_minimal_symbol msym_running_thread
 280     = get_running_thread_msymbol ();
 281
 282   return (msym_ravenscar_runtime_initializer.minsym
 283           && (msym_known_tasks.minsym || msym_first_task.minsym)
 284           && msym_running_thread.minsym);
 285 }
 286
 287 /* Return True if the Ada Ravenscar run-time can be found in the
 288    application, and if it has been initialized on target.  */
 289
 290 bool
 291 ravenscar_thread_target::runtime_initialized ()
 292 {
 293   return active_task (1) != null_ptid;
 294 }
 295
 296 /* Return the ID of the thread that is currently running.
 297    Return 0 if the ID could not be determined.  */
 298
 299 static CORE_ADDR
 300 get_running_thread_id (int cpu)
 301 {
 302   struct bound_minimal_symbol object_msym = get_running_thread_msymbol ();
 303   int object_size;
 304   int buf_size;
 305   gdb_byte *buf;
 306   CORE_ADDR object_addr;
 307   struct type *builtin_type_void_data_ptr
 308     = builtin_type (target_gdbarch ())->builtin_data_ptr;
 309
 310   if (!object_msym.minsym)
 311     return 0;
 312
 313   object_size = TYPE_LENGTH (builtin_type_void_data_ptr);
 314   object_addr = (BMSYMBOL_VALUE_ADDRESS (object_msym)
 315                  + (cpu - 1) * object_size);
 316   buf_size = object_size;
 317   buf = (gdb_byte *) alloca (buf_size);
 318   read_memory (object_addr, buf, buf_size);
 319   return extract_typed_address (buf, builtin_type_void_data_ptr);
 320 }
 321
 322 void
 323 ravenscar_thread_target::resume (ptid_t ptid, int step,
 324                                  enum gdb_signal siggnal)
 325 {
 326   /* If we see a wildcard resume, we simply pass that on.  Otherwise,
 327      arrange to resume the base ptid.  */
 328   inferior_ptid = m_base_ptid;
 329   if (ptid != minus_one_ptid)
 330     ptid = m_base_ptid;
 331   beneath ()->resume (ptid, step, siggnal);
 332 }
 333
 334 ptid_t
 335 ravenscar_thread_target::wait (ptid_t ptid,
 336                                struct target_waitstatus *status,
 337                                int options)
 338 {
 339   ptid_t event_ptid;
 340
 341   inferior_ptid = m_base_ptid;
 342   if (ptid != minus_one_ptid)
 343     ptid = m_base_ptid;
 344   event_ptid = beneath ()->wait (ptid, status, 0);
 345   /* Find any new threads that might have been created, and update
 346      inferior_ptid to the active thread.
 347
 348      Only do it if the program is still alive, though.  Otherwise,
 349      this causes problems when debugging through the remote protocol,
 350      because we might try switching threads (and thus sending packets)
 351      after the remote has disconnected.  */
 352   if (status->kind != TARGET_WAITKIND_EXITED
 353       && status->kind != TARGET_WAITKIND_SIGNALLED)
 354     {
 355       inferior_ptid = event_ptid;
 356       this->update_thread_list ();
 357       this->update_inferior_ptid ();
 358     }
 359   else
 360     inferior_ptid = m_base_ptid;
 361   return inferior_ptid;
 362 }
 363
 364 /* Add the thread associated to the given TASK to the thread list
 365    (if the thread has already been added, this is a no-op).  */
 366
 367 static void
 368 ravenscar_add_thread (struct ada_task_info *task)
 369 {
 370   if (find_thread_ptid (task->ptid) == NULL)
 371     add_thread (task->ptid);
 372 }
 373
 374 void
 375 ravenscar_thread_target::update_thread_list ()
 376 {
 377   /* Do not clear the thread list before adding the Ada task, to keep
 378      the thread that the process stratum has included into it
 379      (m_base_ptid) and the running thread, that may not have been included
 380      to system.tasking.debug's list yet.  */
 381
 382   iterate_over_live_ada_tasks (ravenscar_add_thread);
 383 }
 384
 385 ptid_t
 386 ravenscar_thread_target::active_task (int cpu)
 387 {
 388   CORE_ADDR tid = get_running_thread_id (cpu);
 389
 390   if (tid == 0)
 391     return null_ptid;
 392   else
 393     return ptid_t (m_base_ptid.pid (), 0, tid);
 394 }
 395
 396 const char *
 397 ravenscar_thread_target::extra_thread_info (thread_info *tp)
 398 {
 399   return "Ravenscar task";
 400 }
 401
 402 bool
 403 ravenscar_thread_target::thread_alive (ptid_t ptid)
 404 {
 405   /* Ravenscar tasks are non-terminating.  */
 406   return true;
 407 }
 408
 409 const char *
 410 ravenscar_thread_target::pid_to_str (ptid_t ptid)
 411 {
 412   static char buf[30];
 413
 414   snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid.tid ());
 415   return buf;
 416 }
 417
 418 void
 419 ravenscar_thread_target::fetch_registers (struct regcache *regcache, int regnum)
 420 {
 421   ptid_t ptid = regcache->ptid ();
 422
 423   if (runtime_initialized ()
 424       && is_ravenscar_task (ptid)
 425       && !task_is_currently_active (ptid))
 426     {
 427       struct gdbarch *gdbarch = regcache->arch ();
 428       struct ravenscar_arch_ops *arch_ops
 429         = gdbarch_ravenscar_ops (gdbarch);
 430
 431       arch_ops->fetch_registers (regcache, regnum);
 432     }
 433   else
 434     beneath ()->fetch_registers (regcache, regnum);
 435 }
 436
 437 void
 438 ravenscar_thread_target::store_registers (struct regcache *regcache,
 439                                           int regnum)
 440 {
 441   ptid_t ptid = regcache->ptid ();
 442
 443   if (runtime_initialized ()
 444       && is_ravenscar_task (ptid)
 445       && !task_is_currently_active (ptid))
 446     {
 447       struct gdbarch *gdbarch = regcache->arch ();
 448       struct ravenscar_arch_ops *arch_ops
 449         = gdbarch_ravenscar_ops (gdbarch);
 450
 451       arch_ops->store_registers (regcache, regnum);
 452     }
 453   else
 454     beneath ()->store_registers (regcache, regnum);
 455 }
 456
 457 void
 458 ravenscar_thread_target::prepare_to_store (struct regcache *regcache)
 459 {
 460   ptid_t ptid = regcache->ptid ();
 461
 462   if (runtime_initialized ()
 463       && is_ravenscar_task (ptid)
 464       && !task_is_currently_active (ptid))
 465     {
 466       /* Nothing.  */
 467     }
 468   else
 469     beneath ()->prepare_to_store (regcache);
 470 }
 471
 472 /* Implement the to_stopped_by_sw_breakpoint target_ops "method".  */
 473
 474 bool
 475 ravenscar_thread_target::stopped_by_sw_breakpoint ()
 476 {
 477   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 478   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 479   return beneath ()->stopped_by_sw_breakpoint ();
 480 }
 481
 482 /* Implement the to_stopped_by_hw_breakpoint target_ops "method".  */
 483
 484 bool
 485 ravenscar_thread_target::stopped_by_hw_breakpoint ()
 486 {
 487   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 488   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 489   return beneath ()->stopped_by_hw_breakpoint ();
 490 }
 491
 492 /* Implement the to_stopped_by_watchpoint target_ops "method".  */
 493
 494 bool
 495 ravenscar_thread_target::stopped_by_watchpoint ()
 496 {
 497   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 498   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 499   return beneath ()->stopped_by_watchpoint ();
 500 }
 501
 502 /* Implement the to_stopped_data_address target_ops "method".  */
 503
 504 bool
 505 ravenscar_thread_target::stopped_data_address (CORE_ADDR *addr_p)
 506 {
 507   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 508   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 509   return beneath ()->stopped_data_address (addr_p);
 510 }
 511
 512 void
 513 ravenscar_thread_target::mourn_inferior ()
 514 {
 515   m_base_ptid = null_ptid;
 516   beneath ()->mourn_inferior ();
 517   unpush_target (this);
 518 }
 519
 520 /* Implement the to_core_of_thread target_ops "method".  */
 521
 522 int
 523 ravenscar_thread_target::core_of_thread (ptid_t ptid)
 524 {
 525   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 526   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 527   return beneath ()->core_of_thread (inferior_ptid);
 528 }
 529
 530 /* Observer on inferior_created: push ravenscar thread stratum if needed.  */
 531
 532 static void
 533 ravenscar_inferior_created (struct target_ops *target, int from_tty)
 534 {
 535   const char *err_msg;
 536
 537   if (!ravenscar_task_support
 538       || gdbarch_ravenscar_ops (target_gdbarch ()) == NULL
 539       || !has_ravenscar_runtime ())
 540     return;
 541
 542   err_msg = ada_get_tcb_types_info ();
 543   if (err_msg != NULL)
 544     {
 545       warning (_("%s. Task/thread support disabled."), err_msg);
 546       return;
 547     }
 548
 549   target_ops_up target_holder (new ravenscar_thread_target ());
 550   push_target (std::move (target_holder));
 551 }
 552
 553 ptid_t
 554 ravenscar_thread_target::get_ada_task_ptid (long lwp, long thread)
 555 {
 556   return ptid_t (m_base_ptid.pid (), 0, thread);
 557 }
 558
 559 /* Command-list for the "set/show ravenscar" prefix command.  */
 560 static struct cmd_list_element *set_ravenscar_list;
 561 static struct cmd_list_element *show_ravenscar_list;
 562
 563 /* Implement the "set ravenscar" prefix command.  */
 564
 565 static void
 566 set_ravenscar_command (const char *arg, int from_tty)
 567 {
 568   printf_unfiltered (_(\
 569 "\"set ravenscar\" must be followed by the name of a setting.\n"));
 570   help_list (set_ravenscar_list, "set ravenscar ", all_commands, gdb_stdout);
 571 }
 572
 573 /* Implement the "show ravenscar" prefix command.  */
 574
 575 static void
 576 show_ravenscar_command (const char *args, int from_tty)
 577 {
 578   cmd_show_list (show_ravenscar_list, from_tty, "");
 579 }
 580
 581 /* Implement the "show ravenscar task-switching" command.  */
 582
 583 static void
 584 show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
 585                                        struct cmd_list_element *c,
 586                                        const char *value)
 587 {
 588   if (ravenscar_task_support)
 589     fprintf_filtered (file, _("\
 590 Support for Ravenscar task/thread switching is enabled\n"));
 591   else
 592     fprintf_filtered (file, _("\
 593 Support for Ravenscar task/thread switching is disabled\n"));
 594 }
 595
 596 /* Module startup initialization function, automagically called by
 597    init.c.  */
 598
 599 void
 600 _initialize_ravenscar ()
 601 {
 602   /* Notice when the inferior is created in order to push the
 603      ravenscar ops if needed.  */
 604   gdb::observers::inferior_created.attach (ravenscar_inferior_created);
 605
 606   add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command,
 607                   _("Prefix command for changing Ravenscar-specific settings"),
 608                   &set_ravenscar_list, "set ravenscar ", 0, &setlist);
 609
 610   add_prefix_cmd ("ravenscar", no_class, show_ravenscar_command,
 611                   _("Prefix command for showing Ravenscar-specific settings"),
 612                   &show_ravenscar_list, "show ravenscar ", 0, &showlist);
 613
 614   add_setshow_boolean_cmd ("task-switching", class_obscure,
 615                            &ravenscar_task_support, _("\
 616 Enable or disable support for GNAT Ravenscar tasks"), _("\
 617 Show whether support for GNAT Ravenscar tasks is enabled"),
 618                            _("\
 619 Enable or disable support for task/thread switching with the GNAT\n\
 620 Ravenscar run-time library for bareboard configuration."),
 621                            NULL, show_ravenscar_task_switching_command,
 622                            &set_ravenscar_list, &show_ravenscar_list);
 623 }