gdb/inf-child.c

   1 /* Base/prototype target for default child (native) targets.
   2
   3    Copyright (C) 1988-2023 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 /* This file provides a common base class/target that all native
  21    target implementations extend, by calling inf_child_target to get a
  22    new prototype target and then overriding target methods as
  23    necessary.  */
  24
  25 #include "defs.h"
  26 #include "regcache.h"
  27 #include "memattr.h"
  28 #include "symtab.h"
  29 #include "target.h"
  30 #include "inferior.h"
  31 #include <sys/stat.h>
  32 #include "inf-child.h"
  33 #include "gdbsupport/fileio.h"
  34 #include "gdbsupport/agent.h"
  35 #include "gdbsupport/gdb_wait.h"
  36 #include "gdbsupport/filestuff.h"
  37
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41
  42 static const target_info inf_child_target_info = {
  43   "native",
  44   N_("Native process"),
  45   N_("Native process (started by the \"run\" command).")
  46 };
  47
  48 const target_info &
  49 inf_child_target::info () const
  50 {
  51   return inf_child_target_info;
  52 }
  53
  54 /* See inf-child.h.  */
  55
  56 target_waitstatus
  57 host_status_to_waitstatus (int hoststatus)
  58 {
  59   if (WIFEXITED (hoststatus))
  60     return target_waitstatus ().set_exited (WEXITSTATUS (hoststatus));
  61   else if (!WIFSTOPPED (hoststatus))
  62     return target_waitstatus ().set_signalled
  63       (gdb_signal_from_host (WTERMSIG (hoststatus)));
  64   else
  65     return target_waitstatus ().set_stopped
  66       (gdb_signal_from_host (WSTOPSIG (hoststatus)));
  67 }
  68
  69 inf_child_target::~inf_child_target ()
  70 {}
  71
  72 void
  73 inf_child_target::post_attach (int pid)
  74 {
  75   /* This target doesn't require a meaningful "post attach" operation
  76      by a debugger.  */
  77 }
  78
  79 /* Get ready to modify the registers array.  On machines which store
  80    individual registers, this doesn't need to do anything.  On
  81    machines which store all the registers in one fell swoop, this
  82    makes sure that registers contains all the registers from the
  83    program being debugged.  */
  84
  85 void
  86 inf_child_target::prepare_to_store (struct regcache *regcache)
  87 {
  88 }
  89
  90 bool
  91 inf_child_target::supports_terminal_ours ()
  92 {
  93   return true;
  94 }
  95
  96 void
  97 inf_child_target::terminal_init ()
  98 {
  99   child_terminal_init (this);
 100 }
 101
 102 void
 103 inf_child_target::terminal_inferior ()
 104 {
 105   child_terminal_inferior (this);
 106 }
 107
 108 void
 109 inf_child_target::terminal_save_inferior ()
 110 {
 111   child_terminal_save_inferior (this);
 112 }
 113
 114 void
 115 inf_child_target::terminal_ours_for_output ()
 116 {
 117   child_terminal_ours_for_output (this);
 118 }
 119
 120 void
 121 inf_child_target::terminal_ours ()
 122 {
 123   child_terminal_ours (this);
 124 }
 125
 126 void
 127 inf_child_target::interrupt ()
 128 {
 129   child_interrupt (this);
 130 }
 131
 132 void
 133 inf_child_target::pass_ctrlc ()
 134 {
 135   child_pass_ctrlc (this);
 136 }
 137
 138 void
 139 inf_child_target::terminal_info (const char *args, int from_tty)
 140 {
 141   child_terminal_info (this, args, from_tty);
 142 }
 143
 144 /* True if the user did "target native".  In that case, we won't
 145    unpush the child target automatically when the last inferior is
 146    gone.  */
 147 static int inf_child_explicitly_opened;
 148
 149 /* See inf-child.h.  */
 150
 151 void
 152 inf_child_open_target (const char *arg, int from_tty)
 153 {
 154   target_ops *target = get_native_target ();
 155
 156   /* There's always only ever one native target, and if we get here,
 157      it better be an inf-child target.  */
 158   gdb_assert (dynamic_cast<inf_child_target *> (target) != NULL);
 159
 160   target_preopen (from_tty);
 161   current_inferior ()->push_target (target);
 162   inf_child_explicitly_opened = 1;
 163   if (from_tty)
 164     gdb_printf ("Done.  Use the \"run\" command to start a process.\n");
 165 }
 166
 167 /* Implement the to_disconnect target_ops method.  */
 168
 169 void
 170 inf_child_target::disconnect (const char *args, int from_tty)
 171 {
 172   if (args != NULL)
 173     error (_("Argument given to \"disconnect\"."));
 174
 175   /* This offers to detach/kill current inferiors, and then pops all
 176      targets.  */
 177   target_preopen (from_tty);
 178 }
 179
 180 /* Implement the to_close target_ops method.  */
 181
 182 void
 183 inf_child_target::close ()
 184 {
 185   /* In case we were forcibly closed.  */
 186   inf_child_explicitly_opened = 0;
 187 }
 188
 189 void
 190 inf_child_target::mourn_inferior ()
 191 {
 192   generic_mourn_inferior ();
 193   maybe_unpush_target ();
 194 }
 195
 196 /* See inf-child.h.  */
 197
 198 void
 199 inf_child_target::maybe_unpush_target ()
 200 {
 201   if (!inf_child_explicitly_opened)
 202     current_inferior ()->unpush_target (this);
 203 }
 204
 205 bool
 206 inf_child_target::can_run ()
 207 {
 208   return true;
 209 }
 210
 211 bool
 212 inf_child_target::can_create_inferior ()
 213 {
 214   return true;
 215 }
 216
 217 bool
 218 inf_child_target::can_attach ()
 219 {
 220   return true;
 221 }
 222
 223 const char *
 224 inf_child_target::pid_to_exec_file (int pid)
 225 {
 226   /* This target doesn't support translation of a process ID to the
 227      filename of the executable file.  */
 228   return NULL;
 229 }
 230
 231 /* Implementation of to_fileio_open.  */
 232
 233 int
 234 inf_child_target::fileio_open (struct inferior *inf, const char *filename,
 235                                int flags, int mode, int warn_if_slow,
 236                                fileio_error *target_errno)
 237 {
 238   int nat_flags;
 239   mode_t nat_mode;
 240   int fd;
 241
 242   if (fileio_to_host_openflags (flags, &nat_flags) == -1
 243       || fileio_to_host_mode (mode, &nat_mode) == -1)
 244     {
 245       *target_errno = FILEIO_EINVAL;
 246       return -1;
 247     }
 248
 249   fd = gdb_open_cloexec (filename, nat_flags, nat_mode).release ();
 250   if (fd == -1)
 251     *target_errno = host_to_fileio_error (errno);
 252
 253   return fd;
 254 }
 255
 256 /* Implementation of to_fileio_pwrite.  */
 257
 258 int
 259 inf_child_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
 260                                  ULONGEST offset, fileio_error *target_errno)
 261 {
 262   int ret;
 263
 264 #ifdef HAVE_PWRITE
 265   ret = pwrite (fd, write_buf, len, (long) offset);
 266 #else
 267   ret = -1;
 268 #endif
 269   /* If we have no pwrite or it failed for this file, use lseek/write.  */
 270   if (ret == -1)
 271     {
 272       ret = lseek (fd, (long) offset, SEEK_SET);
 273       if (ret != -1)
 274         ret = write (fd, write_buf, len);
 275     }
 276
 277   if (ret == -1)
 278     *target_errno = host_to_fileio_error (errno);
 279
 280   return ret;
 281 }
 282
 283 /* Implementation of to_fileio_pread.  */
 284
 285 int
 286 inf_child_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
 287                                 ULONGEST offset, fileio_error *target_errno)
 288 {
 289   int ret;
 290
 291 #ifdef HAVE_PREAD
 292   ret = pread (fd, read_buf, len, (long) offset);
 293 #else
 294   ret = -1;
 295 #endif
 296   /* If we have no pread or it failed for this file, use lseek/read.  */
 297   if (ret == -1)
 298     {
 299       ret = lseek (fd, (long) offset, SEEK_SET);
 300       if (ret != -1)
 301         ret = read (fd, read_buf, len);
 302     }
 303
 304   if (ret == -1)
 305     *target_errno = host_to_fileio_error (errno);
 306
 307   return ret;
 308 }
 309
 310 /* Implementation of to_fileio_fstat.  */
 311
 312 int
 313 inf_child_target::fileio_fstat (int fd, struct stat *sb, fileio_error *target_errno)
 314 {
 315   int ret;
 316
 317   ret = fstat (fd, sb);
 318   if (ret == -1)
 319     *target_errno = host_to_fileio_error (errno);
 320
 321   return ret;
 322 }
 323
 324 /* Implementation of to_fileio_close.  */
 325
 326 int
 327 inf_child_target::fileio_close (int fd, fileio_error *target_errno)
 328 {
 329   int ret;
 330
 331   ret = ::close (fd);
 332   if (ret == -1)
 333     *target_errno = host_to_fileio_error (errno);
 334
 335   return ret;
 336 }
 337
 338 /* Implementation of to_fileio_unlink.  */
 339
 340 int
 341 inf_child_target::fileio_unlink (struct inferior *inf, const char *filename,
 342                                  fileio_error *target_errno)
 343 {
 344   int ret;
 345
 346   ret = unlink (filename);
 347   if (ret == -1)
 348     *target_errno = host_to_fileio_error (errno);
 349
 350   return ret;
 351 }
 352
 353 /* Implementation of to_fileio_readlink.  */
 354
 355 gdb::optional<std::string>
 356 inf_child_target::fileio_readlink (struct inferior *inf, const char *filename,
 357                                    fileio_error *target_errno)
 358 {
 359   /* We support readlink only on systems that also provide a compile-time
 360      maximum path length (PATH_MAX), at least for now.  */
 361 #if defined (PATH_MAX)
 362   char buf[PATH_MAX];
 363   int len;
 364
 365   len = readlink (filename, buf, sizeof buf);
 366   if (len < 0)
 367     {
 368       *target_errno = host_to_fileio_error (errno);
 369       return {};
 370     }
 371
 372   return std::string (buf, len);
 373 #else
 374   *target_errno = FILEIO_ENOSYS;
 375   return {};
 376 #endif
 377 }
 378
 379 bool
 380 inf_child_target::use_agent (bool use)
 381 {
 382   if (agent_loaded_p ())
 383     {
 384       ::use_agent = use;
 385       return true;
 386     }
 387   else
 388     return false;
 389 }
 390
 391 bool
 392 inf_child_target::can_use_agent ()
 393 {
 394   return agent_loaded_p ();
 395 }
 396
 397 void
 398 inf_child_target::follow_exec (inferior *follow_inf, ptid_t ptid,
 399                                const char *execd_pathname)
 400 {
 401   inferior *orig_inf = current_inferior ();
 402
 403   process_stratum_target::follow_exec (follow_inf, ptid, execd_pathname);
 404
 405   if (orig_inf != follow_inf)
 406     {
 407       /* If the target was implicitly push in the original inferior, unpush
 408          it.  */
 409       scoped_restore_current_thread restore_thread;
 410       switch_to_inferior_no_thread (orig_inf);
 411       maybe_unpush_target ();
 412     }
 413 }
 414
 415 /* See inf-child.h.  */
 416
 417 void
 418 add_inf_child_target (inf_child_target *target)
 419 {
 420   set_native_target (target);
 421   add_target (inf_child_target_info, inf_child_open_target);
 422 }