gdb/process-stratum-target.c

   1 /* Abstract base class inherited by all process_stratum targets
   2
   3    Copyright (C) 2018-2024 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 "process-stratum-target.h"
  22 #include "inferior.h"
  23 #include <algorithm>
  24
  25 process_stratum_target::~process_stratum_target ()
  26 {
  27 }
  28
  29 struct gdbarch *
  30 process_stratum_target::thread_architecture (ptid_t ptid)
  31 {
  32   inferior *inf = find_inferior_ptid (this, ptid);
  33   gdb_assert (inf != NULL);
  34   return inf->arch ();
  35 }
  36
  37 bool
  38 process_stratum_target::has_all_memory ()
  39 {
  40   /* If no inferior selected, then we can't read memory here.  */
  41   return inferior_ptid != null_ptid;
  42 }
  43
  44 bool
  45 process_stratum_target::has_memory ()
  46 {
  47   /* If no inferior selected, then we can't read memory here.  */
  48   return inferior_ptid != null_ptid;
  49 }
  50
  51 bool
  52 process_stratum_target::has_stack ()
  53 {
  54   /* If no inferior selected, there's no stack.  */
  55   return inferior_ptid != null_ptid;
  56 }
  57
  58 bool
  59 process_stratum_target::has_registers ()
  60 {
  61   /* Can't read registers from no inferior.  */
  62   return inferior_ptid != null_ptid;
  63 }
  64
  65 bool
  66 process_stratum_target::has_execution (inferior *inf)
  67 {
  68   /* If there's a process running already, we can't make it run
  69      through hoops.  */
  70   return inf->pid != 0;
  71 }
  72
  73 /* See process-stratum-target.h.  */
  74
  75 void
  76 process_stratum_target::follow_exec (inferior *follow_inf, ptid_t ptid,
  77                                      const char *execd_pathname)
  78 {
  79   inferior *orig_inf = current_inferior ();
  80
  81   if (orig_inf != follow_inf)
  82     {
  83       /* Execution continues in a new inferior, push the original inferior's
  84          process target on the new inferior's target stack.  The process target
  85          may decide to unpush itself from the original inferior's target stack
  86          after that, at its discretion.  */
  87       follow_inf->push_target (orig_inf->process_target ());
  88       thread_info *t = add_thread (follow_inf->process_target (), ptid);
  89
  90       /* Leave the new inferior / thread as the current inferior / thread.  */
  91       switch_to_thread (t);
  92     }
  93 }
  94
  95 /* See process-stratum-target.h.  */
  96
  97 void
  98 process_stratum_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
  99                                      target_waitkind fork_kind,
 100                                      bool follow_child,
 101                                      bool detach_on_fork)
 102 {
 103   if (child_inf != nullptr)
 104     {
 105       child_inf->push_target (this);
 106       add_thread_silent (this, child_ptid);
 107     }
 108 }
 109
 110 /* See process-stratum-target.h.  */
 111
 112 void
 113 process_stratum_target::maybe_add_resumed_with_pending_wait_status
 114   (thread_info *thread)
 115 {
 116   gdb_assert (!thread->resumed_with_pending_wait_status_node.is_linked ());
 117
 118   if (thread->resumed () && thread->has_pending_waitstatus ())
 119     {
 120       infrun_debug_printf ("adding to resumed threads with event list: %s",
 121                            thread->ptid.to_string ().c_str ());
 122       m_resumed_with_pending_wait_status.push_back (*thread);
 123     }
 124 }
 125
 126 /* See process-stratum-target.h.  */
 127
 128 void
 129 process_stratum_target::maybe_remove_resumed_with_pending_wait_status
 130   (thread_info *thread)
 131 {
 132   if (thread->resumed () && thread->has_pending_waitstatus ())
 133     {
 134       infrun_debug_printf ("removing from resumed threads with event list: %s",
 135                            thread->ptid.to_string ().c_str ());
 136       gdb_assert (thread->resumed_with_pending_wait_status_node.is_linked ());
 137       auto it = m_resumed_with_pending_wait_status.iterator_to (*thread);
 138       m_resumed_with_pending_wait_status.erase (it);
 139     }
 140   else
 141     gdb_assert (!thread->resumed_with_pending_wait_status_node.is_linked ());
 142 }
 143
 144 /* See process-stratum-target.h.  */
 145
 146 thread_info *
 147 process_stratum_target::random_resumed_with_pending_wait_status
 148   (inferior *inf, ptid_t filter_ptid)
 149 {
 150   auto matches = [inf, filter_ptid] (const thread_info &thread)
 151     {
 152       return thread.inf == inf && thread.ptid.matches (filter_ptid);
 153     };
 154
 155   /* First see how many matching events we have.  */
 156   const auto &l = m_resumed_with_pending_wait_status;
 157   unsigned int count = std::count_if (l.begin (), l.end (), matches);
 158
 159   if (count == 0)
 160     return nullptr;
 161
 162   /* Now randomly pick a thread out of those that match the criteria.  */
 163   int random_selector
 164     = (int) ((count * (double) rand ()) / (RAND_MAX + 1.0));
 165
 166   if (count > 1)
 167     infrun_debug_printf ("Found %u events, selecting #%d",
 168                          count, random_selector);
 169
 170   /* Select the Nth thread that matches.  */
 171   auto it = std::find_if (l.begin (), l.end (),
 172                           [&random_selector, &matches]
 173                           (const thread_info &thread)
 174     {
 175       if (!matches (thread))
 176         return false;
 177
 178       return random_selector-- == 0;
 179     });
 180
 181   gdb_assert (it != l.end ());
 182
 183   return &*it;
 184 }
 185
 186 /* See process-stratum-target.h.  */
 187
 188 thread_info *
 189 process_stratum_target::find_thread (ptid_t ptid)
 190 {
 191   inferior *inf = find_inferior_ptid (this, ptid);
 192   if (inf == NULL)
 193     return NULL;
 194   return inf->find_thread (ptid);
 195 }
 196
 197 /* See process-stratum-target.h.  */
 198
 199 std::set<process_stratum_target *>
 200 all_non_exited_process_targets ()
 201 {
 202   /* Inferiors may share targets.  To eliminate duplicates, use a set.  */
 203   std::set<process_stratum_target *> targets;
 204   for (inferior *inf : all_non_exited_inferiors ())
 205     targets.insert (inf->process_target ());
 206
 207   return targets;
 208 }
 209
 210 /* See process-stratum-target.h.  */
 211
 212 void
 213 switch_to_target_no_thread (process_stratum_target *target)
 214 {
 215   for (inferior *inf : all_inferiors (target))
 216     {
 217       switch_to_inferior_no_thread (inf);
 218       break;
 219     }
 220 }