gdb/break-catch-fork.c

   1 /* Everything about vfork catchpoints, for GDB.
   2
   3    Copyright (C) 1986-2022 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
  22 #include "annotate.h"
  23 #include "arch-utils.h"
  24 #include "breakpoint.h"
  25 #include "cli/cli-decode.h"
  26 #include "inferior.h"
  27 #include "mi/mi-common.h"
  28 #include "target.h"
  29 #include "valprint.h"
  30
  31 /* An instance of this type is used to represent a fork or vfork
  32    catchpoint.  A breakpoint is really of this type iff its ops pointer points
  33    to CATCH_FORK_BREAKPOINT_OPS.  */
  34
  35 struct fork_catchpoint : public catchpoint
  36 {
  37   fork_catchpoint (struct gdbarch *gdbarch, bool temp,
  38                    const char *cond_string, bool is_vfork_)
  39     : catchpoint (gdbarch, temp, cond_string),
  40       is_vfork (is_vfork_)
  41   {
  42   }
  43
  44   int insert_location (struct bp_location *) override;
  45   int remove_location (struct bp_location *,
  46                        enum remove_bp_reason reason) override;
  47   int breakpoint_hit (const struct bp_location *bl,
  48                       const address_space *aspace,
  49                       CORE_ADDR bp_addr,
  50                       const target_waitstatus &ws) override;
  51   enum print_stop_action print_it (const bpstat *bs) const override;
  52   bool print_one (bp_location **) const override;
  53   void print_mention () const override;
  54   void print_recreate (struct ui_file *fp) const override;
  55
  56   /* True if the breakpoint is for vfork, false for fork.  */
  57   bool is_vfork;
  58
  59   /* Process id of a child process whose forking triggered this
  60      catchpoint.  This field is only valid immediately after this
  61      catchpoint has triggered.  */
  62   ptid_t forked_inferior_pid = null_ptid;
  63 };
  64
  65 /* Implement the "insert" method for fork catchpoints.  */
  66
  67 int
  68 fork_catchpoint::insert_location (struct bp_location *bl)
  69 {
  70   if (is_vfork)
  71     return target_insert_vfork_catchpoint (inferior_ptid.pid ());
  72   else
  73     return target_insert_fork_catchpoint (inferior_ptid.pid ());
  74 }
  75
  76 /* Implement the "remove" method for fork catchpoints.  */
  77
  78 int
  79 fork_catchpoint::remove_location (struct bp_location *bl,
  80                                   enum remove_bp_reason reason)
  81 {
  82   if (is_vfork)
  83     return target_remove_vfork_catchpoint (inferior_ptid.pid ());
  84   else
  85     return target_remove_fork_catchpoint (inferior_ptid.pid ());
  86 }
  87
  88 /* Implement the "breakpoint_hit" method for fork catchpoints.  */
  89
  90 int
  91 fork_catchpoint::breakpoint_hit (const struct bp_location *bl,
  92                                  const address_space *aspace,
  93                                  CORE_ADDR bp_addr,
  94                                  const target_waitstatus &ws)
  95 {
  96   if (ws.kind () != (is_vfork
  97                      ? TARGET_WAITKIND_VFORKED
  98                      : TARGET_WAITKIND_FORKED))
  99     return 0;
 100
 101   forked_inferior_pid = ws.child_ptid ();
 102   return 1;
 103 }
 104
 105 /* Implement the "print_it" method for fork catchpoints.  */
 106
 107 enum print_stop_action
 108 fork_catchpoint::print_it (const bpstat *bs) const
 109 {
 110   struct ui_out *uiout = current_uiout;
 111
 112   annotate_catchpoint (number);
 113   maybe_print_thread_hit_breakpoint (uiout);
 114   if (disposition == disp_del)
 115     uiout->text ("Temporary catchpoint ");
 116   else
 117     uiout->text ("Catchpoint ");
 118   if (uiout->is_mi_like_p ())
 119     {
 120       uiout->field_string ("reason",
 121                            async_reason_lookup (is_vfork
 122                                                 ? EXEC_ASYNC_VFORK
 123                                                 : EXEC_ASYNC_FORK));
 124       uiout->field_string ("disp", bpdisp_text (disposition));
 125     }
 126   uiout->field_signed ("bkptno", number);
 127   if (is_vfork)
 128     uiout->text (" (vforked process ");
 129   else
 130     uiout->text (" (forked process ");
 131   uiout->field_signed ("newpid", forked_inferior_pid.pid ());
 132   uiout->text ("), ");
 133   return PRINT_SRC_AND_LOC;
 134 }
 135
 136 /* Implement the "print_one" method for fork catchpoints.  */
 137
 138 bool
 139 fork_catchpoint::print_one (bp_location **last_loc) const
 140 {
 141   struct value_print_options opts;
 142   struct ui_out *uiout = current_uiout;
 143
 144   get_user_print_options (&opts);
 145
 146   /* Field 4, the address, is omitted (which makes the columns not
 147      line up too nicely with the headers, but the effect is relatively
 148      readable).  */
 149   if (opts.addressprint)
 150     uiout->field_skip ("addr");
 151   annotate_field (5);
 152   const char *name = is_vfork ? "vfork" : "fork";
 153   uiout->text (name);
 154   if (forked_inferior_pid != null_ptid)
 155     {
 156       uiout->text (", process ");
 157       uiout->field_signed ("what", forked_inferior_pid.pid ());
 158       uiout->spaces (1);
 159     }
 160
 161   if (uiout->is_mi_like_p ())
 162     uiout->field_string ("catch-type", name);
 163
 164   return true;
 165 }
 166
 167 /* Implement the "print_mention" method for fork catchpoints.  */
 168
 169 void
 170 fork_catchpoint::print_mention () const
 171 {
 172   gdb_printf (_("Catchpoint %d (%s)"), number,
 173               is_vfork ? "vfork" : "fork");
 174 }
 175
 176 /* Implement the "print_recreate" method for fork catchpoints.  */
 177
 178 void
 179 fork_catchpoint::print_recreate (struct ui_file *fp) const
 180 {
 181   gdb_printf (fp, "catch %s", is_vfork ? "vfork" : "fork");
 182   print_recreate_thread (fp);
 183 }
 184
 185 static void
 186 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
 187                                     bool temp, const char *cond_string,
 188                                     bool is_vfork)
 189 {
 190   std::unique_ptr<fork_catchpoint> c
 191     (new fork_catchpoint (gdbarch, temp, cond_string, is_vfork));
 192
 193   install_breakpoint (0, std::move (c), 1);
 194 }
 195
 196 enum catch_fork_kind
 197 {
 198   catch_fork_temporary, catch_vfork_temporary,
 199   catch_fork_permanent, catch_vfork_permanent
 200 };
 201
 202 static void
 203 catch_fork_command_1 (const char *arg, int from_tty,
 204                       struct cmd_list_element *command)
 205 {
 206   struct gdbarch *gdbarch = get_current_arch ();
 207   const char *cond_string = NULL;
 208   catch_fork_kind fork_kind;
 209
 210   fork_kind = (catch_fork_kind) (uintptr_t) command->context ();
 211   bool temp = (fork_kind == catch_fork_temporary
 212                || fork_kind == catch_vfork_temporary);
 213
 214   if (!arg)
 215     arg = "";
 216   arg = skip_spaces (arg);
 217
 218   /* The allowed syntax is:
 219      catch [v]fork
 220      catch [v]fork if <cond>
 221
 222      First, check if there's an if clause.  */
 223   cond_string = ep_parse_optional_if_clause (&arg);
 224
 225   if ((*arg != '\0') && !isspace (*arg))
 226     error (_("Junk at end of arguments."));
 227
 228   /* If this target supports it, create a fork or vfork catchpoint
 229      and enable reporting of such events.  */
 230   switch (fork_kind)
 231     {
 232     case catch_fork_temporary:
 233     case catch_fork_permanent:
 234       create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, false);
 235       break;
 236     case catch_vfork_temporary:
 237     case catch_vfork_permanent:
 238       create_fork_vfork_event_catchpoint (gdbarch, temp, cond_string, true);
 239       break;
 240     default:
 241       error (_("unsupported or unknown fork kind; cannot catch it"));
 242       break;
 243     }
 244 }
 245
 246 void _initialize_break_catch_fork ();
 247 void
 248 _initialize_break_catch_fork ()
 249 {
 250   add_catch_command ("fork", _("Catch calls to fork."),
 251                      catch_fork_command_1,
 252                      NULL,
 253                      (void *) (uintptr_t) catch_fork_permanent,
 254                      (void *) (uintptr_t) catch_fork_temporary);
 255   add_catch_command ("vfork", _("Catch calls to vfork."),
 256                      catch_fork_command_1,
 257                      NULL,
 258                      (void *) (uintptr_t) catch_vfork_permanent,
 259                      (void *) (uintptr_t) catch_vfork_temporary);
 260 }