gdb/inf-child.c

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