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