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   ada_build_task_list ();
 378
 379   /* Do not clear the thread list before adding the Ada task, to keep
 380      the thread that the process stratum has included into it
 381      (m_base_ptid) and the running thread, that may not have been included
 382      to system.tasking.debug's list yet.  */
 383
 384   iterate_over_live_ada_tasks (ravenscar_add_thread);
 385 }
 386
 387 ptid_t
 388 ravenscar_thread_target::active_task (int cpu)
 389 {
 390   CORE_ADDR tid = get_running_thread_id (cpu);
 391
 392   if (tid == 0)
 393     return null_ptid;
 394   else
 395     return ptid_t (m_base_ptid.pid (), 0, tid);
 396 }
 397
 398 const char *
 399 ravenscar_thread_target::extra_thread_info (thread_info *tp)
 400 {
 401   return "Ravenscar task";
 402 }
 403
 404 bool
 405 ravenscar_thread_target::thread_alive (ptid_t ptid)
 406 {
 407   /* Ravenscar tasks are non-terminating.  */
 408   return true;
 409 }
 410
 411 const char *
 412 ravenscar_thread_target::pid_to_str (ptid_t ptid)
 413 {
 414   static char buf[30];
 415
 416   snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid.tid ());
 417   return buf;
 418 }
 419
 420 void
 421 ravenscar_thread_target::fetch_registers (struct regcache *regcache, int regnum)
 422 {
 423   ptid_t ptid = regcache->ptid ();
 424
 425   if (runtime_initialized ()
 426       && is_ravenscar_task (ptid)
 427       && !task_is_currently_active (ptid))
 428     {
 429       struct gdbarch *gdbarch = regcache->arch ();
 430       struct ravenscar_arch_ops *arch_ops
 431         = gdbarch_ravenscar_ops (gdbarch);
 432
 433       arch_ops->fetch_registers (regcache, regnum);
 434     }
 435   else
 436     beneath ()->fetch_registers (regcache, regnum);
 437 }
 438
 439 void
 440 ravenscar_thread_target::store_registers (struct regcache *regcache,
 441                                           int regnum)
 442 {
 443   ptid_t ptid = regcache->ptid ();
 444
 445   if (runtime_initialized ()
 446       && is_ravenscar_task (ptid)
 447       && !task_is_currently_active (ptid))
 448     {
 449       struct gdbarch *gdbarch = regcache->arch ();
 450       struct ravenscar_arch_ops *arch_ops
 451         = gdbarch_ravenscar_ops (gdbarch);
 452
 453       arch_ops->store_registers (regcache, regnum);
 454     }
 455   else
 456     beneath ()->store_registers (regcache, regnum);
 457 }
 458
 459 void
 460 ravenscar_thread_target::prepare_to_store (struct regcache *regcache)
 461 {
 462   ptid_t ptid = regcache->ptid ();
 463
 464   if (runtime_initialized ()
 465       && is_ravenscar_task (ptid)
 466       && !task_is_currently_active (ptid))
 467     {
 468       /* Nothing.  */
 469     }
 470   else
 471     beneath ()->prepare_to_store (regcache);
 472 }
 473
 474 /* Implement the to_stopped_by_sw_breakpoint target_ops "method".  */
 475
 476 bool
 477 ravenscar_thread_target::stopped_by_sw_breakpoint ()
 478 {
 479   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 480   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 481   return beneath ()->stopped_by_sw_breakpoint ();
 482 }
 483
 484 /* Implement the to_stopped_by_hw_breakpoint target_ops "method".  */
 485
 486 bool
 487 ravenscar_thread_target::stopped_by_hw_breakpoint ()
 488 {
 489   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 490   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 491   return beneath ()->stopped_by_hw_breakpoint ();
 492 }
 493
 494 /* Implement the to_stopped_by_watchpoint target_ops "method".  */
 495
 496 bool
 497 ravenscar_thread_target::stopped_by_watchpoint ()
 498 {
 499   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 500   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 501   return beneath ()->stopped_by_watchpoint ();
 502 }
 503
 504 /* Implement the to_stopped_data_address target_ops "method".  */
 505
 506 bool
 507 ravenscar_thread_target::stopped_data_address (CORE_ADDR *addr_p)
 508 {
 509   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 510   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 511   return beneath ()->stopped_data_address (addr_p);
 512 }
 513
 514 void
 515 ravenscar_thread_target::mourn_inferior ()
 516 {
 517   m_base_ptid = null_ptid;
 518   beneath ()->mourn_inferior ();
 519   unpush_target (this);
 520 }
 521
 522 /* Implement the to_core_of_thread target_ops "method".  */
 523
 524 int
 525 ravenscar_thread_target::core_of_thread (ptid_t ptid)
 526 {
 527   scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
 528   inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
 529   return beneath ()->core_of_thread (inferior_ptid);
 530 }
 531
 532 /* Observer on inferior_created: push ravenscar thread stratum if needed.  */
 533
 534 static void
 535 ravenscar_inferior_created (struct target_ops *target, int from_tty)
 536 {
 537   const char *err_msg;
 538
 539   if (!ravenscar_task_support
 540       || gdbarch_ravenscar_ops (target_gdbarch ()) == NULL
 541       || !has_ravenscar_runtime ())
 542     return;
 543
 544   err_msg = ada_get_tcb_types_info ();
 545   if (err_msg != NULL)
 546     {
 547       warning (_("%s. Task/thread support disabled."), err_msg);
 548       return;
 549     }
 550
 551   target_ops_up target_holder (new ravenscar_thread_target ());
 552   push_target (std::move (target_holder));
 553 }
 554
 555 ptid_t
 556 ravenscar_thread_target::get_ada_task_ptid (long lwp, long thread)
 557 {
 558   return ptid_t (m_base_ptid.pid (), 0, thread);
 559 }
 560
 561 /* Command-list for the "set/show ravenscar" prefix command.  */
 562 static struct cmd_list_element *set_ravenscar_list;
 563 static struct cmd_list_element *show_ravenscar_list;
 564
 565 /* Implement the "set ravenscar" prefix command.  */
 566
 567 static void
 568 set_ravenscar_command (const char *arg, int from_tty)
 569 {
 570   printf_unfiltered (_(\
 571 "\"set ravenscar\" must be followed by the name of a setting.\n"));
 572   help_list (set_ravenscar_list, "set ravenscar ", all_commands, gdb_stdout);
 573 }
 574
 575 /* Implement the "show ravenscar" prefix command.  */
 576
 577 static void
 578 show_ravenscar_command (const char *args, int from_tty)
 579 {
 580   cmd_show_list (show_ravenscar_list, from_tty, "");
 581 }
 582
 583 /* Implement the "show ravenscar task-switching" command.  */
 584
 585 static void
 586 show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
 587                                        struct cmd_list_element *c,
 588                                        const char *value)
 589 {
 590   if (ravenscar_task_support)
 591     fprintf_filtered (file, _("\
 592 Support for Ravenscar task/thread switching is enabled\n"));
 593   else
 594     fprintf_filtered (file, _("\
 595 Support for Ravenscar task/thread switching is disabled\n"));
 596 }
 597
 598 /* Module startup initialization function, automagically called by
 599    init.c.  */
 600
 601 void
 602 _initialize_ravenscar ()
 603 {
 604   /* Notice when the inferior is created in order to push the
 605      ravenscar ops if needed.  */
 606   gdb::observers::inferior_created.attach (ravenscar_inferior_created);
 607
 608   add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command,
 609                   _("Prefix command for changing Ravenscar-specific settings"),
 610                   &set_ravenscar_list, "set ravenscar ", 0, &setlist);
 611
 612   add_prefix_cmd ("ravenscar", no_class, show_ravenscar_command,
 613                   _("Prefix command for showing Ravenscar-specific settings"),
 614                   &show_ravenscar_list, "show ravenscar ", 0, &showlist);
 615
 616   add_setshow_boolean_cmd ("task-switching", class_obscure,
 617                            &ravenscar_task_support, _("\
 618 Enable or disable support for GNAT Ravenscar tasks"), _("\
 619 Show whether support for GNAT Ravenscar tasks is enabled"),
 620                            _("\
 621 Enable or disable support for task/thread switching with the GNAT\n\
 622 Ravenscar run-time library for bareboard configuration."),
 623                            NULL, show_ravenscar_task_switching_command,
 624                            &set_ravenscar_list, &show_ravenscar_list);
 625 }